hw-breakpoints: new hardware breakpoints API
Subsystems (7)
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
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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -163,10 +163,10 @@ static void fix_processor_context(void)* Now maybe reload the debug registers */ if (current->thread.debugreg7){ -loaddebug (¤t->thread,0 ); -loaddebug (¤t->thread,1 ); -loaddebug (¤t->thread,2 ); -loaddebug (¤t->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 (¤t->thread,6 );loaddebug (¤t->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
PATCH 2/12 hw-breakpoints: introducing generic hardware breakpoint handler interfaces
In reply to Frederic WeisbeckerFrom: 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
@@ -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
@@ -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
PATCH 3/12 hw-breakpoints: x86 architecture implementation of Hardware Breakpoint interfaces
In reply to Frederic WeisbeckerFrom: 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
@@ -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
@@ -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
PATCH 4/12 hw-breakpoints: modifying generic debug exception to use thread-specific debug registers
In reply to Frederic WeisbeckerFrom: 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
@@ -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
PATCH 5/12 hw-breakpoints: use wrapper routines around debug registers in processor related functions
In reply to Frederic WeisbeckerFrom: 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
@@ -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
@@ -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
@@ -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 (¤t->thread,6 ); -loaddebug (¤t->thread,7 ); - } +load_debug_registers (); }
Signature · 1 line
1.6.2.3
PATCH 6/12 hw-breakpoints: use the new wrapper routines to access debug registers in process/thread code
In reply to Frederic WeisbeckerFrom: 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
@@ -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
@@ -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
@@ -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
PATCH 7/12 hw-breakpoints: modify signal handling code to refrain from re-enabling HW Breakpoints
In reply to Frederic WeisbeckerFrom: 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
@@ -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
PATCH 8/12 hw-breakpoints: modify Ptrace routines to access breakpoint registers
In reply to Frederic WeisbeckerFrom: 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
@@ -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
PATCH 9/12 hw-breakpoints: cleanup HW Breakpoint registers before kexec
In reply to Frederic WeisbeckerFrom: 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
@@ -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
@@ -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
PATCH 10/12 hw-breakpoints: sample HW breakpoint over kernel data address
In reply to Frederic WeisbeckerFrom: 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
@@ -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
@@ -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
@@ -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
PATCH 11/12 hw-breakpoints: ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces
In reply to Frederic WeisbeckerFrom: 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
@@ -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
@@ -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
@@ -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
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.
Signed-off-by K.Prasad <[email protected]>Signed-off-by Frederic Weisbecker <[email protected]>--- 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
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.
Signed-off-by K.Prasad <[email protected]>Signed-off-by Frederic Weisbecker <[email protected]>--- 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/189I 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.
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.
Signed-off-by K.Prasad <[email protected]>Signed-off-by Frederic Weisbecker <[email protected]>--- 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/189Quoted 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
Re: [PATCH 11/12] hw-breakpoints: ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces
In reply to Frederic WeisbeckerQuoted 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/189I 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
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/189I 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
Re: [PATCH 11/12] hw-breakpoints: ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces
In reply to David DaneyQuoted 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.
Signed-off-by K.Prasad <[email protected]>Signed-off-by Frederic Weisbecker <[email protected]>--- 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/189I 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
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.
Signed-off-by K.Prasad <[email protected]>Signed-off-by Frederic Weisbecker <[email protected]>--- 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_1for 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/189I 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
PATCH 12/12 hw-breakpoints: reset bits in dr6 after the corresponding exception is handled
In reply to Frederic WeisbeckerFrom: 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
had a quick testrun with this and triggered a build failure:
kernel/trace/trace_ksym.c:226: error: ksym_tracer_mutex undeclared (first use in this function)
Ingo