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 #ifndef FREEBSD
 511 enum subcall_style { shift_style, deref_style, mask_style, door_style };
 512 #else /* FREEBSD */
 513 enum subcall_style { shift_style, deref_style, mask_style, door_style, table_style };
 514
 515 struct subcall {
 516   int call;
 517   int nsubcalls;
 518   int subcalls[5];
 519 };
 520
 521 static const struct subcall subcalls_table[] = {
 522   { SYS_shmsys, 5, { SYS_shmat, SYS_shmctl, SYS_shmdt, SYS_shmget, SYS_shmctl } },
 523 #ifdef SYS_semconfig
 524   { SYS_semsys, 4, { SYS___semctl, SYS_semget, SYS_semop, SYS_semconfig } },
 525 #else
 526   { SYS_semsys, 3, { SYS___semctl, SYS_semget, SYS_semop } },
 527 #endif
 528   { SYS_msgsys, 4, { SYS_msgctl, SYS_msgget, SYS_msgsnd, SYS_msgrcv } },
 529 };
 530 #endif /* FREEBSD */
 531
 532 #if !(defined(LINUX) && ( defined(ALPHA) || defined(MIPS) || defined(__ARM_EABI__) ))
 533
 534 static void
 535 decode_subcall(struct tcb *tcp, int subcall, int nsubcalls, enum subcall_style style)
 536 {
 537         unsigned long addr, mask;
 538         int i, n;
 539         int size = personality_wordsize[current_personality];
 540
 541         switch (style) {
 542         case shift_style:
 543                 if (tcp->u_arg[0] < 0 || tcp->u_arg[0] >= nsubcalls)
 544                         return;
 545                 tcp->scno = subcall + tcp->u_arg[0];
 546                 tcp->u_nargs = n = sysent[tcp->scno].nargs;
 547                 for (i = 0; i < n; i++)
 548                         tcp->u_arg[i] = tcp->u_arg[i + 1];
 549                 break;
 550         case deref_style:
 551                 if (tcp->u_arg[0] < 0 || tcp->u_arg[0] >= nsubcalls)
 552                         return;
 553                 tcp->scno = subcall + tcp->u_arg[0];
 554                 addr = tcp->u_arg[1];
 555                 tcp->u_nargs = n = sysent[tcp->scno].nargs;
 556                 for (i = 0; i < n; i++) {
 557                         if (size == sizeof(int)) {
 558                                 unsigned int arg;
 559                                 if (umove(tcp, addr, &arg) < 0)
 560                                         arg = 0;
 561                                 tcp->u_arg[i] = arg;
 562                         }
 563                         else if (size == sizeof(long)) {
 564                                 unsigned long arg;
 565                                 if (umove(tcp, addr, &arg) < 0)
 566                                         arg = 0;
 567                                 tcp->u_arg[i] = arg;
 568                         }
 569                         else
 570                                 abort();
 571                         addr += size;
 572                 }
 573                 break;
 574         case mask_style:
 575                 mask = (tcp->u_arg[0] >> 8) & 0xff;
 576                 for (i = 0; mask; i++)
 577                         mask >>= 1;
 578                 if (i >= nsubcalls)
 579                         return;
 580                 tcp->u_arg[0] &= 0xff;
 581                 tcp->scno = subcall + i;
 582                 tcp->u_nargs = sysent[tcp->scno].nargs;
 583                 break;
 584         case door_style:
 585                 /*
 586                  * Oh, yuck.  The call code is the *sixth* argument.
 587                  * (don't you mean the *last* argument? - JH)
 588                  */
 589                 if (tcp->u_arg[5] < 0 || tcp->u_arg[5] >= nsubcalls)
 590                         return;
 591                 tcp->scno = subcall + tcp->u_arg[5];
 592                 tcp->u_nargs = sysent[tcp->scno].nargs;
 593                 break;
 594 #ifdef FREEBSD
 595         case table_style:
 596                 for (i = 0; i < ARRAY_SIZE(subcalls_table); i++)
 597                         if (subcalls_table[i].call == tcp->scno) break;
 598                 if (i < ARRAY_SIZE(subcalls_table) &&
 599                     tcp->u_arg[0] >= 0 && tcp->u_arg[0] < subcalls_table[i].nsubcalls) {
 600                         tcp->scno = subcalls_table[i].subcalls[tcp->u_arg[0]];
 601                         for (i = 0; i < tcp->u_nargs; i++)
 602                                 tcp->u_arg[i] = tcp->u_arg[i + 1];
 603                 }
 604                 break;
 605 #endif /* FREEBSD */
 606         }
 607 }
 608 #endif
 609
 610 int
 611 printargs(struct tcb *tcp)
 612 {
 613         if (entering(tcp)) {
 614                 int i;
 615
 616                 for (i = 0; i < tcp->u_nargs; i++)
 617                         tprintf("%s%#lx", i ? ", " : "", tcp->u_arg[i]);
 618         }
 619         return 0;
 620 }
 621
 622 long
 623 getrval2(struct tcb *tcp)
 624 {
 625         long val = -1;
 626
 627 #ifdef LINUX
 628 #if defined (SPARC) || defined (SPARC64)
 629         struct pt_regs regs;
 630         if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)&regs, 0) < 0)
 631                 return -1;
 632         val = regs.u_regs[U_REG_O1];
 633 #elif defined(SH)
 634         if (upeek(tcp, 4*(REG_REG0+1), &val) < 0)
 635                 return -1;
 636 #elif defined(IA64)
 637         if (upeek(tcp, PT_R9, &val) < 0)
 638                 return -1;
 639 #endif
 640 #endif /* LINUX */
 641
 642 #ifdef SUNOS4
 643         if (upeek(tcp, uoff(u_rval2), &val) < 0)
 644                 return -1;
 645 #endif /* SUNOS4 */
 646
 647 #ifdef SVR4
 648 #ifdef SPARC
 649         val = tcp->status.PR_REG[R_O1];
 650 #endif /* SPARC */
 651 #ifdef I386
 652         val = tcp->status.PR_REG[EDX];
 653 #endif /* I386 */
 654 #ifdef X86_64
 655         val = tcp->status.PR_REG[RDX];
 656 #endif /* X86_64 */
 657 #ifdef MIPS
 658         val = tcp->status.PR_REG[CTX_V1];
 659 #endif /* MIPS */
 660 #endif /* SVR4 */
 661
 662 #ifdef FREEBSD
 663         struct reg regs;
 664         pread(tcp->pfd_reg, &regs, sizeof(regs), 0);
 665         val = regs.r_edx;
 666 #endif
 667         return val;
 668 }
 669
 670 #ifdef SUNOS4
 671 /*
 672  * Apparently, indirect system calls have already be converted by ptrace(2),
 673  * so if you see "indir" this program has gone astray.
 674  */
 675 int
 676 sys_indir(struct tcb *tcp)
 677 {
 678         int i, scno, nargs;
 679
 680         if (entering(tcp)) {
 681                 scno = tcp->u_arg[0];
 682                 if (scno > nsyscalls) {
 683                         fprintf(stderr, "Bogus syscall: %u\n", scno);
 684                         return 0;
 685                 }
 686                 nargs = sysent[scno].nargs;
 687                 tprintf("%s", sysent[scno].sys_name);
 688                 for (i = 0; i < nargs; i++)
 689                         tprintf(", %#lx", tcp->u_arg[i+1]);
 690         }
 691         return 0;
 692 }
 693 #endif /* SUNOS4 */
 694
 695 int
 696 is_restart_error(struct tcb *tcp)
 697 {
 698 #ifdef LINUX
 699         if (!syserror(tcp))
 700                 return 0;
 701         switch (tcp->u_error) {
 702                 case ERESTARTSYS:
 703                 case ERESTARTNOINTR:
 704                 case ERESTARTNOHAND:
 705                 case ERESTART_RESTARTBLOCK:
 706                         return 1;
 707                 default:
 708                         break;
 709         }
 710 #endif /* LINUX */
 711         return 0;
 712 }
 713
 714 struct tcb *tcp_last = NULL;
 715
 716 #ifdef LINUX
 717 # if defined (I386)
 718 static long eax;
 719 # elif defined (IA64)
 720 long r8, r10, psr; /* TODO: make static? */
 721 long ia32 = 0; /* not static */
 722 # elif defined (POWERPC)
 723 static long result, flags;
 724 # elif defined (M68K)
 725 static long d0;
 726 # elif defined(BFIN)
 727 static long r0;
 728 # elif defined (ARM)
 729 static struct pt_regs regs;
 730 # elif defined (ALPHA)
 731 static long r0;
 732 static long a3;
 733 # elif defined(AVR32)
 734 static struct pt_regs regs;
 735 # elif defined (SPARC) || defined (SPARC64)
 736 static struct pt_regs regs;
 737 static unsigned long trap;
 738 # elif defined(LINUX_MIPSN32)
 739 static long long a3;
 740 static long long r2;
 741 # elif defined(MIPS)
 742 static long a3;
 743 static long r2;
 744 # elif defined(S390) || defined(S390X)
 745 static long gpr2;
 746 static long pc;
 747 static long syscall_mode;
 748 # elif defined(HPPA)
 749 static long r28;
 750 # elif defined(SH)
 751 static long r0;
 752 # elif defined(SH64)
 753 static long r9;
 754 # elif defined(X86_64)
 755 static long rax;
 756 # elif defined(CRISV10) || defined(CRISV32)
 757 static long r10;
 758 # elif defined(MICROBLAZE)
 759 static long r3;
 760 # endif
 761 #endif /* LINUX */
 762 #ifdef FREEBSD
 763 struct reg regs; /* TODO: make static? */
 764 #endif /* FREEBSD */
 765
 766 /* Returns:
 767  * 0: "ignore this ptrace stop", bail out of trace_syscall() silently.
 768  * 1: ok, continue in trace_syscall().
 769  * other: error, trace_syscall() should print error indicator
 770  *    ("????" etc) and bail out.
 771  */
 772 #ifndef USE_PROCFS
 773 static
 774 #endif
 775 int
 776 get_scno(struct tcb *tcp)
 777 {
 778         long scno = 0;
 779
 780 #ifdef LINUX
 781 # if defined(S390) || defined(S390X)
 782         if (upeek(tcp, PT_GPR2, &syscall_mode) < 0)
 783                 return -1;
 784
 785         if (syscall_mode != -ENOSYS) {
 786                 /*
 787                  * Since kernel version 2.5.44 the scno gets passed in gpr2.
 788                  */
 789                 scno = syscall_mode;
 790         } else {
 791                 /*
 792                  * Old style of "passing" the scno via the SVC instruction.
 793                  */
 794                 long opcode, offset_reg, tmp;
 795                 void *svc_addr;
 796                 static const int gpr_offset[16] = {
 797                                 PT_GPR0,  PT_GPR1,  PT_ORIGGPR2, PT_GPR3,
 798                                 PT_GPR4,  PT_GPR5,  PT_GPR6,     PT_GPR7,
 799                                 PT_GPR8,  PT_GPR9,  PT_GPR10,    PT_GPR11,
 800                                 PT_GPR12, PT_GPR13, PT_GPR14,    PT_GPR15
 801                 };
 802
 803                 if (upeek(tcp, PT_PSWADDR, &pc) < 0)
 804                         return -1;
 805                 errno = 0;
 806                 opcode = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)(pc-sizeof(long)), 0);
 807                 if (errno) {
 808                         perror("peektext(pc-oneword)");
 809                         return -1;
 810                 }
 811
 812                 /*
 813                  *  We have to check if the SVC got executed directly or via an
 814                  *  EXECUTE instruction. In case of EXECUTE it is necessary to do
 815                  *  instruction decoding to derive the system call number.
 816                  *  Unfortunately the opcode sizes of EXECUTE and SVC are differently,
 817                  *  so that this doesn't work if a SVC opcode is part of an EXECUTE
 818                  *  opcode. Since there is no way to find out the opcode size this
 819                  *  is the best we can do...
 820                  */
 821                 if ((opcode & 0xff00) == 0x0a00) {
 822                         /* SVC opcode */
 823                         scno = opcode & 0xff;
 824                 }
 825                 else {
 826                         /* SVC got executed by EXECUTE instruction */
 827
 828                         /*
 829                          *  Do instruction decoding of EXECUTE. If you really want to
 830                          *  understand this, read the Principles of Operations.
 831                          */
 832                         svc_addr = (void *) (opcode & 0xfff);
 833
 834                         tmp = 0;
 835                         offset_reg = (opcode & 0x000f0000) >> 16;
 836                         if (offset_reg && (upeek(tcp, gpr_offset[offset_reg], &tmp) < 0))
 837                                 return -1;
 838                         svc_addr += tmp;
 839
 840                         tmp = 0;
 841                         offset_reg = (opcode & 0x0000f000) >> 12;
 842                         if (offset_reg && (upeek(tcp, gpr_offset[offset_reg], &tmp) < 0))
 843                                 return -1;
 844                         svc_addr += tmp;
 845
 846                         scno = ptrace(PTRACE_PEEKTEXT, tcp->pid, svc_addr, 0);
 847                         if (errno)
 848                                 return -1;
 849 #  if defined(S390X)
 850                         scno >>= 48;
 851 #  else
 852                         scno >>= 16;
 853 #  endif
 854                         tmp = 0;
 855                         offset_reg = (opcode & 0x00f00000) >> 20;
 856                         if (offset_reg && (upeek(tcp, gpr_offset[offset_reg], &tmp) < 0))
 857                                 return -1;
 858
 859                         scno = (scno | tmp) & 0xff;
 860                 }
 861         }
 862 # elif defined (POWERPC)
 863         if (upeek(tcp, sizeof(unsigned long)*PT_R0, &scno) < 0)
 864                 return -1;
 865 #  ifdef POWERPC64
 866         /* TODO: speed up strace by not doing this at every syscall.
 867          * We only need to do it after execve.
 868          */
 869         int currpers;
 870         long val;
 871         int pid = tcp->pid;
 872
 873         /* Check for 64/32 bit mode. */
 874         if (upeek(tcp, sizeof(unsigned long)*PT_MSR, &val) < 0)
 875                 return -1;
 876         /* SF is bit 0 of MSR */
 877         if (val < 0)
 878                 currpers = 0;
 879         else
 880                 currpers = 1;
 881         if (currpers != current_personality) {
 882                 static const char *const names[] = {"64 bit", "32 bit"};
 883                 set_personality(currpers);
 884                 fprintf(stderr, "[ Process PID=%d runs in %s mode. ]\n",
 885                                 pid, names[current_personality]);
 886         }
 887 #  endif
 888 # elif defined(AVR32)
 889         /* Read complete register set in one go. */
 890         if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, &regs) < 0)
 891                 return -1;
 892         scno = regs.r8;
 893 # elif defined(BFIN)
 894         if (upeek(tcp, PT_ORIG_P0, &scno))
 895                 return -1;
 896 # elif defined (I386)
 897         if (upeek(tcp, 4*ORIG_EAX, &scno) < 0)
 898                 return -1;
 899 # elif defined (X86_64)
 900         if (upeek(tcp, 8*ORIG_RAX, &scno) < 0)
 901                 return -1;
 902
 903         /* TODO: speed up strace by not doing this at every syscall.
 904          * We only need to do it after execve.
 905          */
 906         int currpers;
 907         long val;
 908         int pid = tcp->pid;
 909
 910         /* Check CS register value. On x86-64 linux it is:
 911          *      0x33    for long mode (64 bit)
 912          *      0x23    for compatibility mode (32 bit)
 913          * It takes only one ptrace and thus doesn't need
 914          * to be cached.
 915          */
 916         if (upeek(tcp, 8*CS, &val) < 0)
 917                 return -1;
 918         switch (val) {
 919                 case 0x23: currpers = 1; break;
 920                 case 0x33: currpers = 0; break;
 921                 default:
 922                         fprintf(stderr, "Unknown value CS=0x%02X while "
 923                                  "detecting personality of process "
 924                                  "PID=%d\n", (int)val, pid);
 925                         currpers = current_personality;
 926                         break;
 927         }
 928 #  if 0
 929         /* This version analyzes the opcode of a syscall instruction.
 930          * (int 0x80 on i386 vs. syscall on x86-64)
 931          * It works, but is too complicated.
 932          */
 933         unsigned long val, rip, i;
 934
 935         if (upeek(tcp, 8*RIP, &rip) < 0)
 936                 perror("upeek(RIP)");
 937
 938         /* sizeof(syscall) == sizeof(int 0x80) == 2 */
 939         rip -= 2;
 940         errno = 0;
 941
 942         call = ptrace(PTRACE_PEEKTEXT, pid, (char *)rip, (char *)0);
 943         if (errno)
 944                 fprintf(stderr, "ptrace_peektext failed: %s\n",
 945                                 strerror(errno));
 946         switch (call & 0xffff) {
 947                 /* x86-64: syscall = 0x0f 0x05 */
 948                 case 0x050f: currpers = 0; break;
 949                 /* i386: int 0x80 = 0xcd 0x80 */
 950                 case 0x80cd: currpers = 1; break;
 951                 default:
 952                         currpers = current_personality;
 953                         fprintf(stderr,
 954                                 "Unknown syscall opcode (0x%04X) while "
 955                                 "detecting personality of process "
 956                                 "PID=%d\n", (int)call, pid);
 957                         break;
 958         }
 959 #  endif
 960         if (currpers != current_personality) {
 961                 static const char *const names[] = {"64 bit", "32 bit"};
 962                 set_personality(currpers);
 963                 fprintf(stderr, "[ Process PID=%d runs in %s mode. ]\n",
 964                                 pid, names[current_personality]);
 965         }
 966 # elif defined(IA64)
 967 #       define IA64_PSR_IS      ((long)1 << 34)
 968         if (upeek(tcp, PT_CR_IPSR, &psr) >= 0)
 969                 ia32 = (psr & IA64_PSR_IS) != 0;
 970         if (ia32) {
 971                 if (upeek(tcp, PT_R1, &scno) < 0)       /* orig eax */
 972                         return -1;
 973         } else {
 974                 if (upeek(tcp, PT_R15, &scno) < 0)
 975                         return -1;
 976         }
 977 # elif defined (ARM)
 978         /* Read complete register set in one go. */
 979         if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (void *)&regs) == -1)
 980                 return -1;
 981
 982         /*
 983          * We only need to grab the syscall number on syscall entry.
 984          */
 985         if (regs.ARM_ip == 0) {
 986                 /*
 987                  * Note: we only deal with only 32-bit CPUs here.
 988                  */
 989                 if (regs.ARM_cpsr & 0x20) {
 990                         /*
 991                          * Get the Thumb-mode system call number
 992                          */
 993                         scno = regs.ARM_r7;
 994                 } else {
 995                         /*
 996                          * Get the ARM-mode system call number
 997                          */
 998                         errno = 0;
 999                         scno = ptrace(PTRACE_PEEKTEXT, tcp->pid, (void *)(regs.ARM_pc - 4), NULL);
1000                         if (errno)
1001                                 return -1;
1002
1003                         /* Handle the EABI syscall convention.  We do not
1004                            bother converting structures between the two
1005                            ABIs, but basic functionality should work even
1006                            if strace and the traced program have different
1007                            ABIs.  */
1008                         if (scno == 0xef000000) {
1009                                 scno = regs.ARM_r7;
1010                         } else {
1011                                 if ((scno & 0x0ff00000) != 0x0f900000) {
1012                                         fprintf(stderr, "syscall: unknown syscall trap 0x%08lx\n",
1013                                                 scno);
1014                                         return -1;
1015                                 }
1016
1017                                 /*
1018                                  * Fixup the syscall number
1019                                  */
1020                                 scno &= 0x000fffff;
1021                         }
1022                 }
1023                 if (scno & 0x0f0000) {
1024                         /*
1025                          * Handle ARM specific syscall
1026                          */
1027                         set_personality(1);
1028                         scno &= 0x0000ffff;
1029                 } else
1030                         set_personality(0);
1031
1032         } else {
1033                 fprintf(stderr, "pid %d stray syscall entry\n", tcp->pid);
1034                 tcp->flags |= TCB_INSYSCALL;
1035         }
1036 # elif defined (M68K)
1037         if (upeek(tcp, 4*PT_ORIG_D0, &scno) < 0)
1038                 return -1;
1039 # elif defined (LINUX_MIPSN32)
1040         unsigned long long regs[38];
1041
1042         if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) &regs) < 0)
1043                 return -1;
1044         a3 = regs[REG_A3];
1045         r2 = regs[REG_V0];
1046
1047         scno = r2;
1048         if (scno < 0 || scno > nsyscalls) {
1049                 if (a3 == 0 || a3 == -1) {
1050                         if (debug)
1051                                 fprintf(stderr, "stray syscall exit: v0 = %ld\n", scno);
1052                         return 0;
1053                 }
1054         }
1055 # elif defined (MIPS)
1056         if (upeek(tcp, REG_A3, &a3) < 0)
1057                 return -1;
1058         if (upeek(tcp, REG_V0, &scno) < 0)
1059                 return -1;
1060
1061         if (scno < 0 || scno > nsyscalls) {
1062                 if (a3 == 0 || a3 == -1) {
1063                         if (debug)
1064                                 fprintf(stderr, "stray syscall exit: v0 = %ld\n", scno);
1065                         return 0;
1066                 }
1067         }
1068 # elif defined (ALPHA)
1069         if (upeek(tcp, REG_A3, &a3) < 0)
1070                 return -1;
1071         if (upeek(tcp, REG_R0, &scno) < 0)
1072                 return -1;
1073
1074         /*
1075          * Do some sanity checks to figure out if it's
1076          * really a syscall entry
1077          */
1078         if (scno < 0 || scno > nsyscalls) {
1079                 if (a3 == 0 || a3 == -1) {
1080                         if (debug)
1081                                 fprintf(stderr, "stray syscall exit: r0 = %ld\n", scno);
1082                         return 0;
1083                 }
1084         }
1085 # elif defined (SPARC) || defined (SPARC64)
1086         /* Everything we need is in the current register set. */
1087         if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)&regs, 0) < 0)
1088                 return -1;
1089
1090         /* Disassemble the syscall trap. */
1091         /* Retrieve the syscall trap instruction. */
1092         errno = 0;
1093 #  if defined(SPARC64)
1094         trap = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)regs.tpc, 0);
1095         trap >>= 32;
1096 #  else
1097         trap = ptrace(PTRACE_PEEKTEXT, tcp->pid, (char *)regs.pc, 0);
1098 #  endif
1099         if (errno)
1100                 return -1;
1101
1102         /* Disassemble the trap to see what personality to use. */
1103         switch (trap) {
1104         case 0x91d02010:
1105                 /* Linux/SPARC syscall trap. */
1106                 set_personality(0);
1107                 break;
1108         case 0x91d0206d:
1109                 /* Linux/SPARC64 syscall trap. */
1110                 set_personality(2);
1111                 break;
1112         case 0x91d02000:
1113                 /* SunOS syscall trap. (pers 1) */
1114                 fprintf(stderr, "syscall: SunOS no support\n");
1115                 return -1;
1116         case 0x91d02008:
1117                 /* Solaris 2.x syscall trap. (per 2) */
1118                 set_personality(1);
1119                 break;
1120         case 0x91d02009:
1121                 /* NetBSD/FreeBSD syscall trap. */
1122                 fprintf(stderr, "syscall: NetBSD/FreeBSD not supported\n");
1123                 return -1;
1124         case 0x91d02027:
1125                 /* Solaris 2.x gettimeofday */
1126                 set_personality(1);
1127                 break;
1128         default:
1129 #  if defined (SPARC64)
1130                 fprintf(stderr, "syscall: unknown syscall trap %08lx %016lx\n", trap, regs.tpc);
1131 #  else
1132                 fprintf(stderr, "syscall: unknown syscall trap %08lx %08lx\n", trap, regs.pc);
1133 #  endif
1134                 return -1;
1135         }
1136
1137         /* Extract the system call number from the registers. */
1138         if (trap == 0x91d02027)
1139                 scno = 156;
1140         else
1141                 scno = regs.u_regs[U_REG_G1];
1142         if (scno == 0) {
1143                 scno = regs.u_regs[U_REG_O0];
1144                 memmove(&regs.u_regs[U_REG_O0], &regs.u_regs[U_REG_O1], 7*sizeof(regs.u_regs[0]));
1145         }
1146 # elif defined(HPPA)
1147         if (upeek(tcp, PT_GR20, &scno) < 0)
1148                 return -1;
1149 # elif defined(SH)
1150         /*
1151          * In the new syscall ABI, the system call number is in R3.
1152          */
1153         if (upeek(tcp, 4*(REG_REG0+3), &scno) < 0)
1154                 return -1;
1155
1156         if (scno < 0) {
1157                 /* Odd as it may seem, a glibc bug has been known to cause
1158                    glibc to issue bogus negative syscall numbers.  So for
1159                    our purposes, make strace print what it *should* have been */
1160                 long correct_scno = (scno & 0xff);
1161                 if (debug)
1162                         fprintf(stderr,
1163                                 "Detected glibc bug: bogus system call"
1164                                 " number = %ld, correcting to %ld\n",
1165                                 scno,
1166                                 correct_scno);
1167                 scno = correct_scno;
1168         }
1169 # elif defined(SH64)
1170         if (upeek(tcp, REG_SYSCALL, &scno) < 0)
1171                 return -1;
1172         scno &= 0xFFFF;
1173 # elif defined(CRISV10) || defined(CRISV32)
1174         if (upeek(tcp, 4*PT_R9, &scno) < 0)
1175                 return -1;
1176 # elif defined(TILE)
1177         if (upeek(tcp, PTREGS_OFFSET_REG(10), &scno) < 0)
1178                 return -1;
1179 # elif defined(MICROBLAZE)
1180         if (upeek(tcp, 0, &scno) < 0)
1181                 return -1;
1182 # endif
1183 #endif /* LINUX */
1184
1185 #ifdef SUNOS4
1186         if (upeek(tcp, uoff(u_arg[7]), &scno) < 0)
1187                 return -1;
1188 #elif defined(SH)
1189         /* new syscall ABI returns result in R0 */
1190         if (upeek(tcp, 4*REG_REG0, (long *)&r0) < 0)
1191                 return -1;
1192 #elif defined(SH64)
1193         /* ABI defines result returned in r9 */
1194         if (upeek(tcp, REG_GENERAL(9), (long *)&r9) < 0)
1195                 return -1;
1196 #endif
1197
1198 #ifdef USE_PROCFS
1199 # ifdef HAVE_PR_SYSCALL
1200         scno = tcp->status.PR_SYSCALL;
1201 # else
1202 #  ifndef FREEBSD
1203         scno = tcp->status.PR_WHAT;
1204 #  else
1205         if (pread(tcp->pfd_reg, &regs, sizeof(regs), 0) < 0) {
1206                 perror("pread");
1207                 return -1;
1208         }
1209         switch (regs.r_eax) {
1210         case SYS_syscall:
1211         case SYS___syscall:
1212                 pread(tcp->pfd, &scno, sizeof(scno), regs.r_esp + sizeof(int));
1213                 break;
1214         default:
1215                 scno = regs.r_eax;
1216                 break;
1217         }
1218 #  endif /* FREEBSD */
1219 # endif /* !HAVE_PR_SYSCALL */
1220 #endif /* USE_PROCFS */
1221
1222         tcp->scno = scno;
1223         return 1;
1224 }
1225
1226 long
1227 known_scno(struct tcb *tcp)
1228 {
1229         long scno = tcp->scno;
1230 #if SUPPORTED_PERSONALITIES > 1
1231         if (scno >= 0 && scno < nsyscalls && sysent[scno].native_scno != 0)
1232                 scno = sysent[scno].native_scno;
1233         else
1234 #endif
1235                 scno += NR_SYSCALL_BASE;
1236         return scno;
1237 }
1238
1239 /* Called in trace_syscall() at each syscall entry and exit.
1240  * Returns:
1241  * 0: "ignore this ptrace stop", bail out of trace_syscall() silently.
1242  * 1: ok, continue in trace_syscall().
1243  * other: error, trace_syscall() should print error indicator
1244  *    ("????" etc) and bail out.
1245  */
1246 static int
1247 syscall_fixup(struct tcb *tcp)
1248 {
1249 #ifdef USE_PROCFS
1250         int scno = known_scno(tcp);
1251
1252         if (entering(tcp)) {
1253                 if (tcp->status.PR_WHY != PR_SYSENTRY) {
1254                         if (
1255                             scno == SYS_fork
1256 #ifdef SYS_vfork
1257                             || scno == SYS_vfork
1258 #endif /* SYS_vfork */
1259 #ifdef SYS_fork1
1260                             || scno == SYS_fork1
1261 #endif /* SYS_fork1 */
1262 #ifdef SYS_forkall
1263                             || scno == SYS_forkall
1264 #endif /* SYS_forkall */
1265 #ifdef SYS_rfork1
1266                             || scno == SYS_rfork1
1267 #endif /* SYS_fork1 */
1268 #ifdef SYS_rforkall
1269                             || scno == SYS_rforkall
1270 #endif /* SYS_rforkall */
1271                             ) {
1272                                 /* We are returning in the child, fake it. */
1273                                 tcp->status.PR_WHY = PR_SYSENTRY;
1274                                 trace_syscall(tcp);
1275                                 tcp->status.PR_WHY = PR_SYSEXIT;
1276                         }
1277                         else {
1278                                 fprintf(stderr, "syscall: missing entry\n");
1279                                 tcp->flags |= TCB_INSYSCALL;
1280                         }
1281                 }
1282         }
1283         else {
1284                 if (tcp->status.PR_WHY != PR_SYSEXIT) {
1285                         fprintf(stderr, "syscall: missing exit\n");
1286                         tcp->flags &= ~TCB_INSYSCALL;
1287                 }
1288         }
1289 #endif /* USE_PROCFS */
1290
1291 #ifdef SUNOS4
1292         if (entering(tcp)) {
1293                 if (scno == 0) {
1294                         fprintf(stderr, "syscall: missing entry\n");
1295                         tcp->flags |= TCB_INSYSCALL;
1296                 }
1297         }
1298         else {
1299                 if (scno != 0) {
1300                         if (debug) {
1301                                 /*
1302                                  * This happens when a signal handler
1303                                  * for a signal which interrupted a
1304                                  * a system call makes another system call.
1305                                  */
1306                                 fprintf(stderr, "syscall: missing exit\n");
1307                         }
1308                         tcp->flags &= ~TCB_INSYSCALL;
1309                 }
1310         }
1311 #endif /* SUNOS4 */
1312
1313 #ifdef LINUX
1314         /* A common case of "not a syscall entry" is post-execve SIGTRAP */
1315 #if defined (I386)
1316         /* With PTRACE_O_TRACEEXEC, post-execve SIGTRAP is disabled.
1317          * Every extra ptrace call is expensive, so check EAX
1318          * on syscall entry only if PTRACE_O_TRACEEXEC is not enabled:
1319          */
1320         if (entering(tcp) && !(ptrace_setoptions & PTRACE_O_TRACEEXEC)) {
1321                 if (upeek(tcp, 4*EAX, &eax) < 0)
1322                         return -1;
1323                 if (eax != -ENOSYS) {
1324                         if (debug)
1325                                 fprintf(stderr, "not a syscall entry (eax = %ld)\n", eax);
1326                         return 0;
1327                 }
1328         }
1329 #elif defined (X86_64)
1330         if (entering(tcp) && !(ptrace_setoptions & PTRACE_O_TRACEEXEC)) {
1331                 if (upeek(tcp, 8*RAX, &rax) < 0)
1332                         return -1;
1333                 if (current_personality == 1)
1334                         rax = (long int)(int)rax; /* sign extend from 32 bits */
1335                 if (rax != -ENOSYS && entering(tcp)) {
1336                         if (debug)
1337                                 fprintf(stderr, "not a syscall entry (rax = %ld)\n", rax);
1338                         return 0;
1339                 }
1340         }
1341 #elif defined (S390) || defined (S390X)
1342         if (upeek(tcp, PT_GPR2, &gpr2) < 0)
1343                 return -1;
1344         if (syscall_mode != -ENOSYS)
1345                 syscall_mode = tcp->scno;
1346         if (gpr2 != syscall_mode && entering(tcp)) {
1347                 if (debug)
1348                         fprintf(stderr, "not a syscall entry (gpr2 = %ld)\n", gpr2);
1349                 return 0;
1350         }
1351         else if (((tcp->flags & (TCB_INSYSCALL|TCB_WAITEXECVE))
1352                   == (TCB_INSYSCALL|TCB_WAITEXECVE))
1353                  && (gpr2 == -ENOSYS || gpr2 == tcp->scno)) {
1354                 /*
1355                  * Return from execve.
1356                  * Fake a return value of zero.  We leave the TCB_WAITEXECVE
1357                  * flag set for the post-execve SIGTRAP to see and reset.
1358                  */
1359                 gpr2 = 0;
1360         }
1361 #elif defined (POWERPC)
1362 # define SO_MASK 0x10000000
1363         if (upeek(tcp, sizeof(unsigned long)*PT_CCR, &flags) < 0)
1364                 return -1;
1365         if (upeek(tcp, sizeof(unsigned long)*PT_R3, &result) < 0)
1366                 return -1;
1367         if (flags & SO_MASK)
1368                 result = -result;
1369 #elif defined (M68K)
1370         if (upeek(tcp, 4*PT_D0, &d0) < 0)
1371                 return -1;
1372         if (d0 != -ENOSYS && entering(tcp)) {
1373                 if (debug)
1374                         fprintf(stderr, "not a syscall entry (d0 = %ld)\n", d0);
1375                 return 0;
1376         }
1377 #elif defined (ARM)
1378         /*
1379          * Nothing required
1380          */
1381 #elif defined(BFIN)
1382         if (upeek(tcp, PT_R0, &r0) < 0)
1383                 return -1;
1384 #elif defined (HPPA)
1385         if (upeek(tcp, PT_GR28, &r28) < 0)
1386                 return -1;
1387 #elif defined(IA64)
1388         if (upeek(tcp, PT_R10, &r10) < 0)
1389                 return -1;
1390         if (upeek(tcp, PT_R8, &r8) < 0)
1391                 return -1;
1392         if (ia32 && r8 != -ENOSYS && entering(tcp)) {
1393                 if (debug)
1394                         fprintf(stderr, "not a syscall entry (r8 = %ld)\n", r8);
1395                 return 0;
1396         }
1397 #elif defined(CRISV10) || defined(CRISV32)
1398         if (upeek(tcp, 4*PT_R10, &r10) < 0)
1399                 return -1;
1400         if (r10 != -ENOSYS && entering(tcp)) {
1401                 if (debug)
1402                         fprintf(stderr, "not a syscall entry (r10 = %ld)\n", r10);
1403                 return 0;
1404         }
1405 #elif defined(MICROBLAZE)
1406         if (upeek(tcp, 3 * 4, &r3) < 0)
1407                 return -1;
1408         if (r3 != -ENOSYS && entering(tcp)) {
1409                 if (debug)
1410                         fprintf(stderr, "not a syscall entry (r3 = %ld)\n", r3);
1411                 return 0;
1412         }
1413 #endif
1414 #endif /* LINUX */
1415         return 1;
1416 }
1417
1418 static int
1419 internal_syscall(struct tcb *tcp)
1420 {
1421         /*
1422          * We must always trace a few critical system calls in order to
1423          * correctly support following forks in the presence of tracing
1424          * qualifiers.
1425          */
1426         int (*func)();
1427
1428         if (tcp->scno < 0 || tcp->scno >= nsyscalls)
1429                 return 0;
1430
1431         func = sysent[tcp->scno].sys_func;
1432
1433         if (   sys_fork == func
1434 #if defined(FREEBSD) || defined(LINUX) || defined(SUNOS4)
1435             || sys_vfork == func
1436 #endif
1437 #ifdef LINUX
1438             || sys_clone == func
1439 #endif
1440 #if UNIXWARE > 2
1441             || sys_rfork == func
1442 #endif
1443            )
1444                 return internal_fork(tcp);
1445
1446 #if defined SUNOS4 || (defined LINUX && defined TCB_WAITEXECVE)
1447         if (   sys_execve == func
1448 # if defined(SPARC) || defined(SPARC64) || defined(SUNOS4)
1449             || sys_execv == func
1450 # endif
1451 # if UNIXWARE > 2
1452             || sys_rexecve == func
1453 # endif
1454            )
1455                 return internal_exec(tcp);
1456 #endif
1457
1458         return 0;
1459 }
1460
1461 static int
1462 syscall_enter(struct tcb *tcp)
1463 {
1464 #ifdef LINUX
1465         int i, nargs;
1466
1467         if (tcp->scno >= 0 && tcp->scno < nsyscalls)
1468                 nargs = tcp->u_nargs = sysent[tcp->scno].nargs;
1469         else
1470                 nargs = tcp->u_nargs = MAX_ARGS;
1471
1472 # if defined(S390) || defined(S390X)
1473         for (i = 0; i < nargs; ++i)
1474                 if (upeek(tcp, i==0 ? PT_ORIGGPR2 : PT_GPR2 + i*sizeof(long), &tcp->u_arg[i]) < 0)
1475                         return -1;
1476 # elif defined(ALPHA)
1477         for (i = 0; i < nargs; ++i)
1478                 if (upeek(tcp, REG_A0+i, &tcp->u_arg[i]) < 0)
1479                         return -1;
1480 # elif defined(IA64)
1481         if (!ia32) {
1482                 unsigned long *out0, cfm, sof, sol;
1483                 long rbs_end;
1484                 /* be backwards compatible with kernel < 2.4.4... */
1485 #               ifndef PT_RBS_END
1486 #                 define PT_RBS_END     PT_AR_BSP
1487 #               endif
1488
1489                 if (upeek(tcp, PT_RBS_END, &rbs_end) < 0)
1490                         return -1;
1491                 if (upeek(tcp, PT_CFM, (long *) &cfm) < 0)
1492                         return -1;
1493
1494                 sof = (cfm >> 0) & 0x7f;
1495                 sol = (cfm >> 7) & 0x7f;
1496                 out0 = ia64_rse_skip_regs((unsigned long *) rbs_end, -sof + sol);
1497
1498                 for (i = 0; i < nargs; ++i) {
1499                         if (umoven(tcp, (unsigned long) ia64_rse_skip_regs(out0, i),
1500                                    sizeof(long), (char *) &tcp->u_arg[i]) < 0)
1501                                 return -1;
1502                 }
1503         } else {
1504                 static const int argreg[MAX_ARGS] = { PT_R11 /* EBX = out0 */,
1505                                                       PT_R9  /* ECX = out1 */,
1506                                                       PT_R10 /* EDX = out2 */,
1507                                                       PT_R14 /* ESI = out3 */,
1508                                                       PT_R15 /* EDI = out4 */,
1509                                                       PT_R13 /* EBP = out5 */};
1510
1511                 for (i = 0; i < nargs; ++i) {
1512                         if (upeek(tcp, argreg[i], &tcp->u_arg[i]) < 0)
1513                                 return -1;
1514                         /* truncate away IVE sign-extension */
1515                         tcp->u_arg[i] &= 0xffffffff;
1516                 }
1517         }
1518 # elif defined(LINUX_MIPSN32) || defined(LINUX_MIPSN64)
1519         /* N32 and N64 both use up to six registers.  */
1520         unsigned long long regs[38];
1521
1522         if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) &regs) < 0)
1523                 return -1;
1524
1525         for (i = 0; i < nargs; ++i) {
1526                 tcp->u_arg[i] = regs[REG_A0 + i];
1527 #  if defined(LINUX_MIPSN32)
1528                 tcp->ext_arg[i] = regs[REG_A0 + i];
1529 #  endif
1530         }
1531 # elif defined(MIPS)
1532         if (nargs > 4) {
1533                 long sp;
1534
1535                 if (upeek(tcp, REG_SP, &sp) < 0)
1536                         return -1;
1537                 for (i = 0; i < 4; ++i)
1538                         if (upeek(tcp, REG_A0 + i, &tcp->u_arg[i]) < 0)
1539                                 return -1;
1540                 umoven(tcp, sp + 16, (nargs - 4) * sizeof(tcp->u_arg[0]),
1541                        (char *)(tcp->u_arg + 4));
1542         } else {
1543                 for (i = 0; i < nargs; ++i)
1544                         if (upeek(tcp, REG_A0 + i, &tcp->u_arg[i]) < 0)
1545                                 return -1;
1546         }
1547 # elif defined(POWERPC)
1548 #  ifndef PT_ORIG_R3
1549 #   define PT_ORIG_R3 34
1550 #  endif
1551         for (i = 0; i < nargs; ++i) {
1552                 if (upeek(tcp, (i==0) ?
1553                         (sizeof(unsigned long) * PT_ORIG_R3) :
1554                         ((i+PT_R3) * sizeof(unsigned long)),
1555                                 &tcp->u_arg[i]) < 0)
1556                         return -1;
1557         }
1558 # elif defined(SPARC) || defined(SPARC64)
1559         for (i = 0; i < nargs; ++i)
1560                 tcp->u_arg[i] = regs.u_regs[U_REG_O0 + i];
1561 # elif defined(HPPA)
1562         for (i = 0; i < nargs; ++i)
1563                 if (upeek(tcp, PT_GR26-4*i, &tcp->u_arg[i]) < 0)
1564                         return -1;
1565 # elif defined(ARM)
1566         for (i = 0; i < nargs; ++i)
1567                 tcp->u_arg[i] = regs.uregs[i];
1568 # elif defined(AVR32)
1569         static const unsigned long *argregp[MAX_ARGS] = { &regs.r12,
1570                                                           &regs.r11,
1571                                                           &regs.r10,
1572                                                           &regs.r9,
1573                                                           &regs.r5,
1574                                                           &regs.r3 };
1575         for (i = 0; i < nargs; ++i)
1576                 tcp->u_arg[i] = *argregp[i];
1577 # elif defined(BFIN)
1578         static const int argreg[MAX_ARGS] = { PT_R0, PT_R1, PT_R2, PT_R3, PT_R4, PT_R5 };
1579
1580         for (i = 0; i < nargs; ++i)
1581                 if (upeek(tcp, argreg[i], &tcp->u_arg[i]) < 0)
1582                         return -1;
1583 # elif defined(SH)
1584         static const int syscall_regs[MAX_ARGS] = {
1585                 4 * (REG_REG0+4), 4 * (REG_REG0+5), 4 * (REG_REG0+6),
1586                 4 * (REG_REG0+7), 4 * (REG_REG0  ), 4 * (REG_REG0+1)
1587         };
1588
1589         for (i = 0; i < nargs; ++i)
1590                 if (upeek(tcp, syscall_regs[i], &tcp->u_arg[i]) < 0)
1591                         return -1;
1592 # elif defined(SH64)
1593         int i;
1594         /* Registers used by SH5 Linux system calls for parameters */
1595         static const int syscall_regs[MAX_ARGS] = { 2, 3, 4, 5, 6, 7 };
1596
1597         for (i = 0; i < nargs; ++i)
1598                 if (upeek(tcp, REG_GENERAL(syscall_regs[i]), &tcp->u_arg[i]) < 0)
1599                         return -1;
1600 # elif defined(X86_64)
1601         static const int argreg[SUPPORTED_PERSONALITIES][MAX_ARGS] = {
1602                 { 8 * RDI, 8 * RSI, 8 * RDX, 8 * R10, 8 * R8 , 8 * R9  }, /* x86-64 ABI */
1603                 { 8 * RBX, 8 * RCX, 8 * RDX, 8 * RSI, 8 * RDI, 8 * RBP }  /* i386 ABI */
1604         };
1605
1606         for (i = 0; i < nargs; ++i)
1607                 if (upeek(tcp, argreg[current_personality][i], &tcp->u_arg[i]) < 0)
1608                         return -1;
1609 # elif defined(MICROBLAZE)
1610         for (i = 0; i < nargs; ++i)
1611                 if (upeek(tcp, (5 + i) * 4, &tcp->u_arg[i]) < 0)
1612                         return -1;
1613 # elif defined(CRISV10) || defined(CRISV32)
1614         static const int crisregs[MAX_ARGS] = {
1615                 4*PT_ORIG_R10, 4*PT_R11, 4*PT_R12,
1616                 4*PT_R13     , 4*PT_MOF, 4*PT_SRP
1617         };
1618
1619         for (i = 0; i < nargs; ++i)
1620                 if (upeek(tcp, crisregs[i], &tcp->u_arg[i]) < 0)
1621                         return -1;
1622 # elif defined(TILE)
1623         for (i = 0; i < nargs; ++i)
1624                 if (upeek(tcp, PTREGS_OFFSET_REG(i), &tcp->u_arg[i]) < 0)
1625                         return -1;
1626 # elif defined(M68K)
1627         for (i = 0; i < nargs; ++i)
1628                 if (upeek(tcp, (i < 5 ? i : i + 2)*4, &tcp->u_arg[i]) < 0)
1629                         return -1;
1630 # else /* Other architecture (like i386) (32bits specific) */
1631         for (i = 0; i < nargs; ++i)
1632                 if (upeek(tcp, i*4, &tcp->u_arg[i]) < 0)
1633                         return -1;
1634 # endif
1635 #endif /* LINUX */
1636 #ifdef SUNOS4
1637         int i, nargs;
1638         if (tcp->scno >= 0 && tcp->scno < nsyscalls)
1639                 nargs = tcp->u_nargs = sysent[tcp->scno].nargs;
1640         else
1641                 nargs = tcp->u_nargs = MAX_ARGS;
1642         for (i = 0; i < nargs; i++) {
1643                 struct user *u;
1644
1645                 if (upeek(tcp, uoff(u_arg[0]) +
1646                     (i * sizeof(u->u_arg[0])), &tcp->u_arg[i]) < 0)
1647                         return -1;
1648         }
1649 #endif /* SUNOS4 */
1650 #ifdef SVR4
1651 # ifdef MIPS
1652         /*
1653          * SGI is broken: even though it has pr_sysarg, it doesn't
1654          * set them on system call entry.  Get a clue.
1655          */
1656         if (tcp->scno >= 0 && tcp->scno < nsyscalls)
1657                 tcp->u_nargs = sysent[tcp->scno].nargs;
1658         else
1659                 tcp->u_nargs = tcp->status.pr_nsysarg;
1660         if (tcp->u_nargs > 4) {
1661                 memcpy(tcp->u_arg, &tcp->status.pr_reg[CTX_A0],
1662                         4 * sizeof(tcp->u_arg[0]));
1663                 umoven(tcp, tcp->status.pr_reg[CTX_SP] + 16,
1664                         (tcp->u_nargs - 4) * sizeof(tcp->u_arg[0]), (char *) (tcp->u_arg + 4));
1665         }
1666         else {
1667                 memcpy(tcp->u_arg, &tcp->status.pr_reg[CTX_A0],
1668                         tcp->u_nargs * sizeof(tcp->u_arg[0]));
1669         }
1670 # elif UNIXWARE >= 2
1671         /*
1672          * Like SGI, UnixWare doesn't set pr_sysarg until system call exit
1673          */
1674         if (tcp->scno >= 0 && tcp->scno < nsyscalls)
1675                 tcp->u_nargs = sysent[tcp->scno].nargs;
1676         else
1677                 tcp->u_nargs = tcp->status.pr_lwp.pr_nsysarg;
1678         umoven(tcp, tcp->status.PR_REG[UESP] + 4,
1679                 tcp->u_nargs * sizeof(tcp->u_arg[0]), (char *) tcp->u_arg);
1680 # elif defined(HAVE_PR_SYSCALL)
1681         int i;
1682         if (tcp->scno >= 0 && tcp->scno < nsyscalls)
1683                 tcp->u_nargs = sysent[tcp->scno].nargs;
1684         else
1685                 tcp->u_nargs = tcp->status.pr_nsysarg;
1686         for (i = 0; i < tcp->u_nargs; i++)
1687                 tcp->u_arg[i] = tcp->status.pr_sysarg[i];
1688 # elif defined(I386)
1689         if (tcp->scno >= 0 && tcp->scno < nsyscalls)
1690                 tcp->u_nargs = sysent[tcp->scno].nargs;
1691         else
1692                 tcp->u_nargs = 5;
1693         if (tcp->u_nargs > 0)
1694                 umoven(tcp, tcp->status.PR_REG[UESP] + 4,
1695                         tcp->u_nargs * sizeof(tcp->u_arg[0]), (char *) tcp->u_arg);
1696 # else
1697         I DONT KNOW WHAT TO DO
1698 # endif
1699 #endif /* SVR4 */
1700 #ifdef FREEBSD
1701         if (tcp->scno >= 0 && tcp->scno < nsyscalls &&
1702             sysent[tcp->scno].nargs > tcp->status.val)
1703                 tcp->u_nargs = sysent[tcp->scno].nargs;
1704         else
1705                 tcp->u_nargs = tcp->status.val;
1706         if (tcp->u_nargs < 0)
1707                 tcp->u_nargs = 0;
1708         if (tcp->u_nargs > MAX_ARGS)
1709                 tcp->u_nargs = MAX_ARGS;
1710         switch (regs.r_eax) {
1711         case SYS___syscall:
1712                 pread(tcp->pfd, &tcp->u_arg, tcp->u_nargs * sizeof(unsigned long),
1713                       regs.r_esp + sizeof(int) + sizeof(quad_t));
1714                 break;
1715         case SYS_syscall:
1716                 pread(tcp->pfd, &tcp->u_arg, tcp->u_nargs * sizeof(unsigned long),
1717                       regs.r_esp + 2 * sizeof(int));
1718                 break;
1719         default:
1720                 pread(tcp->pfd, &tcp->u_arg, tcp->u_nargs * sizeof(unsigned long),
1721                       regs.r_esp + sizeof(int));
1722                 break;
1723         }
1724 #endif /* FREEBSD */
1725         return 1;
1726 }
1727
1728 static int
1729 trace_syscall_entering(struct tcb *tcp)
1730 {
1731         int res, scno_good;
1732
1733 #if defined TCB_WAITEXECVE
1734         if (tcp->flags & TCB_WAITEXECVE) {
1735                 /* This is the post-execve SIGTRAP. */
1736                 tcp->flags &= ~TCB_WAITEXECVE;
1737                 return 0;
1738         }
1739 #endif
1740
1741         scno_good = res = get_scno(tcp);
1742         if (res == 0)
1743                 return res;
1744         if (res == 1)
1745                 res = syscall_fixup(tcp);
1746         if (res == 0)
1747                 return res;
1748         if (res == 1)
1749                 res = syscall_enter(tcp);
1750         if (res == 0)
1751                 return res;
1752
1753         if (res != 1) {
1754                 printleader(tcp);
1755                 tcp->flags &= ~TCB_REPRINT;
1756                 tcp_last = tcp;
1757                 if (scno_good != 1)
1758                         tprintf("????" /* anti-trigraph gap */ "(");
1759                 else if (tcp->scno >= nsyscalls || tcp->scno < 0)
1760                         tprintf("syscall_%lu(", tcp->scno);
1761                 else
1762                         tprintf("%s(", sysent[tcp->scno].sys_name);
1763                 /*
1764                  * " <unavailable>" will be added later by the code which
1765                  * detects ptrace errors.
1766                  */
1767                 goto ret;
1768         }
1769
1770         switch (known_scno(tcp)) {
1771 #ifdef SYS_socket_subcall
1772         case SYS_socketcall:
1773                 decode_subcall(tcp, SYS_socket_subcall,
1774                         SYS_socket_nsubcalls, deref_style);
1775                 break;
1776 #endif
1777 #ifdef SYS_ipc_subcall
1778         case SYS_ipc:
1779                 decode_subcall(tcp, SYS_ipc_subcall,
1780                         SYS_ipc_nsubcalls, shift_style);
1781                 break;
1782 #endif
1783 #ifdef SVR4
1784 #ifdef SYS_pgrpsys_subcall
1785         case SYS_pgrpsys:
1786                 decode_subcall(tcp, SYS_pgrpsys_subcall,
1787                         SYS_pgrpsys_nsubcalls, shift_style);
1788                 break;
1789 #endif /* SYS_pgrpsys_subcall */
1790 #ifdef SYS_sigcall_subcall
1791         case SYS_sigcall:
1792                 decode_subcall(tcp, SYS_sigcall_subcall,
1793                         SYS_sigcall_nsubcalls, mask_style);
1794                 break;
1795 #endif /* SYS_sigcall_subcall */
1796         case SYS_msgsys:
1797                 decode_subcall(tcp, SYS_msgsys_subcall,
1798                         SYS_msgsys_nsubcalls, shift_style);
1799                 break;
1800         case SYS_shmsys:
1801                 decode_subcall(tcp, SYS_shmsys_subcall,
1802                         SYS_shmsys_nsubcalls, shift_style);
1803                 break;
1804         case SYS_semsys:
1805                 decode_subcall(tcp, SYS_semsys_subcall,
1806                         SYS_semsys_nsubcalls, shift_style);
1807                 break;
1808         case SYS_sysfs:
1809                 decode_subcall(tcp, SYS_sysfs_subcall,
1810                         SYS_sysfs_nsubcalls, shift_style);
1811                 break;
1812         case SYS_spcall:
1813                 decode_subcall(tcp, SYS_spcall_subcall,
1814                         SYS_spcall_nsubcalls, shift_style);
1815                 break;
1816 #ifdef SYS_context_subcall
1817         case SYS_context:
1818                 decode_subcall(tcp, SYS_context_subcall,
1819                         SYS_context_nsubcalls, shift_style);
1820                 break;
1821 #endif /* SYS_context_subcall */
1822 #ifdef SYS_door_subcall
1823         case SYS_door:
1824                 decode_subcall(tcp, SYS_door_subcall,
1825                         SYS_door_nsubcalls, door_style);
1826                 break;
1827 #endif /* SYS_door_subcall */
1828 #ifdef SYS_kaio_subcall
1829         case SYS_kaio:
1830                 decode_subcall(tcp, SYS_kaio_subcall,
1831                         SYS_kaio_nsubcalls, shift_style);
1832                 break;
1833 #endif
1834 #endif /* SVR4 */
1835 #ifdef FREEBSD
1836         case SYS_msgsys:
1837         case SYS_shmsys:
1838         case SYS_semsys:
1839                 decode_subcall(tcp, 0, 0, table_style);
1840                 break;
1841 #endif
1842 #ifdef SUNOS4
1843         case SYS_semsys:
1844                 decode_subcall(tcp, SYS_semsys_subcall,
1845                         SYS_semsys_nsubcalls, shift_style);
1846                 break;
1847         case SYS_msgsys:
1848                 decode_subcall(tcp, SYS_msgsys_subcall,
1849                         SYS_msgsys_nsubcalls, shift_style);
1850                 break;
1851         case SYS_shmsys:
1852                 decode_subcall(tcp, SYS_shmsys_subcall,
1853                         SYS_shmsys_nsubcalls, shift_style);
1854                 break;
1855 #endif
1856         }
1857
1858         internal_syscall(tcp);
1859
1860         if ((tcp->scno >= 0 && tcp->scno < nsyscalls &&
1861              !(qual_flags[tcp->scno] & QUAL_TRACE)) ||
1862             (tracing_paths && !pathtrace_match(tcp))) {
1863                 tcp->flags |= TCB_INSYSCALL | TCB_FILTERED;
1864                 return 0;
1865         }
1866
1867         tcp->flags &= ~TCB_FILTERED;
1868
1869         if (cflag == CFLAG_ONLY_STATS) {
1870                 res = 0;
1871                 goto ret;
1872         }
1873
1874         printleader(tcp);
1875         tcp->flags &= ~TCB_REPRINT;
1876         tcp_last = tcp;
1877         if (tcp->scno >= nsyscalls || tcp->scno < 0)
1878                 tprintf("syscall_%lu(", tcp->scno);
1879         else
1880                 tprintf("%s(", sysent[tcp->scno].sys_name);
1881         if (tcp->scno >= nsyscalls || tcp->scno < 0 ||
1882             ((qual_flags[tcp->scno] & QUAL_RAW) &&
1883              sysent[tcp->scno].sys_func != sys_exit))
1884                 res = printargs(tcp);
1885         else
1886                 res = (*sysent[tcp->scno].sys_func)(tcp);
1887
1888         if (fflush(tcp->outf) == EOF)
1889                 return -1;
1890  ret:
1891         tcp->flags |= TCB_INSYSCALL;
1892         /* Measure the entrance time as late as possible to avoid errors. */
1893         if (dtime || cflag)
1894                 gettimeofday(&tcp->etime, NULL);
1895         return res;
1896 }
1897
1898 /* Returns:
1899  * 0: "ignore this ptrace stop", bail out of trace_syscall() silently.
1900  * 1: ok, continue in trace_syscall().
1901  * other: error, trace_syscall() should print error indicator
1902  *    ("????" etc) and bail out.
1903  */
1904 static int
1905 get_syscall_result(struct tcb *tcp)
1906 {
1907 #ifdef LINUX
1908 # if defined(S390) || defined(S390X)
1909 # elif defined (POWERPC)
1910 # elif defined(AVR32)
1911         /* Read complete register set in one go. */
1912         if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, &regs) < 0)
1913                 return -1;
1914 # elif defined(BFIN)
1915 # elif defined (I386)
1916         if (upeek(tcp, 4*EAX, &eax) < 0)
1917                 return -1;
1918 # elif defined (X86_64)
1919         if (upeek(tcp, 8*RAX, &rax) < 0)
1920                 return -1;
1921 # elif defined(IA64)
1922 #       define IA64_PSR_IS      ((long)1 << 34)
1923         if (upeek(tcp, PT_CR_IPSR, &psr) >= 0)
1924                 ia32 = (psr & IA64_PSR_IS) != 0;
1925         if (upeek(tcp, PT_R8, &r8) < 0)
1926                 return -1;
1927         if (upeek(tcp, PT_R10, &r10) < 0)
1928                 return -1;
1929 # elif defined (ARM)
1930         /* Read complete register set in one go. */
1931         if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (void *)&regs) == -1)
1932                 return -1;
1933 # elif defined (M68K)
1934 # elif defined (LINUX_MIPSN32)
1935         unsigned long long regs[38];
1936
1937         if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long) &regs) < 0)
1938                 return -1;
1939         a3 = regs[REG_A3];
1940         r2 = regs[REG_V0];
1941 # elif defined (MIPS)
1942         if (upeek(tcp, REG_A3, &a3) < 0)
1943                 return -1;
1944         if (upeek(tcp, REG_V0, &r2) < 0)
1945                 return -1;
1946 # elif defined (ALPHA)
1947         if (upeek(tcp, REG_A3, &a3) < 0)
1948                 return -1;
1949         if (upeek(tcp, REG_R0, &r0) < 0)
1950                 return -1;
1951 # elif defined (SPARC) || defined (SPARC64)
1952         /* Everything we need is in the current register set. */
1953         if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)&regs, 0) < 0)
1954                 return -1;
1955 # elif defined(HPPA)
1956 # elif defined(SH)
1957 # elif defined(SH64)
1958 # elif defined(CRISV10) || defined(CRISV32)
1959 # elif defined(TILE)
1960 # elif defined(MICROBLAZE)
1961 # endif
1962 #endif /* LINUX */
1963
1964 #ifdef SUNOS4
1965 #elif defined(SH)
1966         /* new syscall ABI returns result in R0 */
1967         if (upeek(tcp, 4*REG_REG0, (long *)&r0) < 0)
1968                 return -1;
1969 #elif defined(SH64)
1970         /* ABI defines result returned in r9 */
1971         if (upeek(tcp, REG_GENERAL(9), (long *)&r9) < 0)
1972                 return -1;
1973 #endif
1974
1975 #ifdef USE_PROCFS
1976 # ifndef HAVE_PR_SYSCALL
1977 #  ifdef FREEBSD
1978         if (pread(tcp->pfd_reg, &regs, sizeof(regs), 0) < 0) {
1979                 perror("pread");
1980                 return -1;
1981         }
1982 #  endif /* FREEBSD */
1983 # endif /* !HAVE_PR_SYSCALL */
1984 #endif /* USE_PROCFS */
1985
1986         return 1;
1987 }
1988
1989 #ifdef LINUX
1990 /*
1991  * Check the syscall return value register value for whether it is
1992  * a negated errno code indicating an error, or a success return value.
1993  */
1994 static inline int
1995 is_negated_errno(unsigned long int val)
1996 {
1997         unsigned long int max = -(long int) nerrnos;
1998 # if SUPPORTED_PERSONALITIES > 1
1999         if (personality_wordsize[current_personality] < sizeof(val)) {
2000                 val = (unsigned int) val;
2001                 max = (unsigned int) max;
2002         }
2003 # endif
2004         return val > max;
2005 }
2006 #endif
2007
2008 static int
2009 get_error(struct tcb *tcp)
2010 {
2011         int u_error = 0;
2012 #ifdef LINUX
2013         int check_errno = 1;
2014         if (tcp->scno >= 0 && tcp->scno < nsyscalls &&
2015             sysent[tcp->scno].sys_flags & SYSCALL_NEVER_FAILS) {
2016                 check_errno = 0;
2017         }
2018 # if defined(S390) || defined(S390X)
2019         if (check_errno && is_negated_errno(gpr2)) {
2020                 tcp->u_rval = -1;
2021                 u_error = -gpr2;
2022         }
2023         else {
2024                 tcp->u_rval = gpr2;
2025         }
2026 # elif defined(I386)
2027         if (check_errno && is_negated_errno(eax)) {
2028                 tcp->u_rval = -1;
2029                 u_error = -eax;
2030         }
2031         else {
2032                 tcp->u_rval = eax;
2033         }
2034 # elif defined(X86_64)
2035         if (check_errno && is_negated_errno(rax)) {
2036                 tcp->u_rval = -1;
2037                 u_error = -rax;
2038         }
2039         else {
2040                 tcp->u_rval = rax;
2041         }
2042 # elif defined(IA64)
2043         if (ia32) {
2044                 int err;
2045
2046                 err = (int)r8;
2047                 if (check_errno && is_negated_errno(err)) {
2048                         tcp->u_rval = -1;
2049                         u_error = -err;
2050                 }
2051                 else {
2052                         tcp->u_rval = err;
2053                 }
2054         } else {
2055                 if (check_errno && r10) {
2056                         tcp->u_rval = -1;
2057                         u_error = r8;
2058                 } else {
2059                         tcp->u_rval = r8;
2060                 }
2061         }
2062 # elif defined(MIPS)
2063         if (check_errno && a3) {
2064                 tcp->u_rval = -1;
2065                 u_error = r2;
2066         } else {
2067                 tcp->u_rval = r2;
2068         }
2069 # elif defined(POWERPC)
2070         if (check_errno && is_negated_errno(result)) {
2071                 tcp->u_rval = -1;
2072                 u_error = -result;
2073         }
2074         else {
2075                 tcp->u_rval = result;
2076         }
2077 # elif defined(M68K)
2078         if (check_errno && is_negated_errno(d0)) {
2079                 tcp->u_rval = -1;
2080                 u_error = -d0;
2081         }
2082         else {
2083                 tcp->u_rval = d0;
2084         }
2085 # elif defined(ARM)
2086         if (check_errno && is_negated_errno(regs.ARM_r0)) {
2087                 tcp->u_rval = -1;
2088                 u_error = -regs.ARM_r0;
2089         }
2090         else {
2091                 tcp->u_rval = regs.ARM_r0;
2092         }
2093 # elif defined(AVR32)
2094         if (check_errno && regs.r12 && (unsigned) -regs.r12 < nerrnos) {
2095                 tcp->u_rval = -1;
2096                 u_error = -regs.r12;
2097         }
2098         else {
2099                 tcp->u_rval = regs.r12;
2100         }
2101 # elif defined(BFIN)
2102         if (check_errno && is_negated_errno(r0)) {
2103                 tcp->u_rval = -1;
2104                 u_error = -r0;
2105         } else {
2106                 tcp->u_rval = r0;
2107         }
2108 # elif defined(ALPHA)
2109         if (check_errno && a3) {
2110                 tcp->u_rval = -1;
2111                 u_error = r0;
2112         }
2113         else {
2114                 tcp->u_rval = r0;
2115         }
2116 # elif defined(SPARC)
2117         if (check_errno && regs.psr & PSR_C) {
2118                 tcp->u_rval = -1;
2119                 u_error = regs.u_regs[U_REG_O0];
2120         }
2121         else {
2122                 tcp->u_rval = regs.u_regs[U_REG_O0];
2123         }
2124 # elif defined(SPARC64)
2125         if (check_errno && regs.tstate & 0x1100000000UL) {
2126                 tcp->u_rval = -1;
2127                 u_error = regs.u_regs[U_REG_O0];
2128         }
2129         else {
2130                 tcp->u_rval = regs.u_regs[U_REG_O0];
2131         }
2132 # elif defined(HPPA)
2133         if (check_errno && is_negated_errno(r28)) {
2134                 tcp->u_rval = -1;
2135                 u_error = -r28;
2136         }
2137         else {
2138                 tcp->u_rval = r28;
2139         }
2140 # elif defined(SH)
2141         if (check_errno && is_negated_errno(r0)) {
2142                 tcp->u_rval = -1;
2143                 u_error = -r0;
2144         }
2145         else {
2146                 tcp->u_rval = r0;
2147         }
2148 # elif defined(SH64)
2149         if (check_errno && is_negated_errno(r9)) {
2150                 tcp->u_rval = -1;
2151                 u_error = -r9;
2152         }
2153         else {
2154                 tcp->u_rval = r9;
2155         }
2156 # elif defined(CRISV10) || defined(CRISV32)
2157         if (check_errno && r10 && (unsigned) -r10 < nerrnos) {
2158                 tcp->u_rval = -1;
2159                 u_error = -r10;
2160         }
2161         else {
2162                 tcp->u_rval = r10;
2163         }
2164 # elif defined(TILE)
2165         long rval;
2166         if (upeek(tcp, PTREGS_OFFSET_REG(0), &rval) < 0)
2167                 return -1;
2168         if (check_errno && rval < 0 && rval > -nerrnos) {
2169                 tcp->u_rval = -1;
2170                 u_error = -rval;
2171         }
2172         else {
2173                 tcp->u_rval = rval;
2174         }
2175 # elif defined(MICROBLAZE)
2176         if (check_errno && is_negated_errno(r3)) {
2177                 tcp->u_rval = -1;
2178                 u_error = -r3;
2179         }
2180         else {
2181                 tcp->u_rval = r3;
2182         }
2183 # endif
2184 #endif /* LINUX */
2185 #ifdef SUNOS4
2186         /* get error code from user struct */
2187         if (upeek(tcp, uoff(u_error), &u_error) < 0)
2188                 return -1;
2189         u_error >>= 24; /* u_error is a char */
2190
2191         /* get system call return value */
2192         if (upeek(tcp, uoff(u_rval1), &tcp->u_rval) < 0)
2193                 return -1;
2194 #endif /* SUNOS4 */
2195 #ifdef SVR4
2196 # ifdef SPARC
2197         /* Judicious guessing goes a long way. */
2198         if (tcp->status.pr_reg[R_PSR] & 0x100000) {
2199                 tcp->u_rval = -1;
2200                 u_error = tcp->status.pr_reg[R_O0];
2201         }
2202         else {
2203                 tcp->u_rval = tcp->status.pr_reg[R_O0];
2204         }
2205 # endif /* SPARC */
2206 # ifdef I386
2207         if (tcp->status.PR_REG[EFL] & 0x1) {
2208                 tcp->u_rval = -1;
2209                 u_error = tcp->status.PR_REG[EAX];
2210         }
2211         else {
2212                 tcp->u_rval = tcp->status.PR_REG[EAX];
2213 #  ifdef HAVE_LONG_LONG
2214                 tcp->u_lrval =
2215                         ((unsigned long long) tcp->status.PR_REG[EDX] << 32) +
2216                         tcp->status.PR_REG[EAX];
2217 #  endif
2218         }
2219 # endif /* I386 */
2220 # ifdef X86_64
2221         if (tcp->status.PR_REG[EFLAGS] & 0x1) {
2222                 tcp->u_rval = -1;
2223                 u_error = tcp->status.PR_REG[RAX];
2224         }
2225         else {
2226                 tcp->u_rval = tcp->status.PR_REG[RAX];
2227         }
2228 # endif /* X86_64 */
2229 # ifdef MIPS
2230         if (tcp->status.pr_reg[CTX_A3]) {
2231                 tcp->u_rval = -1;
2232                 u_error = tcp->status.pr_reg[CTX_V0];
2233         }
2234         else {
2235                 tcp->u_rval = tcp->status.pr_reg[CTX_V0];
2236         }
2237 # endif /* MIPS */
2238 #endif /* SVR4 */
2239 #ifdef FREEBSD
2240         if (regs.r_eflags & PSL_C) {
2241                 tcp->u_rval = -1;
2242                 u_error = regs.r_eax;
2243         } else {
2244                 tcp->u_rval = regs.r_eax;
2245                 tcp->u_lrval =
2246                   ((unsigned long long) regs.r_edx << 32) + regs.r_eax;
2247         }
2248 #endif /* FREEBSD */
2249         tcp->u_error = u_error;
2250         return 1;
2251 }
2252
2253 static void
2254 dumpio(struct tcb *tcp)
2255 {
2256         if (syserror(tcp))
2257                 return;
2258         if (tcp->u_arg[0] < 0 || tcp->u_arg[0] >= MAX_QUALS)
2259                 return;
2260         if (tcp->scno < 0 || tcp->scno >= nsyscalls)
2261                 return;
2262         if (sysent[tcp->scno].sys_func == printargs)
2263                 return;
2264         if (qual_flags[tcp->u_arg[0]] & QUAL_READ) {
2265                 if (sysent[tcp->scno].sys_func == sys_read ||
2266                     sysent[tcp->scno].sys_func == sys_pread ||
2267                     sysent[tcp->scno].sys_func == sys_pread64 ||
2268                     sysent[tcp->scno].sys_func == sys_recv ||
2269                     sysent[tcp->scno].sys_func == sys_recvfrom)
2270                         dumpstr(tcp, tcp->u_arg[1], tcp->u_rval);
2271                 else if (sysent[tcp->scno].sys_func == sys_readv)
2272                         dumpiov(tcp, tcp->u_arg[2], tcp->u_arg[1]);
2273                 return;
2274         }
2275         if (qual_flags[tcp->u_arg[0]] & QUAL_WRITE) {
2276                 if (sysent[tcp->scno].sys_func == sys_write ||
2277                     sysent[tcp->scno].sys_func == sys_pwrite ||
2278                     sysent[tcp->scno].sys_func == sys_pwrite64 ||
2279                     sysent[tcp->scno].sys_func == sys_send ||
2280                     sysent[tcp->scno].sys_func == sys_sendto)
2281                         dumpstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
2282                 else if (sysent[tcp->scno].sys_func == sys_writev)
2283                         dumpiov(tcp, tcp->u_arg[2], tcp->u_arg[1]);
2284                 return;
2285         }
2286 }
2287
2288 static int
2289 trace_syscall_exiting(struct tcb *tcp)
2290 {
2291         int sys_res;
2292         struct timeval tv;
2293         int res;
2294         long u_error;
2295
2296         /* Measure the exit time as early as possible to avoid errors. */
2297         if (dtime || cflag)
2298                 gettimeofday(&tv, NULL);
2299
2300         res = get_syscall_result(tcp);
2301         if (res == 0)
2302                 return res;
2303         if (res == 1)
2304                 res = syscall_fixup(tcp);
2305         if (res == 0)
2306                 return res;
2307         if (res == 1)
2308                 res = get_error(tcp);
2309         if (res == 0)
2310                 return res;
2311         if (res == 1)
2312                 internal_syscall(tcp);
2313
2314         if (res == 1 && filtered(tcp)) {
2315                 goto ret;
2316         }
2317
2318         if (tcp->flags & TCB_REPRINT) {
2319                 printleader(tcp);
2320                 if (tcp->scno >= nsyscalls || tcp->scno < 0)
2321                         tprintf("<... syscall_%lu resumed> ", tcp->scno);
2322                 else
2323                         tprintf("<... %s resumed> ", sysent[tcp->scno].sys_name);
2324         }
2325
2326         if (cflag) {
2327                 struct timeval t = tv;
2328                 count_syscall(tcp, &t);
2329                 if (cflag == CFLAG_ONLY_STATS) {
2330                         goto ret;
2331                 }
2332         }
2333
2334         if (res != 1) {
2335                 tprintf(") ");
2336                 tabto(acolumn);
2337                 tprintf("= ? <unavailable>");
2338                 printtrailer();
2339                 tcp->flags &= ~TCB_INSYSCALL;
2340                 return res;
2341         }
2342
2343         if (tcp->scno >= nsyscalls || tcp->scno < 0
2344             || (qual_flags[tcp->scno] & QUAL_RAW))
2345                 sys_res = printargs(tcp);
2346         else {
2347         /* FIXME: not_failing_only (IOW, option -z) is broken:
2348          * failure of syscall is known only after syscall return.
2349          * Thus we end up with something like this on, say, ENOENT:
2350          *     open("doesnt_exist", O_RDONLY <unfinished ...>
2351          *     {next syscall decode}
2352          * whereas the intended result is that open(...) line
2353          * is not shown at all.
2354          */
2355                 if (not_failing_only && tcp->u_error)
2356                         goto ret;       /* ignore failed syscalls */
2357                 sys_res = (*sysent[tcp->scno].sys_func)(tcp);
2358         }
2359
2360         tprintf(") ");
2361         tabto(acolumn);
2362         u_error = tcp->u_error;
2363         if (tcp->scno >= nsyscalls || tcp->scno < 0 ||
2364             qual_flags[tcp->scno] & QUAL_RAW) {
2365                 if (u_error)
2366                         tprintf("= -1 (errno %ld)", u_error);
2367                 else
2368                         tprintf("= %#lx", tcp->u_rval);
2369         }
2370         else if (!(sys_res & RVAL_NONE) && u_error) {
2371                 switch (u_error) {
2372 #ifdef LINUX
2373                 case ERESTARTSYS:
2374                         tprintf("= ? ERESTARTSYS (To be restarted)");
2375                         break;
2376                 case ERESTARTNOINTR:
2377                         tprintf("= ? ERESTARTNOINTR (To be restarted)");
2378                         break;
2379                 case ERESTARTNOHAND:
2380                         tprintf("= ? ERESTARTNOHAND (To be restarted)");
2381                         break;
2382                 case ERESTART_RESTARTBLOCK:
2383                         tprintf("= ? ERESTART_RESTARTBLOCK (To be restarted)");
2384                         break;
2385 #endif /* LINUX */
2386                 default:
2387                         if (u_error < 0)
2388                                 tprintf("= -1 E??? (errno %ld)", u_error);
2389                         else if (u_error < nerrnos)
2390                                 tprintf("= -1 %s (%s)", errnoent[u_error],
2391                                         strerror(u_error));
2392                         else
2393                                 tprintf("= -1 ERRNO_%ld (%s)", u_error,
2394                                         strerror(u_error));
2395                         break;
2396                 }
2397                 if ((sys_res & RVAL_STR) && tcp->auxstr)
2398                         tprintf(" (%s)", tcp->auxstr);
2399         }
2400         else {
2401                 if (sys_res & RVAL_NONE)
2402                         tprintf("= ?");
2403                 else {
2404                         switch (sys_res & RVAL_MASK) {
2405                         case RVAL_HEX:
2406                                 tprintf("= %#lx", tcp->u_rval);
2407                                 break;
2408                         case RVAL_OCTAL:
2409                                 tprintf("= %#lo", tcp->u_rval);
2410                                 break;
2411                         case RVAL_UDECIMAL:
2412                                 tprintf("= %lu", tcp->u_rval);
2413                                 break;
2414                         case RVAL_DECIMAL:
2415                                 tprintf("= %ld", tcp->u_rval);
2416                                 break;
2417 #ifdef HAVE_LONG_LONG
2418                         case RVAL_LHEX:
2419                                 tprintf("= %#llx", tcp->u_lrval);
2420                                 break;
2421                         case RVAL_LOCTAL:
2422                                 tprintf("= %#llo", tcp->u_lrval);
2423                                 break;
2424                         case RVAL_LUDECIMAL:
2425                                 tprintf("= %llu", tcp->u_lrval);
2426                                 break;
2427                         case RVAL_LDECIMAL:
2428                                 tprintf("= %lld", tcp->u_lrval);
2429                                 break;
2430 #endif
2431                         default:
2432                                 fprintf(stderr,
2433                                         "invalid rval format\n");
2434                                 break;
2435                         }
2436                 }
2437                 if ((sys_res & RVAL_STR) && tcp->auxstr)
2438                         tprintf(" (%s)", tcp->auxstr);
2439         }
2440         if (dtime) {
2441                 tv_sub(&tv, &tv, &tcp->etime);
2442                 tprintf(" <%ld.%06ld>",
2443                         (long) tv.tv_sec, (long) tv.tv_usec);
2444         }
2445         printtrailer();
2446
2447         dumpio(tcp);
2448         if (fflush(tcp->outf) == EOF)
2449                 return -1;
2450  ret:
2451         tcp->flags &= ~TCB_INSYSCALL;
2452         return 0;
2453 }
2454
2455 int
2456 trace_syscall(struct tcb *tcp)
2457 {
2458         return exiting(tcp) ?
2459                 trace_syscall_exiting(tcp) : trace_syscall_entering(tcp);
2460 }