1 /* 2 * Ptrace interface test helper functions 3 * 4 * Copyright (C) 2015 Anshuman Khandual, IBM Corporation. 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 */ 11 #include <inttypes.h> 12 #include <unistd.h> 13 #include <stdlib.h> 14 #include <string.h> 15 #include <malloc.h> 16 #include <errno.h> 17 #include <time.h> 18 #include <sys/ptrace.h> 19 #include <sys/ioctl.h> 20 #include <sys/uio.h> 21 #include <sys/types.h> 22 #include <sys/wait.h> 23 #include <sys/signal.h> 24 #include <sys/ipc.h> 25 #include <sys/shm.h> 26 #include <sys/user.h> 27 #include <linux/elf.h> 28 #include <linux/types.h> 29 #include <linux/auxvec.h> 30 #include "reg.h" 31 #include "utils.h" 32 33 #define TEST_PASS 0 34 #define TEST_FAIL 1 35 36 struct fpr_regs { 37 unsigned long fpr[32]; 38 unsigned long fpscr; 39 }; 40 41 struct tm_spr_regs { 42 unsigned long tm_tfhar; 43 unsigned long tm_texasr; 44 unsigned long tm_tfiar; 45 }; 46 47 #ifndef NT_PPC_TAR 48 #define NT_PPC_TAR 0x103 49 #define NT_PPC_PPR 0x104 50 #define NT_PPC_DSCR 0x105 51 #define NT_PPC_EBB 0x106 52 #define NT_PPC_PMU 0x107 53 #define NT_PPC_TM_CGPR 0x108 54 #define NT_PPC_TM_CFPR 0x109 55 #define NT_PPC_TM_CVMX 0x10a 56 #define NT_PPC_TM_CVSX 0x10b 57 #define NT_PPC_TM_SPR 0x10c 58 #define NT_PPC_TM_CTAR 0x10d 59 #define NT_PPC_TM_CPPR 0x10e 60 #define NT_PPC_TM_CDSCR 0x10f 61 #endif 62 63 /* Basic ptrace operations */ 64 int start_trace(pid_t child) 65 { 66 int ret; 67 68 ret = ptrace(PTRACE_ATTACH, child, NULL, NULL); 69 if (ret) { 70 perror("ptrace(PTRACE_ATTACH) failed"); 71 return TEST_FAIL; 72 } 73 ret = waitpid(child, NULL, 0); 74 if (ret != child) { 75 perror("waitpid() failed"); 76 return TEST_FAIL; 77 } 78 return TEST_PASS; 79 } 80 81 int stop_trace(pid_t child) 82 { 83 int ret; 84 85 ret = ptrace(PTRACE_DETACH, child, NULL, NULL); 86 if (ret) { 87 perror("ptrace(PTRACE_DETACH) failed"); 88 return TEST_FAIL; 89 } 90 return TEST_PASS; 91 } 92 93 int cont_trace(pid_t child) 94 { 95 int ret; 96 97 ret = ptrace(PTRACE_CONT, child, NULL, NULL); 98 if (ret) { 99 perror("ptrace(PTRACE_CONT) failed"); 100 return TEST_FAIL; 101 } 102 return TEST_PASS; 103 } 104 105 /* TAR, PPR, DSCR */ 106 int show_tar_registers(pid_t child, unsigned long *out) 107 { 108 struct iovec iov; 109 unsigned long *reg; 110 int ret; 111 112 reg = malloc(sizeof(unsigned long)); 113 if (!reg) { 114 perror("malloc() failed"); 115 return TEST_FAIL; 116 } 117 iov.iov_base = (u64 *) reg; 118 iov.iov_len = sizeof(unsigned long); 119 120 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TAR, &iov); 121 if (ret) { 122 perror("ptrace(PTRACE_GETREGSET) failed"); 123 goto fail; 124 } 125 if (out) 126 out[0] = *reg; 127 128 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_PPR, &iov); 129 if (ret) { 130 perror("ptrace(PTRACE_GETREGSET) failed"); 131 goto fail; 132 } 133 if (out) 134 out[1] = *reg; 135 136 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_DSCR, &iov); 137 if (ret) { 138 perror("ptrace(PTRACE_GETREGSET) failed"); 139 goto fail; 140 } 141 if (out) 142 out[2] = *reg; 143 144 free(reg); 145 return TEST_PASS; 146 fail: 147 free(reg); 148 return TEST_FAIL; 149 } 150 151 int write_tar_registers(pid_t child, unsigned long tar, 152 unsigned long ppr, unsigned long dscr) 153 { 154 struct iovec iov; 155 unsigned long *reg; 156 int ret; 157 158 reg = malloc(sizeof(unsigned long)); 159 if (!reg) { 160 perror("malloc() failed"); 161 return TEST_FAIL; 162 } 163 164 iov.iov_base = (u64 *) reg; 165 iov.iov_len = sizeof(unsigned long); 166 167 *reg = tar; 168 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TAR, &iov); 169 if (ret) { 170 perror("ptrace(PTRACE_SETREGSET) failed"); 171 goto fail; 172 } 173 174 *reg = ppr; 175 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_PPR, &iov); 176 if (ret) { 177 perror("ptrace(PTRACE_SETREGSET) failed"); 178 goto fail; 179 } 180 181 *reg = dscr; 182 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_DSCR, &iov); 183 if (ret) { 184 perror("ptrace(PTRACE_SETREGSET) failed"); 185 goto fail; 186 } 187 188 free(reg); 189 return TEST_PASS; 190 fail: 191 free(reg); 192 return TEST_FAIL; 193 } 194 195 int show_tm_checkpointed_state(pid_t child, unsigned long *out) 196 { 197 struct iovec iov; 198 unsigned long *reg; 199 int ret; 200 201 reg = malloc(sizeof(unsigned long)); 202 if (!reg) { 203 perror("malloc() failed"); 204 return TEST_FAIL; 205 } 206 207 iov.iov_base = (u64 *) reg; 208 iov.iov_len = sizeof(unsigned long); 209 210 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CTAR, &iov); 211 if (ret) { 212 perror("ptrace(PTRACE_GETREGSET) failed"); 213 goto fail; 214 } 215 if (out) 216 out[0] = *reg; 217 218 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CPPR, &iov); 219 if (ret) { 220 perror("ptrace(PTRACE_GETREGSET) failed"); 221 goto fail; 222 } 223 if (out) 224 out[1] = *reg; 225 226 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CDSCR, &iov); 227 if (ret) { 228 perror("ptrace(PTRACE_GETREGSET) failed"); 229 goto fail; 230 } 231 if (out) 232 out[2] = *reg; 233 234 free(reg); 235 return TEST_PASS; 236 237 fail: 238 free(reg); 239 return TEST_FAIL; 240 } 241 242 int write_ckpt_tar_registers(pid_t child, unsigned long tar, 243 unsigned long ppr, unsigned long dscr) 244 { 245 struct iovec iov; 246 unsigned long *reg; 247 int ret; 248 249 reg = malloc(sizeof(unsigned long)); 250 if (!reg) { 251 perror("malloc() failed"); 252 return TEST_FAIL; 253 } 254 255 iov.iov_base = (u64 *) reg; 256 iov.iov_len = sizeof(unsigned long); 257 258 *reg = tar; 259 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CTAR, &iov); 260 if (ret) { 261 perror("ptrace(PTRACE_GETREGSET) failed"); 262 goto fail; 263 } 264 265 *reg = ppr; 266 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CPPR, &iov); 267 if (ret) { 268 perror("ptrace(PTRACE_GETREGSET) failed"); 269 goto fail; 270 } 271 272 *reg = dscr; 273 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CDSCR, &iov); 274 if (ret) { 275 perror("ptrace(PTRACE_GETREGSET) failed"); 276 goto fail; 277 } 278 279 free(reg); 280 return TEST_PASS; 281 fail: 282 free(reg); 283 return TEST_FAIL; 284 } 285 286 /* FPR */ 287 int show_fpr(pid_t child, unsigned long *fpr) 288 { 289 struct fpr_regs *regs; 290 int ret, i; 291 292 regs = (struct fpr_regs *) malloc(sizeof(struct fpr_regs)); 293 ret = ptrace(PTRACE_GETFPREGS, child, NULL, regs); 294 if (ret) { 295 perror("ptrace(PTRACE_GETREGSET) failed"); 296 return TEST_FAIL; 297 } 298 299 if (fpr) { 300 for (i = 0; i < 32; i++) 301 fpr[i] = regs->fpr[i]; 302 } 303 return TEST_PASS; 304 } 305 306 int write_fpr(pid_t child, unsigned long val) 307 { 308 struct fpr_regs *regs; 309 int ret, i; 310 311 regs = (struct fpr_regs *) malloc(sizeof(struct fpr_regs)); 312 ret = ptrace(PTRACE_GETFPREGS, child, NULL, regs); 313 if (ret) { 314 perror("ptrace(PTRACE_GETREGSET) failed"); 315 return TEST_FAIL; 316 } 317 318 for (i = 0; i < 32; i++) 319 regs->fpr[i] = val; 320 321 ret = ptrace(PTRACE_SETFPREGS, child, NULL, regs); 322 if (ret) { 323 perror("ptrace(PTRACE_GETREGSET) failed"); 324 return TEST_FAIL; 325 } 326 return TEST_PASS; 327 } 328 329 int show_ckpt_fpr(pid_t child, unsigned long *fpr) 330 { 331 struct fpr_regs *regs; 332 struct iovec iov; 333 int ret, i; 334 335 regs = (struct fpr_regs *) malloc(sizeof(struct fpr_regs)); 336 iov.iov_base = regs; 337 iov.iov_len = sizeof(struct fpr_regs); 338 339 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CFPR, &iov); 340 if (ret) { 341 perror("ptrace(PTRACE_GETREGSET) failed"); 342 return TEST_FAIL; 343 } 344 345 if (fpr) { 346 for (i = 0; i < 32; i++) 347 fpr[i] = regs->fpr[i]; 348 } 349 350 return TEST_PASS; 351 } 352 353 int write_ckpt_fpr(pid_t child, unsigned long val) 354 { 355 struct fpr_regs *regs; 356 struct iovec iov; 357 int ret, i; 358 359 regs = (struct fpr_regs *) malloc(sizeof(struct fpr_regs)); 360 iov.iov_base = regs; 361 iov.iov_len = sizeof(struct fpr_regs); 362 363 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CFPR, &iov); 364 if (ret) { 365 perror("ptrace(PTRACE_GETREGSET) failed"); 366 return TEST_FAIL; 367 } 368 369 for (i = 0; i < 32; i++) 370 regs->fpr[i] = val; 371 372 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CFPR, &iov); 373 if (ret) { 374 perror("ptrace(PTRACE_GETREGSET) failed"); 375 return TEST_FAIL; 376 } 377 return TEST_PASS; 378 } 379 380 /* GPR */ 381 int show_gpr(pid_t child, unsigned long *gpr) 382 { 383 struct pt_regs *regs; 384 int ret, i; 385 386 regs = (struct pt_regs *) malloc(sizeof(struct pt_regs)); 387 if (!regs) { 388 perror("malloc() failed"); 389 return TEST_FAIL; 390 } 391 392 ret = ptrace(PTRACE_GETREGS, child, NULL, regs); 393 if (ret) { 394 perror("ptrace(PTRACE_GETREGSET) failed"); 395 return TEST_FAIL; 396 } 397 398 if (gpr) { 399 for (i = 14; i < 32; i++) 400 gpr[i-14] = regs->gpr[i]; 401 } 402 403 return TEST_PASS; 404 } 405 406 int write_gpr(pid_t child, unsigned long val) 407 { 408 struct pt_regs *regs; 409 int i, ret; 410 411 regs = (struct pt_regs *) malloc(sizeof(struct pt_regs)); 412 if (!regs) { 413 perror("malloc() failed"); 414 return TEST_FAIL; 415 } 416 417 ret = ptrace(PTRACE_GETREGS, child, NULL, regs); 418 if (ret) { 419 perror("ptrace(PTRACE_GETREGSET) failed"); 420 return TEST_FAIL; 421 } 422 423 for (i = 14; i < 32; i++) 424 regs->gpr[i] = val; 425 426 ret = ptrace(PTRACE_SETREGS, child, NULL, regs); 427 if (ret) { 428 perror("ptrace(PTRACE_GETREGSET) failed"); 429 return TEST_FAIL; 430 } 431 return TEST_PASS; 432 } 433 434 int show_ckpt_gpr(pid_t child, unsigned long *gpr) 435 { 436 struct pt_regs *regs; 437 struct iovec iov; 438 int ret, i; 439 440 regs = (struct pt_regs *) malloc(sizeof(struct pt_regs)); 441 if (!regs) { 442 perror("malloc() failed"); 443 return TEST_FAIL; 444 } 445 446 iov.iov_base = (u64 *) regs; 447 iov.iov_len = sizeof(struct pt_regs); 448 449 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CGPR, &iov); 450 if (ret) { 451 perror("ptrace(PTRACE_GETREGSET) failed"); 452 return TEST_FAIL; 453 } 454 455 if (gpr) { 456 for (i = 14; i < 32; i++) 457 gpr[i-14] = regs->gpr[i]; 458 } 459 460 return TEST_PASS; 461 } 462 463 int write_ckpt_gpr(pid_t child, unsigned long val) 464 { 465 struct pt_regs *regs; 466 struct iovec iov; 467 int ret, i; 468 469 regs = (struct pt_regs *) malloc(sizeof(struct pt_regs)); 470 if (!regs) { 471 perror("malloc() failed\n"); 472 return TEST_FAIL; 473 } 474 iov.iov_base = (u64 *) regs; 475 iov.iov_len = sizeof(struct pt_regs); 476 477 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CGPR, &iov); 478 if (ret) { 479 perror("ptrace(PTRACE_GETREGSET) failed"); 480 return TEST_FAIL; 481 } 482 483 for (i = 14; i < 32; i++) 484 regs->gpr[i] = val; 485 486 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CGPR, &iov); 487 if (ret) { 488 perror("ptrace(PTRACE_GETREGSET) failed"); 489 return TEST_FAIL; 490 } 491 return TEST_PASS; 492 } 493 494 /* VMX */ 495 int show_vmx(pid_t child, unsigned long vmx[][2]) 496 { 497 int ret; 498 499 ret = ptrace(PTRACE_GETVRREGS, child, 0, vmx); 500 if (ret) { 501 perror("ptrace(PTRACE_GETVRREGS) failed"); 502 return TEST_FAIL; 503 } 504 return TEST_PASS; 505 } 506 507 int show_vmx_ckpt(pid_t child, unsigned long vmx[][2]) 508 { 509 unsigned long regs[34][2]; 510 struct iovec iov; 511 int ret; 512 513 iov.iov_base = (u64 *) regs; 514 iov.iov_len = sizeof(regs); 515 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CVMX, &iov); 516 if (ret) { 517 perror("ptrace(PTRACE_GETREGSET, NT_PPC_TM_CVMX) failed"); 518 return TEST_FAIL; 519 } 520 memcpy(vmx, regs, sizeof(regs)); 521 return TEST_PASS; 522 } 523 524 525 int write_vmx(pid_t child, unsigned long vmx[][2]) 526 { 527 int ret; 528 529 ret = ptrace(PTRACE_SETVRREGS, child, 0, vmx); 530 if (ret) { 531 perror("ptrace(PTRACE_SETVRREGS) failed"); 532 return TEST_FAIL; 533 } 534 return TEST_PASS; 535 } 536 537 int write_vmx_ckpt(pid_t child, unsigned long vmx[][2]) 538 { 539 unsigned long regs[34][2]; 540 struct iovec iov; 541 int ret; 542 543 memcpy(regs, vmx, sizeof(regs)); 544 iov.iov_base = (u64 *) regs; 545 iov.iov_len = sizeof(regs); 546 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CVMX, &iov); 547 if (ret) { 548 perror("ptrace(PTRACE_SETREGSET, NT_PPC_TM_CVMX) failed"); 549 return TEST_FAIL; 550 } 551 return TEST_PASS; 552 } 553 554 /* VSX */ 555 int show_vsx(pid_t child, unsigned long *vsx) 556 { 557 int ret; 558 559 ret = ptrace(PTRACE_GETVSRREGS, child, 0, vsx); 560 if (ret) { 561 perror("ptrace(PTRACE_GETVSRREGS) failed"); 562 return TEST_FAIL; 563 } 564 return TEST_PASS; 565 } 566 567 int show_vsx_ckpt(pid_t child, unsigned long *vsx) 568 { 569 unsigned long regs[32]; 570 struct iovec iov; 571 int ret; 572 573 iov.iov_base = (u64 *) regs; 574 iov.iov_len = sizeof(regs); 575 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CVSX, &iov); 576 if (ret) { 577 perror("ptrace(PTRACE_GETREGSET, NT_PPC_TM_CVSX) failed"); 578 return TEST_FAIL; 579 } 580 memcpy(vsx, regs, sizeof(regs)); 581 return TEST_PASS; 582 } 583 584 int write_vsx(pid_t child, unsigned long *vsx) 585 { 586 int ret; 587 588 ret = ptrace(PTRACE_SETVSRREGS, child, 0, vsx); 589 if (ret) { 590 perror("ptrace(PTRACE_SETVSRREGS) failed"); 591 return TEST_FAIL; 592 } 593 return TEST_PASS; 594 } 595 596 int write_vsx_ckpt(pid_t child, unsigned long *vsx) 597 { 598 unsigned long regs[32]; 599 struct iovec iov; 600 int ret; 601 602 memcpy(regs, vsx, sizeof(regs)); 603 iov.iov_base = (u64 *) regs; 604 iov.iov_len = sizeof(regs); 605 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CVSX, &iov); 606 if (ret) { 607 perror("ptrace(PTRACE_SETREGSET, NT_PPC_TM_CVSX) failed"); 608 return TEST_FAIL; 609 } 610 return TEST_PASS; 611 } 612 613 /* TM SPR */ 614 int show_tm_spr(pid_t child, struct tm_spr_regs *out) 615 { 616 struct tm_spr_regs *regs; 617 struct iovec iov; 618 int ret; 619 620 regs = (struct tm_spr_regs *) malloc(sizeof(struct tm_spr_regs)); 621 if (!regs) { 622 perror("malloc() failed"); 623 return TEST_FAIL; 624 } 625 626 iov.iov_base = (u64 *) regs; 627 iov.iov_len = sizeof(struct tm_spr_regs); 628 629 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_SPR, &iov); 630 if (ret) { 631 perror("ptrace(PTRACE_GETREGSET) failed"); 632 return TEST_FAIL; 633 } 634 635 if (out) 636 memcpy(out, regs, sizeof(struct tm_spr_regs)); 637 638 return TEST_PASS; 639 } 640 641 642 643 /* Analyse TEXASR after TM failure */ 644 inline unsigned long get_tfiar(void) 645 { 646 unsigned long ret; 647 648 asm volatile("mfspr %0,%1" : "=r" (ret) : "i" (SPRN_TFIAR)); 649 return ret; 650 } 651 652 void analyse_texasr(unsigned long texasr) 653 { 654 printf("TEXASR: %16lx\t", texasr); 655 656 if (texasr & TEXASR_FP) 657 printf("TEXASR_FP "); 658 659 if (texasr & TEXASR_DA) 660 printf("TEXASR_DA "); 661 662 if (texasr & TEXASR_NO) 663 printf("TEXASR_NO "); 664 665 if (texasr & TEXASR_FO) 666 printf("TEXASR_FO "); 667 668 if (texasr & TEXASR_SIC) 669 printf("TEXASR_SIC "); 670 671 if (texasr & TEXASR_NTC) 672 printf("TEXASR_NTC "); 673 674 if (texasr & TEXASR_TC) 675 printf("TEXASR_TC "); 676 677 if (texasr & TEXASR_TIC) 678 printf("TEXASR_TIC "); 679 680 if (texasr & TEXASR_IC) 681 printf("TEXASR_IC "); 682 683 if (texasr & TEXASR_IFC) 684 printf("TEXASR_IFC "); 685 686 if (texasr & TEXASR_ABT) 687 printf("TEXASR_ABT "); 688 689 if (texasr & TEXASR_SPD) 690 printf("TEXASR_SPD "); 691 692 if (texasr & TEXASR_HV) 693 printf("TEXASR_HV "); 694 695 if (texasr & TEXASR_PR) 696 printf("TEXASR_PR "); 697 698 if (texasr & TEXASR_FS) 699 printf("TEXASR_FS "); 700 701 if (texasr & TEXASR_TE) 702 printf("TEXASR_TE "); 703 704 if (texasr & TEXASR_ROT) 705 printf("TEXASR_ROT "); 706 707 printf("TFIAR :%lx\n", get_tfiar()); 708 } 709 710 void store_gpr(unsigned long *addr); 711 void store_fpr(float *addr); 712
