Prepare the code for Hardware Breakpoint interfaces
Subsystems (4)
A message that is not in the archive (sent off-list or not yet received): 20090424055710.764502564@prasadkr_t60p.in.ibm.com
PATCH 1/12 Prepare the code for Hardware Breakpoint interfaces
This patch introduces header files containing constants, structure definitions and declaration of functions used by the hardware breakpoint interface code.
--- arch/x86/include/asm/debugreg.h | 31 +++++++ arch/x86/include/asm/hw_breakpoint.h | 69 +++++++++++++++++ arch/x86/include/asm/processor.h | 4 + include/asm-generic/hw_breakpoint.h | 140 +++++++++++++++++++++++++++++++++++ 4 files changed, 244 insertions(+)
asm-generic/hw_breakpoint.h new file +140 -0
@@ -0,0 +1,140 @@ +#ifndef _ASM_GENERIC_HW_BREAKPOINT_H +#define _ASM_GENERIC_HW_BREAKPOINT_H + +#ifndef __ARCH_HW_BREAKPOINT_H +#error "Please don't include this file directly" +#endif + +#ifdef __KERNEL__ +#include <linux/list.h> +#include <linux/types.h> +#include <linux/kallsyms.h> + +/** +* struct hw_breakpoint - unified kernel/user-space hardware breakpoint +* @triggered: callback invoked after target address access +* @info: arch-specific breakpoint info (address, length, and type) +* +* %hw_breakpoint structures are the kernel's way of representing +* hardware breakpoints. These are data breakpoints +* (also known as "watchpoints", triggered on data access), and the breakpoint's +* target address can be located in either kernel space or user space. +* +* The breakpoint's address, length, and type are highly +* architecture-specific. The values are encoded in the @info field; you +* specify them when registering the breakpoint. To examine the encoded +* values use hw_breakpoint_get_{kaddress,uaddress,len,type}(), declared +* below. +* +* The address is specified as a regular kernel pointer (for kernel-space +* breakponts) or as an %__user pointer (for user-space breakpoints). +* With register_user_hw_breakpoint(), the address must refer to a +* location in user space. The breakpoint will be active only while the +* requested task is running. Conversely with +* register_kernel_hw_breakpoint(), the address must refer to a location +* in kernel space, and the breakpoint will be active on all CPUs +* regardless of the current task. +* +* The length is the breakpoint's extent in bytes, which is subject to +* certain limitations. include/asm/hw_breakpoint.h contains macros +* defining the available lengths for a specific architecture. Note that +* the address's alignment must match the length. The breakpoint will +* catch accesses to any byte in the range from address to address + +* (length - 1). +* +* The breakpoint's type indicates the sort of access that will cause it +* to trigger. Possible values may include: +* +* %HW_BREAKPOINT_RW (triggered on read or write access), +* %HW_BREAKPOINT_WRITE (triggered on write access), and +* %HW_BREAKPOINT_READ (triggered on read access). +* +* Appropriate macros are defined in include/asm/hw_breakpoint.h; not all +* possibilities are available on all architectures. Execute breakpoints +* must have length equal to the special value %HW_BREAKPOINT_LEN_EXECUTE. +* +* When a breakpoint gets hit, the @triggered callback is +* invoked in_interrupt with a pointer to the %hw_breakpoint structure and the +* processor registers. +* Data breakpoints occur after the memory access has taken place. +* Breakpoints are disabled during execution @triggered, to avoid +* recursive traps and allow unhindered access to breakpointed memory. +* +* This sample code sets a breakpoint on pid_max and registers a callback +* function for writes to that variable. Note that it is not portable +* as written, because not all architectures support HW_BREAKPOINT_LEN_4. +* +* ---------------------------------------------------------------------- +* +* #include <asm/hw_breakpoint.h> +* +* struct hw_breakpoint my_bp; +* +* static void my_triggered(struct hw_breakpoint *bp, struct pt_regs *regs) +* { +* printk(KERN_DEBUG "Inside triggered routine of breakpoint exception\n"); +* dump_stack(); +* .......<more debugging output>........ +* } +* +* static struct hw_breakpoint my_bp; +* +* static int init_module(void) +* { +* ..........<do anything>............ +* my_bp.info.type = HW_BREAKPOINT_WRITE; +* my_bp.info.len = HW_BREAKPOINT_LEN_4; +* +* my_bp.installed = (void *)my_bp_installed; +* +* rc = register_kernel_hw_breakpoint(&my_bp); +* ..........<do anything>............ +* } +* +* static void cleanup_module(void) +* { +* ..........<do anything>............ +* unregister_kernel_hw_breakpoint(&my_bp); +* ..........<do anything>............ +* } +* +* ---------------------------------------------------------------------- +*/ +struct hw_breakpoint { +void (*triggered)(struct hw_breakpoint *,struct pt_regs *); +struct arch_hw_breakpoint info; +}; + +/* +* len and type values are defined in include/asm/hw_breakpoint.h. +* Available values vary according to the architecture. On i386 the +* possibilities are: +* +* HW_BREAKPOINT_LEN_1 +* HW_BREAKPOINT_LEN_2 +* HW_BREAKPOINT_LEN_4 +* HW_BREAKPOINT_RW +* HW_BREAKPOINT_READ +* +* On other architectures HW_BREAKPOINT_LEN_8 may be available, and the +* 1-, 2-, and 4-byte lengths may be unavailable. There also may be +* HW_BREAKPOINT_WRITE. You can use #ifdef to check at compile time. +*/ + +int register_user_hw_breakpoint (struct task_struct *tsk, +struct hw_breakpoint *bp); +void unregister_user_hw_breakpoint (struct task_struct *tsk, +struct hw_breakpoint *bp); +/* +* Kernel breakpoints are not associated with any particular thread. +*/ +int register_kernel_hw_breakpoint (struct hw_breakpoint *bp); +void unregister_kernel_hw_breakpoint (struct hw_breakpoint *bp); +void switch_to_none_hw_breakpoint (void ); + +extern unsigned int hbp_kernel_pos; +DECLARE_PER_CPU(struct task_struct *, last_debugged_task); +extern spinlock_t hw_breakpoint_lock; + +#endif /* __KERNEL__ */ +#endif /* _ASM_GENERIC_HW_BREAKPOINT_H */
x86/include/asm/hw_breakpoint.h new file +69 -0
69 lines not on this page · raw message
x86/include/asm/debugreg.h renamed from x86/include/asm/debugreg.h.orig +31 -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,32 @@#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 */ +void flush_thread_hw_breakpoint (struct task_struct *tsk); +int copy_thread_hw_breakpoint (struct task_struct *tsk, +struct task_struct *child,unsigned long clone_flags); +void dump_thread_hw_breakpoint (struct task_struct *tsk,int u_debugreg[8 ]); +void switch_to_thread_hw_breakpoint (struct task_struct *tsk); + +/* For CPU management */ +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 */
x86/include/asm/processor.h renamed from x86/include/asm/processor.h.orig +4 -0
@@ -29,6 +29,7 @@ struct mm_struct;#include <linux/threads.h> #include <linux/init.h> +#define HB_NUM 4/* * Default implementation of macro that returns current * instruction pointer ("program counter").
@@ -435,8 +436,11 @@ struct thread_struct {unsigned long debugreg1;unsigned long debugreg2;unsigned long debugreg3; +unsigned long debugreg[HB_NUM ];unsigned long debugreg6;unsigned long debugreg7; +/* Hardware breakpoint info */ +struct hw_breakpoint *hbp[HB_NUM ];/* Fault info: */ unsigned long cr2;unsigned long trap_no;
PATCH 2/12 Introducing generic hardware breakpoint handler interfaces
In reply to a message not in the archiveThis patch introduces the generic Hardware Breakpoint interfaces for both user and kernel space requests.
--- arch/Kconfig | 4 kernel/Makefile | 1 kernel/hw_breakpoint.c | 364 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 369 insertions(+)
Kconfig renamed from Kconfig.orig +4 -0
@@ -112,3 +112,7 @@ config HAVE_DMA_API_DEBUG config HAVE_DEFAULT_NO_SPIN_MUTEXES bool + +config HAVE_HW_BREAKPOINT + bool +
Makefile renamed from Makefile.orig +1 -0
@@ -97,6 +97,7 @@ obj-$(CONFIG_X86_DS) += trace/ obj-$(CONFIG_SMP) += sched_cpupri.o obj-$(CONFIG_SLOW_WORK) += slow-work.o obj-$(CONFIG_PERF_COUNTERS) += perf_counter.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
hw_breakpoint.c new file +364 -0
364 lines not on this page · raw message
PATCH 3/12 x86 architecture implementation of Hardware Breakpoint interfaces
In reply to a message not in the archiveThis patch introduces the arch-specific implementation of hw_breakpoint.c inside x86 specific directories. They contain functions which help validate and serve requests for using Hardware Breakpoint registers on x86 processors.
--- arch/x86/Kconfig | 1 arch/x86/kernel/Makefile | 2 arch/x86/kernel/hw_breakpoint.c | 366 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 368 insertions(+), 1 deletion(-)
x86/Kconfig renamed from x86/Kconfig.orig +1 -0
@@ -47,6 +47,7 @@ config X86 select HAVE_KERNEL_LZMA select HAVE_ARCH_KMEMCHECK select HAVE_DMA_API_DEBUG + select HAVE_HW_BREAKPOINT config ARCH_DEFCONFIG string
x86/kernel/Makefile renamed from x86/kernel/Makefile.orig +1 -1
@@ -36,7 +36,7 @@ obj-$(CONFIG_X86_64) += sys_x86_64.o x86 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
x86/kernel/hw_breakpoint.c new file +366 -0
366 lines not on this page · raw message
PATCH 4/12 Modifying generic debug exception to use thread-specific debug registers
In reply to a message not in the archiveFrom: Alan Stern <[email protected]>
This patch modifies the breakpoint exception handler code to use the abstract register names.
[K.Prasad: Split-out from the bigger patch and minor changes following
re-basing]
--- arch/x86/kernel/traps.c | 76 +++++++++++++++++------------------------------- 1 file changed, 27 insertions(+), 49 deletions(-)
x86/kernel/traps.c renamed from x86/kernel/traps.c.orig +27 -49
@@ -530,76 +530,54 @@ asmlinkage __kprobes struct pt_regs *syn 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 );/* Catch kmemcheck conditions first of all! */ -if (condition &DR_STEP &&kmemcheck_trap (regs)) +if (((dr6 &DR_STEP ) &&kmemcheck_trap (regs)) && + !(dr6 &DR_TRAP_BITS ))return ; - +/* 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; - } - -#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). -*/ -if (condition &DR_STEP ) { -if (!user_mode (regs)) - goto clear_TF_reenable; +if (regs->flags &X86_VM_MASK ) { +handle_vm86_trap ((struct kernel_vm86_regs *) regs, + error_code,1 ); +return ; } - 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. +* 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. */ -clear_dr7: -set_debugreg (0 ,7 ); -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 ; +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 (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 ; }
PATCH 5/12 Use wrapper routines around debug registers in processor related functions
In reply to a message not in the archiveFrom: Alan Stern <[email protected]>
This patch enables the use of wrapper routines to access the debug/breakpoint registers.
[K.Prasad: Split-out from the bigger patch and minor changes following
re-basing]
--- arch/x86/kernel/smpboot.c | 3 +++ arch/x86/power/cpu_32.c | 16 +++------------- arch/x86/power/cpu_64.c | 15 +++------------ 3 files changed, 9 insertions(+), 25 deletions(-)
x86/kernel/smpboot.c renamed from x86/kernel/smpboot.c.orig +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_secosetup_secondary_clock ();wmb (); +load_debug_registers ();cpu_idle (); }
@@ -1252,6 +1254,7 @@ void cpu_disable_common(void)remove_cpu_from_maps (cpu);unlock_vector_lock ();fixup_irqs (); +hw_breakpoint_disable (); }int native_cpu_disable (void )
x86/power/cpu_32.c renamed from x86/power/cpu_32.c.orig +3 -13
@@ -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(struc ctxt->cr2 =read_cr2 (); ctxt->cr3 =read_cr3 (); ctxt->cr4 =read_cr4_safe (); +hw_breakpoint_disable (); }/* Needed by apm.c */
@@ -80,19 +82,7 @@ static void fix_processor_context(void)load_TR_desc ();/* This does ltr */ load_LDT (¤t->active_mm->context);/* This does lldt */ -/* -* 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 ); -/* 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)
x86/power/cpu_64.c renamed from x86/power/cpu_64.c.orig +3 -12
@@ -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(struc ctxt->cr3 =read_cr3 (); ctxt->cr4 =read_cr4 (); ctxt->cr8 =read_cr8 (); +hw_breakpoint_disable (); }void save_processor_state (void )
@@ -159,16 +161,5 @@ static void fix_processor_context(void)load_TR_desc ();/* This does ltr */ load_LDT (¤t->active_mm->context);/* This does lldt */ -/* -* 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 ); -/* no 4 and 5 */ -loaddebug (¤t->thread,6 ); -loaddebug (¤t->thread,7 ); - } +load_debug_registers (); }
PATCH 6/12 Use the new wrapper routines to access debug registers in process/thread code
In reply to a message not in the archiveFrom: Alan Stern <[email protected]>
This patch enables the use of abstract debug registers in process-handling routines.
[K.Prasad: Split-out from the bigger patch and minor changes following
re-basing]
--- arch/x86/include/asm/processor.h | 4 ---- arch/x86/kernel/process.c | 23 ++++++----------------- arch/x86/kernel/process_32.c | 31 +++++++++++++++++++++++++++++++ arch/x86/kernel/process_64.c | 33 +++++++++++++++++++++++++++++++++ 4 files changed, 70 insertions(+), 21 deletions(-)
x86/kernel/process.c renamed from x86/kernel/process.c.orig +6 -17
@@ -16,6 +16,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);
@@ -47,6 +49,8 @@ void free_thread_xstate(struct task_strukmem_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" ); }
@@ -105,14 +109,9 @@ void flush_thread(void) }#endif -clear_tsk_thread_flag (tsk,TIF_DEBUG ); +if (unlikely (test_tsk_thread_flag (tsk,TIF_DEBUG ))) +flush_thread_hw_breakpoint (tsk); - tsk->thread.debugreg0 =0 ; - tsk->thread.debugreg1 =0 ; - tsk->thread.debugreg2 =0 ; - tsk->thread.debugreg3 =0 ; - tsk->thread.debugreg6 =0 ; - tsk->thread.debugreg7 =0 ;memset (tsk->thread.tls_array,0 ,sizeof (tsk->thread.tls_array));/* * Forget coprocessor state..
@@ -194,16 +193,6 @@ void __switch_to_xtra(struct task_structelse if (next->debugctlmsr != prev->debugctlmsr)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 ); -/* 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 */
x86/kernel/process_32.c renamed from x86/kernel/process_32.c.orig +31 -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,14 @@ int copy_thread(unsigned long clone_flagtask_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 +294,13 @@ int copy_thread(unsigned long clone_flag 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 +439,25 @@ __switch_to(struct task_struct *prev_p,lazy_load_gs (next->gs);percpu_write (current_task, next_p); +/* +* There's a problem with moving the switch_to_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 current is different from the task pointer stored in +* last_debugged_task, so it will think the task pointer 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 +* last_debugged_task 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 last_debugged_task is +* old. But if you move the code above then you'll create a window in +* which current is old and last_debugged_task is correct. +*/ +if (unlikely (test_tsk_thread_flag (next_p,TIF_DEBUG ))) +switch_to_thread_hw_breakpoint (next_p);return prev_p; }
x86/kernel/process_64.c renamed from x86/kernel/process_64.c.orig +33 -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 *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_flag 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,26 @@ __switch_to(struct task_struct *prev_p,*/ if (tsk_used_math (next_p) && next_p->fpu_counter >5 )math_state_restore (); +/* +* There's a problem with moving the switch_to_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 current is different from the task pointer stored in +* last_debugged_task, so it will think the task pointer 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 +* last_debugged_task 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 last_debugged_task is +* old. But if you move the code above then you'll create a window in +* which current is old and last_debugged_task is correct. +*/ +if (unlikely (test_tsk_thread_flag (next_p,TIF_DEBUG ))) +switch_to_thread_hw_breakpoint (next_p); +return prev_p; }
x86/include/asm/processor.h renamed from x86/include/asm/processor.h.orig +0 -4
@@ -432,10 +432,6 @@ 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[HB_NUM ];unsigned long debugreg6;unsigned long debugreg7;
PATCH 7/12 Modify signal handling code to refrain from re-enabling HW Breakpoints
In reply to a message not in the archiveFrom: Alan Stern <[email protected]>
This patch disables re-enabling of Hardware Breakpoint registers through the signal handling code. This is now done during hw_breakpoint_handler().
--- arch/x86/kernel/signal.c | 9 --------- 1 file changed, 9 deletions(-)
x86/kernel/signal.c renamed from x86/kernel/signal.c.orig +0 -9
@@ -799,15 +799,6 @@ static void do_signal(struct pt_regs *re 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 ) {/*
PATCH 8/12 Modify Ptrace routines to access breakpoint registers
In reply to a message not in the archiveThis patch modifies the ptrace code to use the new wrapper routines around the debug/breakpoint registers.
--- arch/x86/kernel/ptrace.c | 239 +++++++++++++++++++++++++++++------------------ 1 file changed, 149 insertions(+), 90 deletions(-)
x86/kernel/ptrace.c renamed from x86/kernel/ptrace.c.orig +149 -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_s 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_s 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,167 @@ static int genregs_set(struct task_struc }/* -* 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.debugreg0; -case 1 :return child->thread.debugreg1; -case 2 :return child->thread.debugreg2; -case 3 :return child->thread.debugreg3; -case 6 :return child->thread.debugreg6; -case 7 :return child->thread.debugreg7; - } -return 0 ; +int temp = dr7 >> (DR_CONTROL_SHIFT + bpnum *DR_CONTROL_SIZE ); + + *len = (temp &0xc ) |0x40 ; + *type = (temp &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.debugreg0 = data;break ; -case 1 : child->thread.debugreg1 = data;break ; -case 2 : child->thread.debugreg2 = data;break ; -case 3 : child->thread.debugreg3 = 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, rc =0 ; +int enabled; +unsigned len, type; +struct hw_breakpoint *bp; +/* +* We want to use allocated memory inside a spinlock and we use the +* trick below +*/ +int temp_mem_used =0 ; +void *temp_mem =kzalloc (sizeof (struct hw_breakpoint ),GFP_KERNEL ); +if (!temp_mem) + temp_mem_used = -ENOMEM ; -case 6 : -if ((data & ~0xffffffffUL ) !=0 ) -return -EIO ; - child->thread.debugreg6 = data; -break ; + data &= ~DR_CONTROL_RESERVED ; -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 ; +restore: +/* +* Loop through all the hardware breakpoints, making the +* appropriate changes to each. +*/ +spin_lock (&hw_breakpoint_lock); + +for (i =0 ; i <HB_NUM ; i++) { + enabled =decode_dr7 (data, i, &len, &type); + bp = thread->hbp[i]; + +if (!enabled) { +if (bp) { +__unregister_user_hw_breakpoint (i, tsk); +kfree (bp); + } +continue ; + } + +if (!bp) { + rc = -ENOMEM ; +if (temp_mem_used != -ENOMEM ) { + bp = temp_mem; + bp->info.address = thread->debugreg[i]; + bp->triggered = ptrace_triggered; + bp->info.len = len; + bp->info.type = type; + temp_mem_used =1 ; + rc =__register_user_hw_breakpoint (i, tsk, bp); +if (!rc) +set_tsk_thread_flag (tsk,TIF_DEBUG ); +else +kfree (bp); + } + }else + rc =__modify_user_hw_breakpoint (i, tsk, bp); + +if (rc) +break ; + } +spin_unlock (&hw_breakpoint_lock); + +/* If anything above failed, restore the original settings */ +if (rc <0 ) { + data = old_dr7; + goto restore; } +if (temp_mem_used ==0 ) +kfree (temp_mem); -return 0 ; +return rc; +} + +/* +* 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 ; + +spin_lock (&hw_breakpoint_lock); +if (n <HB_NUM ) + val = thread->debugreg[n]; +else if (n ==6 ) + val = thread->debugreg6; +else if (n ==7 ) + val = thread->debugreg7; + +spin_unlock (&hw_breakpoint_lock); +return val; +} + +/* +* 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 <HB_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); + +ret_path: +return rc; }/*
PATCH 9/12 Cleanup HW Breakpoint registers before kexec
In reply to a message not in the archiveFrom: Alan Stern <[email protected]>
This patch disables Hardware breakpoints before doing a 'kexec' on the machine.
[K.Prasad: Split-out from the bigger patch and minor changes following
re-basing]
--- arch/x86/kernel/machine_kexec_32.c | 2 ++ arch/x86/kernel/machine_kexec_64.c | 2 ++ 2 files changed, 4 insertions(+)
x86/kernel/machine_kexec_32.c renamed from x86/kernel/machine_kexec_32.c.orig +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 @@/* Interrupts aren't acceptable while we reboot */ local_irq_disable (); +hw_breakpoint_disable ();if (image->preserve_context) {#ifdef CONFIG_X86_IO_APIC
x86/kernel/machine_kexec_64.c renamed from x86/kernel/machine_kexec_64.c.orig +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 @@/* Interrupts aren't acceptable while we reboot */ local_irq_disable (); +hw_breakpoint_disable ();if (image->preserve_context) {#ifdef CONFIG_X86_IO_APIC
PATCH 10/12 Sample HW breakpoint over kernel data address
In reply to a message not in the archiveThis 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 deletion(-)
Kconfig renamed from Kconfig.orig +6 -0
@@ -46,5 +46,11 @@ config SAMPLE_KRETPROBES default m depends on SAMPLE_KPROBES && KRETPROBES +config SAMPLE_HW_BREAKPOINT + tristate "Build kernel hardware breakpoint examples -- loadable modules only" + depends on HAVE_HW_BREAKPOINT && m + help + This builds kernel hardware breakpoint example modules. + endif # SAMPLES
Makefile renamed from Makefile.orig +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/
hw_breakpoint/Makefile new file +1 -0
@@ -0,0 +1 @@ +obj-$(CONFIG_SAMPLE_HW_BREAKPOINT) += data_breakpoint.o
hw_breakpoint/data_breakpoint.c new file +83 -0
83 lines not on this page · raw message
PATCH 11/12 ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces - v3
In reply to a message not in the archiveThis 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 | 20 + kernel/trace/trace_ksym.c | 557 ++++++++++++++++++++++++++++++++++++++++++ kernel/trace/trace_selftest.c | 37 ++ 5 files changed, 636 insertions(+)
trace/Kconfig renamed from trace/Kconfig.orig +21 -0
@@ -272,6 +272,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"
trace/Makefile renamed from trace/Makefile.orig +1 -0
@@ -50,5 +50,6 @@ obj-$(CONFIG_EVENT_TRACING) += trace_exp 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
trace/trace.h renamed from trace/trace.h.orig +20 -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,18 @@ struct syscall_trace_exit {unsigned long ret; }; +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 +340,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 )
@@ -538,6 +556,8 @@ extern int trace_selftest_startup_branch 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);
trace/trace_ksym.c new file +557 -0
557 lines not on this page · raw message
trace/trace_selftest.c renamed from trace/trace_selftest.c.orig +37 -0
@@ -17,6 +17,7 @@ static inline int trace_valid_entry(strucase TRACE_GRAPH_ENT :case TRACE_GRAPH_RET :case TRACE_HW_BRANCHES : +case TRACE_KSYM :return 1 ; }return 0 ;
@@ -807,3 +808,39 @@ trace_selftest_startup_hw_branches(struc return ret; }#endif /* CONFIG_HW_BRANCH_TRACER */ + +#ifdef CONFIG_KSYM_TRACER +int +trace_selftest_startup_ksym (struct tracer *trace,struct trace_array *tr) +{ +unsigned long count; +int ret; + +/* start the tracing */ + ret =tracer_init (trace, tr); +if (ret) { +warn_failed_init_tracer (trace, ret); +return ret; + } + +/* Sleep for a 1/10 of a second */ +msleep (100 ); +/* stop the tracing. */ +tracing_stop (); +/* check the trace buffer */ + ret =trace_test_buffer (tr, &count); + trace->reset (tr); +tracing_start (); + +/* read & write operations - one each is performed on the dummy variable +* triggering two entries in the trace buffer +*/ +if (!ret && count !=2 ) { +printk (KERN_CONT "Ksym tracer startup test failed" ); + ret =-1 ; + } + +return ret; +} +#endif /* CONFIG_KSYM_TRACER */ +
Re: [Patch 11/12] ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces - v3
Quoted 2 lines · K.Prasad
This patch adds an ftrace plugin to detect and profile memory access over kernel variables. It uses HW Breakpoint interfaces to 'watch memory addresses.
Just a small concern, but it would be nice if you could include the history of this patch in the changelogs.
Quoted 164 lines
Signed-off-by K.Prasad <[email protected]>Acked-by Steven Rostedt <[email protected]>--- kernel/trace/Kconfig | 21 + kernel/trace/Makefile | 1 kernel/trace/trace.h | 20 + kernel/trace/trace_ksym.c | 557 ++++++++++++++++++++++++++++++++++++++++++ kernel/trace/trace_selftest.c | 37 ++ 5 files changed, 636 insertions(+)Index:
kernel/trace/Kconfig
===================================================================trace/Kconfig renamed from trace/Kconfig.orig +21
-0@@ -272,6 +272,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"Index:
kernel/trace/Makefile
===================================================================trace/Makefile renamed from trace/Makefile.orig +1
-0@@ -50,5 +50,6 @@ obj-$(CONFIG_EVENT_TRACING) += trace_exp 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.oIndex:
kernel/trace/trace.h
===================================================================trace/trace.h renamed from trace/trace.h.orig +20
-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,18 @@ struct syscall_trace_exit {unsigned long ret; }; +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 +340,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 )@@ -538,6 +556,8 @@ extern int trace_selftest_startup_branch 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);Index:
kernel/trace/trace_ksym.c
===================================================================trace/trace_ksym.c new file +47
-0@@ -0,0 +1,557 @@ +/* +* trace_ksym.c - Kernel Symbol Tracer +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation; either version 2 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +* +* Copyright (C) IBM Corporation, 2009 +*/ + +#include <linux/kallsyms.h> +#include <linux/uaccess.h> +#include <linux/debugfs.h> +#include <linux/ftrace.h> +#include <linux/module.h> +#include <linux/jhash.h> +#include <linux/fs.h> + +#include "trace_output.h" +#include "trace_stat.h" +#include "trace.h" + +/* For now, let us restrict the no. of symbols traced simultaneously to number +* of available hardware breakpoint registers. +*/ +#define KSYM_TRACER_MAX HB_NUM + +#define KSYM_TRACER_OP_LEN 3/* rw- */ +#define KSYM_FILTER_ENTRY_LEN (KSYM_NAME_LEN + KSYM_TRACER_OP_LEN + 1) + +#ifdef CONFIG_FTRACE_SELFTEST + +static int ksym_selftest_dummy; +#define KSYM_SELFTEST_ENTRY "ksym_selftest_dummy" + +#endif /* CONFIG_FTRACE_SELFTEST */ +
trace/trace_ksym.c line 57
Quoted 10 lines
trace/trace_ksym.c new file +10
-0+static struct trace_array *ksym_trace_array; + +static unsigned int ksym_filter_entry_count; +static unsigned int ksym_tracing_enabled; + +static HLIST_HEAD (ksym_filter_head); + +#ifdef CONFIG_PROFILE_KSYM_TRACER + +#define MAX_UL_INT 0xffffffff
I see your counter is an unsigned long.
Then you might prefer to restrict further on 64 bits archs:
#define MAX_UL_INT ~0UL
Which reminds me that you can find this on <linux/kernel.h>:
#define ULONG_MAX (~0UL)
Quoted 405 lines
trace/trace_ksym.c new file +405
-0+static DEFINE_SPINLOCK (ksym_tracer_lock); + +void ksym_collect_stats (unsigned long hbp_hit_addr) +{ +struct hlist_node *node; +struct trace_ksym *entry; + +spin_lock (&ksym_tracer_lock); +hlist_for_each_entry (entry, node, &ksym_filter_head, ksym_hlist) { +if ((entry->ksym_addr == hbp_hit_addr) && + (entry->counter <=MAX_UL_INT )) { + entry->counter++; +break ; + } + } +spin_unlock (&ksym_tracer_lock); +} +#endif /* CONFIG_PROFILE_KSYM_TRACER */ + +void ksym_hbp_handler (struct hw_breakpoint *hbp,struct pt_regs *regs) +{ +struct ring_buffer_event *event; +struct trace_array *tr; +struct trace_ksym *entry; +int pc; + +if (!ksym_tracing_enabled) +return ; + + tr = ksym_trace_array; + pc =preempt_count (); + + event =trace_buffer_lock_reserve (tr,TRACE_KSYM , +sizeof (*entry),0 , pc); +if (!event) +return ; + + entry =ring_buffer_event_data (event); +strlcpy (entry->ksym_name, hbp->info.name,KSYM_SYMBOL_LEN ); + entry->ksym_hbp = hbp; + entry->ip =instruction_pointer (regs); +strlcpy (entry->p_name, current->comm,TASK_COMM_LEN ); +#ifdef CONFIG_PROFILE_KSYM_TRACER +ksym_collect_stats (hbp->info.address); +#endif /* CONFIG_PROFILE_KSYM_TRACER */ + +trace_buffer_unlock_commit (tr, event,0 , pc); +} + +/* Valid access types are represented as +* +* rw- : Set Read/Write Access Breakpoint +* -w- : Set Write Access Breakpoint +* --- : Clear Breakpoints +* --x : Set Execution Break points (Not available yet) +* +*/ +static int ksym_trace_get_access_type (char *access_str) +{ +int pos, access =0 ; + +for (pos =0 ; pos <KSYM_TRACER_OP_LEN ; pos++) { +switch (access_str[pos]) { +case 'r' : + access += (pos ==0 ) ?4 :-1 ; +break ; +case 'w' : + access += (pos ==1 ) ?2 :-1 ; +break ; +case '-' : +break ; +default : +return -EINVAL ; + } + } + +switch (access) { +case 6 : + access =HW_BREAKPOINT_RW ; +break ; +case 2 : + access =HW_BREAKPOINT_WRITE ; +break ; +case 0 : + access =0 ; + } + +return access; +} + +/* +* There can be several possible malformed requests and we attempt to capture +* all of them. We enumerate some of the rules +* 1. We will not allow kernel symbols with ':' since it is used as a delimiter. +* i.e. multiple ':' symbols disallowed. Possible uses are of the form +* <module>:<ksym_name>:<op>. +* 2. No delimiter symbol ':' in the input string +* 3. Spurious operator symbols or symbols not in their respective positions +* 4. <ksym_name>:--- i.e. clear breakpoint request when ksym_name not in file +* 5. Kernel symbol not a part of /proc/kallsyms +* 6. Duplicate requests +*/ +static int parse_ksym_trace_str (char *input_string,char **ksymname, +unsigned long *addr) +{ +char *delimiter =":" ; +int ret; + + ret = -EINVAL ; + *ksymname =strsep (&input_string, delimiter); + *addr =kallsyms_lookup_name (*ksymname); + +/* Check for malformed request: (2), (1) and (5) */ +if ((!input_string) || + (strlen (input_string) != (KSYM_TRACER_OP_LEN +1 )) || + (*addr ==0 )) + goto return_code; + ret =ksym_trace_get_access_type (input_string); + +return_code: +return ret; +} + +static int process_new_ksym_entry (char *ksymname,int op,unsigned long addr) +{ +struct trace_ksym *entry; +int ret; + +if (ksym_filter_entry_count >=KSYM_TRACER_MAX ) { +printk (KERN_ERR "ksym_tracer: Maximum limit:(%d) reached. No" +" new requests for tracing can be accepted now.\n" , +KSYM_TRACER_MAX ); +return -ENOSPC ; + } + + entry =kzalloc (sizeof (struct trace_ksym ),GFP_KERNEL ); +if (!entry) +return -ENOMEM ; + + entry->ksym_hbp =kzalloc (sizeof (struct hw_breakpoint ),GFP_KERNEL ); +if (!entry->ksym_hbp) { +kfree (entry); +return -ENOMEM ; + } + + 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 + entry->ksym_hbp->triggered = (void *)ksym_hbp_handler; + + ret =register_kernel_hw_breakpoint (entry->ksym_hbp); +if (ret <0 ) { +printk (KERN_INFO "ksym_tracer request failed. Try again" +" later!!\n" ); +kfree (entry->ksym_hbp); +kfree (entry); +return -EAGAIN ; + } +hlist_add_head (&(entry->ksym_hlist), &ksym_filter_head); + ksym_filter_entry_count++; + +return 0 ; +} + +static ssize_t ksym_trace_filter_read (struct file *filp,char __user *ubuf, +size_t count,loff_t *ppos) +{ +struct trace_ksym *entry; +struct hlist_node *node; +char buf[KSYM_FILTER_ENTRY_LEN *KSYM_TRACER_MAX ]; +ssize_t ret, cnt =0 ; + +spin_lock (&ksym_tracer_lock); + +hlist_for_each_entry (entry, node, &ksym_filter_head, ksym_hlist) { + cnt +=snprintf (&buf[cnt],KSYM_FILTER_ENTRY_LEN - cnt,"%s:" , + entry->ksym_hbp->info.name); +if (entry->ksym_hbp->info.type ==HW_BREAKPOINT_WRITE ) + cnt +=snprintf (&buf[cnt],KSYM_FILTER_ENTRY_LEN - cnt, +"-w-\n" ); +else if (entry->ksym_hbp->info.type ==HW_BREAKPOINT_RW ) + cnt +=snprintf (&buf[cnt],KSYM_FILTER_ENTRY_LEN - cnt, +"rw-\n" ); + } + ret =simple_read_from_buffer (ubuf, count, ppos, buf,strlen (buf)); +spin_unlock (&ksym_tracer_lock); + +return ret; +} + +static ssize_t ksym_trace_filter_write (struct file *file, +const char __user *buffer, +size_t count,loff_t *ppos) +{ +struct trace_ksym *entry; +struct hlist_node *node; +char *input_string, *ksymname =NULL ; +unsigned long ksym_addr =0 ; +int ret, op, changed =0 ; + +/* Ignore echo "" > ksym_trace_filter */ +if (count ==0 ) +return 0 ; + + input_string =kzalloc (count,GFP_KERNEL ); +if (!input_string) +return -ENOMEM ; + +if (copy_from_user (input_string, buffer, count)) { +kfree (input_string); +return -EFAULT ; + } + + ret = op =parse_ksym_trace_str (input_string, &ksymname, &ksym_addr); +if (ret <0 ) { +kfree (input_string); +return ret; + } + +spin_lock (&ksym_tracer_lock); + + ret = -EINVAL ; +hlist_for_each_entry (entry, node, &ksym_filter_head, ksym_hlist) { +if (entry->ksym_addr == ksym_addr) { +/* Check for malformed request: (6) */ +if (entry->ksym_hbp->info.type != op) + changed =1 ; +else + goto err_ret; +break ; + } + } +if (changed) { +unregister_kernel_hw_breakpoint (entry->ksym_hbp); + entry->ksym_hbp->info.type = op; +if (op >0 ) { + ret =register_kernel_hw_breakpoint (entry->ksym_hbp); +if (ret ==0 ) { + ret = count; + goto unlock_ret_path; + } + } + ksym_filter_entry_count--; +hlist_del (&(entry->ksym_hlist)); +kfree (entry->ksym_hbp); +kfree (entry); + ret = count; + goto err_ret; + }else { +/* Check for malformed request: (4) */ +if (op ==0 ) + goto err_ret; + ret =process_new_ksym_entry (ksymname, op, ksym_addr); +if (ret) + goto err_ret; + } + ret = count; + goto unlock_ret_path; + +err_ret: +kfree (input_string); + +unlock_ret_path: +spin_unlock (&ksym_tracer_lock); +return ret; +} + +static const struct file_operations ksym_tracing_fops = { + .open = tracing_open_generic, + .read = ksym_trace_filter_read, + .write = ksym_trace_filter_write, +}; + +static void ksym_trace_reset (struct trace_array *tr) +{ +struct trace_ksym *entry; +struct hlist_node *node, *node1; + + ksym_tracing_enabled =0 ; + +spin_lock (&ksym_tracer_lock); +hlist_for_each_entry_safe (entry, node, node1, &ksym_filter_head, + ksym_hlist) { +unregister_kernel_hw_breakpoint (entry->ksym_hbp); + ksym_filter_entry_count--; +hlist_del (&(entry->ksym_hlist)); + +/* Free the 'input_string' only if reset +* after startup self-test +*/ +#ifdef CONFIG_FTRACE_SELFTEST +if (strncmp (entry->ksym_hbp->info.name,KSYM_SELFTEST_ENTRY , + strlen(KSYM_SELFTEST_ENTRY)) != 0) +#endif /* CONFIG_FTRACE_SELFTEST*/ +kfree (entry->ksym_hbp->info.name); +kfree (entry->ksym_hbp); +kfree (entry); + } +spin_unlock (&ksym_tracer_lock); + +} + +static int ksym_trace_init (struct trace_array *tr) +{ +int cpu, ret =0 ; + +for_each_online_cpu (cpu) +tracing_reset (tr, cpu); + + ksym_tracing_enabled =1 ; + ksym_trace_array = tr; + +#ifdef CONFIG_FTRACE_SELFTEST +/* Check if we are re-entering self-test code during initialisation */ +if (ksym_selftest_dummy) + goto ret_path; + + ksym_selftest_dummy =0 ; + +/* Register the read-write tracing request */ + ret =process_new_ksym_entry (KSYM_SELFTEST_ENTRY ,HW_BREAKPOINT_RW , + (unsigned long )(&ksym_selftest_dummy)); + +if (ret <0 ) { +printk (KERN_CONT "ksym_trace read-write startup test failed\n" ); + goto ret_path; + } +/* Perform a read and a write operation over the dummy variable to +* trigger the tracer +*/ +if (ksym_selftest_dummy ==0 ) + ksym_selftest_dummy++; + +ret_path: +#endif /* CONFIG_FTRACE_SELFTEST */ + +return ret; +} + +static void ksym_trace_print_header (struct seq_file *m) +{ + +seq_puts (m, +"# TASK-PID CPU# Symbol Type " +"Function \n" ); +seq_puts (m, +"# | | | | " +"| \n" ); +} + +static enum print_line_t ksym_trace_output (struct trace_iterator *iter) +{ +struct trace_entry *entry = iter->ent; +struct trace_seq *s = &iter->seq; +struct trace_ksym *field; +char str[KSYM_SYMBOL_LEN ]; +int ret; + +if (entry->type !=TRACE_KSYM ) +return TRACE_TYPE_UNHANDLED ; + +trace_assign_type (field, entry); + + ret =trace_seq_printf (s,"%-15s %-5d %-3d %-20s " , field->p_name, + entry->pid, iter->cpu, field->ksym_name); +if (!ret) +return TRACE_TYPE_PARTIAL_LINE ; + +switch (field->ksym_hbp->info.type) { +case HW_BREAKPOINT_WRITE : + ret =trace_seq_printf (s," W " ); +break ; +case HW_BREAKPOINT_RW : + ret =trace_seq_printf (s," RW " ); +break ; +default : +return TRACE_TYPE_PARTIAL_LINE ; + } + +if (!ret) +return TRACE_TYPE_PARTIAL_LINE ; + +sprint_symbol (str, field->ip); + ret =trace_seq_printf (s,"%-20s\n" , str); +if (!ret) +return TRACE_TYPE_PARTIAL_LINE ; + +return TRACE_TYPE_HANDLED ; +} + +struct tracer ksym_tracer__read_mostly = +{ + .name ="ksym_tracer" , + .init = ksym_trace_init, + .reset = ksym_trace_reset, +#ifdef CONFIG_FTRACE_SELFTEST + .selftest = trace_selftest_startup_ksym, +#endif + .print_header = ksym_trace_print_header, + .print_line = ksym_trace_output +}; +
trace/trace_ksym.c line 472
Quoted 10 lines
trace/trace_ksym.c new file +10
-0+__init static int init_ksym_trace (void ) +{ +struct dentry *d_tracer; +struct dentry *entry; + + d_tracer =tracing_init_dentry (); + ksym_filter_entry_count =0 ; + + entry =debugfs_create_file ("ksym_trace_filter" ,0666 , d_tracer, +NULL , &ksym_tracing_fops);
Are you sure you want it to be writeable by anyone?
Thanks,
Frederic.
Quoted 138 lines
trace/trace_ksym.c new file +85
-0+if (!entry) +pr_warning ("Could not create debugfs " +"'ksym_trace_filter' file\n" ); + +return register_tracer (&ksym_tracer); +} +device_initcall (init_ksym_trace); + + +#ifdef CONFIG_PROFILE_KSYM_TRACER +static int ksym_tracer_stat_headers (struct seq_file *m) +{ +seq_printf (m," Access type " ); +seq_printf (m," Symbol Counter \n" ); +return 0 ; +} + +static int ksym_tracer_stat_show (struct seq_file *m,void *v) +{ +struct hlist_node *stat = v; +struct trace_ksym *entry; +int access_type =0 ; +char fn_name[KSYM_NAME_LEN ]; + + entry = hlist_entry(stat, struct trace_ksym, ksym_hlist); + +if (entry->ksym_hbp) + access_type = entry->ksym_hbp->info.type; + +switch (access_type) { +case HW_BREAKPOINT_WRITE : +seq_printf (m," W " ); +break ; +case HW_BREAKPOINT_RW : +seq_printf (m," RW " ); +break ; +default : +seq_printf (m," NA " ); + } + +if (lookup_symbol_name (entry->ksym_addr, fn_name) >=0 ) +seq_printf (m," %s " , fn_name); +else +seq_printf (m," <NA> " ); + +seq_printf (m,"%15lu\n" , entry->counter); +return 0 ; +} + +static void *ksym_tracer_stat_start (struct tracer_stat *trace) +{ +return &(ksym_filter_head.first); +} + +static void * +ksym_tracer_stat_next (void *v,int idx) +{ +struct hlist_node *stat = v; + +return stat->next; +} + +static struct tracer_stat ksym_tracer_stats = { + .name ="ksym_tracer" , + .stat_start = ksym_tracer_stat_start, + .stat_next = ksym_tracer_stat_next, + .stat_headers = ksym_tracer_stat_headers, + .stat_show = ksym_tracer_stat_show +}; + +__init static int ksym_tracer_stat_init (void ) +{ +int ret; + + ret =register_stat_tracer (&ksym_tracer_stats); +if (ret) { +printk (KERN_WARNING "Warning: could not register " +"ksym tracer stats\n" ); +return 1 ; + } + +return 0 ; +} +fs_initcall (ksym_tracer_stat_init); +#endif /* CONFIG_PROFILE_KSYM_TRACER */ Index:
kernel/trace/trace_selftest.c
===================================================================trace/trace_selftest.c renamed from trace/trace_selftest.c.orig +37
-0@@ -17,6 +17,7 @@ static inline int trace_valid_entry(strucase TRACE_GRAPH_ENT :case TRACE_GRAPH_RET :case TRACE_HW_BRANCHES : +case TRACE_KSYM :return 1 ; }return 0 ;@@ -807,3 +808,39 @@ trace_selftest_startup_hw_branches(struc return ret; }#endif /* CONFIG_HW_BRANCH_TRACER */ + +#ifdef CONFIG_KSYM_TRACER +int +trace_selftest_startup_ksym (struct tracer *trace,struct trace_array *tr) +{ +unsigned long count; +int ret; + +/* start the tracing */ + ret =tracer_init (trace, tr); +if (ret) { +warn_failed_init_tracer (trace, ret); +return ret; + } + +/* Sleep for a 1/10 of a second */ +msleep (100 ); +/* stop the tracing. */ +tracing_stop (); +/* check the trace buffer */ + ret =trace_test_buffer (tr, &count); + trace->reset (tr); +tracing_start (); + +/* read & write operations - one each is performed on the dummy variable +* triggering two entries in the trace buffer +*/ +if (!ret && count !=2 ) { +printk (KERN_CONT "Ksym tracer startup test failed" ); + ret =-1 ; + } + +return ret; +} +#endif /* CONFIG_KSYM_TRACER */ +
Re: [Patch 11/12] ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces - v3
Quoted 10 lines · Frederic Weisbecker
Quoted 2 lines · K.Prasad
This patch adds an ftrace plugin to detect and profile memory access over kernel variables. It uses HW Breakpoint interfaces to 'watch memory addresses.
Just a small concern, but it would be nice if you could include the history of this patch in the changelogs.
Hi Frederic,
Thanks for looking into the patch. I will provide the history of
changes here. The ULONG_MAX definition from linux/kernel.h is now used and the permission for the 'ksym_trace_filter' file is now set to 644 (similar to other ftrace plugin filters).
Changelog
---------
(since the first post of this patch here: http://lkml.org/lkml/2009/3/4/418)
- Addition of a startup selftest to test basic sanity of HW Breakpoint infrastructure.
- Implementation of a ftrace's stats facility over ksym_tracer to provide aggregate 'hit' counter values.
- Conversion of all locking primitives into spinlocks (ksym_tracer_lock) from previous mutex implementation (since stats collection happens inside the context of the breakpoint exception and we cannot sleep).
- A few changes in ksym_trace_filter_write() and process_new_ksym_entry() to eliminate passing of unnecessary values.
- Fixed a few potential memory leak scenarios (missing kfree() operations in return path) along with other minor issues pointed out in LKML.
- Minor code changes such as unconditional definition of 'struct trace_ksym' - irrespective of CONFIG_KSYM_TRACER.
ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces - v3
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 | 20 + kernel/trace/trace_ksym.c | 556 ++++++++++++++++++++++++++++++++++++++++++ kernel/trace/trace_selftest.c | 37 ++ 5 files changed, 635 insertions(+)
trace/Kconfig renamed from trace/Kconfig.orig +21 -0
@@ -272,6 +272,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"
trace/Makefile renamed from trace/Makefile.orig +1 -0
@@ -50,5 +50,6 @@ obj-$(CONFIG_EVENT_TRACING) += trace_exp 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
trace/trace.h renamed from trace/trace.h.orig +20 -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,18 @@ struct syscall_trace_exit {unsigned long ret; }; +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 +340,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 )
@@ -538,6 +556,8 @@ extern int trace_selftest_startup_branch 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);
trace/trace_ksym.c new file +556 -0
556 lines not on this page · raw message
trace/trace_selftest.c renamed from trace/trace_selftest.c.orig +37 -0
@@ -17,6 +17,7 @@ static inline int trace_valid_entry(strucase TRACE_GRAPH_ENT :case TRACE_GRAPH_RET :case TRACE_HW_BRANCHES : +case TRACE_KSYM :return 1 ; }return 0 ;
@@ -807,3 +808,39 @@ trace_selftest_startup_hw_branches(struc return ret; }#endif /* CONFIG_HW_BRANCH_TRACER */ + +#ifdef CONFIG_KSYM_TRACER +int +trace_selftest_startup_ksym (struct tracer *trace,struct trace_array *tr) +{ +unsigned long count; +int ret; + +/* start the tracing */ + ret =tracer_init (trace, tr); +if (ret) { +warn_failed_init_tracer (trace, ret); +return ret; + } + +/* Sleep for a 1/10 of a second */ +msleep (100 ); +/* stop the tracing. */ +tracing_stop (); +/* check the trace buffer */ + ret =trace_test_buffer (tr, &count); + trace->reset (tr); +tracing_start (); + +/* read & write operations - one each is performed on the dummy variable +* triggering two entries in the trace buffer +*/ +if (!ret && count !=2 ) { +printk (KERN_CONT "Ksym tracer startup test failed" ); + ret =-1 ; + } + +return ret; +} +#endif /* CONFIG_KSYM_TRACER */ +
Re: [Patch 11/12] ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces - v3
Quoted 22 lines · K.Prasad
Quoted 10 lines · Frederic Weisbecker
Quoted 2 lines · K.Prasad
This patch adds an ftrace plugin to detect and profile memory access over kernel variables. It uses HW Breakpoint interfaces to 'watch memory addresses.
Just a small concern, but it would be nice if you could include the history of this patch in the changelogs.
Hi Frederic,
Thanks for looking into the patch. I will provide the history of
changes here. TheULONG_MAXdefinition fromlinux/kernel.his now used and the permission for the 'ksym_trace_filter' file is now set to 644 (similar to other ftrace plugin filters).Changelog
---------
(since the first post of this patch here: http://lkml.org/lkml/2009/3/4/418)
Quoted 13 lines
- Addition of a startup selftest to test basic sanity of HW Breakpoint infrastructure.
- Implementation of a ftrace's stats facility overksym_tracerto provide aggregate 'hit' counter values.
- Conversion of all locking primitives into spinlocks (ksym_tracer_lock) from previous mutex implementation (since stats collection happens inside the context of the breakpoint exception and we cannot sleep).
- A few changes inksym_trace_filter_write()andprocess_new_ksym_entry()to eliminate passing of unnecessary values.
- Fixed a few potential memory leak scenarios (missingkfree()operations in return path) along with other minor issues pointed out in LKML.
- Minor code changes such as unconditional definition of 'structtrace_ksym' - irrespective ofCONFIG_KSYM_TRACER.
Thanks! Such history is very useful to understand a patch. They can explain some logic reasoning of a patch, especially between versions.
Quoted 6 lines
ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces - v3
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]>
It looks good.
Thanks!
PATCH 12/12 Reset bits in dr6 after the corresponding exception is handled
In reply to a message not in the archiveThis patch resets the bit in dr6 after the corresponding exception is handled in code.
--- 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/traps.c +2 -2
@@ -550,8 +550,8 @@ dotraplinkage void __kprobes do_debug(st/* 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/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>
@@ -433,6 +434,11 @@ single_step_cont(struct pt_regs *regs, s "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(s 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/mm/kmmio.c +7 -1
@@ -534,8 +534,14 @@ static int kmmio_die_notifier(struct notstruct 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 ; }
arch/x86/kernel/hw_breakpoint.c +11 -2
@@ -307,8 +307,12 @@ int __kprobes hw_breakpoint_handler(stru {int i, 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 )
@@ -346,6 +350,11 @@ int __kprobes hw_breakpoint_handler(stru rc =NOTIFY_DONE ; } (bp->triggered)(bp, args->regs); +/* +* Reset the 'i'th TRAP bit in dr6 to denote completion of +* exception handling +*/ + (*dr6_p) &= ~(DR_TRAP0 << i); }if (dr6 & (~DR_TRAP_BITS )) rc =NOTIFY_DONE ;