Skip to contentSkip to conversation

kgdb fixes for 2.6.34-rc2

GIT PULL New Jason Wessel 2 participants 12 messages Mar 22, 2010 – Apr 2, 2010

Subsystems (2)
lore
Share & tools
lore

Jason Wessel

author maintainer
#0 lore raw

Linus, please pull the kgdb-fixes for 2.6.34.

git://git.kernel.org/pub/scm/linux/kernel/git/jwessel/linux-2.6-kgdb.git kgdb-fixes

Summary:
* The first 2 patches are the gdbstub and debug core split from the kdb tree
* The rest are the fixes cherry picked from the kdb pull request

The previous kdb pull will require a rebase if you accept the kgdb fixes because there were patch splits that occurred to make this patch set.

Thanks,
Jason.

---
The following changes since commit 220bf991b0366cc50a94feede3d7341fa5710ee4:
Linus Torvalds (1):

        Linux 2.6.34-rc2

are available in the git repository at:

Jason Wessel (8):
Move kernel/kgdb.c to kernel/debug/debug_core.c Separate the gdbstub from the debug core
kgdb: eliminate kgdb_wait(), all cpus enter the same way
kgdb: have ebin2mem call probe_kernel_write once kgdb,debug_core: Use atomic operators which use barriers kgdbts,sh: Add in breakpoint pc offset for superh
debug_core: Turn off tracing while in the debugger
MAINTAINERS: update kgdb, and debug_core info

 MAINTAINERS               |    5 +-
 drivers/misc/kgdbts.c     |    6 +
 include/linux/kgdb.h      |    1 +
 kernel/Makefile           |    2 +-
 kernel/debug/Makefile     |    5 +
 kernel/debug/debug_core.c |  848 ++++++++++++++++++++++
 kernel/debug/debug_core.h |   55 ++
 kernel/debug/gdbstub.c    |  934 ++++++++++++++++++++++++
 kernel/kgdb.c             | 1763 ---------------------------------------------
 9 files changed, 1853 insertions(+), 1766 deletions(-)
 create mode 100644 kernel/debug/Makefile
 create mode 100644 kernel/debug/debug_core.c
 create mode 100644 kernel/debug/debug_core.h
 create mode 100644 kernel/debug/gdbstub.c
 delete mode 100644 kernel/kgdb.c
author maintainer
#1 lore raw

PATCH 1/8 Move kernel/kgdb.c to kernel/debug/debug_core.c

Move kgdb.c in preparation to separate the gdbstub from the debug core and exception handling.

---
 kernel/Makefile                       |    2 +-
 kernel/debug/Makefile                 |    5 +++++
 kernel/{kgdb.c => debug/debug_core.c} |    0
 3 files changed, 6 insertions(+), 1 deletions(-)
 create mode 100644 kernel/debug/Makefile
 rename kernel/{kgdb.c => debug/debug_core.c} (100%)
kernel/Makefile +1 -1
index a987aa1..80b17ce 100644
@@ -75,7 +75,7 @@ obj-$(CONFIG_AUDITSYSCALL) += auditsc.o
 obj-$(CONFIG_GCOV_KERNEL) += gcov/
 obj-$(CONFIG_AUDIT_TREE) += audit_tree.o
 obj-$(CONFIG_KPROBES) += kprobes.o
-obj-$(CONFIG_KGDB) += kgdb.o
+obj-$(CONFIG_KGDB) += debug/
 obj-$(CONFIG_DETECT_SOFTLOCKUP) += softlockup.o
 obj-$(CONFIG_DETECT_HUNG_TASK) += hung_task.o
 obj-$(CONFIG_GENERIC_HARDIRQS) += irq/
kernel/debug/Makefile new file +5 -0
new file mode 100644
index 0000000..5287fc8
@@ -0,0 +1,5 @@
+#
+# Makefile for the linux kernel debugger
+#
+
+obj-$(CONFIG_KGDB) += debug_core.o
\ No newline at end of file
kernel/debug/debug_core.c renamed from kernel/kgdb.c +0 -0
similarity index 100%
rename from kernel/kgdb.c
rename to kernel/debug/debug_core.c
Signature · 1 line
1.6.4.rc1
author maintainer
#2 lore raw

PATCH 2/8 Separate the gdbstub from the debug core

Split the former kernel/kgdb.c into debug_core.c which contains the kernel debugger exception logic and to the gdbstub.c which contains the logic for allowing gdb to talk to the debug core.

This also created a private include file called debug_core.h which contains all the definitions to glue the debug_core to any other debugger connections.

---
 include/linux/kgdb.h      |    1 +
 kernel/debug/Makefile     |    2 +-
 kernel/debug/debug_core.c |  992 ++-------------------------------------------
 kernel/debug/debug_core.h |   48 +++
 kernel/debug/gdbstub.c    |  939 ++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 1028 insertions(+), 954 deletions(-)
 create mode 100644 kernel/debug/debug_core.h
 create mode 100644 kernel/debug/gdbstub.c
include/linux/kgdb.h +1 -0
index 19ec41a..4830142 100644
@@ -264,6 +264,7 @@ extern unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs);
 
 extern int kgdb_register_io_module(struct kgdb_io *local_kgdb_io_ops);
 extern void kgdb_unregister_io_module(struct kgdb_io *local_kgdb_io_ops);
+extern struct kgdb_io *dbg_io_ops;
 
 extern int kgdb_hex2long(char **ptr, unsigned long *long_val);
 extern int kgdb_mem2hex(char *mem, char *buf, int count);
kernel/debug/Makefile +1 -1
index 5287fc8..3657c64 100644
@@ -2,4 +2,4 @@
 # Makefile for the linux kernel debugger
 #
 
-obj-$(CONFIG_KGDB) += debug_core.o
\ No newline at end of file
+obj-$(CONFIG_KGDB) += debug_core.o gdbstub.o
\ No newline at end of file
kernel/debug/debug_core.c +39 -953

1,190 lines not on this page · raw message

kernel/debug/debug_core.h new file +48 -0

48 lines not on this page · raw message

kernel/debug/gdbstub.c new file +939 -0

939 lines not on this page · raw message

Signature · 1 line
1.6.4.rc1
author maintainer
#3 lore raw

PATCH 3/8 kgdb: eliminate kgdb_wait(), all cpus enter the same way

This is a kgdb architectural change to have all the cpus (master or slave) enter the same function.

A cpu that hits an exception (wants to be the master cpu) will call kgdb_handle_exception() from the trap handler and then invoke a kgdb_roundup_cpu() to synchronize the other cpus and bring them into the kgdb_handle_exception() as well.

A slave cpu will enter kgdb_handle_exception() from the kgdb_nmicallback() and set the exception state to note that the processor is a slave.

Previously the salve cpu would have called kgdb_wait(). This change allows the debug core to change cpus without resuming the system in order to inspect arch specific cpu information.

---
 kernel/debug/debug_core.c |  158 +++++++++++++++++++++-----------------------
 kernel/debug/debug_core.h |    7 ++
 2 files changed, 82 insertions(+), 83 deletions(-)
kernel/debug/debug_core.c +75 -83
index ad3caaa..91286e8 100644
@@ -215,49 +215,6 @@ void __weak kgdb_disable_hw_debug(struct pt_regs *regs)
 }
 
 /*
- * CPU debug state control:
- */
-
-#ifdef CONFIG_SMP
-static void kgdb_wait(struct pt_regs *regs)
-{
-	unsigned long flags;
-	int cpu;
-
-	local_irq_save(flags);
-	cpu = raw_smp_processor_id();
-	kgdb_info[cpu].debuggerinfo = regs;
-	kgdb_info[cpu].task = current;
-	/*
-	 * Make sure the above info reaches the primary CPU before
-	 * our cpu_in_kgdb[] flag setting does:
-	 */
-	smp_wmb();
-	atomic_set(&cpu_in_kgdb[cpu], 1);
-
-	/* Disable any cpu specific hw breakpoints */
-	kgdb_disable_hw_debug(regs);
-
-	/* Wait till primary CPU is done with debugging */
-	while (atomic_read(&passive_cpu_wait[cpu]))
-		cpu_relax();
-
-	kgdb_info[cpu].debuggerinfo = NULL;
-	kgdb_info[cpu].task = NULL;
-
-	/* fix up hardware debug registers on local cpu */
-	if (arch_kgdb_ops.correct_hw_break)
-		arch_kgdb_ops.correct_hw_break();
-
-	/* Signal the primary CPU that we are done: */
-	atomic_set(&cpu_in_kgdb[cpu], 0);
-	touch_softlockup_watchdog_sync();
-	clocksource_touch_watchdog();
-	local_irq_restore(flags);
-}
-#endif
-
-/*
  * Some architectures need cache flushes when we set/clear a
  * breakpoint:
  */
@@ -486,34 +443,12 @@ static int kgdb_reenter_check(struct kgdb_state *ks)
 	return 1;
 }
 
-/*
- * kgdb_handle_exception() - main entry point from a kernel exception
- *
- * Locking hierarchy:
- *	interface locks, if any (begin_session)
- *	kgdb lock (kgdb_active)
- */
-int
-kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs)
+static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs)
 {
-	struct kgdb_state kgdb_var;
-	struct kgdb_state *ks = &kgdb_var;
 	unsigned long flags;
 	int sstep_tries = 100;
 	int error = 0;
 	int i, cpu;
-
-	ks->cpu			= raw_smp_processor_id();
-	ks->ex_vector		= evector;
-	ks->signo		= signo;
-	ks->ex_vector		= evector;
-	ks->err_code		= ecode;
-	ks->kgdb_usethreadid	= 0;
-	ks->linux_regs		= regs;
-
-	if (kgdb_reenter_check(ks))
-		return 0; /* Ouch, double exception ! */
-
 acquirelock:
 	/*
 	 * Interrupts will be restored by the 'trap return' code, except when
@@ -521,13 +456,42 @@ acquirelock:
 	 */
 	local_irq_save(flags);
 
-	cpu = raw_smp_processor_id();
+	cpu = ks->cpu;
+	kgdb_info[cpu].debuggerinfo = regs;
+	kgdb_info[cpu].task = current;
+	/*
+	 * Make sure the above info reaches the primary CPU before
+	 * our cpu_in_kgdb[] flag setting does:
+	 */
+	smp_wmb();
+	atomic_set(&cpu_in_kgdb[cpu], 1);
 
 	/*
-	 * Acquire the kgdb_active lock:
+	 * CPU will loop if it is a slave or request to become a kgdb
+	 * master cpu and acquire the kgdb_active lock:
 	 */
-	while (atomic_cmpxchg(&kgdb_active, -1, cpu) != -1)
+	while (1) {
+		if (kgdb_info[cpu].exception_state & DCPU_WANT_MASTER) {
+			if (atomic_cmpxchg(&kgdb_active, -1, cpu) == cpu)
+				break;
+		} else if (kgdb_info[cpu].exception_state & DCPU_IS_SLAVE) {
+			if (!atomic_read(&passive_cpu_wait[cpu]))
+				goto return_normal;
+		} else {
+return_normal:
+			/* Return to normal operation by executing any
+			 * hw breakpoint fixup.
+			 */
+			if (arch_kgdb_ops.correct_hw_break)
+				arch_kgdb_ops.correct_hw_break();
+			atomic_set(&cpu_in_kgdb[cpu], 0);
+			touch_softlockup_watchdog_sync();
+			clocksource_touch_watchdog();
+			local_irq_restore(flags);
+			return 0;
+		}
 		cpu_relax();
+	}
 
 	/*
 	 * For single stepping, try to only enter on the processor
@@ -561,9 +525,6 @@ acquirelock:
 	if (dbg_io_ops->pre_exception)
 		dbg_io_ops->pre_exception();
 
-	kgdb_info[ks->cpu].debuggerinfo = ks->linux_regs;
-	kgdb_info[ks->cpu].task = current;
-
 	kgdb_disable_hw_debug(ks->linux_regs);
 
 	/*
@@ -575,12 +536,6 @@ acquirelock:
 			atomic_set(&passive_cpu_wait[i], 1);
 	}
 
-	/*
-	 * spin_lock code is good enough as a barrier so we don't
-	 * need one here:
-	 */
-	atomic_set(&cpu_in_kgdb[ks->cpu], 1);
-
 #ifdef CONFIG_SMP
 	/* Signal the other CPUs to enter kgdb_wait() */
 	if ((!kgdb_single_step) && kgdb_do_roundup)
@@ -612,8 +567,6 @@ acquirelock:
 	if (dbg_io_ops->post_exception)
 		dbg_io_ops->post_exception();
 
-	kgdb_info[ks->cpu].debuggerinfo = NULL;
-	kgdb_info[ks->cpu].task = NULL;
 	atomic_set(&cpu_in_kgdb[ks->cpu], 0);
 
 	if (!kgdb_single_step) {
@@ -646,13 +599,52 @@ kgdb_restore:
 	return error;
 }
 
+/*
+ * kgdb_handle_exception() - main entry point from a kernel exception
+ *
+ * Locking hierarchy:
+ *	interface locks, if any (begin_session)
+ *	kgdb lock (kgdb_active)
+ */
+int
+kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs)
+{
+	struct kgdb_state kgdb_var;
+	struct kgdb_state *ks = &kgdb_var;
+	int ret;
+
+	ks->cpu			= raw_smp_processor_id();
+	ks->ex_vector		= evector;
+	ks->signo		= signo;
+	ks->ex_vector		= evector;
+	ks->err_code		= ecode;
+	ks->kgdb_usethreadid	= 0;
+	ks->linux_regs		= regs;
+
+	if (kgdb_reenter_check(ks))
+		return 0; /* Ouch, double exception ! */
+	kgdb_info[ks->cpu].exception_state |= DCPU_WANT_MASTER;
+	ret = kgdb_cpu_enter(ks, regs);
+	kgdb_info[ks->cpu].exception_state &= ~DCPU_WANT_MASTER;
+	return ret;
+}
+
 int kgdb_nmicallback(int cpu, void *regs)
 {
 #ifdef CONFIG_SMP
+	struct kgdb_state kgdb_var;
+	struct kgdb_state *ks = &kgdb_var;
+
+	memset(ks, 0, sizeof(struct kgdb_state));
+	ks->cpu			= cpu;
+	ks->linux_regs		= regs;
+
 	if (!atomic_read(&cpu_in_kgdb[cpu]) &&
-			atomic_read(&kgdb_active) != cpu &&
-			atomic_read(&cpu_in_kgdb[atomic_read(&kgdb_active)])) {
-		kgdb_wait((struct pt_regs *)regs);
+	    atomic_read(&kgdb_active) != -1 &&
+	    atomic_read(&kgdb_active) != cpu) {
+		kgdb_info[cpu].exception_state |= DCPU_IS_SLAVE;
+		kgdb_cpu_enter(ks, regs);
+		kgdb_info[cpu].exception_state &= ~DCPU_IS_SLAVE;
 		return 0;
 	}
 #endif
kernel/debug/debug_core.h +7 -0
index 4b9d512..9825c5e 100644
@@ -28,9 +28,16 @@ struct kgdb_state {
 	struct pt_regs		*linux_regs;
 };
 
+/* Exception state values */
+#define DCPU_WANT_MASTER 0x1 /* Waiting to become a master kgdb cpu */
+#define DCPU_NEXT_MASTER 0x2 /* Transition from one master cpu to another */
+#define DCPU_IS_SLAVE    0x4 /* Slave cpu enter exception */
+#define DCPU_SSTEP       0x8 /* CPU is single stepping */
+
 struct debuggerinfo_struct {
 	void			*debuggerinfo;
 	struct task_struct	*task;
+	int exception_state;
 };
 
 extern struct debuggerinfo_struct kgdb_info[];
Signature · 1 line
1.6.4.rc1
author maintainer
#4 lore raw

PATCH 4/8 kgdb: have ebin2mem call probe_kernel_write once

Rather than call probe_kernel_write() one byte at a time, process the whole buffer locally and pass the entire result in one go. This way, architectures that need to do special handling based on the length can do so, or we only end up calling memcpy() once.

[[email protected]: Reported original problem and preliminary patch]

---
 kernel/debug/gdbstub.c |   23 +++++++++--------------
 1 files changed, 9 insertions(+), 14 deletions(-)
kernel/debug/gdbstub.c +9 -14
index ab29bce..ccdf092 100644
@@ -293,27 +293,22 @@ int kgdb_hex2long(char **ptr, unsigned long *long_val)
 
 /*
  * 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.
+ * 0x7d escaped with 0x7d. Return -EFAULT on failure or 0 on success.
+ * The input buf is overwitten with the result to write to mem.
  */
 static int kgdb_ebin2mem(char *buf, char *mem, int count)
 {
-	int err = 0;
-	char c;
+	int size = 0;
+	char *c = buf;
 
 	while (count-- > 0) {
-		c = *buf++;
-		if (c == 0x7d)
-			c = *buf++ ^ 0x20;
-
-		err = probe_kernel_write(mem, &c, 1);
-		if (err)
-			break;
-
-		mem++;
+		c[size] = *buf++;
+		if (c[size] == 0x7d)
+			c[size] = *buf++ ^ 0x20;
+		size++;
 	}
 
-	return err;
+	return probe_kernel_write(mem, c, size);
 }
 
 /* Write memory due to an 'M' or 'X' packet. */
Signature · 1 line
1.6.4.rc1
author maintainer
#5 lore raw

PATCH 5/8 kgdb,debug_core: Use atomic operators which use barriers

A cpu_relax() does not mandate that there is an smp memory barrier. As a result on the arm smp architecture the kernel debugger can hang on entry from time to time, as shown by the kgdb regression tests.

The solution is simply to use the atomic operators which include a proper smp memory barrier, instead of using atomic_set() and atomic_read().

---
 kernel/debug/debug_core.c |   21 ++++++++++-----------
 1 files changed, 10 insertions(+), 11 deletions(-)
kernel/debug/debug_core.c +10 -11
index 91286e8..f471268 100644
@@ -463,8 +463,7 @@ acquirelock:
 	 * Make sure the above info reaches the primary CPU before
 	 * our cpu_in_kgdb[] flag setting does:
 	 */
-	smp_wmb();
-	atomic_set(&cpu_in_kgdb[cpu], 1);
+	atomic_inc(&cpu_in_kgdb[cpu]);
 
 	/*
 	 * CPU will loop if it is a slave or request to become a kgdb
@@ -475,7 +474,7 @@ acquirelock:
 			if (atomic_cmpxchg(&kgdb_active, -1, cpu) == cpu)
 				break;
 		} else if (kgdb_info[cpu].exception_state & DCPU_IS_SLAVE) {
-			if (!atomic_read(&passive_cpu_wait[cpu]))
+			if (!atomic_add_return(0, &passive_cpu_wait[cpu]))
 				goto return_normal;
 		} else {
 return_normal:
@@ -484,7 +483,7 @@ return_normal:
 			 */
 			if (arch_kgdb_ops.correct_hw_break)
 				arch_kgdb_ops.correct_hw_break();
-			atomic_set(&cpu_in_kgdb[cpu], 0);
+			atomic_dec(&cpu_in_kgdb[cpu]);
 			touch_softlockup_watchdog_sync();
 			clocksource_touch_watchdog();
 			local_irq_restore(flags);
@@ -533,7 +532,7 @@ return_normal:
 	 */
 	if (!kgdb_single_step) {
 		for (i = 0; i < NR_CPUS; i++)
-			atomic_set(&passive_cpu_wait[i], 1);
+			atomic_inc(&passive_cpu_wait[i]);
 	}
 
 #ifdef CONFIG_SMP
@@ -546,7 +545,7 @@ return_normal:
 	 * Wait for the other CPUs to be notified and be waiting for us:
 	 */
 	for_each_online_cpu(i) {
-		while (!atomic_read(&cpu_in_kgdb[i]))
+		while (!atomic_add_return(0, &cpu_in_kgdb[i]))
 			cpu_relax();
 	}
 
@@ -567,17 +566,17 @@ return_normal:
 	if (dbg_io_ops->post_exception)
 		dbg_io_ops->post_exception();
 
-	atomic_set(&cpu_in_kgdb[ks->cpu], 0);
+	atomic_dec(&cpu_in_kgdb[ks->cpu]);
 
 	if (!kgdb_single_step) {
 		for (i = NR_CPUS-1; i >= 0; i--)
-			atomic_set(&passive_cpu_wait[i], 0);
+			atomic_dec(&passive_cpu_wait[i]);
 		/*
 		 * Wait till all the CPUs have quit
 		 * from the debugger.
 		 */
 		for_each_online_cpu(i) {
-			while (atomic_read(&cpu_in_kgdb[i]))
+			while (atomic_add_return(0, &cpu_in_kgdb[i]))
 				cpu_relax();
 		}
 	}
@@ -820,11 +819,11 @@ EXPORT_SYMBOL_GPL(kgdb_unregister_io_module);
  */
 void kgdb_breakpoint(void)
 {
-	atomic_set(&kgdb_setting_breakpoint, 1);
+	atomic_inc(&kgdb_setting_breakpoint);
 	wmb(); /* Sync point before breakpoint */
 	arch_kgdb_breakpoint();
 	wmb(); /* Sync point after breakpoint */
-	atomic_set(&kgdb_setting_breakpoint, 0);
+	atomic_dec(&kgdb_setting_breakpoint);
 }
 EXPORT_SYMBOL_GPL(kgdb_breakpoint);
 
Signature · 1 line
1.6.4.rc1
author maintainer
#6 lore raw

PATCH 6/8 kgdbts,sh: Add in breakpoint pc offset for superh

The kgdb test suite mimics the behavior of gdb. For the sh architecture the pc must be decremented by 2 for software breakpoint.

---
 drivers/misc/kgdbts.c |    6 ++++++
 1 files changed, 6 insertions(+), 0 deletions(-)
drivers/misc/kgdbts.c +6 -0
index fcb6ec1..7245023 100644
@@ -295,6 +295,10 @@ static int check_and_rewind_pc(char *put_str, char *arg)
 	/* On x86 a breakpoint stop requires it to be decremented */
 	if (addr + 1 == kgdbts_regs.ip)
 		offset = -1;
+#elif defined(CONFIG_SUPERH)
+	/* On SUPERH a breakpoint stop requires it to be decremented */
+	if (addr + 2 == kgdbts_regs.pc)
+		offset = -2;
 #endif
 	if (strcmp(arg, "silent") &&
 		instruction_pointer(&kgdbts_regs) + offset != addr) {
@@ -305,6 +309,8 @@ static int check_and_rewind_pc(char *put_str, char *arg)
 #ifdef CONFIG_X86
 	/* On x86 adjust the instruction pointer if needed */
 	kgdbts_regs.ip += offset;
+#elif defined(CONFIG_SUPERH)
+	kgdbts_regs.pc += offset;
 #endif
 	return 0;
 }
Signature · 1 line
1.6.4.rc1
author maintainer
#7 lore raw

PATCH 7/8 debug_core: Turn off tracing while in the debugger

The kernel debugger should turn off kernel tracing any time the debugger is active and restore it on resume.

---
 kernel/debug/debug_core.c |    8 ++++++++
 1 files changed, 8 insertions(+), 0 deletions(-)
kernel/debug/debug_core.c +8 -0
index f471268..ab2a43f 100644
@@ -449,6 +449,7 @@ static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs)
 	int sstep_tries = 100;
 	int error = 0;
 	int i, cpu;
+	int trace_on = 0;
 acquirelock:
 	/*
 	 * Interrupts will be restored by the 'trap return' code, except when
@@ -483,6 +484,8 @@ return_normal:
 			 */
 			if (arch_kgdb_ops.correct_hw_break)
 				arch_kgdb_ops.correct_hw_break();
+			if (trace_on)
+				tracing_on();
 			atomic_dec(&cpu_in_kgdb[cpu]);
 			touch_softlockup_watchdog_sync();
 			clocksource_touch_watchdog();
@@ -558,6 +561,9 @@ return_normal:
 	kgdb_single_step = 0;
 	kgdb_contthread = current;
 	exception_level = 0;
+	trace_on = tracing_is_on();
+	if (trace_on)
+		tracing_off();
 
 	/* Talk to debugger with gdbserial protocol */
 	error = gdb_serial_stub(ks);
@@ -589,6 +595,8 @@ kgdb_restore:
 		else
 			kgdb_sstep_pid = 0;
 	}
+	if (trace_on)
+		tracing_on();
 	/* Free kgdb_active */
 	atomic_set(&kgdb_active, -1);
 	touch_softlockup_watchdog_sync();
Signature · 1 line
1.6.4.rc1
author maintainer
#8 lore raw

PATCH 8/8 MAINTAINERS: update kgdb, and debug_core info

Update the kgdb section.

---
 MAINTAINERS |    5 +++--
 1 files changed, 3 insertions(+), 2 deletions(-)
MAINTAINERS +3 -2
index 449d444..2468613 100644
@@ -3269,15 +3269,16 @@ S:	Maintained
 F:	include/linux/kexec.h
 F:	kernel/kexec.c
 
-KGDB
+KGDB / debug_core
 M:	Jason Wessel <[email protected]>
+W:	http://kgdb.wiki.kernel.org/
 L:	[email protected]
 S:	Maintained
 F:	Documentation/DocBook/kgdb.tmpl
 F:	drivers/misc/kgdbts.c
 F:	drivers/serial/kgdboc.c
 F:	include/linux/kgdb.h
-F:	kernel/kgdb.c
+F:	kernel/debug/
 
 KMEMCHECK
 M:	Vegard Nossum <[email protected]>
Signature · 1 line
1.6.4.rc1
author maintainer
#9 lore raw
In reply to Jason Wessel
Quoted 4 lines · Jason Wessel

Linus, please pull the kgdb-fixes for 2.6.34.

git://git.kernel.org/pub/scm/linux/kernel/git/jwessel/linux-2.6-kgdb.git kgdb-fixes

Quoted 9 lines

Summary:
* The first 2 patches are the gdbstub and debug core split from the kdb tree
* The rest are the fixes cherry picked from the kdb pull request

The previous kdb pull will require a rebase if you accept the kgdb fixes because there were patch splits that occurred to make this patch set.

Ping.

Linus, please help me understand how we can continue to move forward on the kernel debugger pull requests. There have been numerous requests that have not been pulled and have no response as to what needs to be acted on to resolve any outstanding issues.

Thanks,
Jason.

#10 lore raw
Quoted 7 lines · Jason Wessel

Ping.

Linus, please help me understand how we can continue to move forward on the kernel debugger pull requests. There have been numerous requests that have not been pulled and have no response as to what needs to be acted on to resolve any outstanding issues.

I've been swamped and bad, and since I wrote another email to explain why I'm always so grumpy (unrelated thread, nothing to do with kgdb), I'll cut-and-paste some of the relevant explanation for my pulling (or not pulling, as in this case) here too..

--> begin cut-and-pastee <--

Even on the merging side, what ends up happening is that some trees I decide I can't afford to merge, simply because the potential pain of merging without knowing the code is too high. So I can merge a new filesystem without any issues - if it's buggy, all I need to know is "new filesystem craps out". But when it comes to core generic code that anybody can hit, I have to _rely_ on submaintainers doing the right thing.

And when that doesn't work out, and stuff falls through the cracks, I'm kind of screwed. And this looked like a "fall through the cracks" thing.

[ I skipped the kdb merge this window, for example, and I feel bad about
that, and will have to walk over the pull request with a comb once the merge window fallout calms down, so that I can do it the next merge window. Not because I need to understand each line, but because I need to understand what the potential bigger-picture impacts are when something that looks odd pops up ]

--> end cut-and-paste <--

and obviously one of the issues is that I end up always prioritizing my pulls etc, and because I'm not a huge fan of debuggers (understatement of the year), that pull request was always at the bottom of the pile. And this merge window I ended up having some Intel event things that took up a good chunk of the window, so I never did get to that bottom.

Usually things calm down for me at around -rc4, when it turns into a waiting game instead of fighting fires. So I'm expecting to do that "look things over" this weekend or next week.

Linus

author maintainer
#11 lore raw
Quoted 6 lines · Linus Torvalds

Usually things calm down for me at around -rc4, when it turns into a waiting game instead of fighting fires. So I'm expecting to do that "look things over" this weekend or next week.

Thanks for the response. Please do let me know if you have any
questions about the kdb patches.

I can repost the series with the minor changes and base it off the pending kgdb-fixes pull request.

Thanks,
Jason.