arch/arm64/kernel/debug-monitors.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * ARMv8 single-step debug support and mdscr context switching.
   4  *
   5  * Copyright (C) 2012 ARM Limited
   6  *
   7  * Author: Will Deacon <will.deacon@arm.com>
   8  */
   9
  10 #include <linux/cpu.h>
  11 #include <linux/debugfs.h>
  12 #include <linux/hardirq.h>
  13 #include <linux/init.h>
  14 #include <linux/ptrace.h>
  15 #include <linux/kprobes.h>
  16 #include <linux/stat.h>
  17 #include <linux/uaccess.h>
  18 #include <linux/sched/task_stack.h>
  19
  20 #include <asm/cpufeature.h>
  21 #include <asm/cputype.h>
  22 #include <asm/daifflags.h>
  23 #include <asm/debug-monitors.h>
  24 #include <asm/system_misc.h>
  25 #include <asm/traps.h>
  26
  27 /* Determine debug architecture. */
  28 u8 debug_monitors_arch(void)
  29 {
  30         return cpuid_feature_extract_unsigned_field(read_sanitised_ftr_reg(SYS_ID_AA64DFR0_EL1),
  31                                                 ID_AA64DFR0_EL1_DebugVer_SHIFT);
  32 }
  33
  34 /*
  35  * MDSCR access routines.
  36  */
  37 static void mdscr_write(u32 mdscr)
  38 {
  39         unsigned long flags;
  40         flags = local_daif_save();
  41         write_sysreg(mdscr, mdscr_el1);
  42         local_daif_restore(flags);
  43 }
  44 NOKPROBE_SYMBOL(mdscr_write);
  45
  46 static u32 mdscr_read(void)
  47 {
  48         return read_sysreg(mdscr_el1);
  49 }
  50 NOKPROBE_SYMBOL(mdscr_read);
  51
  52 /*
  53  * Allow root to disable self-hosted debug from userspace.
  54  * This is useful if you want to connect an external JTAG debugger.
  55  */
  56 static bool debug_enabled = true;
  57
  58 static int create_debug_debugfs_entry(void)
  59 {
  60         debugfs_create_bool("debug_enabled", 0644, NULL, &debug_enabled);
  61         return 0;
  62 }
  63 fs_initcall(create_debug_debugfs_entry);
  64
  65 static int __init early_debug_disable(char *buf)
  66 {
  67         debug_enabled = false;
  68         return 0;
  69 }
  70
  71 early_param("nodebugmon", early_debug_disable);
  72
  73 /*
  74  * Keep track of debug users on each core.
  75  * The ref counts are per-cpu so we use a local_t type.
  76  */
  77 static DEFINE_PER_CPU(int, mde_ref_count);
  78 static DEFINE_PER_CPU(int, kde_ref_count);
  79
  80 void enable_debug_monitors(enum dbg_active_el el)
  81 {
  82         u32 mdscr, enable = 0;
  83
  84         WARN_ON(preemptible());
  85
  86         if (this_cpu_inc_return(mde_ref_count) == 1)
  87                 enable = DBG_MDSCR_MDE;
  88
  89         if (el == DBG_ACTIVE_EL1 &&
  90             this_cpu_inc_return(kde_ref_count) == 1)
  91                 enable |= DBG_MDSCR_KDE;
  92
  93         if (enable && debug_enabled) {
  94                 mdscr = mdscr_read();
  95                 mdscr |= enable;
  96                 mdscr_write(mdscr);
  97         }
  98 }
  99 NOKPROBE_SYMBOL(enable_debug_monitors);
 100
 101 void disable_debug_monitors(enum dbg_active_el el)
 102 {
 103         u32 mdscr, disable = 0;
 104
 105         WARN_ON(preemptible());
 106
 107         if (this_cpu_dec_return(mde_ref_count) == 0)
 108                 disable = ~DBG_MDSCR_MDE;
 109
 110         if (el == DBG_ACTIVE_EL1 &&
 111             this_cpu_dec_return(kde_ref_count) == 0)
 112                 disable &= ~DBG_MDSCR_KDE;
 113
 114         if (disable) {
 115                 mdscr = mdscr_read();
 116                 mdscr &= disable;
 117                 mdscr_write(mdscr);
 118         }
 119 }
 120 NOKPROBE_SYMBOL(disable_debug_monitors);
 121
 122 /*
 123  * OS lock clearing.
 124  */
 125 static int clear_os_lock(unsigned int cpu)
 126 {
 127         write_sysreg(0, osdlr_el1);
 128         write_sysreg(0, oslar_el1);
 129         isb();
 130         return 0;
 131 }
 132
 133 static int __init debug_monitors_init(void)
 134 {
 135         return cpuhp_setup_state(CPUHP_AP_ARM64_DEBUG_MONITORS_STARTING,
 136                                  "arm64/debug_monitors:starting",
 137                                  clear_os_lock, NULL);
 138 }
 139 postcore_initcall(debug_monitors_init);
 140
 141 /*
 142  * Single step API and exception handling.
 143  */
 144 static void set_user_regs_spsr_ss(struct user_pt_regs *regs)
 145 {
 146         regs->pstate |= DBG_SPSR_SS;
 147 }
 148 NOKPROBE_SYMBOL(set_user_regs_spsr_ss);
 149
 150 static void clear_user_regs_spsr_ss(struct user_pt_regs *regs)
 151 {
 152         regs->pstate &= ~DBG_SPSR_SS;
 153 }
 154 NOKPROBE_SYMBOL(clear_user_regs_spsr_ss);
 155
 156 #define set_regs_spsr_ss(r)     set_user_regs_spsr_ss(&(r)->user_regs)
 157 #define clear_regs_spsr_ss(r)   clear_user_regs_spsr_ss(&(r)->user_regs)
 158
 159 static DEFINE_SPINLOCK(debug_hook_lock);
 160 static LIST_HEAD(user_step_hook);
 161 static LIST_HEAD(kernel_step_hook);
 162
 163 static void register_debug_hook(struct list_head *node, struct list_head *list)
 164 {
 165         spin_lock(&debug_hook_lock);
 166         list_add_rcu(node, list);
 167         spin_unlock(&debug_hook_lock);
 168
 169 }
 170
 171 static void unregister_debug_hook(struct list_head *node)
 172 {
 173         spin_lock(&debug_hook_lock);
 174         list_del_rcu(node);
 175         spin_unlock(&debug_hook_lock);
 176         synchronize_rcu();
 177 }
 178
 179 void register_user_step_hook(struct step_hook *hook)
 180 {
 181         register_debug_hook(&hook->node, &user_step_hook);
 182 }
 183
 184 void unregister_user_step_hook(struct step_hook *hook)
 185 {
 186         unregister_debug_hook(&hook->node);
 187 }
 188
 189 void register_kernel_step_hook(struct step_hook *hook)
 190 {
 191         register_debug_hook(&hook->node, &kernel_step_hook);
 192 }
 193
 194 void unregister_kernel_step_hook(struct step_hook *hook)
 195 {
 196         unregister_debug_hook(&hook->node);
 197 }
 198
 199 /*
 200  * Call registered single step handlers
 201  * There is no Syndrome info to check for determining the handler.
 202  * So we call all the registered handlers, until the right handler is
 203  * found which returns zero.
 204  */
 205 static int call_step_hook(struct pt_regs *regs, unsigned long esr)
 206 {
 207         struct step_hook *hook;
 208         struct list_head *list;
 209         int retval = DBG_HOOK_ERROR;
 210
 211         list = user_mode(regs) ? &user_step_hook : &kernel_step_hook;
 212
 213         /*
 214          * Since single-step exception disables interrupt, this function is
 215          * entirely not preemptible, and we can use rcu list safely here.
 216          */
 217         list_for_each_entry_rcu(hook, list, node)       {
 218                 retval = hook->fn(regs, esr);
 219                 if (retval == DBG_HOOK_HANDLED)
 220                         break;
 221         }
 222
 223         return retval;
 224 }
 225 NOKPROBE_SYMBOL(call_step_hook);
 226
 227 static void send_user_sigtrap(int si_code)
 228 {
 229         struct pt_regs *regs = current_pt_regs();
 230
 231         if (WARN_ON(!user_mode(regs)))
 232                 return;
 233
 234         if (interrupts_enabled(regs))
 235                 local_irq_enable();
 236
 237         arm64_force_sig_fault(SIGTRAP, si_code, instruction_pointer(regs),
 238                               "User debug trap");
 239 }
 240
 241 static int single_step_handler(unsigned long unused, unsigned long esr,
 242                                struct pt_regs *regs)
 243 {
 244         bool handler_found = false;
 245
 246         /*
 247          * If we are stepping a pending breakpoint, call the hw_breakpoint
 248          * handler first.
 249          */
 250         if (!reinstall_suspended_bps(regs))
 251                 return 0;
 252
 253         if (!handler_found && call_step_hook(regs, esr) == DBG_HOOK_HANDLED)
 254                 handler_found = true;
 255
 256         if (!handler_found && user_mode(regs)) {
 257                 send_user_sigtrap(TRAP_TRACE);
 258
 259                 /*
 260                  * ptrace will disable single step unless explicitly
 261                  * asked to re-enable it. For other clients, it makes
 262                  * sense to leave it enabled (i.e. rewind the controls
 263                  * to the active-not-pending state).
 264                  */
 265                 user_rewind_single_step(current);
 266         } else if (!handler_found) {
 267                 pr_warn("Unexpected kernel single-step exception at EL1\n");
 268                 /*
 269                  * Re-enable stepping since we know that we will be
 270                  * returning to regs.
 271                  */
 272                 set_regs_spsr_ss(regs);
 273         }
 274
 275         return 0;
 276 }
 277 NOKPROBE_SYMBOL(single_step_handler);
 278
 279 static LIST_HEAD(user_break_hook);
 280 static LIST_HEAD(kernel_break_hook);
 281
 282 void register_user_break_hook(struct break_hook *hook)
 283 {
 284         register_debug_hook(&hook->node, &user_break_hook);
 285 }
 286
 287 void unregister_user_break_hook(struct break_hook *hook)
 288 {
 289         unregister_debug_hook(&hook->node);
 290 }
 291
 292 void register_kernel_break_hook(struct break_hook *hook)
 293 {
 294         register_debug_hook(&hook->node, &kernel_break_hook);
 295 }
 296
 297 void unregister_kernel_break_hook(struct break_hook *hook)
 298 {
 299         unregister_debug_hook(&hook->node);
 300 }
 301
 302 static int call_break_hook(struct pt_regs *regs, unsigned long esr)
 303 {
 304         struct break_hook *hook;
 305         struct list_head *list;
 306
 307         list = user_mode(regs) ? &user_break_hook : &kernel_break_hook;
 308
 309         /*
 310          * Since brk exception disables interrupt, this function is
 311          * entirely not preemptible, and we can use rcu list safely here.
 312          */
 313         list_for_each_entry_rcu(hook, list, node) {
 314                 if ((esr_brk_comment(esr) & ~hook->mask) == hook->imm)
 315                         return hook->fn(regs, esr);
 316         }
 317
 318         return DBG_HOOK_ERROR;
 319 }
 320 NOKPROBE_SYMBOL(call_break_hook);
 321
 322 static int brk_handler(unsigned long unused, unsigned long esr,
 323                        struct pt_regs *regs)
 324 {
 325         if (call_break_hook(regs, esr) == DBG_HOOK_HANDLED)
 326                 return 0;
 327
 328         if (user_mode(regs)) {
 329                 send_user_sigtrap(TRAP_BRKPT);
 330         } else {
 331                 pr_warn("Unexpected kernel BRK exception at EL1\n");
 332                 return -EFAULT;
 333         }
 334
 335         return 0;
 336 }
 337 NOKPROBE_SYMBOL(brk_handler);
 338
 339 int aarch32_break_handler(struct pt_regs *regs)
 340 {
 341         u32 arm_instr;
 342         u16 thumb_instr;
 343         bool bp = false;
 344         void __user *pc = (void __user *)instruction_pointer(regs);
 345
 346         if (!compat_user_mode(regs))
 347                 return -EFAULT;
 348
 349         if (compat_thumb_mode(regs)) {
 350                 /* get 16-bit Thumb instruction */
 351                 __le16 instr;
 352                 get_user(instr, (__le16 __user *)pc);
 353                 thumb_instr = le16_to_cpu(instr);
 354                 if (thumb_instr == AARCH32_BREAK_THUMB2_LO) {
 355                         /* get second half of 32-bit Thumb-2 instruction */
 356                         get_user(instr, (__le16 __user *)(pc + 2));
 357                         thumb_instr = le16_to_cpu(instr);
 358                         bp = thumb_instr == AARCH32_BREAK_THUMB2_HI;
 359                 } else {
 360                         bp = thumb_instr == AARCH32_BREAK_THUMB;
 361                 }
 362         } else {
 363                 /* 32-bit ARM instruction */
 364                 __le32 instr;
 365                 get_user(instr, (__le32 __user *)pc);
 366                 arm_instr = le32_to_cpu(instr);
 367                 bp = (arm_instr & ~0xf0000000) == AARCH32_BREAK_ARM;
 368         }
 369
 370         if (!bp)
 371                 return -EFAULT;
 372
 373         send_user_sigtrap(TRAP_BRKPT);
 374         return 0;
 375 }
 376 NOKPROBE_SYMBOL(aarch32_break_handler);
 377
 378 void __init debug_traps_init(void)
 379 {
 380         hook_debug_fault_code(DBG_ESR_EVT_HWSS, single_step_handler, SIGTRAP,
 381                               TRAP_TRACE, "single-step handler");
 382         hook_debug_fault_code(DBG_ESR_EVT_BRK, brk_handler, SIGTRAP,
 383                               TRAP_BRKPT, "BRK handler");
 384 }
 385
 386 /* Re-enable single step for syscall restarting. */
 387 void user_rewind_single_step(struct task_struct *task)
 388 {
 389         /*
 390          * If single step is active for this thread, then set SPSR.SS
 391          * to 1 to avoid returning to the active-pending state.
 392          */
 393         if (test_tsk_thread_flag(task, TIF_SINGLESTEP))
 394                 set_regs_spsr_ss(task_pt_regs(task));
 395 }
 396 NOKPROBE_SYMBOL(user_rewind_single_step);
 397
 398 void user_fastforward_single_step(struct task_struct *task)
 399 {
 400         if (test_tsk_thread_flag(task, TIF_SINGLESTEP))
 401                 clear_regs_spsr_ss(task_pt_regs(task));
 402 }
 403
 404 void user_regs_reset_single_step(struct user_pt_regs *regs,
 405                                  struct task_struct *task)
 406 {
 407         if (test_tsk_thread_flag(task, TIF_SINGLESTEP))
 408                 set_user_regs_spsr_ss(regs);
 409         else
 410                 clear_user_regs_spsr_ss(regs);
 411 }
 412
 413 /* Kernel API */
 414 void kernel_enable_single_step(struct pt_regs *regs)
 415 {
 416         WARN_ON(!irqs_disabled());
 417         set_regs_spsr_ss(regs);
 418         mdscr_write(mdscr_read() | DBG_MDSCR_SS);
 419         enable_debug_monitors(DBG_ACTIVE_EL1);
 420 }
 421 NOKPROBE_SYMBOL(kernel_enable_single_step);
 422
 423 void kernel_disable_single_step(void)
 424 {
 425         WARN_ON(!irqs_disabled());
 426         mdscr_write(mdscr_read() & ~DBG_MDSCR_SS);
 427         disable_debug_monitors(DBG_ACTIVE_EL1);
 428 }
 429 NOKPROBE_SYMBOL(kernel_disable_single_step);
 430
 431 int kernel_active_single_step(void)
 432 {
 433         WARN_ON(!irqs_disabled());
 434         return mdscr_read() & DBG_MDSCR_SS;
 435 }
 436 NOKPROBE_SYMBOL(kernel_active_single_step);
 437
 438 void kernel_rewind_single_step(struct pt_regs *regs)
 439 {
 440         set_regs_spsr_ss(regs);
 441 }
 442
 443 void kernel_fastforward_single_step(struct pt_regs *regs)
 444 {
 445         clear_regs_spsr_ss(regs);
 446 }
 447
 448 /* ptrace API */
 449 void user_enable_single_step(struct task_struct *task)
 450 {
 451         struct thread_info *ti = task_thread_info(task);
 452
 453         if (!test_and_set_ti_thread_flag(ti, TIF_SINGLESTEP))
 454                 set_regs_spsr_ss(task_pt_regs(task));
 455 }
 456 NOKPROBE_SYMBOL(user_enable_single_step);
 457
 458 void user_disable_single_step(struct task_struct *task)
 459 {
 460         clear_ti_thread_flag(task_thread_info(task), TIF_SINGLESTEP);
 461 }
 462 NOKPROBE_SYMBOL(user_disable_single_step);