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