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