Prepare the code for Hardware Breakpoint interfaces
Subsystems (4)
A message that is not in the archive (sent off-list or not yet received): 20090515105133.629980476@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 | 29 +++++++ arch/x86/include/asm/hw_breakpoint.h | 55 +++++++++++++ arch/x86/include/asm/processor.h | 8 +- include/asm-generic/hw_breakpoint.h | 139 +++++++++++++++++++++++++++++++++++ 4 files changed, 227 insertions(+), 4 deletions(-)
asm-generic/hw_breakpoint.h new file +139 -0
@@ -0,0 +1,139 @@ +#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. +*/ + +extern int register_user_hw_breakpoint (struct task_struct *tsk, +struct hw_breakpoint *bp); +extern int modify_user_hw_breakpoint (struct task_struct *tsk, +struct hw_breakpoint *bp); +extern void unregister_user_hw_breakpoint (struct task_struct *tsk, +struct hw_breakpoint *bp); +/* +* Kernel breakpoints are not associated with any particular thread. +*/ +extern int register_kernel_hw_breakpoint (struct hw_breakpoint *bp); +extern void unregister_kernel_hw_breakpoint (struct hw_breakpoint *bp); + +extern unsigned int hbp_kernel_pos; + +#endif /* __KERNEL__ */ +#endif /* _ASM_GENERIC_HW_BREAKPOINT_H */
x86/include/asm/hw_breakpoint.h new file +55 -0
55 lines not on this page · raw message
x86/include/asm/debugreg.h renamed from x86/include/asm/debugreg.h.orig +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 */
x86/include/asm/processor.h renamed from x86/include/asm/processor.h.orig +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;
PATCH 1/12 Prepare the code for Hardware Breakpoint interfaces
In reply to a message not in the archiveThis 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 | 29 +++++++ arch/x86/include/asm/hw_breakpoint.h | 55 +++++++++++++ arch/x86/include/asm/processor.h | 8 +- include/asm-generic/hw_breakpoint.h | 139 +++++++++++++++++++++++++++++++++++ 4 files changed, 227 insertions(+), 4 deletions(-)
asm-generic/hw_breakpoint.h new file +139 -0
@@ -0,0 +1,139 @@ +#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. +*/ + +extern int register_user_hw_breakpoint (struct task_struct *tsk, +struct hw_breakpoint *bp); +extern int modify_user_hw_breakpoint (struct task_struct *tsk, +struct hw_breakpoint *bp); +extern void unregister_user_hw_breakpoint (struct task_struct *tsk, +struct hw_breakpoint *bp); +/* +* Kernel breakpoints are not associated with any particular thread. +*/ +extern int register_kernel_hw_breakpoint (struct hw_breakpoint *bp); +extern void unregister_kernel_hw_breakpoint (struct hw_breakpoint *bp); + +extern unsigned int hbp_kernel_pos; + +#endif /* __KERNEL__ */ +#endif /* _ASM_GENERIC_HW_BREAKPOINT_H */
x86/include/asm/hw_breakpoint.h new file +55 -0
55 lines not on this page · raw message
x86/include/asm/debugreg.h renamed from x86/include/asm/debugreg.h.orig +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 */
x86/include/asm/processor.h renamed from x86/include/asm/processor.h.orig +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;
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 | 369 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 374 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 +369 -0
369 lines not on this page · raw message
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 | 369 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 374 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 +369 -0
369 lines not on this page · raw message
Re: [Patch 02/12] Introducing generic hardware breakpoint handler interfaces
Quoted 339 lines · K.Prasad
This patch introduces the generic Hardware Breakpoint interfaces for both user and kernel space requests.
Original-patch-by Alan Stern <[email protected]>Signed-off-by K.Prasad <[email protected]>Reviewed-by Alan Stern <[email protected]>--- arch/Kconfig | 4 kernel/Makefile | 1 kernel/hw_breakpoint.c | 369 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 374 insertions(+)Index:
arch/Kconfig
===================================================================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 +Index: kernel/Makefile
===================================================================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 isIndex:
kernel/hw_breakpoint.c
===================================================================hw_breakpoint.c new file +298
-0@@ -0,0 +1,369 @@ +/* +* 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) 2007 Alan Stern +* Copyright (C) IBM Corporation, 2009 +*/ + +/* +* HW_breakpoint: a unified kernel/user-space hardware breakpoint facility, +* using the CPU's debug registers. +* This file contains the arch-independent routines. +*/ + +#include <linux/irqflags.h> +#include <linux/kallsyms.h> +#include <linux/notifier.h> +#include <linux/kprobes.h> +#include <linux/kdebug.h> +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/percpu.h> +#include <linux/sched.h> +#include <linux/init.h> +#include <linux/smp.h> + +#include <asm/hw_breakpoint.h> +#include <asm/processor.h> + +#ifdef CONFIG_X86 +#include <asm/debugreg.h> +#endif +/* +* Spinlock that protects all (un)register operations over kernel/user-space +* breakpoint requests +*/ +static DEFINE_SPINLOCK (hw_breakpoint_lock); + +/* Array of kernel-space breakpoint structures */ +struct hw_breakpoint *hbp_kernel[HBP_NUM ]; + +/* +* Per-processor copy of hbp_kernel[]. Used only when hbp_kernel is being +* modified but we need the older copy to handle any hbp exceptions. It will +* sync with hbp_kernel[] value after updation is done through IPIs. +*/ +DEFINE_PER_CPU(struct hw_breakpoint*, this_hbp_kernel[HBP_NUM]); + +/* +* Kernel breakpoints grow downwards, starting from HBP_NUM +* 'hbp_kernel_pos' denotes lowest numbered breakpoint register occupied for +* kernel-space request. We will initialise it here and not in an __init +* routine because load_debug_registers(), which uses this variable can be +* called very early during CPU initialisation. +*/ +unsigned int hbp_kernel_pos =HBP_NUM ; + +/* +* An array containing refcount of threads using a given bkpt register +* Accesses are synchronised by acquiring hw_breakpoint_lock +*/ +unsigned int hbp_user_refcount[HBP_NUM ]; + +/* +* Load the debug registers during startup of a CPU. +*/ +void load_debug_registers (void ) +{ +unsigned long flags; +struct task_struct *tsk = current; + +spin_lock_bh (&hw_breakpoint_lock); + +/* Prevent IPIs for new kernel breakpoint updates */ +local_irq_save (flags); +arch_update_kernel_hw_breakpoint (NULL ); +local_irq_restore (flags); + +if (test_tsk_thread_flag (tsk,TIF_DEBUG )) +arch_install_thread_hw_breakpoint (tsk); + +spin_unlock_bh (&hw_breakpoint_lock); +} + +/* +* Erase all the hardware breakpoint info associated with a thread. +* +* If tsk != current then tsk must not be usable (for example, a +* child being cleaned up from a failed fork). +*/ +void flush_thread_hw_breakpoint (struct task_struct *tsk) +{ +int i; +struct thread_struct *thread = &(tsk->thread); + +spin_lock_bh (&hw_breakpoint_lock); + +/* The thread no longer has any breakpoints associated with it */ +clear_tsk_thread_flag (tsk,TIF_DEBUG ); +for (i =0 ; i <HBP_NUM ; i++) { +if (thread->hbp[i]) { + hbp_user_refcount[i]--; +kfree (thread->hbp[i]); + thread->hbp[i] =NULL ; + } + } + +arch_flush_thread_hw_breakpoint (tsk); + +/* Actually uninstall the breakpoints if necessary */ +if (tsk == current) +arch_uninstall_thread_hw_breakpoint (); +spin_unlock_bh (&hw_breakpoint_lock); +} + +/* +* Copy the hardware breakpoint info from a thread to its cloned child. +*/ +int copy_thread_hw_breakpoint (struct task_struct *tsk, +struct task_struct *child,unsigned long clone_flags) +{ +/* +* We will assume that breakpoint settings are not inherited +* and the child starts out with no debug registers set. +* But what about CLONE_PTRACE? +*/ +clear_tsk_thread_flag (child,TIF_DEBUG ); + +/* We will call flush routine since the debugregs are not inherited */ +arch_flush_thread_hw_breakpoint (child); + +return 0 ; +} + +static int __register_user_hw_breakpoint (int pos,struct task_struct *tsk, +struct hw_breakpoint *bp) +{ +struct thread_struct *thread = &(tsk->thread); +int rc; + +/* Do not overcommit. Fail if kernel has used the hbp registers */ +if (pos >= hbp_kernel_pos) +return -ENOSPC ; + + rc =arch_validate_hwbkpt_settings (bp, tsk); +if (rc) +return rc; + + thread->hbp[pos] = bp; + hbp_user_refcount[pos]++; + +arch_update_user_hw_breakpoint (pos, tsk); +/* +* Does it need to be installed right now? +* Otherwise it will get installed the next time tsk runs +*/ +if (tsk == current) +arch_install_thread_hw_breakpoint (tsk); + +return rc; +} + +/* +* Modify the address of a hbp register already in use by the task +* Do not invoke this in-lieu of a __unregister_user_hw_breakpoint() +*/ +static int __modify_user_hw_breakpoint (int pos,struct task_struct *tsk, +struct hw_breakpoint *bp) +{ +struct thread_struct *thread = &(tsk->thread); + +if ((pos >= hbp_kernel_pos) || (arch_validate_hwbkpt_settings (bp, tsk))) +return -EINVAL ; + +if (thread->hbp[pos] ==NULL ) +return -EINVAL ; + + thread->hbp[pos] = bp; +/* +* 'pos' must be that of a hbp register already used by 'tsk' +* Otherwise arch_modify_user_hw_breakpoint() will fail +*/ +arch_update_user_hw_breakpoint (pos, tsk); + +if (tsk == current) +arch_install_thread_hw_breakpoint (tsk); + +return 0 ; +} + +static void __unregister_user_hw_breakpoint (int pos,struct task_struct *tsk) +{ + hbp_user_refcount[pos]--; + tsk->thread.hbp[pos] =NULL ; + +arch_update_user_hw_breakpoint (pos, tsk); + +if (tsk == current) +arch_install_thread_hw_breakpoint (tsk); +} + +/** +* register_user_hw_breakpoint - register a hardware breakpoint for user space +* @tsk: pointer to 'task_struct' of the process to which the address belongs +* @bp: the breakpoint structure to register +* +* @bp.info->name or @bp.info->address, @bp.info->len, @bp.info->type and +* @bp->triggered must be set properly before invocation +* +*/ +int register_user_hw_breakpoint (struct task_struct *tsk, +struct hw_breakpoint *bp) +{ +struct thread_struct *thread = &(tsk->thread); +int i, rc = -ENOSPC ; + +spin_lock_bh (&hw_breakpoint_lock); + +for (i =0 ; i < hbp_kernel_pos; i++) { +if (!thread->hbp[i]) { + rc =__register_user_hw_breakpoint (i, tsk, bp); +break ; + } + } + +spin_unlock_bh (&hw_breakpoint_lock); +return rc; +} +EXPORT_SYMBOL_GPL (register_user_hw_breakpoint); + +/** +* modify_user_hw_breakpoint - modify a user-space hardware breakpoint +* @tsk: pointer to 'task_struct' of the process to which the address belongs +* @bp: the breakpoint structure to unregister +* +*/ +int modify_user_hw_breakpoint (struct task_struct *tsk,struct hw_breakpoint *bp) +{ +struct thread_struct *thread = &(tsk->thread); +int i, ret = -ENOENT ; + +spin_lock_bh (&hw_breakpoint_lock); +for (i =0 ; i < hbp_kernel_pos; i++) { +if (bp == thread->hbp[i]) { + ret =__modify_user_hw_breakpoint (i, tsk, bp); +break ; + } + } +spin_unlock_bh (&hw_breakpoint_lock); +return ret; +} +EXPORT_SYMBOL_GPL (modify_user_hw_breakpoint); + +/** +* unregister_user_hw_breakpoint - unregister a user-space hardware breakpoint +* @tsk: pointer to 'task_struct' of the process to which the address belongs +* @bp: the breakpoint structure to unregister +* +*/ +void unregister_user_hw_breakpoint (struct task_struct *tsk, +struct hw_breakpoint *bp) +{ +struct thread_struct *thread = &(tsk->thread); +int i; + +spin_lock_bh (&hw_breakpoint_lock); +for (i =0 ; i < hbp_kernel_pos; i++) { +if (bp == thread->hbp[i]) { +__unregister_user_hw_breakpoint (i, tsk); +break ; + } + } +spin_unlock_bh (&hw_breakpoint_lock); +} +EXPORT_SYMBOL_GPL (unregister_user_hw_breakpoint); + +/** +* register_kernel_hw_breakpoint - register a hardware breakpoint for kernel space +* @bp: the breakpoint structure to register +* +* @bp.info->name or @bp.info->address, @bp.info->len, @bp.info->type and +* @bp->triggered must be set properly before invocation +* +*/ +int register_kernel_hw_breakpoint (struct hw_breakpoint *bp) +{ +int rc;
hw_breakpoint.c line 308
Quoted 10 lines
hw_breakpoint.c new file +10
-0+ + rc =arch_validate_hwbkpt_settings (bp,NULL ); +if (rc) +return rc; + +spin_lock_bh (&hw_breakpoint_lock); + + rc = -EINVAL ; +/* Check if we are over-committing */ +if ((hbp_kernel_pos >0 ) && (!hbp_user_refcount[hbp_kernel_pos-1 ])) {
If hbp_kernel_pos == 0, shouldn't it return -ENOSPC ?
If several kernel users try to register a breakpoint, and there is no more room for one of them, then we know it has failed not because of an error in the breakpoint instance but because of a lack of resources.
Frederic.
Quoted 62 lines
hw_breakpoint.c new file +61
-0+ hbp_kernel_pos--; + hbp_kernel[hbp_kernel_pos] = bp; +on_each_cpu (arch_update_kernel_hw_breakpoint,NULL ,1 ); + rc =0 ; + } + +spin_unlock_bh (&hw_breakpoint_lock); +return rc; +} +EXPORT_SYMBOL_GPL (register_kernel_hw_breakpoint); + +/** +* unregister_kernel_hw_breakpoint - unregister a HW breakpoint for kernel space +* @bp: the breakpoint structure to unregister +* +* Uninstalls and unregisters @bp. +*/ +void unregister_kernel_hw_breakpoint (struct hw_breakpoint *bp) +{ +int i, j; + +spin_lock_bh (&hw_breakpoint_lock); + +/* Find the 'bp' in our list of breakpoints for kernel */ +for (i = hbp_kernel_pos; i <HBP_NUM ; i++) +if (bp == hbp_kernel[i]) +break ; + +/* Check if we did not find a match for 'bp'. If so return early */ +if (i ==HBP_NUM ) { +spin_unlock_bh (&hw_breakpoint_lock); +return ; + } + +/* +* We'll shift the breakpoints one-level above to compact if +* unregistration creates a hole +*/ +for (j = i; j > hbp_kernel_pos; j--) + hbp_kernel[j] = hbp_kernel[j-1 ]; + + hbp_kernel[hbp_kernel_pos] =NULL ; +on_each_cpu (arch_update_kernel_hw_breakpoint,NULL ,1 ); + hbp_kernel_pos++; + +spin_unlock_bh (&hw_breakpoint_lock); +} +EXPORT_SYMBOL_GPL (unregister_kernel_hw_breakpoint); + +static struct notifier_block hw_breakpoint_exceptions_nb = { + .notifier_call = hw_breakpoint_exceptions_notify, +/* we need to be notified first */ + .priority =0x7fffffff +}; + +static int __init init_hw_breakpoint (void ) +{ +return register_die_notifier (&hw_breakpoint_exceptions_nb); +} + +core_initcall (init_hw_breakpoint);
Re: [Patch 02/12] Introducing generic hardware breakpoint handler interfaces
Quoted 43 lines · Frederic Weisbecker
Quoted 23 lines · K.Prasad
This patch introduces the generic Hardware Breakpoint interfaces for both user and kernel space requests.
Original-patch-by Alan Stern <[email protected]>Signed-off-by K.Prasad <[email protected]>Reviewed-by Alan Stern <[email protected]>--- arch/Kconfig | 4 kernel/Makefile | 1 kernel/hw_breakpoint.c | 369 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 374 insertions(+)(quoted diff) +11
-0+/** + * register_kernel_hw_breakpoint - register a hardware breakpoint for kernel space + * @bp: the breakpoint structure to register + * + * @bp.info->name or @bp.info->address, @bp.info->len, @bp.info->type and + * @bp->triggered must be set properly before invocation + * + */ +int register_kernel_hw_breakpoint(struct hw_breakpoint *bp) +{ + int rc;Review
Quoted 10 lines
(quoted diff) +10
-0+ + rc = arch_validate_hwbkpt_settings(bp, NULL); + if (rc) + return rc; + + spin_lock_bh(&hw_breakpoint_lock); + + rc = -EINVAL; + /* Check if we are over-committing */ + if ((hbp_kernel_pos > 0) && (!hbp_user_refcount[hbp_kernel_pos-1])) {If
hbp_kernel_pos== 0, shouldn't it return-ENOSPC?
If several kernel users try to register a breakpoint, and there is no more room for one of them, then we know it has failed not because of an error in the breakpoint instance but because of a lack of resources.
Quoted 2 lines
Frederic.
Agreed. It's done correctly in the case of register_user_hw_breakpoint() but not here. Here's a tiny patch that corrects it.
Modify the return code in register_kernel_hw_breakpoint()
Modify the return code in register_kernel_hw_breakpoint() to return -ENOSPC if we are error-returning due to lack of free HW breakpoint registers.
--- kernel/hw_breakpoint.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/hw_breakpoint.c +1 -1
@@ -312,7 +312,7 @@ int register_kernel_hw_breakpoint(structspin_lock_bh (&hw_breakpoint_lock); - rc = -EINVAL ; + rc = -ENOSPC ;/* Check if we are over-committing */ if ((hbp_kernel_pos >0 ) && (!hbp_user_refcount[hbp_kernel_pos-1 ])) { hbp_kernel_pos--;
Re: [Patch 02/12] Introducing generic hardware breakpoint handler interfaces
Quoted 44 lines · K.Prasad
Quoted 43 lines · Frederic Weisbecker
Quoted 23 lines · K.Prasad
This patch introduces the generic Hardware Breakpoint interfaces for both user and kernel space requests.
Original-patch-by Alan Stern <[email protected]>Signed-off-by K.Prasad <[email protected]>Reviewed-by Alan Stern <[email protected]>--- arch/Kconfig | 4 kernel/Makefile | 1 kernel/hw_breakpoint.c | 369 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 374 insertions(+)(quoted diff) +11
-0+/** + * register_kernel_hw_breakpoint - register a hardware breakpoint for kernel space + * @bp: the breakpoint structure to register + * + * @bp.info->name or @bp.info->address, @bp.info->len, @bp.info->type and + * @bp->triggered must be set properly before invocation + * + */ +int register_kernel_hw_breakpoint(struct hw_breakpoint *bp) +{ + int rc;Review
Quoted 10 lines
(quoted diff) +10
-0+ + rc = arch_validate_hwbkpt_settings(bp, NULL); + if (rc) + return rc; + + spin_lock_bh(&hw_breakpoint_lock); + + rc = -EINVAL; + /* Check if we are over-committing */ + if ((hbp_kernel_pos > 0) && (!hbp_user_refcount[hbp_kernel_pos-1])) {If
hbp_kernel_pos== 0, shouldn't it return-ENOSPC?
If several kernel users try to register a breakpoint, and there is no more room for one of them, then we know it has failed not because of an error in the breakpoint instance but because of a lack of resources.
Quoted 5 lines
Quoted 2 lines
Frederic.
Agreed. It's done correctly in the case of
register_user_hw_breakpoint()but not here. Here's a tiny patch that corrects it.
Thanks. I will apply this one too.
Frederic.
Quoted 25 lines
Modify the return code in
register_kernel_hw_breakpoint()Modify the return code in
register_kernel_hw_breakpoint()to return-ENOSPCif we are error-returning due to lack of free HW breakpoint registers.Signed-off-by K.Prasad <[email protected]>--- kernel/hw_breakpoint.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)Index:
linux-2.6-tip.hbkpt/kernel/hw_breakpoint.c
===================================================================kernel/hw_breakpoint.c +1
-1@@ -312,7 +312,7 @@ int register_kernel_hw_breakpoint(structspin_lock_bh (&hw_breakpoint_lock); - rc = -EINVAL ; + rc = -ENOSPC ;/* Check if we are over-committing */ if ((hbp_kernel_pos >0 ) && (!hbp_user_refcount[hbp_kernel_pos-1 ])) { hbp_kernel_pos--;
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 | 368 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 370 insertions(+), 1 deletion(-)
x86/Kconfig renamed from x86/Kconfig.orig +1 -0
@@ -47,6 +47,7 @@ config X86 select HAVE_KERNEL_BZIP2 select HAVE_KERNEL_LZMA select HAVE_ARCH_KMEMCHECK + select HAVE_HW_BREAKPOINT config OUTPUT_FORMAT 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 +368 -0
368 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 | 368 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 370 insertions(+), 1 deletion(-)
x86/Kconfig renamed from x86/Kconfig.orig +1 -0
@@ -47,6 +47,7 @@ config X86 select HAVE_KERNEL_BZIP2 select HAVE_KERNEL_LZMA select HAVE_ARCH_KMEMCHECK + select HAVE_HW_BREAKPOINT config OUTPUT_FORMAT 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 +368 -0
368 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 4/12 Modifying generic debug exception to use thread-specific debug registers
In reply to a message not in the archiveThis patch modifies the breakpoint exception handler code to use the abstract register names.
--- 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 5/12 Use wrapper routines around debug registers in processor related functions
In reply to a message not in the archiveThis patch enables the use of wrapper routines to access the debug/breakpoint registers.
--- 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/kernel/process.c | 23 ++++++----------------- arch/x86/kernel/process_32.c | 31 +++++++++++++++++++++++++++++++ arch/x86/kernel/process_64.c | 33 +++++++++++++++++++++++++++++++++ 3 files changed, 70 insertions(+), 17 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 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 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 ))) +arch_install_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 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 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 ))) +arch_install_thread_hw_breakpoint (next_p); +return prev_p; }
PATCH 6/12 Use the new wrapper routines to access debug registers in process/thread code
In reply to a message not in the archiveThis patch enables the use of abstract debug registers in process-handling routines.
--- arch/x86/kernel/process.c | 23 ++++++----------------- arch/x86/kernel/process_32.c | 31 +++++++++++++++++++++++++++++++ arch/x86/kernel/process_64.c | 33 +++++++++++++++++++++++++++++++++ 3 files changed, 70 insertions(+), 17 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 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 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 ))) +arch_install_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 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 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 ))) +arch_install_thread_hw_breakpoint (next_p); +return prev_p; }
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 7/12 Modify signal handling code to refrain from re-enabling HW Breakpoints
In reply to a message not in the archiveThis 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 | 232 ++++++++++++++++++++++++++++------------------- 1 file changed, 142 insertions(+), 90 deletions(-)
x86/kernel/ptrace.c renamed from x86/kernel/ptrace.c.orig +142 -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,160 @@ 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, orig_ret =0 , rc =0 ; +int enabled, second_pass =0 ; +unsigned len, type; +struct hw_breakpoint *bp; -case 6 : -if ((data & ~0xffffffffUL ) !=0 ) -return -EIO ; - child->thread.debugreg6 = data; -break ; + 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) +set_tsk_thread_flag (tsk,TIF_DEBUG ); +else +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 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_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; +} + +/* +* 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; }/*
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 | 232 ++++++++++++++++++++++++++++------------------- 1 file changed, 142 insertions(+), 90 deletions(-)
x86/kernel/ptrace.c renamed from x86/kernel/ptrace.c.orig +142 -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,160 @@ 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, orig_ret =0 , rc =0 ; +int enabled, second_pass =0 ; +unsigned len, type; +struct hw_breakpoint *bp; -case 6 : -if ((data & ~0xffffffffUL ) !=0 ) -return -EIO ; - child->thread.debugreg6 = data; -break ; + 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) +set_tsk_thread_flag (tsk,TIF_DEBUG ); +else +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 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_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; +} + +/* +* 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; }/*
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 @@ 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
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 @@ 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
PATCH 9/12 Cleanup HW Breakpoint registers before kexec
In reply to a message not in the archiveThis patch disables Hardware breakpoints before doing a 'kexec' on the machine.
--- 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 @@ 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
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 @@ 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
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
@@ -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 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 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
@@ -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 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 - v5
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 | 22 + kernel/trace/trace_ksym.c | 525 ++++++++++++++++++++++++++++++++++++++++++ kernel/trace/trace_selftest.c | 54 ++++ 5 files changed, 623 insertions(+)
trace/Kconfig renamed from trace/Kconfig.orig +21 -0
@@ -309,6 +309,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
@@ -52,5 +52,6 @@ obj-$(CONFIG_FTRACE_SYSCALLS) += trace_s obj-$(CONFIG_EVENT_PROFILE) += trace_event_profile.o obj-$(CONFIG_EVENT_TRACING) += trace_events_filter.o obj-$(CONFIG_EVENT_TRACING) += trace_mm.o +obj-$(CONFIG_KSYM_TRACER) += trace_ksym.o libftrace-y := ftrace.o
trace/trace.h renamed from trace/trace.h.orig +22 -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,20 @@ struct syscall_trace_exit {unsigned long ret; }; +#define KSYM_SELFTEST_ENTRY "ksym_selftest_dummy" + +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 +342,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 +560,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 +525 -0
525 lines not on this page · raw message
trace/trace_selftest.c renamed from trace/trace_selftest.c.orig +54 -0
63 lines not on this page · raw message
PATCH 11/12 ftrace plugin for kernel symbol tracing using HW Breakpoint interfaces - v5
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 | 22 + kernel/trace/trace_ksym.c | 525 ++++++++++++++++++++++++++++++++++++++++++ kernel/trace/trace_selftest.c | 54 ++++ 5 files changed, 623 insertions(+)
trace/Kconfig renamed from trace/Kconfig.orig +21 -0
@@ -309,6 +309,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
@@ -52,5 +52,6 @@ obj-$(CONFIG_FTRACE_SYSCALLS) += trace_s obj-$(CONFIG_EVENT_PROFILE) += trace_event_profile.o obj-$(CONFIG_EVENT_TRACING) += trace_events_filter.o obj-$(CONFIG_EVENT_TRACING) += trace_mm.o +obj-$(CONFIG_KSYM_TRACER) += trace_ksym.o libftrace-y := ftrace.o
trace/trace.h renamed from trace/trace.h.orig +22 -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,20 @@ struct syscall_trace_exit {unsigned long ret; }; +#define KSYM_SELFTEST_ENTRY "ksym_selftest_dummy" + +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 +342,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 +560,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 +525 -0
525 lines not on this page · raw message
trace/trace_selftest.c renamed from trace/trace_selftest.c.orig +54 -0
63 lines not on this page · raw message
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
@@ -540,8 +540,14 @@ kmmio_die_notifier(struct notifier_blockstruct 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
@@ -301,8 +301,12 @@ int __kprobes hw_breakpoint_handler(stru {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 )
@@ -346,6 +350,11 @@ int __kprobes hw_breakpoint_handler(strucontinue ; (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 ;
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
@@ -540,8 +540,14 @@ kmmio_die_notifier(struct notifier_blockstruct 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
@@ -301,8 +301,12 @@ int __kprobes hw_breakpoint_handler(stru {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 )
@@ -346,6 +350,11 @@ int __kprobes hw_breakpoint_handler(strucontinue ; (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 ;