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