Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : *
4 : : * Copyright (C) 2009, 2010 ARM Limited
5 : : *
6 : : * Author: Will Deacon <will.deacon@arm.com>
7 : : */
8 : :
9 : : /*
10 : : * HW_breakpoint: a unified kernel/user-space hardware breakpoint facility,
11 : : * using the CPU's debug registers.
12 : : */
13 : : #define pr_fmt(fmt) "hw-breakpoint: " fmt
14 : :
15 : : #include <linux/errno.h>
16 : : #include <linux/hardirq.h>
17 : : #include <linux/perf_event.h>
18 : : #include <linux/hw_breakpoint.h>
19 : : #include <linux/smp.h>
20 : : #include <linux/cpu_pm.h>
21 : : #include <linux/coresight.h>
22 : :
23 : : #include <asm/cacheflush.h>
24 : : #include <asm/cputype.h>
25 : : #include <asm/current.h>
26 : : #include <asm/hw_breakpoint.h>
27 : : #include <asm/traps.h>
28 : :
29 : : /* Breakpoint currently in use for each BRP. */
30 : : static DEFINE_PER_CPU(struct perf_event *, bp_on_reg[ARM_MAX_BRP]);
31 : :
32 : : /* Watchpoint currently in use for each WRP. */
33 : : static DEFINE_PER_CPU(struct perf_event *, wp_on_reg[ARM_MAX_WRP]);
34 : :
35 : : /* Number of BRP/WRP registers on this CPU. */
36 : : static int core_num_brps __ro_after_init;
37 : : static int core_num_wrps __ro_after_init;
38 : :
39 : : /* Debug architecture version. */
40 : : static u8 debug_arch __ro_after_init;
41 : :
42 : : /* Does debug architecture support OS Save and Restore? */
43 : : static bool has_ossr __ro_after_init;
44 : :
45 : : /* Maximum supported watchpoint length. */
46 : : static u8 max_watchpoint_len __ro_after_init;
47 : :
48 : : #define READ_WB_REG_CASE(OP2, M, VAL) \
49 : : case ((OP2 << 4) + M): \
50 : : ARM_DBG_READ(c0, c ## M, OP2, VAL); \
51 : : break
52 : :
53 : : #define WRITE_WB_REG_CASE(OP2, M, VAL) \
54 : : case ((OP2 << 4) + M): \
55 : : ARM_DBG_WRITE(c0, c ## M, OP2, VAL); \
56 : : break
57 : :
58 : : #define GEN_READ_WB_REG_CASES(OP2, VAL) \
59 : : READ_WB_REG_CASE(OP2, 0, VAL); \
60 : : READ_WB_REG_CASE(OP2, 1, VAL); \
61 : : READ_WB_REG_CASE(OP2, 2, VAL); \
62 : : READ_WB_REG_CASE(OP2, 3, VAL); \
63 : : READ_WB_REG_CASE(OP2, 4, VAL); \
64 : : READ_WB_REG_CASE(OP2, 5, VAL); \
65 : : READ_WB_REG_CASE(OP2, 6, VAL); \
66 : : READ_WB_REG_CASE(OP2, 7, VAL); \
67 : : READ_WB_REG_CASE(OP2, 8, VAL); \
68 : : READ_WB_REG_CASE(OP2, 9, VAL); \
69 : : READ_WB_REG_CASE(OP2, 10, VAL); \
70 : : READ_WB_REG_CASE(OP2, 11, VAL); \
71 : : READ_WB_REG_CASE(OP2, 12, VAL); \
72 : : READ_WB_REG_CASE(OP2, 13, VAL); \
73 : : READ_WB_REG_CASE(OP2, 14, VAL); \
74 : : READ_WB_REG_CASE(OP2, 15, VAL)
75 : :
76 : : #define GEN_WRITE_WB_REG_CASES(OP2, VAL) \
77 : : WRITE_WB_REG_CASE(OP2, 0, VAL); \
78 : : WRITE_WB_REG_CASE(OP2, 1, VAL); \
79 : : WRITE_WB_REG_CASE(OP2, 2, VAL); \
80 : : WRITE_WB_REG_CASE(OP2, 3, VAL); \
81 : : WRITE_WB_REG_CASE(OP2, 4, VAL); \
82 : : WRITE_WB_REG_CASE(OP2, 5, VAL); \
83 : : WRITE_WB_REG_CASE(OP2, 6, VAL); \
84 : : WRITE_WB_REG_CASE(OP2, 7, VAL); \
85 : : WRITE_WB_REG_CASE(OP2, 8, VAL); \
86 : : WRITE_WB_REG_CASE(OP2, 9, VAL); \
87 : : WRITE_WB_REG_CASE(OP2, 10, VAL); \
88 : : WRITE_WB_REG_CASE(OP2, 11, VAL); \
89 : : WRITE_WB_REG_CASE(OP2, 12, VAL); \
90 : : WRITE_WB_REG_CASE(OP2, 13, VAL); \
91 : : WRITE_WB_REG_CASE(OP2, 14, VAL); \
92 : : WRITE_WB_REG_CASE(OP2, 15, VAL)
93 : :
94 : 2 : static u32 read_wb_reg(int n)
95 : : {
96 : : u32 val = 0;
97 : :
98 : 2 : switch (n) {
99 : 0 : GEN_READ_WB_REG_CASES(ARM_OP2_BVR, val);
100 : 0 : GEN_READ_WB_REG_CASES(ARM_OP2_BCR, val);
101 : 0 : GEN_READ_WB_REG_CASES(ARM_OP2_WVR, val);
102 : 2 : GEN_READ_WB_REG_CASES(ARM_OP2_WCR, val);
103 : : default:
104 : 0 : pr_warn("attempt to read from unknown breakpoint register %d\n",
105 : : n);
106 : : }
107 : :
108 : 2 : return val;
109 : : }
110 : :
111 : 3 : static void write_wb_reg(int n, u32 val)
112 : : {
113 : 3 : switch (n) {
114 : 3 : GEN_WRITE_WB_REG_CASES(ARM_OP2_BVR, val);
115 : 3 : GEN_WRITE_WB_REG_CASES(ARM_OP2_BCR, val);
116 : 3 : GEN_WRITE_WB_REG_CASES(ARM_OP2_WVR, val);
117 : 3 : GEN_WRITE_WB_REG_CASES(ARM_OP2_WCR, val);
118 : : default:
119 : 0 : pr_warn("attempt to write to unknown breakpoint register %d\n",
120 : : n);
121 : : }
122 : 3 : isb();
123 : 3 : }
124 : :
125 : : /* Determine debug architecture. */
126 : 3 : static u8 get_debug_arch(void)
127 : : {
128 : : u32 didr;
129 : :
130 : : /* Do we implement the extended CPUID interface? */
131 : 3 : if (((read_cpuid_id() >> 16) & 0xf) != 0xf) {
132 : 0 : pr_warn_once("CPUID feature registers not supported. "
133 : : "Assuming v6 debug is present.\n");
134 : : return ARM_DEBUG_ARCH_V6;
135 : : }
136 : :
137 : 3 : ARM_DBG_READ(c0, c0, 0, didr);
138 : 3 : return (didr >> 16) & 0xf;
139 : : }
140 : :
141 : 0 : u8 arch_get_debug_arch(void)
142 : : {
143 : 0 : return debug_arch;
144 : : }
145 : :
146 : : static int debug_arch_supported(void)
147 : : {
148 : 3 : u8 arch = get_debug_arch();
149 : :
150 : : /* We don't support the memory-mapped interface. */
151 : 3 : return (arch >= ARM_DEBUG_ARCH_V6 && arch <= ARM_DEBUG_ARCH_V7_ECP14) ||
152 : 3 : arch >= ARM_DEBUG_ARCH_V7_1;
153 : : }
154 : :
155 : : /* Can we determine the watchpoint access type from the fsr? */
156 : : static int debug_exception_updates_fsr(void)
157 : : {
158 : 0 : return get_debug_arch() >= ARM_DEBUG_ARCH_V8;
159 : : }
160 : :
161 : : /* Determine number of WRP registers available. */
162 : : static int get_num_wrp_resources(void)
163 : : {
164 : : u32 didr;
165 : 3 : ARM_DBG_READ(c0, c0, 0, didr);
166 : 3 : return ((didr >> 28) & 0xf) + 1;
167 : : }
168 : :
169 : : /* Determine number of BRP registers available. */
170 : : static int get_num_brp_resources(void)
171 : : {
172 : : u32 didr;
173 : 3 : ARM_DBG_READ(c0, c0, 0, didr);
174 : 3 : return ((didr >> 24) & 0xf) + 1;
175 : : }
176 : :
177 : : /* Does this core support mismatch breakpoints? */
178 : 3 : static int core_has_mismatch_brps(void)
179 : : {
180 : 3 : return (get_debug_arch() >= ARM_DEBUG_ARCH_V7_ECP14 &&
181 : : get_num_brp_resources() > 1);
182 : : }
183 : :
184 : : /* Determine number of usable WRPs available. */
185 : : static int get_num_wrps(void)
186 : : {
187 : : /*
188 : : * On debug architectures prior to 7.1, when a watchpoint fires, the
189 : : * only way to work out which watchpoint it was is by disassembling
190 : : * the faulting instruction and working out the address of the memory
191 : : * access.
192 : : *
193 : : * Furthermore, we can only do this if the watchpoint was precise
194 : : * since imprecise watchpoints prevent us from calculating register
195 : : * based addresses.
196 : : *
197 : : * Providing we have more than 1 breakpoint register, we only report
198 : : * a single watchpoint register for the time being. This way, we always
199 : : * know which watchpoint fired. In the future we can either add a
200 : : * disassembler and address generation emulator, or we can insert a
201 : : * check to see if the DFAR is set on watchpoint exception entry
202 : : * [the ARM ARM states that the DFAR is UNKNOWN, but experience shows
203 : : * that it is set on some implementations].
204 : : */
205 : 3 : if (get_debug_arch() < ARM_DEBUG_ARCH_V7_1)
206 : : return 1;
207 : :
208 : : return get_num_wrp_resources();
209 : : }
210 : :
211 : : /* Determine number of usable BRPs available. */
212 : 3 : static int get_num_brps(void)
213 : : {
214 : : int brps = get_num_brp_resources();
215 : 3 : return core_has_mismatch_brps() ? brps - 1 : brps;
216 : : }
217 : :
218 : : /*
219 : : * In order to access the breakpoint/watchpoint control registers,
220 : : * we must be running in debug monitor mode. Unfortunately, we can
221 : : * be put into halting debug mode at any time by an external debugger
222 : : * but there is nothing we can do to prevent that.
223 : : */
224 : : static int monitor_mode_enabled(void)
225 : : {
226 : : u32 dscr;
227 : 0 : ARM_DBG_READ(c0, c1, 0, dscr);
228 : 0 : return !!(dscr & ARM_DSCR_MDBGEN);
229 : : }
230 : :
231 : 3 : static int enable_monitor_mode(void)
232 : : {
233 : : u32 dscr;
234 : 3 : ARM_DBG_READ(c0, c1, 0, dscr);
235 : :
236 : : /* If monitor mode is already enabled, just return. */
237 : 3 : if (dscr & ARM_DSCR_MDBGEN)
238 : : goto out;
239 : :
240 : : /* Write to the corresponding DSCR. */
241 : 3 : switch (get_debug_arch()) {
242 : : case ARM_DEBUG_ARCH_V6:
243 : : case ARM_DEBUG_ARCH_V6_1:
244 : 0 : ARM_DBG_WRITE(c0, c1, 0, (dscr | ARM_DSCR_MDBGEN));
245 : 0 : break;
246 : : case ARM_DEBUG_ARCH_V7_ECP14:
247 : : case ARM_DEBUG_ARCH_V7_1:
248 : : case ARM_DEBUG_ARCH_V8:
249 : 3 : ARM_DBG_WRITE(c0, c2, 2, (dscr | ARM_DSCR_MDBGEN));
250 : 3 : isb();
251 : 3 : break;
252 : : default:
253 : : return -ENODEV;
254 : : }
255 : :
256 : : /* Check that the write made it through. */
257 : 3 : ARM_DBG_READ(c0, c1, 0, dscr);
258 : 3 : if (!(dscr & ARM_DSCR_MDBGEN)) {
259 : 0 : pr_warn_once("Failed to enable monitor mode on CPU %d.\n",
260 : : smp_processor_id());
261 : : return -EPERM;
262 : : }
263 : :
264 : : out:
265 : : return 0;
266 : : }
267 : :
268 : 3 : int hw_breakpoint_slots(int type)
269 : : {
270 : 3 : if (!debug_arch_supported())
271 : : return 0;
272 : :
273 : : /*
274 : : * We can be called early, so don't rely on
275 : : * our static variables being initialised.
276 : : */
277 : 3 : switch (type) {
278 : : case TYPE_INST:
279 : 3 : return get_num_brps();
280 : : case TYPE_DATA:
281 : 3 : return get_num_wrps();
282 : : default:
283 : 0 : pr_warn("unknown slot type: %d\n", type);
284 : 0 : return 0;
285 : : }
286 : : }
287 : :
288 : : /*
289 : : * Check if 8-bit byte-address select is available.
290 : : * This clobbers WRP 0.
291 : : */
292 : 2 : static u8 get_max_wp_len(void)
293 : : {
294 : : u32 ctrl_reg;
295 : : struct arch_hw_breakpoint_ctrl ctrl;
296 : : u8 size = 4;
297 : :
298 : 2 : if (debug_arch < ARM_DEBUG_ARCH_V7_ECP14)
299 : : goto out;
300 : :
301 : 2 : memset(&ctrl, 0, sizeof(ctrl));
302 : 2 : ctrl.len = ARM_BREAKPOINT_LEN_8;
303 : : ctrl_reg = encode_ctrl_reg(ctrl);
304 : :
305 : 2 : write_wb_reg(ARM_BASE_WVR, 0);
306 : 2 : write_wb_reg(ARM_BASE_WCR, ctrl_reg);
307 : 2 : if ((read_wb_reg(ARM_BASE_WCR) & ctrl_reg) == ctrl_reg)
308 : : size = 8;
309 : :
310 : : out:
311 : 2 : return size;
312 : : }
313 : :
314 : 0 : u8 arch_get_max_wp_len(void)
315 : : {
316 : 0 : return max_watchpoint_len;
317 : : }
318 : :
319 : : /*
320 : : * Install a perf counter breakpoint.
321 : : */
322 : 0 : int arch_install_hw_breakpoint(struct perf_event *bp)
323 : : {
324 : : struct arch_hw_breakpoint *info = counter_arch_bp(bp);
325 : : struct perf_event **slot, **slots;
326 : : int i, max_slots, ctrl_base, val_base;
327 : : u32 addr, ctrl;
328 : :
329 : 0 : addr = info->address;
330 : 0 : ctrl = encode_ctrl_reg(info->ctrl) | 0x1;
331 : :
332 : 0 : if (info->ctrl.type == ARM_BREAKPOINT_EXECUTE) {
333 : : /* Breakpoint */
334 : : ctrl_base = ARM_BASE_BCR;
335 : : val_base = ARM_BASE_BVR;
336 : 0 : slots = this_cpu_ptr(bp_on_reg);
337 : 0 : max_slots = core_num_brps;
338 : : } else {
339 : : /* Watchpoint */
340 : : ctrl_base = ARM_BASE_WCR;
341 : : val_base = ARM_BASE_WVR;
342 : 0 : slots = this_cpu_ptr(wp_on_reg);
343 : 0 : max_slots = core_num_wrps;
344 : : }
345 : :
346 : 0 : for (i = 0; i < max_slots; ++i) {
347 : 0 : slot = &slots[i];
348 : :
349 : 0 : if (!*slot) {
350 : 0 : *slot = bp;
351 : 0 : break;
352 : : }
353 : : }
354 : :
355 : 0 : if (i == max_slots) {
356 : 0 : pr_warn("Can't find any breakpoint slot\n");
357 : 0 : return -EBUSY;
358 : : }
359 : :
360 : : /* Override the breakpoint data with the step data. */
361 : 0 : if (info->step_ctrl.enabled) {
362 : 0 : addr = info->trigger & ~0x3;
363 : : ctrl = encode_ctrl_reg(info->step_ctrl);
364 : 0 : if (info->ctrl.type != ARM_BREAKPOINT_EXECUTE) {
365 : : i = 0;
366 : 0 : ctrl_base = ARM_BASE_BCR + core_num_brps;
367 : 0 : val_base = ARM_BASE_BVR + core_num_brps;
368 : : }
369 : : }
370 : :
371 : : /* Setup the address register. */
372 : 0 : write_wb_reg(val_base + i, addr);
373 : :
374 : : /* Setup the control register. */
375 : 0 : write_wb_reg(ctrl_base + i, ctrl);
376 : 0 : return 0;
377 : : }
378 : :
379 : 0 : void arch_uninstall_hw_breakpoint(struct perf_event *bp)
380 : : {
381 : : struct arch_hw_breakpoint *info = counter_arch_bp(bp);
382 : : struct perf_event **slot, **slots;
383 : : int i, max_slots, base;
384 : :
385 : 0 : if (info->ctrl.type == ARM_BREAKPOINT_EXECUTE) {
386 : : /* Breakpoint */
387 : : base = ARM_BASE_BCR;
388 : 0 : slots = this_cpu_ptr(bp_on_reg);
389 : 0 : max_slots = core_num_brps;
390 : : } else {
391 : : /* Watchpoint */
392 : : base = ARM_BASE_WCR;
393 : 0 : slots = this_cpu_ptr(wp_on_reg);
394 : 0 : max_slots = core_num_wrps;
395 : : }
396 : :
397 : : /* Remove the breakpoint. */
398 : 0 : for (i = 0; i < max_slots; ++i) {
399 : 0 : slot = &slots[i];
400 : :
401 : 0 : if (*slot == bp) {
402 : 0 : *slot = NULL;
403 : 0 : break;
404 : : }
405 : : }
406 : :
407 : 0 : if (i == max_slots) {
408 : 0 : pr_warn("Can't find any breakpoint slot\n");
409 : 0 : return;
410 : : }
411 : :
412 : : /* Ensure that we disable the mismatch breakpoint. */
413 : 0 : if (info->ctrl.type != ARM_BREAKPOINT_EXECUTE &&
414 : : info->step_ctrl.enabled) {
415 : : i = 0;
416 : 0 : base = ARM_BASE_BCR + core_num_brps;
417 : : }
418 : :
419 : : /* Reset the control register. */
420 : 0 : write_wb_reg(base + i, 0);
421 : : }
422 : :
423 : : static int get_hbp_len(u8 hbp_len)
424 : : {
425 : : unsigned int len_in_bytes = 0;
426 : :
427 : 0 : switch (hbp_len) {
428 : : case ARM_BREAKPOINT_LEN_1:
429 : : len_in_bytes = 1;
430 : : break;
431 : : case ARM_BREAKPOINT_LEN_2:
432 : : len_in_bytes = 2;
433 : : break;
434 : : case ARM_BREAKPOINT_LEN_4:
435 : : len_in_bytes = 4;
436 : : break;
437 : : case ARM_BREAKPOINT_LEN_8:
438 : : len_in_bytes = 8;
439 : : break;
440 : : }
441 : :
442 : : return len_in_bytes;
443 : : }
444 : :
445 : : /*
446 : : * Check whether bp virtual address is in kernel space.
447 : : */
448 : 0 : int arch_check_bp_in_kernelspace(struct arch_hw_breakpoint *hw)
449 : : {
450 : : unsigned int len;
451 : : unsigned long va;
452 : :
453 : 0 : va = hw->address;
454 : 0 : len = get_hbp_len(hw->ctrl.len);
455 : :
456 : 0 : return (va >= TASK_SIZE) && ((va + len - 1) >= TASK_SIZE);
457 : : }
458 : :
459 : : /*
460 : : * Extract generic type and length encodings from an arch_hw_breakpoint_ctrl.
461 : : * Hopefully this will disappear when ptrace can bypass the conversion
462 : : * to generic breakpoint descriptions.
463 : : */
464 : 0 : int arch_bp_generic_fields(struct arch_hw_breakpoint_ctrl ctrl,
465 : : int *gen_len, int *gen_type)
466 : : {
467 : : /* Type */
468 : 0 : switch (ctrl.type) {
469 : : case ARM_BREAKPOINT_EXECUTE:
470 : 0 : *gen_type = HW_BREAKPOINT_X;
471 : 0 : break;
472 : : case ARM_BREAKPOINT_LOAD:
473 : 0 : *gen_type = HW_BREAKPOINT_R;
474 : 0 : break;
475 : : case ARM_BREAKPOINT_STORE:
476 : 0 : *gen_type = HW_BREAKPOINT_W;
477 : 0 : break;
478 : : case ARM_BREAKPOINT_LOAD | ARM_BREAKPOINT_STORE:
479 : 0 : *gen_type = HW_BREAKPOINT_RW;
480 : 0 : break;
481 : : default:
482 : : return -EINVAL;
483 : : }
484 : :
485 : : /* Len */
486 : 0 : switch (ctrl.len) {
487 : : case ARM_BREAKPOINT_LEN_1:
488 : 0 : *gen_len = HW_BREAKPOINT_LEN_1;
489 : 0 : break;
490 : : case ARM_BREAKPOINT_LEN_2:
491 : 0 : *gen_len = HW_BREAKPOINT_LEN_2;
492 : 0 : break;
493 : : case ARM_BREAKPOINT_LEN_4:
494 : 0 : *gen_len = HW_BREAKPOINT_LEN_4;
495 : 0 : break;
496 : : case ARM_BREAKPOINT_LEN_8:
497 : 0 : *gen_len = HW_BREAKPOINT_LEN_8;
498 : 0 : break;
499 : : default:
500 : : return -EINVAL;
501 : : }
502 : :
503 : : return 0;
504 : : }
505 : :
506 : : /*
507 : : * Construct an arch_hw_breakpoint from a perf_event.
508 : : */
509 : 0 : static int arch_build_bp_info(struct perf_event *bp,
510 : : const struct perf_event_attr *attr,
511 : : struct arch_hw_breakpoint *hw)
512 : : {
513 : : /* Type */
514 : 0 : switch (attr->bp_type) {
515 : : case HW_BREAKPOINT_X:
516 : 0 : hw->ctrl.type = ARM_BREAKPOINT_EXECUTE;
517 : 0 : break;
518 : : case HW_BREAKPOINT_R:
519 : 0 : hw->ctrl.type = ARM_BREAKPOINT_LOAD;
520 : 0 : break;
521 : : case HW_BREAKPOINT_W:
522 : 0 : hw->ctrl.type = ARM_BREAKPOINT_STORE;
523 : 0 : break;
524 : : case HW_BREAKPOINT_RW:
525 : 0 : hw->ctrl.type = ARM_BREAKPOINT_LOAD | ARM_BREAKPOINT_STORE;
526 : 0 : break;
527 : : default:
528 : : return -EINVAL;
529 : : }
530 : :
531 : : /* Len */
532 : 0 : switch (attr->bp_len) {
533 : : case HW_BREAKPOINT_LEN_1:
534 : 0 : hw->ctrl.len = ARM_BREAKPOINT_LEN_1;
535 : 0 : break;
536 : : case HW_BREAKPOINT_LEN_2:
537 : 0 : hw->ctrl.len = ARM_BREAKPOINT_LEN_2;
538 : 0 : break;
539 : : case HW_BREAKPOINT_LEN_4:
540 : 0 : hw->ctrl.len = ARM_BREAKPOINT_LEN_4;
541 : 0 : break;
542 : : case HW_BREAKPOINT_LEN_8:
543 : 0 : hw->ctrl.len = ARM_BREAKPOINT_LEN_8;
544 : 0 : if ((hw->ctrl.type != ARM_BREAKPOINT_EXECUTE)
545 : 0 : && max_watchpoint_len >= 8)
546 : : break;
547 : : /* Else, fall through */
548 : : default:
549 : : return -EINVAL;
550 : : }
551 : :
552 : : /*
553 : : * Breakpoints must be of length 2 (thumb) or 4 (ARM) bytes.
554 : : * Watchpoints can be of length 1, 2, 4 or 8 bytes if supported
555 : : * by the hardware and must be aligned to the appropriate number of
556 : : * bytes.
557 : : */
558 : 0 : if (hw->ctrl.type == ARM_BREAKPOINT_EXECUTE &&
559 : 0 : hw->ctrl.len != ARM_BREAKPOINT_LEN_2 &&
560 : : hw->ctrl.len != ARM_BREAKPOINT_LEN_4)
561 : : return -EINVAL;
562 : :
563 : : /* Address */
564 : 0 : hw->address = attr->bp_addr;
565 : :
566 : : /* Privilege */
567 : 0 : hw->ctrl.privilege = ARM_BREAKPOINT_USER;
568 : 0 : if (arch_check_bp_in_kernelspace(hw))
569 : 0 : hw->ctrl.privilege |= ARM_BREAKPOINT_PRIV;
570 : :
571 : : /* Enabled? */
572 : 0 : hw->ctrl.enabled = !attr->disabled;
573 : :
574 : : /* Mismatch */
575 : 0 : hw->ctrl.mismatch = 0;
576 : :
577 : 0 : return 0;
578 : : }
579 : :
580 : : /*
581 : : * Validate the arch-specific HW Breakpoint register settings.
582 : : */
583 : 0 : int hw_breakpoint_arch_parse(struct perf_event *bp,
584 : : const struct perf_event_attr *attr,
585 : : struct arch_hw_breakpoint *hw)
586 : : {
587 : : int ret = 0;
588 : : u32 offset, alignment_mask = 0x3;
589 : :
590 : : /* Ensure that we are in monitor debug mode. */
591 : 0 : if (!monitor_mode_enabled())
592 : : return -ENODEV;
593 : :
594 : : /* Build the arch_hw_breakpoint. */
595 : 0 : ret = arch_build_bp_info(bp, attr, hw);
596 : 0 : if (ret)
597 : : goto out;
598 : :
599 : : /* Check address alignment. */
600 : 0 : if (hw->ctrl.len == ARM_BREAKPOINT_LEN_8)
601 : : alignment_mask = 0x7;
602 : 0 : offset = hw->address & alignment_mask;
603 : 0 : switch (offset) {
604 : : case 0:
605 : : /* Aligned */
606 : : break;
607 : : case 1:
608 : : case 2:
609 : : /* Allow halfword watchpoints and breakpoints. */
610 : 0 : if (hw->ctrl.len == ARM_BREAKPOINT_LEN_2)
611 : : break;
612 : : /* Else, fall through */
613 : : case 3:
614 : : /* Allow single byte watchpoint. */
615 : 0 : if (hw->ctrl.len == ARM_BREAKPOINT_LEN_1)
616 : : break;
617 : : /* Else, fall through */
618 : : default:
619 : : ret = -EINVAL;
620 : : goto out;
621 : : }
622 : :
623 : 0 : hw->address &= ~alignment_mask;
624 : 0 : hw->ctrl.len <<= offset;
625 : :
626 : 0 : if (is_default_overflow_handler(bp)) {
627 : : /*
628 : : * Mismatch breakpoints are required for single-stepping
629 : : * breakpoints.
630 : : */
631 : 0 : if (!core_has_mismatch_brps())
632 : : return -EINVAL;
633 : :
634 : : /* We don't allow mismatch breakpoints in kernel space. */
635 : 0 : if (arch_check_bp_in_kernelspace(hw))
636 : : return -EPERM;
637 : :
638 : : /*
639 : : * Per-cpu breakpoints are not supported by our stepping
640 : : * mechanism.
641 : : */
642 : 0 : if (!bp->hw.target)
643 : : return -EINVAL;
644 : :
645 : : /*
646 : : * We only support specific access types if the fsr
647 : : * reports them.
648 : : */
649 : 0 : if (!debug_exception_updates_fsr() &&
650 : 0 : (hw->ctrl.type == ARM_BREAKPOINT_LOAD ||
651 : : hw->ctrl.type == ARM_BREAKPOINT_STORE))
652 : : return -EINVAL;
653 : : }
654 : :
655 : : out:
656 : 0 : return ret;
657 : : }
658 : :
659 : : /*
660 : : * Enable/disable single-stepping over the breakpoint bp at address addr.
661 : : */
662 : 0 : static void enable_single_step(struct perf_event *bp, u32 addr)
663 : : {
664 : : struct arch_hw_breakpoint *info = counter_arch_bp(bp);
665 : :
666 : 0 : arch_uninstall_hw_breakpoint(bp);
667 : 0 : info->step_ctrl.mismatch = 1;
668 : 0 : info->step_ctrl.len = ARM_BREAKPOINT_LEN_4;
669 : 0 : info->step_ctrl.type = ARM_BREAKPOINT_EXECUTE;
670 : 0 : info->step_ctrl.privilege = info->ctrl.privilege;
671 : 0 : info->step_ctrl.enabled = 1;
672 : 0 : info->trigger = addr;
673 : 0 : arch_install_hw_breakpoint(bp);
674 : 0 : }
675 : :
676 : : static void disable_single_step(struct perf_event *bp)
677 : : {
678 : 0 : arch_uninstall_hw_breakpoint(bp);
679 : 0 : counter_arch_bp(bp)->step_ctrl.enabled = 0;
680 : 0 : arch_install_hw_breakpoint(bp);
681 : : }
682 : :
683 : : static int watchpoint_fault_on_uaccess(struct pt_regs *regs,
684 : : struct arch_hw_breakpoint *info)
685 : : {
686 : 0 : return !user_mode(regs) && info->ctrl.privilege == ARM_BREAKPOINT_USER;
687 : : }
688 : :
689 : 0 : static void watchpoint_handler(unsigned long addr, unsigned int fsr,
690 : : struct pt_regs *regs)
691 : : {
692 : : int i, access;
693 : : u32 val, ctrl_reg, alignment_mask;
694 : : struct perf_event *wp, **slots;
695 : : struct arch_hw_breakpoint *info;
696 : : struct arch_hw_breakpoint_ctrl ctrl;
697 : :
698 : 0 : slots = this_cpu_ptr(wp_on_reg);
699 : :
700 : 0 : for (i = 0; i < core_num_wrps; ++i) {
701 : : rcu_read_lock();
702 : :
703 : 0 : wp = slots[i];
704 : :
705 : 0 : if (wp == NULL)
706 : : goto unlock;
707 : :
708 : : info = counter_arch_bp(wp);
709 : : /*
710 : : * The DFAR is an unknown value on debug architectures prior
711 : : * to 7.1. Since we only allow a single watchpoint on these
712 : : * older CPUs, we can set the trigger to the lowest possible
713 : : * faulting address.
714 : : */
715 : 0 : if (debug_arch < ARM_DEBUG_ARCH_V7_1) {
716 : 0 : BUG_ON(i > 0);
717 : 0 : info->trigger = wp->attr.bp_addr;
718 : : } else {
719 : 0 : if (info->ctrl.len == ARM_BREAKPOINT_LEN_8)
720 : : alignment_mask = 0x7;
721 : : else
722 : : alignment_mask = 0x3;
723 : :
724 : : /* Check if the watchpoint value matches. */
725 : 0 : val = read_wb_reg(ARM_BASE_WVR + i);
726 : 0 : if (val != (addr & ~alignment_mask))
727 : : goto unlock;
728 : :
729 : : /* Possible match, check the byte address select. */
730 : 0 : ctrl_reg = read_wb_reg(ARM_BASE_WCR + i);
731 : : decode_ctrl_reg(ctrl_reg, &ctrl);
732 : 0 : if (!((1 << (addr & alignment_mask)) & ctrl.len))
733 : : goto unlock;
734 : :
735 : : /* Check that the access type matches. */
736 : 0 : if (debug_exception_updates_fsr()) {
737 : 0 : access = (fsr & ARM_FSR_ACCESS_MASK) ?
738 : 0 : HW_BREAKPOINT_W : HW_BREAKPOINT_R;
739 : 0 : if (!(access & hw_breakpoint_type(wp)))
740 : : goto unlock;
741 : : }
742 : :
743 : : /* We have a winner. */
744 : 0 : info->trigger = addr;
745 : : }
746 : :
747 : : pr_debug("watchpoint fired: address = 0x%x\n", info->trigger);
748 : :
749 : : /*
750 : : * If we triggered a user watchpoint from a uaccess routine,
751 : : * then handle the stepping ourselves since userspace really
752 : : * can't help us with this.
753 : : */
754 : 0 : if (watchpoint_fault_on_uaccess(regs, info))
755 : : goto step;
756 : :
757 : 0 : perf_bp_event(wp, regs);
758 : :
759 : : /*
760 : : * Defer stepping to the overflow handler if one is installed.
761 : : * Otherwise, insert a temporary mismatch breakpoint so that
762 : : * we can single-step over the watchpoint trigger.
763 : : */
764 : 0 : if (!is_default_overflow_handler(wp))
765 : : goto unlock;
766 : :
767 : : step:
768 : 0 : enable_single_step(wp, instruction_pointer(regs));
769 : : unlock:
770 : : rcu_read_unlock();
771 : : }
772 : 0 : }
773 : :
774 : 0 : static void watchpoint_single_step_handler(unsigned long pc)
775 : : {
776 : : int i;
777 : : struct perf_event *wp, **slots;
778 : : struct arch_hw_breakpoint *info;
779 : :
780 : 0 : slots = this_cpu_ptr(wp_on_reg);
781 : :
782 : 0 : for (i = 0; i < core_num_wrps; ++i) {
783 : : rcu_read_lock();
784 : :
785 : 0 : wp = slots[i];
786 : :
787 : 0 : if (wp == NULL)
788 : : goto unlock;
789 : :
790 : : info = counter_arch_bp(wp);
791 : 0 : if (!info->step_ctrl.enabled)
792 : : goto unlock;
793 : :
794 : : /*
795 : : * Restore the original watchpoint if we've completed the
796 : : * single-step.
797 : : */
798 : 0 : if (info->trigger != pc)
799 : : disable_single_step(wp);
800 : :
801 : : unlock:
802 : : rcu_read_unlock();
803 : : }
804 : 0 : }
805 : :
806 : 0 : static void breakpoint_handler(unsigned long unknown, struct pt_regs *regs)
807 : : {
808 : : int i;
809 : : u32 ctrl_reg, val, addr;
810 : : struct perf_event *bp, **slots;
811 : : struct arch_hw_breakpoint *info;
812 : : struct arch_hw_breakpoint_ctrl ctrl;
813 : :
814 : 0 : slots = this_cpu_ptr(bp_on_reg);
815 : :
816 : : /* The exception entry code places the amended lr in the PC. */
817 : 0 : addr = regs->ARM_pc;
818 : :
819 : : /* Check the currently installed breakpoints first. */
820 : 0 : for (i = 0; i < core_num_brps; ++i) {
821 : : rcu_read_lock();
822 : :
823 : 0 : bp = slots[i];
824 : :
825 : 0 : if (bp == NULL)
826 : : goto unlock;
827 : :
828 : : info = counter_arch_bp(bp);
829 : :
830 : : /* Check if the breakpoint value matches. */
831 : 0 : val = read_wb_reg(ARM_BASE_BVR + i);
832 : 0 : if (val != (addr & ~0x3))
833 : : goto mismatch;
834 : :
835 : : /* Possible match, check the byte address select to confirm. */
836 : 0 : ctrl_reg = read_wb_reg(ARM_BASE_BCR + i);
837 : : decode_ctrl_reg(ctrl_reg, &ctrl);
838 : 0 : if ((1 << (addr & 0x3)) & ctrl.len) {
839 : 0 : info->trigger = addr;
840 : : pr_debug("breakpoint fired: address = 0x%x\n", addr);
841 : 0 : perf_bp_event(bp, regs);
842 : 0 : if (!bp->overflow_handler)
843 : 0 : enable_single_step(bp, addr);
844 : : goto unlock;
845 : : }
846 : :
847 : : mismatch:
848 : : /* If we're stepping a breakpoint, it can now be restored. */
849 : 0 : if (info->step_ctrl.enabled)
850 : : disable_single_step(bp);
851 : : unlock:
852 : : rcu_read_unlock();
853 : : }
854 : :
855 : : /* Handle any pending watchpoint single-step breakpoints. */
856 : 0 : watchpoint_single_step_handler(addr);
857 : 0 : }
858 : :
859 : : /*
860 : : * Called from either the Data Abort Handler [watchpoint] or the
861 : : * Prefetch Abort Handler [breakpoint] with interrupts disabled.
862 : : */
863 : 0 : static int hw_breakpoint_pending(unsigned long addr, unsigned int fsr,
864 : : struct pt_regs *regs)
865 : : {
866 : : int ret = 0;
867 : : u32 dscr;
868 : :
869 : 0 : preempt_disable();
870 : :
871 : 0 : if (interrupts_enabled(regs))
872 : 0 : local_irq_enable();
873 : :
874 : : /* We only handle watchpoints and hardware breakpoints. */
875 : 0 : ARM_DBG_READ(c0, c1, 0, dscr);
876 : :
877 : : /* Perform perf callbacks. */
878 : 0 : switch (ARM_DSCR_MOE(dscr)) {
879 : : case ARM_ENTRY_BREAKPOINT:
880 : 0 : breakpoint_handler(addr, regs);
881 : 0 : break;
882 : : case ARM_ENTRY_ASYNC_WATCHPOINT:
883 : 0 : WARN(1, "Asynchronous watchpoint exception taken. Debugging results may be unreliable\n");
884 : : /* Fall through */
885 : : case ARM_ENTRY_SYNC_WATCHPOINT:
886 : 0 : watchpoint_handler(addr, fsr, regs);
887 : 0 : break;
888 : : default:
889 : : ret = 1; /* Unhandled fault. */
890 : : }
891 : :
892 : 0 : preempt_enable();
893 : :
894 : 0 : return ret;
895 : : }
896 : :
897 : : /*
898 : : * One-time initialisation.
899 : : */
900 : : static cpumask_t debug_err_mask;
901 : :
902 : 0 : static int debug_reg_trap(struct pt_regs *regs, unsigned int instr)
903 : : {
904 : 0 : int cpu = smp_processor_id();
905 : :
906 : 0 : pr_warn("Debug register access (0x%x) caused undefined instruction on CPU %d\n",
907 : : instr, cpu);
908 : :
909 : : /* Set the error flag for this CPU and skip the faulting instruction. */
910 : : cpumask_set_cpu(cpu, &debug_err_mask);
911 : 0 : instruction_pointer(regs) += 4;
912 : 0 : return 0;
913 : : }
914 : :
915 : : static struct undef_hook debug_reg_hook = {
916 : : .instr_mask = 0x0fe80f10,
917 : : .instr_val = 0x0e000e10,
918 : : .fn = debug_reg_trap,
919 : : };
920 : :
921 : : /* Does this core support OS Save and Restore? */
922 : 3 : static bool core_has_os_save_restore(void)
923 : : {
924 : : u32 oslsr;
925 : :
926 : 3 : switch (get_debug_arch()) {
927 : : case ARM_DEBUG_ARCH_V7_1:
928 : : return true;
929 : : case ARM_DEBUG_ARCH_V7_ECP14:
930 : 0 : ARM_DBG_READ(c1, c1, 4, oslsr);
931 : 0 : if (oslsr & ARM_OSLSR_OSLM0)
932 : : return true;
933 : : /* Else, fall through */
934 : : default:
935 : 0 : return false;
936 : : }
937 : : }
938 : :
939 : 3 : static void reset_ctrl_regs(unsigned int cpu)
940 : : {
941 : : int i, raw_num_brps, err = 0;
942 : : u32 val;
943 : :
944 : : /*
945 : : * v7 debug contains save and restore registers so that debug state
946 : : * can be maintained across low-power modes without leaving the debug
947 : : * logic powered up. It is IMPLEMENTATION DEFINED whether we can access
948 : : * the debug registers out of reset, so we must unlock the OS Lock
949 : : * Access Register to avoid taking undefined instruction exceptions
950 : : * later on.
951 : : */
952 : 3 : switch (debug_arch) {
953 : : case ARM_DEBUG_ARCH_V6:
954 : : case ARM_DEBUG_ARCH_V6_1:
955 : : /* ARMv6 cores clear the registers out of reset. */
956 : : goto out_mdbgen;
957 : : case ARM_DEBUG_ARCH_V7_ECP14:
958 : : /*
959 : : * Ensure sticky power-down is clear (i.e. debug logic is
960 : : * powered up).
961 : : */
962 : 0 : ARM_DBG_READ(c1, c5, 4, val);
963 : 0 : if ((val & 0x1) == 0)
964 : : err = -EPERM;
965 : :
966 : 0 : if (!has_ossr)
967 : : goto clear_vcr;
968 : : break;
969 : : case ARM_DEBUG_ARCH_V7_1:
970 : : /*
971 : : * Ensure the OS double lock is clear.
972 : : */
973 : 3 : ARM_DBG_READ(c1, c3, 4, val);
974 : 3 : if ((val & 0x1) == 1)
975 : : err = -EPERM;
976 : : break;
977 : : }
978 : :
979 : 3 : if (err) {
980 : 1 : pr_warn_once("CPU %d debug is powered down!\n", cpu);
981 : : cpumask_or(&debug_err_mask, &debug_err_mask, cpumask_of(cpu));
982 : : return;
983 : : }
984 : :
985 : : /*
986 : : * Unconditionally clear the OS lock by writing a value
987 : : * other than CS_LAR_KEY to the access register.
988 : : */
989 : 3 : ARM_DBG_WRITE(c1, c0, 4, ~CORESIGHT_UNLOCK);
990 : 3 : isb();
991 : :
992 : : /*
993 : : * Clear any configured vector-catch events before
994 : : * enabling monitor mode.
995 : : */
996 : : clear_vcr:
997 : 3 : ARM_DBG_WRITE(c0, c7, 0, 0);
998 : 3 : isb();
999 : :
1000 : 3 : if (cpumask_intersects(&debug_err_mask, cpumask_of(cpu))) {
1001 : 0 : pr_warn_once("CPU %d failed to disable vector catch\n", cpu);
1002 : : return;
1003 : : }
1004 : :
1005 : : /*
1006 : : * The control/value register pairs are UNKNOWN out of reset so
1007 : : * clear them to avoid spurious debug events.
1008 : : */
1009 : : raw_num_brps = get_num_brp_resources();
1010 : 3 : for (i = 0; i < raw_num_brps; ++i) {
1011 : 3 : write_wb_reg(ARM_BASE_BCR + i, 0UL);
1012 : 3 : write_wb_reg(ARM_BASE_BVR + i, 0UL);
1013 : : }
1014 : :
1015 : 3 : for (i = 0; i < core_num_wrps; ++i) {
1016 : 3 : write_wb_reg(ARM_BASE_WCR + i, 0UL);
1017 : 3 : write_wb_reg(ARM_BASE_WVR + i, 0UL);
1018 : : }
1019 : :
1020 : 3 : if (cpumask_intersects(&debug_err_mask, cpumask_of(cpu))) {
1021 : 0 : pr_warn_once("CPU %d failed to clear debug register pairs\n", cpu);
1022 : : return;
1023 : : }
1024 : :
1025 : : /*
1026 : : * Have a crack at enabling monitor mode. We don't actually need
1027 : : * it yet, but reporting an error early is useful if it fails.
1028 : : */
1029 : : out_mdbgen:
1030 : 3 : if (enable_monitor_mode())
1031 : : cpumask_or(&debug_err_mask, &debug_err_mask, cpumask_of(cpu));
1032 : : }
1033 : :
1034 : 3 : static int dbg_reset_online(unsigned int cpu)
1035 : : {
1036 : 3 : local_irq_disable();
1037 : 3 : reset_ctrl_regs(cpu);
1038 : 3 : local_irq_enable();
1039 : 3 : return 0;
1040 : : }
1041 : :
1042 : : #ifdef CONFIG_CPU_PM
1043 : : static int dbg_cpu_pm_notify(struct notifier_block *self, unsigned long action,
1044 : : void *v)
1045 : : {
1046 : : if (action == CPU_PM_EXIT)
1047 : : reset_ctrl_regs(smp_processor_id());
1048 : :
1049 : : return NOTIFY_OK;
1050 : : }
1051 : :
1052 : : static struct notifier_block dbg_cpu_pm_nb = {
1053 : : .notifier_call = dbg_cpu_pm_notify,
1054 : : };
1055 : :
1056 : : static void __init pm_init(void)
1057 : : {
1058 : : cpu_pm_register_notifier(&dbg_cpu_pm_nb);
1059 : : }
1060 : : #else
1061 : : static inline void pm_init(void)
1062 : : {
1063 : : }
1064 : : #endif
1065 : :
1066 : 3 : static int __init arch_hw_breakpoint_init(void)
1067 : : {
1068 : : int ret;
1069 : :
1070 : 3 : debug_arch = get_debug_arch();
1071 : :
1072 : 3 : if (!debug_arch_supported()) {
1073 : 0 : pr_info("debug architecture 0x%x unsupported.\n", debug_arch);
1074 : 0 : return 0;
1075 : : }
1076 : :
1077 : : /*
1078 : : * Scorpion CPUs (at least those in APQ8060) seem to set DBGPRSR.SPD
1079 : : * whenever a WFI is issued, even if the core is not powered down, in
1080 : : * violation of the architecture. When DBGPRSR.SPD is set, accesses to
1081 : : * breakpoint and watchpoint registers are treated as undefined, so
1082 : : * this results in boot time and runtime failures when these are
1083 : : * accessed and we unexpectedly take a trap.
1084 : : *
1085 : : * It's not clear if/how this can be worked around, so we blacklist
1086 : : * Scorpion CPUs to avoid these issues.
1087 : : */
1088 : 3 : if (read_cpuid_part() == ARM_CPU_PART_SCORPION) {
1089 : 0 : pr_info("Scorpion CPU detected. Hardware breakpoints and watchpoints disabled\n");
1090 : 0 : return 0;
1091 : : }
1092 : :
1093 : 3 : has_ossr = core_has_os_save_restore();
1094 : :
1095 : : /* Determine how many BRPs/WRPs are available. */
1096 : 3 : core_num_brps = get_num_brps();
1097 : 3 : core_num_wrps = get_num_wrps();
1098 : :
1099 : : /*
1100 : : * We need to tread carefully here because DBGSWENABLE may be
1101 : : * driven low on this core and there isn't an architected way to
1102 : : * determine that.
1103 : : */
1104 : : cpus_read_lock();
1105 : 3 : register_undef_hook(&debug_reg_hook);
1106 : :
1107 : : /*
1108 : : * Register CPU notifier which resets the breakpoint resources. We
1109 : : * assume that a halting debugger will leave the world in a nice state
1110 : : * for us.
1111 : : */
1112 : : ret = cpuhp_setup_state_cpuslocked(CPUHP_AP_ONLINE_DYN,
1113 : : "arm/hw_breakpoint:online",
1114 : : dbg_reset_online, NULL);
1115 : 3 : unregister_undef_hook(&debug_reg_hook);
1116 : 3 : if (WARN_ON(ret < 0) || !cpumask_empty(&debug_err_mask)) {
1117 : 1 : core_num_brps = 0;
1118 : 1 : core_num_wrps = 0;
1119 : 1 : if (ret > 0)
1120 : : cpuhp_remove_state_nocalls_cpuslocked(ret);
1121 : : cpus_read_unlock();
1122 : : return 0;
1123 : : }
1124 : :
1125 : 2 : pr_info("found %d " "%s" "breakpoint and %d watchpoint registers.\n",
1126 : : core_num_brps, core_has_mismatch_brps() ? "(+1 reserved) " :
1127 : : "", core_num_wrps);
1128 : :
1129 : : /* Work out the maximum supported watchpoint length. */
1130 : 2 : max_watchpoint_len = get_max_wp_len();
1131 : 2 : pr_info("maximum watchpoint size is %u bytes.\n",
1132 : : max_watchpoint_len);
1133 : :
1134 : : /* Register debug fault handler. */
1135 : 2 : hook_fault_code(FAULT_CODE_DEBUG, hw_breakpoint_pending, SIGTRAP,
1136 : : TRAP_HWBKPT, "watchpoint debug exception");
1137 : 2 : hook_ifault_code(FAULT_CODE_DEBUG, hw_breakpoint_pending, SIGTRAP,
1138 : : TRAP_HWBKPT, "breakpoint debug exception");
1139 : : cpus_read_unlock();
1140 : :
1141 : : /* Register PM notifiers. */
1142 : : pm_init();
1143 : 2 : return 0;
1144 : : }
1145 : : arch_initcall(arch_hw_breakpoint_init);
1146 : :
1147 : 0 : void hw_breakpoint_pmu_read(struct perf_event *bp)
1148 : : {
1149 : 0 : }
1150 : :
1151 : : /*
1152 : : * Dummy function to register with die_notifier.
1153 : : */
1154 : 0 : int hw_breakpoint_exceptions_notify(struct notifier_block *unused,
1155 : : unsigned long val, void *data)
1156 : : {
1157 : 0 : return NOTIFY_DONE;
1158 : : }
|
