* [PATCH 0/2] Add back capability of calling KGDB/KDB via UV NMI call. @ 2013-10-02 15:14 Mike Travis 2013-10-02 15:14 ` [PATCH 1/2] KGDB/KDB: add support for external NMI handler to call KGDB/KDB Mike Travis 2013-10-02 15:14 ` [PATCH 2/2] x86/UV: Add call to KGDB/KDB from NMI handler Mike Travis 0 siblings, 2 replies; 6+ messages in thread From: Mike Travis @ 2013-10-02 15:14 UTC (permalink / raw) To: Peter Zijlstra, Paul Mackerras, Ingo Molnar, Arnaldo Carvalho de Melo, Jason Wessel, H. Peter Anvin, Thomas Gleixner, Andrew Morton Cc: Dimitri Sivanich, Hedi Berriche, x86, linux-kernel The following two patches add the capability of calling KGDB/KDB after receiving the NMI signal from the UV system 'power nmi' command. This is mainly required because the system console on UV cannot send the break signal so when the system I/O is not working, the power nmi command from the CMC is the only method to interrupt the system. -- ^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH 1/2] KGDB/KDB: add support for external NMI handler to call KGDB/KDB. 2013-10-02 15:14 [PATCH 0/2] Add back capability of calling KGDB/KDB via UV NMI call Mike Travis @ 2013-10-02 15:14 ` Mike Travis 2013-10-03 7:04 ` Ingo Molnar 2013-10-04 17:31 ` [tip:x86/uv] kdb: Add " tip-bot for Mike Travis 2013-10-02 15:14 ` [PATCH 2/2] x86/UV: Add call to KGDB/KDB from NMI handler Mike Travis 1 sibling, 2 replies; 6+ messages in thread From: Mike Travis @ 2013-10-02 15:14 UTC (permalink / raw) To: Peter Zijlstra, Paul Mackerras, Ingo Molnar, Arnaldo Carvalho de Melo, Jason Wessel, H. Peter Anvin, Thomas Gleixner, Andrew Morton Cc: Dimitri Sivanich, Hedi Berriche, x86, linux-kernel [-- Attachment #1: kgdb-add-nmi-callin.patch --] [-- Type: text/plain, Size: 4363 bytes --] This patch adds a kgdb_nmicallin() interface that can be used by external NMI handlers to call the KGDB/KDB handler. The primary need for this is for those types of NMI interrupts where all the CPUs have already received the NMI signal. Therefore no send_IPI(NMI) is required, and in fact it will cause a 2nd unhandled NMI to occur. This generates the "Dazed and Confuzed" messages. Since all the CPUs are getting the NMI at roughly the same time, it's not guaranteed that the first CPU that hits the NMI handler will manage to enter KGDB and set the dbg_master_lock before the slaves start entering. The new argument "send_ready" was added for KGDB to signal the NMI handler to release the slave CPUs for entry into KGDB. Signed-off-by: Mike Travis <travis@sgi.com> Reviewed-by: Dimitri Sivanich <sivanich@sgi.com> Reviewed-by: Hedi Berriche <hedi@sgi.com> Acked-by: Jason Wessel <jason.wessel@windriver.com> --- v3: make entry into SYSTEM_NMI section more specific --- include/linux/kdb.h | 1 + include/linux/kgdb.h | 1 + kernel/debug/debug_core.c | 30 +++++++++++++++++++++++++++++- kernel/debug/debug_core.h | 1 + kernel/debug/kdb/kdb_debugger.c | 5 ++++- kernel/debug/kdb/kdb_main.c | 3 +++ 6 files changed, 39 insertions(+), 2 deletions(-) --- linux.orig/include/linux/kdb.h +++ linux/include/linux/kdb.h @@ -109,6 +109,7 @@ typedef enum { KDB_REASON_RECURSE, /* Recursive entry to kdb; * regs probably valid */ KDB_REASON_SSTEP, /* Single Step trap. - regs valid */ + KDB_REASON_SYSTEM_NMI, /* In NMI due to SYSTEM cmd; regs valid */ } kdb_reason_t; extern int kdb_trap_printk; --- linux.orig/include/linux/kgdb.h +++ linux/include/linux/kgdb.h @@ -310,6 +310,7 @@ extern int kgdb_handle_exception(int ex_vector, int signo, int err_code, struct pt_regs *regs); extern int kgdb_nmicallback(int cpu, void *regs); +extern int kgdb_nmicallin(int cpu, int trapnr, void *regs, atomic_t *snd_rdy); extern void gdbstub_exit(int status); extern int kgdb_single_step; --- linux.orig/kernel/debug/debug_core.c +++ linux/kernel/debug/debug_core.c @@ -575,8 +575,12 @@ return_normal: raw_spin_lock(&dbg_slave_lock); #ifdef CONFIG_SMP + /* If SYSTEM_NMI, slaves are already waiting */ + if (ks->err_code == KDB_REASON_SYSTEM_NMI) + atomic_set(ks->send_ready, 1); + /* Signal the other CPUs to enter kgdb_wait() */ - if ((!kgdb_single_step) && kgdb_do_roundup) + else if ((!kgdb_single_step) && kgdb_do_roundup) kgdb_roundup_cpus(flags); #endif @@ -729,6 +733,30 @@ int kgdb_nmicallback(int cpu, void *regs return 0; } #endif + return 1; +} + +int kgdb_nmicallin(int cpu, int trapnr, void *regs, atomic_t *send_ready) +{ +#ifdef CONFIG_SMP + if (!kgdb_io_ready(0) || !send_ready) + return 1; + + if (kgdb_info[cpu].enter_kgdb == 0) { + struct kgdb_state kgdb_var; + struct kgdb_state *ks = &kgdb_var; + + memset(ks, 0, sizeof(struct kgdb_state)); + ks->cpu = cpu; + ks->ex_vector = trapnr; + ks->signo = SIGTRAP; + ks->err_code = KDB_REASON_SYSTEM_NMI; + ks->linux_regs = regs; + ks->send_ready = send_ready; + kgdb_cpu_enter(ks, regs, DCPU_WANT_MASTER); + return 0; + } +#endif return 1; } --- linux.orig/kernel/debug/debug_core.h +++ linux/kernel/debug/debug_core.h @@ -26,6 +26,7 @@ struct kgdb_state { unsigned long threadid; long kgdb_usethreadid; struct pt_regs *linux_regs; + atomic_t *send_ready; }; /* Exception state values */ --- linux.orig/kernel/debug/kdb/kdb_debugger.c +++ linux/kernel/debug/kdb/kdb_debugger.c @@ -69,7 +69,10 @@ int kdb_stub(struct kgdb_state *ks) if (atomic_read(&kgdb_setting_breakpoint)) reason = KDB_REASON_KEYBOARD; - if (in_nmi()) + if (ks->err_code == KDB_REASON_SYSTEM_NMI && ks->signo == SIGTRAP) + reason = KDB_REASON_SYSTEM_NMI; + + else if (in_nmi()) reason = KDB_REASON_NMI; for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++) { --- linux.orig/kernel/debug/kdb/kdb_main.c +++ linux/kernel/debug/kdb/kdb_main.c @@ -1200,6 +1200,9 @@ static int kdb_local(kdb_reason_t reason instruction_pointer(regs)); kdb_dumpregs(regs); break; + case KDB_REASON_SYSTEM_NMI: + kdb_printf("due to System NonMaskable Interrupt\n"); + break; case KDB_REASON_NMI: kdb_printf("due to NonMaskable Interrupt @ " kdb_machreg_fmt "\n", -- ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 1/2] KGDB/KDB: add support for external NMI handler to call KGDB/KDB. 2013-10-02 15:14 ` [PATCH 1/2] KGDB/KDB: add support for external NMI handler to call KGDB/KDB Mike Travis @ 2013-10-03 7:04 ` Ingo Molnar 2013-10-04 17:31 ` [tip:x86/uv] kdb: Add " tip-bot for Mike Travis 1 sibling, 0 replies; 6+ messages in thread From: Ingo Molnar @ 2013-10-03 7:04 UTC (permalink / raw) To: Mike Travis Cc: Peter Zijlstra, Paul Mackerras, Ingo Molnar, Arnaldo Carvalho de Melo, Jason Wessel, H. Peter Anvin, Thomas Gleixner, Andrew Morton, Dimitri Sivanich, Hedi Berriche, x86, linux-kernel * Mike Travis <travis@sgi.com> wrote: > This patch adds a kgdb_nmicallin() interface that can be used by > external NMI handlers to call the KGDB/KDB handler. The primary need > for this is for those types of NMI interrupts where all the CPUs > have already received the NMI signal. Therefore no send_IPI(NMI) > is required, and in fact it will cause a 2nd unhandled NMI to occur. > This generates the "Dazed and Confuzed" messages. > > Since all the CPUs are getting the NMI at roughly the same time, it's not > guaranteed that the first CPU that hits the NMI handler will manage to > enter KGDB and set the dbg_master_lock before the slaves start entering. > The new argument "send_ready" was added for KGDB to signal the NMI handler > to release the slave CPUs for entry into KGDB. > > Signed-off-by: Mike Travis <travis@sgi.com> > Reviewed-by: Dimitri Sivanich <sivanich@sgi.com> > Reviewed-by: Hedi Berriche <hedi@sgi.com> > Acked-by: Jason Wessel <jason.wessel@windriver.com> > --- > v3: make entry into SYSTEM_NMI section more specific > --- > include/linux/kdb.h | 1 + > include/linux/kgdb.h | 1 + > kernel/debug/debug_core.c | 30 +++++++++++++++++++++++++++++- > kernel/debug/debug_core.h | 1 + > kernel/debug/kdb/kdb_debugger.c | 5 ++++- > kernel/debug/kdb/kdb_main.c | 3 +++ > 6 files changed, 39 insertions(+), 2 deletions(-) > > --- linux.orig/include/linux/kdb.h > +++ linux/include/linux/kdb.h > @@ -109,6 +109,7 @@ typedef enum { > KDB_REASON_RECURSE, /* Recursive entry to kdb; > * regs probably valid */ > KDB_REASON_SSTEP, /* Single Step trap. - regs valid */ > + KDB_REASON_SYSTEM_NMI, /* In NMI due to SYSTEM cmd; regs valid */ > } kdb_reason_t; Note that this is within an #ifdef CONFIG_KGDB_KDB section. > --- linux.orig/kernel/debug/debug_core.c > +++ linux/kernel/debug/debug_core.c > @@ -575,8 +575,12 @@ return_normal: > raw_spin_lock(&dbg_slave_lock); > > #ifdef CONFIG_SMP > + /* If SYSTEM_NMI, slaves are already waiting */ > + if (ks->err_code == KDB_REASON_SYSTEM_NMI) > + atomic_set(ks->send_ready, 1); And this then fails to build if CONFIG_KGDB_KDB is turned off: kernel/debug/debug_core.c:579:22: error: ‘KDB_REASON_SYSTEM_NMI’ undeclared (first use in this function) kernel/debug/debug_core.c:753:19: error: ‘KDB_REASON_SYSTEM_NMI’ undeclared (first use in this function) More fundamentally, I think the way KDB internals added to debug_core.c by this patch violates its relatively layered design. It would be cleaner to add helper functions defined in kdb and turned into empty inlines in the !CONFIG_KGDB_KDB case, like it's done for a couple of other cases in kdb.h: static inline void kdb_init(int level) {} static inline int kdb_register(char *cmd, kdb_func_t func, char *usage, char *help, short minlen) { return 0; } static inline int kdb_register_repeat(char *cmd, kdb_func_t func, char *usage, char *help, short minlen, kdb_repeat_t repeat) { return 0; } static inline int kdb_unregister(char *cmd) { return 0; } So this needs more work. Thanks, Ingo ^ permalink raw reply [flat|nested] 6+ messages in thread
* [tip:x86/uv] kdb: Add support for external NMI handler to call KGDB/KDB 2013-10-02 15:14 ` [PATCH 1/2] KGDB/KDB: add support for external NMI handler to call KGDB/KDB Mike Travis 2013-10-03 7:04 ` Ingo Molnar @ 2013-10-04 17:31 ` tip-bot for Mike Travis 1 sibling, 0 replies; 6+ messages in thread From: tip-bot for Mike Travis @ 2013-10-04 17:31 UTC (permalink / raw) To: linux-tip-commits Cc: linux-kernel, paulus, hpa, mingo, a.p.zijlstra, jason.wessel, travis, acme, hedi, sivanich, tglx Commit-ID: 8daaa5f8261bffd2f6217a960f9182d0503a5c44 Gitweb: http://git.kernel.org/tip/8daaa5f8261bffd2f6217a960f9182d0503a5c44 Author: Mike Travis <travis@sgi.com> AuthorDate: Wed, 2 Oct 2013 10:14:18 -0500 Committer: Ingo Molnar <mingo@kernel.org> CommitDate: Thu, 3 Oct 2013 18:47:54 +0200 kdb: Add support for external NMI handler to call KGDB/KDB This patch adds a kgdb_nmicallin() interface that can be used by external NMI handlers to call the KGDB/KDB handler. The primary need for this is for those types of NMI interrupts where all the CPUs have already received the NMI signal. Therefore no send_IPI(NMI) is required, and in fact it will cause a 2nd unhandled NMI to occur. This generates the "Dazed and Confuzed" messages. Since all the CPUs are getting the NMI at roughly the same time, it's not guaranteed that the first CPU that hits the NMI handler will manage to enter KGDB and set the dbg_master_lock before the slaves start entering. The new argument "send_ready" was added for KGDB to signal the NMI handler to release the slave CPUs for entry into KGDB. Signed-off-by: Mike Travis <travis@sgi.com> Acked-by: Jason Wessel <jason.wessel@windriver.com> Reviewed-by: Dimitri Sivanich <sivanich@sgi.com> Reviewed-by: Hedi Berriche <hedi@sgi.com> Cc: Peter Zijlstra <a.p.zijlstra@chello.nl> Cc: Paul Mackerras <paulus@samba.org> Cc: Arnaldo Carvalho de Melo <acme@ghostprotocols.net> Link: http://lkml.kernel.org/r/20131002151417.928886849@asylum.americas.sgi.com Signed-off-by: Ingo Molnar <mingo@kernel.org> --- include/linux/kdb.h | 1 + include/linux/kgdb.h | 1 + kernel/debug/debug_core.c | 32 ++++++++++++++++++++++++++++++-- kernel/debug/debug_core.h | 3 +++ kernel/debug/kdb/kdb_debugger.c | 5 ++++- kernel/debug/kdb/kdb_main.c | 3 +++ 6 files changed, 42 insertions(+), 3 deletions(-) diff --git a/include/linux/kdb.h b/include/linux/kdb.h index 7f6fe6e..290db12 100644 --- a/include/linux/kdb.h +++ b/include/linux/kdb.h @@ -109,6 +109,7 @@ typedef enum { KDB_REASON_RECURSE, /* Recursive entry to kdb; * regs probably valid */ KDB_REASON_SSTEP, /* Single Step trap. - regs valid */ + KDB_REASON_SYSTEM_NMI, /* In NMI due to SYSTEM cmd; regs valid */ } kdb_reason_t; extern int kdb_trap_printk; diff --git a/include/linux/kgdb.h b/include/linux/kgdb.h index c6e091b..dfb4f2f 100644 --- a/include/linux/kgdb.h +++ b/include/linux/kgdb.h @@ -310,6 +310,7 @@ extern int kgdb_handle_exception(int ex_vector, int signo, int err_code, struct pt_regs *regs); extern int kgdb_nmicallback(int cpu, void *regs); +extern int kgdb_nmicallin(int cpu, int trapnr, void *regs, atomic_t *snd_rdy); extern void gdbstub_exit(int status); extern int kgdb_single_step; diff --git a/kernel/debug/debug_core.c b/kernel/debug/debug_core.c index 0506d44..7d2f35e 100644 --- a/kernel/debug/debug_core.c +++ b/kernel/debug/debug_core.c @@ -575,8 +575,12 @@ return_normal: raw_spin_lock(&dbg_slave_lock); #ifdef CONFIG_SMP + /* If send_ready set, slaves are already waiting */ + if (ks->send_ready) + atomic_set(ks->send_ready, 1); + /* Signal the other CPUs to enter kgdb_wait() */ - if ((!kgdb_single_step) && kgdb_do_roundup) + else if ((!kgdb_single_step) && kgdb_do_roundup) kgdb_roundup_cpus(flags); #endif @@ -678,11 +682,11 @@ kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs) if (arch_kgdb_ops.enable_nmi) arch_kgdb_ops.enable_nmi(0); + memset(ks, 0, sizeof(struct kgdb_state)); ks->cpu = raw_smp_processor_id(); ks->ex_vector = evector; ks->signo = signo; ks->err_code = ecode; - ks->kgdb_usethreadid = 0; ks->linux_regs = regs; if (kgdb_reenter_check(ks)) @@ -732,6 +736,30 @@ int kgdb_nmicallback(int cpu, void *regs) return 1; } +int kgdb_nmicallin(int cpu, int trapnr, void *regs, atomic_t *send_ready) +{ +#ifdef CONFIG_SMP + if (!kgdb_io_ready(0) || !send_ready) + return 1; + + if (kgdb_info[cpu].enter_kgdb == 0) { + struct kgdb_state kgdb_var; + struct kgdb_state *ks = &kgdb_var; + + memset(ks, 0, sizeof(struct kgdb_state)); + ks->cpu = cpu; + ks->ex_vector = trapnr; + ks->signo = SIGTRAP; + ks->err_code = KGDB_KDB_REASON_SYSTEM_NMI; + ks->linux_regs = regs; + ks->send_ready = send_ready; + kgdb_cpu_enter(ks, regs, DCPU_WANT_MASTER); + return 0; + } +#endif + return 1; +} + static void kgdb_console_write(struct console *co, const char *s, unsigned count) { diff --git a/kernel/debug/debug_core.h b/kernel/debug/debug_core.h index 2235967..572aa4f 100644 --- a/kernel/debug/debug_core.h +++ b/kernel/debug/debug_core.h @@ -26,6 +26,7 @@ struct kgdb_state { unsigned long threadid; long kgdb_usethreadid; struct pt_regs *linux_regs; + atomic_t *send_ready; }; /* Exception state values */ @@ -74,11 +75,13 @@ extern int kdb_stub(struct kgdb_state *ks); extern int kdb_parse(const char *cmdstr); extern int kdb_common_init_state(struct kgdb_state *ks); extern int kdb_common_deinit_state(void); +#define KGDB_KDB_REASON_SYSTEM_NMI KDB_REASON_SYSTEM_NMI #else /* ! CONFIG_KGDB_KDB */ static inline int kdb_stub(struct kgdb_state *ks) { return DBG_PASS_EVENT; } +#define KGDB_KDB_REASON_SYSTEM_NMI 0 #endif /* CONFIG_KGDB_KDB */ #endif /* _DEBUG_CORE_H_ */ diff --git a/kernel/debug/kdb/kdb_debugger.c b/kernel/debug/kdb/kdb_debugger.c index 328d18e..8859ca3 100644 --- a/kernel/debug/kdb/kdb_debugger.c +++ b/kernel/debug/kdb/kdb_debugger.c @@ -69,7 +69,10 @@ int kdb_stub(struct kgdb_state *ks) if (atomic_read(&kgdb_setting_breakpoint)) reason = KDB_REASON_KEYBOARD; - if (in_nmi()) + if (ks->err_code == KDB_REASON_SYSTEM_NMI && ks->signo == SIGTRAP) + reason = KDB_REASON_SYSTEM_NMI; + + else if (in_nmi()) reason = KDB_REASON_NMI; for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++) { diff --git a/kernel/debug/kdb/kdb_main.c b/kernel/debug/kdb/kdb_main.c index 00eb8f7..0b097c8 100644 --- a/kernel/debug/kdb/kdb_main.c +++ b/kernel/debug/kdb/kdb_main.c @@ -1200,6 +1200,9 @@ static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs, instruction_pointer(regs)); kdb_dumpregs(regs); break; + case KDB_REASON_SYSTEM_NMI: + kdb_printf("due to System NonMaskable Interrupt\n"); + break; case KDB_REASON_NMI: kdb_printf("due to NonMaskable Interrupt @ " kdb_machreg_fmt "\n", ^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH 2/2] x86/UV: Add call to KGDB/KDB from NMI handler 2013-10-02 15:14 [PATCH 0/2] Add back capability of calling KGDB/KDB via UV NMI call Mike Travis 2013-10-02 15:14 ` [PATCH 1/2] KGDB/KDB: add support for external NMI handler to call KGDB/KDB Mike Travis @ 2013-10-02 15:14 ` Mike Travis 2013-10-04 17:31 ` [tip:x86/uv] " tip-bot for Mike Travis 1 sibling, 1 reply; 6+ messages in thread From: Mike Travis @ 2013-10-02 15:14 UTC (permalink / raw) To: Peter Zijlstra, Paul Mackerras, Ingo Molnar, Arnaldo Carvalho de Melo, Jason Wessel, H. Peter Anvin, Thomas Gleixner, Andrew Morton Cc: Dimitri Sivanich, Hedi Berriche, x86, linux-kernel [-- Attachment #1: uv-add-nmi-call-kdb.patch --] [-- Type: text/plain, Size: 3589 bytes --] This patch restores the capability to enter KDB (and KGDB) from the UV NMI handler. This is needed because the UV system console is not capable of sending the 'break' signal to the serial console port. It is also useful when the kernel is hung in such a way that it isn't responding to normal external I/O, so sending 'g' to sysreq-trigger does not work either. Another benefit of the external NMI command is that all the cpus receive the NMI signal at roughly the same time so they are more closely aligned timewise. It utilizes the newly added kgdb_nmicallin function to gain entry to KGDB/KDB by the master. The slaves still enter via the standard kgdb_nmicallback function. It also uses the new 'send_ready' pointer to tell KGDB/KDB to signal the slaves when to proceed into the KGDB slave loop. It is enabled when the nmi action is set to "kdb" and the kernel is built with CONFIG_KDB enabled. Note that if kgdb is connected that interface will be used instead. Signed-off-by: Mike Travis <travis@sgi.com> Reviewed-by: Dimitri Sivanich <sivanich@sgi.com> Reviewed-by: Hedi Berriche <hedi@sgi.com> --- arch/x86/platform/uv/uv_nmi.c | 47 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 46 insertions(+), 1 deletion(-) --- linux.orig/arch/x86/platform/uv/uv_nmi.c +++ linux/arch/x86/platform/uv/uv_nmi.c @@ -21,7 +21,9 @@ #include <linux/cpu.h> #include <linux/delay.h> +#include <linux/kdb.h> #include <linux/kexec.h> +#include <linux/kgdb.h> #include <linux/module.h> #include <linux/nmi.h> #include <linux/sched.h> @@ -32,6 +34,7 @@ #include <asm/kdebug.h> #include <asm/local64.h> #include <asm/nmi.h> +#include <asm/traps.h> #include <asm/uv/uv.h> #include <asm/uv/uv_hub.h> #include <asm/uv/uv_mmrs.h> @@ -153,8 +156,9 @@ module_param_named(retry_count, uv_nmi_r * "dump" - dump process stack for each cpu * "ips" - dump IP info for each cpu * "kdump" - do crash dump + * "kdb" - enter KDB/KGDB (default) */ -static char uv_nmi_action[8] = "dump"; +static char uv_nmi_action[8] = "kdb"; module_param_string(action, uv_nmi_action, sizeof(uv_nmi_action), 0644); static inline bool uv_nmi_action_is(const char *action) @@ -540,6 +544,43 @@ static inline void uv_nmi_kdump(int cpu, } #endif /* !CONFIG_KEXEC */ +#ifdef CONFIG_KGDB_KDB +/* Call KDB from NMI handler */ +static void uv_call_kdb(int cpu, struct pt_regs *regs, int master) +{ + int ret; + + if (master) { + /* call KGDB NMI handler as MASTER */ + ret = kgdb_nmicallin(cpu, X86_TRAP_NMI, regs, + &uv_nmi_slave_continue); + if (ret) { + pr_alert("KDB returned error, is kgdboc set?\n"); + atomic_set(&uv_nmi_slave_continue, SLAVE_EXIT); + } + } else { + /* wait for KGDB signal that it's ready for slaves to enter */ + int sig; + + do { + cpu_relax(); + sig = atomic_read(&uv_nmi_slave_continue); + } while (!sig); + + /* call KGDB as slave */ + if (sig == SLAVE_CONTINUE) + kgdb_nmicallback(cpu, regs); + } + uv_nmi_sync_exit(master); +} + +#else /* !CONFIG_KGDB_KDB */ +static inline void uv_call_kdb(int cpu, struct pt_regs *regs, int master) +{ + pr_err("UV: NMI error: KGDB/KDB is not enabled in this kernel\n"); +} +#endif /* !CONFIG_KGDB_KDB */ + /* * UV NMI handler */ @@ -576,6 +617,10 @@ static int uv_handle_nmi(unsigned int re if (uv_nmi_action_is("ips") || uv_nmi_action_is("dump")) uv_nmi_dump_state(cpu, regs, master); + /* Call KDB if enabled */ + else if (uv_nmi_action_is("kdb")) + uv_call_kdb(cpu, regs, master); + /* Clear per_cpu "in nmi" flag */ atomic_set(&uv_cpu_nmi.state, UV_NMI_STATE_OUT); -- ^ permalink raw reply [flat|nested] 6+ messages in thread
* [tip:x86/uv] x86/UV: Add call to KGDB/KDB from NMI handler 2013-10-02 15:14 ` [PATCH 2/2] x86/UV: Add call to KGDB/KDB from NMI handler Mike Travis @ 2013-10-04 17:31 ` tip-bot for Mike Travis 0 siblings, 0 replies; 6+ messages in thread From: tip-bot for Mike Travis @ 2013-10-04 17:31 UTC (permalink / raw) To: linux-tip-commits Cc: linux-kernel, paulus, hpa, mingo, jason.wessel, a.p.zijlstra, travis, acme, hedi, sivanich, tglx Commit-ID: e379ea82dd53a5cc8e3ac0b7899a8012006c712c Gitweb: http://git.kernel.org/tip/e379ea82dd53a5cc8e3ac0b7899a8012006c712c Author: Mike Travis <travis@sgi.com> AuthorDate: Wed, 2 Oct 2013 10:14:19 -0500 Committer: Ingo Molnar <mingo@kernel.org> CommitDate: Thu, 3 Oct 2013 18:48:09 +0200 x86/UV: Add call to KGDB/KDB from NMI handler This patch restores the capability to enter KDB (and KGDB) from the UV NMI handler. This is needed because the UV system console is not capable of sending the 'break' signal to the serial console port. It is also useful when the kernel is hung in such a way that it isn't responding to normal external I/O, so sending 'g' to sysreq-trigger does not work either. Another benefit of the external NMI command is that all the cpus receive the NMI signal at roughly the same time so they are more closely aligned timewise. It utilizes the newly added kgdb_nmicallin function to gain entry to KGDB/KDB by the master. The slaves still enter via the standard kgdb_nmicallback function. It also uses the new 'send_ready' pointer to tell KGDB/KDB to signal the slaves when to proceed into the KGDB slave loop. It is enabled when the nmi action is set to "kdb" and the kernel is built with CONFIG_KDB enabled. Note that if kgdb is connected that interface will be used instead. Signed-off-by: Mike Travis <travis@sgi.com> Reviewed-by: Dimitri Sivanich <sivanich@sgi.com> Reviewed-by: Hedi Berriche <hedi@sgi.com> Cc: Peter Zijlstra <a.p.zijlstra@chello.nl> Cc: Paul Mackerras <paulus@samba.org> Cc: Arnaldo Carvalho de Melo <acme@ghostprotocols.net> Cc: Jason Wessel <jason.wessel@windriver.com> Link: http://lkml.kernel.org/r/20131002151418.089692683@asylum.americas.sgi.com Signed-off-by: Ingo Molnar <mingo@kernel.org> --- arch/x86/platform/uv/uv_nmi.c | 47 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 46 insertions(+), 1 deletion(-) diff --git a/arch/x86/platform/uv/uv_nmi.c b/arch/x86/platform/uv/uv_nmi.c index 9126dfb..9b8ac60 100644 --- a/arch/x86/platform/uv/uv_nmi.c +++ b/arch/x86/platform/uv/uv_nmi.c @@ -21,7 +21,9 @@ #include <linux/cpu.h> #include <linux/delay.h> +#include <linux/kdb.h> #include <linux/kexec.h> +#include <linux/kgdb.h> #include <linux/module.h> #include <linux/nmi.h> #include <linux/sched.h> @@ -32,6 +34,7 @@ #include <asm/kdebug.h> #include <asm/local64.h> #include <asm/nmi.h> +#include <asm/traps.h> #include <asm/uv/uv.h> #include <asm/uv/uv_hub.h> #include <asm/uv/uv_mmrs.h> @@ -153,8 +156,9 @@ module_param_named(retry_count, uv_nmi_retry_count, int, 0644); * "dump" - dump process stack for each cpu * "ips" - dump IP info for each cpu * "kdump" - do crash dump + * "kdb" - enter KDB/KGDB (default) */ -static char uv_nmi_action[8] = "dump"; +static char uv_nmi_action[8] = "kdb"; module_param_string(action, uv_nmi_action, sizeof(uv_nmi_action), 0644); static inline bool uv_nmi_action_is(const char *action) @@ -540,6 +544,43 @@ static inline void uv_nmi_kdump(int cpu, int master, struct pt_regs *regs) } #endif /* !CONFIG_KEXEC */ +#ifdef CONFIG_KGDB_KDB +/* Call KDB from NMI handler */ +static void uv_call_kdb(int cpu, struct pt_regs *regs, int master) +{ + int ret; + + if (master) { + /* call KGDB NMI handler as MASTER */ + ret = kgdb_nmicallin(cpu, X86_TRAP_NMI, regs, + &uv_nmi_slave_continue); + if (ret) { + pr_alert("KDB returned error, is kgdboc set?\n"); + atomic_set(&uv_nmi_slave_continue, SLAVE_EXIT); + } + } else { + /* wait for KGDB signal that it's ready for slaves to enter */ + int sig; + + do { + cpu_relax(); + sig = atomic_read(&uv_nmi_slave_continue); + } while (!sig); + + /* call KGDB as slave */ + if (sig == SLAVE_CONTINUE) + kgdb_nmicallback(cpu, regs); + } + uv_nmi_sync_exit(master); +} + +#else /* !CONFIG_KGDB_KDB */ +static inline void uv_call_kdb(int cpu, struct pt_regs *regs, int master) +{ + pr_err("UV: NMI error: KGDB/KDB is not enabled in this kernel\n"); +} +#endif /* !CONFIG_KGDB_KDB */ + /* * UV NMI handler */ @@ -576,6 +617,10 @@ int uv_handle_nmi(unsigned int reason, struct pt_regs *regs) if (uv_nmi_action_is("ips") || uv_nmi_action_is("dump")) uv_nmi_dump_state(cpu, regs, master); + /* Call KDB if enabled */ + else if (uv_nmi_action_is("kdb")) + uv_call_kdb(cpu, regs, master); + /* Clear per_cpu "in nmi" flag */ atomic_set(&uv_cpu_nmi.state, UV_NMI_STATE_OUT); ^ permalink raw reply related [flat|nested] 6+ messages in thread
end of thread, other threads:[~2013-10-04 17:31 UTC | newest] Thread overview: 6+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2013-10-02 15:14 [PATCH 0/2] Add back capability of calling KGDB/KDB via UV NMI call Mike Travis 2013-10-02 15:14 ` [PATCH 1/2] KGDB/KDB: add support for external NMI handler to call KGDB/KDB Mike Travis 2013-10-03 7:04 ` Ingo Molnar 2013-10-04 17:31 ` [tip:x86/uv] kdb: Add " tip-bot for Mike Travis 2013-10-02 15:14 ` [PATCH 2/2] x86/UV: Add call to KGDB/KDB from NMI handler Mike Travis 2013-10-04 17:31 ` [tip:x86/uv] " tip-bot for Mike Travis
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox