Hardware Breakpoint interfaces
Subsystems (4)
cover Hardware Breakpoint interfaces
Hi Andrew and all,
Please find the patches that introduce interfaces to access
Hardware Breakpoint (or watchpoint) registers and an arch-specific implementation for x86/x86_64 architecture. Can you consider them for inclusion in -mm tree?
A short description of the framework and interfaces is provided below. Some of the details will be specific to x86/x86_64 architecture and may vary depending upon the support provided by the target processor.
Description
------------
The Hardware Breakpoint registers can be used for tracing changes to a variable or data location (even I/O ports in x86/x86_64) and will be extremely helpful in debugging problems such as memory corruption. While these registers have been used by user-space debuggers for long (through 'ptrace' syscalls), KGDB exploited them for kernel-space addresses.
The proposed framework, introduces interfaces to use them directly on both user- and kernel-space addresses apart from arbitrating requests from various such users for the limited number of registers.
The interfaces are:
int register_kernel_hw_breakpoint(struct hw_breakpoint *); void unregister_kernel_hw_breakpoint(struct hw_breakpoint *bp);
int register_user_hw_breakpoint(struct task_struct *tsk,
struct hw_breakpoint *bp);
void unregister_user_hw_breakpoint(struct task_struct *tsk,
struct hw_breakpoint *bp);The 'struct hw_breakpoint' will be the anchor data-structure containing all the necessary information such as name or address, type, length, priority and pointers to handler functions (some of which are arch-specific). More information about the role of each field, the handler functions and their return values can be found in the descriptive comments preceding these functions and in "include/asm-generic/hw_breakpoint.h".
While (un)register_user_hw_breakpoint() isn't exported yet, its worker-routine __register_user-hw_breakpoint() is used by ptrace syscall for all breakpoint register requirements. For the kernel-space, a simple use case to trace 'write' operations on a kernel variable can be found in samples/hw_breakpoint/data_breakpoint.c.
In the current patchset, support is provided only for read and read-write breakpoints on data locations, which can be later expand to include instruction and I/O breakpoints for x86/x86_64.
The patches are based on 2.6.29-rc2 and have been tested on an x86 machine along with concurrent sessions of a kprobe-module and a GDB session using HW breakpoints on the target program.
There is pending integration with 'KGDB' without which mutual exclusion between them (KGDB and HW breakpoint use through above interfaces) needs to be observed.
Several enhancements including support for more architectures and types of breakpoints are contemplated in the revisions to come.
Let me know your thoughts on this.
Thanks,
K.Prasad
PATCH 1/10 Introducing generic hardware breakpoint handler interfaces
This patch introduces two new files hw_breakpoint.[ch] which defines the generic interfaces to use hardware breakpoint infrastructure of the system.
--- include/asm-generic/hw_breakpoint.h | 229 +++++++++++ kernel/hw_breakpoint.c | 722 ++++++++++++++++++++++++++++++++++++ 2 files changed, 951 insertions(+)
include/asm-generic/hw_breakpoint.h new file +229 -0
@@ -0,0 +1,229 @@ +#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 +* @node: internal linked-list management +* @triggered: callback invoked after target address access +* @installed: callback invoked when the breakpoint is installed +* @uninstalled: callback invoked when the breakpoint is uninstalled +* @info: arch-specific breakpoint info (address, length, and type) +* @priority: requested priority level +* @status: current registration/installation status +* +* %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. +* +* Hardware breakpoints are implemented using the CPU's debug registers, +* which are a limited hardware resource. Requests to register a +* breakpoint will always succeed provided the parameters are valid, +* but the breakpoint may not be installed in a debug register right +* away. Physical debug registers are allocated based on the priority +* level stored in @priority (higher values indicate higher priority). +* User-space breakpoints within a single thread compete with one +* another, and all user-space breakpoints compete with all kernel-space +* breakpoints; however user-space breakpoints in different threads do +* not compete. %HW_BREAKPOINT_PRIO_PTRACE is the level used for ptrace +* requests; an unobtrusive kernel-space breakpoint will use +* %HW_BREAKPOINT_PRIO_NORMAL to avoid disturbing user programs. A +* kernel-space breakpoint that always wants to be installed and doesn't +* care about disrupting user debugging sessions can specify +* %HW_BREAKPOINT_PRIO_HIGH. +* +* A particular breakpoint may be allocated (installed in) a debug +* register or deallocated (uninstalled) from its debug register at any +* time, as other breakpoints are registered and unregistered. The +* @installed and @uninstalled callbacks are invoked in_atomic when these +* events occur. It is legal for @installed or @uninstalled to be %NULL. Note +* that it is not possible to register or unregister a user-space breakpoint +* from within a callback routine, since doing so requires a process context. +* Note that for user breakpoints, while in @installed and @uninstalled the +* thread may be context switched. Hence it may not be safe to call printk(). +* +* For kernel-space breakpoints, @installed is invoked after the +* breakpoint is actually installed and @uninstalled is invoked before +* the breakpoint is actually uninstalled. As a result the @triggered routine +* may be invoked when not expected, but this way you will know that during the +* time interval from @installed to @uninstalled, all events are faithfully +* reported. (It is not possible to do any better than this in general, because +* on SMP systems there is no way to set a debug register simultaneously on all +* CPUs.) The same isn't always true with user-space breakpoints, but the +* differences should not be visible to a user process. +* +* If you need to know whether your kernel-space breakpoint was installed +* immediately upon registration, you can check the return value from +* register_kernel_hw_breakpoint(). If the value is not > 0, you can +* give up and unregister the breakpoint right away. +* +* @node and @status are intended for internal use. However @status +* may be read to determine whether or not the breakpoint is currently +* installed. (The value is not reliable unless local interrupts are +* disabled.) +* +* 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.info.priority = HW_BREAKPOINT_PRIO_NORMAL; +* +* my_bp.installed = (void *)my_bp_installed; +* my_bp.uninstalled = (void *)my_bp_uninstalled; +* my_bp.triggered = (void *)my_triggered; +* +* 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 { +struct list_head node; +void (*installed)(struct hw_breakpoint *); +void (*uninstalled)(struct hw_breakpoint *); +void (*triggered)(struct hw_breakpoint *, +struct pt_regs *); +struct arch_hw_breakpoint info; +u8 priority; +u8 status; +}; + +/* +* Inline accessor routines to retrieve the arch-specific parts of +* a breakpoint structure: +*/ +static const void *hw_breakpoint_get_kaddress (struct hw_breakpoint *bp); +static const void __user *hw_breakpoint_get_uaddress (struct hw_breakpoint *bp); +static unsigned hw_breakpoint_get_len (struct hw_breakpoint *bp); +static unsigned hw_breakpoint_get_type (struct hw_breakpoint *bp); + +/* +* 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_LEN_EXECUTE +* HW_BREAKPOINT_RW +* HW_BREAKPOINT_READ +* HW_BREAKPOINT_EXECUTE +* +* 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. +*/ + +/* Standard HW breakpoint priority levels (higher value = higher priority) */ +#define HW_BREAKPOINT_PRIO_NORMAL 25 +#define HW_BREAKPOINT_PRIO_PTRACE 50 +#define HW_BREAKPOINT_PRIO_HIGH 75 + +/* HW breakpoint status values (0 = not registered) */ +#define HW_BREAKPOINT_REGISTERED 1 +#define HW_BREAKPOINT_INSTALLED 2 + +static DEFINE_MUTEX (hw_breakpoint_mutex);/* Protects everything */ + +/* +* The following two routines are meant to be called only from within +* the ptrace or utrace subsystems. The tsk argument will usually be a +* process being debugged by the current task, although it is also legal +* for tsk to be the current task. In any case it must be guaranteed +* that tsk will not start running in user mode while its breakpoints are +* being modified. +*/ +int register_user_hw_breakpoint (struct task_struct *tsk, +struct hw_breakpoint *bp); +void unregister_user_hw_breakpoint (struct task_struct *tsk, +struct hw_breakpoint *bp); + +/* +* Kernel breakpoints are not associated with any particular thread. +*/ +int register_kernel_hw_breakpoint (struct hw_breakpoint *bp); +void unregister_kernel_hw_breakpoint (struct hw_breakpoint *bp); + +struct thread_hw_breakpoint *alloc_thread_hw_breakpoint ( +struct task_struct *tsk); + +#endif /* __KERNEL__ */ +#endif /* _ASM_GENERIC_HW_BREAKPOINT_H */
kernel/hw_breakpoint.c new file +722 -0
722 lines not on this page · raw message
PATCH 2/10 x86 architecture implementation of Hardware Breakpoint interfaces
In reply to K.PrasadThis patch introduces two new files named hw_breakpoint.[ch] inside x86 specific directories. They contain functions which help validate and serve requests for using Hardware Breakpoint registers on x86 processors.
--- arch/x86/kernel/Makefile | 2 arch/x86/kernel/hw_breakpoint.c | 464 ++++++++++++++++++++++++++++++++++++++++ include/asm-x86/hw_breakpoint.h | 135 +++++++++++ 3 files changed, 600 insertions(+), 1 deletion(-)
arch/x86/kernel/hw_breakpoint.c new file +464 -0
@@ -0,0 +1,464 @@ +/* +* 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) 2008 IBM Corporation +*/ + +/* +* HW_breakpoint: a unified kernel/user-space hardware breakpoint facility, +* using the CPU's debug registers. +*/ + +#include <linux/init.h> +#include <linux/irqflags.h> +#include <linux/kdebug.h> +#include <linux/kernel.h> +#include <linux/kprobes.h> +#include <linux/module.h> +#include <linux/mutex.h> +#include <linux/notifier.h> +#include <linux/rculist.h> +#include <linux/sched.h> +#include <linux/smp.h> +#include <linux/percpu.h> +#include <linux/kallsyms.h> + +#include <asm/debugreg.h> +#include <asm/hw_breakpoint.h> +#include <asm/processor.h> + +/* Arch-specific hook routines */ + +/* +* Install the kernel breakpoints in their debug registers. +*/ +static void arch_install_chbi (struct cpu_hw_breakpoint *chbi) +{ +struct hw_breakpoint **bps; + +/* Don't allow debug exceptions while we update the registers */ +set_debugreg (0UL ,7 ); + chbi->cur_kbpdata =rcu_dereference (cur_kbpdata); + +/* Kernel breakpoints are stored starting in DR0 and going up */ + bps = chbi->cur_kbpdata->bps; +switch (chbi->cur_kbpdata->num_kbps) { +case 4 : +set_debugreg (bps[3 ]->info.address,3 ); +case 3 : +set_debugreg (bps[2 ]->info.address,2 ); +case 2 : +set_debugreg (bps[1 ]->info.address,1 ); +case 1 : +set_debugreg (bps[0 ]->info.address,0 ); + } +/* No need to set DR6 */ +set_debugreg (chbi->cur_kbpdata->mkdr7,7 ); +} + +/* +* Update an out-of-date thread hw_breakpoint info structure. +*/ +static void arch_update_thbi (struct thread_hw_breakpoint *thbi, +struct kernel_bp_data *thr_kbpdata) +{ +int num = thr_kbpdata->num_kbps; + + thbi->tkdr7 = thr_kbpdata->mkdr7 | (thbi->tdr7 & ~kdr7_masks[num]); +} + +/* +* Install the thread breakpoints in their debug registers. +*/ +static void arch_install_thbi (struct thread_hw_breakpoint *thbi) +{ +/* Install the user breakpoints. Kernel breakpoints are stored +* starting in DR0 and going up; there are num_kbps of them. +* User breakpoints are stored starting in DR3 and going down, +* as many as we have room for. +*/ +switch (thbi->num_installed) { +case 4 : +set_debugreg (thbi->tdr[0 ],0 ); +case 3 : +set_debugreg (thbi->tdr[1 ],1 ); +case 2 : +set_debugreg (thbi->tdr[2 ],2 ); +case 1 : +set_debugreg (thbi->tdr[3 ],3 ); + } +/* No need to set DR6 */ +set_debugreg (thbi->tkdr7,7 ); +} + +/* +* Install the debug register values for just the kernel, no thread. +*/ +static void arch_install_none (struct cpu_hw_breakpoint *chbi) +{ +set_debugreg (chbi->cur_kbpdata->mkdr7,7 ); +} + +/* +* Create a new kbpdata entry. +*/ +static void arch_new_kbpdata (struct kernel_bp_data *new_kbpdata) +{ +int num = new_kbpdata->num_kbps; + + new_kbpdata->mkdr7 = kdr7 & (kdr7_masks[num] |DR_GLOBAL_SLOWDOWN ); +} + +/* +* Store a thread breakpoint array entry's address +*/ +static void arch_store_thread_bp_array (struct thread_hw_breakpoint *thbi, +struct hw_breakpoint *bp,int i) +{ + thbi->tdr[i] = bp->info.address; +} + +/* +* Check for virtual address in user space. +*/ +static int arch_check_va_in_userspace (unsigned long va, +struct task_struct *tsk) +{ +#ifndef CONFIG_X86_64 +#define TASK_SIZE_OF (t) TASK_SIZE +#endif +return (va <TASK_SIZE_OF (tsk)); +} + +/* +* Check for virtual address in kernel space. +*/ +static int arch_check_va_in_kernelspace (unsigned long va) +{ +#ifndef CONFIG_X86_64 +#define TASK_SIZE64 TASK_SIZE +#endif +return (va >=TASK_SIZE64 ); +} + +/* +* Store a breakpoint's encoded address, length, and type. +*/ +static void arch_store_info (struct hw_breakpoint *bp) +{ +/* +* User-space requests will always have the address field populated +* For kernel-addresses, either the address or symbol name can be +* specified. +*/ +if (bp->info.address) +return ; + bp->info.address = (unsigned long )kallsyms_lookup_name (bp->info.name); +} + +/* +* Validate the arch-specific HW Breakpoint register settings +*/ +static int arch_validate_hwbkpt_settings (struct hw_breakpoint *bp, +unsigned int *align,struct task_struct *tsk) +{ +int ret = -EINVAL ; + +switch (bp->info.type) { + +/* Ptrace-refactoring code +* For now, we'll allow instruction breakpoint only for user-space +* addresses +*/ +case HW_BREAKPOINT_EXECUTE : +if ((!arch_check_va_in_userspace (bp->info.address, tsk)) && + bp->info.len !=HW_BREAKPOINT_LEN_EXECUTE ) +return ret; +break ; +case HW_BREAKPOINT_WRITE : +break ; +case HW_BREAKPOINT_RW : +break ; +default : +return ret; + } + +switch (bp->info.len) { +case HW_BREAKPOINT_LEN_1 : + *align =0 ; +break ; +case HW_BREAKPOINT_LEN_2 : + *align =1 ; +break ; +case HW_BREAKPOINT_LEN_4 : + *align =3 ; +break ; +default : +return ret; + } + +if (bp->triggered) { + ret =0 ; +arch_store_info (bp); + } +return ret; +} + +/* +* Encode the length, type, Exact, and Enable bits for a particular breakpoint +* as stored in debug register 7. +*/ +static unsigned long encode_dr7 (int drnum,unsigned len,unsigned type) +{ +unsigned long temp; + + temp = (len | type) &0xf ; + temp <<= (DR_CONTROL_SHIFT + drnum *DR_CONTROL_SIZE ); + temp |= (DR_GLOBAL_ENABLE << (drnum *DR_ENABLE_SIZE )) | +DR_GLOBAL_SLOWDOWN ; +return temp; +} + +/* +* Calculate the DR7 value for a list of kernel or user breakpoints. +*/ +static unsigned long calculate_dr7 (struct thread_hw_breakpoint *thbi) +{ +int is_user; +struct list_head *bp_list; +struct hw_breakpoint *bp; +int i; +int drnum; +unsigned long dr7; + +if (thbi) { + is_user =1 ; + bp_list = &thbi->thread_bps; + drnum =HB_NUM -1 ; + }else { + is_user =0 ; + bp_list = &kernel_bps; + drnum =0 ; + } + +/* Kernel bps are assigned from DR0 on up, and user bps are assigned +* from DR3 on down. Accumulate all 4 bps; the kernel DR7 mask will +* select the appropriate bits later. +*/ + dr7 =0 ; + i =0 ; +list_for_each_entry (bp, bp_list, node) { + +/* Get the debug register number and accumulate the bits */ + dr7 |=encode_dr7 (drnum, bp->info.len, bp->info.type); +if (++i >=HB_NUM ) +break ; +if (is_user) + --drnum; +else + ++drnum; + } +return dr7; +} + +/* +* Register a new user breakpoint structure. +*/ +static void arch_register_user_hw_breakpoint (struct hw_breakpoint *bp, +struct thread_hw_breakpoint *thbi) +{ + thbi->tdr7 =calculate_dr7 (thbi); + +/* If this is an execution breakpoint for the current PC address, +* we should clear the task's RF so that the bp will be certain +* to trigger. +* +* FIXME: It's not so easy to get hold of the task's PC as a linear +* address! ptrace.c does this already... +*/ +} + +/* +* Unregister a user breakpoint structure. +*/ +static void arch_unregister_user_hw_breakpoint (struct hw_breakpoint *bp, +struct thread_hw_breakpoint *thbi) +{ + thbi->tdr7 =calculate_dr7 (thbi); +} + +/* +* Register a kernel breakpoint structure. +*/ +static void arch_register_kernel_hw_breakpoint ( +struct hw_breakpoint *bp) +{ + kdr7 =calculate_dr7 (NULL ); +} + +/* +* Unregister a kernel breakpoint structure. +*/ +static void arch_unregister_kernel_hw_breakpoint ( +struct hw_breakpoint *bp) +{ + kdr7 =calculate_dr7 (NULL ); +} + + +/* End of arch-specific hook routines */ + + +/* +* Copy out the debug register information for a core dump. +* +* tsk must be equal to current. +*/ +void dump_thread_hw_breakpoint (struct task_struct *tsk,int u_debugreg[8 ]) +{ +struct thread_hw_breakpoint *thbi = tsk->thread.hw_breakpoint_info; +int i; + +memset (u_debugreg,0 ,sizeof u_debugreg); +if (thbi) { +for (i =0 ; i <HB_NUM ; ++i) + u_debugreg[i] = thbi->vdr_bps[i].info.address; + u_debugreg[7 ] = thbi->vdr7; + } + u_debugreg[6 ] = tsk->thread.vdr6; +} + +/* +* Handle debug exception notifications. +*/ + +static void switch_to_none_hw_breakpoint (void ); + +static int __kprobes hw_breakpoint_handler (struct die_args *args) +{ +struct cpu_hw_breakpoint *chbi; +int i; +struct hw_breakpoint *bp; +struct thread_hw_breakpoint *thbi =NULL ; + +/* The DR6 value is stored in args->err */ +#define DR6 (args->err) + +if (DR6 &DR_STEP ) +return NOTIFY_DONE ; + + chbi = &cpu_data (get_cpu ()); + +/* Disable all breakpoints so that the callbacks can run without +* triggering recursive debug exceptions. +*/ +set_debugreg (0UL ,7 ); + +/* Assert that local interrupts are disabled +* Reset the DRn bits in the virtualized register value. +* The ptrace trigger routine will add in whatever is needed. +*/ + current->thread.vdr6 &= ~(DR_TRAP0 |DR_TRAP1 |DR_TRAP2 |DR_TRAP3 ); + +/* Are we a victim of lazy debug-register switching? */ +if (!chbi->bp_task) + ; +else if (chbi->bp_task != current) { + +/* No user breakpoints are valid. Perform the belated +* debug-register switch. +*/ +switch_to_none_hw_breakpoint (); + }else { + thbi = chbi->bp_task->thread.hw_breakpoint_info; + } + +/* Handle all the breakpoints that were triggered */ +for (i =0 ; i <HB_NUM ; ++i) { +if (likely (!(DR6 & (DR_TRAP0 << i)))) +continue ; + +/* Find the corresponding hw_breakpoint structure and +* invoke its triggered callback. +*/ +if (i < chbi->cur_kbpdata->num_kbps) + bp = chbi->cur_kbpdata->bps[i]; +else if (thbi) + bp = thbi->bps[i]; +else /* False alarm due to lazy DR switching */ +continue ; +if (bp) { +switch (bp->info.type) { +case HW_BREAKPOINT_WRITE : +case HW_BREAKPOINT_RW : +if (bp->triggered) + (bp->triggered)(bp, args->regs); +/* Re-enable the breakpoints */ +set_debugreg (thbi ? thbi->tkdr7 : + chbi->cur_kbpdata->mkdr7,7 ); +put_cpu_no_resched (); + +return NOTIFY_STOP ; +/* +* Presently we allow instruction breakpoints only in +* user-space when requested through ptrace. +*/ +case HW_BREAKPOINT_EXECUTE : +if (arch_check_va_in_userspace (bp->info.address, + current)) { + (bp->triggered)(bp, args->regs); +/* We'll return NOTIFY_DONE, do_debug will take care of the rest */ +return NOTIFY_DONE ; + } + } + } + } +/* Stop processing further if the exception is a stray one */ +if (!(DR6 & ~(DR_TRAP0 |DR_TRAP1 |DR_TRAP2 |DR_TRAP3 ))) +return NOTIFY_STOP ; + +return NOTIFY_DONE ; +#undef DR6 +} + +/* +* Handle debug exception notifications. +*/ +static int __kprobes hw_breakpoint_exceptions_notify ( +struct notifier_block *unused,unsigned long val,void *data) +{ +if (val !=DIE_DEBUG ) +return NOTIFY_DONE ; +return hw_breakpoint_handler (data); +} + +static struct notifier_block hw_breakpoint_exceptions_nb = { + .notifier_call = hw_breakpoint_exceptions_notify, + .priority =0x7fffffff /* we need to be notified first */ +}; + +static int __init init_hw_breakpoint (void ) +{ +load_debug_registers (); +return register_die_notifier (&hw_breakpoint_exceptions_nb); +} + +core_initcall (init_hw_breakpoint); + + +/* Grab the arch-independent code */ +#include "../../../kernel/hw_breakpoint.c" +
include/asm-x86/hw_breakpoint.h new file +135 -0
135 lines not on this page · raw message
arch/x86/kernel/Makefile +1 -1
@@ -35,7 +35,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
PATCH 3/10 Modifying generic debug exception to use virtual debug registers
In reply to K.PrasadThis patch modifies the breakpoint exception handler code to use the abstract register names.
--- arch/x86/kernel/traps.c | 66 +++++++++++++++++------------------------------- 1 file changed, 24 insertions(+), 42 deletions(-)
arch/x86/kernel/traps.c +24 -42
@@ -570,10 +570,11 @@ 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 ); +set_debugreg (0 ,6 );/* DR6 may or may not be cleared by the CPU */ /* * The processor cleared BTF, so don't mark that we need it set.
@@ -581,61 +582,42 @@ dotraplinkage void __kprobes do_debug(stclear_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.vdr6 = dr6; + +if (notify_die (DIE_DEBUG ,"debug" , regs, dr6, error_code,SIGTRAP ) ==NOTIFY_STOP )return ;/* It's safe to allow irq's after DR6 has been saved */ preempt_conditional_sti (regs); -/* Mask out spurious debug traps due to lazy DR7 setting */ -if (condition & (DR_TRAP0 |DR_TRAP1 |DR_TRAP2 |DR_TRAP3 )) { -if (!tsk->thread.debugreg7) - goto clear_dr7; +if (regs->flags &X86_VM_MASK ) { +handle_vm86_trap ((struct kernel_vm86_regs *) regs, + error_code,1 ); +return ; }#ifdef CONFIG_X86_32 -if (regs->flags &X86_VM_MASK ) - goto debug_vm86;#endif -/* Save debug status register where ptrace can see it */ - tsk->thread.debugreg6 = condition; - -/* -* Single-stepping through TF: make sure we ignore any events in -* kernel space (but re-enable TF when returning to user mode). -*/ -if (condition &DR_STEP ) { -if (!user_mode (regs)) - goto clear_TF_reenable; - } - - 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: -handle_vm86_trap ((struct kernel_vm86_regs *) regs, error_code,1 ); -preempt_conditional_cli (regs); -return ; -#endif +if ((dr6 &DR_STEP ) && !user_mode (regs)) { + tsk->thread.vdr6 &= ~DR_STEP ; +set_tsk_thread_flag (tsk,TIF_SINGLESTEP ); + regs->flags &= ~X86_EFLAGS_TF ; + } + si_code =get_si_code (dr6); +if (tsk->thread.vdr6 & (DR_STEP |DR_TRAP0 |DR_TRAP1 |DR_TRAP2 |DR_TRAP3 )) +send_sigtrap (tsk, regs, error_code, si_code); -clear_TF_reenable: -set_tsk_thread_flag (tsk,TIF_SINGLESTEP ); - regs->flags &= ~X86_EFLAGS_TF ;preempt_conditional_cli (regs); -return ; }#ifdef CONFIG_X86_64
PATCH 4/10 Introduce virtual debug register in thread_struct and wrapper-routines around process related functions
In reply to K.PrasadThis patch introduces virtual debug registers to used by the per-thread structure ad wrapper routines to manage debug registers by process-related functions.
--- arch/x86/include/asm/debugreg.h | 27 +++++++++++++++++++++++++++ arch/x86/include/asm/processor.h | 10 +++------- 2 files changed, 30 insertions(+), 7 deletions(-)
arch/x86/include/asm/debugreg.h +27 -0
@@ -49,6 +49,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 +69,29 @@#define DR_LOCAL_SLOWDOWN (0x100)/* Local slow the pipeline */ #define DR_GLOBAL_SLOWDOWN (0x200)/* Global slow the pipeline */ +/* +* HW breakpoint additions +*/ +#ifdef __KERNEL__ + +/* For process management */ +void flush_thread_hw_breakpoint (struct task_struct *tsk); +int copy_thread_hw_breakpoint (struct task_struct *tsk, +struct task_struct *child,unsigned long clone_flags); +void dump_thread_hw_breakpoint (struct task_struct *tsk,int u_debugreg[8 ]); +void switch_to_thread_hw_breakpoint (struct task_struct *tsk); + +/* For CPU management */ +void load_debug_registers (void ); +static inline void disable_debug_registers (void ) +{ +set_debugreg (0UL ,7 ); +} + +/* For use by ptrace */ +unsigned long thread_get_debugreg (struct task_struct *tsk,int n); +int thread_set_debugreg (struct task_struct *tsk,int n,unsigned long val); + +#endif /* __KERNEL__ */ +#endif /* _ASM_X86_DEBUGREG_H */
arch/x86/include/asm/processor.h +3 -7
@@ -405,13 +405,9 @@ struct thread_struct {unsigned long ip;unsigned long fs;unsigned long gs; -/* Hardware debugging registers: */ -unsigned long debugreg0; -unsigned long debugreg1; -unsigned long debugreg2; -unsigned long debugreg3; -unsigned long debugreg6; -unsigned long debugreg7; +/* Hardware breakpoint info */ +unsigned long vdr6; +struct thread_hw_breakpoint *hw_breakpoint_info;/* Fault info: */ unsigned long cr2;unsigned long trap_no;
PATCH 5/10 Use wrapper routines around debug registers in processor related functions
In reply to K.PrasadThis 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(-)
arch/x86/power/cpu_32.c +3 -13
@@ -12,6 +12,7 @@#include <asm/mtrr.h> #include <asm/mce.h> #include <asm/xcr.h> +#include <asm/debugreg.h> static struct saved_context saved_context;
@@ -47,6 +48,7 @@ static void __save_processor_state(struc ctxt->cr2 =read_cr2 (); ctxt->cr3 =read_cr3 (); ctxt->cr4 =read_cr4_safe (); +disable_debug_registers (); }/* Needed by apm.c */
@@ -79,19 +81,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)
arch/x86/power/cpu_64.c +3 -12
@@ -15,6 +15,7 @@#include <asm/pgtable.h> #include <asm/mtrr.h> #include <asm/xcr.h> +#include <asm/debugreg.h> static void fix_processor_context (void );
@@ -70,6 +71,7 @@ static void __save_processor_state(struc ctxt->cr3 =read_cr3 (); ctxt->cr4 =read_cr4 (); ctxt->cr8 =read_cr8 (); +disable_debug_registers (); }void save_processor_state (void )
@@ -158,16 +160,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 (); }
arch/x86/kernel/smpboot.c +3 -0
@@ -63,6 +63,7 @@#include <asm/vmi.h> #include <asm/genapic.h> #include <asm/setup.h> +#include <asm/debugreg.h> #include <linux/mc146818rtc.h> #include <mach_apic.h>
@@ -337,6 +338,7 @@ notrace static void __cpuinit start_secosetup_secondary_clock ();wmb (); +load_debug_registers ();cpu_idle (); }
@@ -1373,6 +1375,7 @@ void cpu_disable_common(void)remove_cpu_from_maps (cpu);unlock_vector_lock ();fixup_irqs (); +disable_debug_registers (); }int native_cpu_disable (void )
PATCH 6/10 Use virtual debug registers in process/thread handling code
In reply to K.PrasadThis patch enables the use of abstract/virtual debug registers in process-handling routines.
--- arch/x86/kernel/process_32.c | 43 +++++++++++++++++++++++++------------------ arch/x86/kernel/process_64.c | 41 ++++++++++++++++++++++++----------------- 2 files changed, 49 insertions(+), 35 deletions(-)
arch/x86/kernel/process_32.c +25 -18
@@ -60,6 +60,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");
@@ -231,6 +233,8 @@ EXPORT_SYMBOL(kernel_thread);*/ void exit_thread (void ) { +struct task_struct *tsk = current; +/* The process may have allocated an io port bitmap... nuke it. */ if (unlikely (test_thread_flag (TIF_IO_BITMAP ))) {struct task_struct *tsk = current;
@@ -251,6 +255,8 @@ void exit_thread(void) tss->x86_tss.io_bitmap_base =INVALID_IO_BITMAP_OFFSET ;put_cpu (); } +if (unlikely (tsk->thread.hw_breakpoint_info)) +flush_thread_hw_breakpoint (tsk);ds_exit_thread (current); }
@@ -259,14 +265,9 @@ void flush_thread(void) {struct task_struct *tsk = current; - 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)); -clear_tsk_thread_flag (tsk,TIF_DEBUG ); +if (unlikely (tsk->thread.hw_breakpoint_info)) +flush_thread_hw_breakpoint (tsk);/* * Forget coprocessor state.. */
@@ -310,7 +311,15 @@ int copy_thread(int nr, unsigned long clsavesegment (gs, p->thread.gs); + p->thread.hw_breakpoint_info =NULL ; + p->thread.io_bitmap_ptr =NULL ; + tsk = current; + err = -ENOMEM ; +if (unlikely (tsk->thread.hw_breakpoint_info)) { +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 );
@@ -329,11 +338,13 @@ int copy_thread(int nr, unsigned long clif (clone_flags &CLONE_SETTLS ) 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);ds_copy_thread (p, current);
@@ -435,16 +446,6 @@ __switch_to_xtra(struct task_struct *preelse 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 */
@@ -592,6 +593,12 @@ __switch_to(struct task_struct *prev_p,loadsegment (gs, next->gs);x86_write_percpu (current_task, next_p); +/* +* Handle debug registers. This must be done _after_ current +* is updated. +*/ +if (unlikely (test_tsk_thread_flag (next_p,TIF_DEBUG ))) +switch_to_thread_hw_breakpoint (next_p);return prev_p; }
arch/x86/kernel/process_64.c +24 -17
90 lines not on this page · raw message
PATCH 7/10 Modify signal handling code to refrain from re-enabling HW Breakpoints
In reply to K.PrasadThis 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(-)
arch/x86/kernel/signal.c +0 -9
@@ -814,15 +814,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/10 Modify Ptrace routines to access breakpoint registers
In reply to K.PrasadThis patch modifies the ptrace code to use the new wrapper routines around the debug/breakpoint registers.
--- arch/x86/kernel/ptrace.c | 228 +++++++++++++++++++++++++++++++---------------- 1 file changed, 152 insertions(+), 76 deletions(-)
arch/x86/kernel/ptrace.c +152 -76
@@ -33,6 +33,7 @@#include <asm/prctl.h> #include <asm/proto.h> #include <asm/ds.h> +#include <asm/hw_breakpoint.h> #include "tls.h"
@@ -466,95 +467,170 @@ 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; +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 void ptrace_triggered (struct hw_breakpoint *bp,struct pt_regs *regs) +{ +struct task_struct *tsk = current; +struct thread_hw_breakpoint *thbi = tsk->thread.hw_breakpoint_info; +int i; + +/* Store in the virtual DR6 register the fact that the breakpoint +* was hit so the thread's debugger will see it. +*/ +if (thbi) { + i = bp - thbi->vdr_bps; + tsk->thread.vdr6 |= (DR_TRAP0 << i); } -return 0 ; } -static int ptrace_set_debugreg (struct task_struct *child, -int n,unsigned long data) +/* +* Handle ptrace writes to debug register 7. +*/ +static int ptrace_write_dr7 (struct task_struct *tsk, +struct thread_hw_breakpoint *thbi,unsigned long data) { +struct hw_breakpoint *bp;int i; +int rc =0 ; +unsigned long old_dr7 = thbi->vdr7; -if (unlikely (n ==4 || n ==5 )) -return -EIO ; + data &= ~DR_CONTROL_RESERVED ; -if (n <4 &&unlikely (data >=debugreg_addr_limit (child))) -return -EIO ; +/* Loop through all the hardware breakpoints, making the +* appropriate changes to each. +*/ + restore_settings: + thbi->vdr7 = data; + bp = &thbi->vdr_bps[0 ]; +for (i =0 ; i <HB_NUM ; (++i, ++bp)) { +int enabled; +unsigned len, type; + + enabled =decode_dr7 (data, i, &len, &type); + +/* Unregister the breakpoint before trying to change it */ +if (bp->status) +__unregister_user_hw_breakpoint (tsk, bp); -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 ; +/* Now register the breakpoint if it should be enabled. +* New invalid entries will raise an error here. +*/ +if (enabled) { + bp->triggered = ptrace_triggered; + bp->info.len = len; + bp->info.type = type; + + bp->priority =HW_BREAKPOINT_PRIO_PTRACE ; +if (rc ==0 &&__register_user_hw_breakpoint (tsk, + bp) <0 ) +break ; + } + } -case 6 : -if ((data & ~0xffffffffUL ) !=0 ) -return -EIO ; - child->thread.debugreg6 = data; -break ; +/* If anything above failed, restore the original settings */ +if (i <HB_NUM ) { + rc = -EIO ; + data = old_dr7; + goto restore_settings; + } +return 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) +/* +* Handle PTRACE_PEEKUSR calls for the debug register area. +*/ +unsigned long ptrace_get_debugreg (struct task_struct *tsk,int n) +{ +struct thread_hw_breakpoint *thbi; +unsigned long val =0 ; + +mutex_lock (&hw_breakpoint_mutex); + thbi = tsk->thread.hw_breakpoint_info; +if (n <HB_NUM ) { +if (thbi) + val = thbi->vdr_bps[n].info.address; + }else if (n ==6 ) { + val = tsk->thread.vdr6; + }else if (n ==7 ) { +if (thbi) + val = thbi->vdr7; + } +mutex_unlock (&hw_breakpoint_mutex); +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_hw_breakpoint *thbi; +int rc = -EIO ; + +/* We have to hold this lock the entire time, to prevent thbi +* from being deallocated out from under us. +*/ +mutex_lock (&hw_breakpoint_mutex); + +/* There are no DR4 or DR5 registers */ +if (n ==4 || n ==5 ) + ; + +/* Writes to DR6 modify the virtualized value */ +else if (n ==6 ) { + tsk->thread.vdr6 = val; + rc =0 ; + } + +else if (!tsk->thread.hw_breakpoint_info && val ==0 ) + rc =0 ;/* Minor optimization */ + +else if ((thbi =alloc_thread_hw_breakpoint (tsk)) ==NULL ) + rc = -ENOMEM ; + +/* Writes to DR0 - DR3 change a breakpoint address */ +else if (n <HB_NUM ) { +struct hw_breakpoint *bp = &thbi->vdr_bps[n]; + +/* If the breakpoint is registered then unregister it, +* change it, and re-register it. Revert to the original +* address if an error occurs. */ -#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 ; +if (bp->status) { +unsigned long old_addr = bp->info.address; + +__unregister_user_hw_breakpoint (tsk, bp); + + bp->info.address = val; + rc =__register_user_hw_breakpoint (tsk, bp); +if (rc <0 ) { + bp->info.address = old_addr; +__register_user_hw_breakpoint (tsk, bp); + } + }else { + bp->info.address = val; + rc =0 ; + } } -return 0 ; +/* All that's left is DR7 */ +else + rc =ptrace_write_dr7 (tsk, thbi, val); + +mutex_unlock (&hw_breakpoint_mutex); +return rc; }/*
@@ -872,7 +948,7 @@ long arch_ptrace(struct task_struct *chi else if (addr >= offsetof(struct user, u_debugreg[0]) && addr <= offsetof(struct user, u_debugreg[7])) { addr -= offsetof(struct user, u_debugreg[0]); - tmp =ptrace_get_debugreg (child, addr /sizeof (data)); + tmp =ptrace_get_debugreg (child, addr/sizeof (data)); } ret =put_user (tmp, datap);break ;
@@ -890,7 +966,7 @@ long arch_ptrace(struct task_struct *chi addr <= offsetof(struct user, u_debugreg[7])) { addr -= offsetof(struct user, u_debugreg[0]); ret =ptrace_set_debugreg (child, - addr /sizeof (data), data); + addr/sizeof (data), data); }break ;
PATCH 9/10 Cleanup HW Breakpoint registers before kexec
In reply to K.PrasadThis 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(+)
arch/x86/kernel/machine_kexec_32.c +2 -0
@@ -25,6 +25,7 @@#include <asm/desc.h> #include <asm/system.h> #include <asm/cacheflush.h> +#include <asm/debugreg.h> static void set_idt (void *newidt,__u16 limit) {
@@ -202,6 +203,7 @@ void machine_kexec(struct kimage *image)/* Interrupts aren't acceptable while we reboot */ local_irq_disable (); +disable_debug_registers ();if (image->preserve_context) {#ifdef CONFIG_X86_IO_APIC
arch/x86/kernel/machine_kexec_64.c +2 -0
@@ -17,6 +17,7 @@#include <asm/tlbflush.h> #include <asm/mmu_context.h> #include <asm/io.h> +#include <asm/debugreg.h> #define PAGE_ALIGNED __attribute__ ((__aligned__(PAGE_SIZE))) static u64 kexec_pgd[512] PAGE_ALIGNED;
@@ -190,6 +191,7 @@ void machine_kexec(struct kimage *image)/* Interrupts aren't acceptable while we reboot */ local_irq_disable (); +disable_debug_registers (); control_page =page_address (image->control_code_page) +PAGE_SIZE ;memcpy (control_page, relocate_kernel,PAGE_SIZE );
PATCH 10/10 Sample HW breakpoint over kernel data address
In reply to K.PrasadThis 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 | 80 ++++++++++++++++++++++++++++++++ 4 files changed, 89 insertions(+), 1 deletion(-)
samples/Kconfig +6 -0
@@ -39,5 +39,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 m + help + This builds kernel hardware breakpoint example modules. + endif # SAMPLES
samples/Makefile +2 -1
@@ -1,3 +1,4 @@ # Makefile for Linux samples code -obj-$(CONFIG_SAMPLES) += markers/ kobject/ kprobes/ tracepoints/ +obj-$(CONFIG_SAMPLES) += markers/ kobject/ kprobes/ tracepoints/ \ + hw_breakpoint/
samples/hw_breakpoint/Makefile new file +1 -0
@@ -0,0 +1 @@ +obj-$(CONFIG_SAMPLE_HW_BREAKPOINT) += data_breakpoint.o
samples/hw_breakpoint/data_breakpoint.c new file +80 -0
80 lines not on this page · raw message