granicus.if.org Git - strace/blob - syscall.c

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