LCOV - code coverage report
Current view: top level - arch/arm/kernel - hw_breakpoint.c (source / functions) Hit Total Coverage
Test: Real Lines: 95 321 29.6 %
Date: 2020-10-17 15:46:43 Functions: 4 28 14.3 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           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                 :            : }
    

Generated by: LCOV version 1.14