arch/powerpc/kernel/hw_breakpoint.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * HW_breakpoint: a unified kernel/user-space hardware breakpoint facility,
   4  * using the CPU's debug registers. Derived from
   5  * "arch/x86/kernel/hw_breakpoint.c"
   6  *
   7  * Copyright 2010 IBM Corporation
   8  * Author: K.Prasad <prasad@linux.vnet.ibm.com>
   9  */
  10
  11 #include <linux/hw_breakpoint.h>
  12 #include <linux/notifier.h>
  13 #include <linux/kprobes.h>
  14 #include <linux/percpu.h>
  15 #include <linux/kernel.h>
  16 #include <linux/sched.h>
  17 #include <linux/smp.h>
  18 #include <linux/debugfs.h>
  19 #include <linux/init.h>
  20
  21 #include <asm/hw_breakpoint.h>
  22 #include <asm/processor.h>
  23 #include <asm/sstep.h>
  24 #include <asm/debug.h>
  25 #include <asm/debugfs.h>
  26 #include <asm/hvcall.h>
  27 #include <asm/inst.h>
  28 #include <linux/uaccess.h>
  29
  30 /*
  31  * Stores the breakpoints currently in use on each breakpoint address
  32  * register for every cpu
  33  */
  34 static DEFINE_PER_CPU(struct perf_event *, bp_per_reg[HBP_NUM_MAX]);
  35
  36 /*
  37  * Returns total number of data or instruction breakpoints available.
  38  */
  39 int hw_breakpoint_slots(int type)
  40 {
  41         if (type == TYPE_DATA)
  42                 return nr_wp_slots();
  43         return 0;               /* no instruction breakpoints available */
  44 }
  45
  46 static bool single_step_pending(void)
  47 {
  48         int i;
  49
  50         for (i = 0; i < nr_wp_slots(); i++) {
  51                 if (current->thread.last_hit_ubp[i])
  52                         return true;
  53         }
  54         return false;
  55 }
  56
  57 /*
  58  * Install a perf counter breakpoint.
  59  *
  60  * We seek a free debug address register and use it for this
  61  * breakpoint.
  62  *
  63  * Atomic: we hold the counter->ctx->lock and we only handle variables
  64  * and registers local to this cpu.
  65  */
  66 int arch_install_hw_breakpoint(struct perf_event *bp)
  67 {
  68         struct arch_hw_breakpoint *info = counter_arch_bp(bp);
  69         struct perf_event **slot;
  70         int i;
  71
  72         for (i = 0; i < nr_wp_slots(); i++) {
  73                 slot = this_cpu_ptr(&bp_per_reg[i]);
  74                 if (!*slot) {
  75                         *slot = bp;
  76                         break;
  77                 }
  78         }
  79
  80         if (WARN_ONCE(i == nr_wp_slots(), "Can't find any breakpoint slot"))
  81                 return -EBUSY;
  82
  83         /*
  84          * Do not install DABR values if the instruction must be single-stepped.
  85          * If so, DABR will be populated in single_step_dabr_instruction().
  86          */
  87         if (!single_step_pending())
  88                 __set_breakpoint(i, info);
  89
  90         return 0;
  91 }
  92
  93 /*
  94  * Uninstall the breakpoint contained in the given counter.
  95  *
  96  * First we search the debug address register it uses and then we disable
  97  * it.
  98  *
  99  * Atomic: we hold the counter->ctx->lock and we only handle variables
 100  * and registers local to this cpu.
 101  */
 102 void arch_uninstall_hw_breakpoint(struct perf_event *bp)
 103 {
 104         struct arch_hw_breakpoint null_brk = {0};
 105         struct perf_event **slot;
 106         int i;
 107
 108         for (i = 0; i < nr_wp_slots(); i++) {
 109                 slot = this_cpu_ptr(&bp_per_reg[i]);
 110                 if (*slot == bp) {
 111                         *slot = NULL;
 112                         break;
 113                 }
 114         }
 115
 116         if (WARN_ONCE(i == nr_wp_slots(), "Can't find any breakpoint slot"))
 117                 return;
 118
 119         __set_breakpoint(i, &null_brk);
 120 }
 121
 122 static bool is_ptrace_bp(struct perf_event *bp)
 123 {
 124         return bp->overflow_handler == ptrace_triggered;
 125 }
 126
 127 struct breakpoint {
 128         struct list_head list;
 129         struct perf_event *bp;
 130         bool ptrace_bp;
 131 };
 132
 133 static DEFINE_PER_CPU(struct breakpoint *, cpu_bps[HBP_NUM_MAX]);
 134 static LIST_HEAD(task_bps);
 135
 136 static struct breakpoint *alloc_breakpoint(struct perf_event *bp)
 137 {
 138         struct breakpoint *tmp;
 139
 140         tmp = kzalloc(sizeof(*tmp), GFP_KERNEL);
 141         if (!tmp)
 142                 return ERR_PTR(-ENOMEM);
 143         tmp->bp = bp;
 144         tmp->ptrace_bp = is_ptrace_bp(bp);
 145         return tmp;
 146 }
 147
 148 static bool bp_addr_range_overlap(struct perf_event *bp1, struct perf_event *bp2)
 149 {
 150         __u64 bp1_saddr, bp1_eaddr, bp2_saddr, bp2_eaddr;
 151
 152         bp1_saddr = ALIGN_DOWN(bp1->attr.bp_addr, HW_BREAKPOINT_SIZE);
 153         bp1_eaddr = ALIGN(bp1->attr.bp_addr + bp1->attr.bp_len, HW_BREAKPOINT_SIZE);
 154         bp2_saddr = ALIGN_DOWN(bp2->attr.bp_addr, HW_BREAKPOINT_SIZE);
 155         bp2_eaddr = ALIGN(bp2->attr.bp_addr + bp2->attr.bp_len, HW_BREAKPOINT_SIZE);
 156
 157         return (bp1_saddr < bp2_eaddr && bp1_eaddr > bp2_saddr);
 158 }
 159
 160 static bool alternate_infra_bp(struct breakpoint *b, struct perf_event *bp)
 161 {
 162         return is_ptrace_bp(bp) ? !b->ptrace_bp : b->ptrace_bp;
 163 }
 164
 165 static bool can_co_exist(struct breakpoint *b, struct perf_event *bp)
 166 {
 167         return !(alternate_infra_bp(b, bp) && bp_addr_range_overlap(b->bp, bp));
 168 }
 169
 170 static int task_bps_add(struct perf_event *bp)
 171 {
 172         struct breakpoint *tmp;
 173
 174         tmp = alloc_breakpoint(bp);
 175         if (IS_ERR(tmp))
 176                 return PTR_ERR(tmp);
 177
 178         list_add(&tmp->list, &task_bps);
 179         return 0;
 180 }
 181
 182 static void task_bps_remove(struct perf_event *bp)
 183 {
 184         struct list_head *pos, *q;
 185
 186         list_for_each_safe(pos, q, &task_bps) {
 187                 struct breakpoint *tmp = list_entry(pos, struct breakpoint, list);
 188
 189                 if (tmp->bp == bp) {
 190                         list_del(&tmp->list);
 191                         kfree(tmp);
 192                         break;
 193                 }
 194         }
 195 }
 196
 197 /*
 198  * If any task has breakpoint from alternate infrastructure,
 199  * return true. Otherwise return false.
 200  */
 201 static bool all_task_bps_check(struct perf_event *bp)
 202 {
 203         struct breakpoint *tmp;
 204
 205         list_for_each_entry(tmp, &task_bps, list) {
 206                 if (!can_co_exist(tmp, bp))
 207                         return true;
 208         }
 209         return false;
 210 }
 211
 212 /*
 213  * If same task has breakpoint from alternate infrastructure,
 214  * return true. Otherwise return false.
 215  */
 216 static bool same_task_bps_check(struct perf_event *bp)
 217 {
 218         struct breakpoint *tmp;
 219
 220         list_for_each_entry(tmp, &task_bps, list) {
 221                 if (tmp->bp->hw.target == bp->hw.target &&
 222                     !can_co_exist(tmp, bp))
 223                         return true;
 224         }
 225         return false;
 226 }
 227
 228 static int cpu_bps_add(struct perf_event *bp)
 229 {
 230         struct breakpoint **cpu_bp;
 231         struct breakpoint *tmp;
 232         int i = 0;
 233
 234         tmp = alloc_breakpoint(bp);
 235         if (IS_ERR(tmp))
 236                 return PTR_ERR(tmp);
 237
 238         cpu_bp = per_cpu_ptr(cpu_bps, bp->cpu);
 239         for (i = 0; i < nr_wp_slots(); i++) {
 240                 if (!cpu_bp[i]) {
 241                         cpu_bp[i] = tmp;
 242                         break;
 243                 }
 244         }
 245         return 0;
 246 }
 247
 248 static void cpu_bps_remove(struct perf_event *bp)
 249 {
 250         struct breakpoint **cpu_bp;
 251         int i = 0;
 252
 253         cpu_bp = per_cpu_ptr(cpu_bps, bp->cpu);
 254         for (i = 0; i < nr_wp_slots(); i++) {
 255                 if (!cpu_bp[i])
 256                         continue;
 257
 258                 if (cpu_bp[i]->bp == bp) {
 259                         kfree(cpu_bp[i]);
 260                         cpu_bp[i] = NULL;
 261                         break;
 262                 }
 263         }
 264 }
 265
 266 static bool cpu_bps_check(int cpu, struct perf_event *bp)
 267 {
 268         struct breakpoint **cpu_bp;
 269         int i;
 270
 271         cpu_bp = per_cpu_ptr(cpu_bps, cpu);
 272         for (i = 0; i < nr_wp_slots(); i++) {
 273                 if (cpu_bp[i] && !can_co_exist(cpu_bp[i], bp))
 274                         return true;
 275         }
 276         return false;
 277 }
 278
 279 static bool all_cpu_bps_check(struct perf_event *bp)
 280 {
 281         int cpu;
 282
 283         for_each_online_cpu(cpu) {
 284                 if (cpu_bps_check(cpu, bp))
 285                         return true;
 286         }
 287         return false;
 288 }
 289
 290 /*
 291  * We don't use any locks to serialize accesses to cpu_bps or task_bps
 292  * because are already inside nr_bp_mutex.
 293  */
 294 int arch_reserve_bp_slot(struct perf_event *bp)
 295 {
 296         int ret;
 297
 298         /* ptrace breakpoint */
 299         if (is_ptrace_bp(bp)) {
 300                 if (all_cpu_bps_check(bp))
 301                         return -ENOSPC;
 302
 303                 if (same_task_bps_check(bp))
 304                         return -ENOSPC;
 305
 306                 return task_bps_add(bp);
 307         }
 308
 309         /* perf breakpoint */
 310         if (is_kernel_addr(bp->attr.bp_addr))
 311                 return 0;
 312
 313         if (bp->hw.target && bp->cpu == -1) {
 314                 if (same_task_bps_check(bp))
 315                         return -ENOSPC;
 316
 317                 return task_bps_add(bp);
 318         } else if (!bp->hw.target && bp->cpu != -1) {
 319                 if (all_task_bps_check(bp))
 320                         return -ENOSPC;
 321
 322                 return cpu_bps_add(bp);
 323         }
 324
 325         if (same_task_bps_check(bp))
 326                 return -ENOSPC;
 327
 328         ret = cpu_bps_add(bp);
 329         if (ret)
 330                 return ret;
 331         ret = task_bps_add(bp);
 332         if (ret)
 333                 cpu_bps_remove(bp);
 334
 335         return ret;
 336 }
 337
 338 void arch_release_bp_slot(struct perf_event *bp)
 339 {
 340         if (!is_kernel_addr(bp->attr.bp_addr)) {
 341                 if (bp->hw.target)
 342                         task_bps_remove(bp);
 343                 if (bp->cpu != -1)
 344                         cpu_bps_remove(bp);
 345         }
 346 }
 347
 348 /*
 349  * Perform cleanup of arch-specific counters during unregistration
 350  * of the perf-event
 351  */
 352 void arch_unregister_hw_breakpoint(struct perf_event *bp)
 353 {
 354         /*
 355          * If the breakpoint is unregistered between a hw_breakpoint_handler()
 356          * and the single_step_dabr_instruction(), then cleanup the breakpoint
 357          * restoration variables to prevent dangling pointers.
 358          * FIXME, this should not be using bp->ctx at all! Sayeth peterz.
 359          */
 360         if (bp->ctx && bp->ctx->task && bp->ctx->task != ((void *)-1L)) {
 361                 int i;
 362
 363                 for (i = 0; i < nr_wp_slots(); i++) {
 364                         if (bp->ctx->task->thread.last_hit_ubp[i] == bp)
 365                                 bp->ctx->task->thread.last_hit_ubp[i] = NULL;
 366                 }
 367         }
 368 }
 369
 370 /*
 371  * Check for virtual address in kernel space.
 372  */
 373 int arch_check_bp_in_kernelspace(struct arch_hw_breakpoint *hw)
 374 {
 375         return is_kernel_addr(hw->address);
 376 }
 377
 378 int arch_bp_generic_fields(int type, int *gen_bp_type)
 379 {
 380         *gen_bp_type = 0;
 381         if (type & HW_BRK_TYPE_READ)
 382                 *gen_bp_type |= HW_BREAKPOINT_R;
 383         if (type & HW_BRK_TYPE_WRITE)
 384                 *gen_bp_type |= HW_BREAKPOINT_W;
 385         if (*gen_bp_type == 0)
 386                 return -EINVAL;
 387         return 0;
 388 }
 389
 390 /*
 391  * Watchpoint match range is always doubleword(8 bytes) aligned on
 392  * powerpc. If the given range is crossing doubleword boundary, we
 393  * need to increase the length such that next doubleword also get
 394  * covered. Ex,
 395  *
 396  *          address   len = 6 bytes
 397  *                |=========.
 398  *   |------------v--|------v--------|
 399  *   | | | | | | | | | | | | | | | | |
 400  *   |---------------|---------------|
 401  *    <---8 bytes--->
 402  *
 403  * In this case, we should configure hw as:
 404  *   start_addr = address & ~(HW_BREAKPOINT_SIZE - 1)
 405  *   len = 16 bytes
 406  *
 407  * @start_addr is inclusive but @end_addr is exclusive.
 408  */
 409 static int hw_breakpoint_validate_len(struct arch_hw_breakpoint *hw)
 410 {
 411         u16 max_len = DABR_MAX_LEN;
 412         u16 hw_len;
 413         unsigned long start_addr, end_addr;
 414
 415         start_addr = ALIGN_DOWN(hw->address, HW_BREAKPOINT_SIZE);
 416         end_addr = ALIGN(hw->address + hw->len, HW_BREAKPOINT_SIZE);
 417         hw_len = end_addr - start_addr;
 418
 419         if (dawr_enabled()) {
 420                 max_len = DAWR_MAX_LEN;
 421                 /* DAWR region can't cross 512 bytes boundary on p10 predecessors */
 422                 if (!cpu_has_feature(CPU_FTR_ARCH_31) &&
 423                     (ALIGN_DOWN(start_addr, SZ_512) != ALIGN_DOWN(end_addr - 1, SZ_512)))
 424                         return -EINVAL;
 425         } else if (IS_ENABLED(CONFIG_PPC_8xx)) {
 426                 /* 8xx can setup a range without limitation */
 427                 max_len = U16_MAX;
 428         }
 429
 430         if (hw_len > max_len)
 431                 return -EINVAL;
 432
 433         hw->hw_len = hw_len;
 434         return 0;
 435 }
 436
 437 /*
 438  * Validate the arch-specific HW Breakpoint register settings
 439  */
 440 int hw_breakpoint_arch_parse(struct perf_event *bp,
 441                              const struct perf_event_attr *attr,
 442                              struct arch_hw_breakpoint *hw)
 443 {
 444         int ret = -EINVAL;
 445
 446         if (!bp || !attr->bp_len)
 447                 return ret;
 448
 449         hw->type = HW_BRK_TYPE_TRANSLATE;
 450         if (attr->bp_type & HW_BREAKPOINT_R)
 451                 hw->type |= HW_BRK_TYPE_READ;
 452         if (attr->bp_type & HW_BREAKPOINT_W)
 453                 hw->type |= HW_BRK_TYPE_WRITE;
 454         if (hw->type == HW_BRK_TYPE_TRANSLATE)
 455                 /* must set alteast read or write */
 456                 return ret;
 457         if (!attr->exclude_user)
 458                 hw->type |= HW_BRK_TYPE_USER;
 459         if (!attr->exclude_kernel)
 460                 hw->type |= HW_BRK_TYPE_KERNEL;
 461         if (!attr->exclude_hv)
 462                 hw->type |= HW_BRK_TYPE_HYP;
 463         hw->address = attr->bp_addr;
 464         hw->len = attr->bp_len;
 465
 466         if (!ppc_breakpoint_available())
 467                 return -ENODEV;
 468
 469         return hw_breakpoint_validate_len(hw);
 470 }
 471
 472 /*
 473  * Restores the breakpoint on the debug registers.
 474  * Invoke this function if it is known that the execution context is
 475  * about to change to cause loss of MSR_SE settings.
 476  */
 477 void thread_change_pc(struct task_struct *tsk, struct pt_regs *regs)
 478 {
 479         struct arch_hw_breakpoint *info;
 480         int i;
 481
 482         for (i = 0; i < nr_wp_slots(); i++) {
 483                 if (unlikely(tsk->thread.last_hit_ubp[i]))
 484                         goto reset;
 485         }
 486         return;
 487
 488 reset:
 489         regs_set_return_msr(regs, regs->msr & ~MSR_SE);
 490         for (i = 0; i < nr_wp_slots(); i++) {
 491                 info = counter_arch_bp(__this_cpu_read(bp_per_reg[i]));
 492                 __set_breakpoint(i, info);
 493                 tsk->thread.last_hit_ubp[i] = NULL;
 494         }
 495 }
 496
 497 static bool is_larx_stcx_instr(int type)
 498 {
 499         return type == LARX || type == STCX;
 500 }
 501
 502 static bool is_octword_vsx_instr(int type, int size)
 503 {
 504         return ((type == LOAD_VSX || type == STORE_VSX) && size == 32);
 505 }
 506
 507 /*
 508  * We've failed in reliably handling the hw-breakpoint. Unregister
 509  * it and throw a warning message to let the user know about it.
 510  */
 511 static void handler_error(struct perf_event *bp, struct arch_hw_breakpoint *info)
 512 {
 513         WARN(1, "Unable to handle hardware breakpoint. Breakpoint at 0x%lx will be disabled.",
 514              info->address);
 515         perf_event_disable_inatomic(bp);
 516 }
 517
 518 static void larx_stcx_err(struct perf_event *bp, struct arch_hw_breakpoint *info)
 519 {
 520         printk_ratelimited("Breakpoint hit on instruction that can't be emulated. Breakpoint at 0x%lx will be disabled.\n",
 521                            info->address);
 522         perf_event_disable_inatomic(bp);
 523 }
 524
 525 static bool stepping_handler(struct pt_regs *regs, struct perf_event **bp,
 526                              struct arch_hw_breakpoint **info, int *hit,
 527                              struct ppc_inst instr)
 528 {
 529         int i;
 530         int stepped;
 531
 532         /* Do not emulate user-space instructions, instead single-step them */
 533         if (user_mode(regs)) {
 534                 for (i = 0; i < nr_wp_slots(); i++) {
 535                         if (!hit[i])
 536                                 continue;
 537                         current->thread.last_hit_ubp[i] = bp[i];
 538                         info[i] = NULL;
 539                 }
 540                 regs_set_return_msr(regs, regs->msr | MSR_SE);
 541                 return false;
 542         }
 543
 544         stepped = emulate_step(regs, instr);
 545         if (!stepped) {
 546                 for (i = 0; i < nr_wp_slots(); i++) {
 547                         if (!hit[i])
 548                                 continue;
 549                         handler_error(bp[i], info[i]);
 550                         info[i] = NULL;
 551                 }
 552                 return false;
 553         }
 554         return true;
 555 }
 556
 557 static void handle_p10dd1_spurious_exception(struct arch_hw_breakpoint **info,
 558                                              int *hit, unsigned long ea)
 559 {
 560         int i;
 561         unsigned long hw_end_addr;
 562
 563         /*
 564          * Handle spurious exception only when any bp_per_reg is set.
 565          * Otherwise this might be created by xmon and not actually a
 566          * spurious exception.
 567          */
 568         for (i = 0; i < nr_wp_slots(); i++) {
 569                 if (!info[i])
 570                         continue;
 571
 572                 hw_end_addr = ALIGN(info[i]->address + info[i]->len, HW_BREAKPOINT_SIZE);
 573
 574                 /*
 575                  * Ending address of DAWR range is less than starting
 576                  * address of op.
 577                  */
 578                 if ((hw_end_addr - 1) >= ea)
 579                         continue;
 580
 581                 /*
 582                  * Those addresses need to be in the same or in two
 583                  * consecutive 512B blocks;
 584                  */
 585                 if (((hw_end_addr - 1) >> 10) != (ea >> 10))
 586                         continue;
 587
 588                 /*
 589                  * 'op address + 64B' generates an address that has a
 590                  * carry into bit 52 (crosses 2K boundary).
 591                  */
 592                 if ((ea & 0x800) == ((ea + 64) & 0x800))
 593                         continue;
 594
 595                 break;
 596         }
 597
 598         if (i == nr_wp_slots())
 599                 return;
 600
 601         for (i = 0; i < nr_wp_slots(); i++) {
 602                 if (info[i]) {
 603                         hit[i] = 1;
 604                         info[i]->type |= HW_BRK_TYPE_EXTRANEOUS_IRQ;
 605                 }
 606         }
 607 }
 608
 609 int hw_breakpoint_handler(struct die_args *args)
 610 {
 611         bool err = false;
 612         int rc = NOTIFY_STOP;
 613         struct perf_event *bp[HBP_NUM_MAX] = { NULL };
 614         struct pt_regs *regs = args->regs;
 615         struct arch_hw_breakpoint *info[HBP_NUM_MAX] = { NULL };
 616         int i;
 617         int hit[HBP_NUM_MAX] = {0};
 618         int nr_hit = 0;
 619         bool ptrace_bp = false;
 620         struct ppc_inst instr = ppc_inst(0);
 621         int type = 0;
 622         int size = 0;
 623         unsigned long ea;
 624
 625         /* Disable breakpoints during exception handling */
 626         hw_breakpoint_disable();
 627
 628         /*
 629          * The counter may be concurrently released but that can only
 630          * occur from a call_rcu() path. We can then safely fetch
 631          * the breakpoint, use its callback, touch its counter
 632          * while we are in an rcu_read_lock() path.
 633          */
 634         rcu_read_lock();
 635
 636         if (!IS_ENABLED(CONFIG_PPC_8xx))
 637                 wp_get_instr_detail(regs, &instr, &type, &size, &ea);
 638
 639         for (i = 0; i < nr_wp_slots(); i++) {
 640                 bp[i] = __this_cpu_read(bp_per_reg[i]);
 641                 if (!bp[i])
 642                         continue;
 643
 644                 info[i] = counter_arch_bp(bp[i]);
 645                 info[i]->type &= ~HW_BRK_TYPE_EXTRANEOUS_IRQ;
 646
 647                 if (wp_check_constraints(regs, instr, ea, type, size, info[i])) {
 648                         if (!IS_ENABLED(CONFIG_PPC_8xx) &&
 649                             ppc_inst_equal(instr, ppc_inst(0))) {
 650                                 handler_error(bp[i], info[i]);
 651                                 info[i] = NULL;
 652                                 err = 1;
 653                                 continue;
 654                         }
 655
 656                         if (is_ptrace_bp(bp[i]))
 657                                 ptrace_bp = true;
 658                         hit[i] = 1;
 659                         nr_hit++;
 660                 }
 661         }
 662
 663         if (err)
 664                 goto reset;
 665
 666         if (!nr_hit) {
 667                 /* Workaround for Power10 DD1 */
 668                 if (!IS_ENABLED(CONFIG_PPC_8xx) && mfspr(SPRN_PVR) == 0x800100 &&
 669                     is_octword_vsx_instr(type, size)) {
 670                         handle_p10dd1_spurious_exception(info, hit, ea);
 671                 } else {
 672                         rc = NOTIFY_DONE;
 673                         goto out;
 674                 }
 675         }
 676
 677         /*
 678          * Return early after invoking user-callback function without restoring
 679          * DABR if the breakpoint is from ptrace which always operates in
 680          * one-shot mode. The ptrace-ed process will receive the SIGTRAP signal
 681          * generated in do_dabr().
 682          */
 683         if (ptrace_bp) {
 684                 for (i = 0; i < nr_wp_slots(); i++) {
 685                         if (!hit[i])
 686                                 continue;
 687                         perf_bp_event(bp[i], regs);
 688                         info[i] = NULL;
 689                 }
 690                 rc = NOTIFY_DONE;
 691                 goto reset;
 692         }
 693
 694         if (!IS_ENABLED(CONFIG_PPC_8xx)) {
 695                 if (is_larx_stcx_instr(type)) {
 696                         for (i = 0; i < nr_wp_slots(); i++) {
 697                                 if (!hit[i])
 698                                         continue;
 699                                 larx_stcx_err(bp[i], info[i]);
 700                                 info[i] = NULL;
 701                         }
 702                         goto reset;
 703                 }
 704
 705                 if (!stepping_handler(regs, bp, info, hit, instr))
 706                         goto reset;
 707         }
 708
 709         /*
 710          * As a policy, the callback is invoked in a 'trigger-after-execute'
 711          * fashion
 712          */
 713         for (i = 0; i < nr_wp_slots(); i++) {
 714                 if (!hit[i])
 715                         continue;
 716                 if (!(info[i]->type & HW_BRK_TYPE_EXTRANEOUS_IRQ))
 717                         perf_bp_event(bp[i], regs);
 718         }
 719
 720 reset:
 721         for (i = 0; i < nr_wp_slots(); i++) {
 722                 if (!info[i])
 723                         continue;
 724                 __set_breakpoint(i, info[i]);
 725         }
 726
 727 out:
 728         rcu_read_unlock();
 729         return rc;
 730 }
 731 NOKPROBE_SYMBOL(hw_breakpoint_handler);
 732
 733 /*
 734  * Handle single-step exceptions following a DABR hit.
 735  */
 736 static int single_step_dabr_instruction(struct die_args *args)
 737 {
 738         struct pt_regs *regs = args->regs;
 739         struct perf_event *bp = NULL;
 740         struct arch_hw_breakpoint *info;
 741         int i;
 742         bool found = false;
 743
 744         /*
 745          * Check if we are single-stepping as a result of a
 746          * previous HW Breakpoint exception
 747          */
 748         for (i = 0; i < nr_wp_slots(); i++) {
 749                 bp = current->thread.last_hit_ubp[i];
 750
 751                 if (!bp)
 752                         continue;
 753
 754                 found = true;
 755                 info = counter_arch_bp(bp);
 756
 757                 /*
 758                  * We shall invoke the user-defined callback function in the
 759                  * single stepping handler to confirm to 'trigger-after-execute'
 760                  * semantics
 761                  */
 762                 if (!(info->type & HW_BRK_TYPE_EXTRANEOUS_IRQ))
 763                         perf_bp_event(bp, regs);
 764                 current->thread.last_hit_ubp[i] = NULL;
 765         }
 766
 767         if (!found)
 768                 return NOTIFY_DONE;
 769
 770         for (i = 0; i < nr_wp_slots(); i++) {
 771                 bp = __this_cpu_read(bp_per_reg[i]);
 772                 if (!bp)
 773                         continue;
 774
 775                 info = counter_arch_bp(bp);
 776                 __set_breakpoint(i, info);
 777         }
 778
 779         /*
 780          * If the process was being single-stepped by ptrace, let the
 781          * other single-step actions occur (e.g. generate SIGTRAP).
 782          */
 783         if (test_thread_flag(TIF_SINGLESTEP))
 784                 return NOTIFY_DONE;
 785
 786         return NOTIFY_STOP;
 787 }
 788 NOKPROBE_SYMBOL(single_step_dabr_instruction);
 789
 790 /*
 791  * Handle debug exception notifications.
 792  */
 793 int hw_breakpoint_exceptions_notify(
 794                 struct notifier_block *unused, unsigned long val, void *data)
 795 {
 796         int ret = NOTIFY_DONE;
 797
 798         switch (val) {
 799         case DIE_DABR_MATCH:
 800                 ret = hw_breakpoint_handler(data);
 801                 break;
 802         case DIE_SSTEP:
 803                 ret = single_step_dabr_instruction(data);
 804                 break;
 805         }
 806
 807         return ret;
 808 }
 809 NOKPROBE_SYMBOL(hw_breakpoint_exceptions_notify);
 810
 811 /*
 812  * Release the user breakpoints used by ptrace
 813  */
 814 void flush_ptrace_hw_breakpoint(struct task_struct *tsk)
 815 {
 816         int i;
 817         struct thread_struct *t = &tsk->thread;
 818
 819         for (i = 0; i < nr_wp_slots(); i++) {
 820                 unregister_hw_breakpoint(t->ptrace_bps[i]);
 821                 t->ptrace_bps[i] = NULL;
 822         }
 823 }
 824
 825 void hw_breakpoint_pmu_read(struct perf_event *bp)
 826 {
 827         /* TODO */
 828 }
 829
 830 void ptrace_triggered(struct perf_event *bp,
 831                       struct perf_sample_data *data, struct pt_regs *regs)
 832 {
 833         struct perf_event_attr attr;
 834
 835         /*
 836          * Disable the breakpoint request here since ptrace has defined a
 837          * one-shot behaviour for breakpoint exceptions in PPC64.
 838          * The SIGTRAP signal is generated automatically for us in do_dabr().
 839          * We don't have to do anything about that here
 840          */
 841         attr = bp->attr;
 842         attr.disabled = true;
 843         modify_user_hw_breakpoint(bp, &attr);
 844 }