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