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