1 /* 2 * ARM debug helpers. 3 * 4 * This code is licensed under the GNU GPL v2 or later. 5 * 6 * SPDX-License-Identifier: GPL-2.0-or-later 7 */ 8 #include "qemu/osdep.h" 9 #include "qemu/log.h" 10 #include "cpu.h" 11 #include "internals.h" 12 #include "cpregs.h" 13 #include "exec/exec-all.h" 14 #include "exec/helper-proto.h" 15 16 17 /* Return the Exception Level targeted by debug exceptions. */ 18 static int arm_debug_target_el(CPUARMState *env) 19 { 20 bool secure = arm_is_secure(env); 21 bool route_to_el2 = false; 22 23 if (arm_is_el2_enabled(env)) { 24 route_to_el2 = env->cp15.hcr_el2 & HCR_TGE || 25 env->cp15.mdcr_el2 & MDCR_TDE; 26 } 27 28 if (route_to_el2) { 29 return 2; 30 } else if (arm_feature(env, ARM_FEATURE_EL3) && 31 !arm_el_is_aa64(env, 3) && secure) { 32 return 3; 33 } else { 34 return 1; 35 } 36 } 37 38 /* 39 * Raise an exception to the debug target el. 40 * Modify syndrome to indicate when origin and target EL are the same. 41 */ 42 G_NORETURN static void 43 raise_exception_debug(CPUARMState *env, uint32_t excp, uint32_t syndrome) 44 { 45 int debug_el = arm_debug_target_el(env); 46 int cur_el = arm_current_el(env); 47 48 /* 49 * If singlestep is targeting a lower EL than the current one, then 50 * DisasContext.ss_active must be false and we can never get here. 51 * Similarly for watchpoint and breakpoint matches. 52 */ 53 assert(debug_el >= cur_el); 54 syndrome |= (debug_el == cur_el) << ARM_EL_EC_SHIFT; 55 raise_exception(env, excp, syndrome, debug_el); 56 } 57 58 /* See AArch64.GenerateDebugExceptionsFrom() in ARM ARM pseudocode */ 59 static bool aa64_generate_debug_exceptions(CPUARMState *env) 60 { 61 int cur_el = arm_current_el(env); 62 int debug_el; 63 64 if (cur_el == 3) { 65 return false; 66 } 67 68 /* MDCR_EL3.SDD disables debug events from Secure state */ 69 if (arm_is_secure_below_el3(env) 70 && extract32(env->cp15.mdcr_el3, 16, 1)) { 71 return false; 72 } 73 74 /* 75 * Same EL to same EL debug exceptions need MDSCR_KDE enabled 76 * while not masking the (D)ebug bit in DAIF. 77 */ 78 debug_el = arm_debug_target_el(env); 79 80 if (cur_el == debug_el) { 81 return extract32(env->cp15.mdscr_el1, 13, 1) 82 && !(env->daif & PSTATE_D); 83 } 84 85 /* Otherwise the debug target needs to be a higher EL */ 86 return debug_el > cur_el; 87 } 88 89 static bool aa32_generate_debug_exceptions(CPUARMState *env) 90 { 91 int el = arm_current_el(env); 92 93 if (el == 0 && arm_el_is_aa64(env, 1)) { 94 return aa64_generate_debug_exceptions(env); 95 } 96 97 if (arm_is_secure(env)) { 98 int spd; 99 100 if (el == 0 && (env->cp15.sder & 1)) { 101 /* 102 * SDER.SUIDEN means debug exceptions from Secure EL0 103 * are always enabled. Otherwise they are controlled by 104 * SDCR.SPD like those from other Secure ELs. 105 */ 106 return true; 107 } 108 109 spd = extract32(env->cp15.mdcr_el3, 14, 2); 110 switch (spd) { 111 case 1: 112 /* SPD == 0b01 is reserved, but behaves as 0b00. */ 113 case 0: 114 /* 115 * For 0b00 we return true if external secure invasive debug 116 * is enabled. On real hardware this is controlled by external 117 * signals to the core. QEMU always permits debug, and behaves 118 * as if DBGEN, SPIDEN, NIDEN and SPNIDEN are all tied high. 119 */ 120 return true; 121 case 2: 122 return false; 123 case 3: 124 return true; 125 } 126 } 127 128 return el != 2; 129 } 130 131 /* 132 * Return true if debugging exceptions are currently enabled. 133 * This corresponds to what in ARM ARM pseudocode would be 134 * if UsingAArch32() then 135 * return AArch32.GenerateDebugExceptions() 136 * else 137 * return AArch64.GenerateDebugExceptions() 138 * We choose to push the if() down into this function for clarity, 139 * since the pseudocode has it at all callsites except for the one in 140 * CheckSoftwareStep(), where it is elided because both branches would 141 * always return the same value. 142 */ 143 bool arm_generate_debug_exceptions(CPUARMState *env) 144 { 145 if ((env->cp15.oslsr_el1 & 1) || (env->cp15.osdlr_el1 & 1)) { 146 return false; 147 } 148 if (is_a64(env)) { 149 return aa64_generate_debug_exceptions(env); 150 } else { 151 return aa32_generate_debug_exceptions(env); 152 } 153 } 154 155 /* 156 * Is single-stepping active? (Note that the "is EL_D AArch64?" check 157 * implicitly means this always returns false in pre-v8 CPUs.) 158 */ 159 bool arm_singlestep_active(CPUARMState *env) 160 { 161 return extract32(env->cp15.mdscr_el1, 0, 1) 162 && arm_el_is_aa64(env, arm_debug_target_el(env)) 163 && arm_generate_debug_exceptions(env); 164 } 165 166 /* Return true if the linked breakpoint entry lbn passes its checks */ 167 static bool linked_bp_matches(ARMCPU *cpu, int lbn) 168 { 169 CPUARMState *env = &cpu->env; 170 uint64_t bcr = env->cp15.dbgbcr[lbn]; 171 int brps = arm_num_brps(cpu); 172 int ctx_cmps = arm_num_ctx_cmps(cpu); 173 int bt; 174 uint32_t contextidr; 175 uint64_t hcr_el2; 176 177 /* 178 * Links to unimplemented or non-context aware breakpoints are 179 * CONSTRAINED UNPREDICTABLE: either behave as if disabled, or 180 * as if linked to an UNKNOWN context-aware breakpoint (in which 181 * case DBGWCR<n>_EL1.LBN must indicate that breakpoint). 182 * We choose the former. 183 */ 184 if (lbn >= brps || lbn < (brps - ctx_cmps)) { 185 return false; 186 } 187 188 bcr = env->cp15.dbgbcr[lbn]; 189 190 if (extract64(bcr, 0, 1) == 0) { 191 /* Linked breakpoint disabled : generate no events */ 192 return false; 193 } 194 195 bt = extract64(bcr, 20, 4); 196 hcr_el2 = arm_hcr_el2_eff(env); 197 198 switch (bt) { 199 case 3: /* linked context ID match */ 200 switch (arm_current_el(env)) { 201 default: 202 /* Context matches never fire in AArch64 EL3 */ 203 return false; 204 case 2: 205 if (!(hcr_el2 & HCR_E2H)) { 206 /* Context matches never fire in EL2 without E2H enabled. */ 207 return false; 208 } 209 contextidr = env->cp15.contextidr_el[2]; 210 break; 211 case 1: 212 contextidr = env->cp15.contextidr_el[1]; 213 break; 214 case 0: 215 if ((hcr_el2 & (HCR_E2H | HCR_TGE)) == (HCR_E2H | HCR_TGE)) { 216 contextidr = env->cp15.contextidr_el[2]; 217 } else { 218 contextidr = env->cp15.contextidr_el[1]; 219 } 220 break; 221 } 222 break; 223 224 case 7: /* linked contextidr_el1 match */ 225 contextidr = env->cp15.contextidr_el[1]; 226 break; 227 case 13: /* linked contextidr_el2 match */ 228 contextidr = env->cp15.contextidr_el[2]; 229 break; 230 231 case 9: /* linked VMID match (reserved if no EL2) */ 232 case 11: /* linked context ID and VMID match (reserved if no EL2) */ 233 case 15: /* linked full context ID match */ 234 default: 235 /* 236 * Links to Unlinked context breakpoints must generate no 237 * events; we choose to do the same for reserved values too. 238 */ 239 return false; 240 } 241 242 /* 243 * We match the whole register even if this is AArch32 using the 244 * short descriptor format (in which case it holds both PROCID and ASID), 245 * since we don't implement the optional v7 context ID masking. 246 */ 247 return contextidr == (uint32_t)env->cp15.dbgbvr[lbn]; 248 } 249 250 static bool bp_wp_matches(ARMCPU *cpu, int n, bool is_wp) 251 { 252 CPUARMState *env = &cpu->env; 253 uint64_t cr; 254 int pac, hmc, ssc, wt, lbn; 255 /* 256 * Note that for watchpoints the check is against the CPU security 257 * state, not the S/NS attribute on the offending data access. 258 */ 259 bool is_secure = arm_is_secure(env); 260 int access_el = arm_current_el(env); 261 262 if (is_wp) { 263 CPUWatchpoint *wp = env->cpu_watchpoint[n]; 264 265 if (!wp || !(wp->flags & BP_WATCHPOINT_HIT)) { 266 return false; 267 } 268 cr = env->cp15.dbgwcr[n]; 269 if (wp->hitattrs.user) { 270 /* 271 * The LDRT/STRT/LDT/STT "unprivileged access" instructions should 272 * match watchpoints as if they were accesses done at EL0, even if 273 * the CPU is at EL1 or higher. 274 */ 275 access_el = 0; 276 } 277 } else { 278 uint64_t pc = is_a64(env) ? env->pc : env->regs[15]; 279 280 if (!env->cpu_breakpoint[n] || env->cpu_breakpoint[n]->pc != pc) { 281 return false; 282 } 283 cr = env->cp15.dbgbcr[n]; 284 } 285 /* 286 * The WATCHPOINT_HIT flag guarantees us that the watchpoint is 287 * enabled and that the address and access type match; for breakpoints 288 * we know the address matched; check the remaining fields, including 289 * linked breakpoints. We rely on WCR and BCR having the same layout 290 * for the LBN, SSC, HMC, PAC/PMC and is-linked fields. 291 * Note that some combinations of {PAC, HMC, SSC} are reserved and 292 * must act either like some valid combination or as if the watchpoint 293 * were disabled. We choose the former, and use this together with 294 * the fact that EL3 must always be Secure and EL2 must always be 295 * Non-Secure to simplify the code slightly compared to the full 296 * table in the ARM ARM. 297 */ 298 pac = FIELD_EX64(cr, DBGWCR, PAC); 299 hmc = FIELD_EX64(cr, DBGWCR, HMC); 300 ssc = FIELD_EX64(cr, DBGWCR, SSC); 301 302 switch (ssc) { 303 case 0: 304 break; 305 case 1: 306 case 3: 307 if (is_secure) { 308 return false; 309 } 310 break; 311 case 2: 312 if (!is_secure) { 313 return false; 314 } 315 break; 316 } 317 318 switch (access_el) { 319 case 3: 320 case 2: 321 if (!hmc) { 322 return false; 323 } 324 break; 325 case 1: 326 if (extract32(pac, 0, 1) == 0) { 327 return false; 328 } 329 break; 330 case 0: 331 if (extract32(pac, 1, 1) == 0) { 332 return false; 333 } 334 break; 335 default: 336 g_assert_not_reached(); 337 } 338 339 wt = FIELD_EX64(cr, DBGWCR, WT); 340 lbn = FIELD_EX64(cr, DBGWCR, LBN); 341 342 if (wt && !linked_bp_matches(cpu, lbn)) { 343 return false; 344 } 345 346 return true; 347 } 348 349 static bool check_watchpoints(ARMCPU *cpu) 350 { 351 CPUARMState *env = &cpu->env; 352 int n; 353 354 /* 355 * If watchpoints are disabled globally or we can't take debug 356 * exceptions here then watchpoint firings are ignored. 357 */ 358 if (extract32(env->cp15.mdscr_el1, 15, 1) == 0 359 || !arm_generate_debug_exceptions(env)) { 360 return false; 361 } 362 363 for (n = 0; n < ARRAY_SIZE(env->cpu_watchpoint); n++) { 364 if (bp_wp_matches(cpu, n, true)) { 365 return true; 366 } 367 } 368 return false; 369 } 370 371 bool arm_debug_check_breakpoint(CPUState *cs) 372 { 373 ARMCPU *cpu = ARM_CPU(cs); 374 CPUARMState *env = &cpu->env; 375 target_ulong pc; 376 int n; 377 378 /* 379 * If breakpoints are disabled globally or we can't take debug 380 * exceptions here then breakpoint firings are ignored. 381 */ 382 if (extract32(env->cp15.mdscr_el1, 15, 1) == 0 383 || !arm_generate_debug_exceptions(env)) { 384 return false; 385 } 386 387 /* 388 * Single-step exceptions have priority over breakpoint exceptions. 389 * If single-step state is active-pending, suppress the bp. 390 */ 391 if (arm_singlestep_active(env) && !(env->pstate & PSTATE_SS)) { 392 return false; 393 } 394 395 /* 396 * PC alignment faults have priority over breakpoint exceptions. 397 */ 398 pc = is_a64(env) ? env->pc : env->regs[15]; 399 if ((is_a64(env) || !env->thumb) && (pc & 3) != 0) { 400 return false; 401 } 402 403 /* 404 * Instruction aborts have priority over breakpoint exceptions. 405 * TODO: We would need to look up the page for PC and verify that 406 * it is present and executable. 407 */ 408 409 for (n = 0; n < ARRAY_SIZE(env->cpu_breakpoint); n++) { 410 if (bp_wp_matches(cpu, n, false)) { 411 return true; 412 } 413 } 414 return false; 415 } 416 417 bool arm_debug_check_watchpoint(CPUState *cs, CPUWatchpoint *wp) 418 { 419 /* 420 * Called by core code when a CPU watchpoint fires; need to check if this 421 * is also an architectural watchpoint match. 422 */ 423 ARMCPU *cpu = ARM_CPU(cs); 424 425 return check_watchpoints(cpu); 426 } 427 428 /* 429 * Return the FSR value for a debug exception (watchpoint, hardware 430 * breakpoint or BKPT insn) targeting the specified exception level. 431 */ 432 static uint32_t arm_debug_exception_fsr(CPUARMState *env) 433 { 434 ARMMMUFaultInfo fi = { .type = ARMFault_Debug }; 435 int target_el = arm_debug_target_el(env); 436 bool using_lpae = false; 437 438 if (target_el == 2 || arm_el_is_aa64(env, target_el)) { 439 using_lpae = true; 440 } else if (arm_feature(env, ARM_FEATURE_PMSA) && 441 arm_feature(env, ARM_FEATURE_V8)) { 442 using_lpae = true; 443 } else { 444 if (arm_feature(env, ARM_FEATURE_LPAE) && 445 (env->cp15.tcr_el[target_el] & TTBCR_EAE)) { 446 using_lpae = true; 447 } 448 } 449 450 if (using_lpae) { 451 return arm_fi_to_lfsc(&fi); 452 } else { 453 return arm_fi_to_sfsc(&fi); 454 } 455 } 456 457 void arm_debug_excp_handler(CPUState *cs) 458 { 459 /* 460 * Called by core code when a watchpoint or breakpoint fires; 461 * need to check which one and raise the appropriate exception. 462 */ 463 ARMCPU *cpu = ARM_CPU(cs); 464 CPUARMState *env = &cpu->env; 465 CPUWatchpoint *wp_hit = cs->watchpoint_hit; 466 467 if (wp_hit) { 468 if (wp_hit->flags & BP_CPU) { 469 bool wnr = (wp_hit->flags & BP_WATCHPOINT_HIT_WRITE) != 0; 470 471 cs->watchpoint_hit = NULL; 472 473 env->exception.fsr = arm_debug_exception_fsr(env); 474 env->exception.vaddress = wp_hit->hitaddr; 475 raise_exception_debug(env, EXCP_DATA_ABORT, 476 syn_watchpoint(0, 0, wnr)); 477 } 478 } else { 479 uint64_t pc = is_a64(env) ? env->pc : env->regs[15]; 480 481 /* 482 * (1) GDB breakpoints should be handled first. 483 * (2) Do not raise a CPU exception if no CPU breakpoint has fired, 484 * since singlestep is also done by generating a debug internal 485 * exception. 486 */ 487 if (cpu_breakpoint_test(cs, pc, BP_GDB) 488 || !cpu_breakpoint_test(cs, pc, BP_CPU)) { 489 return; 490 } 491 492 env->exception.fsr = arm_debug_exception_fsr(env); 493 /* 494 * FAR is UNKNOWN: clear vaddress to avoid potentially exposing 495 * values to the guest that it shouldn't be able to see at its 496 * exception/security level. 497 */ 498 env->exception.vaddress = 0; 499 raise_exception_debug(env, EXCP_PREFETCH_ABORT, syn_breakpoint(0)); 500 } 501 } 502 503 /* 504 * Raise an EXCP_BKPT with the specified syndrome register value, 505 * targeting the correct exception level for debug exceptions. 506 */ 507 void HELPER(exception_bkpt_insn)(CPUARMState *env, uint32_t syndrome) 508 { 509 int debug_el = arm_debug_target_el(env); 510 int cur_el = arm_current_el(env); 511 512 /* FSR will only be used if the debug target EL is AArch32. */ 513 env->exception.fsr = arm_debug_exception_fsr(env); 514 /* 515 * FAR is UNKNOWN: clear vaddress to avoid potentially exposing 516 * values to the guest that it shouldn't be able to see at its 517 * exception/security level. 518 */ 519 env->exception.vaddress = 0; 520 /* 521 * Other kinds of architectural debug exception are ignored if 522 * they target an exception level below the current one (in QEMU 523 * this is checked by arm_generate_debug_exceptions()). Breakpoint 524 * instructions are special because they always generate an exception 525 * to somewhere: if they can't go to the configured debug exception 526 * level they are taken to the current exception level. 527 */ 528 if (debug_el < cur_el) { 529 debug_el = cur_el; 530 } 531 raise_exception(env, EXCP_BKPT, syndrome, debug_el); 532 } 533 534 void HELPER(exception_swstep)(CPUARMState *env, uint32_t syndrome) 535 { 536 raise_exception_debug(env, EXCP_UDEF, syndrome); 537 } 538 539 /* 540 * Check for traps to "powerdown debug" registers, which are controlled 541 * by MDCR.TDOSA 542 */ 543 static CPAccessResult access_tdosa(CPUARMState *env, const ARMCPRegInfo *ri, 544 bool isread) 545 { 546 int el = arm_current_el(env); 547 uint64_t mdcr_el2 = arm_mdcr_el2_eff(env); 548 bool mdcr_el2_tdosa = (mdcr_el2 & MDCR_TDOSA) || (mdcr_el2 & MDCR_TDE) || 549 (arm_hcr_el2_eff(env) & HCR_TGE); 550 551 if (el < 2 && mdcr_el2_tdosa) { 552 return CP_ACCESS_TRAP_EL2; 553 } 554 if (el < 3 && (env->cp15.mdcr_el3 & MDCR_TDOSA)) { 555 return CP_ACCESS_TRAP_EL3; 556 } 557 return CP_ACCESS_OK; 558 } 559 560 /* 561 * Check for traps to "debug ROM" registers, which are controlled 562 * by MDCR_EL2.TDRA for EL2 but by the more general MDCR_EL3.TDA for EL3. 563 */ 564 static CPAccessResult access_tdra(CPUARMState *env, const ARMCPRegInfo *ri, 565 bool isread) 566 { 567 int el = arm_current_el(env); 568 uint64_t mdcr_el2 = arm_mdcr_el2_eff(env); 569 bool mdcr_el2_tdra = (mdcr_el2 & MDCR_TDRA) || (mdcr_el2 & MDCR_TDE) || 570 (arm_hcr_el2_eff(env) & HCR_TGE); 571 572 if (el < 2 && mdcr_el2_tdra) { 573 return CP_ACCESS_TRAP_EL2; 574 } 575 if (el < 3 && (env->cp15.mdcr_el3 & MDCR_TDA)) { 576 return CP_ACCESS_TRAP_EL3; 577 } 578 return CP_ACCESS_OK; 579 } 580 581 /* 582 * Check for traps to general debug registers, which are controlled 583 * by MDCR_EL2.TDA for EL2 and MDCR_EL3.TDA for EL3. 584 */ 585 static CPAccessResult access_tda(CPUARMState *env, const ARMCPRegInfo *ri, 586 bool isread) 587 { 588 int el = arm_current_el(env); 589 uint64_t mdcr_el2 = arm_mdcr_el2_eff(env); 590 bool mdcr_el2_tda = (mdcr_el2 & MDCR_TDA) || (mdcr_el2 & MDCR_TDE) || 591 (arm_hcr_el2_eff(env) & HCR_TGE); 592 593 if (el < 2 && mdcr_el2_tda) { 594 return CP_ACCESS_TRAP_EL2; 595 } 596 if (el < 3 && (env->cp15.mdcr_el3 & MDCR_TDA)) { 597 return CP_ACCESS_TRAP_EL3; 598 } 599 return CP_ACCESS_OK; 600 } 601 602 static void oslar_write(CPUARMState *env, const ARMCPRegInfo *ri, 603 uint64_t value) 604 { 605 /* 606 * Writes to OSLAR_EL1 may update the OS lock status, which can be 607 * read via a bit in OSLSR_EL1. 608 */ 609 int oslock; 610 611 if (ri->state == ARM_CP_STATE_AA32) { 612 oslock = (value == 0xC5ACCE55); 613 } else { 614 oslock = value & 1; 615 } 616 617 env->cp15.oslsr_el1 = deposit32(env->cp15.oslsr_el1, 1, 1, oslock); 618 } 619 620 static void osdlr_write(CPUARMState *env, const ARMCPRegInfo *ri, 621 uint64_t value) 622 { 623 ARMCPU *cpu = env_archcpu(env); 624 /* 625 * Only defined bit is bit 0 (DLK); if Feat_DoubleLock is not 626 * implemented this is RAZ/WI. 627 */ 628 if(arm_feature(env, ARM_FEATURE_AARCH64) 629 ? cpu_isar_feature(aa64_doublelock, cpu) 630 : cpu_isar_feature(aa32_doublelock, cpu)) { 631 env->cp15.osdlr_el1 = value & 1; 632 } 633 } 634 635 static const ARMCPRegInfo debug_cp_reginfo[] = { 636 /* 637 * DBGDRAR, DBGDSAR: always RAZ since we don't implement memory mapped 638 * debug components. The AArch64 version of DBGDRAR is named MDRAR_EL1; 639 * unlike DBGDRAR it is never accessible from EL0. 640 * DBGDSAR is deprecated and must RAZ from v8 anyway, so it has no AArch64 641 * accessor. 642 */ 643 { .name = "DBGDRAR", .cp = 14, .crn = 1, .crm = 0, .opc1 = 0, .opc2 = 0, 644 .access = PL0_R, .accessfn = access_tdra, 645 .type = ARM_CP_CONST, .resetvalue = 0 }, 646 { .name = "MDRAR_EL1", .state = ARM_CP_STATE_AA64, 647 .opc0 = 2, .opc1 = 0, .crn = 1, .crm = 0, .opc2 = 0, 648 .access = PL1_R, .accessfn = access_tdra, 649 .type = ARM_CP_CONST, .resetvalue = 0 }, 650 { .name = "DBGDSAR", .cp = 14, .crn = 2, .crm = 0, .opc1 = 0, .opc2 = 0, 651 .access = PL0_R, .accessfn = access_tdra, 652 .type = ARM_CP_CONST, .resetvalue = 0 }, 653 /* Monitor debug system control register; the 32-bit alias is DBGDSCRext. */ 654 { .name = "MDSCR_EL1", .state = ARM_CP_STATE_BOTH, 655 .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 0, .crm = 2, .opc2 = 2, 656 .access = PL1_RW, .accessfn = access_tda, 657 .fieldoffset = offsetof(CPUARMState, cp15.mdscr_el1), 658 .resetvalue = 0 }, 659 /* 660 * MDCCSR_EL0[30:29] map to EDSCR[30:29]. Simply RAZ as the external 661 * Debug Communication Channel is not implemented. 662 */ 663 { .name = "MDCCSR_EL0", .state = ARM_CP_STATE_AA64, 664 .opc0 = 2, .opc1 = 3, .crn = 0, .crm = 1, .opc2 = 0, 665 .access = PL0_R, .accessfn = access_tda, 666 .type = ARM_CP_CONST, .resetvalue = 0 }, 667 /* 668 * DBGDSCRint[15,12,5:2] map to MDSCR_EL1[15,12,5:2]. Map all bits as 669 * it is unlikely a guest will care. 670 * We don't implement the configurable EL0 access. 671 */ 672 { .name = "DBGDSCRint", .state = ARM_CP_STATE_AA32, 673 .cp = 14, .opc1 = 0, .crn = 0, .crm = 1, .opc2 = 0, 674 .type = ARM_CP_ALIAS, 675 .access = PL1_R, .accessfn = access_tda, 676 .fieldoffset = offsetof(CPUARMState, cp15.mdscr_el1), }, 677 { .name = "OSLAR_EL1", .state = ARM_CP_STATE_BOTH, 678 .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 1, .crm = 0, .opc2 = 4, 679 .access = PL1_W, .type = ARM_CP_NO_RAW, 680 .accessfn = access_tdosa, 681 .writefn = oslar_write }, 682 { .name = "OSLSR_EL1", .state = ARM_CP_STATE_BOTH, 683 .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 1, .crm = 1, .opc2 = 4, 684 .access = PL1_R, .resetvalue = 10, 685 .accessfn = access_tdosa, 686 .fieldoffset = offsetof(CPUARMState, cp15.oslsr_el1) }, 687 /* Dummy OSDLR_EL1: 32-bit Linux will read this */ 688 { .name = "OSDLR_EL1", .state = ARM_CP_STATE_BOTH, 689 .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 1, .crm = 3, .opc2 = 4, 690 .access = PL1_RW, .accessfn = access_tdosa, 691 .writefn = osdlr_write, 692 .fieldoffset = offsetof(CPUARMState, cp15.osdlr_el1) }, 693 /* 694 * Dummy DBGVCR: Linux wants to clear this on startup, but we don't 695 * implement vector catch debug events yet. 696 */ 697 { .name = "DBGVCR", 698 .cp = 14, .opc1 = 0, .crn = 0, .crm = 7, .opc2 = 0, 699 .access = PL1_RW, .accessfn = access_tda, 700 .type = ARM_CP_NOP }, 701 /* 702 * Dummy DBGVCR32_EL2 (which is only for a 64-bit hypervisor 703 * to save and restore a 32-bit guest's DBGVCR) 704 */ 705 { .name = "DBGVCR32_EL2", .state = ARM_CP_STATE_AA64, 706 .opc0 = 2, .opc1 = 4, .crn = 0, .crm = 7, .opc2 = 0, 707 .access = PL2_RW, .accessfn = access_tda, 708 .type = ARM_CP_NOP | ARM_CP_EL3_NO_EL2_KEEP }, 709 /* 710 * Dummy MDCCINT_EL1, since we don't implement the Debug Communications 711 * Channel but Linux may try to access this register. The 32-bit 712 * alias is DBGDCCINT. 713 */ 714 { .name = "MDCCINT_EL1", .state = ARM_CP_STATE_BOTH, 715 .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 0, .crm = 2, .opc2 = 0, 716 .access = PL1_RW, .accessfn = access_tda, 717 .type = ARM_CP_NOP }, 718 }; 719 720 static const ARMCPRegInfo debug_lpae_cp_reginfo[] = { 721 /* 64 bit access versions of the (dummy) debug registers */ 722 { .name = "DBGDRAR", .cp = 14, .crm = 1, .opc1 = 0, 723 .access = PL0_R, .type = ARM_CP_CONST | ARM_CP_64BIT, .resetvalue = 0 }, 724 { .name = "DBGDSAR", .cp = 14, .crm = 2, .opc1 = 0, 725 .access = PL0_R, .type = ARM_CP_CONST | ARM_CP_64BIT, .resetvalue = 0 }, 726 }; 727 728 void hw_watchpoint_update(ARMCPU *cpu, int n) 729 { 730 CPUARMState *env = &cpu->env; 731 vaddr len = 0; 732 vaddr wvr = env->cp15.dbgwvr[n]; 733 uint64_t wcr = env->cp15.dbgwcr[n]; 734 int mask; 735 int flags = BP_CPU | BP_STOP_BEFORE_ACCESS; 736 737 if (env->cpu_watchpoint[n]) { 738 cpu_watchpoint_remove_by_ref(CPU(cpu), env->cpu_watchpoint[n]); 739 env->cpu_watchpoint[n] = NULL; 740 } 741 742 if (!FIELD_EX64(wcr, DBGWCR, E)) { 743 /* E bit clear : watchpoint disabled */ 744 return; 745 } 746 747 switch (FIELD_EX64(wcr, DBGWCR, LSC)) { 748 case 0: 749 /* LSC 00 is reserved and must behave as if the wp is disabled */ 750 return; 751 case 1: 752 flags |= BP_MEM_READ; 753 break; 754 case 2: 755 flags |= BP_MEM_WRITE; 756 break; 757 case 3: 758 flags |= BP_MEM_ACCESS; 759 break; 760 } 761 762 /* 763 * Attempts to use both MASK and BAS fields simultaneously are 764 * CONSTRAINED UNPREDICTABLE; we opt to ignore BAS in this case, 765 * thus generating a watchpoint for every byte in the masked region. 766 */ 767 mask = FIELD_EX64(wcr, DBGWCR, MASK); 768 if (mask == 1 || mask == 2) { 769 /* 770 * Reserved values of MASK; we must act as if the mask value was 771 * some non-reserved value, or as if the watchpoint were disabled. 772 * We choose the latter. 773 */ 774 return; 775 } else if (mask) { 776 /* Watchpoint covers an aligned area up to 2GB in size */ 777 len = 1ULL << mask; 778 /* 779 * If masked bits in WVR are not zero it's CONSTRAINED UNPREDICTABLE 780 * whether the watchpoint fires when the unmasked bits match; we opt 781 * to generate the exceptions. 782 */ 783 wvr &= ~(len - 1); 784 } else { 785 /* Watchpoint covers bytes defined by the byte address select bits */ 786 int bas = FIELD_EX64(wcr, DBGWCR, BAS); 787 int basstart; 788 789 if (extract64(wvr, 2, 1)) { 790 /* 791 * Deprecated case of an only 4-aligned address. BAS[7:4] are 792 * ignored, and BAS[3:0] define which bytes to watch. 793 */ 794 bas &= 0xf; 795 } 796 797 if (bas == 0) { 798 /* This must act as if the watchpoint is disabled */ 799 return; 800 } 801 802 /* 803 * The BAS bits are supposed to be programmed to indicate a contiguous 804 * range of bytes. Otherwise it is CONSTRAINED UNPREDICTABLE whether 805 * we fire for each byte in the word/doubleword addressed by the WVR. 806 * We choose to ignore any non-zero bits after the first range of 1s. 807 */ 808 basstart = ctz32(bas); 809 len = cto32(bas >> basstart); 810 wvr += basstart; 811 } 812 813 cpu_watchpoint_insert(CPU(cpu), wvr, len, flags, 814 &env->cpu_watchpoint[n]); 815 } 816 817 void hw_watchpoint_update_all(ARMCPU *cpu) 818 { 819 int i; 820 CPUARMState *env = &cpu->env; 821 822 /* 823 * Completely clear out existing QEMU watchpoints and our array, to 824 * avoid possible stale entries following migration load. 825 */ 826 cpu_watchpoint_remove_all(CPU(cpu), BP_CPU); 827 memset(env->cpu_watchpoint, 0, sizeof(env->cpu_watchpoint)); 828 829 for (i = 0; i < ARRAY_SIZE(cpu->env.cpu_watchpoint); i++) { 830 hw_watchpoint_update(cpu, i); 831 } 832 } 833 834 static void dbgwvr_write(CPUARMState *env, const ARMCPRegInfo *ri, 835 uint64_t value) 836 { 837 ARMCPU *cpu = env_archcpu(env); 838 int i = ri->crm; 839 840 /* 841 * Bits [1:0] are RES0. 842 * 843 * It is IMPLEMENTATION DEFINED whether [63:49] ([63:53] with FEAT_LVA) 844 * are hardwired to the value of bit [48] ([52] with FEAT_LVA), or if 845 * they contain the value written. It is CONSTRAINED UNPREDICTABLE 846 * whether the RESS bits are ignored when comparing an address. 847 * 848 * Therefore we are allowed to compare the entire register, which lets 849 * us avoid considering whether or not FEAT_LVA is actually enabled. 850 */ 851 value &= ~3ULL; 852 853 raw_write(env, ri, value); 854 hw_watchpoint_update(cpu, i); 855 } 856 857 static void dbgwcr_write(CPUARMState *env, const ARMCPRegInfo *ri, 858 uint64_t value) 859 { 860 ARMCPU *cpu = env_archcpu(env); 861 int i = ri->crm; 862 863 raw_write(env, ri, value); 864 hw_watchpoint_update(cpu, i); 865 } 866 867 void hw_breakpoint_update(ARMCPU *cpu, int n) 868 { 869 CPUARMState *env = &cpu->env; 870 uint64_t bvr = env->cp15.dbgbvr[n]; 871 uint64_t bcr = env->cp15.dbgbcr[n]; 872 vaddr addr; 873 int bt; 874 int flags = BP_CPU; 875 876 if (env->cpu_breakpoint[n]) { 877 cpu_breakpoint_remove_by_ref(CPU(cpu), env->cpu_breakpoint[n]); 878 env->cpu_breakpoint[n] = NULL; 879 } 880 881 if (!extract64(bcr, 0, 1)) { 882 /* E bit clear : watchpoint disabled */ 883 return; 884 } 885 886 bt = extract64(bcr, 20, 4); 887 888 switch (bt) { 889 case 4: /* unlinked address mismatch (reserved if AArch64) */ 890 case 5: /* linked address mismatch (reserved if AArch64) */ 891 qemu_log_mask(LOG_UNIMP, 892 "arm: address mismatch breakpoint types not implemented\n"); 893 return; 894 case 0: /* unlinked address match */ 895 case 1: /* linked address match */ 896 { 897 /* 898 * Bits [1:0] are RES0. 899 * 900 * It is IMPLEMENTATION DEFINED whether bits [63:49] 901 * ([63:53] for FEAT_LVA) are hardwired to a copy of the sign bit 902 * of the VA field ([48] or [52] for FEAT_LVA), or whether the 903 * value is read as written. It is CONSTRAINED UNPREDICTABLE 904 * whether the RESS bits are ignored when comparing an address. 905 * Therefore we are allowed to compare the entire register, which 906 * lets us avoid considering whether FEAT_LVA is actually enabled. 907 * 908 * The BAS field is used to allow setting breakpoints on 16-bit 909 * wide instructions; it is CONSTRAINED UNPREDICTABLE whether 910 * a bp will fire if the addresses covered by the bp and the addresses 911 * covered by the insn overlap but the insn doesn't start at the 912 * start of the bp address range. We choose to require the insn and 913 * the bp to have the same address. The constraints on writing to 914 * BAS enforced in dbgbcr_write mean we have only four cases: 915 * 0b0000 => no breakpoint 916 * 0b0011 => breakpoint on addr 917 * 0b1100 => breakpoint on addr + 2 918 * 0b1111 => breakpoint on addr 919 * See also figure D2-3 in the v8 ARM ARM (DDI0487A.c). 920 */ 921 int bas = extract64(bcr, 5, 4); 922 addr = bvr & ~3ULL; 923 if (bas == 0) { 924 return; 925 } 926 if (bas == 0xc) { 927 addr += 2; 928 } 929 break; 930 } 931 case 2: /* unlinked context ID match */ 932 case 8: /* unlinked VMID match (reserved if no EL2) */ 933 case 10: /* unlinked context ID and VMID match (reserved if no EL2) */ 934 qemu_log_mask(LOG_UNIMP, 935 "arm: unlinked context breakpoint types not implemented\n"); 936 return; 937 case 9: /* linked VMID match (reserved if no EL2) */ 938 case 11: /* linked context ID and VMID match (reserved if no EL2) */ 939 case 3: /* linked context ID match */ 940 default: 941 /* 942 * We must generate no events for Linked context matches (unless 943 * they are linked to by some other bp/wp, which is handled in 944 * updates for the linking bp/wp). We choose to also generate no events 945 * for reserved values. 946 */ 947 return; 948 } 949 950 cpu_breakpoint_insert(CPU(cpu), addr, flags, &env->cpu_breakpoint[n]); 951 } 952 953 void hw_breakpoint_update_all(ARMCPU *cpu) 954 { 955 int i; 956 CPUARMState *env = &cpu->env; 957 958 /* 959 * Completely clear out existing QEMU breakpoints and our array, to 960 * avoid possible stale entries following migration load. 961 */ 962 cpu_breakpoint_remove_all(CPU(cpu), BP_CPU); 963 memset(env->cpu_breakpoint, 0, sizeof(env->cpu_breakpoint)); 964 965 for (i = 0; i < ARRAY_SIZE(cpu->env.cpu_breakpoint); i++) { 966 hw_breakpoint_update(cpu, i); 967 } 968 } 969 970 static void dbgbvr_write(CPUARMState *env, const ARMCPRegInfo *ri, 971 uint64_t value) 972 { 973 ARMCPU *cpu = env_archcpu(env); 974 int i = ri->crm; 975 976 raw_write(env, ri, value); 977 hw_breakpoint_update(cpu, i); 978 } 979 980 static void dbgbcr_write(CPUARMState *env, const ARMCPRegInfo *ri, 981 uint64_t value) 982 { 983 ARMCPU *cpu = env_archcpu(env); 984 int i = ri->crm; 985 986 /* 987 * BAS[3] is a read-only copy of BAS[2], and BAS[1] a read-only 988 * copy of BAS[0]. 989 */ 990 value = deposit64(value, 6, 1, extract64(value, 5, 1)); 991 value = deposit64(value, 8, 1, extract64(value, 7, 1)); 992 993 raw_write(env, ri, value); 994 hw_breakpoint_update(cpu, i); 995 } 996 997 void define_debug_regs(ARMCPU *cpu) 998 { 999 /* 1000 * Define v7 and v8 architectural debug registers. 1001 * These are just dummy implementations for now. 1002 */ 1003 int i; 1004 int wrps, brps, ctx_cmps; 1005 1006 /* 1007 * The Arm ARM says DBGDIDR is optional and deprecated if EL1 cannot 1008 * use AArch32. Given that bit 15 is RES1, if the value is 0 then 1009 * the register must not exist for this cpu. 1010 */ 1011 if (cpu->isar.dbgdidr != 0) { 1012 ARMCPRegInfo dbgdidr = { 1013 .name = "DBGDIDR", .cp = 14, .crn = 0, .crm = 0, 1014 .opc1 = 0, .opc2 = 0, 1015 .access = PL0_R, .accessfn = access_tda, 1016 .type = ARM_CP_CONST, .resetvalue = cpu->isar.dbgdidr, 1017 }; 1018 define_one_arm_cp_reg(cpu, &dbgdidr); 1019 } 1020 1021 /* 1022 * DBGDEVID is present in the v7 debug architecture if 1023 * DBGDIDR.DEVID_imp is 1 (bit 15); from v7.1 and on it is 1024 * mandatory (and bit 15 is RES1). DBGDEVID1 and DBGDEVID2 exist 1025 * from v7.1 of the debug architecture. Because no fields have yet 1026 * been defined in DBGDEVID2 (and quite possibly none will ever 1027 * be) we don't define an ARMISARegisters field for it. 1028 * These registers exist only if EL1 can use AArch32, but that 1029 * happens naturally because they are only PL1 accessible anyway. 1030 */ 1031 if (extract32(cpu->isar.dbgdidr, 15, 1)) { 1032 ARMCPRegInfo dbgdevid = { 1033 .name = "DBGDEVID", 1034 .cp = 14, .opc1 = 0, .crn = 7, .opc2 = 2, .crn = 7, 1035 .access = PL1_R, .accessfn = access_tda, 1036 .type = ARM_CP_CONST, .resetvalue = cpu->isar.dbgdevid, 1037 }; 1038 define_one_arm_cp_reg(cpu, &dbgdevid); 1039 } 1040 if (cpu_isar_feature(aa32_debugv7p1, cpu)) { 1041 ARMCPRegInfo dbgdevid12[] = { 1042 { 1043 .name = "DBGDEVID1", 1044 .cp = 14, .opc1 = 0, .crn = 7, .opc2 = 1, .crn = 7, 1045 .access = PL1_R, .accessfn = access_tda, 1046 .type = ARM_CP_CONST, .resetvalue = cpu->isar.dbgdevid1, 1047 }, { 1048 .name = "DBGDEVID2", 1049 .cp = 14, .opc1 = 0, .crn = 7, .opc2 = 0, .crn = 7, 1050 .access = PL1_R, .accessfn = access_tda, 1051 .type = ARM_CP_CONST, .resetvalue = 0, 1052 }, 1053 }; 1054 define_arm_cp_regs(cpu, dbgdevid12); 1055 } 1056 1057 brps = arm_num_brps(cpu); 1058 wrps = arm_num_wrps(cpu); 1059 ctx_cmps = arm_num_ctx_cmps(cpu); 1060 1061 assert(ctx_cmps <= brps); 1062 1063 define_arm_cp_regs(cpu, debug_cp_reginfo); 1064 1065 if (arm_feature(&cpu->env, ARM_FEATURE_LPAE)) { 1066 define_arm_cp_regs(cpu, debug_lpae_cp_reginfo); 1067 } 1068 1069 for (i = 0; i < brps; i++) { 1070 char *dbgbvr_el1_name = g_strdup_printf("DBGBVR%d_EL1", i); 1071 char *dbgbcr_el1_name = g_strdup_printf("DBGBCR%d_EL1", i); 1072 ARMCPRegInfo dbgregs[] = { 1073 { .name = dbgbvr_el1_name, .state = ARM_CP_STATE_BOTH, 1074 .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 0, .crm = i, .opc2 = 4, 1075 .access = PL1_RW, .accessfn = access_tda, 1076 .fieldoffset = offsetof(CPUARMState, cp15.dbgbvr[i]), 1077 .writefn = dbgbvr_write, .raw_writefn = raw_write 1078 }, 1079 { .name = dbgbcr_el1_name, .state = ARM_CP_STATE_BOTH, 1080 .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 0, .crm = i, .opc2 = 5, 1081 .access = PL1_RW, .accessfn = access_tda, 1082 .fieldoffset = offsetof(CPUARMState, cp15.dbgbcr[i]), 1083 .writefn = dbgbcr_write, .raw_writefn = raw_write 1084 }, 1085 }; 1086 define_arm_cp_regs(cpu, dbgregs); 1087 g_free(dbgbvr_el1_name); 1088 g_free(dbgbcr_el1_name); 1089 } 1090 1091 for (i = 0; i < wrps; i++) { 1092 char *dbgwvr_el1_name = g_strdup_printf("DBGWVR%d_EL1", i); 1093 char *dbgwcr_el1_name = g_strdup_printf("DBGWCR%d_EL1", i); 1094 ARMCPRegInfo dbgregs[] = { 1095 { .name = dbgwvr_el1_name, .state = ARM_CP_STATE_BOTH, 1096 .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 0, .crm = i, .opc2 = 6, 1097 .access = PL1_RW, .accessfn = access_tda, 1098 .fieldoffset = offsetof(CPUARMState, cp15.dbgwvr[i]), 1099 .writefn = dbgwvr_write, .raw_writefn = raw_write 1100 }, 1101 { .name = dbgwcr_el1_name, .state = ARM_CP_STATE_BOTH, 1102 .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 0, .crm = i, .opc2 = 7, 1103 .access = PL1_RW, .accessfn = access_tda, 1104 .fieldoffset = offsetof(CPUARMState, cp15.dbgwcr[i]), 1105 .writefn = dbgwcr_write, .raw_writefn = raw_write 1106 }, 1107 }; 1108 define_arm_cp_regs(cpu, dbgregs); 1109 g_free(dbgwvr_el1_name); 1110 g_free(dbgwcr_el1_name); 1111 } 1112 } 1113 1114 #if !defined(CONFIG_USER_ONLY) 1115 1116 vaddr arm_adjust_watchpoint_address(CPUState *cs, vaddr addr, int len) 1117 { 1118 ARMCPU *cpu = ARM_CPU(cs); 1119 CPUARMState *env = &cpu->env; 1120 1121 /* 1122 * In BE32 system mode, target memory is stored byteswapped (on a 1123 * little-endian host system), and by the time we reach here (via an 1124 * opcode helper) the addresses of subword accesses have been adjusted 1125 * to account for that, which means that watchpoints will not match. 1126 * Undo the adjustment here. 1127 */ 1128 if (arm_sctlr_b(env)) { 1129 if (len == 1) { 1130 addr ^= 3; 1131 } else if (len == 2) { 1132 addr ^= 2; 1133 } 1134 } 1135 1136 return addr; 1137 } 1138 1139 #endif 1140