11a59d1b8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later 20067f129SK.Prasad /* 30067f129SK.Prasad * 40067f129SK.Prasad * Copyright (C) 2007 Alan Stern 50067f129SK.Prasad * Copyright (C) 2009 IBM Corporation 624f1e32cSFrederic Weisbecker * Copyright (C) 2009 Frederic Weisbecker <fweisbec@gmail.com> 7ba6909b7SK.Prasad * 8ba6909b7SK.Prasad * Authors: Alan Stern <stern@rowland.harvard.edu> 9ba6909b7SK.Prasad * K.Prasad <prasad@linux.vnet.ibm.com> 10ba6909b7SK.Prasad * Frederic Weisbecker <fweisbec@gmail.com> 110067f129SK.Prasad */ 120067f129SK.Prasad 130067f129SK.Prasad /* 140067f129SK.Prasad * HW_breakpoint: a unified kernel/user-space hardware breakpoint facility, 150067f129SK.Prasad * using the CPU's debug registers. 160067f129SK.Prasad */ 170067f129SK.Prasad 1824f1e32cSFrederic Weisbecker #include <linux/perf_event.h> 1924f1e32cSFrederic Weisbecker #include <linux/hw_breakpoint.h> 200067f129SK.Prasad #include <linux/irqflags.h> 210067f129SK.Prasad #include <linux/notifier.h> 220067f129SK.Prasad #include <linux/kallsyms.h> 23e5779e8eSAndy Lutomirski #include <linux/kprobes.h> 240067f129SK.Prasad #include <linux/percpu.h> 250067f129SK.Prasad #include <linux/kdebug.h> 260067f129SK.Prasad #include <linux/kernel.h> 27186f4360SPaul Gortmaker #include <linux/export.h> 280067f129SK.Prasad #include <linux/sched.h> 290067f129SK.Prasad #include <linux/smp.h> 300067f129SK.Prasad 310067f129SK.Prasad #include <asm/hw_breakpoint.h> 320067f129SK.Prasad #include <asm/processor.h> 330067f129SK.Prasad #include <asm/debugreg.h> 34186f4360SPaul Gortmaker #include <asm/user.h> 3597417cb9SLai Jiangshan #include <asm/desc.h> 360067f129SK.Prasad 3724f1e32cSFrederic Weisbecker /* Per cpu debug control register value */ 3828b4e0d8STejun Heo DEFINE_PER_CPU(unsigned long, cpu_dr7); 3928b4e0d8STejun Heo EXPORT_PER_CPU_SYMBOL(cpu_dr7); 4024f1e32cSFrederic Weisbecker 4124f1e32cSFrederic Weisbecker /* Per cpu debug address registers values */ 4224f1e32cSFrederic Weisbecker static DEFINE_PER_CPU(unsigned long, cpu_debugreg[HBP_NUM]); 430067f129SK.Prasad 440067f129SK.Prasad /* 4524f1e32cSFrederic Weisbecker * Stores the breakpoints currently in use on each breakpoint address 4624f1e32cSFrederic Weisbecker * register for each cpus 470067f129SK.Prasad */ 4824f1e32cSFrederic Weisbecker static DEFINE_PER_CPU(struct perf_event *, bp_per_reg[HBP_NUM]); 490067f129SK.Prasad 500067f129SK.Prasad 512c31b795SFrederic Weisbecker static inline unsigned long 522c31b795SFrederic Weisbecker __encode_dr7(int drnum, unsigned int len, unsigned int type) 532c31b795SFrederic Weisbecker { 542c31b795SFrederic Weisbecker unsigned long bp_info; 552c31b795SFrederic Weisbecker 562c31b795SFrederic Weisbecker bp_info = (len | type) & 0xf; 572c31b795SFrederic Weisbecker bp_info <<= (DR_CONTROL_SHIFT + drnum * DR_CONTROL_SIZE); 582c31b795SFrederic Weisbecker bp_info |= (DR_GLOBAL_ENABLE << (drnum * DR_ENABLE_SIZE)); 592c31b795SFrederic Weisbecker 602c31b795SFrederic Weisbecker return bp_info; 612c31b795SFrederic Weisbecker } 622c31b795SFrederic Weisbecker 630067f129SK.Prasad /* 640067f129SK.Prasad * Encode the length, type, Exact, and Enable bits for a particular breakpoint 650067f129SK.Prasad * as stored in debug register 7. 660067f129SK.Prasad */ 6724f1e32cSFrederic Weisbecker unsigned long encode_dr7(int drnum, unsigned int len, unsigned int type) 680067f129SK.Prasad { 692c31b795SFrederic Weisbecker return __encode_dr7(drnum, len, type) | DR_GLOBAL_SLOWDOWN; 700067f129SK.Prasad } 710067f129SK.Prasad 7224f1e32cSFrederic Weisbecker /* 7324f1e32cSFrederic Weisbecker * Decode the length and type bits for a particular breakpoint as 7424f1e32cSFrederic Weisbecker * stored in debug register 7. Return the "enabled" status. 750067f129SK.Prasad */ 7624f1e32cSFrederic Weisbecker int decode_dr7(unsigned long dr7, int bpnum, unsigned *len, unsigned *type) 7724f1e32cSFrederic Weisbecker { 7824f1e32cSFrederic Weisbecker int bp_info = dr7 >> (DR_CONTROL_SHIFT + bpnum * DR_CONTROL_SIZE); 7924f1e32cSFrederic Weisbecker 8024f1e32cSFrederic Weisbecker *len = (bp_info & 0xc) | 0x40; 8124f1e32cSFrederic Weisbecker *type = (bp_info & 0x3) | 0x80; 8224f1e32cSFrederic Weisbecker 8324f1e32cSFrederic Weisbecker return (dr7 >> (bpnum * DR_ENABLE_SIZE)) & 0x3; 840067f129SK.Prasad } 850067f129SK.Prasad 860067f129SK.Prasad /* 8724f1e32cSFrederic Weisbecker * Install a perf counter breakpoint. 8824f1e32cSFrederic Weisbecker * 8924f1e32cSFrederic Weisbecker * We seek a free debug address register and use it for this 9024f1e32cSFrederic Weisbecker * breakpoint. Eventually we enable it in the debug control register. 9124f1e32cSFrederic Weisbecker * 9224f1e32cSFrederic Weisbecker * Atomic: we hold the counter->ctx->lock and we only handle variables 9324f1e32cSFrederic Weisbecker * and registers local to this cpu. 940067f129SK.Prasad */ 9524f1e32cSFrederic Weisbecker int arch_install_hw_breakpoint(struct perf_event *bp) 960067f129SK.Prasad { 9724f1e32cSFrederic Weisbecker struct arch_hw_breakpoint *info = counter_arch_bp(bp); 9824f1e32cSFrederic Weisbecker unsigned long *dr7; 9924f1e32cSFrederic Weisbecker int i; 1000067f129SK.Prasad 10124f1e32cSFrederic Weisbecker for (i = 0; i < HBP_NUM; i++) { 10289cbc767SChristoph Lameter struct perf_event **slot = this_cpu_ptr(&bp_per_reg[i]); 10324f1e32cSFrederic Weisbecker 10424f1e32cSFrederic Weisbecker if (!*slot) { 10524f1e32cSFrederic Weisbecker *slot = bp; 1060067f129SK.Prasad break; 1070067f129SK.Prasad } 10824f1e32cSFrederic Weisbecker } 1090067f129SK.Prasad 11024f1e32cSFrederic Weisbecker if (WARN_ONCE(i == HBP_NUM, "Can't find any breakpoint slot")) 11124f1e32cSFrederic Weisbecker return -EBUSY; 11224f1e32cSFrederic Weisbecker 11324f1e32cSFrederic Weisbecker set_debugreg(info->address, i); 1140a3aee0dSTejun Heo __this_cpu_write(cpu_debugreg[i], info->address); 11524f1e32cSFrederic Weisbecker 11689cbc767SChristoph Lameter dr7 = this_cpu_ptr(&cpu_dr7); 11724f1e32cSFrederic Weisbecker *dr7 |= encode_dr7(i, info->len, info->type); 11824f1e32cSFrederic Weisbecker 11924f1e32cSFrederic Weisbecker set_debugreg(*dr7, 7); 120d6d55f0bSJacob Shin if (info->mask) 121d6d55f0bSJacob Shin set_dr_addr_mask(info->mask, i); 12224f1e32cSFrederic Weisbecker 12324f1e32cSFrederic Weisbecker return 0; 1240067f129SK.Prasad } 1250067f129SK.Prasad 1260067f129SK.Prasad /* 12724f1e32cSFrederic Weisbecker * Uninstall the breakpoint contained in the given counter. 12824f1e32cSFrederic Weisbecker * 12924f1e32cSFrederic Weisbecker * First we search the debug address register it uses and then we disable 13024f1e32cSFrederic Weisbecker * it. 13124f1e32cSFrederic Weisbecker * 13224f1e32cSFrederic Weisbecker * Atomic: we hold the counter->ctx->lock and we only handle variables 13324f1e32cSFrederic Weisbecker * and registers local to this cpu. 1340067f129SK.Prasad */ 13524f1e32cSFrederic Weisbecker void arch_uninstall_hw_breakpoint(struct perf_event *bp) 1360067f129SK.Prasad { 13724f1e32cSFrederic Weisbecker struct arch_hw_breakpoint *info = counter_arch_bp(bp); 13824f1e32cSFrederic Weisbecker unsigned long *dr7; 13924f1e32cSFrederic Weisbecker int i; 1400067f129SK.Prasad 14124f1e32cSFrederic Weisbecker for (i = 0; i < HBP_NUM; i++) { 14289cbc767SChristoph Lameter struct perf_event **slot = this_cpu_ptr(&bp_per_reg[i]); 14324f1e32cSFrederic Weisbecker 14424f1e32cSFrederic Weisbecker if (*slot == bp) { 14524f1e32cSFrederic Weisbecker *slot = NULL; 14624f1e32cSFrederic Weisbecker break; 14724f1e32cSFrederic Weisbecker } 14824f1e32cSFrederic Weisbecker } 14924f1e32cSFrederic Weisbecker 15024f1e32cSFrederic Weisbecker if (WARN_ONCE(i == HBP_NUM, "Can't find any breakpoint slot")) 15124f1e32cSFrederic Weisbecker return; 15224f1e32cSFrederic Weisbecker 15389cbc767SChristoph Lameter dr7 = this_cpu_ptr(&cpu_dr7); 1542c31b795SFrederic Weisbecker *dr7 &= ~__encode_dr7(i, info->len, info->type); 15524f1e32cSFrederic Weisbecker 15624f1e32cSFrederic Weisbecker set_debugreg(*dr7, 7); 157d6d55f0bSJacob Shin if (info->mask) 158d6d55f0bSJacob Shin set_dr_addr_mask(0, i); 1590067f129SK.Prasad } 1600067f129SK.Prasad 1618e983ff9SFrederic Weisbecker static int arch_bp_generic_len(int x86_len) 1620067f129SK.Prasad { 1638e983ff9SFrederic Weisbecker switch (x86_len) { 1648e983ff9SFrederic Weisbecker case X86_BREAKPOINT_LEN_1: 1658e983ff9SFrederic Weisbecker return HW_BREAKPOINT_LEN_1; 1668e983ff9SFrederic Weisbecker case X86_BREAKPOINT_LEN_2: 1678e983ff9SFrederic Weisbecker return HW_BREAKPOINT_LEN_2; 1688e983ff9SFrederic Weisbecker case X86_BREAKPOINT_LEN_4: 1698e983ff9SFrederic Weisbecker return HW_BREAKPOINT_LEN_4; 1708e983ff9SFrederic Weisbecker #ifdef CONFIG_X86_64 1718e983ff9SFrederic Weisbecker case X86_BREAKPOINT_LEN_8: 1728e983ff9SFrederic Weisbecker return HW_BREAKPOINT_LEN_8; 1738e983ff9SFrederic Weisbecker #endif 1748e983ff9SFrederic Weisbecker default: 1758e983ff9SFrederic Weisbecker return -EINVAL; 1768e983ff9SFrederic Weisbecker } 1770067f129SK.Prasad } 1780067f129SK.Prasad 17924f1e32cSFrederic Weisbecker int arch_bp_generic_fields(int x86_len, int x86_type, 18024f1e32cSFrederic Weisbecker int *gen_len, int *gen_type) 18124f1e32cSFrederic Weisbecker { 1828e983ff9SFrederic Weisbecker int len; 1838e983ff9SFrederic Weisbecker 18489e45aacSFrederic Weisbecker /* Type */ 18589e45aacSFrederic Weisbecker switch (x86_type) { 18689e45aacSFrederic Weisbecker case X86_BREAKPOINT_EXECUTE: 18789e45aacSFrederic Weisbecker if (x86_len != X86_BREAKPOINT_LEN_X) 18889e45aacSFrederic Weisbecker return -EINVAL; 18989e45aacSFrederic Weisbecker 19089e45aacSFrederic Weisbecker *gen_type = HW_BREAKPOINT_X; 19189e45aacSFrederic Weisbecker *gen_len = sizeof(long); 19289e45aacSFrederic Weisbecker return 0; 19389e45aacSFrederic Weisbecker case X86_BREAKPOINT_WRITE: 19489e45aacSFrederic Weisbecker *gen_type = HW_BREAKPOINT_W; 19589e45aacSFrederic Weisbecker break; 19689e45aacSFrederic Weisbecker case X86_BREAKPOINT_RW: 19789e45aacSFrederic Weisbecker *gen_type = HW_BREAKPOINT_W | HW_BREAKPOINT_R; 19889e45aacSFrederic Weisbecker break; 19989e45aacSFrederic Weisbecker default: 20089e45aacSFrederic Weisbecker return -EINVAL; 20189e45aacSFrederic Weisbecker } 20289e45aacSFrederic Weisbecker 20324f1e32cSFrederic Weisbecker /* Len */ 2048e983ff9SFrederic Weisbecker len = arch_bp_generic_len(x86_len); 2058e983ff9SFrederic Weisbecker if (len < 0) 20624f1e32cSFrederic Weisbecker return -EINVAL; 2078e983ff9SFrederic Weisbecker *gen_len = len; 20824f1e32cSFrederic Weisbecker 20924f1e32cSFrederic Weisbecker return 0; 21024f1e32cSFrederic Weisbecker } 21124f1e32cSFrederic Weisbecker 2128e983ff9SFrederic Weisbecker /* 2138e983ff9SFrederic Weisbecker * Check for virtual address in kernel space. 2148e983ff9SFrederic Weisbecker */ 2158e983ff9SFrederic Weisbecker int arch_check_bp_in_kernelspace(struct arch_hw_breakpoint *hw) 2168e983ff9SFrederic Weisbecker { 2178e983ff9SFrederic Weisbecker unsigned long va; 2188e983ff9SFrederic Weisbecker int len; 2198e983ff9SFrederic Weisbecker 2208e983ff9SFrederic Weisbecker va = hw->address; 2218e983ff9SFrederic Weisbecker len = arch_bp_generic_len(hw->len); 2228e983ff9SFrederic Weisbecker WARN_ON_ONCE(len < 0); 2238e983ff9SFrederic Weisbecker 2248e983ff9SFrederic Weisbecker /* 2258e983ff9SFrederic Weisbecker * We don't need to worry about va + len - 1 overflowing: 2268e983ff9SFrederic Weisbecker * we already require that va is aligned to a multiple of len. 2278e983ff9SFrederic Weisbecker */ 2288e983ff9SFrederic Weisbecker return (va >= TASK_SIZE_MAX) || ((va + len - 1) >= TASK_SIZE_MAX); 2298e983ff9SFrederic Weisbecker } 23024f1e32cSFrederic Weisbecker 23124ae0c91SAndy Lutomirski /* 232d390e6deSLai Jiangshan * Checks whether the range [addr, end], overlaps the area [base, base + size). 233d390e6deSLai Jiangshan */ 234d390e6deSLai Jiangshan static inline bool within_area(unsigned long addr, unsigned long end, 235d390e6deSLai Jiangshan unsigned long base, unsigned long size) 236d390e6deSLai Jiangshan { 237d390e6deSLai Jiangshan return end >= base && addr < (base + size); 238d390e6deSLai Jiangshan } 239d390e6deSLai Jiangshan 240d390e6deSLai Jiangshan /* 24197417cb9SLai Jiangshan * Checks whether the range from addr to end, inclusive, overlaps the fixed 24297417cb9SLai Jiangshan * mapped CPU entry area range or other ranges used for CPU entry. 24324ae0c91SAndy Lutomirski */ 24497417cb9SLai Jiangshan static inline bool within_cpu_entry(unsigned long addr, unsigned long end) 24524ae0c91SAndy Lutomirski { 24697417cb9SLai Jiangshan int cpu; 24797417cb9SLai Jiangshan 24897417cb9SLai Jiangshan /* CPU entry erea is always used for CPU entry */ 24997417cb9SLai Jiangshan if (within_area(addr, end, CPU_ENTRY_AREA_BASE, 25097417cb9SLai Jiangshan CPU_ENTRY_AREA_TOTAL_SIZE)) 25197417cb9SLai Jiangshan return true; 25297417cb9SLai Jiangshan 25397417cb9SLai Jiangshan for_each_possible_cpu(cpu) { 25497417cb9SLai Jiangshan /* The original rw GDT is being used after load_direct_gdt() */ 25597417cb9SLai Jiangshan if (within_area(addr, end, (unsigned long)get_cpu_gdt_rw(cpu), 25697417cb9SLai Jiangshan GDT_SIZE)) 25797417cb9SLai Jiangshan return true; 258f9fe0b89SLai Jiangshan 259f9fe0b89SLai Jiangshan /* 260f9fe0b89SLai Jiangshan * cpu_tss_rw is not directly referenced by hardware, but 261f9fe0b89SLai Jiangshan * cpu_tss_rw is also used in CPU entry code, 262f9fe0b89SLai Jiangshan */ 263f9fe0b89SLai Jiangshan if (within_area(addr, end, 264f9fe0b89SLai Jiangshan (unsigned long)&per_cpu(cpu_tss_rw, cpu), 265f9fe0b89SLai Jiangshan sizeof(struct tss_struct))) 266f9fe0b89SLai Jiangshan return true; 26797417cb9SLai Jiangshan } 26897417cb9SLai Jiangshan 26997417cb9SLai Jiangshan return false; 27024ae0c91SAndy Lutomirski } 27124ae0c91SAndy Lutomirski 272a0baf043SFrederic Weisbecker static int arch_build_bp_info(struct perf_event *bp, 273a0baf043SFrederic Weisbecker const struct perf_event_attr *attr, 274a0baf043SFrederic Weisbecker struct arch_hw_breakpoint *hw) 27524f1e32cSFrederic Weisbecker { 27624ae0c91SAndy Lutomirski unsigned long bp_end; 27724ae0c91SAndy Lutomirski 27824ae0c91SAndy Lutomirski bp_end = attr->bp_addr + attr->bp_len - 1; 27924ae0c91SAndy Lutomirski if (bp_end < attr->bp_addr) 28024ae0c91SAndy Lutomirski return -EINVAL; 28124ae0c91SAndy Lutomirski 28224ae0c91SAndy Lutomirski /* 28397417cb9SLai Jiangshan * Prevent any breakpoint of any type that overlaps the CPU 28497417cb9SLai Jiangshan * entry area and data. This protects the IST stacks and also 28524ae0c91SAndy Lutomirski * reduces the chance that we ever find out what happens if 28624ae0c91SAndy Lutomirski * there's a data breakpoint on the GDT, IDT, or TSS. 28724ae0c91SAndy Lutomirski */ 28897417cb9SLai Jiangshan if (within_cpu_entry(attr->bp_addr, bp_end)) 28924ae0c91SAndy Lutomirski return -EINVAL; 29024ae0c91SAndy Lutomirski 291a0baf043SFrederic Weisbecker hw->address = attr->bp_addr; 292a0baf043SFrederic Weisbecker hw->mask = 0; 29324f1e32cSFrederic Weisbecker 294f7809dafSFrederic Weisbecker /* Type */ 295a0baf043SFrederic Weisbecker switch (attr->bp_type) { 296f7809dafSFrederic Weisbecker case HW_BREAKPOINT_W: 297a0baf043SFrederic Weisbecker hw->type = X86_BREAKPOINT_WRITE; 298f7809dafSFrederic Weisbecker break; 299f7809dafSFrederic Weisbecker case HW_BREAKPOINT_W | HW_BREAKPOINT_R: 300a0baf043SFrederic Weisbecker hw->type = X86_BREAKPOINT_RW; 301f7809dafSFrederic Weisbecker break; 302f7809dafSFrederic Weisbecker case HW_BREAKPOINT_X: 303e5779e8eSAndy Lutomirski /* 304e5779e8eSAndy Lutomirski * We don't allow kernel breakpoints in places that are not 305e5779e8eSAndy Lutomirski * acceptable for kprobes. On non-kprobes kernels, we don't 306e5779e8eSAndy Lutomirski * allow kernel breakpoints at all. 307e5779e8eSAndy Lutomirski */ 308a0baf043SFrederic Weisbecker if (attr->bp_addr >= TASK_SIZE_MAX) { 309a0baf043SFrederic Weisbecker if (within_kprobe_blacklist(attr->bp_addr)) 310e5779e8eSAndy Lutomirski return -EINVAL; 311e5779e8eSAndy Lutomirski } 312e5779e8eSAndy Lutomirski 313a0baf043SFrederic Weisbecker hw->type = X86_BREAKPOINT_EXECUTE; 314f7809dafSFrederic Weisbecker /* 315f7809dafSFrederic Weisbecker * x86 inst breakpoints need to have a specific undefined len. 316f7809dafSFrederic Weisbecker * But we still need to check userspace is not trying to setup 317f7809dafSFrederic Weisbecker * an unsupported length, to get a range breakpoint for example. 318f7809dafSFrederic Weisbecker */ 319a0baf043SFrederic Weisbecker if (attr->bp_len == sizeof(long)) { 320a0baf043SFrederic Weisbecker hw->len = X86_BREAKPOINT_LEN_X; 321f7809dafSFrederic Weisbecker return 0; 322f7809dafSFrederic Weisbecker } 3236fcebf13SGustavo A. R. Silva /* fall through */ 324f7809dafSFrederic Weisbecker default: 325f7809dafSFrederic Weisbecker return -EINVAL; 326f7809dafSFrederic Weisbecker } 327f7809dafSFrederic Weisbecker 32824f1e32cSFrederic Weisbecker /* Len */ 329a0baf043SFrederic Weisbecker switch (attr->bp_len) { 33024f1e32cSFrederic Weisbecker case HW_BREAKPOINT_LEN_1: 331a0baf043SFrederic Weisbecker hw->len = X86_BREAKPOINT_LEN_1; 33224f1e32cSFrederic Weisbecker break; 33324f1e32cSFrederic Weisbecker case HW_BREAKPOINT_LEN_2: 334a0baf043SFrederic Weisbecker hw->len = X86_BREAKPOINT_LEN_2; 33524f1e32cSFrederic Weisbecker break; 33624f1e32cSFrederic Weisbecker case HW_BREAKPOINT_LEN_4: 337a0baf043SFrederic Weisbecker hw->len = X86_BREAKPOINT_LEN_4; 33824f1e32cSFrederic Weisbecker break; 33924f1e32cSFrederic Weisbecker #ifdef CONFIG_X86_64 34024f1e32cSFrederic Weisbecker case HW_BREAKPOINT_LEN_8: 341a0baf043SFrederic Weisbecker hw->len = X86_BREAKPOINT_LEN_8; 34224f1e32cSFrederic Weisbecker break; 34324f1e32cSFrederic Weisbecker #endif 34424f1e32cSFrederic Weisbecker default: 345ab513927SAndy Lutomirski /* AMD range breakpoint */ 346a0baf043SFrederic Weisbecker if (!is_power_of_2(attr->bp_len)) 34724f1e32cSFrederic Weisbecker return -EINVAL; 348a0baf043SFrederic Weisbecker if (attr->bp_addr & (attr->bp_len - 1)) 349ab513927SAndy Lutomirski return -EINVAL; 350362f924bSBorislav Petkov 351362f924bSBorislav Petkov if (!boot_cpu_has(X86_FEATURE_BPEXT)) 352362f924bSBorislav Petkov return -EOPNOTSUPP; 353362f924bSBorislav Petkov 354ab513927SAndy Lutomirski /* 355ab513927SAndy Lutomirski * It's impossible to use a range breakpoint to fake out 356ab513927SAndy Lutomirski * user vs kernel detection because bp_len - 1 can't 357ab513927SAndy Lutomirski * have the high bit set. If we ever allow range instruction 358ab513927SAndy Lutomirski * breakpoints, then we'll have to check for kprobe-blacklisted 359ab513927SAndy Lutomirski * addresses anywhere in the range. 360ab513927SAndy Lutomirski */ 361a0baf043SFrederic Weisbecker hw->mask = attr->bp_len - 1; 362a0baf043SFrederic Weisbecker hw->len = X86_BREAKPOINT_LEN_1; 36324f1e32cSFrederic Weisbecker } 36424f1e32cSFrederic Weisbecker 36524f1e32cSFrederic Weisbecker return 0; 36624f1e32cSFrederic Weisbecker } 367d6d55f0bSJacob Shin 3680067f129SK.Prasad /* 3690067f129SK.Prasad * Validate the arch-specific HW Breakpoint register settings 3700067f129SK.Prasad */ 371a0baf043SFrederic Weisbecker int hw_breakpoint_arch_parse(struct perf_event *bp, 372a0baf043SFrederic Weisbecker const struct perf_event_attr *attr, 373a0baf043SFrederic Weisbecker struct arch_hw_breakpoint *hw) 3740067f129SK.Prasad { 3750067f129SK.Prasad unsigned int align; 37624f1e32cSFrederic Weisbecker int ret; 3770067f129SK.Prasad 37824f1e32cSFrederic Weisbecker 379a0baf043SFrederic Weisbecker ret = arch_build_bp_info(bp, attr, hw); 38024f1e32cSFrederic Weisbecker if (ret) 38124f1e32cSFrederic Weisbecker return ret; 38224f1e32cSFrederic Weisbecker 383a0baf043SFrederic Weisbecker switch (hw->len) { 38424f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_1: 3850067f129SK.Prasad align = 0; 386a0baf043SFrederic Weisbecker if (hw->mask) 387a0baf043SFrederic Weisbecker align = hw->mask; 3880067f129SK.Prasad break; 38924f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_2: 3900067f129SK.Prasad align = 1; 3910067f129SK.Prasad break; 39224f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_4: 3930067f129SK.Prasad align = 3; 3940067f129SK.Prasad break; 3950067f129SK.Prasad #ifdef CONFIG_X86_64 39624f1e32cSFrederic Weisbecker case X86_BREAKPOINT_LEN_8: 3970067f129SK.Prasad align = 7; 3980067f129SK.Prasad break; 3990067f129SK.Prasad #endif 4000067f129SK.Prasad default: 401d6d55f0bSJacob Shin WARN_ON_ONCE(1); 402e898e69dSNathan Chancellor return -EINVAL; 4030067f129SK.Prasad } 4040067f129SK.Prasad 40584d71092SFrederic Weisbecker /* 4060067f129SK.Prasad * Check that the low-order bits of the address are appropriate 4070067f129SK.Prasad * for the alignment implied by len. 4080067f129SK.Prasad */ 409a0baf043SFrederic Weisbecker if (hw->address & align) 4100067f129SK.Prasad return -EINVAL; 4110067f129SK.Prasad 4120067f129SK.Prasad return 0; 4130067f129SK.Prasad } 4140067f129SK.Prasad 41524f1e32cSFrederic Weisbecker /* 4169f6b3c2cSFrederic Weisbecker * Dump the debug register contents to the user. 4179f6b3c2cSFrederic Weisbecker * We can't dump our per cpu values because it 4189f6b3c2cSFrederic Weisbecker * may contain cpu wide breakpoint, something that 4199f6b3c2cSFrederic Weisbecker * doesn't belong to the current task. 4209f6b3c2cSFrederic Weisbecker * 4219f6b3c2cSFrederic Weisbecker * TODO: include non-ptrace user breakpoints (perf) 4229f6b3c2cSFrederic Weisbecker */ 4239f6b3c2cSFrederic Weisbecker void aout_dump_debugregs(struct user *dump) 4249f6b3c2cSFrederic Weisbecker { 4259f6b3c2cSFrederic Weisbecker int i; 4269f6b3c2cSFrederic Weisbecker int dr7 = 0; 4279f6b3c2cSFrederic Weisbecker struct perf_event *bp; 4289f6b3c2cSFrederic Weisbecker struct arch_hw_breakpoint *info; 4299f6b3c2cSFrederic Weisbecker struct thread_struct *thread = ¤t->thread; 4309f6b3c2cSFrederic Weisbecker 4319f6b3c2cSFrederic Weisbecker for (i = 0; i < HBP_NUM; i++) { 4329f6b3c2cSFrederic Weisbecker bp = thread->ptrace_bps[i]; 4339f6b3c2cSFrederic Weisbecker 4349f6b3c2cSFrederic Weisbecker if (bp && !bp->attr.disabled) { 4359f6b3c2cSFrederic Weisbecker dump->u_debugreg[i] = bp->attr.bp_addr; 4369f6b3c2cSFrederic Weisbecker info = counter_arch_bp(bp); 4379f6b3c2cSFrederic Weisbecker dr7 |= encode_dr7(i, info->len, info->type); 4389f6b3c2cSFrederic Weisbecker } else { 4399f6b3c2cSFrederic Weisbecker dump->u_debugreg[i] = 0; 4409f6b3c2cSFrederic Weisbecker } 4419f6b3c2cSFrederic Weisbecker } 4429f6b3c2cSFrederic Weisbecker 4439f6b3c2cSFrederic Weisbecker dump->u_debugreg[4] = 0; 4449f6b3c2cSFrederic Weisbecker dump->u_debugreg[5] = 0; 4459f6b3c2cSFrederic Weisbecker dump->u_debugreg[6] = current->thread.debugreg6; 4469f6b3c2cSFrederic Weisbecker 4479f6b3c2cSFrederic Weisbecker dump->u_debugreg[7] = dr7; 4489f6b3c2cSFrederic Weisbecker } 44968efa37dSIngo Molnar EXPORT_SYMBOL_GPL(aout_dump_debugregs); 4509f6b3c2cSFrederic Weisbecker 4519f6b3c2cSFrederic Weisbecker /* 45224f1e32cSFrederic Weisbecker * Release the user breakpoints used by ptrace 45324f1e32cSFrederic Weisbecker */ 45424f1e32cSFrederic Weisbecker void flush_ptrace_hw_breakpoint(struct task_struct *tsk) 4550067f129SK.Prasad { 4560067f129SK.Prasad int i; 45724f1e32cSFrederic Weisbecker struct thread_struct *t = &tsk->thread; 4580067f129SK.Prasad 45924f1e32cSFrederic Weisbecker for (i = 0; i < HBP_NUM; i++) { 46024f1e32cSFrederic Weisbecker unregister_hw_breakpoint(t->ptrace_bps[i]); 46124f1e32cSFrederic Weisbecker t->ptrace_bps[i] = NULL; 4620067f129SK.Prasad } 463f7da04c9SOleg Nesterov 464f7da04c9SOleg Nesterov t->debugreg6 = 0; 465f7da04c9SOleg Nesterov t->ptrace_dr7 = 0; 46624f1e32cSFrederic Weisbecker } 46724f1e32cSFrederic Weisbecker 46824f1e32cSFrederic Weisbecker void hw_breakpoint_restore(void) 46924f1e32cSFrederic Weisbecker { 4700a3aee0dSTejun Heo set_debugreg(__this_cpu_read(cpu_debugreg[0]), 0); 4710a3aee0dSTejun Heo set_debugreg(__this_cpu_read(cpu_debugreg[1]), 1); 4720a3aee0dSTejun Heo set_debugreg(__this_cpu_read(cpu_debugreg[2]), 2); 4730a3aee0dSTejun Heo set_debugreg(__this_cpu_read(cpu_debugreg[3]), 3); 47424f1e32cSFrederic Weisbecker set_debugreg(current->thread.debugreg6, 6); 4750a3aee0dSTejun Heo set_debugreg(__this_cpu_read(cpu_dr7), 7); 47624f1e32cSFrederic Weisbecker } 47724f1e32cSFrederic Weisbecker EXPORT_SYMBOL_GPL(hw_breakpoint_restore); 4780067f129SK.Prasad 4790067f129SK.Prasad /* 4800067f129SK.Prasad * Handle debug exception notifications. 4810067f129SK.Prasad * 4820067f129SK.Prasad * Return value is either NOTIFY_STOP or NOTIFY_DONE as explained below. 4830067f129SK.Prasad * 4840067f129SK.Prasad * NOTIFY_DONE returned if one of the following conditions is true. 4850067f129SK.Prasad * i) When the causative address is from user-space and the exception 4860067f129SK.Prasad * is a valid one, i.e. not triggered as a result of lazy debug register 4870067f129SK.Prasad * switching 4880067f129SK.Prasad * ii) When there are more bits than trap<n> set in DR6 register (such 4890067f129SK.Prasad * as BD, BS or BT) indicating that more than one debug condition is 4900067f129SK.Prasad * met and requires some more action in do_debug(). 4910067f129SK.Prasad * 4920067f129SK.Prasad * NOTIFY_STOP returned for all other cases 4930067f129SK.Prasad * 4940067f129SK.Prasad */ 4959c54b616SMasami Hiramatsu static int hw_breakpoint_handler(struct die_args *args) 4960067f129SK.Prasad { 4970067f129SK.Prasad int i, cpu, rc = NOTIFY_STOP; 49824f1e32cSFrederic Weisbecker struct perf_event *bp; 4999f58fddeSPeter Zijlstra unsigned long dr6; 50062edab90SK.Prasad unsigned long *dr6_p; 50162edab90SK.Prasad 50262edab90SK.Prasad /* The DR6 value is pointed by args->err */ 50362edab90SK.Prasad dr6_p = (unsigned long *)ERR_PTR(args->err); 50462edab90SK.Prasad dr6 = *dr6_p; 5050067f129SK.Prasad 5066c0aca28SFrederic Weisbecker /* If it's a single step, TRAP bits are random */ 5076c0aca28SFrederic Weisbecker if (dr6 & DR_STEP) 5086c0aca28SFrederic Weisbecker return NOTIFY_DONE; 5096c0aca28SFrederic Weisbecker 5100067f129SK.Prasad /* Do an early return if no trap bits are set in DR6 */ 5110067f129SK.Prasad if ((dr6 & DR_TRAP_BITS) == 0) 5120067f129SK.Prasad return NOTIFY_DONE; 5130067f129SK.Prasad 5140067f129SK.Prasad /* 5150067f129SK.Prasad * Assert that local interrupts are disabled 5160067f129SK.Prasad * Reset the DRn bits in the virtualized register value. 5170067f129SK.Prasad * The ptrace trigger routine will add in whatever is needed. 5180067f129SK.Prasad */ 5190067f129SK.Prasad current->thread.debugreg6 &= ~DR_TRAP_BITS; 5200067f129SK.Prasad cpu = get_cpu(); 5210067f129SK.Prasad 5220067f129SK.Prasad /* Handle all the breakpoints that were triggered */ 5230067f129SK.Prasad for (i = 0; i < HBP_NUM; ++i) { 5240067f129SK.Prasad if (likely(!(dr6 & (DR_TRAP0 << i)))) 5250067f129SK.Prasad continue; 52624f1e32cSFrederic Weisbecker 5270067f129SK.Prasad /* 52824f1e32cSFrederic Weisbecker * The counter may be concurrently released but that can only 52924f1e32cSFrederic Weisbecker * occur from a call_rcu() path. We can then safely fetch 53024f1e32cSFrederic Weisbecker * the breakpoint, use its callback, touch its counter 53124f1e32cSFrederic Weisbecker * while we are in an rcu_read_lock() path. 5320067f129SK.Prasad */ 53324f1e32cSFrederic Weisbecker rcu_read_lock(); 53424f1e32cSFrederic Weisbecker 53524f1e32cSFrederic Weisbecker bp = per_cpu(bp_per_reg[i], cpu); 5360067f129SK.Prasad /* 53762edab90SK.Prasad * Reset the 'i'th TRAP bit in dr6 to denote completion of 53862edab90SK.Prasad * exception handling 53962edab90SK.Prasad */ 54062edab90SK.Prasad (*dr6_p) &= ~(DR_TRAP0 << i); 54162edab90SK.Prasad /* 5420067f129SK.Prasad * bp can be NULL due to lazy debug register switching 54324f1e32cSFrederic Weisbecker * or due to concurrent perf counter removing. 5440067f129SK.Prasad */ 54524f1e32cSFrederic Weisbecker if (!bp) { 54624f1e32cSFrederic Weisbecker rcu_read_unlock(); 54724f1e32cSFrederic Weisbecker break; 54824f1e32cSFrederic Weisbecker } 5490067f129SK.Prasad 550b326e956SFrederic Weisbecker perf_bp_event(bp, args->regs); 55124f1e32cSFrederic Weisbecker 5520c4519e8SFrederic Weisbecker /* 5530c4519e8SFrederic Weisbecker * Set up resume flag to avoid breakpoint recursion when 5540c4519e8SFrederic Weisbecker * returning back to origin. 5550c4519e8SFrederic Weisbecker */ 5560c4519e8SFrederic Weisbecker if (bp->hw.info.type == X86_BREAKPOINT_EXECUTE) 5570c4519e8SFrederic Weisbecker args->regs->flags |= X86_EFLAGS_RF; 5580c4519e8SFrederic Weisbecker 55924f1e32cSFrederic Weisbecker rcu_read_unlock(); 5600067f129SK.Prasad } 561e0e53db6SK.Prasad /* 562e0e53db6SK.Prasad * Further processing in do_debug() is needed for a) user-space 563e0e53db6SK.Prasad * breakpoints (to generate signals) and b) when the system has 564e0e53db6SK.Prasad * taken exception due to multiple causes 565e0e53db6SK.Prasad */ 566e0e53db6SK.Prasad if ((current->thread.debugreg6 & DR_TRAP_BITS) || 567e0e53db6SK.Prasad (dr6 & (~DR_TRAP_BITS))) 5680067f129SK.Prasad rc = NOTIFY_DONE; 5690067f129SK.Prasad 570eadb8a09SIngo Molnar put_cpu(); 57124f1e32cSFrederic Weisbecker 5720067f129SK.Prasad return rc; 5730067f129SK.Prasad } 5740067f129SK.Prasad 5750067f129SK.Prasad /* 5760067f129SK.Prasad * Handle debug exception notifications. 5770067f129SK.Prasad */ 5789c54b616SMasami Hiramatsu int hw_breakpoint_exceptions_notify( 5790067f129SK.Prasad struct notifier_block *unused, unsigned long val, void *data) 5800067f129SK.Prasad { 5810067f129SK.Prasad if (val != DIE_DEBUG) 5820067f129SK.Prasad return NOTIFY_DONE; 5830067f129SK.Prasad 5840067f129SK.Prasad return hw_breakpoint_handler(data); 5850067f129SK.Prasad } 58624f1e32cSFrederic Weisbecker 58724f1e32cSFrederic Weisbecker void hw_breakpoint_pmu_read(struct perf_event *bp) 58824f1e32cSFrederic Weisbecker { 58924f1e32cSFrederic Weisbecker /* TODO */ 59024f1e32cSFrederic Weisbecker } 591