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