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