Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : *
4 : : * Copyright (C) 2007 Alan Stern
5 : : * Copyright (C) 2009 IBM Corporation
6 : : * Copyright (C) 2009 Frederic Weisbecker <fweisbec@gmail.com>
7 : : *
8 : : * Authors: Alan Stern <stern@rowland.harvard.edu>
9 : : * K.Prasad <prasad@linux.vnet.ibm.com>
10 : : * Frederic Weisbecker <fweisbec@gmail.com>
11 : : */
12 : :
13 : : /*
14 : : * HW_breakpoint: a unified kernel/user-space hardware breakpoint facility,
15 : : * using the CPU's debug registers.
16 : : */
17 : :
18 : : #include <linux/perf_event.h>
19 : : #include <linux/hw_breakpoint.h>
20 : : #include <linux/irqflags.h>
21 : : #include <linux/notifier.h>
22 : : #include <linux/kallsyms.h>
23 : : #include <linux/kprobes.h>
24 : : #include <linux/percpu.h>
25 : : #include <linux/kdebug.h>
26 : : #include <linux/kernel.h>
27 : : #include <linux/export.h>
28 : : #include <linux/sched.h>
29 : : #include <linux/smp.h>
30 : :
31 : : #include <asm/hw_breakpoint.h>
32 : : #include <asm/processor.h>
33 : : #include <asm/debugreg.h>
34 : : #include <asm/user.h>
35 : :
36 : : /* Per cpu debug control register value */
37 : : DEFINE_PER_CPU(unsigned long, cpu_dr7);
38 : : EXPORT_PER_CPU_SYMBOL(cpu_dr7);
39 : :
40 : : /* Per cpu debug address registers values */
41 : : static DEFINE_PER_CPU(unsigned long, cpu_debugreg[HBP_NUM]);
42 : :
43 : : /*
44 : : * Stores the breakpoints currently in use on each breakpoint address
45 : : * register for each cpus
46 : : */
47 : : static DEFINE_PER_CPU(struct perf_event *, bp_per_reg[HBP_NUM]);
48 : :
49 : :
50 : : static inline unsigned long
51 : 0 : __encode_dr7(int drnum, unsigned int len, unsigned int type)
52 : : {
53 : 0 : unsigned long bp_info;
54 : :
55 : 0 : bp_info = (len | type) & 0xf;
56 : 0 : bp_info <<= (DR_CONTROL_SHIFT + drnum * DR_CONTROL_SIZE);
57 : 0 : bp_info |= (DR_GLOBAL_ENABLE << (drnum * DR_ENABLE_SIZE));
58 : :
59 : 0 : return bp_info;
60 : : }
61 : :
62 : : /*
63 : : * Encode the length, type, Exact, and Enable bits for a particular breakpoint
64 : : * as stored in debug register 7.
65 : : */
66 : 0 : unsigned long encode_dr7(int drnum, unsigned int len, unsigned int type)
67 : : {
68 : 0 : return __encode_dr7(drnum, len, type) | DR_GLOBAL_SLOWDOWN;
69 : : }
70 : :
71 : : /*
72 : : * Decode the length and type bits for a particular breakpoint as
73 : : * stored in debug register 7. Return the "enabled" status.
74 : : */
75 : 0 : int decode_dr7(unsigned long dr7, int bpnum, unsigned *len, unsigned *type)
76 : : {
77 : 0 : int bp_info = dr7 >> (DR_CONTROL_SHIFT + bpnum * DR_CONTROL_SIZE);
78 : :
79 : 0 : *len = (bp_info & 0xc) | 0x40;
80 : 0 : *type = (bp_info & 0x3) | 0x80;
81 : :
82 : 0 : return (dr7 >> (bpnum * DR_ENABLE_SIZE)) & 0x3;
83 : : }
84 : :
85 : : /*
86 : : * Install a perf counter breakpoint.
87 : : *
88 : : * We seek a free debug address register and use it for this
89 : : * breakpoint. Eventually we enable it in the debug control register.
90 : : *
91 : : * Atomic: we hold the counter->ctx->lock and we only handle variables
92 : : * and registers local to this cpu.
93 : : */
94 : 0 : int arch_install_hw_breakpoint(struct perf_event *bp)
95 : : {
96 : 0 : struct arch_hw_breakpoint *info = counter_arch_bp(bp);
97 : 0 : unsigned long *dr7;
98 : 0 : int i;
99 : :
100 [ # # ]: 0 : for (i = 0; i < HBP_NUM; i++) {
101 : 0 : struct perf_event **slot = this_cpu_ptr(&bp_per_reg[i]);
102 : :
103 [ # # ]: 0 : if (!*slot) {
104 : 0 : *slot = bp;
105 : 0 : break;
106 : : }
107 : : }
108 : :
109 [ # # # # : 0 : if (WARN_ONCE(i == HBP_NUM, "Can't find any breakpoint slot"))
# # ]
110 : : return -EBUSY;
111 : :
112 : 0 : set_debugreg(info->address, i);
113 : 0 : __this_cpu_write(cpu_debugreg[i], info->address);
114 : :
115 : 0 : dr7 = this_cpu_ptr(&cpu_dr7);
116 : 0 : *dr7 |= encode_dr7(i, info->len, info->type);
117 : :
118 : 0 : set_debugreg(*dr7, 7);
119 [ # # ]: 0 : if (info->mask)
120 : 0 : set_dr_addr_mask(info->mask, i);
121 : :
122 : : return 0;
123 : : }
124 : :
125 : : /*
126 : : * Uninstall the breakpoint contained in the given counter.
127 : : *
128 : : * First we search the debug address register it uses and then we disable
129 : : * it.
130 : : *
131 : : * Atomic: we hold the counter->ctx->lock and we only handle variables
132 : : * and registers local to this cpu.
133 : : */
134 : 0 : void arch_uninstall_hw_breakpoint(struct perf_event *bp)
135 : : {
136 : 0 : struct arch_hw_breakpoint *info = counter_arch_bp(bp);
137 : 0 : unsigned long *dr7;
138 : 0 : int i;
139 : :
140 [ # # ]: 0 : for (i = 0; i < HBP_NUM; i++) {
141 : 0 : struct perf_event **slot = this_cpu_ptr(&bp_per_reg[i]);
142 : :
143 [ # # ]: 0 : if (*slot == bp) {
144 : 0 : *slot = NULL;
145 : 0 : break;
146 : : }
147 : : }
148 : :
149 [ # # # # : 0 : if (WARN_ONCE(i == HBP_NUM, "Can't find any breakpoint slot"))
# # ]
150 : : return;
151 : :
152 : 0 : dr7 = this_cpu_ptr(&cpu_dr7);
153 : 0 : *dr7 &= ~__encode_dr7(i, info->len, info->type);
154 : :
155 : 0 : set_debugreg(*dr7, 7);
156 [ # # ]: 0 : if (info->mask)
157 : 0 : set_dr_addr_mask(0, i);
158 : : }
159 : :
160 : 0 : static int arch_bp_generic_len(int x86_len)
161 : : {
162 : 0 : switch (x86_len) {
163 : : case X86_BREAKPOINT_LEN_1:
164 : : return HW_BREAKPOINT_LEN_1;
165 : : case X86_BREAKPOINT_LEN_2:
166 : : return HW_BREAKPOINT_LEN_2;
167 : : case X86_BREAKPOINT_LEN_4:
168 : : return HW_BREAKPOINT_LEN_4;
169 : : #ifdef CONFIG_X86_64
170 : : case X86_BREAKPOINT_LEN_8:
171 : : return HW_BREAKPOINT_LEN_8;
172 : : #endif
173 : : default:
174 : : return -EINVAL;
175 : : }
176 : : }
177 : :
178 : 0 : int arch_bp_generic_fields(int x86_len, int x86_type,
179 : : int *gen_len, int *gen_type)
180 : : {
181 : 0 : int len;
182 : :
183 : : /* Type */
184 [ # # # # ]: 0 : switch (x86_type) {
185 : 0 : case X86_BREAKPOINT_EXECUTE:
186 [ # # ]: 0 : if (x86_len != X86_BREAKPOINT_LEN_X)
187 : : return -EINVAL;
188 : :
189 : 0 : *gen_type = HW_BREAKPOINT_X;
190 : 0 : *gen_len = sizeof(long);
191 : 0 : return 0;
192 : 0 : case X86_BREAKPOINT_WRITE:
193 : 0 : *gen_type = HW_BREAKPOINT_W;
194 : 0 : break;
195 : 0 : case X86_BREAKPOINT_RW:
196 : 0 : *gen_type = HW_BREAKPOINT_W | HW_BREAKPOINT_R;
197 : 0 : break;
198 : : default:
199 : : return -EINVAL;
200 : : }
201 : :
202 : : /* Len */
203 [ # # ]: 0 : len = arch_bp_generic_len(x86_len);
204 [ # # ]: 0 : if (len < 0)
205 : : return -EINVAL;
206 : 0 : *gen_len = len;
207 : :
208 : 0 : return 0;
209 : : }
210 : :
211 : : /*
212 : : * Check for virtual address in kernel space.
213 : : */
214 : 0 : int arch_check_bp_in_kernelspace(struct arch_hw_breakpoint *hw)
215 : : {
216 : 0 : unsigned long va;
217 : 0 : int len;
218 : :
219 : 0 : va = hw->address;
220 [ # # ]: 0 : len = arch_bp_generic_len(hw->len);
221 [ # # ]: 0 : WARN_ON_ONCE(len < 0);
222 : :
223 : : /*
224 : : * We don't need to worry about va + len - 1 overflowing:
225 : : * we already require that va is aligned to a multiple of len.
226 : : */
227 [ # # # # : 0 : return (va >= TASK_SIZE_MAX) || ((va + len - 1) >= TASK_SIZE_MAX);
# # # # #
# ]
228 : : }
229 : :
230 : : static int arch_build_bp_info(struct perf_event *bp,
231 : : const struct perf_event_attr *attr,
232 : : struct arch_hw_breakpoint *hw)
233 : : {
234 : : hw->address = attr->bp_addr;
235 : : hw->mask = 0;
236 : :
237 : : /* Type */
238 : : switch (attr->bp_type) {
239 : : case HW_BREAKPOINT_W:
240 : : hw->type = X86_BREAKPOINT_WRITE;
241 : : break;
242 : : case HW_BREAKPOINT_W | HW_BREAKPOINT_R:
243 : : hw->type = X86_BREAKPOINT_RW;
244 : : break;
245 : : case HW_BREAKPOINT_X:
246 : : /*
247 : : * We don't allow kernel breakpoints in places that are not
248 : : * acceptable for kprobes. On non-kprobes kernels, we don't
249 : : * allow kernel breakpoints at all.
250 : : */
251 : : if (attr->bp_addr >= TASK_SIZE_MAX) {
252 : : if (within_kprobe_blacklist(attr->bp_addr))
253 : : return -EINVAL;
254 : : }
255 : :
256 : : hw->type = X86_BREAKPOINT_EXECUTE;
257 : : /*
258 : : * x86 inst breakpoints need to have a specific undefined len.
259 : : * But we still need to check userspace is not trying to setup
260 : : * an unsupported length, to get a range breakpoint for example.
261 : : */
262 : : if (attr->bp_len == sizeof(long)) {
263 : : hw->len = X86_BREAKPOINT_LEN_X;
264 : : return 0;
265 : : }
266 : : /* fall through */
267 : : default:
268 : : return -EINVAL;
269 : : }
270 : :
271 : : /* Len */
272 : : switch (attr->bp_len) {
273 : : case HW_BREAKPOINT_LEN_1:
274 : : hw->len = X86_BREAKPOINT_LEN_1;
275 : : break;
276 : : case HW_BREAKPOINT_LEN_2:
277 : : hw->len = X86_BREAKPOINT_LEN_2;
278 : : break;
279 : : case HW_BREAKPOINT_LEN_4:
280 : : hw->len = X86_BREAKPOINT_LEN_4;
281 : : break;
282 : : #ifdef CONFIG_X86_64
283 : : case HW_BREAKPOINT_LEN_8:
284 : : hw->len = X86_BREAKPOINT_LEN_8;
285 : : break;
286 : : #endif
287 : : default:
288 : : /* AMD range breakpoint */
289 : : if (!is_power_of_2(attr->bp_len))
290 : : return -EINVAL;
291 : : if (attr->bp_addr & (attr->bp_len - 1))
292 : : return -EINVAL;
293 : :
294 : : if (!boot_cpu_has(X86_FEATURE_BPEXT))
295 : : return -EOPNOTSUPP;
296 : :
297 : : /*
298 : : * It's impossible to use a range breakpoint to fake out
299 : : * user vs kernel detection because bp_len - 1 can't
300 : : * have the high bit set. If we ever allow range instruction
301 : : * breakpoints, then we'll have to check for kprobe-blacklisted
302 : : * addresses anywhere in the range.
303 : : */
304 : : hw->mask = attr->bp_len - 1;
305 : : hw->len = X86_BREAKPOINT_LEN_1;
306 : : }
307 : :
308 : : return 0;
309 : : }
310 : :
311 : : /*
312 : : * Validate the arch-specific HW Breakpoint register settings
313 : : */
314 : 0 : int hw_breakpoint_arch_parse(struct perf_event *bp,
315 : : const struct perf_event_attr *attr,
316 : : struct arch_hw_breakpoint *hw)
317 : : {
318 : 0 : unsigned int align;
319 : 0 : int ret;
320 : :
321 : :
322 : 0 : ret = arch_build_bp_info(bp, attr, hw);
323 [ # # ]: 0 : if (ret)
324 : : return ret;
325 : :
326 [ # # # # : 0 : switch (hw->len) {
# ]
327 : 0 : case X86_BREAKPOINT_LEN_1:
328 : 0 : align = 0;
329 [ # # ]: 0 : if (hw->mask)
330 : 0 : align = hw->mask;
331 : : break;
332 : : case X86_BREAKPOINT_LEN_2:
333 : : align = 1;
334 : : break;
335 : 0 : case X86_BREAKPOINT_LEN_4:
336 : 0 : align = 3;
337 : 0 : break;
338 : : #ifdef CONFIG_X86_64
339 : 0 : case X86_BREAKPOINT_LEN_8:
340 : 0 : align = 7;
341 : 0 : break;
342 : : #endif
343 : : default:
344 : 0 : WARN_ON_ONCE(1);
345 : 0 : return -EINVAL;
346 : : }
347 : :
348 : : /*
349 : : * Check that the low-order bits of the address are appropriate
350 : : * for the alignment implied by len.
351 : : */
352 [ # # ]: 0 : if (hw->address & align)
353 : 0 : return -EINVAL;
354 : :
355 : : return 0;
356 : : }
357 : :
358 : : /*
359 : : * Dump the debug register contents to the user.
360 : : * We can't dump our per cpu values because it
361 : : * may contain cpu wide breakpoint, something that
362 : : * doesn't belong to the current task.
363 : : *
364 : : * TODO: include non-ptrace user breakpoints (perf)
365 : : */
366 : 0 : void aout_dump_debugregs(struct user *dump)
367 : : {
368 : 0 : int i;
369 : 0 : int dr7 = 0;
370 : 0 : struct perf_event *bp;
371 : 0 : struct arch_hw_breakpoint *info;
372 : 0 : struct thread_struct *thread = ¤t->thread;
373 : :
374 [ # # ]: 0 : for (i = 0; i < HBP_NUM; i++) {
375 : 0 : bp = thread->ptrace_bps[i];
376 : :
377 [ # # # # ]: 0 : if (bp && !bp->attr.disabled) {
378 : 0 : dump->u_debugreg[i] = bp->attr.bp_addr;
379 : 0 : info = counter_arch_bp(bp);
380 : 0 : dr7 |= encode_dr7(i, info->len, info->type);
381 : : } else {
382 : 0 : dump->u_debugreg[i] = 0;
383 : : }
384 : : }
385 : :
386 : 0 : dump->u_debugreg[4] = 0;
387 : 0 : dump->u_debugreg[5] = 0;
388 : 0 : dump->u_debugreg[6] = current->thread.debugreg6;
389 : :
390 : 0 : dump->u_debugreg[7] = dr7;
391 : 0 : }
392 : : EXPORT_SYMBOL_GPL(aout_dump_debugregs);
393 : :
394 : : /*
395 : : * Release the user breakpoints used by ptrace
396 : : */
397 : 111298 : void flush_ptrace_hw_breakpoint(struct task_struct *tsk)
398 : : {
399 : 111298 : int i;
400 : 111298 : struct thread_struct *t = &tsk->thread;
401 : :
402 [ + + ]: 556490 : for (i = 0; i < HBP_NUM; i++) {
403 : 445192 : unregister_hw_breakpoint(t->ptrace_bps[i]);
404 : 445192 : t->ptrace_bps[i] = NULL;
405 : : }
406 : :
407 : 111298 : t->debugreg6 = 0;
408 : 111298 : t->ptrace_dr7 = 0;
409 : 111298 : }
410 : :
411 : 0 : void hw_breakpoint_restore(void)
412 : : {
413 : 0 : set_debugreg(__this_cpu_read(cpu_debugreg[0]), 0);
414 : 0 : set_debugreg(__this_cpu_read(cpu_debugreg[1]), 1);
415 : 0 : set_debugreg(__this_cpu_read(cpu_debugreg[2]), 2);
416 : 0 : set_debugreg(__this_cpu_read(cpu_debugreg[3]), 3);
417 : 0 : set_debugreg(current->thread.debugreg6, 6);
418 : 0 : set_debugreg(__this_cpu_read(cpu_dr7), 7);
419 : 0 : }
420 : : EXPORT_SYMBOL_GPL(hw_breakpoint_restore);
421 : :
422 : : /*
423 : : * Handle debug exception notifications.
424 : : *
425 : : * Return value is either NOTIFY_STOP or NOTIFY_DONE as explained below.
426 : : *
427 : : * NOTIFY_DONE returned if one of the following conditions is true.
428 : : * i) When the causative address is from user-space and the exception
429 : : * is a valid one, i.e. not triggered as a result of lazy debug register
430 : : * switching
431 : : * ii) When there are more bits than trap<n> set in DR6 register (such
432 : : * as BD, BS or BT) indicating that more than one debug condition is
433 : : * met and requires some more action in do_debug().
434 : : *
435 : : * NOTIFY_STOP returned for all other cases
436 : : *
437 : : */
438 : : static int hw_breakpoint_handler(struct die_args *args)
439 : : {
440 : : int i, cpu, rc = NOTIFY_STOP;
441 : : struct perf_event *bp;
442 : : unsigned long dr7, dr6;
443 : : unsigned long *dr6_p;
444 : :
445 : : /* The DR6 value is pointed by args->err */
446 : : dr6_p = (unsigned long *)ERR_PTR(args->err);
447 : : dr6 = *dr6_p;
448 : :
449 : : /* If it's a single step, TRAP bits are random */
450 : : if (dr6 & DR_STEP)
451 : : return NOTIFY_DONE;
452 : :
453 : : /* Do an early return if no trap bits are set in DR6 */
454 : : if ((dr6 & DR_TRAP_BITS) == 0)
455 : : return NOTIFY_DONE;
456 : :
457 : : get_debugreg(dr7, 7);
458 : : /* Disable breakpoints during exception handling */
459 : : set_debugreg(0UL, 7);
460 : : /*
461 : : * Assert that local interrupts are disabled
462 : : * Reset the DRn bits in the virtualized register value.
463 : : * The ptrace trigger routine will add in whatever is needed.
464 : : */
465 : : current->thread.debugreg6 &= ~DR_TRAP_BITS;
466 : : cpu = get_cpu();
467 : :
468 : : /* Handle all the breakpoints that were triggered */
469 : : for (i = 0; i < HBP_NUM; ++i) {
470 : : if (likely(!(dr6 & (DR_TRAP0 << i))))
471 : : continue;
472 : :
473 : : /*
474 : : * The counter may be concurrently released but that can only
475 : : * occur from a call_rcu() path. We can then safely fetch
476 : : * the breakpoint, use its callback, touch its counter
477 : : * while we are in an rcu_read_lock() path.
478 : : */
479 : : rcu_read_lock();
480 : :
481 : : bp = per_cpu(bp_per_reg[i], cpu);
482 : : /*
483 : : * Reset the 'i'th TRAP bit in dr6 to denote completion of
484 : : * exception handling
485 : : */
486 : : (*dr6_p) &= ~(DR_TRAP0 << i);
487 : : /*
488 : : * bp can be NULL due to lazy debug register switching
489 : : * or due to concurrent perf counter removing.
490 : : */
491 : : if (!bp) {
492 : : rcu_read_unlock();
493 : : break;
494 : : }
495 : :
496 : : perf_bp_event(bp, args->regs);
497 : :
498 : : /*
499 : : * Set up resume flag to avoid breakpoint recursion when
500 : : * returning back to origin.
501 : : */
502 : : if (bp->hw.info.type == X86_BREAKPOINT_EXECUTE)
503 : : args->regs->flags |= X86_EFLAGS_RF;
504 : :
505 : : rcu_read_unlock();
506 : : }
507 : : /*
508 : : * Further processing in do_debug() is needed for a) user-space
509 : : * breakpoints (to generate signals) and b) when the system has
510 : : * taken exception due to multiple causes
511 : : */
512 : : if ((current->thread.debugreg6 & DR_TRAP_BITS) ||
513 : : (dr6 & (~DR_TRAP_BITS)))
514 : : rc = NOTIFY_DONE;
515 : :
516 : : set_debugreg(dr7, 7);
517 : : put_cpu();
518 : :
519 : : return rc;
520 : : }
521 : :
522 : : /*
523 : : * Handle debug exception notifications.
524 : : */
525 : 11 : int hw_breakpoint_exceptions_notify(
526 : : struct notifier_block *unused, unsigned long val, void *data)
527 : : {
528 [ - + ]: 11 : if (val != DIE_DEBUG)
529 : : return NOTIFY_DONE;
530 : :
531 : 0 : return hw_breakpoint_handler(data);
532 : : }
533 : :
534 : 0 : void hw_breakpoint_pmu_read(struct perf_event *bp)
535 : : {
536 : : /* TODO */
537 : 0 : }
|
