Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jwessel/linux-2.6-kgdb (9993b364) · Commits · 戴 / test

arch/blackfin/kernel/kgdb.c

+1 −206

Original line number	Original line	Diff line number	Diff line
	@@ -6,23 +6,9 @@
	* Licensed under the GPL-2 or later.		* Licensed under the GPL-2 or later.
	*/		*/

	#include <linux/string.h>
	#include <linux/kernel.h>
	#include <linux/sched.h>
	#include <linux/smp.h>
	#include <linux/spinlock.h>
	#include <linux/delay.h>
	#include <linux/ptrace.h> /* for linux pt_regs struct */		#include <linux/ptrace.h> /* for linux pt_regs struct */
	#include <linux/kgdb.h>		#include <linux/kgdb.h>
	#include <linux/console.h>
	#include <linux/init.h>
	#include <linux/errno.h>
	#include <linux/irq.h>
	#include <linux/uaccess.h>		#include <linux/uaccess.h>
	#include <asm/system.h>
	#include <asm/traps.h>
	#include <asm/blackfin.h>
	#include <asm/dma.h>

	void pt_regs_to_gdb_regs(unsigned long gdb_regs, struct pt_regs regs)		void pt_regs_to_gdb_regs(unsigned long gdb_regs, struct pt_regs regs)
	{		{
	@@ -147,7 +133,7 @@ void gdb_regs_to_pt_regs(unsigned long gdb_regs, struct pt_regs regs)
	regs->lb1 = gdb_regs[BFIN_LB1];		regs->lb1 = gdb_regs[BFIN_LB1];
	regs->usp = gdb_regs[BFIN_USP];		regs->usp = gdb_regs[BFIN_USP];
	regs->syscfg = gdb_regs[BFIN_SYSCFG];		regs->syscfg = gdb_regs[BFIN_SYSCFG];
	regs->retx = gdb_regs[BFIN_PC];		regs->retx = gdb_regs[BFIN_RETX];
	regs->retn = gdb_regs[BFIN_RETN];		regs->retn = gdb_regs[BFIN_RETN];
	regs->rete = gdb_regs[BFIN_RETE];		regs->rete = gdb_regs[BFIN_RETE];
	regs->pc = gdb_regs[BFIN_PC];		regs->pc = gdb_regs[BFIN_PC];
	@@ -424,182 +410,6 @@ struct kgdb_arch arch_kgdb_ops = {
	.correct_hw_break = bfin_correct_hw_break,		.correct_hw_break = bfin_correct_hw_break,
	};		};

	static int hex(char ch)
	{
	if ((ch >= 'a') && (ch <= 'f'))
	return ch - 'a' + 10;
	if ((ch >= '0') && (ch <= '9'))
	return ch - '0';
	if ((ch >= 'A') && (ch <= 'F'))
	return ch - 'A' + 10;
	return -1;
	}

	static int validate_memory_access_address(unsigned long addr, int size)
	{
	if (size < 0 \|\| addr == 0)
	return -EFAULT;
	return bfin_mem_access_type(addr, size);
	}

	static int bfin_probe_kernel_read(char dst, char src, int size)
	{
	unsigned long lsrc = (unsigned long)src;
	int mem_type;

	mem_type = validate_memory_access_address(lsrc, size);
	if (mem_type < 0)
	return mem_type;

	if (lsrc >= SYSMMR_BASE) {
	if (size == 2 && lsrc % 2 == 0) {
	u16 mmr = bfin_read16(src);
	memcpy(dst, &mmr, sizeof(mmr));
	return 0;
	} else if (size == 4 && lsrc % 4 == 0) {
	u32 mmr = bfin_read32(src);
	memcpy(dst, &mmr, sizeof(mmr));
	return 0;
	}
	} else {
	switch (mem_type) {
	case BFIN_MEM_ACCESS_CORE:
	case BFIN_MEM_ACCESS_CORE_ONLY:
	return probe_kernel_read(dst, src, size);
	/* XXX: should support IDMA here with SMP */
	case BFIN_MEM_ACCESS_DMA:
	if (dma_memcpy(dst, src, size))
	return 0;
	break;
	case BFIN_MEM_ACCESS_ITEST:
	if (isram_memcpy(dst, src, size))
	return 0;
	break;
	}
	}

	return -EFAULT;
	}

	static int bfin_probe_kernel_write(char dst, char src, int size)
	{
	unsigned long ldst = (unsigned long)dst;
	int mem_type;

	mem_type = validate_memory_access_address(ldst, size);
	if (mem_type < 0)
	return mem_type;

	if (ldst >= SYSMMR_BASE) {
	if (size == 2 && ldst % 2 == 0) {
	u16 mmr;
	memcpy(&mmr, src, sizeof(mmr));
	bfin_write16(dst, mmr);
	return 0;
	} else if (size == 4 && ldst % 4 == 0) {
	u32 mmr;
	memcpy(&mmr, src, sizeof(mmr));
	bfin_write32(dst, mmr);
	return 0;
	}
	} else {
	switch (mem_type) {
	case BFIN_MEM_ACCESS_CORE:
	case BFIN_MEM_ACCESS_CORE_ONLY:
	return probe_kernel_write(dst, src, size);
	/* XXX: should support IDMA here with SMP */
	case BFIN_MEM_ACCESS_DMA:
	if (dma_memcpy(dst, src, size))
	return 0;
	break;
	case BFIN_MEM_ACCESS_ITEST:
	if (isram_memcpy(dst, src, size))
	return 0;
	break;
	}
	}

	return -EFAULT;
	}

	/*
	* Convert the memory pointed to by mem into hex, placing result in buf.
	* Return a pointer to the last char put in buf (null). May return an error.
	*/
	int kgdb_mem2hex(char mem, char buf, int count)
	{
	char *tmp;
	int err;

	/*
	* We use the upper half of buf as an intermediate buffer for the
	* raw memory copy. Hex conversion will work against this one.
	*/
	tmp = buf + count;

	err = bfin_probe_kernel_read(tmp, mem, count);
	if (!err) {
	while (count > 0) {
	buf = pack_hex_byte(buf, *tmp);
	tmp++;
	count--;
	}

	*buf = 0;
	}

	return err;
	}

	/*
	* Copy the binary array pointed to by buf into mem. Fix $, #, and
	* 0x7d escaped with 0x7d. Return a pointer to the character after
	* the last byte written.
	*/
	int kgdb_ebin2mem(char buf, char mem, int count)
	{
	char tmp_old, tmp_new;
	int size;

	tmp_old = tmp_new = buf;

	for (size = 0; size < count; ++size) {
	if (*tmp_old == 0x7d)
	tmp_new = (++tmp_old) ^ 0x20;
	else
	tmp_new = tmp_old;
	tmp_new++;
	tmp_old++;
	}

	return bfin_probe_kernel_write(mem, buf, count);
	}

	/*
	* Convert the hex array pointed to by buf into binary to be placed in mem.
	* Return a pointer to the character AFTER the last byte written.
	* May return an error.
	*/
	int kgdb_hex2mem(char buf, char mem, int count)
	{
	char tmp_raw, tmp_hex;

	/*
	* We use the upper half of buf as an intermediate buffer for the
	* raw memory that is converted from hex.
	*/
	tmp_raw = buf + count * 2;

	tmp_hex = tmp_raw - 1;
	while (tmp_hex >= buf) {
	tmp_raw--;
	tmp_raw = hex(tmp_hex--);
	tmp_raw \|= hex(tmp_hex--) << 4;
	}

	return bfin_probe_kernel_write(mem, tmp_raw, count);
	}

	#define IN_MEM(addr, size, l1_addr, l1_size) \		#define IN_MEM(addr, size, l1_addr, l1_size) \
	({ \		({ \
	unsigned long __addr = (unsigned long)(addr); \		unsigned long __addr = (unsigned long)(addr); \
	@@ -629,21 +439,6 @@ int kgdb_validate_break_address(unsigned long addr)
	return -EFAULT;		return -EFAULT;
	}		}

	int kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr)
	{
	int err = bfin_probe_kernel_read(saved_instr, (char *)addr,
	BREAK_INSTR_SIZE);
	if (err)
	return err;
	return bfin_probe_kernel_write((char *)addr, arch_kgdb_ops.gdb_bpt_instr,
	BREAK_INSTR_SIZE);
	}

	int kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle)
	{
	return bfin_probe_kernel_write((char *)addr, bundle, BREAK_INSTR_SIZE);
	}

	int kgdb_arch_init(void)		int kgdb_arch_init(void)
	{		{
	kgdb_single_step = 0;		kgdb_single_step = 0;

arch/blackfin/mm/Makefile

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -2,4 +2,4 @@
	# arch/blackfin/mm/Makefile		# arch/blackfin/mm/Makefile
	#		#

	obj-y := sram-alloc.o isram-driver.o init.o		obj-y := sram-alloc.o isram-driver.o init.o maccess.o

arch/blackfin/mm/maccess.c

0 → 100644

+97 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* safe read and write memory routines callable while atomic
			*
			* Copyright 2005-2008 Analog Devices Inc.
			*
			* Licensed under the GPL-2 or later.
			*/

			#include <linux/uaccess.h>
			#include <asm/dma.h>

			static int validate_memory_access_address(unsigned long addr, int size)
			{
			if (size < 0 \|\| addr == 0)
			return -EFAULT;
			return bfin_mem_access_type(addr, size);
			}

			long probe_kernel_read(void dst, void src, size_t size)
			{
			unsigned long lsrc = (unsigned long)src;
			int mem_type;

			mem_type = validate_memory_access_address(lsrc, size);
			if (mem_type < 0)
			return mem_type;

			if (lsrc >= SYSMMR_BASE) {
			if (size == 2 && lsrc % 2 == 0) {
			u16 mmr = bfin_read16(src);
			memcpy(dst, &mmr, sizeof(mmr));
			return 0;
			} else if (size == 4 && lsrc % 4 == 0) {
			u32 mmr = bfin_read32(src);
			memcpy(dst, &mmr, sizeof(mmr));
			return 0;
			}
			} else {
			switch (mem_type) {
			case BFIN_MEM_ACCESS_CORE:
			case BFIN_MEM_ACCESS_CORE_ONLY:
			return __probe_kernel_read(dst, src, size);
			/* XXX: should support IDMA here with SMP */
			case BFIN_MEM_ACCESS_DMA:
			if (dma_memcpy(dst, src, size))
			return 0;
			break;
			case BFIN_MEM_ACCESS_ITEST:
			if (isram_memcpy(dst, src, size))
			return 0;
			break;
			}
			}

			return -EFAULT;
			}

			long probe_kernel_write(void dst, void src, size_t size)
			{
			unsigned long ldst = (unsigned long)dst;
			int mem_type;

			mem_type = validate_memory_access_address(ldst, size);
			if (mem_type < 0)
			return mem_type;

			if (ldst >= SYSMMR_BASE) {
			if (size == 2 && ldst % 2 == 0) {
			u16 mmr;
			memcpy(&mmr, src, sizeof(mmr));
			bfin_write16(dst, mmr);
			return 0;
			} else if (size == 4 && ldst % 4 == 0) {
			u32 mmr;
			memcpy(&mmr, src, sizeof(mmr));
			bfin_write32(dst, mmr);
			return 0;
			}
			} else {
			switch (mem_type) {
			case BFIN_MEM_ACCESS_CORE:
			case BFIN_MEM_ACCESS_CORE_ONLY:
			return __probe_kernel_write(dst, src, size);
			/* XXX: should support IDMA here with SMP */
			case BFIN_MEM_ACCESS_DMA:
			if (dma_memcpy(dst, src, size))
			return 0;
			break;
			case BFIN_MEM_ACCESS_ITEST:
			if (isram_memcpy(dst, src, size))
			return 0;
			break;
			}
			}

			return -EFAULT;
			}

include/linux/kgdb.h

+3 −4

include/linux/uaccess.h

+3 −1

Original line number	Original line	Diff line number	Diff line
	@@ -94,6 +94,7 @@ static inline unsigned long __copy_from_user_nocache(void *to,
	* happens, handle that and return -EFAULT.		* happens, handle that and return -EFAULT.
	*/		*/
	extern long probe_kernel_read(void dst, void src, size_t size);		extern long probe_kernel_read(void dst, void src, size_t size);
			extern long __probe_kernel_read(void dst, void src, size_t size);

	/*		/*
	* probe_kernel_write(): safely attempt to write to a location		* probe_kernel_write(): safely attempt to write to a location
	@@ -104,6 +105,7 @@ extern long probe_kernel_read(void dst, void src, size_t size);
	* Safely write to address @dst from the buffer at @src. If a kernel fault		* Safely write to address @dst from the buffer at @src. If a kernel fault
	* happens, handle that and return -EFAULT.		* happens, handle that and return -EFAULT.
	*/		*/
	extern long probe_kernel_write(void dst, void src, size_t size);		extern long notrace probe_kernel_write(void dst, void src, size_t size);
			extern long notrace __probe_kernel_write(void dst, void src, size_t size);

	#endif /* __LINUX_UACCESS_H__ */		#endif /* __LINUX_UACCESS_H__ */

Original line number	Original line	Diff line number	Diff line
	@@ -29,8 +29,7 @@ struct pt_regs;
	*		*
	* On some architectures it is required to skip a breakpoint		* On some architectures it is required to skip a breakpoint
	* exception when it occurs after a breakpoint has been removed.		* exception when it occurs after a breakpoint has been removed.
	* This can be implemented in the architecture specific portion of		* This can be implemented in the architecture specific portion of kgdb.
	* for kgdb.
	*/		*/
	extern int kgdb_skipexception(int exception, struct pt_regs *regs);		extern int kgdb_skipexception(int exception, struct pt_regs *regs);

	@@ -65,7 +64,7 @@ struct uart_port;
	/**		/**
	* kgdb_breakpoint - compiled in breakpoint		* kgdb_breakpoint - compiled in breakpoint
	*		*
	* This will be impelmented a static inline per architecture. This		* This will be implemented as a static inline per architecture. This
	* function is called by the kgdb core to execute an architecture		* function is called by the kgdb core to execute an architecture
	* specific trap to cause kgdb to enter the exception processing.		* specific trap to cause kgdb to enter the exception processing.
	*		*
	@@ -190,7 +189,7 @@ kgdb_arch_handle_exception(int vector, int signo, int err_code,
	* @flags: Current IRQ state		* @flags: Current IRQ state
	*		*
	* On SMP systems, we need to get the attention of the other CPUs		* On SMP systems, we need to get the attention of the other CPUs
	* and get them be in a known state. This should do what is needed		* and get them into a known state. This should do what is needed
	* to get the other CPUs to call kgdb_wait(). Note that on some arches,		* to get the other CPUs to call kgdb_wait(). Note that on some arches,
	* the NMI approach is not used for rounding up all the CPUs. For example,		* the NMI approach is not used for rounding up all the CPUs. For example,
	* in case of MIPS, smp_call_function() is used to roundup CPUs. In		* in case of MIPS, smp_call_function() is used to roundup CPUs. In

Admin message