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         umoven(tcp, tcp->status.PR_REG[UESP] + 4,
2356                 tcp->u_nargs*sizeof(tcp->u_arg[0]), (char *) tcp->u_arg);
2357 #else
2358         I DONT KNOW WHAT TO DO
2359 #endif /* !HAVE_PR_SYSCALL */
2360 #endif /* SVR4 */
2361 #ifdef FREEBSD
2362         if (tcp->scno >= 0 && tcp->scno < nsyscalls &&
2363             sysent[tcp->scno].nargs > tcp->status.val)
2364                 tcp->u_nargs = sysent[tcp->scno].nargs;
2365         else
2366                 tcp->u_nargs = tcp->status.val;
2367         if (tcp->u_nargs < 0)
2368                 tcp->u_nargs = 0;
2369         if (tcp->u_nargs > MAX_ARGS)
2370                 tcp->u_nargs = MAX_ARGS;
2371         switch (regs.r_eax) {
2372         case SYS___syscall:
2373                 pread(tcp->pfd, &tcp->u_arg, tcp->u_nargs * sizeof(unsigned long),
2374                       regs.r_esp + sizeof(int) + sizeof(quad_t));
2375                 break;
2376         case SYS_syscall:
2377                 pread(tcp->pfd, &tcp->u_arg, tcp->u_nargs * sizeof(unsigned long),
2378                       regs.r_esp + 2 * sizeof(int));
2379                 break;
2380         default:
2381                 pread(tcp->pfd, &tcp->u_arg, tcp->u_nargs * sizeof(unsigned long),
2382                       regs.r_esp + sizeof(int));
2383                 break;
2384         }
2385 #endif /* FREEBSD */
2386         return 1;
2387 }
2388
2389 static int
2390 trace_syscall_exiting(struct tcb *tcp)
2391 {
2392         int sys_res;
2393         struct timeval tv;
2394         int res, scno_good;
2395         long u_error;
2396
2397         /* Measure the exit time as early as possible to avoid errors. */
2398         if (dtime || cflag)
2399                 gettimeofday(&tv, NULL);
2400
2401         /* BTW, why we don't just memorize syscall no. on entry
2402          * in tcp->something?
2403          */
2404         scno_good = res = get_scno(tcp);
2405         if (res == 0)
2406                 return res;
2407         if (res == 1)
2408                 res = syscall_fixup(tcp);
2409         if (res == 0)
2410                 return res;
2411         if (res == 1)
2412                 res = get_error(tcp);
2413         if (res == 0)
2414                 return res;
2415         if (res == 1)
2416                 internal_syscall(tcp);
2417
2418         if (res == 1 && filtered(tcp)) {
2419                 tcp->flags &= ~TCB_INSYSCALL;
2420                 return 0;
2421         }
2422
2423         if (tcp->flags & TCB_REPRINT) {
2424                 printleader(tcp);
2425                 tprintf("<... ");
2426                 if (scno_good != 1)
2427                         tprintf("????");
2428                 else if (tcp->scno >= nsyscalls || tcp->scno < 0)
2429                         tprintf("syscall_%lu", tcp->scno);
2430                 else
2431                         tprintf("%s", sysent[tcp->scno].sys_name);
2432                 tprintf(" resumed> ");
2433         }
2434
2435         if (cflag) {
2436                 struct timeval t = tv;
2437                 int rc = count_syscall(tcp, &t);
2438                 if (cflag == CFLAG_ONLY_STATS)
2439                 {
2440                         tcp->flags &= ~TCB_INSYSCALL;
2441                         return rc;
2442                 }
2443         }
2444
2445         if (res != 1) {
2446                 tprintf(") ");
2447                 tabto(acolumn);
2448                 tprintf("= ? <unavailable>");
2449                 printtrailer();
2450                 tcp->flags &= ~TCB_INSYSCALL;
2451                 return res;
2452         }
2453
2454         if (tcp->scno >= nsyscalls || tcp->scno < 0
2455             || (qual_flags[tcp->scno] & QUAL_RAW))
2456                 sys_res = printargs(tcp);
2457         else {
2458                 if (not_failing_only && tcp->u_error)
2459                         return 0;       /* ignore failed syscalls */
2460                 sys_res = (*sysent[tcp->scno].sys_func)(tcp);
2461         }
2462
2463         u_error = tcp->u_error;
2464         tprintf(") ");
2465         tabto(acolumn);
2466         if (tcp->scno >= nsyscalls || tcp->scno < 0 ||
2467             qual_flags[tcp->scno] & QUAL_RAW) {
2468                 if (u_error)
2469                         tprintf("= -1 (errno %ld)", u_error);
2470                 else
2471                         tprintf("= %#lx", tcp->u_rval);
2472         }
2473         else if (!(sys_res & RVAL_NONE) && u_error) {
2474                 switch (u_error) {
2475 #ifdef LINUX
2476                 case ERESTARTSYS:
2477                         tprintf("= ? ERESTARTSYS (To be restarted)");
2478                         break;
2479                 case ERESTARTNOINTR:
2480                         tprintf("= ? ERESTARTNOINTR (To be restarted)");
2481                         break;
2482                 case ERESTARTNOHAND:
2483                         tprintf("= ? ERESTARTNOHAND (To be restarted)");
2484                         break;
2485                 case ERESTART_RESTARTBLOCK:
2486                         tprintf("= ? ERESTART_RESTARTBLOCK (To be restarted)");
2487                         break;
2488 #endif /* LINUX */
2489                 default:
2490                         tprintf("= -1 ");
2491                         if (u_error < 0)
2492                                 tprintf("E??? (errno %ld)", u_error);
2493                         else if (u_error < nerrnos)
2494                                 tprintf("%s (%s)", errnoent[u_error],
2495                                         strerror(u_error));
2496                         else
2497                                 tprintf("ERRNO_%ld (%s)", u_error,
2498                                         strerror(u_error));
2499                         break;
2500                 }
2501                 if ((sys_res & RVAL_STR) && tcp->auxstr)
2502                         tprintf(" (%s)", tcp->auxstr);
2503         }
2504         else {
2505                 if (sys_res & RVAL_NONE)
2506                         tprintf("= ?");
2507                 else {
2508                         switch (sys_res & RVAL_MASK) {
2509                         case RVAL_HEX:
2510                                 tprintf("= %#lx", tcp->u_rval);
2511                                 break;
2512                         case RVAL_OCTAL:
2513                                 tprintf("= %#lo", tcp->u_rval);
2514                                 break;
2515                         case RVAL_UDECIMAL:
2516                                 tprintf("= %lu", tcp->u_rval);
2517                                 break;
2518                         case RVAL_DECIMAL:
2519                                 tprintf("= %ld", tcp->u_rval);
2520                                 break;
2521 #ifdef HAVE_LONG_LONG
2522                         case RVAL_LHEX:
2523                                 tprintf("= %#llx", tcp->u_lrval);
2524                                 break;
2525                         case RVAL_LOCTAL:
2526                                 tprintf("= %#llo", tcp->u_lrval);
2527                                 break;
2528                         case RVAL_LUDECIMAL:
2529                                 tprintf("= %llu", tcp->u_lrval);
2530                                 break;
2531                         case RVAL_LDECIMAL:
2532                                 tprintf("= %lld", tcp->u_lrval);
2533                                 break;
2534 #endif
2535                         default:
2536                                 fprintf(stderr,
2537                                         "invalid rval format\n");
2538                                 break;
2539                         }
2540                 }
2541                 if ((sys_res & RVAL_STR) && tcp->auxstr)
2542                         tprintf(" (%s)", tcp->auxstr);
2543         }
2544         if (dtime) {
2545                 tv_sub(&tv, &tv, &tcp->etime);
2546                 tprintf(" <%ld.%06ld>",
2547                         (long) tv.tv_sec, (long) tv.tv_usec);
2548         }
2549         printtrailer();
2550
2551         dumpio(tcp);
2552         if (fflush(tcp->outf) == EOF)
2553                 return -1;
2554         tcp->flags &= ~TCB_INSYSCALL;
2555         return 0;
2556 }
2557
2558 static int
2559 trace_syscall_entering(struct tcb *tcp)
2560 {
2561         int sys_res;
2562         int res, scno_good;
2563
2564         scno_good = res = get_scno(tcp);
2565         if (res == 0)
2566                 return res;
2567         if (res == 1)
2568                 res = syscall_fixup(tcp);
2569         if (res == 0)
2570                 return res;
2571         if (res == 1)
2572                 res = syscall_enter(tcp);
2573         if (res == 0)
2574                 return res;
2575
2576         if (res != 1) {
2577                 printleader(tcp);
2578                 tcp->flags &= ~TCB_REPRINT;
2579                 tcp_last = tcp;
2580                 if (scno_good != 1)
2581                         tprintf("????" /* anti-trigraph gap */ "(");
2582                 else if (tcp->scno >= nsyscalls || tcp->scno < 0)
2583                         tprintf("syscall_%lu(", tcp->scno);
2584                 else
2585                         tprintf("%s(", sysent[tcp->scno].sys_name);
2586                 /*
2587                  * " <unavailable>" will be added later by the code which
2588                  * detects ptrace errors.
2589                  */
2590                 tcp->flags |= TCB_INSYSCALL;
2591                 return res;
2592         }
2593
2594         switch (known_scno(tcp)) {
2595 #ifdef SYS_socket_subcall
2596         case SYS_socketcall:
2597                 decode_subcall(tcp, SYS_socket_subcall,
2598                         SYS_socket_nsubcalls, deref_style);
2599                 break;
2600 #endif
2601 #ifdef SYS_ipc_subcall
2602         case SYS_ipc:
2603                 decode_subcall(tcp, SYS_ipc_subcall,
2604                         SYS_ipc_nsubcalls, shift_style);
2605                 break;
2606 #endif
2607 #ifdef SVR4
2608 #ifdef SYS_pgrpsys_subcall
2609         case SYS_pgrpsys:
2610                 decode_subcall(tcp, SYS_pgrpsys_subcall,
2611                         SYS_pgrpsys_nsubcalls, shift_style);
2612                 break;
2613 #endif /* SYS_pgrpsys_subcall */
2614 #ifdef SYS_sigcall_subcall
2615         case SYS_sigcall:
2616                 decode_subcall(tcp, SYS_sigcall_subcall,
2617                         SYS_sigcall_nsubcalls, mask_style);
2618                 break;
2619 #endif /* SYS_sigcall_subcall */
2620         case SYS_msgsys:
2621                 decode_subcall(tcp, SYS_msgsys_subcall,
2622                         SYS_msgsys_nsubcalls, shift_style);
2623                 break;
2624         case SYS_shmsys:
2625                 decode_subcall(tcp, SYS_shmsys_subcall,
2626                         SYS_shmsys_nsubcalls, shift_style);
2627                 break;
2628         case SYS_semsys:
2629                 decode_subcall(tcp, SYS_semsys_subcall,
2630                         SYS_semsys_nsubcalls, shift_style);
2631                 break;
2632         case SYS_sysfs:
2633                 decode_subcall(tcp, SYS_sysfs_subcall,
2634                         SYS_sysfs_nsubcalls, shift_style);
2635                 break;
2636         case SYS_spcall:
2637                 decode_subcall(tcp, SYS_spcall_subcall,
2638                         SYS_spcall_nsubcalls, shift_style);
2639                 break;
2640 #ifdef SYS_context_subcall
2641         case SYS_context:
2642                 decode_subcall(tcp, SYS_context_subcall,
2643                         SYS_context_nsubcalls, shift_style);
2644                 break;
2645 #endif /* SYS_context_subcall */
2646 #ifdef SYS_door_subcall
2647         case SYS_door:
2648                 decode_subcall(tcp, SYS_door_subcall,
2649                         SYS_door_nsubcalls, door_style);
2650                 break;
2651 #endif /* SYS_door_subcall */
2652 #ifdef SYS_kaio_subcall
2653         case SYS_kaio:
2654                 decode_subcall(tcp, SYS_kaio_subcall,
2655                         SYS_kaio_nsubcalls, shift_style);
2656                 break;
2657 #endif
2658 #endif /* SVR4 */
2659 #ifdef FREEBSD
2660         case SYS_msgsys:
2661         case SYS_shmsys:
2662         case SYS_semsys:
2663                 decode_subcall(tcp, 0, 0, table_style);
2664                 break;
2665 #endif
2666 #ifdef SUNOS4
2667         case SYS_semsys:
2668                 decode_subcall(tcp, SYS_semsys_subcall,
2669                         SYS_semsys_nsubcalls, shift_style);
2670                 break;
2671         case SYS_msgsys:
2672                 decode_subcall(tcp, SYS_msgsys_subcall,
2673                         SYS_msgsys_nsubcalls, shift_style);
2674                 break;
2675         case SYS_shmsys:
2676                 decode_subcall(tcp, SYS_shmsys_subcall,
2677                         SYS_shmsys_nsubcalls, shift_style);
2678                 break;
2679 #endif
2680         }
2681
2682         internal_syscall(tcp);
2683
2684         if ((tcp->scno >= 0 && tcp->scno < nsyscalls &&
2685              !(qual_flags[tcp->scno] & QUAL_TRACE)) ||
2686             (tracing_paths && !pathtrace_match(tcp))) {
2687                 tcp->flags |= TCB_INSYSCALL | TCB_FILTERED;
2688                 return 0;
2689         }
2690
2691         tcp->flags &= ~TCB_FILTERED;
2692
2693         if (cflag == CFLAG_ONLY_STATS) {
2694                 tcp->flags |= TCB_INSYSCALL;
2695                 gettimeofday(&tcp->etime, NULL);
2696                 return 0;
2697         }
2698
2699         printleader(tcp);
2700         tcp->flags &= ~TCB_REPRINT;
2701         tcp_last = tcp;
2702         if (tcp->scno >= nsyscalls || tcp->scno < 0)
2703                 tprintf("syscall_%lu(", tcp->scno);
2704         else
2705                 tprintf("%s(", sysent[tcp->scno].sys_name);
2706         if (tcp->scno >= nsyscalls || tcp->scno < 0 ||
2707             ((qual_flags[tcp->scno] & QUAL_RAW) &&
2708              sysent[tcp->scno].sys_func != sys_exit))
2709                 sys_res = printargs(tcp);
2710         else
2711                 sys_res = (*sysent[tcp->scno].sys_func)(tcp);
2712         if (fflush(tcp->outf) == EOF)
2713                 return -1;
2714         tcp->flags |= TCB_INSYSCALL;
2715         /* Measure the entrance time as late as possible to avoid errors. */
2716         if (dtime || cflag)
2717                 gettimeofday(&tcp->etime, NULL);
2718         return sys_res;
2719 }
2720
2721 int
2722 trace_syscall(struct tcb *tcp)
2723 {
2724         return exiting(tcp) ?
2725                 trace_syscall_exiting(tcp) : trace_syscall_entering(tcp);
2726 }
2727
2728 int
2729 printargs(struct tcb *tcp)
2730 {
2731         if (entering(tcp)) {
2732                 int i;
2733
2734                 for (i = 0; i < tcp->u_nargs; i++)
2735                         tprintf("%s%#lx", i ? ", " : "", tcp->u_arg[i]);
2736         }
2737         return 0;
2738 }
2739
2740 long
2741 getrval2(struct tcb *tcp)
2742 {
2743         long val = -1;
2744
2745 #ifdef LINUX
2746 #if defined (SPARC) || defined (SPARC64)
2747         struct pt_regs regs;
2748         if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)&regs, 0) < 0)
2749                 return -1;
2750         val = regs.u_regs[U_REG_O1];
2751 #elif defined(SH)
2752         if (upeek(tcp, 4*(REG_REG0+1), &val) < 0)
2753                 return -1;
2754 #elif defined(IA64)
2755         if (upeek(tcp, PT_R9, &val) < 0)
2756                 return -1;
2757 #endif
2758 #endif /* LINUX */
2759
2760 #ifdef SUNOS4
2761         if (upeek(tcp, uoff(u_rval2), &val) < 0)
2762                 return -1;
2763 #endif /* SUNOS4 */
2764
2765 #ifdef SVR4
2766 #ifdef SPARC
2767         val = tcp->status.PR_REG[R_O1];
2768 #endif /* SPARC */
2769 #ifdef I386
2770         val = tcp->status.PR_REG[EDX];
2771 #endif /* I386 */
2772 #ifdef X86_64
2773         val = tcp->status.PR_REG[RDX];
2774 #endif /* X86_64 */
2775 #ifdef MIPS
2776         val = tcp->status.PR_REG[CTX_V1];
2777 #endif /* MIPS */
2778 #endif /* SVR4 */
2779
2780 #ifdef FREEBSD
2781         struct reg regs;
2782         pread(tcp->pfd_reg, &regs, sizeof(regs), 0);
2783         val = regs.r_edx;
2784 #endif
2785         return val;
2786 }
2787
2788 #ifdef SUNOS4
2789 /*
2790  * Apparently, indirect system calls have already be converted by ptrace(2),
2791  * so if you see "indir" this program has gone astray.
2792  */
2793 int
2794 sys_indir(struct tcb *tcp)
2795 {
2796         int i, scno, nargs;
2797
2798         if (entering(tcp)) {
2799                 if ((scno = tcp->u_arg[0]) > nsyscalls) {
2800                         fprintf(stderr, "Bogus syscall: %u\n", scno);
2801                         return 0;
2802                 }
2803                 nargs = sysent[scno].nargs;
2804                 tprintf("%s", sysent[scno].sys_name);
2805                 for (i = 0; i < nargs; i++)
2806                         tprintf(", %#lx", tcp->u_arg[i+1]);
2807         }
2808         return 0;
2809 }
2810 #endif /* SUNOS4 */
2811
2812 int
2813 is_restart_error(struct tcb *tcp)
2814 {
2815 #ifdef LINUX
2816         if (!syserror(tcp))
2817                 return 0;
2818         switch (tcp->u_error) {
2819                 case ERESTARTSYS:
2820                 case ERESTARTNOINTR:
2821                 case ERESTARTNOHAND:
2822                 case ERESTART_RESTARTBLOCK:
2823                         return 1;
2824                 default:
2825                         break;
2826         }
2827 #endif /* LINUX */
2828         return 0;
2829 }