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