10067f129SK.Prasad /* 20067f129SK.Prasad * This program is free software; you can redistribute it and/or modify 30067f129SK.Prasad * it under the terms of the GNU General Public License as published by 40067f129SK.Prasad * the Free Software Foundation; either version 2 of the License, or 50067f129SK.Prasad * (at your option) any later version. 60067f129SK.Prasad * 70067f129SK.Prasad * This program is distributed in the hope that it will be useful, 80067f129SK.Prasad * but WITHOUT ANY WARRANTY; without even the implied warranty of 90067f129SK.Prasad * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 100067f129SK.Prasad * GNU General Public License for more details. 110067f129SK.Prasad * 120067f129SK.Prasad * You should have received a copy of the GNU General Public License 130067f129SK.Prasad * along with this program; if not, write to the Free Software 140067f129SK.Prasad * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 150067f129SK.Prasad * 160067f129SK.Prasad * Copyright (C) 2007 Alan Stern 170067f129SK.Prasad * Copyright (C) 2009 IBM Corporation 1824f1e32cSFrederic Weisbecker * Copyright (C) 2009 Frederic Weisbecker <fweisbec@gmail.com> 19ba6909b7SK.Prasad * 20ba6909b7SK.Prasad * Authors: Alan Stern <stern@rowland.harvard.edu> 21ba6909b7SK.Prasad * K.Prasad <prasad@linux.vnet.ibm.com> 22ba6909b7SK.Prasad * Frederic Weisbecker <fweisbec@gmail.com> 230067f129SK.Prasad */ 240067f129SK.Prasad 250067f129SK.Prasad /* 260067f129SK.Prasad * HW_breakpoint: a unified kernel/user-space hardware breakpoint facility, 270067f129SK.Prasad * using the CPU's debug registers. 280067f129SK.Prasad */ 290067f129SK.Prasad 3024f1e32cSFrederic Weisbecker #include <linux/perf_event.h> 3124f1e32cSFrederic Weisbecker #include <linux/hw_breakpoint.h> 320067f129SK.Prasad #include <linux/irqflags.h> 330067f129SK.Prasad #include <linux/notifier.h> 340067f129SK.Prasad #include <linux/kallsyms.h> 35e5779e8eSAndy Lutomirski #include <linux/kprobes.h> 360067f129SK.Prasad #include <linux/percpu.h> 370067f129SK.Prasad #include <linux/kdebug.h> 380067f129SK.Prasad #include <linux/kernel.h> 39186f4360SPaul Gortmaker #include <linux/export.h> 400067f129SK.Prasad #include <linux/sched.h> 410067f129SK.Prasad #include <linux/smp.h> 420067f129SK.Prasad 430067f129SK.Prasad #include <asm/hw_breakpoint.h> 440067f129SK.Prasad #include <asm/processor.h> 450067f129SK.Prasad #include <asm/debugreg.h> 46186f4360SPaul Gortmaker #include <asm/user.h> 470067f129SK.Prasad 4824f1e32cSFrederic Weisbecker /* Per cpu debug control register value */ 4928b4e0d8STejun Heo DEFINE_PER_CPU(unsigned long, cpu_dr7); 5028b4e0d8STejun Heo EXPORT_PER_CPU_SYMBOL(cpu_dr7); 5124f1e32cSFrederic Weisbecker 5224f1e32cSFrederic Weisbecker /* Per cpu debug address registers values */ 5324f1e32cSFrederic Weisbecker static DEFINE_PER_CPU(unsigned long, cpu_debugreg[HBP_NUM]); 540067f129SK.Prasad 550067f129SK.Prasad /* 5624f1e32cSFrederic Weisbecker * Stores the breakpoints currently in use on each breakpoint address 5724f1e32cSFrederic Weisbecker * register for each cpus 580067f129SK.Prasad */ 5924f1e32cSFrederic Weisbecker static DEFINE_PER_CPU(struct perf_event *, bp_per_reg[HBP_NUM]); 600067f129SK.Prasad 610067f129SK.Prasad 622c31b795SFrederic Weisbecker static inline unsigned long 632c31b795SFrederic Weisbecker __encode_dr7(int drnum, unsigned int len, unsigned int type) 642c31b795SFrederic Weisbecker { 652c31b795SFrederic Weisbecker unsigned long bp_info; 662c31b795SFrederic Weisbecker 672c31b795SFrederic Weisbecker bp_info = (len | type) & 0xf; 682c31b795SFrederic Weisbecker bp_info <<= (DR_CONTROL_SHIFT + drnum * DR_CONTROL_SIZE); 692c31b795SFrederic Weisbecker bp_info |= (DR_GLOBAL_ENABLE << (drnum * DR_ENABLE_SIZE)); 702c31b795SFrederic Weisbecker 712c31b795SFrederic Weisbecker return bp_info; 722c31b795SFrederic Weisbecker } 732c31b795SFrederic Weisbecker 740067f129SK.Prasad /* 750067f129SK.Prasad * Encode the length, type, Exact, and Enable bits for a particular breakpoint 760067f129SK.Prasad * as stored in debug register 7. 770067f129SK.Prasad */ 7824f1e32cSFrederic Weisbecker unsigned long encode_dr7(int drnum, unsigned int len, unsigned int type) 790067f129SK.Prasad { 802c31b795SFrederic Weisbecker return __encode_dr7(drnum, len, type) | DR_GLOBAL_SLOWDOWN; 810067f129SK.Prasad } 820067f129SK.Prasad 8324f1e32cSFrederic Weisbecker /* 8424f1e32cSFrederic Weisbecker * Decode the length and type bits for a particular breakpoint as 8524f1e32cSFrederic Weisbecker * stored in debug register 7. Return the "enabled" status. 860067f129SK.Prasad */ 8724f1e32cSFrederic Weisbecker int decode_dr7(unsigned long dr7, int bpnum, unsigned *len, unsigned *type) 8824f1e32cSFrederic Weisbecker { 8924f1e32cSFrederic Weisbecker int bp_info = dr7 >> (DR_CONTROL_SHIFT + bpnum * DR_CONTROL_SIZE); 9024f1e32cSFrederic Weisbecker 9124f1e32cSFrederic Weisbecker *len = (bp_info & 0xc) | 0x40; 9224f1e32cSFrederic Weisbecker *type = (bp_info & 0x3) | 0x80; 9324f1e32cSFrederic Weisbecker 9424f1e32cSFrederic Weisbecker return (dr7 >> (bpnum * DR_ENABLE_SIZE)) & 0x3; 950067f129SK.Prasad } 960067f129SK.Prasad 970067f129SK.Prasad /* 9824f1e32cSFrederic Weisbecker * Install a perf counter breakpoint. 9924f1e32cSFrederic Weisbecker * 10024f1e32cSFrederic Weisbecker * We seek a free debug address register and use it for this 10124f1e32cSFrederic Weisbecker * breakpoint. Eventually we enable it in the debug control register. 10224f1e32cSFrederic Weisbecker * 10324f1e32cSFrederic Weisbecker * Atomic: we hold the counter->ctx->lock and we only handle variables 10424f1e32cSFrederic Weisbecker * and registers local to this cpu. 1050067f129SK.Prasad */ 10624f1e32cSFrederic Weisbecker int arch_install_hw_breakpoint(struct perf_event *bp) 1070067f129SK.Prasad { 10824f1e32cSFrederic Weisbecker struct arch_hw_breakpoint *info = counter_arch_bp(bp); 10924f1e32cSFrederic Weisbecker unsigned long *dr7; 11024f1e32cSFrederic Weisbecker int i; 1110067f129SK.Prasad 11224f1e32cSFrederic Weisbecker for (i = 0; i < HBP_NUM; i++) { 11389cbc767SChristoph Lameter struct perf_event **slot = this_cpu_ptr(&bp_per_reg[i]); 11424f1e32cSFrederic Weisbecker 11524f1e32cSFrederic Weisbecker if (!*slot) { 11624f1e32cSFrederic Weisbecker *slot = bp; 1170067f129SK.Prasad break; 1180067f129SK.Prasad } 11924f1e32cSFrederic Weisbecker } 1200067f129SK.Prasad 12124f1e32cSFrederic Weisbecker if (WARN_ONCE(i == HBP_NUM, "Can't find any breakpoint slot")) 12224f1e32cSFrederic Weisbecker return -EBUSY; 12324f1e32cSFrederic Weisbecker 12424f1e32cSFrederic Weisbecker set_debugreg(info->address, i); 1250a3aee0dSTejun Heo __this_cpu_write(cpu_debugreg[i], info->address); 12624f1e32cSFrederic Weisbecker 12789cbc767SChristoph Lameter dr7 = this_cpu_ptr(&cpu_dr7); 12824f1e32cSFrederic Weisbecker *dr7 |= encode_dr7(i, info->len, info->type); 12924f1e32cSFrederic Weisbecker 13024f1e32cSFrederic Weisbecker set_debugreg(*dr7, 7); 131d6d55f0bSJacob Shin if (info->mask) 132d6d55f0bSJacob Shin set_dr_addr_mask(info->mask, i); 13324f1e32cSFrederic Weisbecker 13424f1e32cSFrederic Weisbecker return 0; 1350067f129SK.Prasad } 1360067f129SK.Prasad 1370067f129SK.Prasad /* 13824f1e32cSFrederic Weisbecker * Uninstall the breakpoint contained in the given counter. 13924f1e32cSFrederic Weisbecker * 14024f1e32cSFrederic Weisbecker * First we search the debug address register it uses and then we disable 14124f1e32cSFrederic Weisbecker * it. 14224f1e32cSFrederic Weisbecker * 14324f1e32cSFrederic Weisbecker * Atomic: we hold the counter->ctx->lock and we only handle variables 14424f1e32cSFrederic Weisbecker * and registers local to this cpu. 1450067f129SK.Prasad */ 14624f1e32cSFrederic Weisbecker void arch_uninstall_hw_breakpoint(struct perf_event *bp) 1470067f129SK.Prasad { 14824f1e32cSFrederic Weisbecker struct arch_hw_breakpoint *info = counter_arch_bp(bp); 14924f1e32cSFrederic Weisbecker unsigned long *dr7; 15024f1e32cSFrederic Weisbecker int i; 1510067f129SK.Prasad 15224f1e32cSFrederic Weisbecker for (i = 0; i < HBP_NUM; i++) { 15389cbc767SChristoph Lameter struct perf_event **slot = this_cpu_ptr(&bp_per_reg[i]); 15424f1e32cSFrederic Weisbecker 15524f1e32cSFrederic Weisbecker if (*slot == bp) { 15624f1e32cSFrederic Weisbecker *slot = NULL; 15724f1e32cSFrederic Weisbecker break; 15824f1e32cSFrederic Weisbecker } 15924f1e32cSFrederic Weisbecker } 16024f1e32cSFrederic Weisbecker 16124f1e32cSFrederic Weisbecker if (WARN_ONCE(i == HBP_NUM, "Can't find any breakpoint slot")) 16224f1e32cSFrederic Weisbecker return; 16324f1e32cSFrederic Weisbecker 16489cbc767SChristoph Lameter dr7 = this_cpu_ptr(&cpu_dr7); 1652c31b795SFrederic Weisbecker *dr7 &= ~__encode_dr7(i, info->len, info->type); 16624f1e32cSFrederic Weisbecker 16724f1e32cSFrederic Weisbecker set_debugreg(*dr7, 7); 168d6d55f0bSJacob Shin if (info->mask) 169d6d55f0bSJacob Shin set_dr_addr_mask(0, i); 1700067f129SK.Prasad } 1710067f129SK.Prasad 1720067f129SK.Prasad /* 1730067f129SK.Prasad * Check for virtual address in kernel space. 1740067f129SK.Prasad */ 175b2812d03SFrederic Weisbecker int arch_check_bp_in_kernelspace(struct perf_event *bp) 1760067f129SK.Prasad { 1770067f129SK.Prasad unsigned int len; 178b2812d03SFrederic Weisbecker unsigned long va; 179b2812d03SFrederic Weisbecker struct arch_hw_breakpoint *info = counter_arch_bp(bp); 1800067f129SK.Prasad 181b2812d03SFrederic Weisbecker va = info->address; 18236748b95SJacob Shin len = bp->attr.bp_len; 1830067f129SK.Prasad 18427747f8bSAndy Lutomirski /* 18527747f8bSAndy Lutomirski * We don't need to worry about va + len - 1 overflowing: 18627747f8bSAndy Lutomirski * we already require that va is aligned to a multiple of len. 18727747f8bSAndy Lutomirski */ 18827747f8bSAndy Lutomirski return (va >= TASK_SIZE_MAX) || ((va + len - 1) >= TASK_SIZE_MAX); 1890067f129SK.Prasad } 1900067f129SK.Prasad 19124f1e32cSFrederic Weisbecker int arch_bp_generic_fields(int x86_len, int x86_type, 19224f1e32cSFrederic Weisbecker int *gen_len, int *gen_type) 19324f1e32cSFrederic Weisbecker { 19489e45aacSFrederic Weisbecker /* Type */ 19589e45aacSFrederic Weisbecker switch (x86_type) { 19689e45aacSFrederic Weisbecker case X86_BREAKPOINT_EXECUTE: 19789e45aacSFrederic Weisbecker if (x86_len != X86_BREAKPOINT_LEN_X) 19889e45aacSFrederic Weisbecker return -EINVAL; 19989e45aacSFrederic Weisbecker 20089e45aacSFrederic Weisbecker *gen_type = HW_BREAKPOINT_X; 20189e45aacSFrederic Weisbecker *gen_len = sizeof(long); 20289e45aacSFrederic Weisbecker return 0; 20389e45aacSFrederic Weisbecker case X86_BREAKPOINT_WRITE: 20489e45aacSFrederic Weisbecker *gen_type = HW_BREAKPOINT_W; 20589e45aacSFrederic Weisbecker break; 20689e45aacSFrederic Weisbecker case X86_BREAKPOINT_RW: 20789e45aacSFrederic Weisbecker *gen_type = HW_BREAKPOINT_W | HW_BREAKPOINT_R; 20889e45aacSFrederic Weisbecker break; 20989e45aacSFrederic Weisbecker default: 21089e45aacSFrederic Weisbecker return -EINVAL; 21189e45aacSFrederic Weisbecker } 21289e45aacSFrederic Weisbecker 21324f1e32cSFrederic Weisbecker /* Len */ 21424f1e32cSFrederic Weisbecker switch (x86_len) { 21524f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_1: 21624f1e32cSFrederic Weisbecker *gen_len = HW_BREAKPOINT_LEN_1; 21724f1e32cSFrederic Weisbecker break; 21824f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_2: 21924f1e32cSFrederic Weisbecker *gen_len = HW_BREAKPOINT_LEN_2; 22024f1e32cSFrederic Weisbecker break; 22124f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_4: 22224f1e32cSFrederic Weisbecker *gen_len = HW_BREAKPOINT_LEN_4; 22324f1e32cSFrederic Weisbecker break; 22424f1e32cSFrederic Weisbecker #ifdef CONFIG_X86_64 22524f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_8: 22624f1e32cSFrederic Weisbecker *gen_len = HW_BREAKPOINT_LEN_8; 22724f1e32cSFrederic Weisbecker break; 22824f1e32cSFrederic Weisbecker #endif 22924f1e32cSFrederic Weisbecker default: 23024f1e32cSFrederic Weisbecker return -EINVAL; 23124f1e32cSFrederic Weisbecker } 23224f1e32cSFrederic Weisbecker 23324f1e32cSFrederic Weisbecker return 0; 23424f1e32cSFrederic Weisbecker } 23524f1e32cSFrederic Weisbecker 23624f1e32cSFrederic Weisbecker 23724f1e32cSFrederic Weisbecker static int arch_build_bp_info(struct perf_event *bp) 23824f1e32cSFrederic Weisbecker { 23924f1e32cSFrederic Weisbecker struct arch_hw_breakpoint *info = counter_arch_bp(bp); 24024f1e32cSFrederic Weisbecker 24124f1e32cSFrederic Weisbecker info->address = bp->attr.bp_addr; 24224f1e32cSFrederic Weisbecker 243f7809dafSFrederic Weisbecker /* Type */ 244f7809dafSFrederic Weisbecker switch (bp->attr.bp_type) { 245f7809dafSFrederic Weisbecker case HW_BREAKPOINT_W: 246f7809dafSFrederic Weisbecker info->type = X86_BREAKPOINT_WRITE; 247f7809dafSFrederic Weisbecker break; 248f7809dafSFrederic Weisbecker case HW_BREAKPOINT_W | HW_BREAKPOINT_R: 249f7809dafSFrederic Weisbecker info->type = X86_BREAKPOINT_RW; 250f7809dafSFrederic Weisbecker break; 251f7809dafSFrederic Weisbecker case HW_BREAKPOINT_X: 252e5779e8eSAndy Lutomirski /* 253e5779e8eSAndy Lutomirski * We don't allow kernel breakpoints in places that are not 254e5779e8eSAndy Lutomirski * acceptable for kprobes. On non-kprobes kernels, we don't 255e5779e8eSAndy Lutomirski * allow kernel breakpoints at all. 256e5779e8eSAndy Lutomirski */ 257e5779e8eSAndy Lutomirski if (bp->attr.bp_addr >= TASK_SIZE_MAX) { 258e5779e8eSAndy Lutomirski #ifdef CONFIG_KPROBES 259e5779e8eSAndy Lutomirski if (within_kprobe_blacklist(bp->attr.bp_addr)) 260e5779e8eSAndy Lutomirski return -EINVAL; 261e5779e8eSAndy Lutomirski #else 262e5779e8eSAndy Lutomirski return -EINVAL; 263e5779e8eSAndy Lutomirski #endif 264e5779e8eSAndy Lutomirski } 265e5779e8eSAndy Lutomirski 266f7809dafSFrederic Weisbecker info->type = X86_BREAKPOINT_EXECUTE; 267f7809dafSFrederic Weisbecker /* 268f7809dafSFrederic Weisbecker * x86 inst breakpoints need to have a specific undefined len. 269f7809dafSFrederic Weisbecker * But we still need to check userspace is not trying to setup 270f7809dafSFrederic Weisbecker * an unsupported length, to get a range breakpoint for example. 271f7809dafSFrederic Weisbecker */ 272f7809dafSFrederic Weisbecker if (bp->attr.bp_len == sizeof(long)) { 273f7809dafSFrederic Weisbecker info->len = X86_BREAKPOINT_LEN_X; 274f7809dafSFrederic Weisbecker return 0; 275f7809dafSFrederic Weisbecker } 276f7809dafSFrederic Weisbecker default: 277f7809dafSFrederic Weisbecker return -EINVAL; 278f7809dafSFrederic Weisbecker } 279f7809dafSFrederic Weisbecker 28024f1e32cSFrederic Weisbecker /* Len */ 281d6d55f0bSJacob Shin info->mask = 0; 282d6d55f0bSJacob Shin 28324f1e32cSFrederic Weisbecker switch (bp->attr.bp_len) { 28424f1e32cSFrederic Weisbecker case HW_BREAKPOINT_LEN_1: 28524f1e32cSFrederic Weisbecker info->len = X86_BREAKPOINT_LEN_1; 28624f1e32cSFrederic Weisbecker break; 28724f1e32cSFrederic Weisbecker case HW_BREAKPOINT_LEN_2: 28824f1e32cSFrederic Weisbecker info->len = X86_BREAKPOINT_LEN_2; 28924f1e32cSFrederic Weisbecker break; 29024f1e32cSFrederic Weisbecker case HW_BREAKPOINT_LEN_4: 29124f1e32cSFrederic Weisbecker info->len = X86_BREAKPOINT_LEN_4; 29224f1e32cSFrederic Weisbecker break; 29324f1e32cSFrederic Weisbecker #ifdef CONFIG_X86_64 29424f1e32cSFrederic Weisbecker case HW_BREAKPOINT_LEN_8: 29524f1e32cSFrederic Weisbecker info->len = X86_BREAKPOINT_LEN_8; 29624f1e32cSFrederic Weisbecker break; 29724f1e32cSFrederic Weisbecker #endif 29824f1e32cSFrederic Weisbecker default: 299ab513927SAndy Lutomirski /* AMD range breakpoint */ 300d6d55f0bSJacob Shin if (!is_power_of_2(bp->attr.bp_len)) 30124f1e32cSFrederic Weisbecker return -EINVAL; 302ab513927SAndy Lutomirski if (bp->attr.bp_addr & (bp->attr.bp_len - 1)) 303ab513927SAndy Lutomirski return -EINVAL; 304362f924bSBorislav Petkov 305362f924bSBorislav Petkov if (!boot_cpu_has(X86_FEATURE_BPEXT)) 306362f924bSBorislav Petkov return -EOPNOTSUPP; 307362f924bSBorislav Petkov 308ab513927SAndy Lutomirski /* 309ab513927SAndy Lutomirski * It's impossible to use a range breakpoint to fake out 310ab513927SAndy Lutomirski * user vs kernel detection because bp_len - 1 can't 311ab513927SAndy Lutomirski * have the high bit set. If we ever allow range instruction 312ab513927SAndy Lutomirski * breakpoints, then we'll have to check for kprobe-blacklisted 313ab513927SAndy Lutomirski * addresses anywhere in the range. 314ab513927SAndy Lutomirski */ 315d6d55f0bSJacob Shin info->mask = bp->attr.bp_len - 1; 316d6d55f0bSJacob Shin info->len = X86_BREAKPOINT_LEN_1; 31724f1e32cSFrederic Weisbecker } 31824f1e32cSFrederic Weisbecker 31924f1e32cSFrederic Weisbecker return 0; 32024f1e32cSFrederic Weisbecker } 321d6d55f0bSJacob Shin 3220067f129SK.Prasad /* 3230067f129SK.Prasad * Validate the arch-specific HW Breakpoint register settings 3240067f129SK.Prasad */ 325b2812d03SFrederic Weisbecker int arch_validate_hwbkpt_settings(struct perf_event *bp) 3260067f129SK.Prasad { 32724f1e32cSFrederic Weisbecker struct arch_hw_breakpoint *info = counter_arch_bp(bp); 3280067f129SK.Prasad unsigned int align; 32924f1e32cSFrederic Weisbecker int ret; 3300067f129SK.Prasad 33124f1e32cSFrederic Weisbecker 33224f1e32cSFrederic Weisbecker ret = arch_build_bp_info(bp); 33324f1e32cSFrederic Weisbecker if (ret) 33424f1e32cSFrederic Weisbecker return ret; 33524f1e32cSFrederic Weisbecker 33624f1e32cSFrederic Weisbecker switch (info->len) { 33724f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_1: 3380067f129SK.Prasad align = 0; 339d6d55f0bSJacob Shin if (info->mask) 340d6d55f0bSJacob Shin align = info->mask; 3410067f129SK.Prasad break; 34224f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_2: 3430067f129SK.Prasad align = 1; 3440067f129SK.Prasad break; 34524f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_4: 3460067f129SK.Prasad align = 3; 3470067f129SK.Prasad break; 3480067f129SK.Prasad #ifdef CONFIG_X86_64 34924f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_8: 3500067f129SK.Prasad align = 7; 3510067f129SK.Prasad break; 3520067f129SK.Prasad #endif 3530067f129SK.Prasad default: 354d6d55f0bSJacob Shin WARN_ON_ONCE(1); 3550067f129SK.Prasad } 3560067f129SK.Prasad 35784d71092SFrederic Weisbecker /* 3580067f129SK.Prasad * Check that the low-order bits of the address are appropriate 3590067f129SK.Prasad * for the alignment implied by len. 3600067f129SK.Prasad */ 36124f1e32cSFrederic Weisbecker if (info->address & align) 3620067f129SK.Prasad return -EINVAL; 3630067f129SK.Prasad 3640067f129SK.Prasad return 0; 3650067f129SK.Prasad } 3660067f129SK.Prasad 36724f1e32cSFrederic Weisbecker /* 3689f6b3c2cSFrederic Weisbecker * Dump the debug register contents to the user. 3699f6b3c2cSFrederic Weisbecker * We can't dump our per cpu values because it 3709f6b3c2cSFrederic Weisbecker * may contain cpu wide breakpoint, something that 3719f6b3c2cSFrederic Weisbecker * doesn't belong to the current task. 3729f6b3c2cSFrederic Weisbecker * 3739f6b3c2cSFrederic Weisbecker * TODO: include non-ptrace user breakpoints (perf) 3749f6b3c2cSFrederic Weisbecker */ 3759f6b3c2cSFrederic Weisbecker void aout_dump_debugregs(struct user *dump) 3769f6b3c2cSFrederic Weisbecker { 3779f6b3c2cSFrederic Weisbecker int i; 3789f6b3c2cSFrederic Weisbecker int dr7 = 0; 3799f6b3c2cSFrederic Weisbecker struct perf_event *bp; 3809f6b3c2cSFrederic Weisbecker struct arch_hw_breakpoint *info; 3819f6b3c2cSFrederic Weisbecker struct thread_struct *thread = ¤t->thread; 3829f6b3c2cSFrederic Weisbecker 3839f6b3c2cSFrederic Weisbecker for (i = 0; i < HBP_NUM; i++) { 3849f6b3c2cSFrederic Weisbecker bp = thread->ptrace_bps[i]; 3859f6b3c2cSFrederic Weisbecker 3869f6b3c2cSFrederic Weisbecker if (bp && !bp->attr.disabled) { 3879f6b3c2cSFrederic Weisbecker dump->u_debugreg[i] = bp->attr.bp_addr; 3889f6b3c2cSFrederic Weisbecker info = counter_arch_bp(bp); 3899f6b3c2cSFrederic Weisbecker dr7 |= encode_dr7(i, info->len, info->type); 3909f6b3c2cSFrederic Weisbecker } else { 3919f6b3c2cSFrederic Weisbecker dump->u_debugreg[i] = 0; 3929f6b3c2cSFrederic Weisbecker } 3939f6b3c2cSFrederic Weisbecker } 3949f6b3c2cSFrederic Weisbecker 3959f6b3c2cSFrederic Weisbecker dump->u_debugreg[4] = 0; 3969f6b3c2cSFrederic Weisbecker dump->u_debugreg[5] = 0; 3979f6b3c2cSFrederic Weisbecker dump->u_debugreg[6] = current->thread.debugreg6; 3989f6b3c2cSFrederic Weisbecker 3999f6b3c2cSFrederic Weisbecker dump->u_debugreg[7] = dr7; 4009f6b3c2cSFrederic Weisbecker } 40168efa37dSIngo Molnar EXPORT_SYMBOL_GPL(aout_dump_debugregs); 4029f6b3c2cSFrederic Weisbecker 4039f6b3c2cSFrederic Weisbecker /* 40424f1e32cSFrederic Weisbecker * Release the user breakpoints used by ptrace 40524f1e32cSFrederic Weisbecker */ 40624f1e32cSFrederic Weisbecker void flush_ptrace_hw_breakpoint(struct task_struct *tsk) 4070067f129SK.Prasad { 4080067f129SK.Prasad int i; 40924f1e32cSFrederic Weisbecker struct thread_struct *t = &tsk->thread; 4100067f129SK.Prasad 41124f1e32cSFrederic Weisbecker for (i = 0; i < HBP_NUM; i++) { 41224f1e32cSFrederic Weisbecker unregister_hw_breakpoint(t->ptrace_bps[i]); 41324f1e32cSFrederic Weisbecker t->ptrace_bps[i] = NULL; 4140067f129SK.Prasad } 415f7da04c9SOleg Nesterov 416f7da04c9SOleg Nesterov t->debugreg6 = 0; 417f7da04c9SOleg Nesterov t->ptrace_dr7 = 0; 41824f1e32cSFrederic Weisbecker } 41924f1e32cSFrederic Weisbecker 42024f1e32cSFrederic Weisbecker void hw_breakpoint_restore(void) 42124f1e32cSFrederic Weisbecker { 4220a3aee0dSTejun Heo set_debugreg(__this_cpu_read(cpu_debugreg[0]), 0); 4230a3aee0dSTejun Heo set_debugreg(__this_cpu_read(cpu_debugreg[1]), 1); 4240a3aee0dSTejun Heo set_debugreg(__this_cpu_read(cpu_debugreg[2]), 2); 4250a3aee0dSTejun Heo set_debugreg(__this_cpu_read(cpu_debugreg[3]), 3); 42624f1e32cSFrederic Weisbecker set_debugreg(current->thread.debugreg6, 6); 4270a3aee0dSTejun Heo set_debugreg(__this_cpu_read(cpu_dr7), 7); 42824f1e32cSFrederic Weisbecker } 42924f1e32cSFrederic Weisbecker EXPORT_SYMBOL_GPL(hw_breakpoint_restore); 4300067f129SK.Prasad 4310067f129SK.Prasad /* 4320067f129SK.Prasad * Handle debug exception notifications. 4330067f129SK.Prasad * 4340067f129SK.Prasad * Return value is either NOTIFY_STOP or NOTIFY_DONE as explained below. 4350067f129SK.Prasad * 4360067f129SK.Prasad * NOTIFY_DONE returned if one of the following conditions is true. 4370067f129SK.Prasad * i) When the causative address is from user-space and the exception 4380067f129SK.Prasad * is a valid one, i.e. not triggered as a result of lazy debug register 4390067f129SK.Prasad * switching 4400067f129SK.Prasad * ii) When there are more bits than trap<n> set in DR6 register (such 4410067f129SK.Prasad * as BD, BS or BT) indicating that more than one debug condition is 4420067f129SK.Prasad * met and requires some more action in do_debug(). 4430067f129SK.Prasad * 4440067f129SK.Prasad * NOTIFY_STOP returned for all other cases 4450067f129SK.Prasad * 4460067f129SK.Prasad */ 4479c54b616SMasami Hiramatsu static int hw_breakpoint_handler(struct die_args *args) 4480067f129SK.Prasad { 4490067f129SK.Prasad int i, cpu, rc = NOTIFY_STOP; 45024f1e32cSFrederic Weisbecker struct perf_event *bp; 45162edab90SK.Prasad unsigned long dr7, dr6; 45262edab90SK.Prasad unsigned long *dr6_p; 45362edab90SK.Prasad 45462edab90SK.Prasad /* The DR6 value is pointed by args->err */ 45562edab90SK.Prasad dr6_p = (unsigned long *)ERR_PTR(args->err); 45662edab90SK.Prasad dr6 = *dr6_p; 4570067f129SK.Prasad 4586c0aca28SFrederic Weisbecker /* If it's a single step, TRAP bits are random */ 4596c0aca28SFrederic Weisbecker if (dr6 & DR_STEP) 4606c0aca28SFrederic Weisbecker return NOTIFY_DONE; 4616c0aca28SFrederic Weisbecker 4620067f129SK.Prasad /* Do an early return if no trap bits are set in DR6 */ 4630067f129SK.Prasad if ((dr6 & DR_TRAP_BITS) == 0) 4640067f129SK.Prasad return NOTIFY_DONE; 4650067f129SK.Prasad 4660067f129SK.Prasad get_debugreg(dr7, 7); 4670067f129SK.Prasad /* Disable breakpoints during exception handling */ 4680067f129SK.Prasad set_debugreg(0UL, 7); 4690067f129SK.Prasad /* 4700067f129SK.Prasad * Assert that local interrupts are disabled 4710067f129SK.Prasad * Reset the DRn bits in the virtualized register value. 4720067f129SK.Prasad * The ptrace trigger routine will add in whatever is needed. 4730067f129SK.Prasad */ 4740067f129SK.Prasad current->thread.debugreg6 &= ~DR_TRAP_BITS; 4750067f129SK.Prasad cpu = get_cpu(); 4760067f129SK.Prasad 4770067f129SK.Prasad /* Handle all the breakpoints that were triggered */ 4780067f129SK.Prasad for (i = 0; i < HBP_NUM; ++i) { 4790067f129SK.Prasad if (likely(!(dr6 & (DR_TRAP0 << i)))) 4800067f129SK.Prasad continue; 48124f1e32cSFrederic Weisbecker 4820067f129SK.Prasad /* 48324f1e32cSFrederic Weisbecker * The counter may be concurrently released but that can only 48424f1e32cSFrederic Weisbecker * occur from a call_rcu() path. We can then safely fetch 48524f1e32cSFrederic Weisbecker * the breakpoint, use its callback, touch its counter 48624f1e32cSFrederic Weisbecker * while we are in an rcu_read_lock() path. 4870067f129SK.Prasad */ 48824f1e32cSFrederic Weisbecker rcu_read_lock(); 48924f1e32cSFrederic Weisbecker 49024f1e32cSFrederic Weisbecker bp = per_cpu(bp_per_reg[i], cpu); 4910067f129SK.Prasad /* 49262edab90SK.Prasad * Reset the 'i'th TRAP bit in dr6 to denote completion of 49362edab90SK.Prasad * exception handling 49462edab90SK.Prasad */ 49562edab90SK.Prasad (*dr6_p) &= ~(DR_TRAP0 << i); 49662edab90SK.Prasad /* 4970067f129SK.Prasad * bp can be NULL due to lazy debug register switching 49824f1e32cSFrederic Weisbecker * or due to concurrent perf counter removing. 4990067f129SK.Prasad */ 50024f1e32cSFrederic Weisbecker if (!bp) { 50124f1e32cSFrederic Weisbecker rcu_read_unlock(); 50224f1e32cSFrederic Weisbecker break; 50324f1e32cSFrederic Weisbecker } 5040067f129SK.Prasad 505b326e956SFrederic Weisbecker perf_bp_event(bp, args->regs); 50624f1e32cSFrederic Weisbecker 5070c4519e8SFrederic Weisbecker /* 5080c4519e8SFrederic Weisbecker * Set up resume flag to avoid breakpoint recursion when 5090c4519e8SFrederic Weisbecker * returning back to origin. 5100c4519e8SFrederic Weisbecker */ 5110c4519e8SFrederic Weisbecker if (bp->hw.info.type == X86_BREAKPOINT_EXECUTE) 5120c4519e8SFrederic Weisbecker args->regs->flags |= X86_EFLAGS_RF; 5130c4519e8SFrederic Weisbecker 51424f1e32cSFrederic Weisbecker rcu_read_unlock(); 5150067f129SK.Prasad } 516e0e53db6SK.Prasad /* 517e0e53db6SK.Prasad * Further processing in do_debug() is needed for a) user-space 518e0e53db6SK.Prasad * breakpoints (to generate signals) and b) when the system has 519e0e53db6SK.Prasad * taken exception due to multiple causes 520e0e53db6SK.Prasad */ 521e0e53db6SK.Prasad if ((current->thread.debugreg6 & DR_TRAP_BITS) || 522e0e53db6SK.Prasad (dr6 & (~DR_TRAP_BITS))) 5230067f129SK.Prasad rc = NOTIFY_DONE; 5240067f129SK.Prasad 5250067f129SK.Prasad set_debugreg(dr7, 7); 526eadb8a09SIngo Molnar put_cpu(); 52724f1e32cSFrederic Weisbecker 5280067f129SK.Prasad return rc; 5290067f129SK.Prasad } 5300067f129SK.Prasad 5310067f129SK.Prasad /* 5320067f129SK.Prasad * Handle debug exception notifications. 5330067f129SK.Prasad */ 5349c54b616SMasami Hiramatsu int hw_breakpoint_exceptions_notify( 5350067f129SK.Prasad struct notifier_block *unused, unsigned long val, void *data) 5360067f129SK.Prasad { 5370067f129SK.Prasad if (val != DIE_DEBUG) 5380067f129SK.Prasad return NOTIFY_DONE; 5390067f129SK.Prasad 5400067f129SK.Prasad return hw_breakpoint_handler(data); 5410067f129SK.Prasad } 54224f1e32cSFrederic Weisbecker 54324f1e32cSFrederic Weisbecker void hw_breakpoint_pmu_read(struct perf_event *bp) 54424f1e32cSFrederic Weisbecker { 54524f1e32cSFrederic Weisbecker /* TODO */ 54624f1e32cSFrederic Weisbecker } 547