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