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 (LINUX) && defined (SPARC64)
  64 # undef PTRACE_GETREGS
  65 # define PTRACE_GETREGS PTRACE_GETREGS64
  66 # undef PTRACE_SETREGS
  67 # define PTRACE_SETREGS PTRACE_SETREGS64
  68 #endif /* LINUX && SPARC64 */
  69
  70 #if defined(LINUX) && defined(IA64)
  71 # include <asm/ptrace_offsets.h>
  72 # include <asm/rse.h>
  73 #endif
  74
  75 #define NR_SYSCALL_BASE 0
  76 #ifdef LINUX
  77 #ifndef ERESTARTSYS
  78 #define ERESTARTSYS     512
  79 #endif
  80 #ifndef ERESTARTNOINTR
  81 #define ERESTARTNOINTR  513
  82 #endif
  83 #ifndef ERESTARTNOHAND
  84 #define ERESTARTNOHAND  514     /* restart if no handler.. */
  85 #endif
  86 #ifndef ENOIOCTLCMD
  87 #define ENOIOCTLCMD     515     /* No ioctl command */
  88 #endif
  89 #ifndef ERESTART_RESTARTBLOCK
  90 #define ERESTART_RESTARTBLOCK 516       /* restart by calling sys_restart_syscall */
  91 #endif
  92 #ifndef NSIG
  93 #define NSIG 32
  94 #endif
  95 #ifdef ARM
  96 #undef NSIG
  97 #define NSIG 32
  98 #undef NR_SYSCALL_BASE
  99 #define NR_SYSCALL_BASE __NR_SYSCALL_BASE
 100 #endif
 101 #endif /* LINUX */
 102
 103 #include "syscall.h"
 104
 105 /* Define these shorthand notations to simplify the syscallent files. */
 106 #define TD TRACE_DESC
 107 #define TF TRACE_FILE
 108 #define TI TRACE_IPC
 109 #define TN TRACE_NETWORK
 110 #define TP TRACE_PROCESS
 111 #define TS TRACE_SIGNAL
 112 #define NF SYSCALL_NEVER_FAILS
 113
 114 static const struct sysent sysent0[] = {
 115 #include "syscallent.h"
 116 };
 117 static const int nsyscalls0 = sizeof sysent0 / sizeof sysent0[0];
 118 int qual_flags0[MAX_QUALS];
 119
 120 #if SUPPORTED_PERSONALITIES >= 2
 121 static const struct sysent sysent1[] = {
 122 #include "syscallent1.h"
 123 };
 124 static const int nsyscalls1 = sizeof sysent1 / sizeof sysent1[0];
 125 int qual_flags1[MAX_QUALS];
 126 #endif /* SUPPORTED_PERSONALITIES >= 2 */
 127
 128 #if SUPPORTED_PERSONALITIES >= 3
 129 static const struct sysent sysent2[] = {
 130 #include "syscallent2.h"
 131 };
 132 static const int nsyscalls2 = sizeof sysent2 / sizeof sysent2[0];
 133 int qual_flags2[MAX_QUALS];
 134 #endif /* SUPPORTED_PERSONALITIES >= 3 */
 135
 136 const struct sysent *sysent;
 137 int *qual_flags;
 138 int nsyscalls;
 139
 140 /* Now undef them since short defines cause wicked namespace pollution. */
 141 #undef TD
 142 #undef TF
 143 #undef TI
 144 #undef TN
 145 #undef TP
 146 #undef TS
 147 #undef NF
 148
 149 static const char *const errnoent0[] = {
 150 #include "errnoent.h"
 151 };
 152 static const int nerrnos0 = sizeof errnoent0 / sizeof errnoent0[0];
 153
 154 #if SUPPORTED_PERSONALITIES >= 2
 155 static const char *const errnoent1[] = {
 156 #include "errnoent1.h"
 157 };
 158 static const int nerrnos1 = sizeof errnoent1 / sizeof errnoent1[0];
 159 #endif /* SUPPORTED_PERSONALITIES >= 2 */
 160
 161 #if SUPPORTED_PERSONALITIES >= 3
 162 static const char *const errnoent2[] = {
 163 #include "errnoent2.h"
 164 };
 165 static const int nerrnos2 = sizeof errnoent2 / sizeof errnoent2[0];
 166 #endif /* SUPPORTED_PERSONALITIES >= 3 */
 167
 168 const char *const *errnoent;
 169 int nerrnos;
 170
 171 int current_personality;
 172
 173 #ifndef PERSONALITY0_WORDSIZE
 174 # define PERSONALITY0_WORDSIZE sizeof(long)
 175 #endif
 176 const int personality_wordsize[SUPPORTED_PERSONALITIES] = {
 177         PERSONALITY0_WORDSIZE,
 178 #if SUPPORTED_PERSONALITIES > 1
 179         PERSONALITY1_WORDSIZE,
 180 #endif
 181 #if SUPPORTED_PERSONALITIES > 2
 182         PERSONALITY2_WORDSIZE,
 183 #endif
 184 };;
 185
 186 int
 187 set_personality(int personality)
 188 {
 189         switch (personality) {
 190         case 0:
 191                 errnoent = errnoent0;
 192                 nerrnos = nerrnos0;
 193                 sysent = sysent0;
 194                 nsyscalls = nsyscalls0;
 195                 ioctlent = ioctlent0;
 196                 nioctlents = nioctlents0;
 197                 signalent = signalent0;
 198                 nsignals = nsignals0;
 199                 qual_flags = qual_flags0;
 200                 break;
 201
 202 #if SUPPORTED_PERSONALITIES >= 2
 203         case 1:
 204                 errnoent = errnoent1;
 205                 nerrnos = nerrnos1;
 206                 sysent = sysent1;
 207                 nsyscalls = nsyscalls1;
 208                 ioctlent = ioctlent1;
 209                 nioctlents = nioctlents1;
 210                 signalent = signalent1;
 211                 nsignals = nsignals1;
 212                 qual_flags = qual_flags1;
 213                 break;
 214 #endif /* SUPPORTED_PERSONALITIES >= 2 */
 215
 216 #if SUPPORTED_PERSONALITIES >= 3
 217         case 2:
 218                 errnoent = errnoent2;
 219                 nerrnos = nerrnos2;
 220                 sysent = sysent2;
 221                 nsyscalls = nsyscalls2;
 222                 ioctlent = ioctlent2;
 223                 nioctlents = nioctlents2;
 224                 signalent = signalent2;
 225                 nsignals = nsignals2;
 226                 qual_flags = qual_flags2;
 227                 break;
 228 #endif /* SUPPORTED_PERSONALITIES >= 3 */
 229
 230         default:
 231                 return -1;
 232         }
 233
 234         current_personality = personality;
 235         return 0;
 236 }
 237
 238
 239 static int qual_syscall(), qual_signal(), qual_fault(), qual_desc();
 240
 241 static const struct qual_options {
 242         int bitflag;
 243         const char *option_name;
 244         int (*qualify)(const char *, int, int);
 245         const char *argument_name;
 246 } qual_options[] = {
 247         { QUAL_TRACE,   "trace",        qual_syscall,   "system call"   },
 248         { QUAL_TRACE,   "t",            qual_syscall,   "system call"   },
 249         { QUAL_ABBREV,  "abbrev",       qual_syscall,   "system call"   },
 250         { QUAL_ABBREV,  "a",            qual_syscall,   "system call"   },
 251         { QUAL_VERBOSE, "verbose",      qual_syscall,   "system call"   },
 252         { QUAL_VERBOSE, "v",            qual_syscall,   "system call"   },
 253         { QUAL_RAW,     "raw",          qual_syscall,   "system call"   },
 254         { QUAL_RAW,     "x",            qual_syscall,   "system call"   },
 255         { QUAL_SIGNAL,  "signal",       qual_signal,    "signal"        },
 256         { QUAL_SIGNAL,  "signals",      qual_signal,    "signal"        },
 257         { QUAL_SIGNAL,  "s",            qual_signal,    "signal"        },
 258         { QUAL_FAULT,   "fault",        qual_fault,     "fault"         },
 259         { QUAL_FAULT,   "faults",       qual_fault,     "fault"         },
 260         { QUAL_FAULT,   "m",            qual_fault,     "fault"         },
 261         { QUAL_READ,    "read",         qual_desc,      "descriptor"    },
 262         { QUAL_READ,    "reads",        qual_desc,      "descriptor"    },
 263         { QUAL_READ,    "r",            qual_desc,      "descriptor"    },
 264         { QUAL_WRITE,   "write",        qual_desc,      "descriptor"    },
 265         { QUAL_WRITE,   "writes",       qual_desc,      "descriptor"    },
 266         { QUAL_WRITE,   "w",            qual_desc,      "descriptor"    },
 267         { 0,            NULL,           NULL,           NULL            },
 268 };
 269
 270 static void
 271 qualify_one(int n, int bitflag, int not, int pers)
 272 {
 273         if (pers == 0 || pers < 0) {
 274                 if (not)
 275                         qual_flags0[n] &= ~bitflag;
 276                 else
 277                         qual_flags0[n] |= bitflag;
 278         }
 279
 280 #if SUPPORTED_PERSONALITIES >= 2
 281         if (pers == 1 || pers < 0) {
 282                 if (not)
 283                         qual_flags1[n] &= ~bitflag;
 284                 else
 285                         qual_flags1[n] |= bitflag;
 286         }
 287 #endif /* SUPPORTED_PERSONALITIES >= 2 */
 288
 289 #if SUPPORTED_PERSONALITIES >= 3
 290         if (pers == 2 || pers < 0) {
 291                 if (not)
 292                         qual_flags2[n] &= ~bitflag;
 293                 else
 294                         qual_flags2[n] |= bitflag;
 295         }
 296 #endif /* SUPPORTED_PERSONALITIES >= 3 */
 297 }
 298
 299 static int
 300 qual_syscall(const char *s, int bitflag, int not)
 301 {
 302         int i;
 303         int rc = -1;
 304
 305         if (isdigit((unsigned char)*s)) {
 306                 int i = atoi(s);
 307                 if (i < 0 || i >= MAX_QUALS)
 308                         return -1;
 309                 qualify_one(i, bitflag, not, -1);
 310                 return 0;
 311         }
 312         for (i = 0; i < nsyscalls0; i++)
 313                 if (strcmp(s, sysent0[i].sys_name) == 0) {
 314                         qualify_one(i, bitflag, not, 0);
 315                         rc = 0;
 316                 }
 317
 318 #if SUPPORTED_PERSONALITIES >= 2
 319         for (i = 0; i < nsyscalls1; i++)
 320                 if (strcmp(s, sysent1[i].sys_name) == 0) {
 321                         qualify_one(i, bitflag, not, 1);
 322                         rc = 0;
 323                 }
 324 #endif /* SUPPORTED_PERSONALITIES >= 2 */
 325
 326 #if SUPPORTED_PERSONALITIES >= 3
 327         for (i = 0; i < nsyscalls2; i++)
 328                 if (strcmp(s, sysent2[i].sys_name) == 0) {
 329                         qualify_one(i, bitflag, not, 2);
 330                         rc = 0;
 331                 }
 332 #endif /* SUPPORTED_PERSONALITIES >= 3 */
 333
 334         return rc;
 335 }
 336
 337 static int
 338 qual_signal(const char *s, int bitflag, int not)
 339 {
 340         int i;
 341         char buf[32];
 342
 343         if (isdigit((unsigned char)*s)) {
 344                 int signo = atoi(s);
 345                 if (signo < 0 || signo >= MAX_QUALS)
 346                         return -1;
 347                 qualify_one(signo, bitflag, not, -1);
 348                 return 0;
 349         }
 350         if (strlen(s) >= sizeof buf)
 351                 return -1;
 352         strcpy(buf, s);
 353         s = buf;
 354         if (strncasecmp(s, "SIG", 3) == 0)
 355                 s += 3;
 356         for (i = 0; i <= NSIG; i++)
 357                 if (strcasecmp(s, signame(i) + 3) == 0) {
 358                         qualify_one(i, bitflag, not, -1);
 359                         return 0;
 360                 }
 361         return -1;
 362 }
 363
 364 static int
 365 qual_fault(const char *s, int bitflag, int not)
 366 {
 367         return -1;
 368 }
 369
 370 static int
 371 qual_desc(const char *s, int bitflag, int not)
 372 {
 373         if (isdigit((unsigned char)*s)) {
 374                 int desc = atoi(s);
 375                 if (desc < 0 || desc >= MAX_QUALS)
 376                         return -1;
 377                 qualify_one(desc, bitflag, not, -1);
 378                 return 0;
 379         }
 380         return -1;
 381 }
 382
 383 static int
 384 lookup_class(const char *s)
 385 {
 386         if (strcmp(s, "file") == 0)
 387                 return TRACE_FILE;
 388         if (strcmp(s, "ipc") == 0)
 389                 return TRACE_IPC;
 390         if (strcmp(s, "network") == 0)
 391                 return TRACE_NETWORK;
 392         if (strcmp(s, "process") == 0)
 393                 return TRACE_PROCESS;
 394         if (strcmp(s, "signal") == 0)
 395                 return TRACE_SIGNAL;
 396         if (strcmp(s, "desc") == 0)
 397                 return TRACE_DESC;
 398         return -1;
 399 }
 400
 401 void
 402 qualify(const char *s)
 403 {
 404         const struct qual_options *opt;
 405         int not;
 406         char *copy;
 407         const char *p;
 408         int i, n;
 409
 410         opt = &qual_options[0];
 411         for (i = 0; (p = qual_options[i].option_name); i++) {
 412                 n = strlen(p);
 413                 if (strncmp(s, p, n) == 0 && s[n] == '=') {
 414                         opt = &qual_options[i];
 415                         s += n + 1;
 416                         break;
 417                 }
 418         }
 419         not = 0;
 420         if (*s == '!') {
 421                 not = 1;
 422                 s++;
 423         }
 424         if (strcmp(s, "none") == 0) {
 425                 not = 1 - not;
 426                 s = "all";
 427         }
 428         if (strcmp(s, "all") == 0) {
 429                 for (i = 0; i < MAX_QUALS; i++) {
 430                         qualify_one(i, opt->bitflag, not, -1);
 431                 }
 432                 return;
 433         }
 434         for (i = 0; i < MAX_QUALS; i++) {
 435                 qualify_one(i, opt->bitflag, !not, -1);
 436         }
 437         if (!(copy = strdup(s))) {
 438                 fprintf(stderr, "out of memory\n");
 439                 exit(1);
 440         }
 441         for (p = strtok(copy, ","); p; p = strtok(NULL, ",")) {
 442                 if (opt->bitflag == QUAL_TRACE && (n = lookup_class(p)) > 0) {
 443                         for (i = 0; i < nsyscalls0; i++)
 444                                 if (sysent0[i].sys_flags & n)
 445                                         qualify_one(i, opt->bitflag, not, 0);
 446
 447 #if SUPPORTED_PERSONALITIES >= 2
 448                         for (i = 0; i < nsyscalls1; i++)
 449                                 if (sysent1[i].sys_flags & n)
 450                                         qualify_one(i, opt->bitflag, not, 1);
 451 #endif /* SUPPORTED_PERSONALITIES >= 2 */
 452
 453 #if SUPPORTED_PERSONALITIES >= 3
 454                         for (i = 0; i < nsyscalls2; i++)
 455                                 if (sysent2[i].sys_flags & n)
 456                                         qualify_one(i, opt->bitflag, not, 2);
 457 #endif /* SUPPORTED_PERSONALITIES >= 3 */
 458
 459                         continue;
 460                 }
 461                 if (opt->qualify(p, opt->bitflag, not)) {
 462                         fprintf(stderr, "strace: invalid %s `%s'\n",
 463                                 opt->argument_name, p);
 464                         exit(1);
 465                 }
 466         }
 467         free(copy);
 468         return;
 469 }
 470
 471 static void
 472 dumpio(struct tcb *tcp)
 473 {
 474         if (syserror(tcp))
 475                 return;
 476         if (tcp->u_arg[0] < 0 || tcp->u_arg[0] >= MAX_QUALS)
 477                 return;
 478         if (tcp->scno < 0 || tcp->scno >= nsyscalls)
 479                 return;
 480         if (sysent[tcp->scno].sys_func == printargs)
 481                 return;
 482         if (qual_flags[tcp->u_arg[0]] & QUAL_READ) {
 483                 if (sysent[tcp->scno].sys_func == sys_read ||
 484                     sysent[tcp->scno].sys_func == sys_pread ||
 485                     sysent[tcp->scno].sys_func == sys_pread64 ||
 486                     sysent[tcp->scno].sys_func == sys_recv ||
 487                     sysent[tcp->scno].sys_func == sys_recvfrom)
 488                         dumpstr(tcp, tcp->u_arg[1], tcp->u_rval);
 489                 else if (sysent[tcp->scno].sys_func == sys_readv)
 490                         dumpiov(tcp, tcp->u_arg[2], tcp->u_arg[1]);
 491                 return;
 492         }
 493         if (qual_flags[tcp->u_arg[0]] & QUAL_WRITE) {
 494                 if (sysent[tcp->scno].sys_func == sys_write ||
 495                     sysent[tcp->scno].sys_func == sys_pwrite ||
 496                     sysent[tcp->scno].sys_func == sys_pwrite64 ||
 497                     sysent[tcp->scno].sys_func == sys_send ||
 498                     sysent[tcp->scno].sys_func == sys_sendto)
 499                         dumpstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 500                 else if (sysent[tcp->scno].sys_func == sys_writev)
 501                         dumpiov(tcp, tcp->u_arg[2], tcp->u_arg[1]);
 502                 return;
 503         }
 504 }
 505
 506 #ifndef FREEBSD
 507 enum subcall_style { shift_style, deref_style, mask_style, door_style };
 508 #else /* FREEBSD */
 509 enum subcall_style { shift_style, deref_style, mask_style, door_style, table_style };
 510
 511 struct subcall {
 512   int call;
 513   int nsubcalls;
 514   int subcalls[5];
 515 };
 516
 517 static const struct subcall subcalls_table[] = {
 518   { SYS_shmsys, 5, { SYS_shmat, SYS_shmctl, SYS_shmdt, SYS_shmget, SYS_shmctl } },
 519 #ifdef SYS_semconfig
 520   { SYS_semsys, 4, { SYS___semctl, SYS_semget, SYS_semop, SYS_semconfig } },
 521 #else
 522   { SYS_semsys, 3, { SYS___semctl, SYS_semget, SYS_semop } },
 523 #endif
 524   { SYS_msgsys, 4, { SYS_msgctl, SYS_msgget, SYS_msgsnd, SYS_msgrcv } },
 525 };
 526 #endif /* FREEBSD */
 527
 528 #if !(defined(LINUX) && ( defined(ALPHA) || defined(MIPS) || defined(__ARM_EABI__) ))
 529
 530 static void
 531 decode_subcall(struct tcb *tcp, int subcall, int nsubcalls, enum subcall_style style)
 532 {
 533         unsigned long addr, mask;
 534         int i;
 535         int size = personality_wordsize[current_personality];
 536
 537         switch (style) {
 538         case shift_style:
 539                 if (tcp->u_arg[0] < 0 || tcp->u_arg[0] >= nsubcalls)
 540                         return;
 541                 tcp->scno = subcall + tcp->u_arg[0];
 542                 if (sysent[tcp->scno].nargs != -1)
 543                         tcp->u_nargs = sysent[tcp->scno].nargs;
 544                 else
 545                         tcp->u_nargs--;
 546                 for (i = 0; i < tcp->u_nargs; i++)
 547                         tcp->u_arg[i] = tcp->u_arg[i + 1];
 548                 break;
 549         case deref_style:
 550                 if (tcp->u_arg[0] < 0 || tcp->u_arg[0] >= nsubcalls)
 551                         return;
 552                 tcp->scno = subcall + tcp->u_arg[0];
 553                 addr = tcp->u_arg[1];
 554                 for (i = 0; i < sysent[tcp->scno].nargs; i++) {
 555                         if (size == sizeof(int)) {
 556                                 unsigned int arg;
 557                                 if (umove(tcp, addr, &arg) < 0)
 558                                         arg = 0;
 559                                 tcp->u_arg[i] = arg;
 560                         }
 561                         else if (size == sizeof(long)) {
 562                                 unsigned long arg;
 563                                 if (umove(tcp, addr, &arg) < 0)
 564                                         arg = 0;
 565                                 tcp->u_arg[i] = arg;
 566                         }
 567                         else
 568                                 abort();
 569                         addr += size;
 570                 }
 571                 tcp->u_nargs = sysent[tcp->scno].nargs;
 572                 break;
 573         case mask_style:
 574                 mask = (tcp->u_arg[0] >> 8) & 0xff;
 575                 for (i = 0; mask; i++)
 576                         mask >>= 1;
 577                 if (i >= nsubcalls)
 578                         return;
 579                 tcp->u_arg[0] &= 0xff;
 580                 tcp->scno = subcall + i;
 581                 if (sysent[tcp->scno].nargs != -1)
 582                         tcp->u_nargs = sysent[tcp->scno].nargs;
 583                 break;
 584         case door_style:
 585                 /*
 586                  * Oh, yuck.  The call code is the *sixth* argument.
 587                  * (don't you mean the *last* argument? - JH)
 588                  */
 589                 if (tcp->u_arg[5] < 0 || tcp->u_arg[5] >= nsubcalls)
 590                         return;
 591                 tcp->scno = subcall + tcp->u_arg[5];
 592                 if (sysent[tcp->scno].nargs != -1)
 593                         tcp->u_nargs = sysent[tcp->scno].nargs;
 594                 else
 595                         tcp->u_nargs--;
 596                 break;
 597 #ifdef FREEBSD
 598         case table_style:
 599                 for (i = 0; i < sizeof(subcalls_table) / sizeof(struct subcall); i++)
 600                         if (subcalls_table[i].call == tcp->scno) break;
 601                 if (i < sizeof(subcalls_table) / sizeof(struct subcall) &&
 602                     tcp->u_arg[0] >= 0 && tcp->u_arg[0] < subcalls_table[i].nsubcalls) {
 603                         tcp->scno = subcalls_table[i].subcalls[tcp->u_arg[0]];
 604                         for (i = 0; i < tcp->u_nargs; i++)
 605                                 tcp->u_arg[i] = tcp->u_arg[i + 1];
 606                 }
 607                 break;
 608 #endif /* FREEBSD */
 609         }
 610 }
 611 #endif
 612
 613 struct tcb *tcp_last = NULL;
 614
 615 static int
 616 internal_syscall(struct tcb *tcp)
 617 {
 618         /*
 619          * We must always trace a few critical system calls in order to
 620          * correctly support following forks in the presence of tracing
 621          * qualifiers.
 622          */
 623         int     (*func)();
 624
 625         if (tcp->scno < 0 || tcp->scno >= nsyscalls)
 626                 return 0;
 627
 628         func = sysent[tcp->scno].sys_func;
 629
 630         if (sys_exit == func)
 631                 return internal_exit(tcp);
 632
 633         if (   sys_fork == func
 634 #if defined(FREEBSD) || defined(LINUX) || defined(SUNOS4)
 635             || sys_vfork == func
 636 #endif
 637 #ifdef LINUX
 638             || sys_clone == func
 639 #endif
 640 #if UNIXWARE > 2
 641             || sys_rfork == func
 642 #endif
 643            )
 644                 return internal_fork(tcp);
 645
 646         if (   sys_execve == func
 647 #if defined(SPARC) || defined(SPARC64) || defined(SUNOS4)
 648             || sys_execv == func
 649 #endif
 650 #if UNIXWARE > 2
 651             || sys_rexecve == func
 652 #endif
 653            )
 654                 return internal_exec(tcp);
 655
 656         if (   sys_waitpid == func
 657             || sys_wait4 == func
 658 #if defined(SVR4) || defined(FREEBSD) || defined(SUNOS4)
 659             || sys_wait == func
 660 #endif
 661 #ifdef ALPHA
 662             || sys_osf_wait4 == func
 663 #endif
 664            )
 665                 return internal_wait(tcp, 2);
 666
 667 #if defined(LINUX) || defined(SVR4)
 668         if (sys_waitid == func)
 669                 return internal_wait(tcp, 3);
 670 #endif
 671
 672         return 0;
 673 }
 674
 675
 676 #ifdef LINUX
 677 # if defined (I386)
 678 static long eax;
 679 # elif defined (IA64)
 680 long r8, r10, psr; /* TODO: make static? */
 681 long ia32 = 0; /* not static */
 682 # elif defined (POWERPC)
 683 static long result, flags;
 684 # elif defined (M68K)
 685 static long d0;
 686 # elif defined(BFIN)
 687 static long r0;
 688 # elif defined (ARM)
 689 static struct pt_regs regs;
 690 # elif defined (ALPHA)
 691 static long r0;
 692 static long a3;
 693 # elif defined(AVR32)
 694 static struct pt_regs regs;
 695 # elif defined (SPARC) || defined (SPARC64)
 696 static struct pt_regs regs;
 697 static unsigned long trap;
 698 # elif defined(LINUX_MIPSN32)
 699 static long long a3;
 700 static long long r2;
 701 # elif defined(MIPS)
 702 static long a3;
 703 static long r2;
 704 # elif defined(S390) || defined(S390X)
 705 static long gpr2;
 706 static long pc;
 707 static long syscall_mode;
 708 # elif defined(HPPA)
 709 static long r28;
 710 # elif defined(SH)
 711 static long r0;
 712 # elif defined(SH64)
 713 static long r9;
 714 # elif defined(X86_64)
 715 static long rax;
 716 # elif defined(CRISV10) || defined(CRISV32)
 717 static long r10;
 718 # elif defined(MICROBLAZE)
 719 static long r3;
 720 # endif
 721 #endif /* LINUX */
 722 #ifdef FREEBSD
 723 struct reg regs; /* TODO: make static? */
 724 #endif /* FREEBSD */
 725
 726 int
 727 get_scno(struct tcb *tcp)
 728 {
 729         long scno = 0;
 730
 731 #ifdef LINUX
 732 # if defined(S390) || defined(S390X)
 733         if (tcp->flags & TCB_WAITEXECVE) {
 734                 /*
 735                  * When the execve system call completes successfully, the
 736                  * new process still has -ENOSYS (old style) or __NR_execve
 737                  * (new style) in gpr2.  We cannot recover the scno again
 738                  * by disassembly, because the image that executed the
 739                  * syscall is gone now.  Fortunately, we don't want it.  We
 740                  * leave the flag set so that syscall_fixup can fake the
 741                  * result.
 742                  */
 743                 if (tcp->flags & TCB_INSYSCALL)
 744                         return 1;
 745                 /*
 746                  * This is the SIGTRAP after execve.  We cannot try to read
 747                  * the system call here either.
 748                  */
 749                 tcp->flags &= ~TCB_WAITEXECVE;
 750                 return 0;
 751         }
 752
 753         if (upeek(tcp, PT_GPR2, &syscall_mode) < 0)
 754                 return -1;
 755
 756         if (syscall_mode != -ENOSYS) {
 757                 /*
 758                  * Since kernel version 2.5.44 the scno gets passed in gpr2.
 759                  */
 760                 scno = syscall_mode;
 761         } else {
 762                 /*
 763                  * Old style of "passing" the scno via the SVC instruction.
 764                  */
 765
 766                 long opcode, offset_reg, tmp;
 767                 void * svc_addr;
 768                 int gpr_offset[16] = {PT_GPR0,  PT_GPR1,  PT_ORIGGPR2, PT_GPR3,
 769                                       PT_GPR4,  PT_GPR5,  PT_GPR6,     PT_GPR7,
 770                                       PT_GPR8,  PT_GPR9,  PT_GPR10,    PT_GPR11,
 771                                       PT_GPR12, PT_GPR13, PT_GPR14,    PT_GPR15};
 772
 773                 if (upeek(tcp, PT_PSWADDR, &pc) < 0)
 774                         return -1;
 775                 errno = 0;
 776                 opcode = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)(pc-sizeof(long)), 0);
 777                 if (errno) {
 778                         perror("peektext(pc-oneword)");
 779                         return -1;
 780                 }
 781
 782                 /*
 783                  *  We have to check if the SVC got executed directly or via an
 784                  *  EXECUTE instruction. In case of EXECUTE it is necessary to do
 785                  *  instruction decoding to derive the system call number.
 786                  *  Unfortunately the opcode sizes of EXECUTE and SVC are differently,
 787                  *  so that this doesn't work if a SVC opcode is part of an EXECUTE
 788                  *  opcode. Since there is no way to find out the opcode size this
 789                  *  is the best we can do...
 790                  */
 791
 792                 if ((opcode & 0xff00) == 0x0a00) {
 793                         /* SVC opcode */
 794                         scno = opcode & 0xff;
 795                 }
 796                 else {
 797                         /* SVC got executed by EXECUTE instruction */
 798
 799                         /*
 800                          *  Do instruction decoding of EXECUTE. If you really want to
 801                          *  understand this, read the Principles of Operations.
 802                          */
 803                         svc_addr = (void *) (opcode & 0xfff);
 804
 805                         tmp = 0;
 806                         offset_reg = (opcode & 0x000f0000) >> 16;
 807                         if (offset_reg && (upeek(tcp, gpr_offset[offset_reg], &tmp) < 0))
 808                                 return -1;
 809                         svc_addr += tmp;
 810
 811                         tmp = 0;
 812                         offset_reg = (opcode & 0x0000f000) >> 12;
 813                         if (offset_reg && (upeek(tcp, gpr_offset[offset_reg], &tmp) < 0))
 814                                 return -1;
 815                         svc_addr += tmp;
 816
 817                         scno = ptrace(PTRACE_PEEKTEXT, tcp->pid, svc_addr, 0);
 818                         if (errno)
 819                                 return -1;
 820 #  if defined(S390X)
 821                         scno >>= 48;
 822 #  else
 823                         scno >>= 16;
 824 #  endif
 825                         tmp = 0;
 826                         offset_reg = (opcode & 0x00f00000) >> 20;
 827                         if (offset_reg && (upeek(tcp, gpr_offset[offset_reg], &tmp) < 0))
 828                                 return -1;
 829
 830                         scno = (scno | tmp) & 0xff;
 831                 }
 832         }
 833 # elif defined (POWERPC)
 834         if (upeek(tcp, sizeof(unsigned long)*PT_R0, &scno) < 0)
 835                 return -1;
 836         if (!(tcp->flags & TCB_INSYSCALL)) {
 837                 /* Check if we return from execve. */
 838                 if (scno == 0 && (tcp->flags & TCB_WAITEXECVE)) {
 839                         tcp->flags &= ~TCB_WAITEXECVE;
 840                         return 0;
 841                 }
 842         }
 843
 844 #  ifdef POWERPC64
 845         if (!(tcp->flags & TCB_INSYSCALL)) {
 846                 static int currpers = -1;
 847                 long val;
 848                 int pid = tcp->pid;
 849
 850                 /* Check for 64/32 bit mode. */
 851                 if (upeek(tcp, sizeof(unsigned long)*PT_MSR, &val) < 0)
 852                         return -1;
 853                 /* SF is bit 0 of MSR */
 854                 if (val < 0)
 855                         currpers = 0;
 856                 else
 857                         currpers = 1;
 858                 if (currpers != current_personality) {
 859                         static const char *const names[] = {"64 bit", "32 bit"};
 860                         set_personality(currpers);
 861                         fprintf(stderr, "[ Process PID=%d runs in %s mode. ]\n",
 862                                         pid, names[current_personality]);
 863                 }
 864         }
 865 #  endif
 866 # elif defined(AVR32)
 867         /*
 868          * Read complete register set in one go.
 869          */
 870         if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, &regs) < 0)
 871                 return -1;
 872
 873         /*
 874          * We only need to grab the syscall number on syscall entry.
 875          */
 876         if (!(tcp->flags & TCB_INSYSCALL)) {
 877                 scno = regs.r8;
 878
 879                 /* Check if we return from execve. */
 880                 if (tcp->flags & TCB_WAITEXECVE) {
 881                         tcp->flags &= ~TCB_WAITEXECVE;
 882                         return 0;
 883                 }
 884         }
 885 # elif defined(BFIN)
 886         if (upeek(tcp, PT_ORIG_P0, &scno))
 887                 return -1;
 888 # elif defined (I386)
 889         if (upeek(tcp, 4*ORIG_EAX, &scno) < 0)
 890                 return -1;
 891 # elif defined (X86_64)
 892         if (upeek(tcp, 8*ORIG_RAX, &scno) < 0)
 893                 return -1;
 894
 895         if (!(tcp->flags & TCB_INSYSCALL)) {
 896                 static int currpers = -1;
 897                 long val;
 898                 int pid = tcp->pid;
 899
 900                 /* Check CS register value. On x86-64 linux it is:
 901                  *      0x33    for long mode (64 bit)
 902                  *      0x23    for compatibility mode (32 bit)
 903                  * It takes only one ptrace and thus doesn't need
 904                  * to be cached.
 905                  */
 906                 if (upeek(tcp, 8*CS, &val) < 0)
 907                         return -1;
 908                 switch (val) {
 909                         case 0x23: currpers = 1; break;
 910                         case 0x33: currpers = 0; break;
 911                         default:
 912                                 fprintf(stderr, "Unknown value CS=0x%02X while "
 913                                          "detecting personality of process "
 914                                          "PID=%d\n", (int)val, pid);
 915                                 currpers = current_personality;
 916                                 break;
 917                 }
 918 #  if 0
 919                 /* This version analyzes the opcode of a syscall instruction.
 920                  * (int 0x80 on i386 vs. syscall on x86-64)
 921                  * It works, but is too complicated.
 922                  */
 923                 unsigned long val, rip, i;
 924
 925                 if (upeek(tcp, 8*RIP, &rip) < 0)
 926                         perror("upeek(RIP)");
 927
 928                 /* sizeof(syscall) == sizeof(int 0x80) == 2 */
 929                 rip -= 2;
 930                 errno = 0;
 931
 932                 call = ptrace(PTRACE_PEEKTEXT, pid, (char *)rip, (char *)0);
 933                 if (errno)
 934                         fprintf(stderr, "ptrace_peektext failed: %s\n",
 935                                         strerror(errno));
 936                 switch (call & 0xffff) {
 937                         /* x86-64: syscall = 0x0f 0x05 */
 938                         case 0x050f: currpers = 0; break;
 939                         /* i386: int 0x80 = 0xcd 0x80 */
 940                         case 0x80cd: currpers = 1; break;
 941                         default:
 942                                 currpers = current_personality;
 943                                 fprintf(stderr,
 944                                         "Unknown syscall opcode (0x%04X) while "
 945                                         "detecting personality of process "
 946                                         "PID=%d\n", (int)call, pid);
 947                                 break;
 948                 }
 949 #  endif
 950                 if (currpers != current_personality) {
 951                         static const char *const names[] = {"64 bit", "32 bit"};
 952                         set_personality(currpers);
 953                         fprintf(stderr, "[ Process PID=%d runs in %s mode. ]\n",
 954                                         pid, names[current_personality]);
 955                 }
 956         }
 957 # elif defined(IA64)
 958 #       define IA64_PSR_IS      ((long)1 << 34)
 959         if (upeek(tcp, PT_CR_IPSR, &psr) >= 0)
 960                 ia32 = (psr & IA64_PSR_IS) != 0;
 961         if (!(tcp->flags & TCB_INSYSCALL)) {
 962                 if (ia32) {
 963                         if (upeek(tcp, PT_R1, &scno) < 0)       /* orig eax */
 964                                 return -1;
 965                 } else {
 966                         if (upeek(tcp, PT_R15, &scno) < 0)
 967                                 return -1;
 968                 }
 969                 /* Check if we return from execve. */
 970                 if (tcp->flags & TCB_WAITEXECVE) {
 971                         tcp->flags &= ~TCB_WAITEXECVE;
 972                         return 0;
 973                 }
 974         } else {
 975                 /* syscall in progress */
 976                 if (upeek(tcp, PT_R8, &r8) < 0)
 977                         return -1;
 978                 if (upeek(tcp, PT_R10, &r10) < 0)
 979                         return -1;
 980         }
 981 # elif defined (ARM)
 982         /*
 983          * Read complete register set in one go.
 984          */
 985         if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (void *)&regs) == -1)
 986                 return -1;
 987
 988         /*
 989          * We only need to grab the syscall number on syscall entry.
 990          */
 991         if (regs.ARM_ip == 0) {
 992                 if (!(tcp->flags & TCB_INSYSCALL)) {
 993                         /* Check if we return from execve. */
 994                         if (tcp->flags & TCB_WAITEXECVE) {
 995                                 tcp->flags &= ~TCB_WAITEXECVE;
 996                                 return 0;
 997                         }
 998                 }
 999
1000                 /*
1001                  * Note: we only deal with only 32-bit CPUs here.
1002                  */
1003                 if (regs.ARM_cpsr & 0x20) {
1004                         /*
1005                          * Get the Thumb-mode system call number
1006                          */
1007                         scno = regs.ARM_r7;
1008                 } else {
1009                         /*
1010                          * Get the ARM-mode system call number
1011                          */
1012                         errno = 0;
1013                         scno = ptrace(PTRACE_PEEKTEXT, tcp->pid, (void *)(regs.ARM_pc - 4), NULL);
1014                         if (errno)
1015                                 return -1;
1016
1017                         if (scno == 0 && (tcp->flags & TCB_WAITEXECVE)) {
1018                                 tcp->flags &= ~TCB_WAITEXECVE;
1019                                 return 0;
1020                         }
1021
1022                         /* Handle the EABI syscall convention.  We do not
1023                            bother converting structures between the two
1024                            ABIs, but basic functionality should work even
1025                            if strace and the traced program have different
1026                            ABIs.  */
1027                         if (scno == 0xef000000) {
1028                                 scno = regs.ARM_r7;
1029                         } else {
1030                                 if ((scno & 0x0ff00000) != 0x0f900000) {
1031                                         fprintf(stderr, "syscall: unknown syscall trap 0x%08lx\n",
1032                                                 scno);
1033                                         return -1;
1034                                 }
1035
1036                                 /*
1037                                  * Fixup the syscall number
1038                                  */
1039                                 scno &= 0x000fffff;
1040                         }
1041                 }
1042                 if (scno & 0x0f0000) {
1043                         /*
1044                          * Handle ARM specific syscall
1045                          */
1046                         set_personality(1);
1047                         scno &= 0x0000ffff;
1048                 } else
1049                         set_personality(0);
1050
1051                 if (tcp->flags & TCB_INSYSCALL) {
1052                         fprintf(stderr, "pid %d stray syscall entry\n", tcp->pid);
1053                         tcp->flags &= ~TCB_INSYSCALL;
1054                 }
1055         } else {
1056                 if (!(tcp->flags & TCB_INSYSCALL)) {
1057                         fprintf(stderr, "pid %d stray syscall exit\n", tcp->pid);
1058                         tcp->flags |= TCB_INSYSCALL;
1059                 }
1060         }
1061 # elif defined (M68K)
1062         if (upeek(tcp, 4*PT_ORIG_D0, &scno) < 0)
1063                 return -1;
1064 # elif defined (LINUX_MIPSN32)
1065         unsigned long long regs[38];
1066
1067         if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) &regs) < 0)
1068                 return -1;
1069         a3 = regs[REG_A3];
1070         r2 = regs[REG_V0];
1071
1072         if (!(tcp->flags & TCB_INSYSCALL)) {
1073                 scno = r2;
1074
1075                 /* Check if we return from execve. */
1076                 if (scno == 0 && tcp->flags & TCB_WAITEXECVE) {
1077                         tcp->flags &= ~TCB_WAITEXECVE;
1078                         return 0;
1079                 }
1080
1081                 if (scno < 0 || scno > nsyscalls) {
1082                         if (a3 == 0 || a3 == -1) {
1083                                 if (debug)
1084                                         fprintf(stderr, "stray syscall exit: v0 = %ld\n", scno);
1085                                 return 0;
1086                         }
1087                 }
1088         }
1089 # elif defined (MIPS)
1090         if (upeek(tcp, REG_A3, &a3) < 0)
1091                 return -1;
1092         if (!(tcp->flags & TCB_INSYSCALL)) {
1093                 if (upeek(tcp, REG_V0, &scno) < 0)
1094                         return -1;
1095
1096                 /* Check if we return from execve. */
1097                 if (scno == 0 && tcp->flags & TCB_WAITEXECVE) {
1098                         tcp->flags &= ~TCB_WAITEXECVE;
1099                         return 0;
1100                 }
1101
1102                 if (scno < 0 || scno > nsyscalls) {
1103                         if (a3 == 0 || a3 == -1) {
1104                                 if (debug)
1105                                         fprintf(stderr, "stray syscall exit: v0 = %ld\n", scno);
1106                                 return 0;
1107                         }
1108                 }
1109         } else {
1110                 if (upeek(tcp, REG_V0, &r2) < 0)
1111                         return -1;
1112         }
1113 # elif defined (ALPHA)
1114         if (upeek(tcp, REG_A3, &a3) < 0)
1115                 return -1;
1116
1117         if (!(tcp->flags & TCB_INSYSCALL)) {
1118                 if (upeek(tcp, REG_R0, &scno) < 0)
1119                         return -1;
1120
1121                 /* Check if we return from execve. */
1122                 if (scno == 0 && tcp->flags & TCB_WAITEXECVE) {
1123                         tcp->flags &= ~TCB_WAITEXECVE;
1124                         return 0;
1125                 }
1126
1127                 /*
1128                  * Do some sanity checks to figure out if it's
1129                  * really a syscall entry
1130                  */
1131                 if (scno < 0 || scno > nsyscalls) {
1132                         if (a3 == 0 || a3 == -1) {
1133                                 if (debug)
1134                                         fprintf(stderr, "stray syscall exit: r0 = %ld\n", scno);
1135                                 return 0;
1136                         }
1137                 }
1138         }
1139         else {
1140                 if (upeek(tcp, REG_R0, &r0) < 0)
1141                         return -1;
1142         }
1143 # elif defined (SPARC) || defined (SPARC64)
1144         /* Everything we need is in the current register set. */
1145         if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)&regs, 0) < 0)
1146                 return -1;
1147
1148         /* If we are entering, then disassemble the syscall trap. */
1149         if (!(tcp->flags & TCB_INSYSCALL)) {
1150                 /* Retrieve the syscall trap instruction. */
1151                 errno = 0;
1152 #  if defined(SPARC64)
1153                 trap = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)regs.tpc, 0);
1154                 trap >>= 32;
1155 #  else
1156                 trap = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)regs.pc, 0);
1157 #  endif
1158                 if (errno)
1159                         return -1;
1160
1161                 /* Disassemble the trap to see what personality to use. */
1162                 switch (trap) {
1163                 case 0x91d02010:
1164                         /* Linux/SPARC syscall trap. */
1165                         set_personality(0);
1166                         break;
1167                 case 0x91d0206d:
1168                         /* Linux/SPARC64 syscall trap. */
1169                         set_personality(2);
1170                         break;
1171                 case 0x91d02000:
1172                         /* SunOS syscall trap. (pers 1) */
1173                         fprintf(stderr, "syscall: SunOS no support\n");
1174                         return -1;
1175                 case 0x91d02008:
1176                         /* Solaris 2.x syscall trap. (per 2) */
1177                         set_personality(1);
1178                         break;
1179                 case 0x91d02009:
1180                         /* NetBSD/FreeBSD syscall trap. */
1181                         fprintf(stderr, "syscall: NetBSD/FreeBSD not supported\n");
1182                         return -1;
1183                 case 0x91d02027:
1184                         /* Solaris 2.x gettimeofday */
1185                         set_personality(1);
1186                         break;
1187                 default:
1188                         /* Unknown syscall trap. */
1189                         if (tcp->flags & TCB_WAITEXECVE) {
1190                                 tcp->flags &= ~TCB_WAITEXECVE;
1191                                 return 0;
1192                         }
1193 #  if defined (SPARC64)
1194                         fprintf(stderr, "syscall: unknown syscall trap %08lx %016lx\n", trap, regs.tpc);
1195 #  else
1196                         fprintf(stderr, "syscall: unknown syscall trap %08lx %08lx\n", trap, regs.pc);
1197 #  endif
1198                         return -1;
1199                 }
1200
1201                 /* Extract the system call number from the registers. */
1202                 if (trap == 0x91d02027)
1203                         scno = 156;
1204                 else
1205                         scno = regs.u_regs[U_REG_G1];
1206                 if (scno == 0) {
1207                         scno = regs.u_regs[U_REG_O0];
1208                         memmove(&regs.u_regs[U_REG_O0], &regs.u_regs[U_REG_O1], 7*sizeof(regs.u_regs[0]));
1209                 }
1210         }
1211 # elif defined(HPPA)
1212         if (upeek(tcp, PT_GR20, &scno) < 0)
1213                 return -1;
1214         if (!(tcp->flags & TCB_INSYSCALL)) {
1215                 /* Check if we return from execve. */
1216                 if ((tcp->flags & TCB_WAITEXECVE)) {
1217                         tcp->flags &= ~TCB_WAITEXECVE;
1218                         return 0;
1219                 }
1220         }
1221 # elif defined(SH)
1222         /*
1223          * In the new syscall ABI, the system call number is in R3.
1224          */
1225         if (upeek(tcp, 4*(REG_REG0+3), &scno) < 0)
1226                 return -1;
1227
1228         if (scno < 0) {
1229                 /* Odd as it may seem, a glibc bug has been known to cause
1230                    glibc to issue bogus negative syscall numbers.  So for
1231                    our purposes, make strace print what it *should* have been */
1232                 long correct_scno = (scno & 0xff);
1233                 if (debug)
1234                         fprintf(stderr,
1235                                 "Detected glibc bug: bogus system call"
1236                                 " number = %ld, correcting to %ld\n",
1237                                 scno,
1238                                 correct_scno);
1239                 scno = correct_scno;
1240         }
1241
1242         if (!(tcp->flags & TCB_INSYSCALL)) {
1243                 /* Check if we return from execve. */
1244                 if (scno == 0 && tcp->flags & TCB_WAITEXECVE) {
1245                         tcp->flags &= ~TCB_WAITEXECVE;
1246                         return 0;
1247                 }
1248         }
1249 # elif defined(SH64)
1250         if (upeek(tcp, REG_SYSCALL, &scno) < 0)
1251                 return -1;
1252         scno &= 0xFFFF;
1253
1254         if (!(tcp->flags & TCB_INSYSCALL)) {
1255                 /* Check if we return from execve. */
1256                 if (tcp->flags & TCB_WAITEXECVE) {
1257                         tcp->flags &= ~TCB_WAITEXECVE;
1258                         return 0;
1259                 }
1260         }
1261 # elif defined(CRISV10) || defined(CRISV32)
1262         if (upeek(tcp, 4*PT_R9, &scno) < 0)
1263                 return -1;
1264 # elif defined(TILE)
1265         if (upeek(tcp, PTREGS_OFFSET_REG(10), &scno) < 0)
1266                 return -1;
1267
1268         if (!(tcp->flags & TCB_INSYSCALL)) {
1269                 /* Check if we return from execve. */
1270                 if (tcp->flags & TCB_WAITEXECVE) {
1271                         tcp->flags &= ~TCB_WAITEXECVE;
1272                         return 0;
1273                 }
1274         }
1275 # elif defined(MICROBLAZE)
1276         if (upeek(tcp, 0, &scno) < 0)
1277                 return -1;
1278 # endif
1279 #endif /* LINUX */
1280
1281 #ifdef SUNOS4
1282         if (upeek(tcp, uoff(u_arg[7]), &scno) < 0)
1283                 return -1;
1284 #elif defined(SH)
1285         /* new syscall ABI returns result in R0 */
1286         if (upeek(tcp, 4*REG_REG0, (long *)&r0) < 0)
1287                 return -1;
1288 #elif defined(SH64)
1289         /* ABI defines result returned in r9 */
1290         if (upeek(tcp, REG_GENERAL(9), (long *)&r9) < 0)
1291                 return -1;
1292 #endif
1293
1294 #ifdef USE_PROCFS
1295 # ifdef HAVE_PR_SYSCALL
1296         scno = tcp->status.PR_SYSCALL;
1297 # else
1298 #  ifndef FREEBSD
1299         scno = tcp->status.PR_WHAT;
1300 #  else
1301         if (pread(tcp->pfd_reg, &regs, sizeof(regs), 0) < 0) {
1302                 perror("pread");
1303                 return -1;
1304         }
1305         switch (regs.r_eax) {
1306         case SYS_syscall:
1307         case SYS___syscall:
1308                 pread(tcp->pfd, &scno, sizeof(scno), regs.r_esp + sizeof(int));
1309                 break;
1310         default:
1311                 scno = regs.r_eax;
1312                 break;
1313         }
1314 #  endif /* FREEBSD */
1315 # endif /* !HAVE_PR_SYSCALL */
1316 #endif /* USE_PROCFS */
1317
1318         if (!(tcp->flags & TCB_INSYSCALL))
1319                 tcp->scno = scno;
1320         return 1;
1321 }
1322
1323
1324 long
1325 known_scno(struct tcb *tcp)
1326 {
1327         long scno = tcp->scno;
1328 #if SUPPORTED_PERSONALITIES > 1
1329         if (scno >= 0 && scno < nsyscalls && sysent[scno].native_scno != 0)
1330                 scno = sysent[scno].native_scno;
1331         else
1332 #endif
1333                 scno += NR_SYSCALL_BASE;
1334         return scno;
1335 }
1336
1337 /* Called in trace_syscall() at each syscall entry and exit.
1338  * Returns:
1339  * 0: "ignore this syscall", bail out of trace_syscall() silently.
1340  * 1: ok, continue in trace_syscall().
1341  * other: error, trace_syscall() should print error indicator
1342  *    ("????" etc) and bail out.
1343  */
1344 static int
1345 syscall_fixup(struct tcb *tcp)
1346 {
1347 #ifdef USE_PROCFS
1348         int scno = known_scno(tcp);
1349
1350         if (!(tcp->flags & TCB_INSYSCALL)) {
1351                 if (tcp->status.PR_WHY != PR_SYSENTRY) {
1352                         if (
1353                             scno == SYS_fork
1354 #ifdef SYS_vfork
1355                             || scno == SYS_vfork
1356 #endif /* SYS_vfork */
1357 #ifdef SYS_fork1
1358                             || scno == SYS_fork1
1359 #endif /* SYS_fork1 */
1360 #ifdef SYS_forkall
1361                             || scno == SYS_forkall
1362 #endif /* SYS_forkall */
1363 #ifdef SYS_rfork1
1364                             || scno == SYS_rfork1
1365 #endif /* SYS_fork1 */
1366 #ifdef SYS_rforkall
1367                             || scno == SYS_rforkall
1368 #endif /* SYS_rforkall */
1369                             ) {
1370                                 /* We are returning in the child, fake it. */
1371                                 tcp->status.PR_WHY = PR_SYSENTRY;
1372                                 trace_syscall(tcp);
1373                                 tcp->status.PR_WHY = PR_SYSEXIT;
1374                         }
1375                         else {
1376                                 fprintf(stderr, "syscall: missing entry\n");
1377                                 tcp->flags |= TCB_INSYSCALL;
1378                         }
1379                 }
1380         }
1381         else {
1382                 if (tcp->status.PR_WHY != PR_SYSEXIT) {
1383                         fprintf(stderr, "syscall: missing exit\n");
1384                         tcp->flags &= ~TCB_INSYSCALL;
1385                 }
1386         }
1387 #endif /* USE_PROCFS */
1388 #ifdef SUNOS4
1389         if (!(tcp->flags & TCB_INSYSCALL)) {
1390                 if (scno == 0) {
1391                         fprintf(stderr, "syscall: missing entry\n");
1392                         tcp->flags |= TCB_INSYSCALL;
1393                 }
1394         }
1395         else {
1396                 if (scno != 0) {
1397                         if (debug) {
1398                                 /*
1399                                  * This happens when a signal handler
1400                                  * for a signal which interrupted a
1401                                  * a system call makes another system call.
1402                                  */
1403                                 fprintf(stderr, "syscall: missing exit\n");
1404                         }
1405                         tcp->flags &= ~TCB_INSYSCALL;
1406                 }
1407         }
1408 #endif /* SUNOS4 */
1409 #ifdef LINUX
1410 #if defined (I386)
1411         if (upeek(tcp, 4*EAX, &eax) < 0)
1412                 return -1;
1413         if (eax != -ENOSYS && !(tcp->flags & TCB_INSYSCALL)) {
1414                 if (debug)
1415                         fprintf(stderr, "stray syscall exit: eax = %ld\n", eax);
1416                 return 0;
1417         }
1418 #elif defined (X86_64)
1419         if (upeek(tcp, 8*RAX, &rax) < 0)
1420                 return -1;
1421         if (current_personality == 1)
1422                 rax = (long int)(int)rax; /* sign extend from 32 bits */
1423         if (rax != -ENOSYS && !(tcp->flags & TCB_INSYSCALL)) {
1424                 if (debug)
1425                         fprintf(stderr, "stray syscall exit: rax = %ld\n", rax);
1426                 return 0;
1427         }
1428 #elif defined (S390) || defined (S390X)
1429         if (upeek(tcp, PT_GPR2, &gpr2) < 0)
1430                 return -1;
1431         if (syscall_mode != -ENOSYS)
1432                 syscall_mode = tcp->scno;
1433         if (gpr2 != syscall_mode && !(tcp->flags & TCB_INSYSCALL)) {
1434                 if (debug)
1435                         fprintf(stderr, "stray syscall exit: gpr2 = %ld\n", gpr2);
1436                 return 0;
1437         }
1438         else if (((tcp->flags & (TCB_INSYSCALL|TCB_WAITEXECVE))
1439                   == (TCB_INSYSCALL|TCB_WAITEXECVE))
1440                  && (gpr2 == -ENOSYS || gpr2 == tcp->scno)) {
1441                 /*
1442                  * Fake a return value of zero.  We leave the TCB_WAITEXECVE
1443                  * flag set for the post-execve SIGTRAP to see and reset.
1444                  */
1445                 gpr2 = 0;
1446         }
1447 #elif defined (POWERPC)
1448 # define SO_MASK 0x10000000
1449         if (upeek(tcp, sizeof(unsigned long)*PT_CCR, &flags) < 0)
1450                 return -1;
1451         if (upeek(tcp, sizeof(unsigned long)*PT_R3, &result) < 0)
1452                 return -1;
1453         if (flags & SO_MASK)
1454                 result = -result;
1455 #elif defined (M68K)
1456         if (upeek(tcp, 4*PT_D0, &d0) < 0)
1457                 return -1;
1458         if (d0 != -ENOSYS && !(tcp->flags & TCB_INSYSCALL)) {
1459                 if (debug)
1460                         fprintf(stderr, "stray syscall exit: d0 = %ld\n", d0);
1461                 return 0;
1462         }
1463 #elif defined (ARM)
1464         /*
1465          * Nothing required
1466          */
1467 #elif defined(BFIN)
1468         if (upeek(tcp, PT_R0, &r0) < 0)
1469                 return -1;
1470 #elif defined (HPPA)
1471         if (upeek(tcp, PT_GR28, &r28) < 0)
1472                 return -1;
1473 #elif defined(IA64)
1474         if (upeek(tcp, PT_R10, &r10) < 0)
1475                 return -1;
1476         if (upeek(tcp, PT_R8, &r8) < 0)
1477                 return -1;
1478         if (ia32 && r8 != -ENOSYS && !(tcp->flags & TCB_INSYSCALL)) {
1479                 if (debug)
1480                         fprintf(stderr, "stray syscall exit: r8 = %ld\n", r8);
1481                 return 0;
1482         }
1483 #elif defined(CRISV10) || defined(CRISV32)
1484         if (upeek(tcp, 4*PT_R10, &r10) < 0)
1485                 return -1;
1486         if (r10 != -ENOSYS && !(tcp->flags & TCB_INSYSCALL)) {
1487                 if (debug)
1488                         fprintf(stderr, "stray syscall exit: r10 = %ld\n", r10);
1489                 return 0;
1490         }
1491 #elif defined(MICROBLAZE)
1492         if (upeek(tcp, 3 * 4, &r3) < 0)
1493                 return -1;
1494         if (r3 != -ENOSYS && !(tcp->flags & TCB_INSYSCALL)) {
1495                 if (debug)
1496                         fprintf(stderr, "stray syscall exit: r3 = %ld\n", r3);
1497                 return 0;
1498         }
1499 #endif
1500 #endif /* LINUX */
1501         return 1;
1502 }
1503
1504 #ifdef LINUX
1505 /*
1506  * Check the syscall return value register value for whether it is
1507  * a negated errno code indicating an error, or a success return value.
1508  */
1509 static inline int
1510 is_negated_errno(unsigned long int val)
1511 {
1512         unsigned long int max = -(long int) nerrnos;
1513         if (personality_wordsize[current_personality] < sizeof(val)) {
1514                 val = (unsigned int) val;
1515                 max = (unsigned int) max;
1516         }
1517         return val > max;
1518 }
1519 #endif
1520
1521 static int
1522 get_error(struct tcb *tcp)
1523 {
1524         int u_error = 0;
1525 #ifdef LINUX
1526         int check_errno = 1;
1527         if (tcp->scno >= 0 && tcp->scno < nsyscalls &&
1528             sysent[tcp->scno].sys_flags & SYSCALL_NEVER_FAILS) {
1529                 check_errno = 0;
1530         }
1531 # if defined(S390) || defined(S390X)
1532         if (check_errno && is_negated_errno(gpr2)) {
1533                 tcp->u_rval = -1;
1534                 u_error = -gpr2;
1535         }
1536         else {
1537                 tcp->u_rval = gpr2;
1538                 u_error = 0;
1539         }
1540 # elif defined(I386)
1541         if (check_errno && is_negated_errno(eax)) {
1542                 tcp->u_rval = -1;
1543                 u_error = -eax;
1544         }
1545         else {
1546                 tcp->u_rval = eax;
1547                 u_error = 0;
1548         }
1549 # elif defined(X86_64)
1550         if (check_errno && is_negated_errno(rax)) {
1551                 tcp->u_rval = -1;
1552                 u_error = -rax;
1553         }
1554         else {
1555                 tcp->u_rval = rax;
1556                 u_error = 0;
1557         }
1558 # elif defined(IA64)
1559         if (ia32) {
1560                 int err;
1561
1562                 err = (int)r8;
1563                 if (check_errno && is_negated_errno(err)) {
1564                         tcp->u_rval = -1;
1565                         u_error = -err;
1566                 }
1567                 else {
1568                         tcp->u_rval = err;
1569                         u_error = 0;
1570                 }
1571         } else {
1572                 if (check_errno && r10) {
1573                         tcp->u_rval = -1;
1574                         u_error = r8;
1575                 } else {
1576                         tcp->u_rval = r8;
1577                         u_error = 0;
1578                 }
1579         }
1580 # elif defined(MIPS)
1581         if (check_errno && a3) {
1582                 tcp->u_rval = -1;
1583                 u_error = r2;
1584         } else {
1585                 tcp->u_rval = r2;
1586                 u_error = 0;
1587         }
1588 # elif defined(POWERPC)
1589         if (check_errno && is_negated_errno(result)) {
1590                 tcp->u_rval = -1;
1591                 u_error = -result;
1592         }
1593         else {
1594                 tcp->u_rval = result;
1595                 u_error = 0;
1596         }
1597 # elif defined(M68K)
1598         if (check_errno && is_negated_errno(d0)) {
1599                 tcp->u_rval = -1;
1600                 u_error = -d0;
1601         }
1602         else {
1603                 tcp->u_rval = d0;
1604                 u_error = 0;
1605         }
1606 # elif defined(ARM)
1607         if (check_errno && is_negated_errno(regs.ARM_r0)) {
1608                 tcp->u_rval = -1;
1609                 u_error = -regs.ARM_r0;
1610         }
1611         else {
1612                 tcp->u_rval = regs.ARM_r0;
1613                 u_error = 0;
1614         }
1615 # elif defined(AVR32)
1616         if (check_errno && regs.r12 && (unsigned) -regs.r12 < nerrnos) {
1617                 tcp->u_rval = -1;
1618                 u_error = -regs.r12;
1619         }
1620         else {
1621                 tcp->u_rval = regs.r12;
1622                 u_error = 0;
1623         }
1624 # elif defined(BFIN)
1625         if (check_errno && is_negated_errno(r0)) {
1626                 tcp->u_rval = -1;
1627                 u_error = -r0;
1628         } else {
1629                 tcp->u_rval = r0;
1630                 u_error = 0;
1631         }
1632 # elif defined(ALPHA)
1633         if (check_errno && a3) {
1634                 tcp->u_rval = -1;
1635                 u_error = r0;
1636         }
1637         else {
1638                 tcp->u_rval = r0;
1639                 u_error = 0;
1640         }
1641 # elif defined(SPARC)
1642         if (check_errno && regs.psr & PSR_C) {
1643                 tcp->u_rval = -1;
1644                 u_error = regs.u_regs[U_REG_O0];
1645         }
1646         else {
1647                 tcp->u_rval = regs.u_regs[U_REG_O0];
1648                 u_error = 0;
1649         }
1650 # elif defined(SPARC64)
1651         if (check_errno && regs.tstate & 0x1100000000UL) {
1652                 tcp->u_rval = -1;
1653                 u_error = regs.u_regs[U_REG_O0];
1654         }
1655         else {
1656                 tcp->u_rval = regs.u_regs[U_REG_O0];
1657                 u_error = 0;
1658         }
1659 # elif defined(HPPA)
1660         if (check_errno && is_negated_errno(r28)) {
1661                 tcp->u_rval = -1;
1662                 u_error = -r28;
1663         }
1664         else {
1665                 tcp->u_rval = r28;
1666                 u_error = 0;
1667         }
1668 # elif defined(SH)
1669         /* interpret R0 as return value or error number */
1670         if (check_errno && is_negated_errno(r0)) {
1671                 tcp->u_rval = -1;
1672                 u_error = -r0;
1673         }
1674         else {
1675                 tcp->u_rval = r0;
1676                 u_error = 0;
1677         }
1678 # elif defined(SH64)
1679         /* interpret result as return value or error number */
1680         if (check_errno && is_negated_errno(r9)) {
1681                 tcp->u_rval = -1;
1682                 u_error = -r9;
1683         }
1684         else {
1685                 tcp->u_rval = r9;
1686                 u_error = 0;
1687         }
1688 # elif defined(CRISV10) || defined(CRISV32)
1689         if (check_errno && r10 && (unsigned) -r10 < nerrnos) {
1690                 tcp->u_rval = -1;
1691                 u_error = -r10;
1692         }
1693         else {
1694                 tcp->u_rval = r10;
1695                 u_error = 0;
1696         }
1697 # elif defined(TILE)
1698         long rval;
1699         /* interpret result as return value or error number */
1700         if (upeek(tcp, PTREGS_OFFSET_REG(0), &rval) < 0)
1701                 return -1;
1702         if (check_errno && rval < 0 && rval > -nerrnos) {
1703                 tcp->u_rval = -1;
1704                 u_error = -rval;
1705         }
1706         else {
1707                 tcp->u_rval = rval;
1708                 u_error = 0;
1709         }
1710 # elif defined(MICROBLAZE)
1711         /* interpret result as return value or error number */
1712         if (check_errno && is_negated_errno(r3)) {
1713                 tcp->u_rval = -1;
1714                 u_error = -r3;
1715         }
1716         else {
1717                 tcp->u_rval = r3;
1718                 u_error = 0;
1719         }
1720 # endif
1721 #endif /* LINUX */
1722 #ifdef SUNOS4
1723         /* get error code from user struct */
1724         if (upeek(tcp, uoff(u_error), &u_error) < 0)
1725                 return -1;
1726         u_error >>= 24; /* u_error is a char */
1727
1728         /* get system call return value */
1729         if (upeek(tcp, uoff(u_rval1), &tcp->u_rval) < 0)
1730                 return -1;
1731 #endif /* SUNOS4 */
1732 #ifdef SVR4
1733 # ifdef SPARC
1734         /* Judicious guessing goes a long way. */
1735         if (tcp->status.pr_reg[R_PSR] & 0x100000) {
1736                 tcp->u_rval = -1;
1737                 u_error = tcp->status.pr_reg[R_O0];
1738         }
1739         else {
1740                 tcp->u_rval = tcp->status.pr_reg[R_O0];
1741                 u_error = 0;
1742         }
1743 # endif /* SPARC */
1744 # ifdef I386
1745         /* Wanna know how to kill an hour single-stepping? */
1746         if (tcp->status.PR_REG[EFL] & 0x1) {
1747                 tcp->u_rval = -1;
1748                 u_error = tcp->status.PR_REG[EAX];
1749         }
1750         else {
1751                 tcp->u_rval = tcp->status.PR_REG[EAX];
1752 #  ifdef HAVE_LONG_LONG
1753                 tcp->u_lrval =
1754                         ((unsigned long long) tcp->status.PR_REG[EDX] << 32) +
1755                         tcp->status.PR_REG[EAX];
1756 #  endif
1757                 u_error = 0;
1758         }
1759 # endif /* I386 */
1760 # ifdef X86_64
1761         /* Wanna know how to kill an hour single-stepping? */
1762         if (tcp->status.PR_REG[EFLAGS] & 0x1) {
1763                 tcp->u_rval = -1;
1764                 u_error = tcp->status.PR_REG[RAX];
1765         }
1766         else {
1767                 tcp->u_rval = tcp->status.PR_REG[RAX];
1768                 u_error = 0;
1769         }
1770 # endif /* X86_64 */
1771 # ifdef MIPS
1772         if (tcp->status.pr_reg[CTX_A3]) {
1773                 tcp->u_rval = -1;
1774                 u_error = tcp->status.pr_reg[CTX_V0];
1775         }
1776         else {
1777                 tcp->u_rval = tcp->status.pr_reg[CTX_V0];
1778                 u_error = 0;
1779         }
1780 # endif /* MIPS */
1781 #endif /* SVR4 */
1782 #ifdef FREEBSD
1783         if (regs.r_eflags & PSL_C) {
1784                 tcp->u_rval = -1;
1785                 u_error = regs.r_eax;
1786         } else {
1787                 tcp->u_rval = regs.r_eax;
1788                 tcp->u_lrval =
1789                   ((unsigned long long) regs.r_edx << 32) +  regs.r_eax;
1790                 u_error = 0;
1791         }
1792 #endif /* FREEBSD */
1793         tcp->u_error = u_error;
1794         return 1;
1795 }
1796
1797 int
1798 force_result(struct tcb *tcp, int error, long rval)
1799 {
1800 #ifdef LINUX
1801 # if defined(S390) || defined(S390X)
1802         gpr2 = error ? -error : rval;
1803         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)PT_GPR2, gpr2) < 0)
1804                 return -1;
1805 # elif defined(I386)
1806         eax = error ? -error : rval;
1807         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(EAX * 4), eax) < 0)
1808                 return -1;
1809 # elif defined(X86_64)
1810         rax = error ? -error : rval;
1811         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(RAX * 8), rax) < 0)
1812                 return -1;
1813 # elif defined(IA64)
1814         if (ia32) {
1815                 r8 = error ? -error : rval;
1816                 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R8), r8) < 0)
1817                         return -1;
1818         }
1819         else {
1820                 if (error) {
1821                         r8 = error;
1822                         r10 = -1;
1823                 }
1824                 else {
1825                         r8 = rval;
1826                         r10 = 0;
1827                 }
1828                 if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R8), r8) < 0 ||
1829                     ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_R10), r10) < 0)
1830                         return -1;
1831         }
1832 # elif defined(BFIN)
1833         r0 = error ? -error : rval;
1834         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)PT_R0, r0) < 0)
1835                 return -1;
1836 # elif defined(MIPS)
1837         if (error) {
1838                 r2 = error;
1839                 a3 = -1;
1840         }
1841         else {
1842                 r2 = rval;
1843                 a3 = 0;
1844         }
1845         /* PTRACE_POKEUSER is OK even for n32 since rval is only a long.  */
1846         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_A3), a3) < 0 ||
1847             ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_V0), r2) < 0)
1848                 return -1;
1849 # elif defined(POWERPC)
1850         if (upeek(tcp, sizeof(unsigned long)*PT_CCR, &flags) < 0)
1851                 return -1;
1852         if (error) {
1853                 flags |= SO_MASK;
1854                 result = error;
1855         }
1856         else {
1857                 flags &= ~SO_MASK;
1858                 result = rval;
1859         }
1860         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(sizeof(unsigned long)*PT_CCR), flags) < 0 ||
1861             ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(sizeof(unsigned long)*PT_R3), result) < 0)
1862                 return -1;
1863 # elif defined(M68K)
1864         d0 = error ? -error : rval;
1865         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*PT_D0), d0) < 0)
1866                 return -1;
1867 # elif defined(ARM)
1868         regs.ARM_r0 = error ? -error : rval;
1869         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*0), regs.ARM_r0) < 0)
1870                 return -1;
1871 # elif defined(AVR32)
1872         regs.r12 = error ? -error : rval;
1873         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)REG_R12, regs.r12) < 0)
1874                 return -1;
1875 # elif defined(ALPHA)
1876         if (error) {
1877                 a3 = -1;
1878                 r0 = error;
1879         }
1880         else {
1881                 a3 = 0;
1882                 r0 = rval;
1883         }
1884         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_A3), a3) < 0 ||
1885             ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(REG_R0), r0) < 0)
1886                 return -1;
1887 # elif defined(SPARC)
1888         if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)&regs, 0) < 0)
1889                 return -1;
1890         if (error) {
1891                 regs.psr |= PSR_C;
1892                 regs.u_regs[U_REG_O0] = error;
1893         }
1894         else {
1895                 regs.psr &= ~PSR_C;
1896                 regs.u_regs[U_REG_O0] = rval;
1897         }
1898         if (ptrace(PTRACE_SETREGS, tcp->pid, (char *)&regs, 0) < 0)
1899                 return -1;
1900 # elif defined(SPARC64)
1901         if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)&regs, 0) < 0)
1902                 return -1;
1903         if (error) {
1904                 regs.tstate |= 0x1100000000UL;
1905                 regs.u_regs[U_REG_O0] = error;
1906         }
1907         else {
1908                 regs.tstate &= ~0x1100000000UL;
1909                 regs.u_regs[U_REG_O0] = rval;
1910         }
1911         if (ptrace(PTRACE_SETREGS, tcp->pid, (char *)&regs, 0) < 0)
1912                 return -1;
1913 # elif defined(HPPA)
1914         r28 = error ? -error : rval;
1915         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(PT_GR28), r28) < 0)
1916                 return -1;
1917 # elif defined(SH)
1918         r0 = error ? -error : rval;
1919         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)(4*REG_REG0), r0) < 0)
1920                 return -1;
1921 # elif defined(SH64)
1922         r9 = error ? -error : rval;
1923         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)REG_GENERAL(9), r9) < 0)
1924                 return -1;
1925 # endif
1926 #endif /* LINUX */
1927
1928 #ifdef SUNOS4
1929         if (ptrace(PTRACE_POKEUSER, tcp->pid, (char*)uoff(u_error),
1930                    error << 24) < 0 ||
1931             ptrace(PTRACE_POKEUSER, tcp->pid, (char*)uoff(u_rval1), rval) < 0)
1932                 return -1;
1933 #endif /* SUNOS4 */
1934
1935 #ifdef SVR4
1936         /* XXX no clue */
1937         return -1;
1938 #endif /* SVR4 */
1939
1940 #ifdef FREEBSD
1941         if (pread(tcp->pfd_reg, &regs, sizeof(regs), 0) < 0) {
1942                 perror("pread");
1943                 return -1;
1944         }
1945         if (error) {
1946                 regs.r_eflags |= PSL_C;
1947                 regs.r_eax = error;
1948         }
1949         else {
1950                 regs.r_eflags &= ~PSL_C;
1951                 regs.r_eax = rval;
1952         }
1953         if (pwrite(tcp->pfd_reg, &regs, sizeof(regs), 0) < 0) {
1954                 perror("pwrite");
1955                 return -1;
1956         }
1957 #endif /* FREEBSD */
1958
1959         /* All branches reach here on success (only).  */
1960         tcp->u_error = error;
1961         tcp->u_rval = rval;
1962         return 0;
1963 }
1964
1965 static int
1966 syscall_enter(struct tcb *tcp)
1967 {
1968 #ifdef LINUX
1969 #if defined(S390) || defined(S390X)
1970         {
1971                 int i;
1972                 if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
1973                         tcp->u_nargs = sysent[tcp->scno].nargs;
1974                 else
1975                         tcp->u_nargs = MAX_ARGS;
1976                 for (i = 0; i < tcp->u_nargs; i++) {
1977                         if (upeek(tcp, i==0 ? PT_ORIGGPR2 : PT_GPR2+i*sizeof(long), &tcp->u_arg[i]) < 0)
1978                                 return -1;
1979                 }
1980         }
1981 #elif defined (ALPHA)
1982         {
1983                 int i;
1984                 if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
1985                         tcp->u_nargs = sysent[tcp->scno].nargs;
1986                 else
1987                         tcp->u_nargs = MAX_ARGS;
1988                 for (i = 0; i < tcp->u_nargs; i++) {
1989                         /* WTA: if scno is out-of-bounds this will bomb. Add range-check
1990                          * for scno somewhere above here!
1991                          */
1992                         if (upeek(tcp, REG_A0+i, &tcp->u_arg[i]) < 0)
1993                                 return -1;
1994                 }
1995         }
1996 #elif defined (IA64)
1997         {
1998                 if (!ia32) {
1999                         unsigned long *out0, cfm, sof, sol, i;
2000                         long rbs_end;
2001                         /* be backwards compatible with kernel < 2.4.4... */
2002 #                       ifndef PT_RBS_END
2003 #                         define PT_RBS_END     PT_AR_BSP
2004 #                       endif
2005
2006                         if (upeek(tcp, PT_RBS_END, &rbs_end) < 0)
2007                                 return -1;
2008                         if (upeek(tcp, PT_CFM, (long *) &cfm) < 0)
2009                                 return -1;
2010
2011                         sof = (cfm >> 0) & 0x7f;
2012                         sol = (cfm >> 7) & 0x7f;
2013                         out0 = ia64_rse_skip_regs((unsigned long *) rbs_end, -sof + sol);
2014
2015                         if (tcp->scno >= 0 && tcp->scno < nsyscalls
2016                             && sysent[tcp->scno].nargs != -1)
2017                                 tcp->u_nargs = sysent[tcp->scno].nargs;
2018                         else
2019                                 tcp->u_nargs = MAX_ARGS;
2020                         for (i = 0; i < tcp->u_nargs; ++i) {
2021                                 if (umoven(tcp, (unsigned long) ia64_rse_skip_regs(out0, i),
2022                                            sizeof(long), (char *) &tcp->u_arg[i]) < 0)
2023                                         return -1;
2024                         }
2025                 } else {
2026                         int i;
2027
2028                         if (/* EBX = out0 */
2029                             upeek(tcp, PT_R11, (long *) &tcp->u_arg[0]) < 0
2030                             /* ECX = out1 */
2031                             || upeek(tcp, PT_R9,  (long *) &tcp->u_arg[1]) < 0
2032                             /* EDX = out2 */
2033                             || upeek(tcp, PT_R10, (long *) &tcp->u_arg[2]) < 0
2034                             /* ESI = out3 */
2035                             || upeek(tcp, PT_R14, (long *) &tcp->u_arg[3]) < 0
2036                             /* EDI = out4 */
2037                             || upeek(tcp, PT_R15, (long *) &tcp->u_arg[4]) < 0
2038                             /* EBP = out5 */
2039                             || upeek(tcp, PT_R13, (long *) &tcp->u_arg[5]) < 0)
2040                                 return -1;
2041
2042                         for (i = 0; i < 6; ++i)
2043                                 /* truncate away IVE sign-extension */
2044                                 tcp->u_arg[i] &= 0xffffffff;
2045
2046                         if (tcp->scno >= 0 && tcp->scno < nsyscalls
2047                             && sysent[tcp->scno].nargs != -1)
2048                                 tcp->u_nargs = sysent[tcp->scno].nargs;
2049                         else
2050                                 tcp->u_nargs = 5;
2051                 }
2052         }
2053 #elif defined (LINUX_MIPSN32) || defined (LINUX_MIPSN64)
2054         /* N32 and N64 both use up to six registers.  */
2055         {
2056                 unsigned long long regs[38];
2057                 int i, nargs;
2058
2059                 if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
2060                         nargs = tcp->u_nargs = sysent[tcp->scno].nargs;
2061                 else
2062                         nargs = tcp->u_nargs = MAX_ARGS;
2063
2064                 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) &regs) < 0)
2065                         return -1;
2066
2067                 for (i = 0; i < nargs; i++) {
2068                         tcp->u_arg[i] = regs[REG_A0 + i];
2069 # if defined (LINUX_MIPSN32)
2070                         tcp->ext_arg[i] = regs[REG_A0 + i];
2071 # endif
2072                 }
2073         }
2074 #elif defined (MIPS)
2075         {
2076                 long sp;
2077                 int i, nargs;
2078
2079                 if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
2080                         nargs = tcp->u_nargs = sysent[tcp->scno].nargs;
2081                 else
2082                         nargs = tcp->u_nargs = MAX_ARGS;
2083                 if (nargs > 4) {
2084                         if (upeek(tcp, REG_SP, &sp) < 0)
2085                                 return -1;
2086                         for (i = 0; i < 4; i++) {
2087                                 if (upeek(tcp, REG_A0 + i, &tcp->u_arg[i]) < 0)
2088                                         return -1;
2089                         }
2090                         umoven(tcp, sp+16, (nargs-4) * sizeof(tcp->u_arg[0]),
2091                                (char *)(tcp->u_arg + 4));
2092                 } else {
2093                         for (i = 0; i < nargs; i++) {
2094                                 if (upeek(tcp, REG_A0 + i, &tcp->u_arg[i]) < 0)
2095                                         return -1;
2096                         }
2097                 }
2098         }
2099 #elif defined (POWERPC)
2100 # ifndef PT_ORIG_R3
2101 #  define PT_ORIG_R3 34
2102 # endif
2103         {
2104                 int i;
2105                 if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
2106                         tcp->u_nargs = sysent[tcp->scno].nargs;
2107                 else
2108                         tcp->u_nargs = MAX_ARGS;
2109                 for (i = 0; i < tcp->u_nargs; i++) {
2110                         if (upeek(tcp, (i==0) ?
2111                                 (sizeof(unsigned long)*PT_ORIG_R3) :
2112                                 ((i+PT_R3)*sizeof(unsigned long)),
2113                                         &tcp->u_arg[i]) < 0)
2114                                 return -1;
2115                 }
2116         }
2117 #elif defined (SPARC) || defined (SPARC64)
2118         {
2119                 int i;
2120
2121                 if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
2122                         tcp->u_nargs = sysent[tcp->scno].nargs;
2123                 else
2124                         tcp->u_nargs = MAX_ARGS;
2125                 for (i = 0; i < tcp->u_nargs; i++)
2126                         tcp->u_arg[i] = regs.u_regs[U_REG_O0 + i];
2127         }
2128 #elif defined (HPPA)
2129         {
2130                 int i;
2131
2132                 if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
2133                         tcp->u_nargs = sysent[tcp->scno].nargs;
2134                 else
2135                         tcp->u_nargs = MAX_ARGS;
2136                 for (i = 0; i < tcp->u_nargs; i++) {
2137                         if (upeek(tcp, PT_GR26-4*i, &tcp->u_arg[i]) < 0)
2138                                 return -1;
2139                 }
2140         }
2141 #elif defined(ARM)
2142         {
2143                 int i;
2144
2145                 if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
2146                         tcp->u_nargs = sysent[tcp->scno].nargs;
2147                 else
2148                         tcp->u_nargs = MAX_ARGS;
2149                 for (i = 0; i < tcp->u_nargs; i++)
2150                         tcp->u_arg[i] = regs.uregs[i];
2151         }
2152 #elif defined(AVR32)
2153         tcp->u_nargs = sysent[tcp->scno].nargs;
2154         tcp->u_arg[0] = regs.r12;
2155         tcp->u_arg[1] = regs.r11;
2156         tcp->u_arg[2] = regs.r10;
2157         tcp->u_arg[3] = regs.r9;
2158         tcp->u_arg[4] = regs.r5;
2159         tcp->u_arg[5] = regs.r3;
2160 #elif defined(BFIN)
2161         {
2162                 int i;
2163                 int argreg[] = {PT_R0, PT_R1, PT_R2, PT_R3, PT_R4, PT_R5};
2164
2165                 if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
2166                         tcp->u_nargs = sysent[tcp->scno].nargs;
2167                 else
2168                         tcp->u_nargs = sizeof(argreg) / sizeof(argreg[0]);
2169
2170                 for (i = 0; i < tcp->u_nargs; ++i)
2171                         if (upeek(tcp, argreg[i], &tcp->u_arg[i]) < 0)
2172                                 return -1;
2173         }
2174 #elif defined(SH)
2175         {
2176                 int i;
2177                 static int syscall_regs[] = {
2178                         REG_REG0+4, REG_REG0+5, REG_REG0+6, REG_REG0+7,
2179                         REG_REG0, REG_REG0+1, REG_REG0+2
2180                 };
2181
2182                 tcp->u_nargs = sysent[tcp->scno].nargs;
2183                 for (i = 0; i < tcp->u_nargs; i++) {
2184                         if (upeek(tcp, 4*syscall_regs[i], &tcp->u_arg[i]) < 0)
2185                                 return -1;
2186                 }
2187         }
2188 #elif defined(SH64)
2189         {
2190                 int i;
2191                 /* Registers used by SH5 Linux system calls for parameters */
2192                 static int syscall_regs[] = { 2, 3, 4, 5, 6, 7 };
2193
2194                 /*
2195                  * TODO: should also check that the number of arguments encoded
2196                  *       in the trap number matches the number strace expects.
2197                  */
2198                 /*
2199                 assert(sysent[tcp->scno].nargs <
2200                        sizeof(syscall_regs)/sizeof(syscall_regs[0]));
2201                  */
2202
2203                 tcp->u_nargs = sysent[tcp->scno].nargs;
2204                 for (i = 0; i < tcp->u_nargs; i++) {
2205                         if (upeek(tcp, REG_GENERAL(syscall_regs[i]), &tcp->u_arg[i]) < 0)
2206                                 return -1;
2207                 }
2208         }
2209
2210 #elif defined(X86_64)
2211         {
2212                 int i;
2213                 static int argreg[SUPPORTED_PERSONALITIES][MAX_ARGS] = {
2214                         {RDI,RSI,RDX,R10,R8,R9},        /* x86-64 ABI */
2215                         {RBX,RCX,RDX,RSI,RDI,RBP}       /* i386 ABI */
2216                 };
2217
2218                 if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
2219                         tcp->u_nargs = sysent[tcp->scno].nargs;
2220                 else
2221                         tcp->u_nargs = MAX_ARGS;
2222                 for (i = 0; i < tcp->u_nargs; i++) {
2223                         if (upeek(tcp, argreg[current_personality][i]*8, &tcp->u_arg[i]) < 0)
2224                                 return -1;
2225                 }
2226         }
2227 #elif defined(MICROBLAZE)
2228         {
2229                 int i;
2230                 if (tcp->scno >= 0 && tcp->scno < nsyscalls)
2231                         tcp->u_nargs = sysent[tcp->scno].nargs;
2232                 else
2233                         tcp->u_nargs = 0;
2234                 for (i = 0; i < tcp->u_nargs; i++) {
2235                         if (upeek(tcp, (5 + i) * 4, &tcp->u_arg[i]) < 0)
2236                                 return -1;
2237                 }
2238         }
2239 #elif defined(CRISV10) || defined(CRISV32)
2240         {
2241                 int i;
2242                 static const int crisregs[] = {
2243                         4*PT_ORIG_R10, 4*PT_R11, 4*PT_R12,
2244                         4*PT_R13, 4*PT_MOF, 4*PT_SRP
2245                 };
2246
2247                 if (tcp->scno >= 0 && tcp->scno < nsyscalls)
2248                         tcp->u_nargs = sysent[tcp->scno].nargs;
2249                 else
2250                         tcp->u_nargs = 0;
2251                 for (i = 0; i < tcp->u_nargs; i++) {
2252                         if (upeek(tcp, crisregs[i], &tcp->u_arg[i]) < 0)
2253                                 return -1;
2254                 }
2255         }
2256 #elif defined(TILE)
2257         {
2258                 int i;
2259                 if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
2260                         tcp->u_nargs = sysent[tcp->scno].nargs;
2261                 else
2262                         tcp->u_nargs = MAX_ARGS;
2263                 for (i = 0; i < tcp->u_nargs; ++i) {
2264                         if (upeek(tcp, PTREGS_OFFSET_REG(i), &tcp->u_arg[i]) < 0)
2265                                 return -1;
2266                 }
2267         }
2268 #elif defined (M68K)
2269         {
2270                 int i;
2271                 if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
2272                         tcp->u_nargs = sysent[tcp->scno].nargs;
2273                 else
2274                         tcp->u_nargs = MAX_ARGS;
2275                 for (i = 0; i < tcp->u_nargs; i++) {
2276                         if (upeek(tcp, (i < 5 ? i : i + 2)*4, &tcp->u_arg[i]) < 0)
2277                                 return -1;
2278                 }
2279         }
2280 #else /* Other architecture (like i386) (32bits specific) */
2281         {
2282                 int i;
2283                 if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
2284                         tcp->u_nargs = sysent[tcp->scno].nargs;
2285                 else
2286                         tcp->u_nargs = MAX_ARGS;
2287                 for (i = 0; i < tcp->u_nargs; i++) {
2288                         if (upeek(tcp, i*4, &tcp->u_arg[i]) < 0)
2289                                 return -1;
2290                 }
2291         }
2292 #endif
2293 #endif /* LINUX */
2294 #ifdef SUNOS4
2295         {
2296                 int i;
2297                 if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
2298                         tcp->u_nargs = sysent[tcp->scno].nargs;
2299                 else
2300                         tcp->u_nargs = MAX_ARGS;
2301                 for (i = 0; i < tcp->u_nargs; i++) {
2302                         struct user *u;
2303
2304                         if (upeek(tcp, uoff(u_arg[0]) +
2305                             (i*sizeof(u->u_arg[0])), &tcp->u_arg[i]) < 0)
2306                                 return -1;
2307                 }
2308         }
2309 #endif /* SUNOS4 */
2310 #ifdef SVR4
2311 #ifdef MIPS
2312         /*
2313          * SGI is broken: even though it has pr_sysarg, it doesn't
2314          * set them on system call entry.  Get a clue.
2315          */
2316         if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
2317                 tcp->u_nargs = sysent[tcp->scno].nargs;
2318         else
2319                 tcp->u_nargs = tcp->status.pr_nsysarg;
2320         if (tcp->u_nargs > 4) {
2321                 memcpy(tcp->u_arg, &tcp->status.pr_reg[CTX_A0],
2322                         4*sizeof(tcp->u_arg[0]));
2323                 umoven(tcp, tcp->status.pr_reg[CTX_SP] + 16,
2324                         (tcp->u_nargs - 4)*sizeof(tcp->u_arg[0]), (char *) (tcp->u_arg + 4));
2325         }
2326         else {
2327                 memcpy(tcp->u_arg, &tcp->status.pr_reg[CTX_A0],
2328                         tcp->u_nargs*sizeof(tcp->u_arg[0]));
2329         }
2330 #elif UNIXWARE >= 2
2331         /*
2332          * Like SGI, UnixWare doesn't set pr_sysarg until system call exit
2333          */
2334         if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
2335                 tcp->u_nargs = sysent[tcp->scno].nargs;
2336         else
2337                 tcp->u_nargs = tcp->status.pr_lwp.pr_nsysarg;
2338         umoven(tcp, tcp->status.PR_REG[UESP] + 4,
2339                 tcp->u_nargs*sizeof(tcp->u_arg[0]), (char *) tcp->u_arg);
2340 #elif defined (HAVE_PR_SYSCALL)
2341         if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
2342                 tcp->u_nargs = sysent[tcp->scno].nargs;
2343         else
2344                 tcp->u_nargs = tcp->status.pr_nsysarg;
2345         {
2346                 int i;
2347                 for (i = 0; i < tcp->u_nargs; i++)
2348                         tcp->u_arg[i] = tcp->status.pr_sysarg[i];
2349         }
2350 #elif defined (I386)
2351         if (tcp->scno >= 0 && tcp->scno < nsyscalls && sysent[tcp->scno].nargs != -1)
2352                 tcp->u_nargs = sysent[tcp->scno].nargs;
2353         else
2354                 tcp->u_nargs = 5;
2355         if (tcp->u_nargs > 0)
2356                 umoven(tcp, tcp->status.PR_REG[UESP] + 4,
2357                         tcp->u_nargs*sizeof(tcp->u_arg[0]), (char *) tcp->u_arg);
2358 #else
2359         I DONT KNOW WHAT TO DO
2360 #endif /* !HAVE_PR_SYSCALL */
2361 #endif /* SVR4 */
2362 #ifdef FREEBSD
2363         if (tcp->scno >= 0 && tcp->scno < nsyscalls &&
2364             sysent[tcp->scno].nargs > tcp->status.val)
2365                 tcp->u_nargs = sysent[tcp->scno].nargs;
2366         else
2367                 tcp->u_nargs = tcp->status.val;
2368         if (tcp->u_nargs < 0)
2369                 tcp->u_nargs = 0;
2370         if (tcp->u_nargs > MAX_ARGS)
2371                 tcp->u_nargs = MAX_ARGS;
2372         switch (regs.r_eax) {
2373         case SYS___syscall:
2374                 pread(tcp->pfd, &tcp->u_arg, tcp->u_nargs * sizeof(unsigned long),
2375                       regs.r_esp + sizeof(int) + sizeof(quad_t));
2376                 break;
2377         case SYS_syscall:
2378                 pread(tcp->pfd, &tcp->u_arg, tcp->u_nargs * sizeof(unsigned long),
2379                       regs.r_esp + 2 * sizeof(int));
2380                 break;
2381         default:
2382                 pread(tcp->pfd, &tcp->u_arg, tcp->u_nargs * sizeof(unsigned long),
2383                       regs.r_esp + sizeof(int));
2384                 break;
2385         }
2386 #endif /* FREEBSD */
2387         return 1;
2388 }
2389
2390 static int
2391 trace_syscall_exiting(struct tcb *tcp)
2392 {
2393         int sys_res;
2394         struct timeval tv;
2395         int res, scno_good;
2396         long u_error;
2397
2398         /* Measure the exit time as early as possible to avoid errors. */
2399         if (dtime || cflag)
2400                 gettimeofday(&tv, NULL);
2401
2402         /* BTW, why we don't just memorize syscall no. on entry
2403          * in tcp->something?
2404          */
2405         scno_good = res = get_scno(tcp);
2406         if (res == 0)
2407                 return res;
2408         if (res == 1)
2409                 res = syscall_fixup(tcp);
2410         if (res == 0)
2411                 return res;
2412         if (res == 1)
2413                 res = get_error(tcp);
2414         if (res == 0)
2415                 return res;
2416         if (res == 1)
2417                 internal_syscall(tcp);
2418
2419         if (res == 1 && filtered(tcp)) {
2420                 tcp->flags &= ~TCB_INSYSCALL;
2421                 return 0;
2422         }
2423
2424         if (tcp->flags & TCB_REPRINT) {
2425                 printleader(tcp);
2426                 tprintf("<... ");
2427                 if (scno_good != 1)
2428                         tprintf("????");
2429                 else if (tcp->scno >= nsyscalls || tcp->scno < 0)
2430                         tprintf("syscall_%lu", tcp->scno);
2431                 else
2432                         tprintf("%s", sysent[tcp->scno].sys_name);
2433                 tprintf(" resumed> ");
2434         }
2435
2436         if (cflag) {
2437                 struct timeval t = tv;
2438                 int rc = count_syscall(tcp, &t);
2439                 if (cflag == CFLAG_ONLY_STATS)
2440                 {
2441                         tcp->flags &= ~TCB_INSYSCALL;
2442                         return rc;
2443                 }
2444         }
2445
2446         if (res != 1) {
2447                 tprintf(") ");
2448                 tabto(acolumn);
2449                 tprintf("= ? <unavailable>");
2450                 printtrailer();
2451                 tcp->flags &= ~TCB_INSYSCALL;
2452                 return res;
2453         }
2454
2455         if (tcp->scno >= nsyscalls || tcp->scno < 0
2456             || (qual_flags[tcp->scno] & QUAL_RAW))
2457                 sys_res = printargs(tcp);
2458         else {
2459                 if (not_failing_only && tcp->u_error)
2460                         return 0;       /* ignore failed syscalls */
2461                 sys_res = (*sysent[tcp->scno].sys_func)(tcp);
2462         }
2463
2464         u_error = tcp->u_error;
2465         tprintf(") ");
2466         tabto(acolumn);
2467         if (tcp->scno >= nsyscalls || tcp->scno < 0 ||
2468             qual_flags[tcp->scno] & QUAL_RAW) {
2469                 if (u_error)
2470                         tprintf("= -1 (errno %ld)", u_error);
2471                 else
2472                         tprintf("= %#lx", tcp->u_rval);
2473         }
2474         else if (!(sys_res & RVAL_NONE) && u_error) {
2475                 switch (u_error) {
2476 #ifdef LINUX
2477                 case ERESTARTSYS:
2478                         tprintf("= ? ERESTARTSYS (To be restarted)");
2479                         break;
2480                 case ERESTARTNOINTR:
2481                         tprintf("= ? ERESTARTNOINTR (To be restarted)");
2482                         break;
2483                 case ERESTARTNOHAND:
2484                         tprintf("= ? ERESTARTNOHAND (To be restarted)");
2485                         break;
2486                 case ERESTART_RESTARTBLOCK:
2487                         tprintf("= ? ERESTART_RESTARTBLOCK (To be restarted)");
2488                         break;
2489 #endif /* LINUX */
2490                 default:
2491                         tprintf("= -1 ");
2492                         if (u_error < 0)
2493                                 tprintf("E??? (errno %ld)", u_error);
2494                         else if (u_error < nerrnos)
2495                                 tprintf("%s (%s)", errnoent[u_error],
2496                                         strerror(u_error));
2497                         else
2498                                 tprintf("ERRNO_%ld (%s)", u_error,
2499                                         strerror(u_error));
2500                         break;
2501                 }
2502                 if ((sys_res & RVAL_STR) && tcp->auxstr)
2503                         tprintf(" (%s)", tcp->auxstr);
2504         }
2505         else {
2506                 if (sys_res & RVAL_NONE)
2507                         tprintf("= ?");
2508                 else {
2509                         switch (sys_res & RVAL_MASK) {
2510                         case RVAL_HEX:
2511                                 tprintf("= %#lx", tcp->u_rval);
2512                                 break;
2513                         case RVAL_OCTAL:
2514                                 tprintf("= %#lo", tcp->u_rval);
2515                                 break;
2516                         case RVAL_UDECIMAL:
2517                                 tprintf("= %lu", tcp->u_rval);
2518                                 break;
2519                         case RVAL_DECIMAL:
2520                                 tprintf("= %ld", tcp->u_rval);
2521                                 break;
2522 #ifdef HAVE_LONG_LONG
2523                         case RVAL_LHEX:
2524                                 tprintf("= %#llx", tcp->u_lrval);
2525                                 break;
2526                         case RVAL_LOCTAL:
2527                                 tprintf("= %#llo", tcp->u_lrval);
2528                                 break;
2529                         case RVAL_LUDECIMAL:
2530                                 tprintf("= %llu", tcp->u_lrval);
2531                                 break;
2532                         case RVAL_LDECIMAL:
2533                                 tprintf("= %lld", tcp->u_lrval);
2534                                 break;
2535 #endif
2536                         default:
2537                                 fprintf(stderr,
2538                                         "invalid rval format\n");
2539                                 break;
2540                         }
2541                 }
2542                 if ((sys_res & RVAL_STR) && tcp->auxstr)
2543                         tprintf(" (%s)", tcp->auxstr);
2544         }
2545         if (dtime) {
2546                 tv_sub(&tv, &tv, &tcp->etime);
2547                 tprintf(" <%ld.%06ld>",
2548                         (long) tv.tv_sec, (long) tv.tv_usec);
2549         }
2550         printtrailer();
2551
2552         dumpio(tcp);
2553         if (fflush(tcp->outf) == EOF)
2554                 return -1;
2555         tcp->flags &= ~TCB_INSYSCALL;
2556         return 0;
2557 }
2558
2559 static int
2560 trace_syscall_entering(struct tcb *tcp)
2561 {
2562         int sys_res;
2563         int res, scno_good;
2564
2565         scno_good = res = get_scno(tcp);
2566         if (res == 0)
2567                 return res;
2568         if (res == 1)
2569                 res = syscall_fixup(tcp);
2570         if (res == 0)
2571                 return res;
2572         if (res == 1)
2573                 res = syscall_enter(tcp);
2574         if (res == 0)
2575                 return res;
2576
2577         if (res != 1) {
2578                 printleader(tcp);
2579                 tcp->flags &= ~TCB_REPRINT;
2580                 tcp_last = tcp;
2581                 if (scno_good != 1)
2582                         tprintf("????" /* anti-trigraph gap */ "(");
2583                 else if (tcp->scno >= nsyscalls || tcp->scno < 0)
2584                         tprintf("syscall_%lu(", tcp->scno);
2585                 else
2586                         tprintf("%s(", sysent[tcp->scno].sys_name);
2587                 /*
2588                  * " <unavailable>" will be added later by the code which
2589                  * detects ptrace errors.
2590                  */
2591                 tcp->flags |= TCB_INSYSCALL;
2592                 return res;
2593         }
2594
2595         switch (known_scno(tcp)) {
2596 #ifdef SYS_socket_subcall
2597         case SYS_socketcall:
2598                 decode_subcall(tcp, SYS_socket_subcall,
2599                         SYS_socket_nsubcalls, deref_style);
2600                 break;
2601 #endif
2602 #ifdef SYS_ipc_subcall
2603         case SYS_ipc:
2604                 decode_subcall(tcp, SYS_ipc_subcall,
2605                         SYS_ipc_nsubcalls, shift_style);
2606                 break;
2607 #endif
2608 #ifdef SVR4
2609 #ifdef SYS_pgrpsys_subcall
2610         case SYS_pgrpsys:
2611                 decode_subcall(tcp, SYS_pgrpsys_subcall,
2612                         SYS_pgrpsys_nsubcalls, shift_style);
2613                 break;
2614 #endif /* SYS_pgrpsys_subcall */
2615 #ifdef SYS_sigcall_subcall
2616         case SYS_sigcall:
2617                 decode_subcall(tcp, SYS_sigcall_subcall,
2618                         SYS_sigcall_nsubcalls, mask_style);
2619                 break;
2620 #endif /* SYS_sigcall_subcall */
2621         case SYS_msgsys:
2622                 decode_subcall(tcp, SYS_msgsys_subcall,
2623                         SYS_msgsys_nsubcalls, shift_style);
2624                 break;
2625         case SYS_shmsys:
2626                 decode_subcall(tcp, SYS_shmsys_subcall,
2627                         SYS_shmsys_nsubcalls, shift_style);
2628                 break;
2629         case SYS_semsys:
2630                 decode_subcall(tcp, SYS_semsys_subcall,
2631                         SYS_semsys_nsubcalls, shift_style);
2632                 break;
2633         case SYS_sysfs:
2634                 decode_subcall(tcp, SYS_sysfs_subcall,
2635                         SYS_sysfs_nsubcalls, shift_style);
2636                 break;
2637         case SYS_spcall:
2638                 decode_subcall(tcp, SYS_spcall_subcall,
2639                         SYS_spcall_nsubcalls, shift_style);
2640                 break;
2641 #ifdef SYS_context_subcall
2642         case SYS_context:
2643                 decode_subcall(tcp, SYS_context_subcall,
2644                         SYS_context_nsubcalls, shift_style);
2645                 break;
2646 #endif /* SYS_context_subcall */
2647 #ifdef SYS_door_subcall
2648         case SYS_door:
2649                 decode_subcall(tcp, SYS_door_subcall,
2650                         SYS_door_nsubcalls, door_style);
2651                 break;
2652 #endif /* SYS_door_subcall */
2653 #ifdef SYS_kaio_subcall
2654         case SYS_kaio:
2655                 decode_subcall(tcp, SYS_kaio_subcall,
2656                         SYS_kaio_nsubcalls, shift_style);
2657                 break;
2658 #endif
2659 #endif /* SVR4 */
2660 #ifdef FREEBSD
2661         case SYS_msgsys:
2662         case SYS_shmsys:
2663         case SYS_semsys:
2664                 decode_subcall(tcp, 0, 0, table_style);
2665                 break;
2666 #endif
2667 #ifdef SUNOS4
2668         case SYS_semsys:
2669                 decode_subcall(tcp, SYS_semsys_subcall,
2670                         SYS_semsys_nsubcalls, shift_style);
2671                 break;
2672         case SYS_msgsys:
2673                 decode_subcall(tcp, SYS_msgsys_subcall,
2674                         SYS_msgsys_nsubcalls, shift_style);
2675                 break;
2676         case SYS_shmsys:
2677                 decode_subcall(tcp, SYS_shmsys_subcall,
2678                         SYS_shmsys_nsubcalls, shift_style);
2679                 break;
2680 #endif
2681         }
2682
2683         internal_syscall(tcp);
2684
2685         if ((tcp->scno >= 0 && tcp->scno < nsyscalls &&
2686              !(qual_flags[tcp->scno] & QUAL_TRACE)) ||
2687             (tracing_paths && !pathtrace_match(tcp))) {
2688                 tcp->flags |= TCB_INSYSCALL | TCB_FILTERED;
2689                 return 0;
2690         }
2691
2692         tcp->flags &= ~TCB_FILTERED;
2693
2694         if (cflag == CFLAG_ONLY_STATS) {
2695                 tcp->flags |= TCB_INSYSCALL;
2696                 gettimeofday(&tcp->etime, NULL);
2697                 return 0;
2698         }
2699
2700         printleader(tcp);
2701         tcp->flags &= ~TCB_REPRINT;
2702         tcp_last = tcp;
2703         if (tcp->scno >= nsyscalls || tcp->scno < 0)
2704                 tprintf("syscall_%lu(", tcp->scno);
2705         else
2706                 tprintf("%s(", sysent[tcp->scno].sys_name);
2707         if (tcp->scno >= nsyscalls || tcp->scno < 0 ||
2708             ((qual_flags[tcp->scno] & QUAL_RAW) &&
2709              sysent[tcp->scno].sys_func != sys_exit))
2710                 sys_res = printargs(tcp);
2711         else
2712                 sys_res = (*sysent[tcp->scno].sys_func)(tcp);
2713         if (fflush(tcp->outf) == EOF)
2714                 return -1;
2715         tcp->flags |= TCB_INSYSCALL;
2716         /* Measure the entrance time as late as possible to avoid errors. */
2717         if (dtime || cflag)
2718                 gettimeofday(&tcp->etime, NULL);
2719         return sys_res;
2720 }
2721
2722 int
2723 trace_syscall(struct tcb *tcp)
2724 {
2725         return exiting(tcp) ?
2726                 trace_syscall_exiting(tcp) : trace_syscall_entering(tcp);
2727 }
2728
2729 int
2730 printargs(struct tcb *tcp)
2731 {
2732         if (entering(tcp)) {
2733                 int i;
2734
2735                 for (i = 0; i < tcp->u_nargs; i++)
2736                         tprintf("%s%#lx", i ? ", " : "", tcp->u_arg[i]);
2737         }
2738         return 0;
2739 }
2740
2741 long
2742 getrval2(struct tcb *tcp)
2743 {
2744         long val = -1;
2745
2746 #ifdef LINUX
2747 #if defined (SPARC) || defined (SPARC64)
2748         struct pt_regs regs;
2749         if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)&regs, 0) < 0)
2750                 return -1;
2751         val = regs.u_regs[U_REG_O1];
2752 #elif defined(SH)
2753         if (upeek(tcp, 4*(REG_REG0+1), &val) < 0)
2754                 return -1;
2755 #elif defined(IA64)
2756         if (upeek(tcp, PT_R9, &val) < 0)
2757                 return -1;
2758 #endif
2759 #endif /* LINUX */
2760
2761 #ifdef SUNOS4
2762         if (upeek(tcp, uoff(u_rval2), &val) < 0)
2763                 return -1;
2764 #endif /* SUNOS4 */
2765
2766 #ifdef SVR4
2767 #ifdef SPARC
2768         val = tcp->status.PR_REG[R_O1];
2769 #endif /* SPARC */
2770 #ifdef I386
2771         val = tcp->status.PR_REG[EDX];
2772 #endif /* I386 */
2773 #ifdef X86_64
2774         val = tcp->status.PR_REG[RDX];
2775 #endif /* X86_64 */
2776 #ifdef MIPS
2777         val = tcp->status.PR_REG[CTX_V1];
2778 #endif /* MIPS */
2779 #endif /* SVR4 */
2780
2781 #ifdef FREEBSD
2782         struct reg regs;
2783         pread(tcp->pfd_reg, &regs, sizeof(regs), 0);
2784         val = regs.r_edx;
2785 #endif
2786         return val;
2787 }
2788
2789 #ifdef SUNOS4
2790 /*
2791  * Apparently, indirect system calls have already be converted by ptrace(2),
2792  * so if you see "indir" this program has gone astray.
2793  */
2794 int
2795 sys_indir(struct tcb *tcp)
2796 {
2797         int i, scno, nargs;
2798
2799         if (entering(tcp)) {
2800                 if ((scno = tcp->u_arg[0]) > nsyscalls) {
2801                         fprintf(stderr, "Bogus syscall: %u\n", scno);
2802                         return 0;
2803                 }
2804                 nargs = sysent[scno].nargs;
2805                 tprintf("%s", sysent[scno].sys_name);
2806                 for (i = 0; i < nargs; i++)
2807                         tprintf(", %#lx", tcp->u_arg[i+1]);
2808         }
2809         return 0;
2810 }
2811 #endif /* SUNOS4 */
2812
2813 int
2814 is_restart_error(struct tcb *tcp)
2815 {
2816 #ifdef LINUX
2817         if (!syserror(tcp))
2818                 return 0;
2819         switch (tcp->u_error) {
2820                 case ERESTARTSYS:
2821                 case ERESTARTNOINTR:
2822                 case ERESTARTNOHAND:
2823                 case ERESTART_RESTARTBLOCK:
2824                         return 1;
2825                 default:
2826                         break;
2827         }
2828 #endif /* LINUX */
2829         return 0;
2830 }