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