Skip to contentSkip to conversation

hw-breakpoints: new hardware breakpoints API

PATCH In review Frederic Weisbecker 4 participants 21 messages Jun 2, 2009 – Jun 5, 2009

Subsystems (7)
lore
Share & tools
lore
#0 lore raw

cover hw-breakpoints: new hardware breakpoints API

Hi Ingo,

The new hardware breakpoint API has benefit from deep reviews since its first iteration several months ago, and Prasad has addressed most (all?) of them.

After a small reorg and few fixes that were done recently, it seems ready for integration on -tip.

I've tested it successfully for both kernel (ftrace) and user (gdb) hardware breakpoints.

Thanks!

Frederic.

The following changes since commit 43bd1236234cacbc18d1476a9b57e7a306efddf5:
Frederic Weisbecker (1):
tracing/stat: remove unappropriate safe walk on list

are available in the git repository at:

git://git.kernel.org/pub/scm/linux/kernel/git/frederic/random-tracing.git hw-breakpoints

K.Prasad (12):
hw-breakpoints: prepare the code for Hardware Breakpoint interfaces
hw-breakpoints: introducing generic hardware breakpoint handler interfaces
hw-breakpoints: x86 architecture implementation of Hardware Breakpoint interfaces
hw-breakpoints: modifying generic debug exception to use thread-specific debug registers
hw-breakpoints: use wrapper routines around debug registers in processor related functions
hw-breakpoints: use the new wrapper routines to access debug registers in process/thread code
hw-breakpoints: modify signal handling code to refrain from re-enabling HW Breakpoints
hw-breakpoints: modify Ptrace routines to access breakpoint registers
hw-breakpoints: cleanup HW Breakpoint registers before kexec
hw-breakpoints: sample HW breakpoint over kernel data address
hw-breakpoints: ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces
hw-breakpoints: reset bits in dr6 after the corresponding exception is handled

 arch/Kconfig                            |    4 +
 arch/x86/Kconfig                        |    1 +
 arch/x86/include/asm/a.out-core.h       |    8 +-
 arch/x86/include/asm/debugreg.h         |   29 ++
 arch/x86/include/asm/hw_breakpoint.h    |   55 ++++
 arch/x86/include/asm/processor.h        |    8 +-
 arch/x86/kernel/Makefile                |    2 +-
 arch/x86/kernel/hw_breakpoint.c         |  391 +++++++++++++++++++++++
 arch/x86/kernel/kgdb.c                  |    6 +
 arch/x86/kernel/kprobes.c               |    9 +-
 arch/x86/kernel/machine_kexec_32.c      |    2 +
 arch/x86/kernel/machine_kexec_64.c      |    2 +
 arch/x86/kernel/process.c               |   22 +-
 arch/x86/kernel/process_32.c            |   28 ++
 arch/x86/kernel/process_64.c            |   31 ++
 arch/x86/kernel/ptrace.c                |  231 +++++++++------
 arch/x86/kernel/signal.c                |    9 -
 arch/x86/kernel/smpboot.c               |    3 +
 arch/x86/kernel/traps.c                 |   71 ++---
 arch/x86/mm/kmmio.c                     |    8 +-
 arch/x86/power/cpu_32.c                 |   13 +-
 arch/x86/power/cpu_64.c                 |   12 +-
 include/asm-generic/hw_breakpoint.h     |  139 ++++++++
 kernel/Makefile                         |    1 +
 kernel/hw_breakpoint.c                  |  378 ++++++++++++++++++++++
 kernel/trace/Kconfig                    |   21 ++
 kernel/trace/Makefile                   |    1 +
 kernel/trace/trace.h                    |   23 ++
 kernel/trace/trace_ksym.c               |  525 +++++++++++++++++++++++++++++++
 kernel/trace/trace_selftest.c           |   53 +++
 samples/Kconfig                         |    6 +
 samples/Makefile                        |    3 +-
 samples/hw_breakpoint/Makefile          |    1 +
 samples/hw_breakpoint/data_breakpoint.c |   83 +++++
 34 files changed, 1987 insertions(+), 192 deletions(-)
 create mode 100644 arch/x86/include/asm/hw_breakpoint.h
 create mode 100644 arch/x86/kernel/hw_breakpoint.c
 create mode 100644 include/asm-generic/hw_breakpoint.h
 create mode 100644 kernel/hw_breakpoint.c
 create mode 100644 kernel/trace/trace_ksym.c
 create mode 100644 samples/hw_breakpoint/Makefile
 create mode 100644 samples/hw_breakpoint/data_breakpoint.c
#1 lore raw

PATCH 1/12 hw-breakpoints: prepare the code for Hardware Breakpoint interfaces

From: K.Prasad <[email protected]>

The generic hardware breakpoint interface provides an abstraction of hardware breakpoints in front of specific arch implementations for both kernel and user side breakpoints.
This includes execution breakpoints and read/write breakpoints, also known as "watchpoints".

This patch introduces header files containing constants, structure definitions and declaration of functions used by the hardware breakpoint core and x86 specific code.
It also introduces an array based storage for the debug-register values in 'struct thread_struct', while modifying all users of debugreg<n> member in the structure.

[ Impact: add headers for new hardware breakpoint interface ]

---
 arch/x86/include/asm/a.out-core.h    |    8 +-
 arch/x86/include/asm/debugreg.h      |   29 +++++++
 arch/x86/include/asm/hw_breakpoint.h |   55 +++++++++++++
 arch/x86/include/asm/processor.h     |    8 +-
 arch/x86/kernel/process.c            |   16 ++--
 arch/x86/kernel/ptrace.c             |   16 ++--
 arch/x86/power/cpu_32.c              |    8 +-
 arch/x86/power/cpu_64.c              |    8 +-
 include/asm-generic/hw_breakpoint.h  |  139 ++++++++++++++++++++++++++++++++++
 9 files changed, 255 insertions(+), 32 deletions(-)
 create mode 100644 arch/x86/include/asm/hw_breakpoint.h
 create mode 100644 include/asm-generic/hw_breakpoint.h
arch/x86/include/asm/a.out-core.h +4 -4
index bb70e39..fc4685d 100644
@@ -32,10 +32,10 @@ static inline void aout_dump_thread(struct pt_regs *regs, struct user *dump)
 			>> PAGE_SHIFT;
 	dump->u_dsize -= dump->u_tsize;
 	dump->u_ssize = 0;
-	dump->u_debugreg[0] = current->thread.debugreg0;
-	dump->u_debugreg[1] = current->thread.debugreg1;
-	dump->u_debugreg[2] = current->thread.debugreg2;
-	dump->u_debugreg[3] = current->thread.debugreg3;
+	dump->u_debugreg[0] = current->thread.debugreg[0];
+	dump->u_debugreg[1] = current->thread.debugreg[1];
+	dump->u_debugreg[2] = current->thread.debugreg[2];
+	dump->u_debugreg[3] = current->thread.debugreg[3];
 	dump->u_debugreg[4] = 0;
 	dump->u_debugreg[5] = 0;
 	dump->u_debugreg[6] = current->thread.debugreg6;
arch/x86/include/asm/debugreg.h +29 -0
index 3ea6f37..23439fb 100644
@@ -18,6 +18,7 @@
 #define DR_TRAP1	(0x2)		/* db1 */
 #define DR_TRAP2	(0x4)		/* db2 */
 #define DR_TRAP3	(0x8)		/* db3 */
+#define DR_TRAP_BITS	(DR_TRAP0|DR_TRAP1|DR_TRAP2|DR_TRAP3)
 
 #define DR_STEP		(0x4000)	/* single-step */
 #define DR_SWITCH	(0x8000)	/* task switch */
@@ -49,6 +50,8 @@
 
 #define DR_LOCAL_ENABLE_SHIFT 0    /* Extra shift to the local enable bit */
 #define DR_GLOBAL_ENABLE_SHIFT 1   /* Extra shift to the global enable bit */
+#define DR_LOCAL_ENABLE (0x1)      /* Local enable for reg 0 */
+#define DR_GLOBAL_ENABLE (0x2)     /* Global enable for reg 0 */
 #define DR_ENABLE_SIZE 2           /* 2 enable bits per register */
 
 #define DR_LOCAL_ENABLE_MASK (0x55)  /* Set  local bits for all 4 regs */
@@ -67,4 +70,30 @@
 #define DR_LOCAL_SLOWDOWN (0x100)   /* Local slow the pipeline */
 #define DR_GLOBAL_SLOWDOWN (0x200)  /* Global slow the pipeline */
 
+/*
+ * HW breakpoint additions
+ */
+#ifdef __KERNEL__
+
+/* For process management */
+extern void flush_thread_hw_breakpoint(struct task_struct *tsk);
+extern int copy_thread_hw_breakpoint(struct task_struct *tsk,
+		struct task_struct *child, unsigned long clone_flags);
+
+/* For CPU management */
+extern void load_debug_registers(void);
+static inline void hw_breakpoint_disable(void)
+{
+	/* Zero the control register for HW Breakpoint */
+	set_debugreg(0UL, 7);
+
+	/* Zero-out the individual HW breakpoint address registers */
+	set_debugreg(0UL, 0);
+	set_debugreg(0UL, 1);
+	set_debugreg(0UL, 2);
+	set_debugreg(0UL, 3);
+}
+
+#endif	/* __KERNEL__ */
+
 #endif /* _ASM_X86_DEBUGREG_H */
arch/x86/include/asm/hw_breakpoint.h new file +55 -0

55 lines not on this page · raw message

arch/x86/include/asm/processor.h +4 -4
index 0b2fab0..448b34a 100644
@@ -29,6 +29,7 @@ struct mm_struct;
 #include <linux/threads.h>
 #include <linux/init.h>
 
+#define HBP_NUM 4
 /*
  * Default implementation of macro that returns current
  * instruction pointer ("program counter").
@@ -431,12 +432,11 @@ struct thread_struct {
 	unsigned long		fs;
 	unsigned long		gs;
 	/* Hardware debugging registers: */
-	unsigned long		debugreg0;
-	unsigned long		debugreg1;
-	unsigned long		debugreg2;
-	unsigned long		debugreg3;
+	unsigned long		debugreg[HBP_NUM];
 	unsigned long		debugreg6;
 	unsigned long		debugreg7;
+	/* Hardware breakpoint info */
+	struct hw_breakpoint	*hbp[HBP_NUM];
 	/* Fault info: */
 	unsigned long		cr2;
 	unsigned long		trap_no;
arch/x86/kernel/process.c +8 -8
index fb5dfb8..291527c 100644
@@ -106,10 +106,10 @@ void flush_thread(void)
 
 	clear_tsk_thread_flag(tsk, TIF_DEBUG);
 
-	tsk->thread.debugreg0 = 0;
-	tsk->thread.debugreg1 = 0;
-	tsk->thread.debugreg2 = 0;
-	tsk->thread.debugreg3 = 0;
+	tsk->thread.debugreg[0] = 0;
+	tsk->thread.debugreg[1] = 0;
+	tsk->thread.debugreg[2] = 0;
+	tsk->thread.debugreg[3] = 0;
 	tsk->thread.debugreg6 = 0;
 	tsk->thread.debugreg7 = 0;
 	memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));
@@ -194,10 +194,10 @@ void __switch_to_xtra(struct task_struct *prev_p, struct task_struct *next_p,
 		update_debugctlmsr(next->debugctlmsr);
 
 	if (test_tsk_thread_flag(next_p, TIF_DEBUG)) {
-		set_debugreg(next->debugreg0, 0);
-		set_debugreg(next->debugreg1, 1);
-		set_debugreg(next->debugreg2, 2);
-		set_debugreg(next->debugreg3, 3);
+		set_debugreg(next->debugreg[0], 0);
+		set_debugreg(next->debugreg[1], 1);
+		set_debugreg(next->debugreg[2], 2);
+		set_debugreg(next->debugreg[3], 3);
 		/* no 4 and 5 */
 		set_debugreg(next->debugreg6, 6);
 		set_debugreg(next->debugreg7, 7);
arch/x86/kernel/ptrace.c +8 -8
index 09ecbde..313be40 100644
@@ -471,10 +471,10 @@ static int genregs_set(struct task_struct *target,
 static unsigned long ptrace_get_debugreg(struct task_struct *child, int n)
 {
 	switch (n) {
-	case 0:		return child->thread.debugreg0;
-	case 1:		return child->thread.debugreg1;
-	case 2:		return child->thread.debugreg2;
-	case 3:		return child->thread.debugreg3;
+	case 0:		return child->thread.debugreg[0];
+	case 1:		return child->thread.debugreg[1];
+	case 2:		return child->thread.debugreg[2];
+	case 3:		return child->thread.debugreg[3];
 	case 6:		return child->thread.debugreg6;
 	case 7:		return child->thread.debugreg7;
 	}
@@ -493,10 +493,10 @@ static int ptrace_set_debugreg(struct task_struct *child,
 		return -EIO;
 
 	switch (n) {
-	case 0:		child->thread.debugreg0 = data; break;
-	case 1:		child->thread.debugreg1 = data; break;
-	case 2:		child->thread.debugreg2 = data; break;
-	case 3:		child->thread.debugreg3 = data; break;
+	case 0:		child->thread.debugreg[0] = data; break;
+	case 1:		child->thread.debugreg[1] = data; break;
+	case 2:		child->thread.debugreg[2] = data; break;
+	case 3:		child->thread.debugreg[3] = data; break;
 
 	case 6:
 		if ((data & ~0xffffffffUL) != 0)
arch/x86/power/cpu_32.c +4 -4
index ce702c5..5199139 100644
@@ -84,10 +84,10 @@ static void fix_processor_context(void)
 	 * Now maybe reload the debug registers
 	 */
 	if (current->thread.debugreg7) {
-		set_debugreg(current->thread.debugreg0, 0);
-		set_debugreg(current->thread.debugreg1, 1);
-		set_debugreg(current->thread.debugreg2, 2);
-		set_debugreg(current->thread.debugreg3, 3);
+		set_debugreg(current->thread.debugreg[0], 0);
+		set_debugreg(current->thread.debugreg[1], 1);
+		set_debugreg(current->thread.debugreg[2], 2);
+		set_debugreg(current->thread.debugreg[3], 3);
 		/* no 4 and 5 */
 		set_debugreg(current->thread.debugreg6, 6);
 		set_debugreg(current->thread.debugreg7, 7);
arch/x86/power/cpu_64.c +4 -4
index 5343540..1e3bdcc 100644
@@ -163,10 +163,10 @@ static void fix_processor_context(void)
 	 * Now maybe reload the debug registers
 	 */
 	if (current->thread.debugreg7){
-                loaddebug(&current->thread, 0);
-                loaddebug(&current->thread, 1);
-                loaddebug(&current->thread, 2);
-                loaddebug(&current->thread, 3);
+		set_debugreg(current->thread.debugreg[0], 0);
+		set_debugreg(current->thread.debugreg[1], 1);
+		set_debugreg(current->thread.debugreg[2], 2);
+		set_debugreg(current->thread.debugreg[3], 3);
                 /* no 4 and 5 */
                 loaddebug(&current->thread, 6);
                 loaddebug(&current->thread, 7);
include/asm-generic/hw_breakpoint.h new file +139 -0

139 lines not on this page · raw message

Signature · 1 line
1.6.2.3
#2 lore raw

PATCH 2/12 hw-breakpoints: introducing generic hardware breakpoint handler interfaces

In reply to Frederic Weisbecker

From: K.Prasad <[email protected]>

This patch introduces the generic Hardware Breakpoint interfaces for both user and kernel space requests.
This core Api handles the hardware breakpoints through new helpers. It handles the user-space breakpoints and kernel breakpoints in front of arch implementation.

One can choose kernel wide breakpoints using the following helpers and passing them a generic struct hw_breakpoint:

- register_kernel_hw_breakpoint()
- unregister_kernel_hw_breakpoint()
- modify_kernel_hw_breakpoint()

On the other side, you can choose per task breakpoints.

- register_user_hw_breakpoint()
- unregister_user_hw_breakpoint()
- modify_user_hw_breakpoint()

[ [email protected]: fix conflict against perfcounter ]

---
 arch/Kconfig           |    4 +
 kernel/Makefile        |    1 +
 kernel/hw_breakpoint.c |  378 ++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 383 insertions(+), 0 deletions(-)
 create mode 100644 kernel/hw_breakpoint.c
arch/Kconfig +4 -0
index 78a35e9..1adf2d0 100644
@@ -112,3 +112,7 @@ config HAVE_DMA_API_DEBUG
 
 config HAVE_DEFAULT_NO_SPIN_MUTEXES
 	bool
+
+config HAVE_HW_BREAKPOINT
+	bool
+
kernel/Makefile +1 -0
index a35eee3..18ad111 100644
@@ -96,6 +96,7 @@ obj-$(CONFIG_TRACING) += trace/
 obj-$(CONFIG_X86_DS) += trace/
 obj-$(CONFIG_SMP) += sched_cpupri.o
 obj-$(CONFIG_SLOW_WORK) += slow-work.o
+obj-$(CONFIG_HAVE_HW_BREAKPOINT) += hw_breakpoint.o
 
 ifneq ($(CONFIG_SCHED_OMIT_FRAME_POINTER),y)
 # According to Alan Modra <[email protected]>, the -fno-omit-frame-pointer is
kernel/hw_breakpoint.c new file +378 -0

378 lines not on this page · raw message

Signature · 1 line
1.6.2.3
#3 lore raw

PATCH 3/12 hw-breakpoints: x86 architecture implementation of Hardware Breakpoint interfaces

In reply to Frederic Weisbecker

From: K.Prasad <[email protected]>

This patch introduces the arch-specific implementation of the generic hardware breakpoints in kernel/hw_breakpoint.c inside x86 specific directories. It contains functions which help to validate and serve requests using Hardware Breakpoint registers on x86 processors.

[ [email protected]: fix conflict against kmemcheck ]

---
 arch/x86/Kconfig                |    1 +
 arch/x86/kernel/Makefile        |    2 +-
 arch/x86/kernel/hw_breakpoint.c |  382 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 384 insertions(+), 1 deletions(-)
 create mode 100644 arch/x86/kernel/hw_breakpoint.c
arch/x86/Kconfig +1 -0
index df9e885..3033375 100644
@@ -46,6 +46,7 @@ config X86
 	select HAVE_KERNEL_GZIP
 	select HAVE_KERNEL_BZIP2
 	select HAVE_KERNEL_LZMA
+	select HAVE_HW_BREAKPOINT
 
 config ARCH_DEFCONFIG
 	string
arch/x86/kernel/Makefile +1 -1
index 77df4d6..cbc7818 100644
@@ -36,7 +36,7 @@ obj-$(CONFIG_X86_64)	+= sys_x86_64.o x8664_ksyms_64.o
 obj-$(CONFIG_X86_64)	+= syscall_64.o vsyscall_64.o
 obj-y			+= bootflag.o e820.o
 obj-y			+= pci-dma.o quirks.o i8237.o topology.o kdebugfs.o
-obj-y			+= alternative.o i8253.o pci-nommu.o
+obj-y			+= alternative.o i8253.o pci-nommu.o hw_breakpoint.o
 obj-y			+= tsc.o io_delay.o rtc.o
 
 obj-$(CONFIG_X86_TRAMPOLINE)	+= trampoline.o
arch/x86/kernel/hw_breakpoint.c new file +382 -0

382 lines not on this page · raw message

Signature · 1 line
1.6.2.3
#4 lore raw

PATCH 4/12 hw-breakpoints: modifying generic debug exception to use thread-specific debug registers

In reply to Frederic Weisbecker

From: K.Prasad <[email protected]>

This patch modifies the breakpoint exception handler code to use the new abstract debug register names.

[ [email protected]: fix conflict against kmemcheck ]

[ Impact: refactor and cleanup x86 debug exception handler ]

---
 arch/x86/kernel/traps.c |   69 ++++++++++++++++------------------------------
 1 files changed, 24 insertions(+), 45 deletions(-)
arch/x86/kernel/traps.c +24 -45
index a1d2883..de99132 100644
@@ -529,73 +529,52 @@ asmlinkage __kprobes struct pt_regs *sync_regs(struct pt_regs *eregs)
 dotraplinkage void __kprobes do_debug(struct pt_regs *regs, long error_code)
 {
 	struct task_struct *tsk = current;
-	unsigned long condition;
+	unsigned long dr6;
 	int si_code;
 
-	get_debugreg(condition, 6);
+	get_debugreg(dr6, 6);
 
+	/* DR6 may or may not be cleared by the CPU */
+	set_debugreg(0, 6);
 	/*
 	 * The processor cleared BTF, so don't mark that we need it set.
 	 */
 	clear_tsk_thread_flag(tsk, TIF_DEBUGCTLMSR);
 	tsk->thread.debugctlmsr = 0;
 
-	if (notify_die(DIE_DEBUG, "debug", regs, condition, error_code,
+	/* Store the virtualized DR6 value */
+	tsk->thread.debugreg6 = dr6;
+
+	if (notify_die(DIE_DEBUG, "debug", regs, dr6, error_code,
 						SIGTRAP) == NOTIFY_STOP)
 		return;
 
 	/* It's safe to allow irq's after DR6 has been saved */
 	preempt_conditional_sti(regs);
 
-	/* Mask out spurious debug traps due to lazy DR7 setting */
-	if (condition & (DR_TRAP0|DR_TRAP1|DR_TRAP2|DR_TRAP3)) {
-		if (!tsk->thread.debugreg7)
-			goto clear_dr7;
+	if (regs->flags & X86_VM_MASK) {
+		handle_vm86_trap((struct kernel_vm86_regs *) regs,
+				error_code, 1);
+		return;
 	}
 
-#ifdef CONFIG_X86_32
-	if (regs->flags & X86_VM_MASK)
-		goto debug_vm86;
-#endif
-
-	/* Save debug status register where ptrace can see it */
-	tsk->thread.debugreg6 = condition;
-
 	/*
-	 * Single-stepping through TF: make sure we ignore any events in
-	 * kernel space (but re-enable TF when returning to user mode).
+	 * Single-stepping through system calls: ignore any exceptions in
+	 * kernel space, but re-enable TF when returning to user mode.
+	 *
+	 * We already checked v86 mode above, so we can check for kernel mode
+	 * by just checking the CPL of CS.
 	 */
-	if (condition & DR_STEP) {
-		if (!user_mode(regs))
-			goto clear_TF_reenable;
+	if ((dr6 & DR_STEP) && !user_mode(regs)) {
+		tsk->thread.debugreg6 &= ~DR_STEP;
+		set_tsk_thread_flag(tsk, TIF_SINGLESTEP);
+		regs->flags &= ~X86_EFLAGS_TF;
 	}
-
-	si_code = get_si_code(condition);
-	/* Ok, finally something we can handle */
-	send_sigtrap(tsk, regs, error_code, si_code);
-
-	/*
-	 * Disable additional traps. They'll be re-enabled when
-	 * the signal is delivered.
-	 */
-clear_dr7:
-	set_debugreg(0, 7);
+	si_code = get_si_code(tsk->thread.debugreg6);
+	if (tsk->thread.debugreg6 & (DR_STEP | DR_TRAP_BITS))
+		send_sigtrap(tsk, regs, error_code, si_code);
 	preempt_conditional_cli(regs);
-	return;
 
-#ifdef CONFIG_X86_32
-debug_vm86:
-	/* reenable preemption: handle_vm86_trap() might sleep */
-	dec_preempt_count();
-	handle_vm86_trap((struct kernel_vm86_regs *) regs, error_code, 1);
-	conditional_cli(regs);
-	return;
-#endif
-
-clear_TF_reenable:
-	set_tsk_thread_flag(tsk, TIF_SINGLESTEP);
-	regs->flags &= ~X86_EFLAGS_TF;
-	preempt_conditional_cli(regs);
 	return;
 }
 
Signature · 1 line
1.6.2.3
#5 lore raw

PATCH 5/12 hw-breakpoints: use wrapper routines around debug registers in processor related functions

In reply to Frederic Weisbecker

From: K.Prasad <[email protected]>

This patch enables the use of wrapper routines to access the debug/breakpoint registers on cpu management.

The hardcoded debug registers save and restore operations for threads breakpoints are replaced by wrappers.

And now that we handle the kernel breakpoints too, we also need to handle them on cpu hotplug operations.

[ Impact: adapt new hardware breakpoint api to cpu hotplug ]

---
 arch/x86/kernel/smpboot.c |    3 +++
 arch/x86/power/cpu_32.c   |   13 +++----------
 arch/x86/power/cpu_64.c   |   12 +++---------
 3 files changed, 9 insertions(+), 19 deletions(-)
arch/x86/kernel/smpboot.c +3 -0
index 58d24ef..2b2652d 100644
@@ -63,6 +63,7 @@
 #include <asm/apic.h>
 #include <asm/setup.h>
 #include <asm/uv/uv.h>
+#include <asm/debugreg.h>
 #include <linux/mc146818rtc.h>
 
 #include <asm/smpboot_hooks.h>
@@ -326,6 +327,7 @@ notrace static void __cpuinit start_secondary(void *unused)
 	setup_secondary_clock();
 
 	wmb();
+	load_debug_registers();
 	cpu_idle();
 }
 
@@ -1250,6 +1252,7 @@ void cpu_disable_common(void)
 	remove_cpu_from_maps(cpu);
 	unlock_vector_lock();
 	fixup_irqs();
+	hw_breakpoint_disable();
 }
 
 int native_cpu_disable(void)
arch/x86/power/cpu_32.c +3 -10
index 5199139..2bc3b01 100644
@@ -13,6 +13,7 @@
 #include <asm/mce.h>
 #include <asm/xcr.h>
 #include <asm/suspend.h>
+#include <asm/debugreg.h>
 
 static struct saved_context saved_context;
 
@@ -48,6 +49,7 @@ static void __save_processor_state(struct saved_context *ctxt)
 	ctxt->cr2 = read_cr2();
 	ctxt->cr3 = read_cr3();
 	ctxt->cr4 = read_cr4_safe();
+	hw_breakpoint_disable();
 }
 
 /* Needed by apm.c */
@@ -83,16 +85,7 @@ static void fix_processor_context(void)
 	/*
 	 * Now maybe reload the debug registers
 	 */
-	if (current->thread.debugreg7) {
-		set_debugreg(current->thread.debugreg[0], 0);
-		set_debugreg(current->thread.debugreg[1], 1);
-		set_debugreg(current->thread.debugreg[2], 2);
-		set_debugreg(current->thread.debugreg[3], 3);
-		/* no 4 and 5 */
-		set_debugreg(current->thread.debugreg6, 6);
-		set_debugreg(current->thread.debugreg7, 7);
-	}
-
+	load_debug_registers();
 }
 
 static void __restore_processor_state(struct saved_context *ctxt)
arch/x86/power/cpu_64.c +3 -9
index 1e3bdcc..46866a1 100644
@@ -16,6 +16,7 @@
 #include <asm/mtrr.h>
 #include <asm/xcr.h>
 #include <asm/suspend.h>
+#include <asm/debugreg.h>
 
 static void fix_processor_context(void);
 
@@ -71,6 +72,7 @@ static void __save_processor_state(struct saved_context *ctxt)
 	ctxt->cr3 = read_cr3();
 	ctxt->cr4 = read_cr4();
 	ctxt->cr8 = read_cr8();
+	hw_breakpoint_disable();
 }
 
 void save_processor_state(void)
@@ -162,13 +164,5 @@ static void fix_processor_context(void)
 	/*
 	 * Now maybe reload the debug registers
 	 */
-	if (current->thread.debugreg7){
-		set_debugreg(current->thread.debugreg[0], 0);
-		set_debugreg(current->thread.debugreg[1], 1);
-		set_debugreg(current->thread.debugreg[2], 2);
-		set_debugreg(current->thread.debugreg[3], 3);
-                /* no 4 and 5 */
-                loaddebug(&current->thread, 6);
-                loaddebug(&current->thread, 7);
-	}
+	load_debug_registers();
 }
Signature · 1 line
1.6.2.3
#6 lore raw

PATCH 6/12 hw-breakpoints: use the new wrapper routines to access debug registers in process/thread code

In reply to Frederic Weisbecker

From: K.Prasad <[email protected]>

This patch enables the use of abstract debug registers in process-handling routines, according to the new hardware breakpoint Api.

[ Impact: adapt thread breakpoints handling code to the new breakpoint Api ]

---
 arch/x86/kernel/process.c    |   22 ++++++----------------
 arch/x86/kernel/process_32.c |   28 ++++++++++++++++++++++++++++
 arch/x86/kernel/process_64.c |   31 +++++++++++++++++++++++++++++++
 3 files changed, 65 insertions(+), 16 deletions(-)
arch/x86/kernel/process.c +6 -16
index 291527c..19a686c 100644
@@ -15,6 +15,8 @@
 #include <asm/uaccess.h>
 #include <asm/i387.h>
 #include <asm/ds.h>
+#include <asm/debugreg.h>
+#include <asm/hw_breakpoint.h>
 
 unsigned long idle_halt;
 EXPORT_SYMBOL(idle_halt);
@@ -46,6 +48,8 @@ void free_thread_xstate(struct task_struct *tsk)
 		kmem_cache_free(task_xstate_cachep, tsk->thread.xstate);
 		tsk->thread.xstate = NULL;
 	}
+	if (unlikely(test_tsk_thread_flag(tsk, TIF_DEBUG)))
+		flush_thread_hw_breakpoint(tsk);
 
 	WARN(tsk->thread.ds_ctx, "leaking DS context\n");
 }
@@ -106,12 +110,8 @@ void flush_thread(void)
 
 	clear_tsk_thread_flag(tsk, TIF_DEBUG);
 
-	tsk->thread.debugreg[0] = 0;
-	tsk->thread.debugreg[1] = 0;
-	tsk->thread.debugreg[2] = 0;
-	tsk->thread.debugreg[3] = 0;
-	tsk->thread.debugreg6 = 0;
-	tsk->thread.debugreg7 = 0;
+	if (unlikely(test_tsk_thread_flag(tsk, TIF_DEBUG)))
+		flush_thread_hw_breakpoint(tsk);
 	memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));
 	/*
 	 * Forget coprocessor state..
@@ -193,16 +193,6 @@ void __switch_to_xtra(struct task_struct *prev_p, struct task_struct *next_p,
 	else if (next->debugctlmsr != prev->debugctlmsr)
 		update_debugctlmsr(next->debugctlmsr);
 
-	if (test_tsk_thread_flag(next_p, TIF_DEBUG)) {
-		set_debugreg(next->debugreg[0], 0);
-		set_debugreg(next->debugreg[1], 1);
-		set_debugreg(next->debugreg[2], 2);
-		set_debugreg(next->debugreg[3], 3);
-		/* no 4 and 5 */
-		set_debugreg(next->debugreg6, 6);
-		set_debugreg(next->debugreg7, 7);
-	}
-
 	if (test_tsk_thread_flag(prev_p, TIF_NOTSC) ^
 	    test_tsk_thread_flag(next_p, TIF_NOTSC)) {
 		/* prev and next are different */
arch/x86/kernel/process_32.c +28 -0
index b5e4bfe..297ffff 100644
@@ -61,6 +61,8 @@
 #include <asm/idle.h>
 #include <asm/syscalls.h>
 #include <asm/ds.h>
+#include <asm/debugreg.h>
+#include <asm/hw_breakpoint.h>
 
 asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
 
@@ -265,7 +267,13 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
 
 	task_user_gs(p) = get_user_gs(regs);
 
+	p->thread.io_bitmap_ptr = NULL;
 	tsk = current;
+	err = -ENOMEM;
+	if (unlikely(test_tsk_thread_flag(tsk, TIF_DEBUG)))
+		if (copy_thread_hw_breakpoint(tsk, p, clone_flags))
+			goto out;
+
 	if (unlikely(test_tsk_thread_flag(tsk, TIF_IO_BITMAP))) {
 		p->thread.io_bitmap_ptr = kmemdup(tsk->thread.io_bitmap_ptr,
 						IO_BITMAP_BYTES, GFP_KERNEL);
@@ -285,10 +293,13 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
 		err = do_set_thread_area(p, -1,
 			(struct user_desc __user *)childregs->si, 0);
 
+out:
 	if (err && p->thread.io_bitmap_ptr) {
 		kfree(p->thread.io_bitmap_ptr);
 		p->thread.io_bitmap_max = 0;
 	}
+	if (err)
+		flush_thread_hw_breakpoint(p);
 
 	clear_tsk_thread_flag(p, TIF_DS_AREA_MSR);
 	p->thread.ds_ctx = NULL;
@@ -427,6 +438,23 @@ __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
 		lazy_load_gs(next->gs);
 
 	percpu_write(current_task, next_p);
+	/*
+	 * There's a problem with moving the arch_install_thread_hw_breakpoint()
+	 * call before current is updated.  Suppose a kernel breakpoint is
+	 * triggered in between the two, the hw-breakpoint handler will see that
+	 * the 'current' task does not have TIF_DEBUG flag set and will think it
+	 * is leftover from an old task (lazy switching) and will erase it. Then
+	 * until the next context switch, no user-breakpoints will be installed.
+	 *
+	 * The real problem is that it's impossible to update both current and
+	 * physical debug registers at the same instant, so there will always be
+	 * a window in which they disagree and a breakpoint might get triggered.
+	 * Since we use lazy switching, we are forced to assume that a
+	 * disagreement means that current is correct and the exception is due
+	 * to lazy debug register switching.
+	 */
+	if (unlikely(test_tsk_thread_flag(next_p, TIF_DEBUG)))
+		arch_install_thread_hw_breakpoint(next_p);
 
 	return prev_p;
 }
arch/x86/kernel/process_64.c +31 -0
index 5a1a1de..f7b276d 100644
@@ -55,6 +55,8 @@
 #include <asm/idle.h>
 #include <asm/syscalls.h>
 #include <asm/ds.h>
+#include <asm/debugreg.h>
+#include <asm/hw_breakpoint.h>
 
 asmlinkage extern void ret_from_fork(void);
 
@@ -248,6 +250,8 @@ void release_thread(struct task_struct *dead_task)
 			BUG();
 		}
 	}
+	if (unlikely(dead_task->thread.debugreg7))
+		flush_thread_hw_breakpoint(dead_task);
 }
 
 static inline void set_32bit_tls(struct task_struct *t, int tls, u32 addr)
@@ -303,12 +307,18 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
 
 	p->thread.fs = me->thread.fs;
 	p->thread.gs = me->thread.gs;
+	p->thread.io_bitmap_ptr = NULL;
 
 	savesegment(gs, p->thread.gsindex);
 	savesegment(fs, p->thread.fsindex);
 	savesegment(es, p->thread.es);
 	savesegment(ds, p->thread.ds);
 
+	err = -ENOMEM;
+	if (unlikely(test_tsk_thread_flag(me, TIF_DEBUG)))
+		if (copy_thread_hw_breakpoint(me, p, clone_flags))
+			goto out;
+
 	if (unlikely(test_tsk_thread_flag(me, TIF_IO_BITMAP))) {
 		p->thread.io_bitmap_ptr = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
 		if (!p->thread.io_bitmap_ptr) {
@@ -347,6 +357,9 @@ out:
 		kfree(p->thread.io_bitmap_ptr);
 		p->thread.io_bitmap_max = 0;
 	}
+	if (err)
+		flush_thread_hw_breakpoint(p);
+
 	return err;
 }
 
@@ -492,6 +505,24 @@ __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
 	 */
 	if (tsk_used_math(next_p) && next_p->fpu_counter > 5)
 		math_state_restore();
+	/*
+	 * There's a problem with moving the arch_install_thread_hw_breakpoint()
+	 * call before current is updated.  Suppose a kernel breakpoint is
+	 * triggered in between the two, the hw-breakpoint handler will see that
+	 * the 'current' task does not have TIF_DEBUG flag set and will think it
+	 * is leftover from an old task (lazy switching) and will erase it. Then
+	 * until the next context switch, no user-breakpoints will be installed.
+	 *
+	 * The real problem is that it's impossible to update both current and
+	 * physical debug registers at the same instant, so there will always be
+	 * a window in which they disagree and a breakpoint might get triggered.
+	 * Since we use lazy switching, we are forced to assume that a
+	 * disagreement means that current is correct and the exception is due
+	 * to lazy debug register switching.
+	 */
+	if (unlikely(test_tsk_thread_flag(next_p, TIF_DEBUG)))
+		arch_install_thread_hw_breakpoint(next_p);
+
 	return prev_p;
 }
 
Signature · 1 line
1.6.2.3
#7 lore raw

PATCH 7/12 hw-breakpoints: modify signal handling code to refrain from re-enabling HW Breakpoints

In reply to Frederic Weisbecker

From: K.Prasad <[email protected]>

This patch disables re-enabling of Hardware Breakpoint registers through the signal handling code. This is now done during from hw_breakpoint_handler().

---
 arch/x86/kernel/signal.c |    9 ---------
 1 files changed, 0 insertions(+), 9 deletions(-)
arch/x86/kernel/signal.c +0 -9
index 1442516..f33d2e0 100644
@@ -800,15 +800,6 @@ static void do_signal(struct pt_regs *regs)
 
 	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 	if (signr > 0) {
-		/*
-		 * Re-enable any watchpoints before delivering the
-		 * signal to user space. The processor register will
-		 * have been cleared if the watchpoint triggered
-		 * inside the kernel.
-		 */
-		if (current->thread.debugreg7)
-			set_debugreg(current->thread.debugreg7, 7);
-
 		/* Whee! Actually deliver the signal.  */
 		if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
 			/*
Signature · 1 line
1.6.2.3
#8 lore raw

PATCH 8/12 hw-breakpoints: modify Ptrace routines to access breakpoint registers

In reply to Frederic Weisbecker

From: K.Prasad <[email protected]>

This patch modifies the ptrace code to use the new wrapper routines around the debug/breakpoint registers.

[ Impact: adapt x86 ptrace to the new breakpoint Api ]

---
 arch/x86/kernel/ptrace.c |  231 ++++++++++++++++++++++++++++------------------
 1 files changed, 141 insertions(+), 90 deletions(-)
arch/x86/kernel/ptrace.c +141 -90
index 313be40..b457f78 100644
@@ -34,6 +34,7 @@
 #include <asm/prctl.h>
 #include <asm/proto.h>
 #include <asm/ds.h>
+#include <asm/hw_breakpoint.h>
 
 #include <trace/syscall.h>
 
@@ -136,11 +137,6 @@ static int set_segment_reg(struct task_struct *task,
 	return 0;
 }
 
-static unsigned long debugreg_addr_limit(struct task_struct *task)
-{
-	return TASK_SIZE - 3;
-}
-
 #else  /* CONFIG_X86_64 */
 
 #define FLAG_MASK		(FLAG_MASK_32 | X86_EFLAGS_NT)
@@ -265,15 +261,6 @@ static int set_segment_reg(struct task_struct *task,
 	return 0;
 }
 
-static unsigned long debugreg_addr_limit(struct task_struct *task)
-{
-#ifdef CONFIG_IA32_EMULATION
-	if (test_tsk_thread_flag(task, TIF_IA32))
-		return IA32_PAGE_OFFSET - 3;
-#endif
-	return TASK_SIZE_MAX - 7;
-}
-
 #endif	/* CONFIG_X86_32 */
 
 static unsigned long get_flags(struct task_struct *task)
@@ -464,95 +451,159 @@ static int genregs_set(struct task_struct *target,
 }
 
 /*
- * This function is trivial and will be inlined by the compiler.
- * Having it separates the implementation details of debug
- * registers from the interface details of ptrace.
+ * Decode the length and type bits for a particular breakpoint as
+ * stored in debug register 7.  Return the "enabled" status.
  */
-static unsigned long ptrace_get_debugreg(struct task_struct *child, int n)
+static int decode_dr7(unsigned long dr7, int bpnum, unsigned *len,
+		unsigned *type)
 {
-	switch (n) {
-	case 0:		return child->thread.debugreg[0];
-	case 1:		return child->thread.debugreg[1];
-	case 2:		return child->thread.debugreg[2];
-	case 3:		return child->thread.debugreg[3];
-	case 6:		return child->thread.debugreg6;
-	case 7:		return child->thread.debugreg7;
-	}
-	return 0;
+	int bp_info = dr7 >> (DR_CONTROL_SHIFT + bpnum * DR_CONTROL_SIZE);
+
+	*len = (bp_info & 0xc) | 0x40;
+	*type = (bp_info & 0x3) | 0x80;
+	return (dr7 >> (bpnum * DR_ENABLE_SIZE)) & 0x3;
 }
 
-static int ptrace_set_debugreg(struct task_struct *child,
-			       int n, unsigned long data)
+static void ptrace_triggered(struct hw_breakpoint *bp, struct pt_regs *regs)
 {
+	struct thread_struct *thread = &(current->thread);
 	int i;
 
-	if (unlikely(n == 4 || n == 5))
-		return -EIO;
+	/*
+	 * Store in the virtual DR6 register the fact that the breakpoint
+	 * was hit so the thread's debugger will see it.
+	 */
+	for (i = 0; i < hbp_kernel_pos; i++)
+		/*
+		 * We will check bp->info.address against the address stored in
+		 * thread's hbp structure and not debugreg[i]. This is to ensure
+		 * that the corresponding bit for 'i' in DR7 register is enabled
+		 */
+		if (bp->info.address == thread->hbp[i]->info.address)
+			break;
 
-	if (n < 4 && unlikely(data >= debugreg_addr_limit(child)))
-		return -EIO;
+	thread->debugreg6 |= (DR_TRAP0 << i);
+}
 
-	switch (n) {
-	case 0:		child->thread.debugreg[0] = data; break;
-	case 1:		child->thread.debugreg[1] = data; break;
-	case 2:		child->thread.debugreg[2] = data; break;
-	case 3:		child->thread.debugreg[3] = data; break;
+/*
+ * Handle ptrace writes to debug register 7.
+ */
+static int ptrace_write_dr7(struct task_struct *tsk, unsigned long data)
+{
+	struct thread_struct *thread = &(tsk->thread);
+	unsigned long old_dr7 = thread->debugreg7;
+	int i, orig_ret = 0, rc = 0;
+	int enabled, second_pass = 0;
+	unsigned len, type;
+	struct hw_breakpoint *bp;
+
+	data &= ~DR_CONTROL_RESERVED;
+restore:
+	/*
+	 * Loop through all the hardware breakpoints, making the
+	 * appropriate changes to each.
+	 */
+	for (i = 0; i < HBP_NUM; i++) {
+		enabled = decode_dr7(data, i, &len, &type);
+		bp = thread->hbp[i];
+
+		if (!enabled) {
+			if (bp) {
+				/* Don't unregister the breakpoints right-away,
+				 * unless all register_user_hw_breakpoint()
+				 * requests have succeeded. This prevents
+				 * any window of opportunity for debug
+				 * register grabbing by other users.
+				 */
+				if (!second_pass)
+					continue;
+				unregister_user_hw_breakpoint(tsk, bp);
+				kfree(bp);
+			}
+			continue;
+		}
+		if (!bp) {
+			rc = -ENOMEM;
+			bp = kzalloc(sizeof(struct hw_breakpoint), GFP_KERNEL);
+			if (bp) {
+				bp->info.address = thread->debugreg[i];
+				bp->triggered = ptrace_triggered;
+				bp->info.len = len;
+				bp->info.type = type;
+				rc = register_user_hw_breakpoint(tsk, bp);
+				if (rc)
+					kfree(bp);
+			}
+		} else
+			rc = modify_user_hw_breakpoint(tsk, bp);
+		if (rc)
+			break;
+	}
+	/*
+	 * Make a second pass to free the remaining unused breakpoints
+	 * or to restore the original breakpoints if an error occurred.
+	 */
+	if (!second_pass) {
+		second_pass = 1;
+		if (rc < 0) {
+			orig_ret = rc;
+			data = old_dr7;
+		}
+		goto restore;
+	}
+	return ((orig_ret < 0) ? orig_ret : rc);
+}
 
-	case 6:
-		if ((data & ~0xffffffffUL) != 0)
-			return -EIO;
-		child->thread.debugreg6 = data;
-		break;
+/*
+ * Handle PTRACE_PEEKUSR calls for the debug register area.
+ */
+unsigned long ptrace_get_debugreg(struct task_struct *tsk, int n)
+{
+	struct thread_struct *thread = &(tsk->thread);
+	unsigned long val = 0;
+
+	if (n < HBP_NUM)
+		val = thread->debugreg[n];
+	else if (n == 6)
+		val = thread->debugreg6;
+	else if (n == 7)
+		val = thread->debugreg7;
+	return val;
+}
 
-	case 7:
-		/*
-		 * Sanity-check data. Take one half-byte at once with
-		 * check = (val >> (16 + 4*i)) & 0xf. It contains the
-		 * R/Wi and LENi bits; bits 0 and 1 are R/Wi, and bits
-		 * 2 and 3 are LENi. Given a list of invalid values,
-		 * we do mask |= 1 << invalid_value, so that
-		 * (mask >> check) & 1 is a correct test for invalid
-		 * values.
-		 *
-		 * R/Wi contains the type of the breakpoint /
-		 * watchpoint, LENi contains the length of the watched
-		 * data in the watchpoint case.
-		 *
-		 * The invalid values are:
-		 * - LENi == 0x10 (undefined), so mask |= 0x0f00.	[32-bit]
-		 * - R/Wi == 0x10 (break on I/O reads or writes), so
-		 *   mask |= 0x4444.
-		 * - R/Wi == 0x00 && LENi != 0x00, so we have mask |=
-		 *   0x1110.
-		 *
-		 * Finally, mask = 0x0f00 | 0x4444 | 0x1110 == 0x5f54.
-		 *
-		 * See the Intel Manual "System Programming Guide",
-		 * 15.2.4
-		 *
-		 * Note that LENi == 0x10 is defined on x86_64 in long
-		 * mode (i.e. even for 32-bit userspace software, but
-		 * 64-bit kernel), so the x86_64 mask value is 0x5454.
-		 * See the AMD manual no. 24593 (AMD64 System Programming)
-		 */
-#ifdef CONFIG_X86_32
-#define	DR7_MASK	0x5f54
-#else
-#define	DR7_MASK	0x5554
-#endif
-		data &= ~DR_CONTROL_RESERVED;
-		for (i = 0; i < 4; i++)
-			if ((DR7_MASK >> ((data >> (16 + 4*i)) & 0xf)) & 1)
-				return -EIO;
-		child->thread.debugreg7 = data;
-		if (data)
-			set_tsk_thread_flag(child, TIF_DEBUG);
-		else
-			clear_tsk_thread_flag(child, TIF_DEBUG);
-		break;
+/*
+ * Handle PTRACE_POKEUSR calls for the debug register area.
+ */
+int ptrace_set_debugreg(struct task_struct *tsk, int n, unsigned long val)
+{
+	struct thread_struct *thread = &(tsk->thread);
+	int rc = 0;
+
+	/* There are no DR4 or DR5 registers */
+	if (n == 4 || n == 5)
+		return -EIO;
+
+	if (n == 6) {
+		tsk->thread.debugreg6 = val;
+		goto ret_path;
 	}
+	if (n < HBP_NUM) {
+		if (thread->hbp[n]) {
+			if (arch_check_va_in_userspace(val,
+					thread->hbp[n]->info.len) == 0) {
+				rc = -EIO;
+				goto ret_path;
+			}
+			thread->hbp[n]->info.address = val;
+		}
+		thread->debugreg[n] = val;
+	}
+	/* All that's left is DR7 */
+	if (n == 7)
+		rc = ptrace_write_dr7(tsk, val);
 
-	return 0;
+ret_path:
+	return rc;
 }
 
 /*
Signature · 1 line
1.6.2.3
#9 lore raw

PATCH 9/12 hw-breakpoints: cleanup HW Breakpoint registers before kexec

In reply to Frederic Weisbecker

From: K.Prasad <[email protected]>

This patch disables Hardware breakpoints before doing a 'kexec' on the machine so that the cpu doesn't keep debug registers values which would be out of sync for the new image.

---
 arch/x86/kernel/machine_kexec_32.c |    2 ++
 arch/x86/kernel/machine_kexec_64.c |    2 ++
 2 files changed, 4 insertions(+), 0 deletions(-)
arch/x86/kernel/machine_kexec_32.c +2 -0
index c1c429d..c843f84 100644
@@ -25,6 +25,7 @@
 #include <asm/desc.h>
 #include <asm/system.h>
 #include <asm/cacheflush.h>
+#include <asm/debugreg.h>
 
 static void set_idt(void *newidt, __u16 limit)
 {
@@ -202,6 +203,7 @@ void machine_kexec(struct kimage *image)
 
 	/* Interrupts aren't acceptable while we reboot */
 	local_irq_disable();
+	hw_breakpoint_disable();
 
 	if (image->preserve_context) {
 #ifdef CONFIG_X86_IO_APIC
arch/x86/kernel/machine_kexec_64.c +2 -0
index 84c3bf2..4a8bb82 100644
@@ -18,6 +18,7 @@
 #include <asm/pgtable.h>
 #include <asm/tlbflush.h>
 #include <asm/mmu_context.h>
+#include <asm/debugreg.h>
 
 static int init_one_level2_page(struct kimage *image, pgd_t *pgd,
 				unsigned long addr)
@@ -282,6 +283,7 @@ void machine_kexec(struct kimage *image)
 
 	/* Interrupts aren't acceptable while we reboot */
 	local_irq_disable();
+	hw_breakpoint_disable();
 
 	if (image->preserve_context) {
 #ifdef CONFIG_X86_IO_APIC
Signature · 1 line
1.6.2.3
#10 lore raw

PATCH 10/12 hw-breakpoints: sample HW breakpoint over kernel data address

In reply to Frederic Weisbecker

From: K.Prasad <[email protected]>

This patch introduces a sample kernel module to demonstrate the use of Hardware Breakpoint feature. It places a breakpoint over the kernel variable 'pid_max' to monitor all write operations and emits a function-backtrace when done.

---
 samples/Kconfig                         |    6 ++
 samples/Makefile                        |    3 +-
 samples/hw_breakpoint/Makefile          |    1 +
 samples/hw_breakpoint/data_breakpoint.c |   83 +++++++++++++++++++++++++++++++
 4 files changed, 92 insertions(+), 1 deletions(-)
 create mode 100644 samples/hw_breakpoint/Makefile
 create mode 100644 samples/hw_breakpoint/data_breakpoint.c
samples/Kconfig +6 -0
index b75d28c..8458516 100644
@@ -45,5 +45,11 @@ config SAMPLE_KRETPROBES
 	default m
 	depends on SAMPLE_KPROBES && KRETPROBES
 
+config SAMPLE_HW_BREAKPOINT
+	tristate "Build kernel hardware breakpoint examples -- loadable module only"
+	depends on HAVE_HW_BREAKPOINT && m
+	help
+	  This builds kernel hardware breakpoint example modules.
+
 endif # SAMPLES
 
samples/Makefile +2 -1
index 13e4b47..42e1755 100644
@@ -1,3 +1,4 @@
 # Makefile for Linux samples code
 
-obj-$(CONFIG_SAMPLES)	+= markers/ kobject/ kprobes/ tracepoints/ trace_events/
+obj-$(CONFIG_SAMPLES)	+= markers/ kobject/ kprobes/ tracepoints/ \
+			trace_events/ hw_breakpoint/
samples/hw_breakpoint/Makefile new file +1 -0
new file mode 100644
index 0000000..0f5c31c
@@ -0,0 +1 @@
+obj-$(CONFIG_SAMPLE_HW_BREAKPOINT) += data_breakpoint.o
samples/hw_breakpoint/data_breakpoint.c new file +83 -0

83 lines not on this page · raw message

Signature · 1 line
1.6.2.3
#11 lore raw

PATCH 11/12 hw-breakpoints: ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces

In reply to Frederic Weisbecker

From: K.Prasad <[email protected]>

This patch adds an ftrace plugin to detect and profile memory access over kernel variables. It uses HW Breakpoint interfaces to 'watch memory addresses.

---
 kernel/trace/Kconfig          |   21 ++
 kernel/trace/Makefile         |    1 +
 kernel/trace/trace.h          |   23 ++
 kernel/trace/trace_ksym.c     |  525 +++++++++++++++++++++++++++++++++++++++++
 kernel/trace/trace_selftest.c |   53 ++++
 5 files changed, 623 insertions(+), 0 deletions(-)
 create mode 100644 kernel/trace/trace_ksym.c
kernel/trace/Kconfig +21 -0
index a508b9d..d7f01e6 100644
@@ -314,6 +314,27 @@ config POWER_TRACER
 	  power management decisions, specifically the C-state and P-state
 	  behavior.
 
+config KSYM_TRACER
+	bool "Trace read and write access on kernel memory locations"
+	depends on HAVE_HW_BREAKPOINT
+	select TRACING
+	help
+	  This tracer helps find read and write operations on any given kernel
+	  symbol i.e. /proc/kallsyms.
+
+config PROFILE_KSYM_TRACER
+	bool "Profile all kernel memory accesses on 'watched' variables"
+	depends on KSYM_TRACER
+	help
+	  This tracer profiles kernel accesses on variables watched through the
+	  ksym tracer ftrace plugin. Depending upon the hardware, all read
+	  and write operations on kernel variables can be monitored for
+	  accesses.
+
+	  The results will be displayed in:
+	  /debugfs/tracing/profile_ksym
+
+	  Say N if unsure.
 
 config STACK_TRACER
 	bool "Trace max stack"
kernel/trace/Makefile +1 -0
index 06b8585..658aace 100644
@@ -51,5 +51,6 @@ obj-$(CONFIG_EVENT_TRACING) += trace_export.o
 obj-$(CONFIG_FTRACE_SYSCALLS) += trace_syscalls.o
 obj-$(CONFIG_EVENT_PROFILE) += trace_event_profile.o
 obj-$(CONFIG_EVENT_TRACING) += trace_events_filter.o
+obj-$(CONFIG_KSYM_TRACER) += trace_ksym.o
 
 libftrace-y := ftrace.o
kernel/trace/trace.h +23 -0
index 6e735d4..7d5cc37 100644
@@ -15,6 +15,10 @@
 #include <linux/trace_seq.h>
 #include <linux/ftrace_event.h>
 
+#ifdef CONFIG_KSYM_TRACER
+#include <asm/hw_breakpoint.h>
+#endif
+
 enum trace_type {
 	__TRACE_FIRST_TYPE = 0,
 
@@ -40,6 +44,7 @@ enum trace_type {
 	TRACE_KMEM_FREE,
 	TRACE_POWER,
 	TRACE_BLK,
+	TRACE_KSYM,
 
 	__TRACE_LAST_TYPE,
 };
@@ -207,6 +212,21 @@ struct syscall_trace_exit {
 	unsigned long		ret;
 };
 
+#define KSYM_SELFTEST_ENTRY "ksym_selftest_dummy"
+extern int process_new_ksym_entry(char *ksymname, int op, unsigned long addr);
+
+struct trace_ksym {
+	struct trace_entry	ent;
+	struct hw_breakpoint	*ksym_hbp;
+	unsigned long		ksym_addr;
+	unsigned long		ip;
+#ifdef CONFIG_PROFILE_KSYM_TRACER
+	unsigned long		counter;
+#endif
+	struct hlist_node	ksym_hlist;
+	char			ksym_name[KSYM_NAME_LEN];
+	char			p_name[TASK_COMM_LEN];
+};
 
 /*
  * trace_flag_type is an enumeration that holds different
@@ -323,6 +343,7 @@ extern void __ftrace_bad_type(void);
 			  TRACE_SYSCALL_ENTER);				\
 		IF_ASSIGN(var, ent, struct syscall_trace_exit,		\
 			  TRACE_SYSCALL_EXIT);				\
+		IF_ASSIGN(var, ent, struct trace_ksym, TRACE_KSYM);	\
 		__ftrace_bad_type();					\
 	} while (0)
 
@@ -540,6 +561,8 @@ extern int trace_selftest_startup_branch(struct tracer *trace,
 					 struct trace_array *tr);
 extern int trace_selftest_startup_hw_branches(struct tracer *trace,
 					      struct trace_array *tr);
+extern int trace_selftest_startup_ksym(struct tracer *trace,
+					 struct trace_array *tr);
 #endif /* CONFIG_FTRACE_STARTUP_TEST */
 
 extern void *head_page(struct trace_array_cpu *data);
kernel/trace/trace_ksym.c new file +525 -0

525 lines not on this page · raw message

kernel/trace/trace_selftest.c +53 -0

62 lines not on this page · raw message

Signature · 1 line
1.6.2.3
#12 lore raw

Re: [PATCH 11/12] hw-breakpoints: ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces

Quoted 15 lines · Frederic Weisbecker

From: K.Prasad <[email protected]>

This patch adds an ftrace plugin to detect and profile memory access over kernel variables. It uses HW Breakpoint interfaces to 'watch memory addresses.

---
 kernel/trace/Kconfig          |   21 ++
 kernel/trace/Makefile         |    1 +
 kernel/trace/trace.h          |   23 ++
 kernel/trace/trace_ksym.c     |  525 +++++++++++++++++++++++++++++++++++++++++
 kernel/trace/trace_selftest.c |   53 ++++
 5 files changed, 623 insertions(+), 0 deletions(-)
 create mode 100644 kernel/trace/trace_ksym.c

[...]

kernel/trace/trace_ksym.c line 201

Quoted 6 lines
kernel/trace/trace_ksym.c new file +6 -0
+	entry->ksym_hbp->info.name = ksymname;
+	entry->ksym_hbp->info.type = op;
+	entry->ksym_addr = entry->ksym_hbp->info.address = addr;
+#ifdef CONFIG_X86
+	entry->ksym_hbp->info.len = HW_BREAKPOINT_LEN_4;
+#endif

What if the symbol referred to an object of size other than 4? This would clearly be incorrect in that case.

kernel/trace/trace_ksym.c line 204

Quoted 3 lines
kernel/trace/trace_ksym.c new file +3 -0
+	entry->ksym_hbp->triggered = (void *)ksym_hbp_handler;
+
+	ret = register_kernel_hw_breakpoint(entry->ksym_hbp);

I hate to sound like a broken record, but could some one explain to me again why it is a good idea to design a new API that requires processor specific #ifdefs to be sprinkled all around generic kernel code?

Back in:
http://lkml.org/lkml/2008/12/4/329
and
http://lkml.org/lkml/2009/5/21/189

I raised doubts about this hw-breakpoint thing being generic and the responses made think that the processor specific portions would be isolated in the processor specific parts of the kernel. I now see that I was wrong.

When we add sparc, MIPS, ppc... Support it would be nice to not have to add all our own #ifdefs to this, but instead have a generic interface that will not need changes.

David Daney

#13 lore raw

Re: [PATCH 11/12] hw-breakpoints: ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces

Quoted 46 lines · David Daney
Quoted 15 lines · Frederic Weisbecker

From: K.Prasad <[email protected]>

This patch adds an ftrace plugin to detect and profile memory access over kernel variables. It uses HW Breakpoint interfaces to 'watch memory addresses.

---
 kernel/trace/Kconfig          |   21 ++
 kernel/trace/Makefile         |    1 +
 kernel/trace/trace.h          |   23 ++
 kernel/trace/trace_ksym.c     |  525 +++++++++++++++++++++++++++++++++++++++++
 kernel/trace/trace_selftest.c |   53 ++++
 5 files changed, 623 insertions(+), 0 deletions(-)
 create mode 100644 kernel/trace/trace_ksym.c

[...]

kernel/trace/trace_ksym.c line 201

Quoted 6 lines
kernel/trace/trace_ksym.c new file +6 -0
+	entry->ksym_hbp->info.name = ksymname;
+	entry->ksym_hbp->info.type = op;
+	entry->ksym_addr = entry->ksym_hbp->info.address = addr;
+#ifdef CONFIG_X86
+	entry->ksym_hbp->info.len = HW_BREAKPOINT_LEN_4;
+#endif

What if the symbol referred to an object of size other than 4? This would clearly be incorrect in that case.

kernel/trace/trace_ksym.c line 204

Quoted 3 lines
kernel/trace/trace_ksym.c new file +3 -0
+	entry->ksym_hbp->triggered = (void *)ksym_hbp_handler;
+
+	ret = register_kernel_hw_breakpoint(entry->ksym_hbp);

I hate to sound like a broken record, but could some one explain to me again why it is a good idea to design a new API that requires processor specific #ifdefs to be sprinkled all around generic kernel code?

Back in:
http://lkml.org/lkml/2008/12/4/329
and
http://lkml.org/lkml/2009/5/21/189

I raised doubts about this hw-breakpoint thing being generic and the responses made think that the processor specific portions would be isolated in the processor specific parts of the kernel. I now see that I was wrong.

Quoted 5 lines

When we add sparc, MIPS, ppc... Support it would be nice to not have to add all our own #ifdefs to this, but instead have a generic interface that will not need changes.

David Daney

I was discussing about it with Prasad few hours ago :)

The fact is that archs support the hardware breakpoints in very different ways each.
Some of them support read breakpoint, others not (x86). Some support addresses range, others (x86).

But still it would be nice to gather the most common breakpoints operations through a real generic wrapper that relies on arch specific implmentation in background.

Such as setting very simple x/w/r breakpoints...

Well Prasad and Alan Stern could tell more about it, I wait for their answer.

Anyway it's a fairly new Api that can still evolve. The basis are set but can still be improved and more high level and generic things can still be implemented.

#14 lore raw

Re: [PATCH 11/12] hw-breakpoints: ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces

Quoted 50 lines · Frederic Weisbecker
Quoted 36 lines · David Daney
Quoted 15 lines · Frederic Weisbecker

From: K.Prasad <[email protected]>

This patch adds an ftrace plugin to detect and profile memory access over kernel variables. It uses HW Breakpoint interfaces to 'watch memory addresses.

---
 kernel/trace/Kconfig          |   21 ++
 kernel/trace/Makefile         |    1 +
 kernel/trace/trace.h          |   23 ++
 kernel/trace/trace_ksym.c     |  525 +++++++++++++++++++++++++++++++++++++++++
 kernel/trace/trace_selftest.c |   53 ++++
 5 files changed, 623 insertions(+), 0 deletions(-)
 create mode 100644 kernel/trace/trace_ksym.c

[...]

kernel/trace/trace_ksym.c line 201

Quoted 6 lines
kernel/trace/trace_ksym.c new file +6 -0
+	entry->ksym_hbp->info.name = ksymname;
+	entry->ksym_hbp->info.type = op;
+	entry->ksym_addr = entry->ksym_hbp->info.address = addr;
+#ifdef CONFIG_X86
+	entry->ksym_hbp->info.len = HW_BREAKPOINT_LEN_4;
+#endif

What if the symbol referred to an object of size other than 4? This would clearly be incorrect in that case.

kernel/trace/trace_ksym.c line 204

Quoted 3 lines
kernel/trace/trace_ksym.c new file +3 -0
+	entry->ksym_hbp->triggered = (void *)ksym_hbp_handler;
+
+	ret = register_kernel_hw_breakpoint(entry->ksym_hbp);

I hate to sound like a broken record, but could some one explain to me again why it is a good idea to design a new API that requires processor specific #ifdefs to be sprinkled all around generic kernel code?

Back in:
http://lkml.org/lkml/2008/12/4/329
and
http://lkml.org/lkml/2009/5/21/189

Quoted 5 lines

I raised doubts about this hw-breakpoint thing being generic and the responses made think that the processor specific portions would be isolated in the processor specific parts of the kernel. I now see that I was wrong.

When we add sparc, MIPS, ppc... Support it would be nice to not have to add all our own #ifdefs to this, but instead have a generic interface that will not need changes.

David Daney

I was discussing about it with Prasad few hours ago :)

The fact is that archs support the hardware breakpoints in very different ways each.
Some of them support read breakpoint, others not (x86). Some support addresses range, others (x86).

Quoted 5 lines

But still it would be nice to gather the most common breakpoints operations through a real generic wrapper that relies on arch specific implmentation in background.

Thanks for taking the time to think about it. I do think this patch set will be useful.

One thing I was thinking was that when I am using gdb, all I have to do is say 'watch symbol' and the differences in hardware breakpoint facilities are abstracted away. Having similar abstraction in this kernel API should be possible as well.

David Daney

#15 lore raw

Re: [PATCH 11/12] hw-breakpoints: ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces

In reply to Frederic Weisbecker
Quoted 36 lines · Frederic Weisbecker
Quoted 17 lines · David Daney
Quoted 1 line · Frederic Weisbecker

From: K.Prasad <[email protected]>

I hate to sound like a broken record, but could some one explain to me again why it is a good idea to design a new API that requires processor specific #ifdefs to be sprinkled all around generic kernel code?

Back in:
http://lkml.org/lkml/2008/12/4/329
and
http://lkml.org/lkml/2009/5/21/189

I raised doubts about this hw-breakpoint thing being generic and the responses made think that the processor specific portions would be isolated in the processor specific parts of the kernel. I now see that I was wrong.

Quoted 5 lines

When we add sparc, MIPS, ppc... Support it would be nice to not have to add all our own #ifdefs to this, but instead have a generic interface that will not need changes.

David Daney

I was discussing about it with Prasad few hours ago :)

The fact is that archs support the hardware breakpoints in very different ways each.
Some of them support read breakpoint, others not (x86). Some support addresses range, others (x86).

But still it would be nice to gather the most common breakpoints operations through a real generic wrapper that relies on arch specific implmentation in background.

Quoted 9 lines

Such as setting very simple x/w/r breakpoints...

Well Prasad and Alan Stern could tell more about it, I wait for their answer.

Anyway it's a fairly new Api that can still evolve. The basis are set but can still be improved and more high level and generic things can still be implemented.

I think this concern can be partially addressed, atleast as far as the breakpoint length is concerned. I've added my comments in the response to David Daney here: http://lkml.org/lkml/2009/6/4/303.

Hope that the changes proposed there is acceptable to the community.

Thanks,
K.Prasad

#16 lore raw

Re: [PATCH 11/12] hw-breakpoints: ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces

Quoted 47 lines · K.Prasad
Quoted 36 lines · Frederic Weisbecker
Quoted 17 lines · David Daney
Quoted 1 line · Frederic Weisbecker

From: K.Prasad <[email protected]>

I hate to sound like a broken record, but could some one explain to me again why it is a good idea to design a new API that requires processor specific #ifdefs to be sprinkled all around generic kernel code?

Back in:
http://lkml.org/lkml/2008/12/4/329
and
http://lkml.org/lkml/2009/5/21/189

I raised doubts about this hw-breakpoint thing being generic and the responses made think that the processor specific portions would be isolated in the processor specific parts of the kernel. I now see that I was wrong.

Quoted 5 lines

When we add sparc, MIPS, ppc... Support it would be nice to not have to add all our own #ifdefs to this, but instead have a generic interface that will not need changes.

David Daney

I was discussing about it with Prasad few hours ago :)

The fact is that archs support the hardware breakpoints in very different ways each.
Some of them support read breakpoint, others not (x86). Some support addresses range, others (x86).

But still it would be nice to gather the most common breakpoints operations through a real generic wrapper that relies on arch specific implmentation in background.

Quoted 9 lines

Such as setting very simple x/w/r breakpoints...

Well Prasad and Alan Stern could tell more about it, I wait for their answer.

Anyway it's a fairly new Api that can still evolve. The basis are set but can still be improved and more high level and generic things can still be implemented.

Quoted 5 lines

I think this concern can be partially addressed, atleast as far as the breakpoint length is concerned. I've added my comments in the response to David Daney here: http://lkml.org/lkml/2009/6/4/303.

Hope that the changes proposed there is acceptable to the community.

Yeah, I think it's worth trying it.

Btw, I see there is no easy way to implement read breapoints in x86. I guess the only solution would be to use the instruction decoder sent recently by Masami for the kprobe tracer, coupled with RW breakpoints.

Quoted 3 lines

Thanks,
K.Prasad

#17 lore raw

Re: [PATCH 11/12] hw-breakpoints: ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces

In reply to David Daney
Quoted 17 lines · David Daney
Quoted 15 lines · Frederic Weisbecker

From: K.Prasad <[email protected]>

This patch adds an ftrace plugin to detect and profile memory access over kernel variables. It uses HW Breakpoint interfaces to 'watch memory addresses.

---
 kernel/trace/Kconfig          |   21 ++
 kernel/trace/Makefile         |    1 +
 kernel/trace/trace.h          |   23 ++
 kernel/trace/trace_ksym.c     |  525 +++++++++++++++++++++++++++++++++++++++++
 kernel/trace/trace_selftest.c |   53 ++++
 5 files changed, 623 insertions(+), 0 deletions(-)
 create mode 100644 kernel/trace/trace_ksym.c

[...]

Quoted 10 lines

kernel/trace/trace_ksym.c line 201

Quoted 6 lines
kernel/trace/trace_ksym.c new file +6 -0
+	entry->ksym_hbp->info.name = ksymname;
+	entry->ksym_hbp->info.type = op;
+	entry->ksym_addr = entry->ksym_hbp->info.address = addr;
+#ifdef CONFIG_X86
+	entry->ksym_hbp->info.len = HW_BREAKPOINT_LEN_4;
+#endif

What if the symbol referred to an object of size other than 4? This would clearly be incorrect in that case.

I don't see a way in which we could automatically detect the size of a variable using the symbol name and use that as the 'len' (as this would be the ideal case). However, in this case we can circumvent this problem by using the least of the possible lengths (HW_BREAKPOINT_LEN_1 for x86) as it would be valid for symbols of all sizes. I will change this. Thanks for pointing it out!

Quoted 18 lines

kernel/trace/trace_ksym.c line 204

Quoted 3 lines
kernel/trace/trace_ksym.c new file +3 -0
+	entry->ksym_hbp->triggered = (void *)ksym_hbp_handler;
+
+	ret = register_kernel_hw_breakpoint(entry->ksym_hbp);

I hate to sound like a broken record, but could some one explain to me again why it is a good idea to design a new API that requires processor specific #ifdefs to be sprinkled all around generic kernel code?

Back in:
http://lkml.org/lkml/2008/12/4/329
and
http://lkml.org/lkml/2009/5/21/189

I raised doubts about this hw-breakpoint thing being generic and the responses made think that the processor specific portions would be isolated in the processor specific parts of the kernel. I now see that I was wrong.

Quoted 5 lines

When we add sparc, MIPS, ppc... Support it would be nice to not have to add all our own #ifdefs to this, but instead have a generic interface that will not need changes.

David Daney

One of the ways in which we could do this for 'len' field is to allow numeric lengths to be specified (as suggested by David Gibson in another mail thread), say "entry->ksym_hbp->info.len = 4;".

The length encoding based on register layout can be done in arch-specific code. I think this would make the code more usable and I should be implementing it in a patch soon.

As far as the 'type' information is concerned, some of the common breakpoint types (such as HW_BREAKPOINT_READ, HW_BREAKPOINT_WRITE, HW_BREAKPOINT_EXECUTE) can be defined in generic files and as NULL for those architectures that don't implement them.

However it might be a source of confusion to the end-user about supported breakpoint types on a given architecture.

Thanks,
K.Prasad

#18 lore raw

Re: [PATCH 11/12] hw-breakpoints: ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces

Quoted 29 lines · K.Prasad
Quoted 17 lines · David Daney
Quoted 15 lines · Frederic Weisbecker

From: K.Prasad <[email protected]>

This patch adds an ftrace plugin to detect and profile memory access over kernel variables. It uses HW Breakpoint interfaces to 'watch memory addresses.

---
 kernel/trace/Kconfig          |   21 ++
 kernel/trace/Makefile         |    1 +
 kernel/trace/trace.h          |   23 ++
 kernel/trace/trace_ksym.c     |  525 +++++++++++++++++++++++++++++++++++++++++
 kernel/trace/trace_selftest.c |   53 ++++
 5 files changed, 623 insertions(+), 0 deletions(-)
 create mode 100644 kernel/trace/trace_ksym.c

[...]

Quoted 10 lines

kernel/trace/trace_ksym.c line 201

Quoted 6 lines
kernel/trace/trace_ksym.c new file +6 -0
+	entry->ksym_hbp->info.name = ksymname;
+	entry->ksym_hbp->info.type = op;
+	entry->ksym_addr = entry->ksym_hbp->info.address = addr;
+#ifdef CONFIG_X86
+	entry->ksym_hbp->info.len = HW_BREAKPOINT_LEN_4;
+#endif

What if the symbol referred to an object of size other than 4? This would clearly be incorrect in that case.

Quoted 6 lines

I don't see a way in which we could automatically detect the size of a variable using the symbol name and use that as the 'len' (as this would be the ideal case). However, in this case we can circumvent this problem by using the least of the possible lengths (HW_BREAKPOINT_LEN_1 for x86) as it would be valid for symbols of all sizes. I will change this. Thanks for pointing it out!

Indeed, that looks a good solution.

Quoted 24 lines
Quoted 18 lines

kernel/trace/trace_ksym.c line 204

Quoted 3 lines
kernel/trace/trace_ksym.c new file +3 -0
+	entry->ksym_hbp->triggered = (void *)ksym_hbp_handler;
+
+	ret = register_kernel_hw_breakpoint(entry->ksym_hbp);

I hate to sound like a broken record, but could some one explain to me again why it is a good idea to design a new API that requires processor specific #ifdefs to be sprinkled all around generic kernel code?

Back in:
http://lkml.org/lkml/2008/12/4/329
and
http://lkml.org/lkml/2009/5/21/189

I raised doubts about this hw-breakpoint thing being generic and the responses made think that the processor specific portions would be isolated in the processor specific parts of the kernel. I now see that I was wrong.

Quoted 5 lines

When we add sparc, MIPS, ppc... Support it would be nice to not have to add all our own #ifdefs to this, but instead have a generic interface that will not need changes.

David Daney

Quoted 7 lines

One of the ways in which we could do this for 'len' field is to allow numeric lengths to be specified (as suggested by David Gibson in another mail thread), say "entry->ksym_hbp->info.len = 4;".

The length encoding based on register layout can be done in arch-specific code. I think this would make the code more usable and I should be implementing it in a patch soon.

Yeah, but are you sure every arch support length encoding based breakpoints? May be such information should be passed in register_breakpoint instead and let the arch answer whether it supports or not this operation...

Quoted 8 lines

As far as the 'type' information is concerned, some of the common breakpoint types (such as HW_BREAKPOINT_READ, HW_BREAKPOINT_WRITE, HW_BREAKPOINT_EXECUTE) can be defined in generic files and as NULL for those architectures that don't implement them.

However it might be a source of confusion to the end-user about supported breakpoint types on a given architecture.

Indeed but I think it's still worth. The Api documentation could be thought with a section on which we can find the operations that are supported by every archs.

Quoted 4 lines

Thanks,
K.Prasad

#19 lore raw

PATCH 12/12 hw-breakpoints: reset bits in dr6 after the corresponding exception is handled

In reply to Frederic Weisbecker

From: K.Prasad <[email protected]>

This patch resets the bit in dr6 after the corresponding exception is handled in code, so that we keep a clean track of the current virtual debug status register.

[ Impact: keep track of breakpoints triggering completion ]

---
 arch/x86/kernel/hw_breakpoint.c |   13 +++++++++++--
 arch/x86/kernel/kgdb.c          |    6 ++++++
 arch/x86/kernel/kprobes.c       |    9 ++++++++-
 arch/x86/kernel/traps.c         |    4 ++--
 arch/x86/mm/kmmio.c             |    8 +++++++-
 5 files changed, 34 insertions(+), 6 deletions(-)
arch/x86/kernel/hw_breakpoint.c +11 -2
index 4867c9f..6945147 100644
@@ -314,8 +314,12 @@ int __kprobes hw_breakpoint_handler(struct die_args *args)
 {
 	int i, cpu, rc = NOTIFY_STOP;
 	struct hw_breakpoint *bp;
-	/* The DR6 value is stored in args->err */
-	unsigned long dr7, dr6 = args->err;
+	unsigned long dr7, dr6;
+	unsigned long *dr6_p;
+
+	/* The DR6 value is pointed by args->err */
+	dr6_p = (unsigned long *)ERR_PTR(args->err);
+	dr6 = *dr6_p;
 
 	/* Do an early return if no trap bits are set in DR6 */
 	if ((dr6 & DR_TRAP_BITS) == 0)
@@ -352,6 +356,11 @@ int __kprobes hw_breakpoint_handler(struct die_args *args)
 				rc = NOTIFY_DONE;
 		}
 		/*
+		 * Reset the 'i'th TRAP bit in dr6 to denote completion of
+		 * exception handling
+		 */
+		(*dr6_p) &= ~(DR_TRAP0 << i);
+		/*
 		 * bp can be NULL due to lazy debug register switching
 		 * or due to the delay between updates of hbp_kernel_pos
 		 * and this_hbp_kernel.
arch/x86/kernel/kgdb.c +6 -0
index b1f4dff..f820b73 100644
@@ -43,6 +43,7 @@
 #include <linux/smp.h>
 #include <linux/nmi.h>
 
+#include <asm/debugreg.h>
 #include <asm/apicdef.h>
 #include <asm/system.h>
 
@@ -434,6 +435,11 @@ single_step_cont(struct pt_regs *regs, struct die_args *args)
 			"resuming...\n");
 	kgdb_arch_handle_exception(args->trapnr, args->signr,
 				   args->err, "c", "", regs);
+	/*
+	 * Reset the BS bit in dr6 (pointed by args->err) to
+	 * denote completion of processing
+	 */
+	(*(unsigned long *)ERR_PTR(args->err)) &= ~DR_STEP;
 
 	return NOTIFY_STOP;
 }
arch/x86/kernel/kprobes.c +8 -1
index 7b5169d..b5b1848 100644
@@ -54,6 +54,7 @@
 #include <asm/pgtable.h>
 #include <asm/uaccess.h>
 #include <asm/alternative.h>
+#include <asm/debugreg.h>
 
 void jprobe_return_end(void);
 
@@ -967,8 +968,14 @@ int __kprobes kprobe_exceptions_notify(struct notifier_block *self,
 			ret = NOTIFY_STOP;
 		break;
 	case DIE_DEBUG:
-		if (post_kprobe_handler(args->regs))
+		if (post_kprobe_handler(args->regs)) {
+			/*
+			 * Reset the BS bit in dr6 (pointed by args->err) to
+			 * denote completion of processing
+			 */
+			(*(unsigned long *)ERR_PTR(args->err)) &= ~DR_STEP;
 			ret = NOTIFY_STOP;
+		}
 		break;
 	case DIE_GPF:
 		/*
arch/x86/kernel/traps.c +2 -2
index de99132..124a4d5 100644
@@ -545,8 +545,8 @@ dotraplinkage void __kprobes do_debug(struct pt_regs *regs, long error_code)
 	/* Store the virtualized DR6 value */
 	tsk->thread.debugreg6 = dr6;
 
-	if (notify_die(DIE_DEBUG, "debug", regs, dr6, error_code,
-						SIGTRAP) == NOTIFY_STOP)
+	if (notify_die(DIE_DEBUG, "debug", regs, PTR_ERR(&dr6), error_code,
+							SIGTRAP) == NOTIFY_STOP)
 		return;
 
 	/* It's safe to allow irq's after DR6 has been saved */
arch/x86/mm/kmmio.c +7 -1
index 16ccbd7..11a4ad4 100644
@@ -540,8 +540,14 @@ kmmio_die_notifier(struct notifier_block *nb, unsigned long val, void *args)
 	struct die_args *arg = args;
 
 	if (val == DIE_DEBUG && (arg->err & DR_STEP))
-		if (post_kmmio_handler(arg->err, arg->regs) == 1)
+		if (post_kmmio_handler(arg->err, arg->regs) == 1) {
+			/*
+			 * Reset the BS bit in dr6 (pointed by args->err) to
+			 * denote completion of processing
+			 */
+			(*(unsigned long *)ERR_PTR(arg->err)) &= ~DR_STEP;
 			return NOTIFY_STOP;
+		}
 
 	return NOTIFY_DONE;
 }
Signature · 1 line
1.6.2.3