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