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