Commit 88547001 authored by Jason Wessel's avatar Jason Wessel Committed by Ralf Baechle
Browse files

[MIPS] kgdb: add arch support for the kernel's kgdb core 



The new kgdb architecture specific handler registers and unregisters
dynamically for exceptions depending on when you configure a kgdb I/O
driver.

Aside from initializing the exceptions earlier in the boot process,
kgdb should have no impact on a device when it is compiled in so long
as an I/O module is not configured for use.

There have been quite a number of contributors during the existence of
this patch (see arch/mips/kernel/kgdb.c).  Most recently Jason
re-wrote the mips kgdb logic to use the die notification handlers.

Signed-off-by: default avatarJason Wessel <jason.wessel@windriver.com>
Signed-off-by: default avatarRalf Baechle <ralf@linux-mips.org>
parent 8d60a903

arch/mips/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -3,6 +3,7 @@ config MIPS 
	default y

	select HAVE_IDE

	select HAVE_OPROFILE

	select HAVE_ARCH_KGDB

	# Horrible source of confusion.  Die, die, die ...

	select EMBEDDED

	select RTC_LIB

arch/mips/kernel/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -71,6 +71,7 @@ obj-$(CONFIG_MIPS32_COMPAT) += linux32.o ptrace32.o signal32.o 
obj-$(CONFIG_MIPS32_N32)	+= binfmt_elfn32.o scall64-n32.o signal_n32.o

obj-$(CONFIG_MIPS32_O32)	+= binfmt_elfo32.o scall64-o32.o



obj-$(CONFIG_KGDB)		+= kgdb.o

obj-$(CONFIG_PROC_FS)		+= proc.o



obj-$(CONFIG_64BIT)		+= cpu-bugs64.o

arch/mips/kernel/irq.c

+15 −0
Original line number Diff line number Diff line
@@ -21,11 +21,16 @@ 
#include <linux/sched.h>

#include <linux/seq_file.h>

#include <linux/kallsyms.h>

#include <linux/kgdb.h>



#include <asm/atomic.h>

#include <asm/system.h>

#include <asm/uaccess.h>



#ifdef CONFIG_KGDB

int kgdb_early_setup;

#endif



static unsigned long irq_map[NR_IRQS / BITS_PER_LONG];



int allocate_irqno(void)
@@ -130,8 +135,18 @@ void __init init_IRQ(void) 
{

	int i;



#ifdef CONFIG_KGDB

	if (kgdb_early_setup)

		return;

#endif



	for (i = 0; i < NR_IRQS; i++)

		set_irq_noprobe(i);



	arch_init_irq();



#ifdef CONFIG_KGDB

	if (!kgdb_early_setup)

		kgdb_early_setup = 1;

#endif

}

arch/mips/kernel/kgdb.c

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

 *  Originally written by Glenn Engel, Lake Stevens Instrument Division

 *

 *  Contributed by HP Systems

 *

 *  Modified for Linux/MIPS (and MIPS in general) by Andreas Busse

 *  Send complaints, suggestions etc. to <andy@waldorf-gmbh.de>

 *

 *  Copyright (C) 1995 Andreas Busse

 *

 *  Copyright (C) 2003 MontaVista Software Inc.

 *  Author: Jun Sun, jsun@mvista.com or jsun@junsun.net

 *

 *  Copyright (C) 2004-2005 MontaVista Software Inc.

 *  Author: Manish Lachwani, mlachwani@mvista.com or manish@koffee-break.com

 *

 *  Copyright (C) 2007-2008 Wind River Systems, Inc.

 *  Author/Maintainer: Jason Wessel, jason.wessel@windriver.com

 *

 *  This file is licensed under the terms of the GNU General Public License

 *  version 2. This program is licensed "as is" without any warranty of any

 *  kind, whether express or implied.

 */



#include <linux/ptrace.h>		/* for linux pt_regs struct */

#include <linux/kgdb.h>

#include <linux/kdebug.h>

#include <linux/sched.h>

#include <asm/inst.h>

#include <asm/fpu.h>

#include <asm/cacheflush.h>

#include <asm/processor.h>

#include <asm/sigcontext.h>



static struct hard_trap_info {

	unsigned char tt;	/* Trap type code for MIPS R3xxx and R4xxx */

	unsigned char signo;	/* Signal that we map this trap into */

} hard_trap_info[] = {

	{ 6, SIGBUS },		/* instruction bus error */

	{ 7, SIGBUS },		/* data bus error */

	{ 9, SIGTRAP },		/* break */

/*	{ 11, SIGILL },	*/	/* CPU unusable */

	{ 12, SIGFPE },		/* overflow */

	{ 13, SIGTRAP },	/* trap */

	{ 14, SIGSEGV },	/* virtual instruction cache coherency */

	{ 15, SIGFPE },		/* floating point exception */

	{ 23, SIGSEGV },	/* watch */

	{ 31, SIGSEGV },	/* virtual data cache coherency */

	{ 0, 0}			/* Must be last */

};



void arch_kgdb_breakpoint(void)

{

	__asm__ __volatile__(

		".globl breakinst\n\t"

		".set\tnoreorder\n\t"

		"nop\n"

		"breakinst:\tbreak\n\t"

		"nop\n\t"

		".set\treorder");

}



static void kgdb_call_nmi_hook(void *ignored)

{

	kgdb_nmicallback(raw_smp_processor_id(), (void *)0);

}



void kgdb_roundup_cpus(unsigned long flags)

{

	local_irq_enable();

	smp_call_function(kgdb_call_nmi_hook, NULL, NULL);

	local_irq_disable();

}



static int compute_signal(int tt)

{

	struct hard_trap_info *ht;



	for (ht = hard_trap_info; ht->tt && ht->signo; ht++)

		if (ht->tt == tt)

			return ht->signo;



	return SIGHUP;		/* default for things we don't know about */

}



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

{

	int reg;



#if (KGDB_GDB_REG_SIZE == 32)

	u32 *ptr = (u32 *)gdb_regs;

#else

	u64 *ptr = (u64 *)gdb_regs;

#endif



	for (reg = 0; reg < 32; reg++)

		*(ptr++) = regs->regs[reg];



	*(ptr++) = regs->cp0_status;

	*(ptr++) = regs->lo;

	*(ptr++) = regs->hi;

	*(ptr++) = regs->cp0_badvaddr;

	*(ptr++) = regs->cp0_cause;

	*(ptr++) = regs->cp0_epc;



	/* FP REGS */

	if (!(current && (regs->cp0_status & ST0_CU1)))

		return;



	save_fp(current);

	for (reg = 0; reg < 32; reg++)

		*(ptr++) = current->thread.fpu.fpr[reg];

}



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

{

	int reg;



#if (KGDB_GDB_REG_SIZE == 32)

	const u32 *ptr = (u32 *)gdb_regs;

#else

	const u64 *ptr = (u64 *)gdb_regs;

#endif



	for (reg = 0; reg < 32; reg++)

		regs->regs[reg] = *(ptr++);



	regs->cp0_status = *(ptr++);

	regs->lo = *(ptr++);

	regs->hi = *(ptr++);

	regs->cp0_badvaddr = *(ptr++);

	regs->cp0_cause = *(ptr++);

	regs->cp0_epc = *(ptr++);



	/* FP REGS from current */

	if (!(current && (regs->cp0_status & ST0_CU1)))

		return;



	for (reg = 0; reg < 32; reg++)

		current->thread.fpu.fpr[reg] = *(ptr++);

	restore_fp(current);

}



/*

 * Similar to regs_to_gdb_regs() except that process is sleeping and so

 * we may not be able to get all the info.

 */

void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p)

{

	int reg;

	struct thread_info *ti = task_thread_info(p);

	unsigned long ksp = (unsigned long)ti + THREAD_SIZE - 32;

	struct pt_regs *regs = (struct pt_regs *)ksp - 1;

#if (KGDB_GDB_REG_SIZE == 32)

	u32 *ptr = (u32 *)gdb_regs;

#else

	u64 *ptr = (u64 *)gdb_regs;

#endif



	for (reg = 0; reg < 16; reg++)

		*(ptr++) = regs->regs[reg];



	/* S0 - S7 */

	for (reg = 16; reg < 24; reg++)

		*(ptr++) = regs->regs[reg];



	for (reg = 24; reg < 28; reg++)

		*(ptr++) = 0;



	/* GP, SP, FP, RA */

	for (reg = 28; reg < 32; reg++)

		*(ptr++) = regs->regs[reg];



	*(ptr++) = regs->cp0_status;

	*(ptr++) = regs->lo;

	*(ptr++) = regs->hi;

	*(ptr++) = regs->cp0_badvaddr;

	*(ptr++) = regs->cp0_cause;

	*(ptr++) = regs->cp0_epc;

}



/*

 * Calls linux_debug_hook before the kernel dies. If KGDB is enabled,

 * then try to fall into the debugger

 */

static int kgdb_mips_notify(struct notifier_block *self, unsigned long cmd,

			    void *ptr)

{

	struct die_args *args = (struct die_args *)ptr;

	struct pt_regs *regs = args->regs;

	int trap = (regs->cp0_cause & 0x7c) >> 2;



	if (fixup_exception(regs))

		return NOTIFY_DONE;



	/* Userpace events, ignore. */

	if (user_mode(regs))

		return NOTIFY_DONE;



	if (atomic_read(&kgdb_active) != -1)

		kgdb_nmicallback(smp_processor_id(), regs);



	if (kgdb_handle_exception(trap, compute_signal(trap), 0, regs))

		return NOTIFY_DONE;



	if (atomic_read(&kgdb_setting_breakpoint))

		if ((trap == 9) && (regs->cp0_epc == (unsigned long)breakinst))

			regs->cp0_epc += 4;



	/* In SMP mode, __flush_cache_all does IPI */

	local_irq_enable();

	__flush_cache_all();



	return NOTIFY_STOP;

}



static struct notifier_block kgdb_notifier = {

	.notifier_call = kgdb_mips_notify,

};



/*

 * Handle the 's' and 'c' commands

 */

int kgdb_arch_handle_exception(int vector, int signo, int err_code,

			       char *remcom_in_buffer, char *remcom_out_buffer,

			       struct pt_regs *regs)

{

	char *ptr;

	unsigned long address;

	int cpu = smp_processor_id();



	switch (remcom_in_buffer[0]) {

	case 's':

	case 'c':

		/* handle the optional parameter */

		ptr = &remcom_in_buffer[1];

		if (kgdb_hex2long(&ptr, &address))

			regs->cp0_epc = address;



		atomic_set(&kgdb_cpu_doing_single_step, -1);

		if (remcom_in_buffer[0] == 's')

			if (kgdb_contthread)

				atomic_set(&kgdb_cpu_doing_single_step, cpu);



		return 0;

	}



	return -1;

}



struct kgdb_arch arch_kgdb_ops;



/*

 * We use kgdb_early_setup so that functions we need to call now don't

 * cause trouble when called again later.

 */

int kgdb_arch_init(void)

{

	union mips_instruction insn = {

		.r_format = {

			.opcode = spec_op,

			.func   = break_op,

		}

	};

	memcpy(arch_kgdb_ops.gdb_bpt_instr, insn.byte, BREAK_INSTR_SIZE);



	register_die_notifier(&kgdb_notifier);



	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_die_notifier(&kgdb_notifier);

}

arch/mips/kernel/traps.c

+21 −0
Original line number Diff line number Diff line
@@ -23,6 +23,8 @@ 
#include <linux/bootmem.h>

#include <linux/interrupt.h>

#include <linux/ptrace.h>

#include <linux/kgdb.h>

#include <linux/kdebug.h>



#include <asm/bootinfo.h>

#include <asm/branch.h>
@@ -425,6 +427,10 @@ asmlinkage void do_be(struct pt_regs *regs) 
	printk(KERN_ALERT "%s bus error, epc == %0*lx, ra == %0*lx\n",

	       data ? "Data" : "Instruction",

	       field, regs->cp0_epc, field, regs->regs[31]);

	if (notify_die(DIE_OOPS, "bus error", regs, SIGBUS, 0, 0)

	    == NOTIFY_STOP)

		return;



	die_if_kernel("Oops", regs);

	force_sig(SIGBUS, current);

}
@@ -623,6 +629,9 @@ asmlinkage void do_fpe(struct pt_regs *regs, unsigned long fcr31) 
{

	siginfo_t info;



	if (notify_die(DIE_FP, "FP exception", regs, SIGFPE, 0, 0)

	    == NOTIFY_STOP)

		return;

	die_if_kernel("FP exception in kernel code", regs);



	if (fcr31 & FPU_CSR_UNI_X) {
@@ -682,6 +691,9 @@ static void do_trap_or_bp(struct pt_regs *regs, unsigned int code, 
	siginfo_t info;

	char b[40];



	if (notify_die(DIE_TRAP, str, regs, code, 0, 0) == NOTIFY_STOP)

		return;



	/*

	 * A short test says that IRIX 5.3 sends SIGTRAP for all trap

	 * insns, even for trap and break codes that indicate arithmetic
@@ -762,6 +774,10 @@ asmlinkage void do_ri(struct pt_regs *regs) 
	unsigned int opcode = 0;

	int status = -1;



	if (notify_die(DIE_RI, "RI Fault", regs, SIGSEGV, 0, 0)

	    == NOTIFY_STOP)

		return;



	die_if_kernel("Reserved instruction in kernel code", regs);



	if (unlikely(compute_return_epc(regs) < 0))
@@ -1537,6 +1553,11 @@ void __init trap_init(void) 
	extern char except_vec4;

	unsigned long i;



#if defined(CONFIG_KGDB)

	if (kgdb_early_setup)

		return;	/* Already done */

#endif



	if (cpu_has_veic || cpu_has_vint)

		ebase = (unsigned long) alloc_bootmem_low_pages(0x200 + VECTORSPACING*64);

	else

CRA Git | Maintained and supported by SUSTech CRA and CCSE