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> 190067f129SK.Prasad */ 200067f129SK.Prasad 210067f129SK.Prasad /* 220067f129SK.Prasad * HW_breakpoint: a unified kernel/user-space hardware breakpoint facility, 230067f129SK.Prasad * using the CPU's debug registers. 240067f129SK.Prasad */ 250067f129SK.Prasad 2624f1e32cSFrederic Weisbecker #include <linux/perf_event.h> 2724f1e32cSFrederic Weisbecker #include <linux/hw_breakpoint.h> 280067f129SK.Prasad #include <linux/irqflags.h> 290067f129SK.Prasad #include <linux/notifier.h> 300067f129SK.Prasad #include <linux/kallsyms.h> 310067f129SK.Prasad #include <linux/kprobes.h> 320067f129SK.Prasad #include <linux/percpu.h> 330067f129SK.Prasad #include <linux/kdebug.h> 340067f129SK.Prasad #include <linux/kernel.h> 350067f129SK.Prasad #include <linux/module.h> 360067f129SK.Prasad #include <linux/sched.h> 370067f129SK.Prasad #include <linux/init.h> 380067f129SK.Prasad #include <linux/smp.h> 390067f129SK.Prasad 400067f129SK.Prasad #include <asm/hw_breakpoint.h> 410067f129SK.Prasad #include <asm/processor.h> 420067f129SK.Prasad #include <asm/debugreg.h> 430067f129SK.Prasad 4424f1e32cSFrederic Weisbecker /* Per cpu debug control register value */ 4524f1e32cSFrederic Weisbecker DEFINE_PER_CPU(unsigned long, dr7); 4668efa37dSIngo Molnar EXPORT_PER_CPU_SYMBOL(dr7); 4724f1e32cSFrederic Weisbecker 4824f1e32cSFrederic Weisbecker /* Per cpu debug address registers values */ 4924f1e32cSFrederic Weisbecker static DEFINE_PER_CPU(unsigned long, cpu_debugreg[HBP_NUM]); 500067f129SK.Prasad 510067f129SK.Prasad /* 5224f1e32cSFrederic Weisbecker * Stores the breakpoints currently in use on each breakpoint address 5324f1e32cSFrederic Weisbecker * register for each cpus 540067f129SK.Prasad */ 5524f1e32cSFrederic Weisbecker static DEFINE_PER_CPU(struct perf_event *, bp_per_reg[HBP_NUM]); 560067f129SK.Prasad 570067f129SK.Prasad 580067f129SK.Prasad /* 590067f129SK.Prasad * Encode the length, type, Exact, and Enable bits for a particular breakpoint 600067f129SK.Prasad * as stored in debug register 7. 610067f129SK.Prasad */ 6224f1e32cSFrederic Weisbecker unsigned long encode_dr7(int drnum, unsigned int len, unsigned int type) 630067f129SK.Prasad { 640067f129SK.Prasad unsigned long bp_info; 650067f129SK.Prasad 660067f129SK.Prasad bp_info = (len | type) & 0xf; 670067f129SK.Prasad bp_info <<= (DR_CONTROL_SHIFT + drnum * DR_CONTROL_SIZE); 680067f129SK.Prasad bp_info |= (DR_GLOBAL_ENABLE << (drnum * DR_ENABLE_SIZE)) | 690067f129SK.Prasad DR_GLOBAL_SLOWDOWN; 700067f129SK.Prasad return bp_info; 710067f129SK.Prasad } 720067f129SK.Prasad 7324f1e32cSFrederic Weisbecker /* 7424f1e32cSFrederic Weisbecker * Decode the length and type bits for a particular breakpoint as 7524f1e32cSFrederic Weisbecker * stored in debug register 7. Return the "enabled" status. 760067f129SK.Prasad */ 7724f1e32cSFrederic Weisbecker int decode_dr7(unsigned long dr7, int bpnum, unsigned *len, unsigned *type) 7824f1e32cSFrederic Weisbecker { 7924f1e32cSFrederic Weisbecker int bp_info = dr7 >> (DR_CONTROL_SHIFT + bpnum * DR_CONTROL_SIZE); 8024f1e32cSFrederic Weisbecker 8124f1e32cSFrederic Weisbecker *len = (bp_info & 0xc) | 0x40; 8224f1e32cSFrederic Weisbecker *type = (bp_info & 0x3) | 0x80; 8324f1e32cSFrederic Weisbecker 8424f1e32cSFrederic Weisbecker return (dr7 >> (bpnum * DR_ENABLE_SIZE)) & 0x3; 850067f129SK.Prasad } 860067f129SK.Prasad 870067f129SK.Prasad /* 8824f1e32cSFrederic Weisbecker * Install a perf counter breakpoint. 8924f1e32cSFrederic Weisbecker * 9024f1e32cSFrederic Weisbecker * We seek a free debug address register and use it for this 9124f1e32cSFrederic Weisbecker * breakpoint. Eventually we enable it in the debug control register. 9224f1e32cSFrederic Weisbecker * 9324f1e32cSFrederic Weisbecker * Atomic: we hold the counter->ctx->lock and we only handle variables 9424f1e32cSFrederic Weisbecker * and registers local to this cpu. 950067f129SK.Prasad */ 9624f1e32cSFrederic Weisbecker int arch_install_hw_breakpoint(struct perf_event *bp) 970067f129SK.Prasad { 9824f1e32cSFrederic Weisbecker struct arch_hw_breakpoint *info = counter_arch_bp(bp); 9924f1e32cSFrederic Weisbecker unsigned long *dr7; 10024f1e32cSFrederic Weisbecker int i; 1010067f129SK.Prasad 10224f1e32cSFrederic Weisbecker for (i = 0; i < HBP_NUM; i++) { 10324f1e32cSFrederic Weisbecker struct perf_event **slot = &__get_cpu_var(bp_per_reg[i]); 10424f1e32cSFrederic Weisbecker 10524f1e32cSFrederic Weisbecker if (!*slot) { 10624f1e32cSFrederic Weisbecker *slot = bp; 1070067f129SK.Prasad break; 1080067f129SK.Prasad } 10924f1e32cSFrederic Weisbecker } 1100067f129SK.Prasad 11124f1e32cSFrederic Weisbecker if (WARN_ONCE(i == HBP_NUM, "Can't find any breakpoint slot")) 11224f1e32cSFrederic Weisbecker return -EBUSY; 11324f1e32cSFrederic Weisbecker 11424f1e32cSFrederic Weisbecker set_debugreg(info->address, i); 11524f1e32cSFrederic Weisbecker __get_cpu_var(cpu_debugreg[i]) = info->address; 11624f1e32cSFrederic Weisbecker 11724f1e32cSFrederic Weisbecker dr7 = &__get_cpu_var(dr7); 11824f1e32cSFrederic Weisbecker *dr7 |= encode_dr7(i, info->len, info->type); 11924f1e32cSFrederic Weisbecker 12024f1e32cSFrederic Weisbecker set_debugreg(*dr7, 7); 12124f1e32cSFrederic Weisbecker 12224f1e32cSFrederic Weisbecker return 0; 1230067f129SK.Prasad } 1240067f129SK.Prasad 1250067f129SK.Prasad /* 12624f1e32cSFrederic Weisbecker * Uninstall the breakpoint contained in the given counter. 12724f1e32cSFrederic Weisbecker * 12824f1e32cSFrederic Weisbecker * First we search the debug address register it uses and then we disable 12924f1e32cSFrederic Weisbecker * it. 13024f1e32cSFrederic Weisbecker * 13124f1e32cSFrederic Weisbecker * Atomic: we hold the counter->ctx->lock and we only handle variables 13224f1e32cSFrederic Weisbecker * and registers local to this cpu. 1330067f129SK.Prasad */ 13424f1e32cSFrederic Weisbecker void arch_uninstall_hw_breakpoint(struct perf_event *bp) 1350067f129SK.Prasad { 13624f1e32cSFrederic Weisbecker struct arch_hw_breakpoint *info = counter_arch_bp(bp); 13724f1e32cSFrederic Weisbecker unsigned long *dr7; 13824f1e32cSFrederic Weisbecker int i; 1390067f129SK.Prasad 14024f1e32cSFrederic Weisbecker for (i = 0; i < HBP_NUM; i++) { 14124f1e32cSFrederic Weisbecker struct perf_event **slot = &__get_cpu_var(bp_per_reg[i]); 14224f1e32cSFrederic Weisbecker 14324f1e32cSFrederic Weisbecker if (*slot == bp) { 14424f1e32cSFrederic Weisbecker *slot = NULL; 14524f1e32cSFrederic Weisbecker break; 14624f1e32cSFrederic Weisbecker } 14724f1e32cSFrederic Weisbecker } 14824f1e32cSFrederic Weisbecker 14924f1e32cSFrederic Weisbecker if (WARN_ONCE(i == HBP_NUM, "Can't find any breakpoint slot")) 15024f1e32cSFrederic Weisbecker return; 15124f1e32cSFrederic Weisbecker 15224f1e32cSFrederic Weisbecker dr7 = &__get_cpu_var(dr7); 15324f1e32cSFrederic Weisbecker *dr7 &= ~encode_dr7(i, info->len, info->type); 15424f1e32cSFrederic Weisbecker 15524f1e32cSFrederic Weisbecker set_debugreg(*dr7, 7); 1560067f129SK.Prasad } 1570067f129SK.Prasad 1580067f129SK.Prasad static int get_hbp_len(u8 hbp_len) 1590067f129SK.Prasad { 1600067f129SK.Prasad unsigned int len_in_bytes = 0; 1610067f129SK.Prasad 1620067f129SK.Prasad switch (hbp_len) { 16324f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_1: 1640067f129SK.Prasad len_in_bytes = 1; 1650067f129SK.Prasad break; 16624f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_2: 1670067f129SK.Prasad len_in_bytes = 2; 1680067f129SK.Prasad break; 16924f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_4: 1700067f129SK.Prasad len_in_bytes = 4; 1710067f129SK.Prasad break; 1720067f129SK.Prasad #ifdef CONFIG_X86_64 17324f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_8: 1740067f129SK.Prasad len_in_bytes = 8; 1750067f129SK.Prasad break; 1760067f129SK.Prasad #endif 1770067f129SK.Prasad } 1780067f129SK.Prasad return len_in_bytes; 1790067f129SK.Prasad } 1800067f129SK.Prasad 1810067f129SK.Prasad /* 1820067f129SK.Prasad * Check for virtual address in user space. 1830067f129SK.Prasad */ 1840067f129SK.Prasad int arch_check_va_in_userspace(unsigned long va, u8 hbp_len) 1850067f129SK.Prasad { 1860067f129SK.Prasad unsigned int len; 1870067f129SK.Prasad 1880067f129SK.Prasad len = get_hbp_len(hbp_len); 1890067f129SK.Prasad 1900067f129SK.Prasad return (va <= TASK_SIZE - len); 1910067f129SK.Prasad } 1920067f129SK.Prasad 1930067f129SK.Prasad /* 1940067f129SK.Prasad * Check for virtual address in kernel space. 1950067f129SK.Prasad */ 1964555835bSJaswinder Singh Rajput static int arch_check_va_in_kernelspace(unsigned long va, u8 hbp_len) 1970067f129SK.Prasad { 1980067f129SK.Prasad unsigned int len; 1990067f129SK.Prasad 2000067f129SK.Prasad len = get_hbp_len(hbp_len); 2010067f129SK.Prasad 2020067f129SK.Prasad return (va >= TASK_SIZE) && ((va + len - 1) >= TASK_SIZE); 2030067f129SK.Prasad } 2040067f129SK.Prasad 2050067f129SK.Prasad /* 2060067f129SK.Prasad * Store a breakpoint's encoded address, length, and type. 2070067f129SK.Prasad */ 20824f1e32cSFrederic Weisbecker static int arch_store_info(struct perf_event *bp) 2090067f129SK.Prasad { 21024f1e32cSFrederic Weisbecker struct arch_hw_breakpoint *info = counter_arch_bp(bp); 2110067f129SK.Prasad /* 2120067f129SK.Prasad * For kernel-addresses, either the address or symbol name can be 2130067f129SK.Prasad * specified. 2140067f129SK.Prasad */ 21524f1e32cSFrederic Weisbecker if (info->name) 21624f1e32cSFrederic Weisbecker info->address = (unsigned long) 21724f1e32cSFrederic Weisbecker kallsyms_lookup_name(info->name); 21824f1e32cSFrederic Weisbecker if (info->address) 2190067f129SK.Prasad return 0; 22024f1e32cSFrederic Weisbecker 2210067f129SK.Prasad return -EINVAL; 2220067f129SK.Prasad } 2230067f129SK.Prasad 22424f1e32cSFrederic Weisbecker int arch_bp_generic_fields(int x86_len, int x86_type, 22524f1e32cSFrederic Weisbecker int *gen_len, int *gen_type) 22624f1e32cSFrederic Weisbecker { 22724f1e32cSFrederic Weisbecker /* Len */ 22824f1e32cSFrederic Weisbecker switch (x86_len) { 22924f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_1: 23024f1e32cSFrederic Weisbecker *gen_len = HW_BREAKPOINT_LEN_1; 23124f1e32cSFrederic Weisbecker break; 23224f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_2: 23324f1e32cSFrederic Weisbecker *gen_len = HW_BREAKPOINT_LEN_2; 23424f1e32cSFrederic Weisbecker break; 23524f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_4: 23624f1e32cSFrederic Weisbecker *gen_len = HW_BREAKPOINT_LEN_4; 23724f1e32cSFrederic Weisbecker break; 23824f1e32cSFrederic Weisbecker #ifdef CONFIG_X86_64 23924f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_8: 24024f1e32cSFrederic Weisbecker *gen_len = HW_BREAKPOINT_LEN_8; 24124f1e32cSFrederic Weisbecker break; 24224f1e32cSFrederic Weisbecker #endif 24324f1e32cSFrederic Weisbecker default: 24424f1e32cSFrederic Weisbecker return -EINVAL; 24524f1e32cSFrederic Weisbecker } 24624f1e32cSFrederic Weisbecker 24724f1e32cSFrederic Weisbecker /* Type */ 24824f1e32cSFrederic Weisbecker switch (x86_type) { 24924f1e32cSFrederic Weisbecker case X86_BREAKPOINT_EXECUTE: 25024f1e32cSFrederic Weisbecker *gen_type = HW_BREAKPOINT_X; 25124f1e32cSFrederic Weisbecker break; 25224f1e32cSFrederic Weisbecker case X86_BREAKPOINT_WRITE: 25324f1e32cSFrederic Weisbecker *gen_type = HW_BREAKPOINT_W; 25424f1e32cSFrederic Weisbecker break; 25524f1e32cSFrederic Weisbecker case X86_BREAKPOINT_RW: 25624f1e32cSFrederic Weisbecker *gen_type = HW_BREAKPOINT_W | HW_BREAKPOINT_R; 25724f1e32cSFrederic Weisbecker break; 25824f1e32cSFrederic Weisbecker default: 25924f1e32cSFrederic Weisbecker return -EINVAL; 26024f1e32cSFrederic Weisbecker } 26124f1e32cSFrederic Weisbecker 26224f1e32cSFrederic Weisbecker return 0; 26324f1e32cSFrederic Weisbecker } 26424f1e32cSFrederic Weisbecker 26524f1e32cSFrederic Weisbecker 26624f1e32cSFrederic Weisbecker static int arch_build_bp_info(struct perf_event *bp) 26724f1e32cSFrederic Weisbecker { 26824f1e32cSFrederic Weisbecker struct arch_hw_breakpoint *info = counter_arch_bp(bp); 26924f1e32cSFrederic Weisbecker 27024f1e32cSFrederic Weisbecker info->address = bp->attr.bp_addr; 27124f1e32cSFrederic Weisbecker 27224f1e32cSFrederic Weisbecker /* Len */ 27324f1e32cSFrederic Weisbecker switch (bp->attr.bp_len) { 27424f1e32cSFrederic Weisbecker case HW_BREAKPOINT_LEN_1: 27524f1e32cSFrederic Weisbecker info->len = X86_BREAKPOINT_LEN_1; 27624f1e32cSFrederic Weisbecker break; 27724f1e32cSFrederic Weisbecker case HW_BREAKPOINT_LEN_2: 27824f1e32cSFrederic Weisbecker info->len = X86_BREAKPOINT_LEN_2; 27924f1e32cSFrederic Weisbecker break; 28024f1e32cSFrederic Weisbecker case HW_BREAKPOINT_LEN_4: 28124f1e32cSFrederic Weisbecker info->len = X86_BREAKPOINT_LEN_4; 28224f1e32cSFrederic Weisbecker break; 28324f1e32cSFrederic Weisbecker #ifdef CONFIG_X86_64 28424f1e32cSFrederic Weisbecker case HW_BREAKPOINT_LEN_8: 28524f1e32cSFrederic Weisbecker info->len = X86_BREAKPOINT_LEN_8; 28624f1e32cSFrederic Weisbecker break; 28724f1e32cSFrederic Weisbecker #endif 28824f1e32cSFrederic Weisbecker default: 28924f1e32cSFrederic Weisbecker return -EINVAL; 29024f1e32cSFrederic Weisbecker } 29124f1e32cSFrederic Weisbecker 29224f1e32cSFrederic Weisbecker /* Type */ 29324f1e32cSFrederic Weisbecker switch (bp->attr.bp_type) { 29424f1e32cSFrederic Weisbecker case HW_BREAKPOINT_W: 29524f1e32cSFrederic Weisbecker info->type = X86_BREAKPOINT_WRITE; 29624f1e32cSFrederic Weisbecker break; 29724f1e32cSFrederic Weisbecker case HW_BREAKPOINT_W | HW_BREAKPOINT_R: 29824f1e32cSFrederic Weisbecker info->type = X86_BREAKPOINT_RW; 29924f1e32cSFrederic Weisbecker break; 30024f1e32cSFrederic Weisbecker case HW_BREAKPOINT_X: 30124f1e32cSFrederic Weisbecker info->type = X86_BREAKPOINT_EXECUTE; 30224f1e32cSFrederic Weisbecker break; 30324f1e32cSFrederic Weisbecker default: 30424f1e32cSFrederic Weisbecker return -EINVAL; 30524f1e32cSFrederic Weisbecker } 30624f1e32cSFrederic Weisbecker 30724f1e32cSFrederic Weisbecker return 0; 30824f1e32cSFrederic Weisbecker } 3090067f129SK.Prasad /* 3100067f129SK.Prasad * Validate the arch-specific HW Breakpoint register settings 3110067f129SK.Prasad */ 31224f1e32cSFrederic Weisbecker int arch_validate_hwbkpt_settings(struct perf_event *bp, 3130067f129SK.Prasad struct task_struct *tsk) 3140067f129SK.Prasad { 31524f1e32cSFrederic Weisbecker struct arch_hw_breakpoint *info = counter_arch_bp(bp); 3160067f129SK.Prasad unsigned int align; 31724f1e32cSFrederic Weisbecker int ret; 3180067f129SK.Prasad 31924f1e32cSFrederic Weisbecker 32024f1e32cSFrederic Weisbecker ret = arch_build_bp_info(bp); 32124f1e32cSFrederic Weisbecker if (ret) 32224f1e32cSFrederic Weisbecker return ret; 32324f1e32cSFrederic Weisbecker 32424f1e32cSFrederic Weisbecker ret = -EINVAL; 32524f1e32cSFrederic Weisbecker 32624f1e32cSFrederic Weisbecker if (info->type == X86_BREAKPOINT_EXECUTE) 3270067f129SK.Prasad /* 3280067f129SK.Prasad * Ptrace-refactoring code 3290067f129SK.Prasad * For now, we'll allow instruction breakpoint only for user-space 3300067f129SK.Prasad * addresses 3310067f129SK.Prasad */ 33224f1e32cSFrederic Weisbecker if ((!arch_check_va_in_userspace(info->address, info->len)) && 33324f1e32cSFrederic Weisbecker info->len != X86_BREAKPOINT_EXECUTE) 3340067f129SK.Prasad return ret; 3350067f129SK.Prasad 33624f1e32cSFrederic Weisbecker switch (info->len) { 33724f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_1: 3380067f129SK.Prasad align = 0; 3390067f129SK.Prasad break; 34024f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_2: 3410067f129SK.Prasad align = 1; 3420067f129SK.Prasad break; 34324f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_4: 3440067f129SK.Prasad align = 3; 3450067f129SK.Prasad break; 3460067f129SK.Prasad #ifdef CONFIG_X86_64 34724f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_8: 3480067f129SK.Prasad align = 7; 3490067f129SK.Prasad break; 3500067f129SK.Prasad #endif 3510067f129SK.Prasad default: 3520067f129SK.Prasad return ret; 3530067f129SK.Prasad } 3540067f129SK.Prasad 35524f1e32cSFrederic Weisbecker if (bp->callback) 35624f1e32cSFrederic Weisbecker ret = arch_store_info(bp); 3570067f129SK.Prasad 3580067f129SK.Prasad if (ret < 0) 3590067f129SK.Prasad return ret; 3600067f129SK.Prasad /* 3610067f129SK.Prasad * Check that the low-order bits of the address are appropriate 3620067f129SK.Prasad * for the alignment implied by len. 3630067f129SK.Prasad */ 36424f1e32cSFrederic Weisbecker if (info->address & align) 3650067f129SK.Prasad return -EINVAL; 3660067f129SK.Prasad 3670067f129SK.Prasad /* Check that the virtual address is in the proper range */ 3680067f129SK.Prasad if (tsk) { 36924f1e32cSFrederic Weisbecker if (!arch_check_va_in_userspace(info->address, info->len)) 3700067f129SK.Prasad return -EFAULT; 3710067f129SK.Prasad } else { 37224f1e32cSFrederic Weisbecker if (!arch_check_va_in_kernelspace(info->address, info->len)) 3730067f129SK.Prasad return -EFAULT; 3740067f129SK.Prasad } 37524f1e32cSFrederic Weisbecker 3760067f129SK.Prasad return 0; 3770067f129SK.Prasad } 3780067f129SK.Prasad 37924f1e32cSFrederic Weisbecker /* 3809f6b3c2cSFrederic Weisbecker * Dump the debug register contents to the user. 3819f6b3c2cSFrederic Weisbecker * We can't dump our per cpu values because it 3829f6b3c2cSFrederic Weisbecker * may contain cpu wide breakpoint, something that 3839f6b3c2cSFrederic Weisbecker * doesn't belong to the current task. 3849f6b3c2cSFrederic Weisbecker * 3859f6b3c2cSFrederic Weisbecker * TODO: include non-ptrace user breakpoints (perf) 3869f6b3c2cSFrederic Weisbecker */ 3879f6b3c2cSFrederic Weisbecker void aout_dump_debugregs(struct user *dump) 3889f6b3c2cSFrederic Weisbecker { 3899f6b3c2cSFrederic Weisbecker int i; 3909f6b3c2cSFrederic Weisbecker int dr7 = 0; 3919f6b3c2cSFrederic Weisbecker struct perf_event *bp; 3929f6b3c2cSFrederic Weisbecker struct arch_hw_breakpoint *info; 3939f6b3c2cSFrederic Weisbecker struct thread_struct *thread = ¤t->thread; 3949f6b3c2cSFrederic Weisbecker 3959f6b3c2cSFrederic Weisbecker for (i = 0; i < HBP_NUM; i++) { 3969f6b3c2cSFrederic Weisbecker bp = thread->ptrace_bps[i]; 3979f6b3c2cSFrederic Weisbecker 3989f6b3c2cSFrederic Weisbecker if (bp && !bp->attr.disabled) { 3999f6b3c2cSFrederic Weisbecker dump->u_debugreg[i] = bp->attr.bp_addr; 4009f6b3c2cSFrederic Weisbecker info = counter_arch_bp(bp); 4019f6b3c2cSFrederic Weisbecker dr7 |= encode_dr7(i, info->len, info->type); 4029f6b3c2cSFrederic Weisbecker } else { 4039f6b3c2cSFrederic Weisbecker dump->u_debugreg[i] = 0; 4049f6b3c2cSFrederic Weisbecker } 4059f6b3c2cSFrederic Weisbecker } 4069f6b3c2cSFrederic Weisbecker 4079f6b3c2cSFrederic Weisbecker dump->u_debugreg[4] = 0; 4089f6b3c2cSFrederic Weisbecker dump->u_debugreg[5] = 0; 4099f6b3c2cSFrederic Weisbecker dump->u_debugreg[6] = current->thread.debugreg6; 4109f6b3c2cSFrederic Weisbecker 4119f6b3c2cSFrederic Weisbecker dump->u_debugreg[7] = dr7; 4129f6b3c2cSFrederic Weisbecker } 41368efa37dSIngo Molnar EXPORT_SYMBOL_GPL(aout_dump_debugregs); 4149f6b3c2cSFrederic Weisbecker 4159f6b3c2cSFrederic Weisbecker /* 41624f1e32cSFrederic Weisbecker * Release the user breakpoints used by ptrace 41724f1e32cSFrederic Weisbecker */ 41824f1e32cSFrederic Weisbecker void flush_ptrace_hw_breakpoint(struct task_struct *tsk) 4190067f129SK.Prasad { 4200067f129SK.Prasad int i; 42124f1e32cSFrederic Weisbecker struct thread_struct *t = &tsk->thread; 4220067f129SK.Prasad 42324f1e32cSFrederic Weisbecker for (i = 0; i < HBP_NUM; i++) { 42424f1e32cSFrederic Weisbecker unregister_hw_breakpoint(t->ptrace_bps[i]); 42524f1e32cSFrederic Weisbecker t->ptrace_bps[i] = NULL; 4260067f129SK.Prasad } 42724f1e32cSFrederic Weisbecker } 42824f1e32cSFrederic Weisbecker 42924f1e32cSFrederic Weisbecker void hw_breakpoint_restore(void) 43024f1e32cSFrederic Weisbecker { 43124f1e32cSFrederic Weisbecker set_debugreg(__get_cpu_var(cpu_debugreg[0]), 0); 43224f1e32cSFrederic Weisbecker set_debugreg(__get_cpu_var(cpu_debugreg[1]), 1); 43324f1e32cSFrederic Weisbecker set_debugreg(__get_cpu_var(cpu_debugreg[2]), 2); 43424f1e32cSFrederic Weisbecker set_debugreg(__get_cpu_var(cpu_debugreg[3]), 3); 43524f1e32cSFrederic Weisbecker set_debugreg(current->thread.debugreg6, 6); 43624f1e32cSFrederic Weisbecker set_debugreg(__get_cpu_var(dr7), 7); 43724f1e32cSFrederic Weisbecker } 43824f1e32cSFrederic Weisbecker EXPORT_SYMBOL_GPL(hw_breakpoint_restore); 4390067f129SK.Prasad 4400067f129SK.Prasad /* 4410067f129SK.Prasad * Handle debug exception notifications. 4420067f129SK.Prasad * 4430067f129SK.Prasad * Return value is either NOTIFY_STOP or NOTIFY_DONE as explained below. 4440067f129SK.Prasad * 4450067f129SK.Prasad * NOTIFY_DONE returned if one of the following conditions is true. 4460067f129SK.Prasad * i) When the causative address is from user-space and the exception 4470067f129SK.Prasad * is a valid one, i.e. not triggered as a result of lazy debug register 4480067f129SK.Prasad * switching 4490067f129SK.Prasad * ii) When there are more bits than trap<n> set in DR6 register (such 4500067f129SK.Prasad * as BD, BS or BT) indicating that more than one debug condition is 4510067f129SK.Prasad * met and requires some more action in do_debug(). 4520067f129SK.Prasad * 4530067f129SK.Prasad * NOTIFY_STOP returned for all other cases 4540067f129SK.Prasad * 4550067f129SK.Prasad */ 4564555835bSJaswinder Singh Rajput static int __kprobes hw_breakpoint_handler(struct die_args *args) 4570067f129SK.Prasad { 4580067f129SK.Prasad int i, cpu, rc = NOTIFY_STOP; 45924f1e32cSFrederic Weisbecker struct perf_event *bp; 46062edab90SK.Prasad unsigned long dr7, dr6; 46162edab90SK.Prasad unsigned long *dr6_p; 46262edab90SK.Prasad 46362edab90SK.Prasad /* The DR6 value is pointed by args->err */ 46462edab90SK.Prasad dr6_p = (unsigned long *)ERR_PTR(args->err); 46562edab90SK.Prasad dr6 = *dr6_p; 4660067f129SK.Prasad 4670067f129SK.Prasad /* Do an early return if no trap bits are set in DR6 */ 4680067f129SK.Prasad if ((dr6 & DR_TRAP_BITS) == 0) 4690067f129SK.Prasad return NOTIFY_DONE; 4700067f129SK.Prasad 4710067f129SK.Prasad get_debugreg(dr7, 7); 4720067f129SK.Prasad /* Disable breakpoints during exception handling */ 4730067f129SK.Prasad set_debugreg(0UL, 7); 4740067f129SK.Prasad /* 4750067f129SK.Prasad * Assert that local interrupts are disabled 4760067f129SK.Prasad * Reset the DRn bits in the virtualized register value. 4770067f129SK.Prasad * The ptrace trigger routine will add in whatever is needed. 4780067f129SK.Prasad */ 4790067f129SK.Prasad current->thread.debugreg6 &= ~DR_TRAP_BITS; 4800067f129SK.Prasad cpu = get_cpu(); 4810067f129SK.Prasad 4820067f129SK.Prasad /* Handle all the breakpoints that were triggered */ 4830067f129SK.Prasad for (i = 0; i < HBP_NUM; ++i) { 4840067f129SK.Prasad if (likely(!(dr6 & (DR_TRAP0 << i)))) 4850067f129SK.Prasad continue; 48624f1e32cSFrederic Weisbecker 4870067f129SK.Prasad /* 48824f1e32cSFrederic Weisbecker * The counter may be concurrently released but that can only 48924f1e32cSFrederic Weisbecker * occur from a call_rcu() path. We can then safely fetch 49024f1e32cSFrederic Weisbecker * the breakpoint, use its callback, touch its counter 49124f1e32cSFrederic Weisbecker * while we are in an rcu_read_lock() path. 4920067f129SK.Prasad */ 49324f1e32cSFrederic Weisbecker rcu_read_lock(); 49424f1e32cSFrederic Weisbecker 49524f1e32cSFrederic Weisbecker bp = per_cpu(bp_per_reg[i], cpu); 4960067f129SK.Prasad if (bp) 4970067f129SK.Prasad rc = NOTIFY_DONE; 4980067f129SK.Prasad /* 49962edab90SK.Prasad * Reset the 'i'th TRAP bit in dr6 to denote completion of 50062edab90SK.Prasad * exception handling 50162edab90SK.Prasad */ 50262edab90SK.Prasad (*dr6_p) &= ~(DR_TRAP0 << i); 50362edab90SK.Prasad /* 5040067f129SK.Prasad * bp can be NULL due to lazy debug register switching 50524f1e32cSFrederic Weisbecker * or due to concurrent perf counter removing. 5060067f129SK.Prasad */ 50724f1e32cSFrederic Weisbecker if (!bp) { 50824f1e32cSFrederic Weisbecker rcu_read_unlock(); 50924f1e32cSFrederic Weisbecker break; 51024f1e32cSFrederic Weisbecker } 5110067f129SK.Prasad 51224f1e32cSFrederic Weisbecker (bp->callback)(bp, args->regs); 51324f1e32cSFrederic Weisbecker 51424f1e32cSFrederic Weisbecker rcu_read_unlock(); 5150067f129SK.Prasad } 5160067f129SK.Prasad if (dr6 & (~DR_TRAP_BITS)) 5170067f129SK.Prasad rc = NOTIFY_DONE; 5180067f129SK.Prasad 5190067f129SK.Prasad set_debugreg(dr7, 7); 520eadb8a09SIngo Molnar put_cpu(); 52124f1e32cSFrederic Weisbecker 5220067f129SK.Prasad return rc; 5230067f129SK.Prasad } 5240067f129SK.Prasad 5250067f129SK.Prasad /* 5260067f129SK.Prasad * Handle debug exception notifications. 5270067f129SK.Prasad */ 5280067f129SK.Prasad int __kprobes hw_breakpoint_exceptions_notify( 5290067f129SK.Prasad struct notifier_block *unused, unsigned long val, void *data) 5300067f129SK.Prasad { 5310067f129SK.Prasad if (val != DIE_DEBUG) 5320067f129SK.Prasad return NOTIFY_DONE; 5330067f129SK.Prasad 5340067f129SK.Prasad return hw_breakpoint_handler(data); 5350067f129SK.Prasad } 53624f1e32cSFrederic Weisbecker 53724f1e32cSFrederic Weisbecker void hw_breakpoint_pmu_read(struct perf_event *bp) 53824f1e32cSFrederic Weisbecker { 53924f1e32cSFrederic Weisbecker /* TODO */ 54024f1e32cSFrederic Weisbecker } 54124f1e32cSFrederic Weisbecker 54224f1e32cSFrederic Weisbecker void hw_breakpoint_pmu_unthrottle(struct perf_event *bp) 54324f1e32cSFrederic Weisbecker { 54424f1e32cSFrederic Weisbecker /* TODO */ 54524f1e32cSFrederic Weisbecker } 546