Merge tag 'kgdb-4.21-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/danielt...
authorLinus Torvalds <torvalds@linux-foundation.org>
Tue, 1 Jan 2019 23:38:14 +0000 (15:38 -0800)
committerLinus Torvalds <torvalds@linux-foundation.org>
Tue, 1 Jan 2019 23:38:14 +0000 (15:38 -0800)
Pull kgdb updates from Daniel Thompson:
 "Mostly clean ups although while Doug's was chasing down a odd lockdep
  warning he also did some work to improved debugger resilience when
  some CPUs fail to respond to the round up request.

  The main changes are:

   - Fixing a lockdep warning on architectures that cannot use an NMI
     for the round up plus related changes to make CPU round up and all
     CPU backtrace more resilient.

   - Constify the arch ops tables

   - A couple of other small clean ups

  Two of the three patchsets here include changes that spill over into
  arch/. Changes in the arch space are relatively narrow in scope (and
  directly related to kgdb). Didn't get comprehensive acks but all
  impacted maintainers were Cc:ed in good time"

* tag 'kgdb-4.21-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/danielt/linux:
  kgdb/treewide: constify struct kgdb_arch arch_kgdb_ops
  mips/kgdb: prepare arch_kgdb_ops for constness
  kdb: use bool for binary state indicators
  kdb: Don't back trace on a cpu that didn't round up
  kgdb: Don't round up a CPU that failed rounding up before
  kgdb: Fix kgdb_roundup_cpus() for arches who used smp_call_function()
  kgdb: Remove irq flags from roundup

20 files changed:
arch/arc/kernel/kgdb.c
arch/arm/kernel/kgdb.c
arch/arm64/kernel/kgdb.c
arch/h8300/kernel/kgdb.c
arch/hexagon/kernel/kgdb.c
arch/microblaze/kernel/kgdb.c
arch/mips/kernel/kgdb.c
arch/nios2/kernel/kgdb.c
arch/powerpc/kernel/kgdb.c
arch/sh/kernel/kgdb.c
arch/sparc/kernel/kgdb_32.c
arch/sparc/kernel/kgdb_64.c
arch/sparc/kernel/smp_64.c
arch/x86/kernel/kgdb.c
include/linux/kgdb.h
kernel/debug/debug_core.c
kernel/debug/debug_core.h
kernel/debug/kdb/kdb_bt.c
kernel/debug/kdb/kdb_debugger.c
kernel/debug/kdb/kdb_main.c

index 9a3c34af2ae8104e3a6735aa00cdedd8b1904371..96bca9963c6334bc5387189ecd4a1f9194787738 100644 (file)
@@ -192,19 +192,13 @@ void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long ip)
        instruction_pointer(regs) = ip;
 }
 
-static void kgdb_call_nmi_hook(void *ignored)
+void kgdb_call_nmi_hook(void *ignored)
 {
+       /* Default implementation passes get_irq_regs() but we don't */
        kgdb_nmicallback(raw_smp_processor_id(), NULL);
 }
 
-void kgdb_roundup_cpus(unsigned long flags)
-{
-       local_irq_enable();
-       smp_call_function(kgdb_call_nmi_hook, NULL, 0);
-       local_irq_disable();
-}
-
-struct kgdb_arch arch_kgdb_ops = {
+const struct kgdb_arch arch_kgdb_ops = {
        /* breakpoint instruction: TRAP_S 0x3 */
 #ifdef CONFIG_CPU_BIG_ENDIAN
        .gdb_bpt_instr          = {0x78, 0x7e},
index caa0dbe3dc6156b6f1d36db227ab11346157322a..6a95b92966406c2db3693c8ca5611eec5146fe76 100644 (file)
@@ -170,18 +170,6 @@ static struct undef_hook kgdb_compiled_brkpt_hook = {
        .fn                     = kgdb_compiled_brk_fn
 };
 
-static void kgdb_call_nmi_hook(void *ignored)
-{
-       kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs());
-}
-
-void kgdb_roundup_cpus(unsigned long flags)
-{
-       local_irq_enable();
-       smp_call_function(kgdb_call_nmi_hook, NULL, 0);
-       local_irq_disable();
-}
-
 static int __kgdb_notify(struct die_args *args, unsigned long cmd)
 {
        struct pt_regs *regs = args->regs;
@@ -274,7 +262,7 @@ int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
  * and we handle the normal undef case within the do_undefinstr
  * handler.
  */
-struct kgdb_arch arch_kgdb_ops = {
+const struct kgdb_arch arch_kgdb_ops = {
 #ifndef __ARMEB__
        .gdb_bpt_instr          = {0xfe, 0xde, 0xff, 0xe7}
 #else /* ! __ARMEB__ */
index a20de58061a8e62b271a17a6da700ffd884db620..ce46c4cdf368dcf18dfbd318fd3ceda7aec5fc1d 100644 (file)
@@ -284,18 +284,6 @@ static struct step_hook kgdb_step_hook = {
        .fn             = kgdb_step_brk_fn
 };
 
-static void kgdb_call_nmi_hook(void *ignored)
-{
-       kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs());
-}
-
-void kgdb_roundup_cpus(unsigned long flags)
-{
-       local_irq_enable();
-       smp_call_function(kgdb_call_nmi_hook, NULL, 0);
-       local_irq_disable();
-}
-
 static int __kgdb_notify(struct die_args *args, unsigned long cmd)
 {
        struct pt_regs *regs = args->regs;
@@ -357,7 +345,7 @@ void kgdb_arch_exit(void)
        unregister_die_notifier(&kgdb_notifier);
 }
 
-struct kgdb_arch arch_kgdb_ops;
+const struct kgdb_arch arch_kgdb_ops;
 
 int kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
 {
index 1a1d30cb0609c60cc3a92528060a10f1f4d286e4..602e478afbd5800eab9ba03277bf7d4db36336f0 100644 (file)
@@ -129,7 +129,7 @@ void kgdb_arch_exit(void)
        /* Nothing to do */
 }
 
-struct kgdb_arch arch_kgdb_ops = {
+const struct kgdb_arch arch_kgdb_ops = {
        /* Breakpoint instruction: trapa #2 */
        .gdb_bpt_instr = { 0x57, 0x20 },
 };
index 16c24b22d0b269cc2dca516d2a1ba76ec04e72a2..3fabd3ff3bbd03e9b28800807a76f12f76617b49 100644 (file)
@@ -83,7 +83,7 @@ struct dbg_reg_def_t dbg_reg_def[DBG_MAX_REG_NUM] = {
        { "syscall_nr", GDB_SIZEOF_REG, offsetof(struct pt_regs, syscall_nr)},
 };
 
-struct kgdb_arch arch_kgdb_ops = {
+const struct kgdb_arch arch_kgdb_ops = {
        /* trap0(#0xDB) 0x0cdb0054 */
        .gdb_bpt_instr = {0x54, 0x00, 0xdb, 0x0c},
 };
@@ -115,38 +115,6 @@ void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc)
        instruction_pointer(regs) = pc;
 }
 
-#ifdef CONFIG_SMP
-
-/**
- * kgdb_roundup_cpus - Get other CPUs into a holding pattern
- * @flags: Current IRQ state
- *
- * 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
- * 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,
- * in case of MIPS, smp_call_function() is used to roundup CPUs. In
- * this case, we have to make sure that interrupts are enabled before
- * calling smp_call_function(). The argument to this function is
- * the flags that will be used when restoring the interrupts. There is
- * local_irq_save() call before kgdb_roundup_cpus().
- *
- * On non-SMP systems, this is not called.
- */
-
-static void hexagon_kgdb_nmi_hook(void *ignored)
-{
-       kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs());
-}
-
-void kgdb_roundup_cpus(unsigned long flags)
-{
-       local_irq_enable();
-       smp_call_function(hexagon_kgdb_nmi_hook, NULL, 0);
-       local_irq_disable();
-}
-#endif
-
 
 /*  Not yet working  */
 void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs,
index 6366f69d118ecd1af77d8910023ed92afaf7329b..130cd0f064cebcb58b8ea35bb32a53ad0f10964a 100644 (file)
@@ -143,7 +143,7 @@ void kgdb_arch_exit(void)
 /*
  * Global data
  */
-struct kgdb_arch arch_kgdb_ops = {
+const struct kgdb_arch arch_kgdb_ops = {
 #ifdef __MICROBLAZEEL__
        .gdb_bpt_instr = {0x18, 0x00, 0x0c, 0xba}, /* brki r16, 0x18 */
 #else
index eb6c0d582626b114fcb8d30f9fb28ee3472e8cc9..149100e1bc7c4687903d929e6b9a33700b199454 100644 (file)
@@ -207,7 +207,7 @@ void arch_kgdb_breakpoint(void)
                ".set\treorder");
 }
 
-static void kgdb_call_nmi_hook(void *ignored)
+void kgdb_call_nmi_hook(void *ignored)
 {
        mm_segment_t old_fs;
 
@@ -219,13 +219,6 @@ static void kgdb_call_nmi_hook(void *ignored)
        set_fs(old_fs);
 }
 
-void kgdb_roundup_cpus(unsigned long flags)
-{
-       local_irq_enable();
-       smp_call_function(kgdb_call_nmi_hook, NULL, 0);
-       local_irq_disable();
-}
-
 static int compute_signal(int tt)
 {
        struct hard_trap_info *ht;
@@ -394,18 +387,16 @@ int kgdb_arch_handle_exception(int vector, int signo, int err_code,
        return -1;
 }
 
-struct kgdb_arch arch_kgdb_ops;
+const struct kgdb_arch arch_kgdb_ops = {
+#ifdef CONFIG_CPU_BIG_ENDIAN
+       .gdb_bpt_instr = { spec_op << 2, 0x00, 0x00, break_op },
+#else
+       .gdb_bpt_instr = { break_op, 0x00, 0x00, spec_op << 2 },
+#endif
+};
 
 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;
index 117859122d1caf963365f718f8b330544c0a61db..37b25f844a2de7b2db8a84fbcba9a537cf29365e 100644 (file)
@@ -165,7 +165,7 @@ void kgdb_arch_exit(void)
        /* Nothing to do */
 }
 
-struct kgdb_arch arch_kgdb_ops = {
+const struct kgdb_arch arch_kgdb_ops = {
        /* Breakpoint instruction: trap 30 */
        .gdb_bpt_instr = { 0xba, 0x6f, 0x3b, 0x00 },
 };
index 59c578f865aa69c9fe8dce7d47962fe58877d079..e1865565f0aeead6284fa396614faf56143f9f9b 100644 (file)
@@ -117,14 +117,14 @@ int kgdb_skipexception(int exception, struct pt_regs *regs)
        return kgdb_isremovedbreak(regs->nip);
 }
 
-static int kgdb_call_nmi_hook(struct pt_regs *regs)
+static int kgdb_debugger_ipi(struct pt_regs *regs)
 {
        kgdb_nmicallback(raw_smp_processor_id(), regs);
        return 0;
 }
 
 #ifdef CONFIG_SMP
-void kgdb_roundup_cpus(unsigned long flags)
+void kgdb_roundup_cpus(void)
 {
        smp_send_debugger_break();
 }
@@ -477,7 +477,7 @@ int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
 /*
  * Global data
  */
-struct kgdb_arch arch_kgdb_ops;
+const struct kgdb_arch arch_kgdb_ops;
 
 static int kgdb_not_implemented(struct pt_regs *regs)
 {
@@ -502,7 +502,7 @@ int kgdb_arch_init(void)
        old__debugger_break_match = __debugger_break_match;
        old__debugger_fault_handler = __debugger_fault_handler;
 
-       __debugger_ipi = kgdb_call_nmi_hook;
+       __debugger_ipi = kgdb_debugger_ipi;
        __debugger = kgdb_debugger;
        __debugger_bpt = kgdb_handle_breakpoint;
        __debugger_sstep = kgdb_singlestep;
index d24bd2d2ffad2dcc5566893c349b6d0b9fd0547d..6d61f8cf4c131dac3b48b33acc4635f85814a32e 100644 (file)
@@ -311,18 +311,6 @@ BUILD_TRAP_HANDLER(singlestep)
        local_irq_restore(flags);
 }
 
-static void kgdb_call_nmi_hook(void *ignored)
-{
-       kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs());
-}
-
-void kgdb_roundup_cpus(unsigned long flags)
-{
-       local_irq_enable();
-       smp_call_function(kgdb_call_nmi_hook, NULL, 0);
-       local_irq_disable();
-}
-
 static int __kgdb_notify(struct die_args *args, unsigned long cmd)
 {
        int ret;
@@ -379,7 +367,7 @@ void kgdb_arch_exit(void)
        unregister_die_notifier(&kgdb_notifier);
 }
 
-struct kgdb_arch arch_kgdb_ops = {
+const struct kgdb_arch arch_kgdb_ops = {
        /* Breakpoint instruction: trapa #0x3c */
 #ifdef CONFIG_CPU_LITTLE_ENDIAN
        .gdb_bpt_instr          = { 0x3c, 0xc3 },
index 639c8e54530aa56c8493b3676b63b0192025571b..7580775a14b9e71567252dae142f5bb111efdcf8 100644 (file)
@@ -166,7 +166,7 @@ void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long ip)
        regs->npc = regs->pc + 4;
 }
 
-struct kgdb_arch arch_kgdb_ops = {
+const struct kgdb_arch arch_kgdb_ops = {
        /* Breakpoint instruction: ta 0x7d */
        .gdb_bpt_instr          = { 0x91, 0xd0, 0x20, 0x7d },
 };
index a68bbddbdba4702727247f5c4c5a8d35d9426398..5d6c2d287e85533fafba6b9c3fb8243a32e4de93 100644 (file)
@@ -195,7 +195,7 @@ void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long ip)
        regs->tnpc = regs->tpc + 4;
 }
 
-struct kgdb_arch arch_kgdb_ops = {
+const struct kgdb_arch arch_kgdb_ops = {
        /* Breakpoint instruction: ta 0x72 */
        .gdb_bpt_instr          = { 0x91, 0xd0, 0x20, 0x72 },
 };
index 4792e08ad36b0116f5bb4948d1deb0e19ca30405..f45d876983f152fbda3ecab15e2a4a37be82c40e 100644 (file)
@@ -1014,7 +1014,7 @@ void flush_dcache_page_all(struct mm_struct *mm, struct page *page)
 }
 
 #ifdef CONFIG_KGDB
-void kgdb_roundup_cpus(unsigned long flags)
+void kgdb_roundup_cpus(void)
 {
        smp_cross_call(&xcall_kgdb_capture, 0, 0, 0);
 }
index 8e36f249646e25d20bc2bcc04b7a0ccc292e498c..5db08425063edef59a449760ac8c67c95409f742 100644 (file)
@@ -422,21 +422,16 @@ static void kgdb_disable_hw_debug(struct pt_regs *regs)
 #ifdef CONFIG_SMP
 /**
  *     kgdb_roundup_cpus - Get other CPUs into a holding pattern
- *     @flags: Current IRQ state
  *
  *     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
  *     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,
- *     in case of MIPS, smp_call_function() is used to roundup CPUs. In
- *     this case, we have to make sure that interrupts are enabled before
- *     calling smp_call_function(). The argument to this function is
- *     the flags that will be used when restoring the interrupts. There is
- *     local_irq_save() call before kgdb_roundup_cpus().
+ *     in case of MIPS, smp_call_function() is used to roundup CPUs.
  *
  *     On non-SMP systems, this is not called.
  */
-void kgdb_roundup_cpus(unsigned long flags)
+void kgdb_roundup_cpus(void)
 {
        apic->send_IPI_allbutself(APIC_DM_NMI);
 }
@@ -804,7 +799,7 @@ knl_write:
                                  (char *)bpt->saved_instr, BREAK_INSTR_SIZE);
 }
 
-struct kgdb_arch arch_kgdb_ops = {
+const struct kgdb_arch arch_kgdb_ops = {
        /* Breakpoint instruction: */
        .gdb_bpt_instr          = { 0xcc },
        .flags                  = KGDB_HW_BREAKPOINT,
index e465bb15912d98cd1136f985a110bf0347667bd1..fbf144aaa7491ad952db5935b738b925e0195659 100644 (file)
@@ -176,23 +176,29 @@ kgdb_arch_handle_exception(int vector, int signo, int err_code,
                           char *remcom_out_buffer,
                           struct pt_regs *regs);
 
+/**
+ *     kgdb_call_nmi_hook - Call kgdb_nmicallback() on the current CPU
+ *     @ignored: This parameter is only here to match the prototype.
+ *
+ *     If you're using the default implementation of kgdb_roundup_cpus()
+ *     this function will be called per CPU.  If you don't implement
+ *     kgdb_call_nmi_hook() a default will be used.
+ */
+
+extern void kgdb_call_nmi_hook(void *ignored);
+
 /**
  *     kgdb_roundup_cpus - Get other CPUs into a holding pattern
- *     @flags: Current IRQ state
  *
  *     On SMP systems, we need to get the attention of the other CPUs
  *     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,
- *     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
- *     this case, we have to make sure that interrupts are enabled before
- *     calling smp_call_function(). The argument to this function is
- *     the flags that will be used when restoring the interrupts. There is
- *     local_irq_save() call before kgdb_roundup_cpus().
+ *     the NMI approach is not used for rounding up all the CPUs.  Normally
+ *     those architectures can just not implement this and get the default.
  *
  *     On non-SMP systems, this is not called.
  */
-extern void kgdb_roundup_cpus(unsigned long flags);
+extern void kgdb_roundup_cpus(void);
 
 /**
  *     kgdb_arch_set_pc - Generic call back to the program counter
@@ -281,7 +287,7 @@ struct kgdb_io {
        int                     is_console;
 };
 
-extern struct kgdb_arch                arch_kgdb_ops;
+extern const struct kgdb_arch          arch_kgdb_ops;
 
 extern unsigned long kgdb_arch_pc(int exception, struct pt_regs *regs);
 
index 65c0f13637882d50fe1da0268c9290933556750a..5cc608de6883127e6925c6cc71ce7c89eb8b7f84 100644 (file)
@@ -55,6 +55,7 @@
 #include <linux/mm.h>
 #include <linux/vmacache.h>
 #include <linux/rcupdate.h>
+#include <linux/irq.h>
 
 #include <asm/cacheflush.h>
 #include <asm/byteorder.h>
@@ -220,6 +221,62 @@ int __weak kgdb_skipexception(int exception, struct pt_regs *regs)
        return 0;
 }
 
+#ifdef CONFIG_SMP
+
+/*
+ * Default (weak) implementation for kgdb_roundup_cpus
+ */
+
+static DEFINE_PER_CPU(call_single_data_t, kgdb_roundup_csd);
+
+void __weak kgdb_call_nmi_hook(void *ignored)
+{
+       /*
+        * NOTE: get_irq_regs() is supposed to get the registers from
+        * before the IPI interrupt happened and so is supposed to
+        * show where the processor was.  In some situations it's
+        * possible we might be called without an IPI, so it might be
+        * safer to figure out how to make kgdb_breakpoint() work
+        * properly here.
+        */
+       kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs());
+}
+
+void __weak kgdb_roundup_cpus(void)
+{
+       call_single_data_t *csd;
+       int this_cpu = raw_smp_processor_id();
+       int cpu;
+       int ret;
+
+       for_each_online_cpu(cpu) {
+               /* No need to roundup ourselves */
+               if (cpu == this_cpu)
+                       continue;
+
+               csd = &per_cpu(kgdb_roundup_csd, cpu);
+
+               /*
+                * If it didn't round up last time, don't try again
+                * since smp_call_function_single_async() will block.
+                *
+                * If rounding_up is false then we know that the
+                * previous call must have at least started and that
+                * means smp_call_function_single_async() won't block.
+                */
+               if (kgdb_info[cpu].rounding_up)
+                       continue;
+               kgdb_info[cpu].rounding_up = true;
+
+               csd->func = kgdb_call_nmi_hook;
+               ret = smp_call_function_single_async(cpu, csd);
+               if (ret)
+                       kgdb_info[cpu].rounding_up = false;
+       }
+}
+
+#endif
+
 /*
  * Some architectures need cache flushes when we set/clear a
  * breakpoint:
@@ -535,6 +592,8 @@ return_normal:
                                arch_kgdb_ops.correct_hw_break();
                        if (trace_on)
                                tracing_on();
+                       kgdb_info[cpu].debuggerinfo = NULL;
+                       kgdb_info[cpu].task = NULL;
                        kgdb_info[cpu].exception_state &=
                                ~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
                        kgdb_info[cpu].enter_kgdb--;
@@ -593,7 +652,7 @@ return_normal:
 
        /* Signal the other CPUs to enter kgdb_wait() */
        else if ((!kgdb_single_step) && kgdb_do_roundup)
-               kgdb_roundup_cpus(flags);
+               kgdb_roundup_cpus();
 #endif
 
        /*
@@ -667,6 +726,8 @@ kgdb_restore:
        if (trace_on)
                tracing_on();
 
+       kgdb_info[cpu].debuggerinfo = NULL;
+       kgdb_info[cpu].task = NULL;
        kgdb_info[cpu].exception_state &=
                ~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
        kgdb_info[cpu].enter_kgdb--;
@@ -747,6 +808,8 @@ int kgdb_nmicallback(int cpu, void *regs)
        struct kgdb_state kgdb_var;
        struct kgdb_state *ks = &kgdb_var;
 
+       kgdb_info[cpu].rounding_up = false;
+
        memset(ks, 0, sizeof(struct kgdb_state));
        ks->cpu                 = cpu;
        ks->linux_regs          = regs;
index 127d9bc49fb4b24ea6824b12f73befc7fe870012..b4a7c326d5464c5c22f3a64311aad813c10cbcee 100644 (file)
@@ -42,6 +42,7 @@ struct debuggerinfo_struct {
        int                     ret_state;
        int                     irq_depth;
        int                     enter_kgdb;
+       bool                    rounding_up;
 };
 
 extern struct debuggerinfo_struct kgdb_info[];
index 7921ae4fca8de92513fb5b71cbc36fd96ed0e04f..7e2379aa0a1e7a2247041b497e6d747a3e05bb04 100644 (file)
@@ -186,7 +186,16 @@ kdb_bt(int argc, const char **argv)
                kdb_printf("btc: cpu status: ");
                kdb_parse("cpu\n");
                for_each_online_cpu(cpu) {
-                       sprintf(buf, "btt 0x%px\n", KDB_TSK(cpu));
+                       void *kdb_tsk = KDB_TSK(cpu);
+
+                       /* If a CPU failed to round up we could be here */
+                       if (!kdb_tsk) {
+                               kdb_printf("WARNING: no task for cpu %ld\n",
+                                          cpu);
+                               continue;
+                       }
+
+                       sprintf(buf, "btt 0x%px\n", kdb_tsk);
                        kdb_parse(buf);
                        touch_nmi_watchdog();
                }
index 15e1a7af5dd033f130ef2b4ed96cf1e2809442f5..53a0df6e4d92c9ebf59f1b4471f9be615fd5e904 100644 (file)
@@ -118,13 +118,6 @@ int kdb_stub(struct kgdb_state *ks)
        kdb_bp_remove();
        KDB_STATE_CLEAR(DOING_SS);
        KDB_STATE_SET(PAGER);
-       /* zero out any offline cpu data */
-       for_each_present_cpu(i) {
-               if (!cpu_online(i)) {
-                       kgdb_info[i].debuggerinfo = NULL;
-                       kgdb_info[i].task = NULL;
-               }
-       }
        if (ks->err_code == DIE_OOPS || reason == KDB_REASON_OOPS) {
                ks->pass_exception = 1;
                KDB_FLAG_SET(CATASTROPHIC);
index d72b32c66f7dd3ba3f5cf254b4d8a66da21d259d..82a3b32a7cfc975ea99dba2eae7bdd7e23d070e9 100644 (file)
@@ -658,7 +658,7 @@ static void kdb_cmderror(int diag)
  */
 struct defcmd_set {
        int count;
-       int usable;
+       bool usable;
        char *name;
        char *usage;
        char *help;
@@ -666,7 +666,7 @@ struct defcmd_set {
 };
 static struct defcmd_set *defcmd_set;
 static int defcmd_set_count;
-static int defcmd_in_progress;
+static bool defcmd_in_progress;
 
 /* Forward references */
 static int kdb_exec_defcmd(int argc, const char **argv);
@@ -676,9 +676,9 @@ static int kdb_defcmd2(const char *cmdstr, const char *argv0)
        struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
        char **save_command = s->command;
        if (strcmp(argv0, "endefcmd") == 0) {
-               defcmd_in_progress = 0;
+               defcmd_in_progress = false;
                if (!s->count)
-                       s->usable = 0;
+                       s->usable = false;
                if (s->usable)
                        /* macros are always safe because when executed each
                         * internal command re-enters kdb_parse() and is
@@ -695,7 +695,7 @@ static int kdb_defcmd2(const char *cmdstr, const char *argv0)
        if (!s->command) {
                kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
                           cmdstr);
-               s->usable = 0;
+               s->usable = false;
                return KDB_NOTIMP;
        }
        memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
@@ -737,7 +737,7 @@ static int kdb_defcmd(int argc, const char **argv)
               defcmd_set_count * sizeof(*defcmd_set));
        s = defcmd_set + defcmd_set_count;
        memset(s, 0, sizeof(*s));
-       s->usable = 1;
+       s->usable = true;
        s->name = kdb_strdup(argv[1], GFP_KDB);
        if (!s->name)
                goto fail_name;
@@ -756,7 +756,7 @@ static int kdb_defcmd(int argc, const char **argv)
                s->help[strlen(s->help)-1] = '\0';
        }
        ++defcmd_set_count;
-       defcmd_in_progress = 1;
+       defcmd_in_progress = true;
        kfree(save_defcmd_set);
        return 0;
 fail_help: