Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0f6e38a6 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jwessel/linux-2.6-kgdb 

* 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jwessel/linux-2.6-kgdb:
  kgdb: kgdboc console poll hooks for mpsc uart
  kgdb: kgdboc console poll hooks for cpm uart
  kgdb, powerpc: arch specific powerpc kgdb support
  kgdb: support for ARCH=arm
  kgdb: remove unused HAVE_ARCH_KGDB_SHADOW_INFO config variable
parents e669e817 3b216c9e

arch/arm/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -12,6 +12,7 @@ config ARM 
	select RTC_LIB

	select SYS_SUPPORTS_APM_EMULATION

	select HAVE_OPROFILE

	select HAVE_ARCH_KGDB

	select HAVE_KPROBES if (!XIP_KERNEL)

	select HAVE_KRETPROBES if (HAVE_KPROBES)

	select HAVE_FTRACE if (!XIP_KERNEL)

arch/arm/kernel/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ obj-$(CONFIG_KPROBES) += kprobes.o kprobes-decode.o 
obj-$(CONFIG_ATAGS_PROC)	+= atags.o

obj-$(CONFIG_OABI_COMPAT)	+= sys_oabi-compat.o

obj-$(CONFIG_ARM_THUMBEE)	+= thumbee.o

obj-$(CONFIG_KGDB)		+= kgdb.o



obj-$(CONFIG_CRUNCH)		+= crunch.o crunch-bits.o

AFLAGS_crunch-bits.o		:= -Wa,-mcpu=ep9312

arch/arm/kernel/kgdb.c

0 → 100644
+201 −0
Original line number Diff line number Diff line 
/*

 * arch/arm/kernel/kgdb.c

 *

 * ARM KGDB support

 *

 * Copyright (c) 2002-2004 MontaVista Software, Inc

 * Copyright (c) 2008 Wind River Systems, Inc.

 *

 * Authors:  George Davis <davis_g@mvista.com>

 *           Deepak Saxena <dsaxena@plexity.net>

 */

#include <linux/kgdb.h>

#include <asm/traps.h>



/* Make a local copy of the registers passed into the handler (bletch) */

void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *kernel_regs)

{

	int regno;



	/* Initialize all to zero. */

	for (regno = 0; regno < GDB_MAX_REGS; regno++)

		gdb_regs[regno] = 0;



	gdb_regs[_R0]		= kernel_regs->ARM_r0;

	gdb_regs[_R1]		= kernel_regs->ARM_r1;

	gdb_regs[_R2]		= kernel_regs->ARM_r2;

	gdb_regs[_R3]		= kernel_regs->ARM_r3;

	gdb_regs[_R4]		= kernel_regs->ARM_r4;

	gdb_regs[_R5]		= kernel_regs->ARM_r5;

	gdb_regs[_R6]		= kernel_regs->ARM_r6;

	gdb_regs[_R7]		= kernel_regs->ARM_r7;

	gdb_regs[_R8]		= kernel_regs->ARM_r8;

	gdb_regs[_R9]		= kernel_regs->ARM_r9;

	gdb_regs[_R10]		= kernel_regs->ARM_r10;

	gdb_regs[_FP]		= kernel_regs->ARM_fp;

	gdb_regs[_IP]		= kernel_regs->ARM_ip;

	gdb_regs[_SPT]		= kernel_regs->ARM_sp;

	gdb_regs[_LR]		= kernel_regs->ARM_lr;

	gdb_regs[_PC]		= kernel_regs->ARM_pc;

	gdb_regs[_CPSR]		= kernel_regs->ARM_cpsr;

}



/* Copy local gdb registers back to kgdb regs, for later copy to kernel */

void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *kernel_regs)

{

	kernel_regs->ARM_r0	= gdb_regs[_R0];

	kernel_regs->ARM_r1	= gdb_regs[_R1];

	kernel_regs->ARM_r2	= gdb_regs[_R2];

	kernel_regs->ARM_r3	= gdb_regs[_R3];

	kernel_regs->ARM_r4	= gdb_regs[_R4];

	kernel_regs->ARM_r5	= gdb_regs[_R5];

	kernel_regs->ARM_r6	= gdb_regs[_R6];

	kernel_regs->ARM_r7	= gdb_regs[_R7];

	kernel_regs->ARM_r8	= gdb_regs[_R8];

	kernel_regs->ARM_r9	= gdb_regs[_R9];

	kernel_regs->ARM_r10	= gdb_regs[_R10];

	kernel_regs->ARM_fp	= gdb_regs[_FP];

	kernel_regs->ARM_ip	= gdb_regs[_IP];

	kernel_regs->ARM_sp	= gdb_regs[_SPT];

	kernel_regs->ARM_lr	= gdb_regs[_LR];

	kernel_regs->ARM_pc	= gdb_regs[_PC];

	kernel_regs->ARM_cpsr	= gdb_regs[_CPSR];

}



void

sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *task)

{

	struct pt_regs *thread_regs;

	int regno;



	/* Just making sure... */

	if (task == NULL)

		return;



	/* Initialize to zero */

	for (regno = 0; regno < GDB_MAX_REGS; regno++)

		gdb_regs[regno] = 0;



	/* Otherwise, we have only some registers from switch_to() */

	thread_regs		= task_pt_regs(task);

	gdb_regs[_R0]		= thread_regs->ARM_r0;

	gdb_regs[_R1]		= thread_regs->ARM_r1;

	gdb_regs[_R2]		= thread_regs->ARM_r2;

	gdb_regs[_R3]		= thread_regs->ARM_r3;

	gdb_regs[_R4]		= thread_regs->ARM_r4;

	gdb_regs[_R5]		= thread_regs->ARM_r5;

	gdb_regs[_R6]		= thread_regs->ARM_r6;

	gdb_regs[_R7]		= thread_regs->ARM_r7;

	gdb_regs[_R8]		= thread_regs->ARM_r8;

	gdb_regs[_R9]		= thread_regs->ARM_r9;

	gdb_regs[_R10]		= thread_regs->ARM_r10;

	gdb_regs[_FP]		= thread_regs->ARM_fp;

	gdb_regs[_IP]		= thread_regs->ARM_ip;

	gdb_regs[_SPT]		= thread_regs->ARM_sp;

	gdb_regs[_LR]		= thread_regs->ARM_lr;

	gdb_regs[_PC]		= thread_regs->ARM_pc;

	gdb_regs[_CPSR]		= thread_regs->ARM_cpsr;

}



static int compiled_break;



int kgdb_arch_handle_exception(int exception_vector, int signo,

			       int err_code, char *remcom_in_buffer,

			       char *remcom_out_buffer,

			       struct pt_regs *linux_regs)

{

	unsigned long addr;

	char *ptr;



	switch (remcom_in_buffer[0]) {

	case 'D':

	case 'k':

	case 'c':

		kgdb_contthread = NULL;



		/*

		 * Try to read optional parameter, pc unchanged if no parm.

		 * If this was a compiled breakpoint, we need to move

		 * to the next instruction or we will just breakpoint

		 * over and over again.

		 */

		ptr = &remcom_in_buffer[1];

		if (kgdb_hex2long(&ptr, &addr))

			linux_regs->ARM_pc = addr;

		else if (compiled_break == 1)

			linux_regs->ARM_pc += 4;



		compiled_break = 0;



		return 0;

	}



	return -1;

}



static int kgdb_brk_fn(struct pt_regs *regs, unsigned int instr)

{

	kgdb_handle_exception(1, SIGTRAP, 0, regs);



	return 0;

}



static int kgdb_compiled_brk_fn(struct pt_regs *regs, unsigned int instr)

{

	compiled_break = 1;

	kgdb_handle_exception(1, SIGTRAP, 0, regs);



	return 0;

}



static struct undef_hook kgdb_brkpt_hook = {

	.instr_mask		= 0xffffffff,

	.instr_val		= KGDB_BREAKINST,

	.fn			= kgdb_brk_fn

};



static struct undef_hook kgdb_compiled_brkpt_hook = {

	.instr_mask		= 0xffffffff,

	.instr_val		= KGDB_COMPILED_BREAK,

	.fn			= kgdb_compiled_brk_fn

};



/**

 *	kgdb_arch_init - Perform any architecture specific initalization.

 *

 *	This function will handle the initalization of any architecture

 *	specific callbacks.

 */

int kgdb_arch_init(void)

{

	register_undef_hook(&kgdb_brkpt_hook);

	register_undef_hook(&kgdb_compiled_brkpt_hook);



	return 0;

}



/**

 *	kgdb_arch_exit - Perform any architecture specific uninitalization.

 *

 *	This function will handle the uninitalization of any architecture

 *	specific callbacks, for dynamic registration and unregistration.

 */

void kgdb_arch_exit(void)

{

	unregister_undef_hook(&kgdb_brkpt_hook);

	unregister_undef_hook(&kgdb_compiled_brkpt_hook);

}



/*

 * Register our undef instruction hooks with ARM undef core.

 * We regsiter a hook specifically looking for the KGB break inst

 * and we handle the normal undef case within the do_undefinstr

 * handler.

 */

struct kgdb_arch arch_kgdb_ops = {

#ifndef __ARMEB__

	.gdb_bpt_instr		= {0xfe, 0xde, 0xff, 0xe7}

#else /* ! __ARMEB__ */

	.gdb_bpt_instr		= {0xe7, 0xff, 0xde, 0xfe}

#endif

};

arch/arm/kernel/setup.c

+2 −0
Original line number Diff line number Diff line
@@ -36,6 +36,7 @@ 
#include <asm/mach/arch.h>

#include <asm/mach/irq.h>

#include <asm/mach/time.h>

#include <asm/traps.h>



#include "compat.h"

#include "atags.h"
@@ -853,6 +854,7 @@ void __init setup_arch(char **cmdline_p) 
	conswitchp = &dummy_con;

#endif

#endif

	early_trap_init();

}

arch/arm/kernel/traps.c

+5 −0
Original line number Diff line number Diff line
@@ -707,6 +707,11 @@ void abort(void) 
EXPORT_SYMBOL(abort);



void __init trap_init(void)

{

	return;

}



void __init early_trap_init(void)

{

	unsigned long vectors = CONFIG_VECTORS_BASE;

	extern char __stubs_start[], __stubs_end[];