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