1 /* 2 * Copyright (c) 1991, 1992 Paul Kranenburg <pk (at) cs.few.eur.nl> 3 * Copyright (c) 1993 Branko Lankester <branko (at) hacktic.nl> 4 * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs (at) world.std.com> 5 * Copyright (c) 1996-1999 Wichert Akkerman <wichert (at) cistron.nl> 6 * Copyright (c) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation 7 * Linux for s390 port by D.J. Barrow 8 * <barrow_dj (at) mail.yahoo.com,djbarrow (at) de.ibm.com> 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. The name of the author may not be used to endorse or promote products 20 * derived from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "defs.h" 35 #include <sys/user.h> 36 #include <sys/param.h> 37 38 #ifdef HAVE_SYS_REG_H 39 # include <sys/reg.h> 40 #elif defined(HAVE_LINUX_PTRACE_H) 41 # undef PTRACE_SYSCALL 42 # ifdef HAVE_STRUCT_IA64_FPREG 43 # define ia64_fpreg XXX_ia64_fpreg 44 # endif 45 # ifdef HAVE_STRUCT_PT_ALL_USER_REGS 46 # define pt_all_user_regs XXX_pt_all_user_regs 47 # endif 48 # ifdef HAVE_STRUCT_PTRACE_PEEKSIGINFO_ARGS 49 # define ptrace_peeksiginfo_args XXX_ptrace_peeksiginfo_args 50 # endif 51 # include <linux/ptrace.h> 52 # undef ptrace_peeksiginfo_args 53 # undef ia64_fpreg 54 # undef pt_all_user_regs 55 #endif 56 57 #if defined(SPARC64) 58 # undef PTRACE_GETREGS 59 # define PTRACE_GETREGS PTRACE_GETREGS64 60 # undef PTRACE_SETREGS 61 # define PTRACE_SETREGS PTRACE_SETREGS64 62 #endif 63 64 #if defined(IA64) 65 # include <asm/ptrace_offsets.h> 66 # include <asm/rse.h> 67 #endif 68 69 /* for struct iovec */ 70 #include <sys/uio.h> 71 /* for NT_PRSTATUS */ 72 #ifdef HAVE_ELF_H 73 # include <elf.h> 74 #endif 75 76 #if defined(AARCH64) 77 # include <asm/ptrace.h> 78 #endif 79 80 #if defined(XTENSA) 81 # include <asm/ptrace.h> 82 #endif 83 84 #ifndef NSIG 85 # warning: NSIG is not defined, using 32 86 # define NSIG 32 87 #endif 88 89 #include "syscall.h" 90 91 /* Define these shorthand notations to simplify the syscallent files. */ 92 #define TD TRACE_DESC 93 #define TF TRACE_FILE 94 #define TI TRACE_IPC 95 #define TN TRACE_NETWORK 96 #define TP TRACE_PROCESS 97 #define TS TRACE_SIGNAL 98 #define TM TRACE_MEMORY 99 #define NF SYSCALL_NEVER_FAILS 100 #define MA MAX_ARGS 101 #define SI STACKTRACE_INVALIDATE_CACHE 102 #define SE STACKTRACE_CAPTURE_ON_ENTER 103 104 const struct_sysent sysent0[] = { 105 #include "syscallent.h" 106 }; 107 108 #if SUPPORTED_PERSONALITIES > 1 109 static const struct_sysent sysent1[] = { 110 # include "syscallent1.h" 111 }; 112 #endif 113 114 #if SUPPORTED_PERSONALITIES > 2 115 static const struct_sysent sysent2[] = { 116 # include "syscallent2.h" 117 }; 118 #endif 119 120 /* Now undef them since short defines cause wicked namespace pollution. */ 121 #undef TD 122 #undef TF 123 #undef TI 124 #undef TN 125 #undef TP 126 #undef TS 127 #undef TM 128 #undef NF 129 #undef MA 130 #undef SI 131 #undef SE 132 133 /* 134 * `ioctlent.h' may be generated from `ioctlent.raw' by the auxiliary 135 * program `ioctlsort', such that the list is sorted by the `code' field. 136 * This has the side-effect of resolving the _IO.. macros into 137 * plain integers, eliminating the need to include here everything 138 * in "/usr/include". 139 */ 140 141 const char *const errnoent0[] = { 142 #include "errnoent.h" 143 }; 144 const char *const signalent0[] = { 145 #include "signalent.h" 146 }; 147 const struct_ioctlent ioctlent0[] = { 148 #include "ioctlent.h" 149 }; 150 151 #if SUPPORTED_PERSONALITIES > 1 152 static const char *const errnoent1[] = { 153 # include "errnoent1.h" 154 }; 155 static const char *const signalent1[] = { 156 # include "signalent1.h" 157 }; 158 static const struct_ioctlent ioctlent1[] = { 159 # include "ioctlent1.h" 160 }; 161 #endif 162 163 #if SUPPORTED_PERSONALITIES > 2 164 static const char *const errnoent2[] = { 165 # include "errnoent2.h" 166 }; 167 static const char *const signalent2[] = { 168 # include "signalent2.h" 169 }; 170 static const struct_ioctlent ioctlent2[] = { 171 # include "ioctlent2.h" 172 }; 173 #endif 174 175 enum { 176 nsyscalls0 = ARRAY_SIZE(sysent0) 177 #if SUPPORTED_PERSONALITIES > 1 178 , nsyscalls1 = ARRAY_SIZE(sysent1) 179 # if SUPPORTED_PERSONALITIES > 2 180 , nsyscalls2 = ARRAY_SIZE(sysent2) 181 # endif 182 #endif 183 }; 184 185 enum { 186 nerrnos0 = ARRAY_SIZE(errnoent0) 187 #if SUPPORTED_PERSONALITIES > 1 188 , nerrnos1 = ARRAY_SIZE(errnoent1) 189 # if SUPPORTED_PERSONALITIES > 2 190 , nerrnos2 = ARRAY_SIZE(errnoent2) 191 # endif 192 #endif 193 }; 194 195 enum { 196 nsignals0 = ARRAY_SIZE(signalent0) 197 #if SUPPORTED_PERSONALITIES > 1 198 , nsignals1 = ARRAY_SIZE(signalent1) 199 # if SUPPORTED_PERSONALITIES > 2 200 , nsignals2 = ARRAY_SIZE(signalent2) 201 # endif 202 #endif 203 }; 204 205 enum { 206 nioctlents0 = ARRAY_SIZE(ioctlent0) 207 #if SUPPORTED_PERSONALITIES > 1 208 , nioctlents1 = ARRAY_SIZE(ioctlent1) 209 # if SUPPORTED_PERSONALITIES > 2 210 , nioctlents2 = ARRAY_SIZE(ioctlent2) 211 # endif 212 #endif 213 }; 214 215 #if SUPPORTED_PERSONALITIES > 1 216 const struct_sysent *sysent = sysent0; 217 const char *const *errnoent = errnoent0; 218 const char *const *signalent = signalent0; 219 const struct_ioctlent *ioctlent = ioctlent0; 220 #endif 221 unsigned nsyscalls = nsyscalls0; 222 unsigned nerrnos = nerrnos0; 223 unsigned nsignals = nsignals0; 224 unsigned nioctlents = nioctlents0; 225 226 unsigned num_quals; 227 qualbits_t *qual_vec[SUPPORTED_PERSONALITIES]; 228 229 static const unsigned nsyscall_vec[SUPPORTED_PERSONALITIES] = { 230 nsyscalls0, 231 #if SUPPORTED_PERSONALITIES > 1 232 nsyscalls1, 233 #endif 234 #if SUPPORTED_PERSONALITIES > 2 235 nsyscalls2, 236 #endif 237 }; 238 static const struct_sysent *const sysent_vec[SUPPORTED_PERSONALITIES] = { 239 sysent0, 240 #if SUPPORTED_PERSONALITIES > 1 241 sysent1, 242 #endif 243 #if SUPPORTED_PERSONALITIES > 2 244 sysent2, 245 #endif 246 }; 247 248 enum { 249 MAX_NSYSCALLS1 = (nsyscalls0 250 #if SUPPORTED_PERSONALITIES > 1 251 > nsyscalls1 ? nsyscalls0 : nsyscalls1 252 #endif 253 ), 254 MAX_NSYSCALLS2 = (MAX_NSYSCALLS1 255 #if SUPPORTED_PERSONALITIES > 2 256 > nsyscalls2 ? MAX_NSYSCALLS1 : nsyscalls2 257 #endif 258 ), 259 MAX_NSYSCALLS = MAX_NSYSCALLS2, 260 /* We are ready for arches with up to 255 signals, 261 * even though the largest known signo is on MIPS and it is 128. 262 * The number of existing syscalls on all arches is 263 * larger that 255 anyway, so it is just a pedantic matter. 264 */ 265 MIN_QUALS = MAX_NSYSCALLS > 255 ? MAX_NSYSCALLS : 255 266 }; 267 268 #if SUPPORTED_PERSONALITIES > 1 269 unsigned current_personality; 270 271 # ifndef current_wordsize 272 unsigned current_wordsize; 273 static const int personality_wordsize[SUPPORTED_PERSONALITIES] = { 274 PERSONALITY0_WORDSIZE, 275 PERSONALITY1_WORDSIZE, 276 # if SUPPORTED_PERSONALITIES > 2 277 PERSONALITY2_WORDSIZE, 278 # endif 279 }; 280 # endif 281 282 void 283 set_personality(int personality) 284 { 285 nsyscalls = nsyscall_vec[personality]; 286 sysent = sysent_vec[personality]; 287 288 switch (personality) { 289 case 0: 290 errnoent = errnoent0; 291 nerrnos = nerrnos0; 292 ioctlent = ioctlent0; 293 nioctlents = nioctlents0; 294 signalent = signalent0; 295 nsignals = nsignals0; 296 break; 297 298 case 1: 299 errnoent = errnoent1; 300 nerrnos = nerrnos1; 301 ioctlent = ioctlent1; 302 nioctlents = nioctlents1; 303 signalent = signalent1; 304 nsignals = nsignals1; 305 break; 306 307 # if SUPPORTED_PERSONALITIES > 2 308 case 2: 309 errnoent = errnoent2; 310 nerrnos = nerrnos2; 311 ioctlent = ioctlent2; 312 nioctlents = nioctlents2; 313 signalent = signalent2; 314 nsignals = nsignals2; 315 break; 316 # endif 317 } 318 319 current_personality = personality; 320 # ifndef current_wordsize 321 current_wordsize = personality_wordsize[personality]; 322 # endif 323 } 324 325 static void 326 update_personality(struct tcb *tcp, int personality) 327 { 328 if (personality == current_personality) 329 return; 330 set_personality(personality); 331 332 if (personality == tcp->currpers) 333 return; 334 tcp->currpers = personality; 335 336 # if defined(POWERPC64) 337 if (!qflag) { 338 static const char *const names[] = {"64 bit", "32 bit"}; 339 fprintf(stderr, "[ Process PID=%d runs in %s mode. ]\n", 340 tcp->pid, names[personality]); 341 } 342 # elif defined(X86_64) 343 if (!qflag) { 344 static const char *const names[] = {"64 bit", "32 bit", "x32"}; 345 fprintf(stderr, "[ Process PID=%d runs in %s mode. ]\n", 346 tcp->pid, names[personality]); 347 } 348 # elif defined(X32) 349 if (!qflag) { 350 static const char *const names[] = {"x32", "32 bit"}; 351 fprintf(stderr, "[ Process PID=%d runs in %s mode. ]\n", 352 tcp->pid, names[personality]); 353 } 354 # elif defined(AARCH64) 355 if (!qflag) { 356 static const char *const names[] = {"32-bit", "AArch64"}; 357 fprintf(stderr, "[ Process PID=%d runs in %s mode. ]\n", 358 tcp->pid, names[personality]); 359 } 360 # elif defined(TILE) 361 if (!qflag) { 362 static const char *const names[] = {"64-bit", "32-bit"}; 363 fprintf(stderr, "[ Process PID=%d runs in %s mode. ]\n", 364 tcp->pid, names[personality]); 365 } 366 # endif 367 } 368 #endif 369 370 static int qual_syscall(), qual_signal(), qual_desc(); 371 372 static const struct qual_options { 373 int bitflag; 374 const char *option_name; 375 int (*qualify)(const char *, int, int); 376 const char *argument_name; 377 } qual_options[] = { 378 { QUAL_TRACE, "trace", qual_syscall, "system call" }, 379 { QUAL_TRACE, "t", qual_syscall, "system call" }, 380 { QUAL_ABBREV, "abbrev", qual_syscall, "system call" }, 381 { QUAL_ABBREV, "a", qual_syscall, "system call" }, 382 { QUAL_VERBOSE, "verbose", qual_syscall, "system call" }, 383 { QUAL_VERBOSE, "v", qual_syscall, "system call" }, 384 { QUAL_RAW, "raw", qual_syscall, "system call" }, 385 { QUAL_RAW, "x", qual_syscall, "system call" }, 386 { QUAL_SIGNAL, "signal", qual_signal, "signal" }, 387 { QUAL_SIGNAL, "signals", qual_signal, "signal" }, 388 { QUAL_SIGNAL, "s", qual_signal, "signal" }, 389 { QUAL_READ, "read", qual_desc, "descriptor" }, 390 { QUAL_READ, "reads", qual_desc, "descriptor" }, 391 { QUAL_READ, "r", qual_desc, "descriptor" }, 392 { QUAL_WRITE, "write", qual_desc, "descriptor" }, 393 { QUAL_WRITE, "writes", qual_desc, "descriptor" }, 394 { QUAL_WRITE, "w", qual_desc, "descriptor" }, 395 { 0, NULL, NULL, NULL }, 396 }; 397 398 static void 399 reallocate_qual(int n) 400 { 401 unsigned p; 402 qualbits_t *qp; 403 for (p = 0; p < SUPPORTED_PERSONALITIES; p++) { 404 qp = qual_vec[p] = realloc(qual_vec[p], n * sizeof(qualbits_t)); 405 if (!qp) 406 die_out_of_memory(); 407 memset(&qp[num_quals], 0, (n - num_quals) * sizeof(qualbits_t)); 408 } 409 num_quals = n; 410 } 411 412 static void 413 qualify_one(int n, int bitflag, int not, int pers) 414 { 415 unsigned p; 416 417 if (num_quals <= n) 418 reallocate_qual(n + 1); 419 420 for (p = 0; p < SUPPORTED_PERSONALITIES; p++) { 421 if (pers == p || pers < 0) { 422 if (not) 423 qual_vec[p][n] &= ~bitflag; 424 else 425 qual_vec[p][n] |= bitflag; 426 } 427 } 428 } 429 430 static int 431 qual_syscall(const char *s, int bitflag, int not) 432 { 433 unsigned p; 434 unsigned i; 435 int rc = -1; 436 437 if (*s >= '0' && *s <= '9') { 438 i = string_to_uint(s); 439 if (i >= MAX_NSYSCALLS) 440 return -1; 441 qualify_one(i, bitflag, not, -1); 442 return 0; 443 } 444 445 for (p = 0; p < SUPPORTED_PERSONALITIES; p++) { 446 for (i = 0; i < nsyscall_vec[p]; i++) { 447 if (sysent_vec[p][i].sys_name 448 && strcmp(s, sysent_vec[p][i].sys_name) == 0 449 ) { 450 qualify_one(i, bitflag, not, p); 451 rc = 0; 452 } 453 } 454 } 455 456 return rc; 457 } 458 459 static int 460 qual_signal(const char *s, int bitflag, int not) 461 { 462 int i; 463 464 if (*s >= '0' && *s <= '9') { 465 int signo = string_to_uint(s); 466 if (signo < 0 || signo > 255) 467 return -1; 468 qualify_one(signo, bitflag, not, -1); 469 return 0; 470 } 471 if (strncasecmp(s, "SIG", 3) == 0) 472 s += 3; 473 for (i = 0; i <= NSIG; i++) { 474 if (strcasecmp(s, signame(i) + 3) == 0) { 475 qualify_one(i, bitflag, not, -1); 476 return 0; 477 } 478 } 479 return -1; 480 } 481 482 static int 483 qual_desc(const char *s, int bitflag, int not) 484 { 485 if (*s >= '0' && *s <= '9') { 486 int desc = string_to_uint(s); 487 if (desc < 0 || desc > 0x7fff) /* paranoia */ 488 return -1; 489 qualify_one(desc, bitflag, not, -1); 490 return 0; 491 } 492 return -1; 493 } 494 495 static int 496 lookup_class(const char *s) 497 { 498 if (strcmp(s, "file") == 0) 499 return TRACE_FILE; 500 if (strcmp(s, "ipc") == 0) 501 return TRACE_IPC; 502 if (strcmp(s, "network") == 0) 503 return TRACE_NETWORK; 504 if (strcmp(s, "process") == 0) 505 return TRACE_PROCESS; 506 if (strcmp(s, "signal") == 0) 507 return TRACE_SIGNAL; 508 if (strcmp(s, "desc") == 0) 509 return TRACE_DESC; 510 if (strcmp(s, "memory") == 0) 511 return TRACE_MEMORY; 512 return -1; 513 } 514 515 void 516 qualify(const char *s) 517 { 518 const struct qual_options *opt; 519 int not; 520 char *copy; 521 const char *p; 522 int i, n; 523 524 if (num_quals == 0) 525 reallocate_qual(MIN_QUALS); 526 527 opt = &qual_options[0]; 528 for (i = 0; (p = qual_options[i].option_name); i++) { 529 n = strlen(p); 530 if (strncmp(s, p, n) == 0 && s[n] == '=') { 531 opt = &qual_options[i]; 532 s += n + 1; 533 break; 534 } 535 } 536 not = 0; 537 if (*s == '!') { 538 not = 1; 539 s++; 540 } 541 if (strcmp(s, "none") == 0) { 542 not = 1 - not; 543 s = "all"; 544 } 545 if (strcmp(s, "all") == 0) { 546 for (i = 0; i < num_quals; i++) { 547 qualify_one(i, opt->bitflag, not, -1); 548 } 549 return; 550 } 551 for (i = 0; i < num_quals; i++) { 552 qualify_one(i, opt->bitflag, !not, -1); 553 } 554 copy = strdup(s); 555 if (!copy) 556 die_out_of_memory(); 557 for (p = strtok(copy, ","); p; p = strtok(NULL, ",")) { 558 if (opt->bitflag == QUAL_TRACE && (n = lookup_class(p)) > 0) { 559 unsigned pers; 560 for (pers = 0; pers < SUPPORTED_PERSONALITIES; pers++) { 561 for (i = 0; i < nsyscall_vec[pers]; i++) 562 if (sysent_vec[pers][i].sys_flags & n) 563 qualify_one(i, opt->bitflag, not, pers); 564 } 565 continue; 566 } 567 if (opt->qualify(p, opt->bitflag, not)) { 568 error_msg_and_die("invalid %s '%s'", 569 opt->argument_name, p); 570 } 571 } 572 free(copy); 573 return; 574 } 575 576 #ifdef SYS_socket_subcall 577 static void 578 decode_socket_subcall(struct tcb *tcp) 579 { 580 unsigned long addr; 581 unsigned int i, n, size; 582 583 if (tcp->u_arg[0] < 0 || tcp->u_arg[0] >= SYS_socket_nsubcalls) 584 return; 585 586 tcp->scno = SYS_socket_subcall + tcp->u_arg[0]; 587 tcp->qual_flg = qual_flags[tcp->scno]; 588 tcp->s_ent = &sysent[tcp->scno]; 589 addr = tcp->u_arg[1]; 590 size = current_wordsize; 591 n = tcp->s_ent->nargs; 592 for (i = 0; i < n; ++i) { 593 if (size == sizeof(int)) { 594 unsigned int arg; 595 if (umove(tcp, addr, &arg) < 0) 596 arg = 0; 597 tcp->u_arg[i] = arg; 598 } 599 else { 600 unsigned long arg; 601 if (umove(tcp, addr, &arg) < 0) 602 arg = 0; 603 tcp->u_arg[i] = arg; 604 } 605 addr += size; 606 } 607 } 608 #endif 609 610 #ifdef SYS_ipc_subcall 611 static void 612 decode_ipc_subcall(struct tcb *tcp) 613 { 614 unsigned int i, n; 615 616 if (tcp->u_arg[0] < 0 || tcp->u_arg[0] >= SYS_ipc_nsubcalls) 617 return; 618 619 tcp->scno = SYS_ipc_subcall + tcp->u_arg[0]; 620 tcp->qual_flg = qual_flags[tcp->scno]; 621 tcp->s_ent = &sysent[tcp->scno]; 622 n = tcp->s_ent->nargs; 623 for (i = 0; i < n; i++) 624 tcp->u_arg[i] = tcp->u_arg[i + 1]; 625 } 626 #endif 627 628 int 629 printargs(struct tcb *tcp) 630 { 631 if (entering(tcp)) { 632 int i; 633 int n = tcp->s_ent->nargs; 634 for (i = 0; i < n; i++) 635 tprintf("%s%#lx", i ? ", " : "", tcp->u_arg[i]); 636 } 637 return 0; 638 } 639 640 int 641 printargs_lu(struct tcb *tcp) 642 { 643 if (entering(tcp)) { 644 int i; 645 int n = tcp->s_ent->nargs; 646 for (i = 0; i < n; i++) 647 tprintf("%s%lu", i ? ", " : "", tcp->u_arg[i]); 648 } 649 return 0; 650 } 651 652 int 653 printargs_ld(struct tcb *tcp) 654 { 655 if (entering(tcp)) { 656 int i; 657 int n = tcp->s_ent->nargs; 658 for (i = 0; i < n; i++) 659 tprintf("%s%ld", i ? ", " : "", tcp->u_arg[i]); 660 } 661 return 0; 662 } 663 664 #if defined(SPARC) || defined(SPARC64) || defined(IA64) || defined(SH) 665 long 666 getrval2(struct tcb *tcp) 667 { 668 long val; 669 670 # if defined(SPARC) || defined(SPARC64) 671 val = sparc_regs.u_regs[U_REG_O1]; 672 # elif defined(SH) 673 if (upeek(tcp->pid, 4*(REG_REG0+1), &val) < 0) 674 return -1; 675 # elif defined(IA64) 676 if (upeek(tcp->pid, PT_R9, &val) < 0) 677 return -1; 678 # endif 679 680 return val; 681 } 682 #endif 683 684 #if defined(I386) 685 static struct user_regs_struct i386_regs; 686 /* Cast suppresses signedness warning (.esp is long, not unsigned long) */ 687 uint32_t *const i386_esp_ptr = (uint32_t*)&i386_regs.esp; 688 # define ARCH_REGS_FOR_GETREGSET i386_regs 689 #elif defined(X86_64) || defined(X32) 690 /* 691 * On i386, pt_regs and user_regs_struct are the same, 692 * but on 64 bit x86, user_regs_struct has six more fields: 693 * fs_base, gs_base, ds, es, fs, gs. 694 * PTRACE_GETREGS fills them too, so struct pt_regs would overflow. 695 */ 696 struct i386_user_regs_struct { 697 uint32_t ebx; 698 uint32_t ecx; 699 uint32_t edx; 700 uint32_t esi; 701 uint32_t edi; 702 uint32_t ebp; 703 uint32_t eax; 704 uint32_t xds; 705 uint32_t xes; 706 uint32_t xfs; 707 uint32_t xgs; 708 uint32_t orig_eax; 709 uint32_t eip; 710 uint32_t xcs; 711 uint32_t eflags; 712 uint32_t esp; 713 uint32_t xss; 714 }; 715 static union { 716 struct user_regs_struct x86_64_r; 717 struct i386_user_regs_struct i386_r; 718 } x86_regs_union; 719 # define x86_64_regs x86_regs_union.x86_64_r 720 # define i386_regs x86_regs_union.i386_r 721 uint32_t *const i386_esp_ptr = &i386_regs.esp; 722 static struct iovec x86_io = { 723 .iov_base = &x86_regs_union 724 }; 725 #elif defined(IA64) 726 bool ia64_ia32mode = 0; /* not static */ 727 static long ia64_r8, ia64_r10; 728 #elif defined(POWERPC) 729 struct pt_regs ppc_regs; 730 #elif defined(M68K) 731 static long m68k_d0; 732 #elif defined(BFIN) 733 static long bfin_r0; 734 #elif defined(ARM) 735 struct pt_regs arm_regs; /* not static */ 736 # define ARCH_REGS_FOR_GETREGSET arm_regs 737 #elif defined(AARCH64) 738 static union { 739 struct user_pt_regs aarch64_r; 740 struct arm_pt_regs arm_r; 741 } arm_regs_union; 742 # define aarch64_regs arm_regs_union.aarch64_r 743 # define arm_regs arm_regs_union.arm_r 744 static struct iovec aarch64_io = { 745 .iov_base = &arm_regs_union 746 }; 747 #elif defined(ALPHA) 748 static long alpha_r0; 749 static long alpha_a3; 750 #elif defined(AVR32) 751 static struct pt_regs avr32_regs; 752 #elif defined(SPARC) || defined(SPARC64) 753 struct pt_regs sparc_regs; /* not static */ 754 #elif defined(LINUX_MIPSN32) 755 static long long mips_a3; 756 static long long mips_r2; 757 #elif defined(MIPS) 758 static long mips_a3; 759 static long mips_r2; 760 #elif defined(S390) || defined(S390X) 761 static long s390_gpr2; 762 #elif defined(HPPA) 763 static long hppa_r28; 764 #elif defined(SH) 765 static long sh_r0; 766 #elif defined(SH64) 767 static long sh64_r9; 768 #elif defined(CRISV10) || defined(CRISV32) 769 static long cris_r10; 770 #elif defined(TILE) 771 struct pt_regs tile_regs; 772 #elif defined(MICROBLAZE) 773 static long microblaze_r3; 774 #elif defined(OR1K) 775 static struct user_regs_struct or1k_regs; 776 # define ARCH_REGS_FOR_GETREGSET or1k_regs 777 #elif defined(METAG) 778 static struct user_gp_regs metag_regs; 779 # define ARCH_REGS_FOR_GETREGSET metag_regs 780 #elif defined(XTENSA) 781 static long xtensa_a2; 782 # elif defined(ARC) 783 static struct user_regs_struct arc_regs; 784 # define ARCH_REGS_FOR_GETREGSET arc_regs 785 #endif 786 787 void 788 print_pc(struct tcb *tcp) 789 { 790 #define PRINTBADPC tprintf(sizeof(long) == 4 ? "[????????] " : \ 791 sizeof(long) == 8 ? "[????????????????] " : \ 792 NULL /* crash */) 793 if (get_regs_error) { 794 PRINTBADPC; 795 return; 796 } 797 #if defined(I386) 798 tprintf("[%08lx] ", i386_regs.eip); 799 #elif defined(S390) || defined(S390X) 800 long psw; 801 if (upeek(tcp->pid, PT_PSWADDR, &psw) < 0) { 802 PRINTBADPC; 803 return; 804 } 805 # ifdef S390 806 tprintf("[%08lx] ", psw); 807 # elif S390X 808 tprintf("[%016lx] ", psw); 809 # endif 810 #elif defined(X86_64) || defined(X32) 811 if (x86_io.iov_len == sizeof(i386_regs)) { 812 tprintf("[%08x] ", (unsigned) i386_regs.eip); 813 } else { 814 # if defined(X86_64) 815 tprintf("[%016lx] ", (unsigned long) x86_64_regs.rip); 816 # elif defined(X32) 817 /* Note: this truncates 64-bit rip to 32 bits */ 818 tprintf("[%08lx] ", (unsigned long) x86_64_regs.rip); 819 # endif 820 } 821 #elif defined(IA64) 822 long ip; 823 if (upeek(tcp->pid, PT_B0, &ip) < 0) { 824 PRINTBADPC; 825 return; 826 } 827 tprintf("[%08lx] ", ip); 828 #elif defined(POWERPC) 829 long pc = ppc_regs.nip; 830 # ifdef POWERPC64 831 tprintf("[%016lx] ", pc); 832 # else 833 tprintf("[%08lx] ", pc); 834 # endif 835 #elif defined(M68K) 836 long pc; 837 if (upeek(tcp->pid, 4*PT_PC, &pc) < 0) { 838 tprints("[????????] "); 839 return; 840 } 841 tprintf("[%08lx] ", pc); 842 #elif defined(ALPHA) 843 long pc; 844 if (upeek(tcp->pid, REG_PC, &pc) < 0) { 845 tprints("[????????????????] "); 846 return; 847 } 848 tprintf("[%08lx] ", pc); 849 #elif defined(SPARC) 850 tprintf("[%08lx] ", sparc_regs.pc); 851 #elif defined(SPARC64) 852 tprintf("[%08lx] ", sparc_regs.tpc); 853 #elif defined(HPPA) 854 long pc; 855 if (upeek(tcp->pid, PT_IAOQ0, &pc) < 0) { 856 tprints("[????????] "); 857 return; 858 } 859 tprintf("[%08lx] ", pc); 860 #elif defined(MIPS) 861 long pc; 862 if (upeek(tcp->pid, REG_EPC, &pc) < 0) { 863 tprints("[????????] "); 864 return; 865 } 866 tprintf("[%08lx] ", pc); 867 #elif defined(SH) 868 long pc; 869 if (upeek(tcp->pid, 4*REG_PC, &pc) < 0) { 870 tprints("[????????] "); 871 return; 872 } 873 tprintf("[%08lx] ", pc); 874 #elif defined(SH64) 875 long pc; 876 if (upeek(tcp->pid, REG_PC, &pc) < 0) { 877 tprints("[????????????????] "); 878 return; 879 } 880 tprintf("[%08lx] ", pc); 881 #elif defined(ARM) 882 tprintf("[%08lx] ", arm_regs.ARM_pc); 883 #elif defined(AARCH64) 884 /* tprintf("[%016lx] ", aarch64_regs.regs[???]); */ 885 #elif defined(AVR32) 886 tprintf("[%08lx] ", avr32_regs.pc); 887 #elif defined(BFIN) 888 long pc; 889 if (upeek(tcp->pid, PT_PC, &pc) < 0) { 890 PRINTBADPC; 891 return; 892 } 893 tprintf("[%08lx] ", pc); 894 #elif defined(CRISV10) 895 long pc; 896 if (upeek(tcp->pid, 4*PT_IRP, &pc) < 0) { 897 PRINTBADPC; 898 return; 899 } 900 tprintf("[%08lx] ", pc); 901 #elif defined(CRISV32) 902 long pc; 903 if (upeek(tcp->pid, 4*PT_ERP, &pc) < 0) { 904 PRINTBADPC; 905 return; 906 } 907 tprintf("[%08lx] ", pc); 908 #elif defined(TILE) 909 # ifdef _LP64 910 tprintf("[%016lx] ", (unsigned long) tile_regs.pc); 911 # else 912 tprintf("[%08lx] ", (unsigned long) tile_regs.pc); 913 # endif 914 #elif defined(OR1K) 915 tprintf("[%08lx] ", or1k_regs.pc); 916 #elif defined(METAG) 917 tprintf("[%08lx] ", metag_regs.pc); 918 #elif defined(XTENSA) 919 long pc; 920 if (upeek(tcp->pid, REG_PC, &pc) < 0) { 921 PRINTBADPC; 922 return; 923 } 924 tprintf("[%08lx] ", pc); 925 #elif defined(ARC) 926 tprintf("[%08lx] ", arc_regs.efa); 927 #endif /* architecture */ 928 } 929 930 /* Shuffle syscall numbers so that we don't have huge gaps in syscall table. 931 * The shuffling should be reversible: shuffle_scno(shuffle_scno(n)) == n. 932 */ 933 #if defined(ARM) || defined(AARCH64) /* So far only 32-bit ARM needs this */ 934 static long 935 shuffle_scno(unsigned long scno) 936 { 937 if (scno <= ARM_LAST_ORDINARY_SYSCALL) 938 return scno; 939 940 /* __ARM_NR_cmpxchg? Swap with LAST_ORDINARY+1 */ 941 if (scno == 0x000ffff0) 942 return ARM_LAST_ORDINARY_SYSCALL+1; 943 if (scno == ARM_LAST_ORDINARY_SYSCALL+1) 944 return 0x000ffff0; 945 946 /* Is it ARM specific syscall? 947 * Swap with [LAST_ORDINARY+2, LAST_ORDINARY+2 + LAST_SPECIAL] range. 948 */ 949 if (scno >= 0x000f0000 950 && scno <= 0x000f0000 + ARM_LAST_SPECIAL_SYSCALL 951 ) { 952 return scno - 0x000f0000 + (ARM_LAST_ORDINARY_SYSCALL+2); 953 } 954 if (/* scno >= ARM_LAST_ORDINARY_SYSCALL+2 - always true */ 1 955 && scno <= (ARM_LAST_ORDINARY_SYSCALL+2) + ARM_LAST_SPECIAL_SYSCALL 956 ) { 957 return scno + 0x000f0000 - (ARM_LAST_ORDINARY_SYSCALL+2); 958 } 959 960 return scno; 961 } 962 #else 963 # define shuffle_scno(scno) ((long)(scno)) 964 #endif 965 966 static char* 967 undefined_scno_name(struct tcb *tcp) 968 { 969 static char buf[sizeof("syscall_%lu") + sizeof(long)*3]; 970 971 sprintf(buf, "syscall_%lu", shuffle_scno(tcp->scno)); 972 return buf; 973 } 974 975 #ifdef POWERPC 976 /* 977 * PTRACE_GETREGS was added to the PowerPC kernel in v2.6.23, 978 * we provide a slow fallback for old kernels. 979 */ 980 static int powerpc_getregs_old(pid_t pid) 981 { 982 int i; 983 long r; 984 985 if (iflag) { 986 r = upeek(pid, sizeof(long) * PT_NIP, (long *)&ppc_regs.nip); 987 if (r) 988 goto out; 989 } 990 #ifdef POWERPC64 /* else we never use it */ 991 r = upeek(pid, sizeof(long) * PT_MSR, (long *)&ppc_regs.msr); 992 if (r) 993 goto out; 994 #endif 995 r = upeek(pid, sizeof(long) * PT_CCR, (long *)&ppc_regs.ccr); 996 if (r) 997 goto out; 998 r = upeek(pid, sizeof(long) * PT_ORIG_R3, (long *)&ppc_regs.orig_gpr3); 999 if (r) 1000 goto out; 1001 for (i = 0; i <= 8; i++) { 1002 r = upeek(pid, sizeof(long) * (PT_R0 + i), 1003 (long *)&ppc_regs.gpr[i]); 1004 if (r) 1005 goto out; 1006 } 1007 out: 1008 return r; 1009 } 1010 #endif 1011 1012 #ifndef get_regs 1013 long get_regs_error; 1014 1015 #if defined(PTRACE_GETREGSET) && defined(NT_PRSTATUS) 1016 static void get_regset(pid_t pid) 1017 { 1018 /* constant iovec */ 1019 # if defined(ARM) \ 1020 || defined(I386) \ 1021 || defined(METAG) \ 1022 || defined(OR1K) \ 1023 || defined(ARC) 1024 static struct iovec io = { 1025 .iov_base = &ARCH_REGS_FOR_GETREGSET, 1026 .iov_len = sizeof(ARCH_REGS_FOR_GETREGSET) 1027 }; 1028 get_regs_error = ptrace(PTRACE_GETREGSET, pid, NT_PRSTATUS, &io); 1029 1030 /* variable iovec */ 1031 # elif defined(X86_64) || defined(X32) 1032 /* x86_io.iov_base = &x86_regs_union; - already is */ 1033 x86_io.iov_len = sizeof(x86_regs_union); 1034 get_regs_error = ptrace(PTRACE_GETREGSET, pid, NT_PRSTATUS, &x86_io); 1035 # elif defined(AARCH64) 1036 /* aarch64_io.iov_base = &arm_regs_union; - already is */ 1037 aarch64_io.iov_len = sizeof(arm_regs_union); 1038 get_regs_error = ptrace(PTRACE_GETREGSET, pid, NT_PRSTATUS, &aarch64_io); 1039 # else 1040 # warning both PTRACE_GETREGSET and NT_PRSTATUS are available but not yet used 1041 # endif 1042 } 1043 #endif /* PTRACE_GETREGSET && NT_PRSTATUS */ 1044 1045 void 1046 get_regs(pid_t pid) 1047 { 1048 /* PTRACE_GETREGSET only */ 1049 # if defined(METAG) || defined(OR1K) || defined(X32) || defined(AARCH64) || defined(ARC) 1050 get_regset(pid); 1051 1052 /* PTRACE_GETREGS only */ 1053 # elif defined(AVR32) 1054 get_regs_error = ptrace(PTRACE_GETREGS, pid, NULL, &avr32_regs); 1055 # elif defined(TILE) 1056 get_regs_error = ptrace(PTRACE_GETREGS, pid, NULL, &tile_regs); 1057 # elif defined(SPARC) || defined(SPARC64) 1058 get_regs_error = ptrace(PTRACE_GETREGS, pid, (char *)&sparc_regs, 0); 1059 # elif defined(POWERPC) 1060 static bool old_kernel = 0; 1061 if (old_kernel) 1062 goto old; 1063 get_regs_error = ptrace(PTRACE_GETREGS, pid, NULL, (long) &ppc_regs); 1064 if (get_regs_error && errno == EIO) { 1065 old_kernel = 1; 1066 old: 1067 get_regs_error = powerpc_getregs_old(pid); 1068 } 1069 1070 /* try PTRACE_GETREGSET first, fallback to PTRACE_GETREGS */ 1071 # else 1072 # if defined(PTRACE_GETREGSET) && defined(NT_PRSTATUS) 1073 static int getregset_support; 1074 1075 if (getregset_support >= 0) { 1076 get_regset(pid); 1077 if (getregset_support > 0) 1078 return; 1079 if (get_regs_error >= 0) { 1080 getregset_support = 1; 1081 return; 1082 } 1083 if (errno == EPERM || errno == ESRCH) 1084 return; 1085 getregset_support = -1; 1086 } 1087 # endif /* PTRACE_GETREGSET && NT_PRSTATUS */ 1088 # if defined(ARM) 1089 get_regs_error = ptrace(PTRACE_GETREGS, pid, NULL, &arm_regs); 1090 # elif defined(I386) 1091 get_regs_error = ptrace(PTRACE_GETREGS, pid, NULL, &i386_regs); 1092 # elif defined(X86_64) 1093 /* Use old method, with unreliable heuristical detection of 32-bitness. */ 1094 x86_io.iov_len = sizeof(x86_64_regs); 1095 get_regs_error = ptrace(PTRACE_GETREGS, pid, NULL, &x86_64_regs); 1096 if (!get_regs_error && x86_64_regs.cs == 0x23) { 1097 x86_io.iov_len = sizeof(i386_regs); 1098 /* 1099 * The order is important: i386_regs and x86_64_regs 1100 * are overlaid in memory! 1101 */ 1102 i386_regs.ebx = x86_64_regs.rbx; 1103 i386_regs.ecx = x86_64_regs.rcx; 1104 i386_regs.edx = x86_64_regs.rdx; 1105 i386_regs.esi = x86_64_regs.rsi; 1106 i386_regs.edi = x86_64_regs.rdi; 1107 i386_regs.ebp = x86_64_regs.rbp; 1108 i386_regs.eax = x86_64_regs.rax; 1109 /* i386_regs.xds = x86_64_regs.ds; unused by strace */ 1110 /* i386_regs.xes = x86_64_regs.es; ditto... */ 1111 /* i386_regs.xfs = x86_64_regs.fs; */ 1112 /* i386_regs.xgs = x86_64_regs.gs; */ 1113 i386_regs.orig_eax = x86_64_regs.orig_rax; 1114 i386_regs.eip = x86_64_regs.rip; 1115 /* i386_regs.xcs = x86_64_regs.cs; */ 1116 /* i386_regs.eflags = x86_64_regs.eflags; */ 1117 i386_regs.esp = x86_64_regs.rsp; 1118 /* i386_regs.xss = x86_64_regs.ss; */ 1119 } 1120 # else 1121 # error unhandled architecture 1122 # endif /* ARM || I386 || X86_64 */ 1123 # endif 1124 } 1125 #endif /* !get_regs */ 1126 1127 /* Returns: 1128 * 0: "ignore this ptrace stop", bail out of trace_syscall_entering() silently. 1129 * 1: ok, continue in trace_syscall_entering(). 1130 * other: error, trace_syscall_entering() should print error indicator 1131 * ("????" etc) and bail out. 1132 */ 1133 static int 1134 get_scno(struct tcb *tcp) 1135 { 1136 long scno = 0; 1137 1138 #if defined(S390) || defined(S390X) 1139 if (upeek(tcp->pid, PT_GPR2, &s390_gpr2) < 0) 1140 return -1; 1141 1142 if (s390_gpr2 != -ENOSYS) { 1143 /* 1144 * Since kernel version 2.5.44 the scno gets passed in gpr2. 1145 */ 1146 scno = s390_gpr2; 1147 } else { 1148 /* 1149 * Old style of "passing" the scno via the SVC instruction. 1150 */ 1151 long psw; 1152 long opcode, offset_reg, tmp; 1153 void *svc_addr; 1154 static const int gpr_offset[16] = { 1155 PT_GPR0, PT_GPR1, PT_ORIGGPR2, PT_GPR3, 1156 PT_GPR4, PT_GPR5, PT_GPR6, PT_GPR7, 1157 PT_GPR8, PT_GPR9, PT_GPR10, PT_GPR11, 1158 PT_GPR12, PT_GPR13, PT_GPR14, PT_GPR15 1159 }; 1160 1161 if (upeek(tcp->pid, PT_PSWADDR, &psw) < 0) 1162 return -1; 1163 errno = 0; 1164 opcode = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)(psw - sizeof(long)), 0); 1165 if (errno) { 1166 perror_msg("peektext(psw-oneword)"); 1167 return -1; 1168 } 1169 1170 /* 1171 * We have to check if the SVC got executed directly or via an 1172 * EXECUTE instruction. In case of EXECUTE it is necessary to do 1173 * instruction decoding to derive the system call number. 1174 * Unfortunately the opcode sizes of EXECUTE and SVC are differently, 1175 * so that this doesn't work if a SVC opcode is part of an EXECUTE 1176 * opcode. Since there is no way to find out the opcode size this 1177 * is the best we can do... 1178 */ 1179 if ((opcode & 0xff00) == 0x0a00) { 1180 /* SVC opcode */ 1181 scno = opcode & 0xff; 1182 } 1183 else { 1184 /* SVC got executed by EXECUTE instruction */ 1185 1186 /* 1187 * Do instruction decoding of EXECUTE. If you really want to 1188 * understand this, read the Principles of Operations. 1189 */ 1190 svc_addr = (void *) (opcode & 0xfff); 1191 1192 tmp = 0; 1193 offset_reg = (opcode & 0x000f0000) >> 16; 1194 if (offset_reg && (upeek(tcp->pid, gpr_offset[offset_reg], &tmp) < 0)) 1195 return -1; 1196 svc_addr += tmp; 1197 1198 tmp = 0; 1199 offset_reg = (opcode & 0x0000f000) >> 12; 1200 if (offset_reg && (upeek(tcp->pid, gpr_offset[offset_reg], &tmp) < 0)) 1201 return -1; 1202 svc_addr += tmp; 1203 1204 scno = ptrace(PTRACE_PEEKTEXT, tcp->pid, svc_addr, 0); 1205 if (errno) 1206 return -1; 1207 # if defined(S390X) 1208 scno >>= 48; 1209 # else 1210 scno >>= 16; 1211 # endif 1212 tmp = 0; 1213 offset_reg = (opcode & 0x00f00000) >> 20; 1214 if (offset_reg && (upeek(tcp->pid, gpr_offset[offset_reg], &tmp) < 0)) 1215 return -1; 1216 1217 scno = (scno | tmp) & 0xff; 1218 } 1219 } 1220 #elif defined(POWERPC) 1221 scno = ppc_regs.gpr[0]; 1222 # ifdef POWERPC64 1223 int currpers; 1224 1225 /* 1226 * Check for 64/32 bit mode. 1227 * Embedded implementations covered by Book E extension of PPC use 1228 * bit 0 (CM) of 32-bit Machine state register (MSR). 1229 * Other implementations use bit 0 (SF) of 64-bit MSR. 1230 */ 1231 currpers = (ppc_regs.msr & 0x8000000080000000) ? 0 : 1; 1232 update_personality(tcp, currpers); 1233 # endif 1234 #elif defined(AVR32) 1235 scno = avr32_regs.r8; 1236 #elif defined(BFIN) 1237 if (upeek(tcp->pid, PT_ORIG_P0, &scno)) 1238 return -1; 1239 #elif defined(I386) 1240 scno = i386_regs.orig_eax; 1241 #elif defined(X86_64) || defined(X32) 1242 # ifndef __X32_SYSCALL_BIT 1243 # define __X32_SYSCALL_BIT 0x40000000 1244 # endif 1245 int currpers; 1246 # if 1 1247 /* GETREGSET of NT_PRSTATUS tells us regset size, 1248 * which unambiguously detects i386. 1249 * 1250 * Linux kernel distinguishes x86-64 and x32 processes 1251 * solely by looking at __X32_SYSCALL_BIT: 1252 * arch/x86/include/asm/compat.h::is_x32_task(): 1253 * if (task_pt_regs(current)->orig_ax & __X32_SYSCALL_BIT) 1254 * return true; 1255 */ 1256 if (x86_io.iov_len == sizeof(i386_regs)) { 1257 scno = i386_regs.orig_eax; 1258 currpers = 1; 1259 } else { 1260 scno = x86_64_regs.orig_rax; 1261 currpers = 0; 1262 if (scno & __X32_SYSCALL_BIT) { 1263 scno -= __X32_SYSCALL_BIT; 1264 currpers = 2; 1265 } 1266 } 1267 # elif 0 1268 /* cs = 0x33 for long mode (native 64 bit and x32) 1269 * cs = 0x23 for compatibility mode (32 bit) 1270 * ds = 0x2b for x32 mode (x86-64 in 32 bit) 1271 */ 1272 scno = x86_64_regs.orig_rax; 1273 switch (x86_64_regs.cs) { 1274 case 0x23: currpers = 1; break; 1275 case 0x33: 1276 if (x86_64_regs.ds == 0x2b) { 1277 currpers = 2; 1278 scno &= ~__X32_SYSCALL_BIT; 1279 } else 1280 currpers = 0; 1281 break; 1282 default: 1283 fprintf(stderr, "Unknown value CS=0x%08X while " 1284 "detecting personality of process " 1285 "PID=%d\n", (int)x86_64_regs.cs, tcp->pid); 1286 currpers = current_personality; 1287 break; 1288 } 1289 # elif 0 1290 /* This version analyzes the opcode of a syscall instruction. 1291 * (int 0x80 on i386 vs. syscall on x86-64) 1292 * It works, but is too complicated, and strictly speaking, unreliable. 1293 */ 1294 unsigned long call, rip = x86_64_regs.rip; 1295 /* sizeof(syscall) == sizeof(int 0x80) == 2 */ 1296 rip -= 2; 1297 errno = 0; 1298 call = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)rip, (char *)0); 1299 if (errno) 1300 fprintf(stderr, "ptrace_peektext failed: %s\n", 1301 strerror(errno)); 1302 switch (call & 0xffff) { 1303 /* x86-64: syscall = 0x0f 0x05 */ 1304 case 0x050f: currpers = 0; break; 1305 /* i386: int 0x80 = 0xcd 0x80 */ 1306 case 0x80cd: currpers = 1; break; 1307 default: 1308 currpers = current_personality; 1309 fprintf(stderr, 1310 "Unknown syscall opcode (0x%04X) while " 1311 "detecting personality of process " 1312 "PID=%d\n", (int)call, tcp->pid); 1313 break; 1314 } 1315 # endif 1316 1317 # ifdef X32 1318 /* If we are built for a x32 system, then personality 0 is x32 1319 * (not x86_64), and stracing of x86_64 apps is not supported. 1320 * Stracing of i386 apps is still supported. 1321 */ 1322 if (currpers == 0) { 1323 fprintf(stderr, "syscall_%lu(...) in unsupported " 1324 "64-bit mode of process PID=%d\n", 1325 scno, tcp->pid); 1326 return 0; 1327 } 1328 currpers &= ~2; /* map 2,1 to 0,1 */ 1329 # endif 1330 update_personality(tcp, currpers); 1331 #elif defined(IA64) 1332 # define IA64_PSR_IS ((long)1 << 34) 1333 long psr; 1334 if (upeek(tcp->pid, PT_CR_IPSR, &psr) >= 0) 1335 ia64_ia32mode = ((psr & IA64_PSR_IS) != 0); 1336 if (ia64_ia32mode) { 1337 if (upeek(tcp->pid, PT_R1, &scno) < 0) 1338 return -1; 1339 } else { 1340 if (upeek(tcp->pid, PT_R15, &scno) < 0) 1341 return -1; 1342 } 1343 #elif defined(AARCH64) 1344 switch (aarch64_io.iov_len) { 1345 case sizeof(aarch64_regs): 1346 /* We are in 64-bit mode */ 1347 scno = aarch64_regs.regs[8]; 1348 update_personality(tcp, 1); 1349 break; 1350 case sizeof(arm_regs): 1351 /* We are in 32-bit mode */ 1352 /* Note: we don't support OABI, unlike 32-bit ARM build */ 1353 scno = arm_regs.ARM_r7; 1354 scno = shuffle_scno(scno); 1355 update_personality(tcp, 0); 1356 break; 1357 } 1358 #elif defined(ARM) 1359 if (arm_regs.ARM_ip != 0) { 1360 /* It is not a syscall entry */ 1361 fprintf(stderr, "pid %d stray syscall exit\n", tcp->pid); 1362 tcp->flags |= TCB_INSYSCALL; 1363 return 0; 1364 } 1365 /* Note: we support only 32-bit CPUs, not 26-bit */ 1366 1367 # if !defined(__ARM_EABI__) || ENABLE_ARM_OABI 1368 if (arm_regs.ARM_cpsr & 0x20) 1369 /* Thumb mode */ 1370 goto scno_in_r7; 1371 /* ARM mode */ 1372 /* Check EABI/OABI by examining SVC insn's low 24 bits */ 1373 errno = 0; 1374 scno = ptrace(PTRACE_PEEKTEXT, tcp->pid, (void *)(arm_regs.ARM_pc - 4), NULL); 1375 if (errno) 1376 return -1; 1377 /* EABI syscall convention? */ 1378 if (scno != 0xef000000) { 1379 /* No, it's OABI */ 1380 if ((scno & 0x0ff00000) != 0x0f900000) { 1381 fprintf(stderr, "pid %d unknown syscall trap 0x%08lx\n", 1382 tcp->pid, scno); 1383 return -1; 1384 } 1385 /* Fixup the syscall number */ 1386 scno &= 0x000fffff; 1387 } else { 1388 scno_in_r7: 1389 scno = arm_regs.ARM_r7; 1390 } 1391 # else /* __ARM_EABI__ || !ENABLE_ARM_OABI */ 1392 scno = arm_regs.ARM_r7; 1393 # endif 1394 scno = shuffle_scno(scno); 1395 #elif defined(M68K) 1396 if (upeek(tcp->pid, 4*PT_ORIG_D0, &scno) < 0) 1397 return -1; 1398 #elif defined(LINUX_MIPSN32) 1399 unsigned long long regs[38]; 1400 1401 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) ®s) < 0) 1402 return -1; 1403 mips_a3 = regs[REG_A3]; 1404 mips_r2 = regs[REG_V0]; 1405 1406 scno = mips_r2; 1407 if (!SCNO_IN_RANGE(scno)) { 1408 if (mips_a3 == 0 || mips_a3 == -1) { 1409 if (debug_flag) 1410 fprintf(stderr, "stray syscall exit: v0 = %ld\n", scno); 1411 return 0; 1412 } 1413 } 1414 #elif defined(MIPS) 1415 if (upeek(tcp->pid, REG_A3, &mips_a3) < 0) 1416 return -1; 1417 if (upeek(tcp->pid, REG_V0, &scno) < 0) 1418 return -1; 1419 1420 if (!SCNO_IN_RANGE(scno)) { 1421 if (mips_a3 == 0 || mips_a3 == -1) { 1422 if (debug_flag) 1423 fprintf(stderr, "stray syscall exit: v0 = %ld\n", scno); 1424 return 0; 1425 } 1426 } 1427 #elif defined(ALPHA) 1428 if (upeek(tcp->pid, REG_A3, &alpha_a3) < 0) 1429 return -1; 1430 if (upeek(tcp->pid, REG_R0, &scno) < 0) 1431 return -1; 1432 1433 /* 1434 * Do some sanity checks to figure out if it's 1435 * really a syscall entry 1436 */ 1437 if (!SCNO_IN_RANGE(scno)) { 1438 if (alpha_a3 == 0 || alpha_a3 == -1) { 1439 if (debug_flag) 1440 fprintf(stderr, "stray syscall exit: r0 = %ld\n", scno); 1441 return 0; 1442 } 1443 } 1444 #elif defined(SPARC) || defined(SPARC64) 1445 /* Disassemble the syscall trap. */ 1446 /* Retrieve the syscall trap instruction. */ 1447 unsigned long trap; 1448 errno = 0; 1449 # if defined(SPARC64) 1450 trap = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)sparc_regs.tpc, 0); 1451 trap >>= 32; 1452 # else 1453 trap = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)sparc_regs.pc, 0); 1454 # endif 1455 if (errno) 1456 return -1; 1457 1458 /* Disassemble the trap to see what personality to use. */ 1459 switch (trap) { 1460 case 0x91d02010: 1461 /* Linux/SPARC syscall trap. */ 1462 update_personality(tcp, 0); 1463 break; 1464 case 0x91d0206d: 1465 /* Linux/SPARC64 syscall trap. */ 1466 update_personality(tcp, 2); 1467 break; 1468 case 0x91d02000: 1469 /* SunOS syscall trap. (pers 1) */ 1470 fprintf(stderr, "syscall: SunOS no support\n"); 1471 return -1; 1472 case 0x91d02008: 1473 /* Solaris 2.x syscall trap. (per 2) */ 1474 update_personality(tcp, 1); 1475 break; 1476 case 0x91d02009: 1477 /* NetBSD/FreeBSD syscall trap. */ 1478 fprintf(stderr, "syscall: NetBSD/FreeBSD not supported\n"); 1479 return -1; 1480 case 0x91d02027: 1481 /* Solaris 2.x gettimeofday */ 1482 update_personality(tcp, 1); 1483 break; 1484 default: 1485 # if defined(SPARC64) 1486 fprintf(stderr, "syscall: unknown syscall trap %08lx %016lx\n", trap, sparc_regs.tpc); 1487 # else 1488 fprintf(stderr, "syscall: unknown syscall trap %08lx %08lx\n", trap, sparc_regs.pc); 1489 # endif 1490 return -1; 1491 } 1492 1493 /* Extract the system call number from the registers. */ 1494 if (trap == 0x91d02027) 1495 scno = 156; 1496 else 1497 scno = sparc_regs.u_regs[U_REG_G1]; 1498 if (scno == 0) { 1499 scno = sparc_regs.u_regs[U_REG_O0]; 1500 memmove(&sparc_regs.u_regs[U_REG_O0], &sparc_regs.u_regs[U_REG_O1], 7*sizeof(sparc_regs.u_regs[0])); 1501 } 1502 #elif defined(HPPA) 1503 if (upeek(tcp->pid, PT_GR20, &scno) < 0) 1504 return -1; 1505 #elif defined(SH) 1506 /* 1507 * In the new syscall ABI, the system call number is in R3. 1508 */ 1509 if (upeek(tcp->pid, 4*(REG_REG0+3), &scno) < 0) 1510 return -1; 1511 1512 if (scno < 0) { 1513 /* Odd as it may seem, a glibc bug has been known to cause 1514 glibc to issue bogus negative syscall numbers. So for 1515 our purposes, make strace print what it *should* have been */ 1516 long correct_scno = (scno & 0xff); 1517 if (debug_flag) 1518 fprintf(stderr, 1519 "Detected glibc bug: bogus system call" 1520 " number = %ld, correcting to %ld\n", 1521 scno, 1522 correct_scno); 1523 scno = correct_scno; 1524 } 1525 #elif defined(SH64) 1526 if (upeek(tcp->pid, REG_SYSCALL, &scno) < 0) 1527 return -1; 1528 scno &= 0xFFFF; 1529 #elif defined(CRISV10) || defined(CRISV32) 1530 if (upeek(tcp->pid, 4*PT_R9, &scno) < 0) 1531 return -1; 1532 #elif defined(TILE) 1533 int currpers; 1534 scno = tile_regs.regs[10]; 1535 # ifdef __tilepro__ 1536 currpers = 1; 1537 # else 1538 # ifndef PT_FLAGS_COMPAT 1539 # define PT_FLAGS_COMPAT 0x10000 /* from Linux 3.8 on */ 1540 # endif 1541 if (tile_regs.flags & PT_FLAGS_COMPAT) 1542 currpers = 1; 1543 else 1544 currpers = 0; 1545 # endif 1546 update_personality(tcp, currpers); 1547 #elif defined(MICROBLAZE) 1548 if (upeek(tcp->pid, 0, &scno) < 0) 1549 return -1; 1550 #elif defined(OR1K) 1551 scno = or1k_regs.gpr[11]; 1552 #elif defined(METAG) 1553 scno = metag_regs.dx[0][1]; /* syscall number in D1Re0 (D1.0) */ 1554 #elif defined(XTENSA) 1555 if (upeek(tcp->pid, SYSCALL_NR, &scno) < 0) 1556 return -1; 1557 # elif defined(ARC) 1558 scno = arc_regs.scratch.r8; 1559 #endif 1560 1561 tcp->scno = scno; 1562 if (SCNO_IS_VALID(tcp->scno)) { 1563 tcp->s_ent = &sysent[scno]; 1564 tcp->qual_flg = qual_flags[scno]; 1565 } else { 1566 static const struct_sysent unknown = { 1567 .nargs = MAX_ARGS, 1568 .sys_flags = 0, 1569 .sys_func = printargs, 1570 .sys_name = "unknown", /* not used */ 1571 }; 1572 tcp->s_ent = &unknown; 1573 tcp->qual_flg = UNDEFINED_SCNO | QUAL_RAW | DEFAULT_QUAL_FLAGS; 1574 } 1575 return 1; 1576 } 1577 1578 /* Called at each syscall entry. 1579 * Returns: 1580 * 0: "ignore this ptrace stop", bail out of trace_syscall_entering() silently. 1581 * 1: ok, continue in trace_syscall_entering(). 1582 * other: error, trace_syscall_entering() should print error indicator 1583 * ("????" etc) and bail out. 1584 */ 1585 static int 1586 syscall_fixup_on_sysenter(struct tcb *tcp) 1587 { 1588 /* A common case of "not a syscall entry" is post-execve SIGTRAP */ 1589 #if defined(I386) 1590 if (i386_regs.eax != -ENOSYS) { 1591 if (debug_flag) 1592 fprintf(stderr, "not a syscall entry (eax = %ld)\n", i386_regs.eax); 1593 return 0; 1594 } 1595 #elif defined(X86_64) || defined(X32) 1596 { 1597 long rax; 1598 if (x86_io.iov_len == sizeof(i386_regs)) { 1599 /* Sign extend from 32 bits */ 1600 rax = (int32_t)i386_regs.eax; 1601 } else { 1602 /* Note: in X32 build, this truncates 64 to 32 bits */ 1603 rax = x86_64_regs.rax; 1604 } 1605 if (rax != -ENOSYS) { 1606 if (debug_flag) 1607 fprintf(stderr, "not a syscall entry (rax = %ld)\n", rax); 1608 return 0; 1609 } 1610 } 1611 #elif defined(M68K) 1612 /* TODO? Eliminate upeek's in arches below like we did in x86 */ 1613 if (upeek(tcp->pid, 4*PT_D0, &m68k_d0) < 0) 1614 return -1; 1615 if (m68k_d0 != -ENOSYS) { 1616 if (debug_flag) 1617 fprintf(stderr, "not a syscall entry (d0 = %ld)\n", m68k_d0); 1618 return 0; 1619 } 1620 #elif defined(IA64) 1621 if (upeek(tcp->pid, PT_R10, &ia64_r10) < 0) 1622 return -1; 1623 if (upeek(tcp->pid, PT_R8, &ia64_r8) < 0) 1624 return -1; 1625 if (ia64_ia32mode && ia64_r8 != -ENOSYS) { 1626 if (debug_flag) 1627 fprintf(stderr, "not a syscall entry (r8 = %ld)\n", ia64_r8); 1628 return 0; 1629 } 1630 #elif defined(CRISV10) || defined(CRISV32) 1631 if (upeek(tcp->pid, 4*PT_R10, &cris_r10) < 0) 1632 return -1; 1633 if (cris_r10 != -ENOSYS) { 1634 if (debug_flag) 1635 fprintf(stderr, "not a syscall entry (r10 = %ld)\n", cris_r10); 1636 return 0; 1637 } 1638 #elif defined(MICROBLAZE) 1639 if (upeek(tcp->pid, 3 * 4, µblaze_r3) < 0) 1640 return -1; 1641 if (microblaze_r3 != -ENOSYS) { 1642 if (debug_flag) 1643 fprintf(stderr, "not a syscall entry (r3 = %ld)\n", microblaze_r3); 1644 return 0; 1645 } 1646 #endif 1647 return 1; 1648 } 1649 1650 static void 1651 internal_fork(struct tcb *tcp) 1652 { 1653 #if defined S390 || defined S390X || defined CRISV10 || defined CRISV32 1654 # define ARG_FLAGS 1 1655 #else 1656 # define ARG_FLAGS 0 1657 #endif 1658 #ifndef CLONE_UNTRACED 1659 # define CLONE_UNTRACED 0x00800000 1660 #endif 1661 if ((ptrace_setoptions 1662 & (PTRACE_O_TRACECLONE | PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK)) 1663 == (PTRACE_O_TRACECLONE | PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK)) 1664 return; 1665 1666 if (!followfork) 1667 return; 1668 1669 if (entering(tcp)) { 1670 /* 1671 * We won't see the new child if clone is called with 1672 * CLONE_UNTRACED, so we keep the same logic with that option 1673 * and don't trace it. 1674 */ 1675 if ((tcp->s_ent->sys_func == sys_clone) 1676 && (tcp->u_arg[ARG_FLAGS] & CLONE_UNTRACED) 1677 ) 1678 return; 1679 setbpt(tcp); 1680 } else { 1681 if (tcp->flags & TCB_BPTSET) 1682 clearbpt(tcp); 1683 } 1684 } 1685 1686 #if defined(TCB_WAITEXECVE) 1687 static void 1688 internal_exec(struct tcb *tcp) 1689 { 1690 /* Maybe we have post-execve SIGTRAP suppressed? */ 1691 if (ptrace_setoptions & PTRACE_O_TRACEEXEC) 1692 return; /* yes, no need to do anything */ 1693 1694 if (exiting(tcp) && syserror(tcp)) 1695 /* Error in execve, no post-execve SIGTRAP expected */ 1696 tcp->flags &= ~TCB_WAITEXECVE; 1697 else 1698 tcp->flags |= TCB_WAITEXECVE; 1699 } 1700 #endif 1701 1702 static void 1703 syscall_fixup_for_fork_exec(struct tcb *tcp) 1704 { 1705 /* 1706 * We must always trace a few critical system calls in order to 1707 * correctly support following forks in the presence of tracing 1708 * qualifiers. 1709 */ 1710 int (*func)(); 1711 1712 func = tcp->s_ent->sys_func; 1713 1714 if ( sys_fork == func 1715 || sys_clone == func 1716 ) { 1717 internal_fork(tcp); 1718 return; 1719 } 1720 1721 #if defined(TCB_WAITEXECVE) 1722 if ( sys_execve == func 1723 # if defined(SPARC) || defined(SPARC64) 1724 || sys_execv == func 1725 # endif 1726 ) { 1727 internal_exec(tcp); 1728 return; 1729 } 1730 #endif 1731 } 1732 1733 /* Return -1 on error or 1 on success (never 0!) */ 1734 static int 1735 get_syscall_args(struct tcb *tcp) 1736 { 1737 int i, nargs; 1738 1739 nargs = tcp->s_ent->nargs; 1740 1741 #if defined(S390) || defined(S390X) 1742 for (i = 0; i < nargs; ++i) 1743 if (upeek(tcp->pid, i==0 ? PT_ORIGGPR2 : PT_GPR2 + i*sizeof(long), &tcp->u_arg[i]) < 0) 1744 return -1; 1745 #elif defined(ALPHA) 1746 for (i = 0; i < nargs; ++i) 1747 if (upeek(tcp->pid, REG_A0+i, &tcp->u_arg[i]) < 0) 1748 return -1; 1749 #elif defined(IA64) 1750 if (!ia64_ia32mode) { 1751 unsigned long *out0, cfm, sof, sol; 1752 long rbs_end; 1753 /* be backwards compatible with kernel < 2.4.4... */ 1754 # ifndef PT_RBS_END 1755 # define PT_RBS_END PT_AR_BSP 1756 # endif 1757 1758 if (upeek(tcp->pid, PT_RBS_END, &rbs_end) < 0) 1759 return -1; 1760 if (upeek(tcp->pid, PT_CFM, (long *) &cfm) < 0) 1761 return -1; 1762 1763 sof = (cfm >> 0) & 0x7f; 1764 sol = (cfm >> 7) & 0x7f; 1765 out0 = ia64_rse_skip_regs((unsigned long *) rbs_end, -sof + sol); 1766 1767 for (i = 0; i < nargs; ++i) { 1768 if (umoven(tcp, (unsigned long) ia64_rse_skip_regs(out0, i), 1769 sizeof(long), (char *) &tcp->u_arg[i]) < 0) 1770 return -1; 1771 } 1772 } else { 1773 static const int argreg[MAX_ARGS] = { PT_R11 /* EBX = out0 */, 1774 PT_R9 /* ECX = out1 */, 1775 PT_R10 /* EDX = out2 */, 1776 PT_R14 /* ESI = out3 */, 1777 PT_R15 /* EDI = out4 */, 1778 PT_R13 /* EBP = out5 */}; 1779 1780 for (i = 0; i < nargs; ++i) { 1781 if (upeek(tcp->pid, argreg[i], &tcp->u_arg[i]) < 0) 1782 return -1; 1783 /* truncate away IVE sign-extension */ 1784 tcp->u_arg[i] &= 0xffffffff; 1785 } 1786 } 1787 #elif defined(LINUX_MIPSN32) || defined(LINUX_MIPSN64) 1788 /* N32 and N64 both use up to six registers. */ 1789 unsigned long long regs[38]; 1790 1791 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) ®s) < 0) 1792 return -1; 1793 1794 for (i = 0; i < nargs; ++i) { 1795 tcp->u_arg[i] = regs[REG_A0 + i]; 1796 # if defined(LINUX_MIPSN32) 1797 tcp->ext_arg[i] = regs[REG_A0 + i]; 1798 # endif 1799 } 1800 #elif defined(MIPS) 1801 if (nargs > 4) { 1802 long sp; 1803 1804 if (upeek(tcp->pid, REG_SP, &sp) < 0) 1805 return -1; 1806 for (i = 0; i < 4; ++i) 1807 if (upeek(tcp->pid, REG_A0 + i, &tcp->u_arg[i]) < 0) 1808 return -1; 1809 umoven(tcp, sp + 16, (nargs - 4) * sizeof(tcp->u_arg[0]), 1810 (char *)(tcp->u_arg + 4)); 1811 } else { 1812 for (i = 0; i < nargs; ++i) 1813 if (upeek(tcp->pid, REG_A0 + i, &tcp->u_arg[i]) < 0) 1814 return -1; 1815 } 1816 #elif defined(POWERPC) 1817 (void)i; 1818 (void)nargs; 1819 tcp->u_arg[0] = ppc_regs.orig_gpr3; 1820 tcp->u_arg[1] = ppc_regs.gpr[4]; 1821 tcp->u_arg[2] = ppc_regs.gpr[5]; 1822 tcp->u_arg[3] = ppc_regs.gpr[6]; 1823 tcp->u_arg[4] = ppc_regs.gpr[7]; 1824 tcp->u_arg[5] = ppc_regs.gpr[8]; 1825 #elif defined(SPARC) || defined(SPARC64) 1826 for (i = 0; i < nargs; ++i) 1827 tcp->u_arg[i] = sparc_regs.u_regs[U_REG_O0 + i]; 1828 #elif defined(HPPA) 1829 for (i = 0; i < nargs; ++i) 1830 if (upeek(tcp->pid, PT_GR26-4*i, &tcp->u_arg[i]) < 0) 1831 return -1; 1832 #elif defined(ARM) || defined(AARCH64) 1833 # if defined(AARCH64) 1834 if (tcp->currpers == 1) 1835 for (i = 0; i < nargs; ++i) 1836 tcp->u_arg[i] = aarch64_regs.regs[i]; 1837 else 1838 # endif 1839 for (i = 0; i < nargs; ++i) 1840 tcp->u_arg[i] = arm_regs.uregs[i]; 1841 #elif defined(AVR32) 1842 (void)i; 1843 (void)nargs; 1844 tcp->u_arg[0] = avr32_regs.r12; 1845 tcp->u_arg[1] = avr32_regs.r11; 1846 tcp->u_arg[2] = avr32_regs.r10; 1847 tcp->u_arg[3] = avr32_regs.r9; 1848 tcp->u_arg[4] = avr32_regs.r5; 1849 tcp->u_arg[5] = avr32_regs.r3; 1850 #elif defined(BFIN) 1851 static const int argreg[MAX_ARGS] = { PT_R0, PT_R1, PT_R2, PT_R3, PT_R4, PT_R5 }; 1852 1853 for (i = 0; i < nargs; ++i) 1854 if (upeek(tcp->pid, argreg[i], &tcp->u_arg[i]) < 0) 1855 return -1; 1856 #elif defined(SH) 1857 static const int syscall_regs[MAX_ARGS] = { 1858 4 * (REG_REG0+4), 4 * (REG_REG0+5), 4 * (REG_REG0+6), 1859 4 * (REG_REG0+7), 4 * (REG_REG0 ), 4 * (REG_REG0+1) 1860 }; 1861 1862 for (i = 0; i < nargs; ++i) 1863 if (upeek(tcp->pid, syscall_regs[i], &tcp->u_arg[i]) < 0) 1864 return -1; 1865 #elif defined(SH64) 1866 int i; 1867 /* Registers used by SH5 Linux system calls for parameters */ 1868 static const int syscall_regs[MAX_ARGS] = { 2, 3, 4, 5, 6, 7 }; 1869 1870 for (i = 0; i < nargs; ++i) 1871 if (upeek(tcp->pid, REG_GENERAL(syscall_regs[i]), &tcp->u_arg[i]) < 0) 1872 return -1; 1873 #elif defined(I386) 1874 (void)i; 1875 (void)nargs; 1876 tcp->u_arg[0] = i386_regs.ebx; 1877 tcp->u_arg[1] = i386_regs.ecx; 1878 tcp->u_arg[2] = i386_regs.edx; 1879 tcp->u_arg[3] = i386_regs.esi; 1880 tcp->u_arg[4] = i386_regs.edi; 1881 tcp->u_arg[5] = i386_regs.ebp; 1882 #elif defined(X86_64) || defined(X32) 1883 (void)i; 1884 (void)nargs; 1885 if (x86_io.iov_len != sizeof(i386_regs)) { 1886 /* x86-64 or x32 ABI */ 1887 tcp->u_arg[0] = x86_64_regs.rdi; 1888 tcp->u_arg[1] = x86_64_regs.rsi; 1889 tcp->u_arg[2] = x86_64_regs.rdx; 1890 tcp->u_arg[3] = x86_64_regs.r10; 1891 tcp->u_arg[4] = x86_64_regs.r8; 1892 tcp->u_arg[5] = x86_64_regs.r9; 1893 # ifdef X32 1894 tcp->ext_arg[0] = x86_64_regs.rdi; 1895 tcp->ext_arg[1] = x86_64_regs.rsi; 1896 tcp->ext_arg[2] = x86_64_regs.rdx; 1897 tcp->ext_arg[3] = x86_64_regs.r10; 1898 tcp->ext_arg[4] = x86_64_regs.r8; 1899 tcp->ext_arg[5] = x86_64_regs.r9; 1900 # endif 1901 } else { 1902 /* i386 ABI */ 1903 /* Zero-extend from 32 bits */ 1904 /* Use widen_to_long(tcp->u_arg[N]) in syscall handlers 1905 * if you need to use *sign-extended* parameter. 1906 */ 1907 tcp->u_arg[0] = (long)(uint32_t)i386_regs.ebx; 1908 tcp->u_arg[1] = (long)(uint32_t)i386_regs.ecx; 1909 tcp->u_arg[2] = (long)(uint32_t)i386_regs.edx; 1910 tcp->u_arg[3] = (long)(uint32_t)i386_regs.esi; 1911 tcp->u_arg[4] = (long)(uint32_t)i386_regs.edi; 1912 tcp->u_arg[5] = (long)(uint32_t)i386_regs.ebp; 1913 } 1914 #elif defined(MICROBLAZE) 1915 for (i = 0; i < nargs; ++i) 1916 if (upeek(tcp->pid, (5 + i) * 4, &tcp->u_arg[i]) < 0) 1917 return -1; 1918 #elif defined(CRISV10) || defined(CRISV32) 1919 static const int crisregs[MAX_ARGS] = { 1920 4*PT_ORIG_R10, 4*PT_R11, 4*PT_R12, 1921 4*PT_R13 , 4*PT_MOF, 4*PT_SRP 1922 }; 1923 1924 for (i = 0; i < nargs; ++i) 1925 if (upeek(tcp->pid, crisregs[i], &tcp->u_arg[i]) < 0) 1926 return -1; 1927 #elif defined(TILE) 1928 for (i = 0; i < nargs; ++i) 1929 tcp->u_arg[i] = tile_regs.regs[i]; 1930 #elif defined(M68K) 1931 for (i = 0; i < nargs; ++i) 1932 if (upeek(tcp->pid, (i < 5 ? i : i + 2)*4, &tcp->u_arg[i]) < 0) 1933 return -1; 1934 #elif defined(OR1K) 1935 (void)nargs; 1936 for (i = 0; i < 6; ++i) 1937 tcp->u_arg[i] = or1k_regs.gpr[3 + i]; 1938 #elif defined(METAG) 1939 for (i = 0; i < nargs; i++) 1940 /* arguments go backwards from D1Ar1 (D1.3) */ 1941 tcp->u_arg[i] = ((unsigned long *)&metag_regs.dx[3][1])[-i]; 1942 #elif defined(XTENSA) 1943 /* arg0: a6, arg1: a3, arg2: a4, arg3: a5, arg4: a8, arg5: a9 */ 1944 static const int xtensaregs[MAX_ARGS] = { 6, 3, 4, 5, 8, 9 }; 1945 for (i = 0; i < nargs; ++i) 1946 if (upeek(tcp->pid, REG_A_BASE + xtensaregs[i], &tcp->u_arg[i]) < 0) 1947 return -1; 1948 # elif defined(ARC) 1949 long *arc_args = &arc_regs.scratch.r0; 1950 for (i = 0; i < nargs; ++i) 1951 tcp->u_arg[i] = *arc_args--; 1952 1953 #else /* Other architecture (32bits specific) */ 1954 for (i = 0; i < nargs; ++i) 1955 if (upeek(tcp->pid, i*4, &tcp->u_arg[i]) < 0) 1956 return -1; 1957 #endif 1958 return 1; 1959 } 1960 1961 static int 1962 trace_syscall_entering(struct tcb *tcp) 1963 { 1964 int res, scno_good; 1965 1966 #if defined TCB_WAITEXECVE 1967 if (tcp->flags & TCB_WAITEXECVE) { 1968 /* This is the post-execve SIGTRAP. */ 1969 tcp->flags &= ~TCB_WAITEXECVE; 1970 return 0; 1971 } 1972 #endif 1973 1974 scno_good = res = (get_regs_error ? -1 : get_scno(tcp)); 1975 if (res == 0) 1976 return res; 1977 if (res == 1) { 1978 res = syscall_fixup_on_sysenter(tcp); 1979 if (res == 0) 1980 return res; 1981 if (res == 1) 1982 res = get_syscall_args(tcp); 1983 } 1984 1985 if (res != 1) { 1986 printleader(tcp); 1987 if (scno_good != 1) 1988 tprints("????" /* anti-trigraph gap */ "("); 1989 else if (tcp->qual_flg & UNDEFINED_SCNO) 1990 tprintf("%s(", undefined_scno_name(tcp)); 1991 else 1992 tprintf("%s(", tcp->s_ent->sys_name); 1993 /* 1994 * " <unavailable>" will be added later by the code which 1995 * detects ptrace errors. 1996 */ 1997 goto ret; 1998 } 1999 2000 if ( sys_execve == tcp->s_ent->sys_func 2001 # if defined(SPARC) || defined(SPARC64) 2002 || sys_execv == tcp->s_ent->sys_func 2003 # endif 2004 ) { 2005 hide_log_until_execve = 0; 2006 } 2007 2008 #if defined(SYS_socket_subcall) || defined(SYS_ipc_subcall) 2009 while (1) { 2010 # ifdef SYS_socket_subcall 2011 if (tcp->s_ent->sys_func == sys_socketcall) { 2012 decode_socket_subcall(tcp); 2013 break; 2014 } 2015 # endif 2016 # ifdef SYS_ipc_subcall 2017 if (tcp->s_ent->sys_func == sys_ipc) { 2018 decode_ipc_subcall(tcp); 2019 break; 2020 } 2021 # endif 2022 break; 2023 } 2024 #endif 2025 2026 if (need_fork_exec_workarounds) 2027 syscall_fixup_for_fork_exec(tcp); 2028 2029 if (!(tcp->qual_flg & QUAL_TRACE) 2030 || (tracing_paths && !pathtrace_match(tcp)) 2031 ) { 2032 tcp->flags |= TCB_INSYSCALL | TCB_FILTERED; 2033 return 0; 2034 } 2035 2036 tcp->flags &= ~TCB_FILTERED; 2037 2038 if (cflag == CFLAG_ONLY_STATS || hide_log_until_execve) { 2039 res = 0; 2040 goto ret; 2041 } 2042 2043 #ifdef USE_LIBUNWIND 2044 if (stack_trace_enabled) { 2045 if (tcp->s_ent->sys_flags & STACKTRACE_CAPTURE_ON_ENTER) 2046 unwind_capture_stacktrace(tcp); 2047 } 2048 #endif 2049 2050 printleader(tcp); 2051 if (tcp->qual_flg & UNDEFINED_SCNO) 2052 tprintf("%s(", undefined_scno_name(tcp)); 2053 else 2054 tprintf("%s(", tcp->s_ent->sys_name); 2055 if ((tcp->qual_flg & QUAL_RAW) && tcp->s_ent->sys_func != sys_exit) 2056 res = printargs(tcp); 2057 else 2058 res = tcp->s_ent->sys_func(tcp); 2059 2060 fflush(tcp->outf); 2061 ret: 2062 tcp->flags |= TCB_INSYSCALL; 2063 /* Measure the entrance time as late as possible to avoid errors. */ 2064 if (Tflag || cflag) 2065 gettimeofday(&tcp->etime, NULL); 2066 return res; 2067 } 2068 2069 /* Returns: 2070 * 1: ok, continue in trace_syscall_exiting(). 2071 * -1: error, trace_syscall_exiting() should print error indicator 2072 * ("????" etc) and bail out. 2073 */ 2074 static int 2075 get_syscall_result(struct tcb *tcp) 2076 { 2077 #if defined(S390) || defined(S390X) 2078 if (upeek(tcp->pid, PT_GPR2, &s390_gpr2) < 0) 2079 return -1; 2080 #elif defined(POWERPC) 2081 /* already done by get_regs */ 2082 #elif defined(AVR32) 2083 /* already done by get_regs */ 2084 #elif defined(BFIN) 2085 if (upeek(tcp->pid, PT_R0, &bfin_r0) < 0) 2086 return -1; 2087 #elif defined(I386) 2088 /* already done by get_regs */ 2089 #elif defined(X86_64) || defined(X32) 2090 /* already done by get_regs */ 2091 #elif defined(IA64) 2092 # define IA64_PSR_IS ((long)1 << 34) 2093 long psr; 2094 if (upeek(tcp->pid, PT_CR_IPSR, &psr) >= 0) 2095 ia64_ia32mode = ((psr & IA64_PSR_IS) != 0); 2096 if (upeek(tcp->pid, PT_R8, &ia64_r8) < 0) 2097 return -1; 2098 if (upeek(tcp->pid, PT_R10, &ia64_r10) < 0) 2099 return -1; 2100 #elif defined(ARM) 2101 /* already done by get_regs */ 2102 #elif defined(AARCH64) 2103 /* register reading already done by get_regs */ 2104 2105 /* Used to do this, but we did it on syscall entry already: */ 2106 /* We are in 64-bit mode (personality 1) if register struct is aarch64_regs, 2107 * else it's personality 0. 2108 */ 2109 /*update_personality(tcp, aarch64_io.iov_len == sizeof(aarch64_regs));*/ 2110 #elif defined(M68K) 2111 if (upeek(tcp->pid, 4*PT_D0, &m68k_d0) < 0) 2112 return -1; 2113 #elif defined(LINUX_MIPSN32) 2114 unsigned long long regs[38]; 2115 2116 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) ®s) < 0) 2117 return -1; 2118 mips_a3 = regs[REG_A3]; 2119 mips_r2 = regs[REG_V0]; 2120 #elif defined(MIPS) 2121 if (upeek(tcp->pid, REG_A3, &mips_a3) < 0) 2122 return -1; 2123 if (upeek(tcp->pid, REG_V0, &mips_r2) < 0) 2124 return -1; 2125 #elif defined(ALPHA) 2126 if (upeek(tcp->pid, REG_A3, &alpha_a3) < 0) 2127 return -1; 2128 if (upeek(tcp->pid, REG_R0, &alpha_r0) < 0) 2129 return -1; 2130 #elif defined(SPARC) || defined(SPARC64) 2131 /* already done by get_regs */ 2132 #elif defined(HPPA) 2133 if (upeek(tcp->pid, PT_GR28, &hppa_r28) < 0) 2134 return -1; 2135 #elif defined(SH) 2136 /* new syscall ABI returns result in R0 */ 2137 if (upeek(tcp->pid, 4*REG_REG0, (long *)&sh_r0) < 0) 2138 return -1; 2139 #elif defined(SH64) 2140 /* ABI defines result returned in r9 */ 2141 if (upeek(tcp->pid, REG_GENERAL(9), (long *)&sh64_r9) < 0) 2142 return -1; 2143 #elif defined(CRISV10) || defined(CRISV32) 2144 if (upeek(tcp->pid, 4*PT_R10, &cris_r10) < 0) 2145 return -1; 2146 #elif defined(TILE) 2147 /* already done by get_regs */ 2148 #elif defined(MICROBLAZE) 2149 if (upeek(tcp->pid, 3 * 4, µblaze_r3) < 0) 2150 return -1; 2151 #elif defined(OR1K) 2152 /* already done by get_regs */ 2153 #elif defined(METAG) 2154 /* already done by get_regs */ 2155 #elif defined(XTENSA) 2156 if (upeek(tcp->pid, REG_A_BASE + 2, &xtensa_a2) < 0) 2157 return -1; 2158 #elif defined(ARC) 2159 /* already done by get_regs */ 2160 #endif 2161 return 1; 2162 } 2163 2164 /* Called at each syscall exit */ 2165 static void 2166 syscall_fixup_on_sysexit(struct tcb *tcp) 2167 { 2168 #if defined(S390) || defined(S390X) 2169 if ((tcp->flags & TCB_WAITEXECVE) 2170 && (s390_gpr2 == -ENOSYS || s390_gpr2 == tcp->scno)) { 2171 /* 2172 * Return from execve. 2173 * Fake a return value of zero. We leave the TCB_WAITEXECVE 2174 * flag set for the post-execve SIGTRAP to see and reset. 2175 */ 2176 s390_gpr2 = 0; 2177 } 2178 #endif 2179 } 2180 2181 /* 2182 * Check the syscall return value register value for whether it is 2183 * a negated errno code indicating an error, or a success return value. 2184 */ 2185 static inline int 2186 is_negated_errno(unsigned long int val) 2187 { 2188 unsigned long int max = -(long int) nerrnos; 2189 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4 2190 if (current_wordsize < sizeof(val)) { 2191 val = (unsigned int) val; 2192 max = (unsigned int) max; 2193 } 2194 #endif 2195 return val > max; 2196 } 2197 2198 #if defined(X32) 2199 static inline int 2200 is_negated_errno_x32(unsigned long long val) 2201 { 2202 unsigned long long max = -(long long) nerrnos; 2203 /* 2204 * current_wordsize is 4 even in personality 0 (native X32) 2205 * but truncation _must not_ be done in it. 2206 * can't check current_wordsize here! 2207 */ 2208 if (current_personality != 0) { 2209 val = (uint32_t) val; 2210 max = (uint32_t) max; 2211 } 2212 return val > max; 2213 } 2214 #endif 2215 2216 /* Returns: 2217 * 1: ok, continue in trace_syscall_exiting(). 2218 * -1: error, trace_syscall_exiting() should print error indicator 2219 * ("????" etc) and bail out. 2220 */ 2221 static void 2222 get_error(struct tcb *tcp) 2223 { 2224 int u_error = 0; 2225 int check_errno = 1; 2226 if (tcp->s_ent->sys_flags & SYSCALL_NEVER_FAILS) { 2227 check_errno = 0; 2228 } 2229 #if defined(S390) || defined(S390X) 2230 if (check_errno && is_negated_errno(s390_gpr2)) { 2231 tcp->u_rval = -1; 2232 u_error = -s390_gpr2; 2233 } 2234 else { 2235 tcp->u_rval = s390_gpr2; 2236 } 2237 #elif defined(I386) 2238 if (check_errno && is_negated_errno(i386_regs.eax)) { 2239 tcp->u_rval = -1; 2240 u_error = -i386_regs.eax; 2241 } 2242 else { 2243 tcp->u_rval = i386_regs.eax; 2244 } 2245 #elif defined(X86_64) 2246 long rax; 2247 if (x86_io.iov_len == sizeof(i386_regs)) { 2248 /* Sign extend from 32 bits */ 2249 rax = (int32_t)i386_regs.eax; 2250 } else { 2251 rax = x86_64_regs.rax; 2252 } 2253 if (check_errno && is_negated_errno(rax)) { 2254 tcp->u_rval = -1; 2255 u_error = -rax; 2256 } 2257 else { 2258 tcp->u_rval = rax; 2259 } 2260 #elif defined(X32) 2261 /* In X32, return value is 64-bit (llseek uses one). 2262 * Using merely "long rax" would not work. 2263 */ 2264 long long rax; 2265 if (x86_io.iov_len == sizeof(i386_regs)) { 2266 /* Sign extend from 32 bits */ 2267 rax = (int32_t)i386_regs.eax; 2268 } else { 2269 rax = x86_64_regs.rax; 2270 } 2271 /* Careful: is_negated_errno() works only on longs */ 2272 if (check_errno && is_negated_errno_x32(rax)) { 2273 tcp->u_rval = -1; 2274 u_error = -rax; 2275 } 2276 else { 2277 tcp->u_rval = rax; /* truncating */ 2278 tcp->u_lrval = rax; 2279 } 2280 #elif defined(IA64) 2281 if (ia64_ia32mode) { 2282 int err; 2283 2284 err = (int)ia64_r8; 2285 if (check_errno && is_negated_errno(err)) { 2286 tcp->u_rval = -1; 2287 u_error = -err; 2288 } 2289 else { 2290 tcp->u_rval = err; 2291 } 2292 } else { 2293 if (check_errno && ia64_r10) { 2294 tcp->u_rval = -1; 2295 u_error = ia64_r8; 2296 } else { 2297 tcp->u_rval = ia64_r8; 2298 } 2299 } 2300 #elif defined(MIPS) 2301 if (check_errno && mips_a3) { 2302 tcp->u_rval = -1; 2303 u_error = mips_r2; 2304 } else { 2305 tcp->u_rval = mips_r2; 2306 # if defined(LINUX_MIPSN32) 2307 tcp->u_lrval = mips_r2; 2308 # endif 2309 } 2310 #elif defined(POWERPC) 2311 if (check_errno && (ppc_regs.ccr & 0x10000000)) { 2312 tcp->u_rval = -1; 2313 u_error = ppc_regs.gpr[3]; 2314 } 2315 else { 2316 tcp->u_rval = ppc_regs.gpr[3]; 2317 } 2318 #elif defined(M68K) 2319 if (check_errno && is_negated_errno(m68k_d0)) { 2320 tcp->u_rval = -1; 2321 u_error = -m68k_d0; 2322 } 2323 else { 2324 tcp->u_rval = m68k_d0; 2325 } 2326 #elif defined(ARM) || defined(AARCH64) 2327 # if defined(AARCH64) 2328 if (tcp->currpers == 1) { 2329 if (check_errno && is_negated_errno(aarch64_regs.regs[0])) { 2330 tcp->u_rval = -1; 2331 u_error = -aarch64_regs.regs[0]; 2332 } 2333 else { 2334 tcp->u_rval = aarch64_regs.regs[0]; 2335 } 2336 } 2337 else 2338 # endif 2339 { 2340 if (check_errno && is_negated_errno(arm_regs.ARM_r0)) { 2341 tcp->u_rval = -1; 2342 u_error = -arm_regs.ARM_r0; 2343 } 2344 else { 2345 tcp->u_rval = arm_regs.ARM_r0; 2346 } 2347 } 2348 #elif defined(AVR32) 2349 if (check_errno && avr32_regs.r12 && (unsigned) -avr32_regs.r12 < nerrnos) { 2350 tcp->u_rval = -1; 2351 u_error = -avr32_regs.r12; 2352 } 2353 else { 2354 tcp->u_rval = avr32_regs.r12; 2355 } 2356 #elif defined(BFIN) 2357 if (check_errno && is_negated_errno(bfin_r0)) { 2358 tcp->u_rval = -1; 2359 u_error = -bfin_r0; 2360 } else { 2361 tcp->u_rval = bfin_r0; 2362 } 2363 #elif defined(ALPHA) 2364 if (check_errno && alpha_a3) { 2365 tcp->u_rval = -1; 2366 u_error = alpha_r0; 2367 } 2368 else { 2369 tcp->u_rval = alpha_r0; 2370 } 2371 #elif defined(SPARC) 2372 if (check_errno && sparc_regs.psr & PSR_C) { 2373 tcp->u_rval = -1; 2374 u_error = sparc_regs.u_regs[U_REG_O0]; 2375 } 2376 else { 2377 tcp->u_rval = sparc_regs.u_regs[U_REG_O0]; 2378 } 2379 #elif defined(SPARC64) 2380 if (check_errno && sparc_regs.tstate & 0x1100000000UL) { 2381 tcp->u_rval = -1; 2382 u_error = sparc_regs.u_regs[U_REG_O0]; 2383 } 2384 else { 2385 tcp->u_rval = sparc_regs.u_regs[U_REG_O0]; 2386 } 2387 #elif defined(HPPA) 2388 if (check_errno && is_negated_errno(hppa_r28)) { 2389 tcp->u_rval = -1; 2390 u_error = -hppa_r28; 2391 } 2392 else { 2393 tcp->u_rval = hppa_r28; 2394 } 2395 #elif defined(SH) 2396 if (check_errno && is_negated_errno(sh_r0)) { 2397 tcp->u_rval = -1; 2398 u_error = -sh_r0; 2399 } 2400 else { 2401 tcp->u_rval = sh_r0; 2402 } 2403 #elif defined(SH64) 2404 if (check_errno && is_negated_errno(sh64_r9)) { 2405 tcp->u_rval = -1; 2406 u_error = -sh64_r9; 2407 } 2408 else { 2409 tcp->u_rval = sh64_r9; 2410 } 2411 #elif defined(METAG) 2412 /* result pointer in D0Re0 (D0.0) */ 2413 if (check_errno && is_negated_errno(metag_regs.dx[0][0])) { 2414 tcp->u_rval = -1; 2415 u_error = -metag_regs.dx[0][0]; 2416 } 2417 else { 2418 tcp->u_rval = metag_regs.dx[0][0]; 2419 } 2420 #elif defined(CRISV10) || defined(CRISV32) 2421 if (check_errno && cris_r10 && (unsigned) -cris_r10 < nerrnos) { 2422 tcp->u_rval = -1; 2423 u_error = -cris_r10; 2424 } 2425 else { 2426 tcp->u_rval = cris_r10; 2427 } 2428 #elif defined(TILE) 2429 /* 2430 * The standard tile calling convention returns the value (or negative 2431 * errno) in r0, and zero (or positive errno) in r1. 2432 * Until at least kernel 3.8, however, the r1 value is not reflected 2433 * in ptregs at this point, so we use r0 here. 2434 */ 2435 if (check_errno && is_negated_errno(tile_regs.regs[0])) { 2436 tcp->u_rval = -1; 2437 u_error = -tile_regs.regs[0]; 2438 } else { 2439 tcp->u_rval = tile_regs.regs[0]; 2440 } 2441 #elif defined(MICROBLAZE) 2442 if (check_errno && is_negated_errno(microblaze_r3)) { 2443 tcp->u_rval = -1; 2444 u_error = -microblaze_r3; 2445 } 2446 else { 2447 tcp->u_rval = microblaze_r3; 2448 } 2449 #elif defined(OR1K) 2450 if (check_errno && is_negated_errno(or1k_regs.gpr[11])) { 2451 tcp->u_rval = -1; 2452 u_error = -or1k_regs.gpr[11]; 2453 } 2454 else { 2455 tcp->u_rval = or1k_regs.gpr[11]; 2456 } 2457 #elif defined(XTENSA) 2458 if (check_errno && is_negated_errno(xtensa_a2)) { 2459 tcp->u_rval = -1; 2460 u_error = -xtensa_a2; 2461 } 2462 else { 2463 tcp->u_rval = xtensa_a2; 2464 } 2465 #elif defined(ARC) 2466 if (check_errno && is_negated_errno(arc_regs.scratch.r0)) { 2467 tcp->u_rval = -1; 2468 u_error = -arc_regs.scratch.r0; 2469 } 2470 else { 2471 tcp->u_rval = arc_regs.scratch.r0; 2472 } 2473 #endif 2474 tcp->u_error = u_error; 2475 } 2476 2477 static void 2478 dumpio(struct tcb *tcp) 2479 { 2480 int (*func)(); 2481 2482 if (syserror(tcp)) 2483 return; 2484 if ((unsigned long) tcp->u_arg[0] >= num_quals) 2485 return; 2486 func = tcp->s_ent->sys_func; 2487 if (func == printargs) 2488 return; 2489 if (qual_flags[tcp->u_arg[0]] & QUAL_READ) { 2490 if (func == sys_read || 2491 func == sys_pread || 2492 func == sys_recv || 2493 func == sys_recvfrom) 2494 dumpstr(tcp, tcp->u_arg[1], tcp->u_rval); 2495 else if (func == sys_readv) 2496 dumpiov(tcp, tcp->u_arg[2], tcp->u_arg[1]); 2497 return; 2498 } 2499 if (qual_flags[tcp->u_arg[0]] & QUAL_WRITE) { 2500 if (func == sys_write || 2501 func == sys_pwrite || 2502 func == sys_send || 2503 func == sys_sendto) 2504 dumpstr(tcp, tcp->u_arg[1], tcp->u_arg[2]); 2505 else if (func == sys_writev) 2506 dumpiov(tcp, tcp->u_arg[2], tcp->u_arg[1]); 2507 return; 2508 } 2509 } 2510 2511 static int 2512 trace_syscall_exiting(struct tcb *tcp) 2513 { 2514 int sys_res; 2515 struct timeval tv; 2516 int res; 2517 long u_error; 2518 2519 /* Measure the exit time as early as possible to avoid errors. */ 2520 if (Tflag || cflag) 2521 gettimeofday(&tv, NULL); 2522 2523 #ifdef USE_LIBUNWIND 2524 if (stack_trace_enabled) { 2525 if (tcp->s_ent->sys_flags & STACKTRACE_INVALIDATE_CACHE) 2526 unwind_cache_invalidate(tcp); 2527 } 2528 #endif 2529 2530 #if SUPPORTED_PERSONALITIES > 1 2531 update_personality(tcp, tcp->currpers); 2532 #endif 2533 res = (get_regs_error ? -1 : get_syscall_result(tcp)); 2534 if (res == 1) { 2535 syscall_fixup_on_sysexit(tcp); /* never fails */ 2536 get_error(tcp); /* never fails */ 2537 if (need_fork_exec_workarounds) 2538 syscall_fixup_for_fork_exec(tcp); 2539 if (filtered(tcp) || hide_log_until_execve) 2540 goto ret; 2541 } 2542 2543 if (cflag) { 2544 count_syscall(tcp, &tv); 2545 if (cflag == CFLAG_ONLY_STATS) { 2546 goto ret; 2547 } 2548 } 2549 2550 /* If not in -ff mode, and printing_tcp != tcp, 2551 * then the log currently does not end with output 2552 * of _our syscall entry_, but with something else. 2553 * We need to say which syscall's return is this. 2554 * 2555 * Forced reprinting via TCB_REPRINT is used only by 2556 * "strace -ff -oLOG test/threaded_execve" corner case. 2557 * It's the only case when -ff mode needs reprinting. 2558 */ 2559 if ((followfork < 2 && printing_tcp != tcp) || (tcp->flags & TCB_REPRINT)) { 2560 tcp->flags &= ~TCB_REPRINT; 2561 printleader(tcp); 2562 if (tcp->qual_flg & UNDEFINED_SCNO) 2563 tprintf("<... %s resumed> ", undefined_scno_name(tcp)); 2564 else 2565 tprintf("<... %s resumed> ", tcp->s_ent->sys_name); 2566 } 2567 printing_tcp = tcp; 2568 2569 if (res != 1) { 2570 /* There was error in one of prior ptrace ops */ 2571 tprints(") "); 2572 tabto(); 2573 tprints("= ? <unavailable>\n"); 2574 line_ended(); 2575 tcp->flags &= ~TCB_INSYSCALL; 2576 return res; 2577 } 2578 2579 sys_res = 0; 2580 if (tcp->qual_flg & QUAL_RAW) { 2581 /* sys_res = printargs(tcp); - but it's nop on sysexit */ 2582 } else { 2583 /* FIXME: not_failing_only (IOW, option -z) is broken: 2584 * failure of syscall is known only after syscall return. 2585 * Thus we end up with something like this on, say, ENOENT: 2586 * open("doesnt_exist", O_RDONLY <unfinished ...> 2587 * {next syscall decode} 2588 * whereas the intended result is that open(...) line 2589 * is not shown at all. 2590 */ 2591 if (not_failing_only && tcp->u_error) 2592 goto ret; /* ignore failed syscalls */ 2593 sys_res = tcp->s_ent->sys_func(tcp); 2594 } 2595 2596 tprints(") "); 2597 tabto(); 2598 u_error = tcp->u_error; 2599 if (tcp->qual_flg & QUAL_RAW) { 2600 if (u_error) 2601 tprintf("= -1 (errno %ld)", u_error); 2602 else 2603 tprintf("= %#lx", tcp->u_rval); 2604 } 2605 else if (!(sys_res & RVAL_NONE) && u_error) { 2606 switch (u_error) { 2607 /* Blocked signals do not interrupt any syscalls. 2608 * In this case syscalls don't return ERESTARTfoo codes. 2609 * 2610 * Deadly signals set to SIG_DFL interrupt syscalls 2611 * and kill the process regardless of which of the codes below 2612 * is returned by the interrupted syscall. 2613 * In some cases, kernel forces a kernel-generated deadly 2614 * signal to be unblocked and set to SIG_DFL (and thus cause 2615 * death) if it is blocked or SIG_IGNed: for example, SIGSEGV 2616 * or SIGILL. (The alternative is to leave process spinning 2617 * forever on the faulty instruction - not useful). 2618 * 2619 * SIG_IGNed signals and non-deadly signals set to SIG_DFL 2620 * (for example, SIGCHLD, SIGWINCH) interrupt syscalls, 2621 * but kernel will always restart them. 2622 */ 2623 case ERESTARTSYS: 2624 /* Most common type of signal-interrupted syscall exit code. 2625 * The system call will be restarted with the same arguments 2626 * if SA_RESTART is set; otherwise, it will fail with EINTR. 2627 */ 2628 tprints("= ? ERESTARTSYS (To be restarted if SA_RESTART is set)"); 2629 break; 2630 case ERESTARTNOINTR: 2631 /* Rare. For example, fork() returns this if interrupted. 2632 * SA_RESTART is ignored (assumed set): the restart is unconditional. 2633 */ 2634 tprints("= ? ERESTARTNOINTR (To be restarted)"); 2635 break; 2636 case ERESTARTNOHAND: 2637 /* pause(), rt_sigsuspend() etc use this code. 2638 * SA_RESTART is ignored (assumed not set): 2639 * syscall won't restart (will return EINTR instead) 2640 * even after signal with SA_RESTART set. However, 2641 * after SIG_IGN or SIG_DFL signal it will restart 2642 * (thus the name "restart only if has no handler"). 2643 */ 2644 tprints("= ? ERESTARTNOHAND (To be restarted if no handler)"); 2645 break; 2646 case ERESTART_RESTARTBLOCK: 2647 /* Syscalls like nanosleep(), poll() which can't be 2648 * restarted with their original arguments use this 2649 * code. Kernel will execute restart_syscall() instead, 2650 * which changes arguments before restarting syscall. 2651 * SA_RESTART is ignored (assumed not set) similarly 2652 * to ERESTARTNOHAND. (Kernel can't honor SA_RESTART 2653 * since restart data is saved in "restart block" 2654 * in task struct, and if signal handler uses a syscall 2655 * which in turn saves another such restart block, 2656 * old data is lost and restart becomes impossible) 2657 */ 2658 tprints("= ? ERESTART_RESTARTBLOCK (Interrupted by signal)"); 2659 break; 2660 default: 2661 if (u_error < 0) 2662 tprintf("= -1 E??? (errno %ld)", u_error); 2663 else if (u_error < nerrnos) 2664 tprintf("= -1 %s (%s)", errnoent[u_error], 2665 strerror(u_error)); 2666 else 2667 tprintf("= -1 ERRNO_%ld (%s)", u_error, 2668 strerror(u_error)); 2669 break; 2670 } 2671 if ((sys_res & RVAL_STR) && tcp->auxstr) 2672 tprintf(" (%s)", tcp->auxstr); 2673 } 2674 else { 2675 if (sys_res & RVAL_NONE) 2676 tprints("= ?"); 2677 else { 2678 switch (sys_res & RVAL_MASK) { 2679 case RVAL_HEX: 2680 tprintf("= %#lx", tcp->u_rval); 2681 break; 2682 case RVAL_OCTAL: 2683 tprintf("= %#lo", tcp->u_rval); 2684 break; 2685 case RVAL_UDECIMAL: 2686 tprintf("= %lu", tcp->u_rval); 2687 break; 2688 case RVAL_DECIMAL: 2689 tprintf("= %ld", tcp->u_rval); 2690 break; 2691 case RVAL_FD: 2692 if (show_fd_path) { 2693 tprints("= "); 2694 printfd(tcp, tcp->u_rval); 2695 } 2696 else 2697 tprintf("= %ld", tcp->u_rval); 2698 break; 2699 #if defined(LINUX_MIPSN32) || defined(X32) 2700 /* 2701 case RVAL_LHEX: 2702 tprintf("= %#llx", tcp->u_lrval); 2703 break; 2704 case RVAL_LOCTAL: 2705 tprintf("= %#llo", tcp->u_lrval); 2706 break; 2707 */ 2708 case RVAL_LUDECIMAL: 2709 tprintf("= %llu", tcp->u_lrval); 2710 break; 2711 /* 2712 case RVAL_LDECIMAL: 2713 tprintf("= %lld", tcp->u_lrval); 2714 break; 2715 */ 2716 #endif 2717 default: 2718 fprintf(stderr, 2719 "invalid rval format\n"); 2720 break; 2721 } 2722 } 2723 if ((sys_res & RVAL_STR) && tcp->auxstr) 2724 tprintf(" (%s)", tcp->auxstr); 2725 } 2726 if (Tflag) { 2727 tv_sub(&tv, &tv, &tcp->etime); 2728 tprintf(" <%ld.%06ld>", 2729 (long) tv.tv_sec, (long) tv.tv_usec); 2730 } 2731 tprints("\n"); 2732 dumpio(tcp); 2733 line_ended(); 2734 2735 #ifdef USE_LIBUNWIND 2736 if (stack_trace_enabled) 2737 unwind_print_stacktrace(tcp); 2738 #endif 2739 2740 ret: 2741 tcp->flags &= ~TCB_INSYSCALL; 2742 return 0; 2743 } 2744 2745 int 2746 trace_syscall(struct tcb *tcp) 2747 { 2748 return exiting(tcp) ? 2749 trace_syscall_exiting(tcp) : trace_syscall_entering(tcp); 2750 } 2751
