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