1 // SPDX-License-Identifier: GPL-2.0 2 #include <test_util.h> 3 #include <kvm_util.h> 4 #include <processor.h> 5 #include <linux/bitfield.h> 6 7 #define MDSCR_KDE (1 << 13) 8 #define MDSCR_MDE (1 << 15) 9 #define MDSCR_SS (1 << 0) 10 11 #define DBGBCR_LEN8 (0xff << 5) 12 #define DBGBCR_EXEC (0x0 << 3) 13 #define DBGBCR_EL1 (0x1 << 1) 14 #define DBGBCR_E (0x1 << 0) 15 #define DBGBCR_LBN_SHIFT 16 16 #define DBGBCR_BT_SHIFT 20 17 #define DBGBCR_BT_ADDR_LINK_CTX (0x1 << DBGBCR_BT_SHIFT) 18 #define DBGBCR_BT_CTX_LINK (0x3 << DBGBCR_BT_SHIFT) 19 20 #define DBGWCR_LEN8 (0xff << 5) 21 #define DBGWCR_RD (0x1 << 3) 22 #define DBGWCR_WR (0x2 << 3) 23 #define DBGWCR_EL1 (0x1 << 1) 24 #define DBGWCR_E (0x1 << 0) 25 #define DBGWCR_LBN_SHIFT 16 26 #define DBGWCR_WT_SHIFT 20 27 #define DBGWCR_WT_LINK (0x1 << DBGWCR_WT_SHIFT) 28 29 #define SPSR_D (1 << 9) 30 #define SPSR_SS (1 << 21) 31 32 extern unsigned char sw_bp, sw_bp2, hw_bp, hw_bp2, bp_svc, bp_brk, hw_wp, ss_start, hw_bp_ctx; 33 extern unsigned char iter_ss_begin, iter_ss_end; 34 static volatile uint64_t sw_bp_addr, hw_bp_addr; 35 static volatile uint64_t wp_addr, wp_data_addr; 36 static volatile uint64_t svc_addr; 37 static volatile uint64_t ss_addr[4], ss_idx; 38 #define PC(v) ((uint64_t)&(v)) 39 40 #define GEN_DEBUG_WRITE_REG(reg_name) \ 41 static void write_##reg_name(int num, uint64_t val) \ 42 { \ 43 switch (num) { \ 44 case 0: \ 45 write_sysreg(val, reg_name##0_el1); \ 46 break; \ 47 case 1: \ 48 write_sysreg(val, reg_name##1_el1); \ 49 break; \ 50 case 2: \ 51 write_sysreg(val, reg_name##2_el1); \ 52 break; \ 53 case 3: \ 54 write_sysreg(val, reg_name##3_el1); \ 55 break; \ 56 case 4: \ 57 write_sysreg(val, reg_name##4_el1); \ 58 break; \ 59 case 5: \ 60 write_sysreg(val, reg_name##5_el1); \ 61 break; \ 62 case 6: \ 63 write_sysreg(val, reg_name##6_el1); \ 64 break; \ 65 case 7: \ 66 write_sysreg(val, reg_name##7_el1); \ 67 break; \ 68 case 8: \ 69 write_sysreg(val, reg_name##8_el1); \ 70 break; \ 71 case 9: \ 72 write_sysreg(val, reg_name##9_el1); \ 73 break; \ 74 case 10: \ 75 write_sysreg(val, reg_name##10_el1); \ 76 break; \ 77 case 11: \ 78 write_sysreg(val, reg_name##11_el1); \ 79 break; \ 80 case 12: \ 81 write_sysreg(val, reg_name##12_el1); \ 82 break; \ 83 case 13: \ 84 write_sysreg(val, reg_name##13_el1); \ 85 break; \ 86 case 14: \ 87 write_sysreg(val, reg_name##14_el1); \ 88 break; \ 89 case 15: \ 90 write_sysreg(val, reg_name##15_el1); \ 91 break; \ 92 default: \ 93 GUEST_ASSERT(0); \ 94 } \ 95 } 96 97 /* Define write_dbgbcr()/write_dbgbvr()/write_dbgwcr()/write_dbgwvr() */ 98 GEN_DEBUG_WRITE_REG(dbgbcr) 99 GEN_DEBUG_WRITE_REG(dbgbvr) 100 GEN_DEBUG_WRITE_REG(dbgwcr) 101 GEN_DEBUG_WRITE_REG(dbgwvr) 102 103 static void reset_debug_state(void) 104 { 105 uint8_t brps, wrps, i; 106 uint64_t dfr0; 107 108 asm volatile("msr daifset, #8"); 109 110 write_sysreg(0, osdlr_el1); 111 write_sysreg(0, oslar_el1); 112 isb(); 113 114 write_sysreg(0, mdscr_el1); 115 write_sysreg(0, contextidr_el1); 116 117 /* Reset all bcr/bvr/wcr/wvr registers */ 118 dfr0 = read_sysreg(id_aa64dfr0_el1); 119 brps = FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_BRPS), dfr0); 120 for (i = 0; i <= brps; i++) { 121 write_dbgbcr(i, 0); 122 write_dbgbvr(i, 0); 123 } 124 wrps = FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_WRPS), dfr0); 125 for (i = 0; i <= wrps; i++) { 126 write_dbgwcr(i, 0); 127 write_dbgwvr(i, 0); 128 } 129 130 isb(); 131 } 132 133 static void enable_os_lock(void) 134 { 135 write_sysreg(1, oslar_el1); 136 isb(); 137 138 GUEST_ASSERT(read_sysreg(oslsr_el1) & 2); 139 } 140 141 static void enable_monitor_debug_exceptions(void) 142 { 143 uint32_t mdscr; 144 145 asm volatile("msr daifclr, #8"); 146 147 mdscr = read_sysreg(mdscr_el1) | MDSCR_KDE | MDSCR_MDE; 148 write_sysreg(mdscr, mdscr_el1); 149 isb(); 150 } 151 152 static void install_wp(uint8_t wpn, uint64_t addr) 153 { 154 uint32_t wcr; 155 156 wcr = DBGWCR_LEN8 | DBGWCR_RD | DBGWCR_WR | DBGWCR_EL1 | DBGWCR_E; 157 write_dbgwcr(wpn, wcr); 158 write_dbgwvr(wpn, addr); 159 160 isb(); 161 162 enable_monitor_debug_exceptions(); 163 } 164 165 static void install_hw_bp(uint8_t bpn, uint64_t addr) 166 { 167 uint32_t bcr; 168 169 bcr = DBGBCR_LEN8 | DBGBCR_EXEC | DBGBCR_EL1 | DBGBCR_E; 170 write_dbgbcr(bpn, bcr); 171 write_dbgbvr(bpn, addr); 172 isb(); 173 174 enable_monitor_debug_exceptions(); 175 } 176 177 static void install_wp_ctx(uint8_t addr_wp, uint8_t ctx_bp, uint64_t addr, 178 uint64_t ctx) 179 { 180 uint32_t wcr; 181 uint64_t ctx_bcr; 182 183 /* Setup a context-aware breakpoint for Linked Context ID Match */ 184 ctx_bcr = DBGBCR_LEN8 | DBGBCR_EXEC | DBGBCR_EL1 | DBGBCR_E | 185 DBGBCR_BT_CTX_LINK; 186 write_dbgbcr(ctx_bp, ctx_bcr); 187 write_dbgbvr(ctx_bp, ctx); 188 189 /* Setup a linked watchpoint (linked to the context-aware breakpoint) */ 190 wcr = DBGWCR_LEN8 | DBGWCR_RD | DBGWCR_WR | DBGWCR_EL1 | DBGWCR_E | 191 DBGWCR_WT_LINK | ((uint32_t)ctx_bp << DBGWCR_LBN_SHIFT); 192 write_dbgwcr(addr_wp, wcr); 193 write_dbgwvr(addr_wp, addr); 194 isb(); 195 196 enable_monitor_debug_exceptions(); 197 } 198 199 void install_hw_bp_ctx(uint8_t addr_bp, uint8_t ctx_bp, uint64_t addr, 200 uint64_t ctx) 201 { 202 uint32_t addr_bcr, ctx_bcr; 203 204 /* Setup a context-aware breakpoint for Linked Context ID Match */ 205 ctx_bcr = DBGBCR_LEN8 | DBGBCR_EXEC | DBGBCR_EL1 | DBGBCR_E | 206 DBGBCR_BT_CTX_LINK; 207 write_dbgbcr(ctx_bp, ctx_bcr); 208 write_dbgbvr(ctx_bp, ctx); 209 210 /* 211 * Setup a normal breakpoint for Linked Address Match, and link it 212 * to the context-aware breakpoint. 213 */ 214 addr_bcr = DBGBCR_LEN8 | DBGBCR_EXEC | DBGBCR_EL1 | DBGBCR_E | 215 DBGBCR_BT_ADDR_LINK_CTX | 216 ((uint32_t)ctx_bp << DBGBCR_LBN_SHIFT); 217 write_dbgbcr(addr_bp, addr_bcr); 218 write_dbgbvr(addr_bp, addr); 219 isb(); 220 221 enable_monitor_debug_exceptions(); 222 } 223 224 static void install_ss(void) 225 { 226 uint32_t mdscr; 227 228 asm volatile("msr daifclr, #8"); 229 230 mdscr = read_sysreg(mdscr_el1) | MDSCR_KDE | MDSCR_SS; 231 write_sysreg(mdscr, mdscr_el1); 232 isb(); 233 } 234 235 static volatile char write_data; 236 237 static void guest_code(uint8_t bpn, uint8_t wpn, uint8_t ctx_bpn) 238 { 239 uint64_t ctx = 0xabcdef; /* a random context number */ 240 241 /* Software-breakpoint */ 242 reset_debug_state(); 243 asm volatile("sw_bp: brk #0"); 244 GUEST_ASSERT_EQ(sw_bp_addr, PC(sw_bp)); 245 246 /* Hardware-breakpoint */ 247 reset_debug_state(); 248 install_hw_bp(bpn, PC(hw_bp)); 249 asm volatile("hw_bp: nop"); 250 GUEST_ASSERT_EQ(hw_bp_addr, PC(hw_bp)); 251 252 /* Hardware-breakpoint + svc */ 253 reset_debug_state(); 254 install_hw_bp(bpn, PC(bp_svc)); 255 asm volatile("bp_svc: svc #0"); 256 GUEST_ASSERT_EQ(hw_bp_addr, PC(bp_svc)); 257 GUEST_ASSERT_EQ(svc_addr, PC(bp_svc) + 4); 258 259 /* Hardware-breakpoint + software-breakpoint */ 260 reset_debug_state(); 261 install_hw_bp(bpn, PC(bp_brk)); 262 asm volatile("bp_brk: brk #0"); 263 GUEST_ASSERT_EQ(sw_bp_addr, PC(bp_brk)); 264 GUEST_ASSERT_EQ(hw_bp_addr, PC(bp_brk)); 265 266 /* Watchpoint */ 267 reset_debug_state(); 268 install_wp(wpn, PC(write_data)); 269 write_data = 'x'; 270 GUEST_ASSERT_EQ(write_data, 'x'); 271 GUEST_ASSERT_EQ(wp_data_addr, PC(write_data)); 272 273 /* Single-step */ 274 reset_debug_state(); 275 install_ss(); 276 ss_idx = 0; 277 asm volatile("ss_start:\n" 278 "mrs x0, esr_el1\n" 279 "add x0, x0, #1\n" 280 "msr daifset, #8\n" 281 : : : "x0"); 282 GUEST_ASSERT_EQ(ss_addr[0], PC(ss_start)); 283 GUEST_ASSERT_EQ(ss_addr[1], PC(ss_start) + 4); 284 GUEST_ASSERT_EQ(ss_addr[2], PC(ss_start) + 8); 285 286 /* OS Lock does not block software-breakpoint */ 287 reset_debug_state(); 288 enable_os_lock(); 289 sw_bp_addr = 0; 290 asm volatile("sw_bp2: brk #0"); 291 GUEST_ASSERT_EQ(sw_bp_addr, PC(sw_bp2)); 292 293 /* OS Lock blocking hardware-breakpoint */ 294 reset_debug_state(); 295 enable_os_lock(); 296 install_hw_bp(bpn, PC(hw_bp2)); 297 hw_bp_addr = 0; 298 asm volatile("hw_bp2: nop"); 299 GUEST_ASSERT_EQ(hw_bp_addr, 0); 300 301 /* OS Lock blocking watchpoint */ 302 reset_debug_state(); 303 enable_os_lock(); 304 write_data = '\0'; 305 wp_data_addr = 0; 306 install_wp(wpn, PC(write_data)); 307 write_data = 'x'; 308 GUEST_ASSERT_EQ(write_data, 'x'); 309 GUEST_ASSERT_EQ(wp_data_addr, 0); 310 311 /* OS Lock blocking single-step */ 312 reset_debug_state(); 313 enable_os_lock(); 314 ss_addr[0] = 0; 315 install_ss(); 316 ss_idx = 0; 317 asm volatile("mrs x0, esr_el1\n\t" 318 "add x0, x0, #1\n\t" 319 "msr daifset, #8\n\t" 320 : : : "x0"); 321 GUEST_ASSERT_EQ(ss_addr[0], 0); 322 323 /* Linked hardware-breakpoint */ 324 hw_bp_addr = 0; 325 reset_debug_state(); 326 install_hw_bp_ctx(bpn, ctx_bpn, PC(hw_bp_ctx), ctx); 327 /* Set context id */ 328 write_sysreg(ctx, contextidr_el1); 329 isb(); 330 asm volatile("hw_bp_ctx: nop"); 331 write_sysreg(0, contextidr_el1); 332 GUEST_ASSERT_EQ(hw_bp_addr, PC(hw_bp_ctx)); 333 334 /* Linked watchpoint */ 335 reset_debug_state(); 336 install_wp_ctx(wpn, ctx_bpn, PC(write_data), ctx); 337 /* Set context id */ 338 write_sysreg(ctx, contextidr_el1); 339 isb(); 340 write_data = 'x'; 341 GUEST_ASSERT_EQ(write_data, 'x'); 342 GUEST_ASSERT_EQ(wp_data_addr, PC(write_data)); 343 344 GUEST_DONE(); 345 } 346 347 static void guest_sw_bp_handler(struct ex_regs *regs) 348 { 349 sw_bp_addr = regs->pc; 350 regs->pc += 4; 351 } 352 353 static void guest_hw_bp_handler(struct ex_regs *regs) 354 { 355 hw_bp_addr = regs->pc; 356 regs->pstate |= SPSR_D; 357 } 358 359 static void guest_wp_handler(struct ex_regs *regs) 360 { 361 wp_data_addr = read_sysreg(far_el1); 362 wp_addr = regs->pc; 363 regs->pstate |= SPSR_D; 364 } 365 366 static void guest_ss_handler(struct ex_regs *regs) 367 { 368 GUEST_ASSERT_1(ss_idx < 4, ss_idx); 369 ss_addr[ss_idx++] = regs->pc; 370 regs->pstate |= SPSR_SS; 371 } 372 373 static void guest_svc_handler(struct ex_regs *regs) 374 { 375 svc_addr = regs->pc; 376 } 377 378 static void guest_code_ss(int test_cnt) 379 { 380 uint64_t i; 381 uint64_t bvr, wvr, w_bvr, w_wvr; 382 383 for (i = 0; i < test_cnt; i++) { 384 /* Bits [1:0] of dbg{b,w}vr are RES0 */ 385 w_bvr = i << 2; 386 w_wvr = i << 2; 387 388 /* 389 * Enable Single Step execution. Note! This _must_ be a bare 390 * ucall as the ucall() path uses atomic operations to manage 391 * the ucall structures, and the built-in "atomics" are usually 392 * implemented via exclusive access instructions. The exlusive 393 * monitor is cleared on ERET, and so taking debug exceptions 394 * during a LDREX=>STREX sequence will prevent forward progress 395 * and hang the guest/test. 396 */ 397 GUEST_UCALL_NONE(); 398 399 /* 400 * The userspace will verify that the pc is as expected during 401 * single step execution between iter_ss_begin and iter_ss_end. 402 */ 403 asm volatile("iter_ss_begin:nop\n"); 404 405 write_sysreg(w_bvr, dbgbvr0_el1); 406 write_sysreg(w_wvr, dbgwvr0_el1); 407 bvr = read_sysreg(dbgbvr0_el1); 408 wvr = read_sysreg(dbgwvr0_el1); 409 410 /* Userspace disables Single Step when the end is nigh. */ 411 asm volatile("iter_ss_end:\n"); 412 413 GUEST_ASSERT(bvr == w_bvr); 414 GUEST_ASSERT(wvr == w_wvr); 415 } 416 GUEST_DONE(); 417 } 418 419 static int debug_version(uint64_t id_aa64dfr0) 420 { 421 return FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_DEBUGVER), id_aa64dfr0); 422 } 423 424 static void test_guest_debug_exceptions(uint8_t bpn, uint8_t wpn, uint8_t ctx_bpn) 425 { 426 struct kvm_vcpu *vcpu; 427 struct kvm_vm *vm; 428 struct ucall uc; 429 430 vm = vm_create_with_one_vcpu(&vcpu, guest_code); 431 432 vm_init_descriptor_tables(vm); 433 vcpu_init_descriptor_tables(vcpu); 434 435 vm_install_sync_handler(vm, VECTOR_SYNC_CURRENT, 436 ESR_EC_BRK_INS, guest_sw_bp_handler); 437 vm_install_sync_handler(vm, VECTOR_SYNC_CURRENT, 438 ESR_EC_HW_BP_CURRENT, guest_hw_bp_handler); 439 vm_install_sync_handler(vm, VECTOR_SYNC_CURRENT, 440 ESR_EC_WP_CURRENT, guest_wp_handler); 441 vm_install_sync_handler(vm, VECTOR_SYNC_CURRENT, 442 ESR_EC_SSTEP_CURRENT, guest_ss_handler); 443 vm_install_sync_handler(vm, VECTOR_SYNC_CURRENT, 444 ESR_EC_SVC64, guest_svc_handler); 445 446 /* Specify bpn/wpn/ctx_bpn to be tested */ 447 vcpu_args_set(vcpu, 3, bpn, wpn, ctx_bpn); 448 pr_debug("Use bpn#%d, wpn#%d and ctx_bpn#%d\n", bpn, wpn, ctx_bpn); 449 450 vcpu_run(vcpu); 451 switch (get_ucall(vcpu, &uc)) { 452 case UCALL_ABORT: 453 REPORT_GUEST_ASSERT_2(uc, "values: %#lx, %#lx"); 454 break; 455 case UCALL_DONE: 456 goto done; 457 default: 458 TEST_FAIL("Unknown ucall %lu", uc.cmd); 459 } 460 461 done: 462 kvm_vm_free(vm); 463 } 464 465 void test_single_step_from_userspace(int test_cnt) 466 { 467 struct kvm_vcpu *vcpu; 468 struct kvm_vm *vm; 469 struct ucall uc; 470 struct kvm_run *run; 471 uint64_t pc, cmd; 472 uint64_t test_pc = 0; 473 bool ss_enable = false; 474 struct kvm_guest_debug debug = {}; 475 476 vm = vm_create_with_one_vcpu(&vcpu, guest_code_ss); 477 run = vcpu->run; 478 vcpu_args_set(vcpu, 1, test_cnt); 479 480 while (1) { 481 vcpu_run(vcpu); 482 if (run->exit_reason != KVM_EXIT_DEBUG) { 483 cmd = get_ucall(vcpu, &uc); 484 if (cmd == UCALL_ABORT) { 485 REPORT_GUEST_ASSERT(uc); 486 /* NOT REACHED */ 487 } else if (cmd == UCALL_DONE) { 488 break; 489 } 490 491 TEST_ASSERT(cmd == UCALL_NONE, 492 "Unexpected ucall cmd 0x%lx", cmd); 493 494 debug.control = KVM_GUESTDBG_ENABLE | 495 KVM_GUESTDBG_SINGLESTEP; 496 ss_enable = true; 497 vcpu_guest_debug_set(vcpu, &debug); 498 continue; 499 } 500 501 TEST_ASSERT(ss_enable, "Unexpected KVM_EXIT_DEBUG"); 502 503 /* Check if the current pc is expected. */ 504 vcpu_get_reg(vcpu, ARM64_CORE_REG(regs.pc), &pc); 505 TEST_ASSERT(!test_pc || pc == test_pc, 506 "Unexpected pc 0x%lx (expected 0x%lx)", 507 pc, test_pc); 508 509 if ((pc + 4) == (uint64_t)&iter_ss_end) { 510 test_pc = 0; 511 debug.control = KVM_GUESTDBG_ENABLE; 512 ss_enable = false; 513 vcpu_guest_debug_set(vcpu, &debug); 514 continue; 515 } 516 517 /* 518 * If the current pc is between iter_ss_bgin and 519 * iter_ss_end, the pc for the next KVM_EXIT_DEBUG should 520 * be the current pc + 4. 521 */ 522 if ((pc >= (uint64_t)&iter_ss_begin) && 523 (pc < (uint64_t)&iter_ss_end)) 524 test_pc = pc + 4; 525 else 526 test_pc = 0; 527 } 528 529 kvm_vm_free(vm); 530 } 531 532 /* 533 * Run debug testing using the various breakpoint#, watchpoint# and 534 * context-aware breakpoint# with the given ID_AA64DFR0_EL1 configuration. 535 */ 536 void test_guest_debug_exceptions_all(uint64_t aa64dfr0) 537 { 538 uint8_t brp_num, wrp_num, ctx_brp_num, normal_brp_num, ctx_brp_base; 539 int b, w, c; 540 541 /* Number of breakpoints */ 542 brp_num = FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_BRPS), aa64dfr0) + 1; 543 __TEST_REQUIRE(brp_num >= 2, "At least two breakpoints are required"); 544 545 /* Number of watchpoints */ 546 wrp_num = FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_WRPS), aa64dfr0) + 1; 547 548 /* Number of context aware breakpoints */ 549 ctx_brp_num = FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_CTX_CMPS), aa64dfr0) + 1; 550 551 pr_debug("%s brp_num:%d, wrp_num:%d, ctx_brp_num:%d\n", __func__, 552 brp_num, wrp_num, ctx_brp_num); 553 554 /* Number of normal (non-context aware) breakpoints */ 555 normal_brp_num = brp_num - ctx_brp_num; 556 557 /* Lowest context aware breakpoint number */ 558 ctx_brp_base = normal_brp_num; 559 560 /* Run tests with all supported breakpoints/watchpoints */ 561 for (c = ctx_brp_base; c < ctx_brp_base + ctx_brp_num; c++) { 562 for (b = 0; b < normal_brp_num; b++) { 563 for (w = 0; w < wrp_num; w++) 564 test_guest_debug_exceptions(b, w, c); 565 } 566 } 567 } 568 569 static void help(char *name) 570 { 571 puts(""); 572 printf("Usage: %s [-h] [-i iterations of the single step test]\n", name); 573 puts(""); 574 exit(0); 575 } 576 577 int main(int argc, char *argv[]) 578 { 579 struct kvm_vcpu *vcpu; 580 struct kvm_vm *vm; 581 int opt; 582 int ss_iteration = 10000; 583 uint64_t aa64dfr0; 584 585 vm = vm_create_with_one_vcpu(&vcpu, guest_code); 586 vcpu_get_reg(vcpu, KVM_ARM64_SYS_REG(SYS_ID_AA64DFR0_EL1), &aa64dfr0); 587 __TEST_REQUIRE(debug_version(aa64dfr0) >= 6, 588 "Armv8 debug architecture not supported."); 589 kvm_vm_free(vm); 590 591 while ((opt = getopt(argc, argv, "i:")) != -1) { 592 switch (opt) { 593 case 'i': 594 ss_iteration = atoi_positive("Number of iterations", optarg); 595 break; 596 case 'h': 597 default: 598 help(argv[0]); 599 break; 600 } 601 } 602 603 test_guest_debug_exceptions_all(aa64dfr0); 604 test_single_step_from_userspace(ss_iteration); 605 606 return 0; 607 } 608