granicus.if.org Git - strace/blob - syscall.c

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