signal.c revision 594527353359d9a6aad516992e09c393e11f3bd2
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 <fcntl.h> 37 38#ifdef HAVE_SYS_REG_H 39# include <sys/reg.h> 40#elif defined(HAVE_LINUX_PTRACE_H) 41# undef PTRACE_SYSCALL 42# ifdef HAVE_STRUCT_IA64_FPREG 43# define ia64_fpreg XXX_ia64_fpreg 44# endif 45# ifdef HAVE_STRUCT_PT_ALL_USER_REGS 46# define pt_all_user_regs XXX_pt_all_user_regs 47# endif 48# ifdef HAVE_STRUCT_PTRACE_PEEKSIGINFO_ARGS 49# define ptrace_peeksiginfo_args XXX_ptrace_peeksiginfo_args 50# endif 51# include <linux/ptrace.h> 52# undef ptrace_peeksiginfo_args 53# undef ia64_fpreg 54# undef pt_all_user_regs 55#endif 56 57#ifdef IA64 58# include <asm/ptrace_offsets.h> 59#endif 60 61#if defined(SPARC) || defined(SPARC64) || defined(MIPS) 62typedef struct { 63 struct pt_regs si_regs; 64 int si_mask; 65} m_siginfo_t; 66#elif defined HAVE_ASM_SIGCONTEXT_H 67# if !defined(IA64) && !defined(X86_64) && !defined(X32) 68# include <asm/sigcontext.h> 69# endif 70#else /* !HAVE_ASM_SIGCONTEXT_H */ 71# if defined M68K && !defined HAVE_STRUCT_SIGCONTEXT 72struct sigcontext { 73 unsigned long sc_mask; 74 unsigned long sc_usp; 75 unsigned long sc_d0; 76 unsigned long sc_d1; 77 unsigned long sc_a0; 78 unsigned long sc_a1; 79 unsigned short sc_sr; 80 unsigned long sc_pc; 81 unsigned short sc_formatvec; 82}; 83# endif /* M68K */ 84#endif /* !HAVE_ASM_SIGCONTEXT_H */ 85 86#ifndef NSIG 87# warning: NSIG is not defined, using 32 88# define NSIG 32 89#endif 90 91#ifdef HAVE_SIGACTION 92 93#if defined I386 || defined X86_64 || defined X32 94/* The libc headers do not define this constant since it should only be 95 used by the implementation. So we define it here. */ 96# ifndef SA_RESTORER 97# define SA_RESTORER 0x04000000 98# endif 99#endif 100 101static const struct xlat sigact_flags[] = { 102#ifdef SA_RESTORER 103 XLAT(SA_RESTORER), 104#endif 105#ifdef SA_STACK 106 XLAT(SA_STACK), 107#endif 108#ifdef SA_RESTART 109 XLAT(SA_RESTART), 110#endif 111#ifdef SA_INTERRUPT 112 XLAT(SA_INTERRUPT), 113#endif 114#ifdef SA_NODEFER 115 XLAT(SA_NODEFER), 116#endif 117#if defined SA_NOMASK && SA_NODEFER != SA_NOMASK 118 XLAT(SA_NOMASK), 119#endif 120#ifdef SA_RESETHAND 121 XLAT(SA_RESETHAND), 122#endif 123#if defined SA_ONESHOT && SA_ONESHOT != SA_RESETHAND 124 XLAT(SA_ONESHOT), 125#endif 126#ifdef SA_SIGINFO 127 XLAT(SA_SIGINFO), 128#endif 129#ifdef SA_RESETHAND 130 XLAT(SA_RESETHAND), 131#endif 132#ifdef SA_ONSTACK 133 XLAT(SA_ONSTACK), 134#endif 135#ifdef SA_NODEFER 136 XLAT(SA_NODEFER), 137#endif 138#ifdef SA_NOCLDSTOP 139 XLAT(SA_NOCLDSTOP), 140#endif 141#ifdef SA_NOCLDWAIT 142 XLAT(SA_NOCLDWAIT), 143#endif 144#ifdef _SA_BSDCALL 145 XLAT(_SA_BSDCALL), 146#endif 147#ifdef SA_NOPTRACE 148 XLAT(SA_NOPTRACE), 149#endif 150 XLAT_END 151}; 152 153static const struct xlat sigprocmaskcmds[] = { 154 XLAT(SIG_BLOCK), 155 XLAT(SIG_UNBLOCK), 156 XLAT(SIG_SETMASK), 157#ifdef SIG_SETMASK32 158 XLAT(SIG_SETMASK32), 159#endif 160 XLAT_END 161}; 162 163#endif /* HAVE_SIGACTION */ 164 165/* Anonymous realtime signals. */ 166/* Under glibc 2.1, SIGRTMIN et al are functions, but __SIGRTMIN is a 167 constant. This is what we want. Otherwise, just use SIGRTMIN. */ 168#ifdef SIGRTMIN 169#ifndef __SIGRTMIN 170#define __SIGRTMIN SIGRTMIN 171#define __SIGRTMAX SIGRTMAX /* likewise */ 172#endif 173#endif 174 175/* Note on the size of sigset_t: 176 * 177 * In glibc, sigset_t is an array with space for 1024 bits (!), 178 * even though all arches supported by Linux have only 64 signals 179 * except MIPS, which has 128. IOW, it is 128 bytes long. 180 * 181 * In-kernel sigset_t is sized correctly (it is either 64 or 128 bit long). 182 * However, some old syscall return only 32 lower bits (one word). 183 * Example: sys_sigpending vs sys_rt_sigpending. 184 * 185 * Be aware of this fact when you try to 186 * memcpy(&tcp->u_arg[1], &something, sizeof(sigset_t)) 187 * - sizeof(sigset_t) is much bigger than you think, 188 * it may overflow tcp->u_arg[] array, and it may try to copy more data 189 * than is really available in <something>. 190 * Similarly, 191 * umoven(tcp, addr, sizeof(sigset_t), &sigset) 192 * may be a bad idea: it'll try to read much more data than needed 193 * to fetch a sigset_t. 194 * Use (NSIG / 8) as a size instead. 195 */ 196 197const char * 198signame(int sig) 199{ 200 static char buf[sizeof("SIGRT_%d") + sizeof(int)*3]; 201 202 if (sig >= 0 && sig < nsignals) 203 return signalent[sig]; 204#ifdef SIGRTMIN 205 if (sig >= __SIGRTMIN && sig <= __SIGRTMAX) { 206 sprintf(buf, "SIGRT_%d", (int)(sig - __SIGRTMIN)); 207 return buf; 208 } 209#endif 210 sprintf(buf, "%d", sig); 211 return buf; 212} 213 214static const char * 215sprintsigmask(const char *str, sigset_t *mask) 216/* set might include realtime sigs */ 217{ 218 /* Was [8 * sizeof(sigset_t) * 8], but 219 * glibc sigset_t is huge (1024 bits = 128 *bytes*), 220 * and we were ending up with 8k (!) buffer here. 221 * 222 * No Unix system can have sig > 255 223 * (waitpid API won't be able to indicate death from one) 224 * and sig 0 doesn't exist either. 225 * Therefore max possible no of sigs is 255: 1..255 226 */ 227 static char outstr[8 * (255 * 2 / 3)]; 228 229 int i, nsigs; 230 int maxsigs; 231 int show_members; 232 char sep; 233 char *s; 234 235 /* Note: nsignals = ARRAY_SIZE(signalent[]), 236 * and that array may not have SIGRTnn. 237 */ 238#ifdef __SIGRTMAX 239 maxsigs = __SIGRTMAX + 1; /* instead */ 240#else 241 maxsigs = nsignals; 242#endif 243 s = stpcpy(outstr, str); 244 nsigs = 0; 245 for (i = 1; i < maxsigs; i++) { 246 if (sigismember(mask, i) == 1) 247 nsigs++; 248 } 249 250 /* 1: show mask members, 0: show those which are NOT in mask */ 251 show_members = (nsigs < nsignals * 2 / 3); 252 if (!show_members) 253 *s++ = '~'; 254 255 sep = '['; 256 for (i = 1; i < maxsigs; i++) { 257 if (sigismember(mask, i) == show_members) { 258 *s++ = sep; 259 if (i < nsignals) { 260 s = stpcpy(s, signalent[i] + 3); 261 } 262#ifdef SIGRTMIN 263 else if (i >= __SIGRTMIN && i <= __SIGRTMAX) { 264 s += sprintf(s, "RT_%u", i - __SIGRTMIN); 265 } 266#endif 267 else { 268 s += sprintf(s, "%u", i); 269 } 270 sep = ' '; 271 } 272 } 273 if (sep == '[') 274 *s++ = sep; 275 *s++ = ']'; 276 *s = '\0'; 277 return outstr; 278} 279 280static const char * 281sprintsigmask_long(const char *str, long mask) 282{ 283 sigset_t s; 284 sigemptyset(&s); 285 *(long *)&s = mask; 286 return sprintsigmask(str, &s); 287} 288 289static void 290printsigmask(sigset_t *mask) 291{ 292 tprints(sprintsigmask("", mask)); 293} 294 295void 296printsignal(int nr) 297{ 298 tprints(signame(nr)); 299} 300 301void 302print_sigset_addr_len(struct tcb *tcp, long addr, long len) 303{ 304 sigset_t ss; 305 306 if (!addr) { 307 tprints("NULL"); 308 return; 309 } 310 /* Here len is usually equals NSIG / 8 or current_wordsize. 311 * But we code this defensively: 312 */ 313 if (len < 0) { 314 bad: 315 tprintf("%#lx", addr); 316 return; 317 } 318 if (len > NSIG / 8) 319 len = NSIG / 8; 320 sigemptyset(&ss); 321 if (umoven(tcp, addr, len, (char *)&ss) < 0) 322 goto bad; 323 printsigmask(&ss); 324} 325 326#ifndef ILL_ILLOPC 327#define ILL_ILLOPC 1 /* illegal opcode */ 328#define ILL_ILLOPN 2 /* illegal operand */ 329#define ILL_ILLADR 3 /* illegal addressing mode */ 330#define ILL_ILLTRP 4 /* illegal trap */ 331#define ILL_PRVOPC 5 /* privileged opcode */ 332#define ILL_PRVREG 6 /* privileged register */ 333#define ILL_COPROC 7 /* coprocessor error */ 334#define ILL_BADSTK 8 /* internal stack error */ 335#define FPE_INTDIV 1 /* integer divide by zero */ 336#define FPE_INTOVF 2 /* integer overflow */ 337#define FPE_FLTDIV 3 /* floating point divide by zero */ 338#define FPE_FLTOVF 4 /* floating point overflow */ 339#define FPE_FLTUND 5 /* floating point underflow */ 340#define FPE_FLTRES 6 /* floating point inexact result */ 341#define FPE_FLTINV 7 /* floating point invalid operation */ 342#define FPE_FLTSUB 8 /* subscript out of range */ 343#define SEGV_MAPERR 1 /* address not mapped to object */ 344#define SEGV_ACCERR 2 /* invalid permissions for mapped object */ 345#define BUS_ADRALN 1 /* invalid address alignment */ 346#define BUS_ADRERR 2 /* non-existant physical address */ 347#define BUS_OBJERR 3 /* object specific hardware error */ 348#define TRAP_BRKPT 1 /* process breakpoint */ 349#define TRAP_TRACE 2 /* process trace trap */ 350#define CLD_EXITED 1 /* child has exited */ 351#define CLD_KILLED 2 /* child was killed */ 352#define CLD_DUMPED 3 /* child terminated abnormally */ 353#define CLD_TRAPPED 4 /* traced child has trapped */ 354#define CLD_STOPPED 5 /* child has stopped */ 355#define CLD_CONTINUED 6 /* stopped child has continued */ 356#define POLL_IN 1 /* data input available */ 357#define POLL_OUT 2 /* output buffers available */ 358#define POLL_MSG 3 /* input message available */ 359#define POLL_ERR 4 /* i/o error */ 360#define POLL_PRI 5 /* high priority input available */ 361#define POLL_HUP 6 /* device disconnected */ 362#define SI_KERNEL 0x80 /* sent by kernel */ 363#define SI_USER 0 /* sent by kill, sigsend, raise */ 364#define SI_QUEUE -1 /* sent by sigqueue */ 365#define SI_TIMER -2 /* sent by timer expiration */ 366#define SI_MESGQ -3 /* sent by real time mesq state change */ 367#define SI_ASYNCIO -4 /* sent by AIO completion */ 368#define SI_SIGIO -5 /* sent by SIGIO */ 369#define SI_TKILL -6 /* sent by tkill */ 370#define SI_ASYNCNL -60 /* sent by asynch name lookup completion */ 371#endif 372 373#ifndef SI_FROMUSER 374# define SI_FROMUSER(sip) ((sip)->si_code <= 0) 375#endif 376 377static const struct xlat siginfo_codes[] = { 378#ifdef SI_KERNEL 379 XLAT(SI_KERNEL), 380#endif 381#ifdef SI_USER 382 XLAT(SI_USER), 383#endif 384#ifdef SI_QUEUE 385 XLAT(SI_QUEUE), 386#endif 387#ifdef SI_TIMER 388 XLAT(SI_TIMER), 389#endif 390#ifdef SI_MESGQ 391 XLAT(SI_MESGQ), 392#endif 393#ifdef SI_ASYNCIO 394 XLAT(SI_ASYNCIO), 395#endif 396#ifdef SI_SIGIO 397 XLAT(SI_SIGIO), 398#endif 399#ifdef SI_TKILL 400 XLAT(SI_TKILL), 401#endif 402#ifdef SI_ASYNCNL 403 XLAT(SI_ASYNCNL), 404#endif 405#ifdef SI_NOINFO 406 XLAT(SI_NOINFO), 407#endif 408#ifdef SI_LWP 409 XLAT(SI_LWP), 410#endif 411 XLAT_END 412}; 413 414static const struct xlat sigill_codes[] = { 415 XLAT(ILL_ILLOPC), 416 XLAT(ILL_ILLOPN), 417 XLAT(ILL_ILLADR), 418 XLAT(ILL_ILLTRP), 419 XLAT(ILL_PRVOPC), 420 XLAT(ILL_PRVREG), 421 XLAT(ILL_COPROC), 422 XLAT(ILL_BADSTK), 423 XLAT_END 424}; 425 426static const struct xlat sigfpe_codes[] = { 427 XLAT(FPE_INTDIV), 428 XLAT(FPE_INTOVF), 429 XLAT(FPE_FLTDIV), 430 XLAT(FPE_FLTOVF), 431 XLAT(FPE_FLTUND), 432 XLAT(FPE_FLTRES), 433 XLAT(FPE_FLTINV), 434 XLAT(FPE_FLTSUB), 435 XLAT_END 436}; 437 438static const struct xlat sigtrap_codes[] = { 439 XLAT(TRAP_BRKPT), 440 XLAT(TRAP_TRACE), 441 XLAT_END 442}; 443 444static const struct xlat sigchld_codes[] = { 445 XLAT(CLD_EXITED), 446 XLAT(CLD_KILLED), 447 XLAT(CLD_DUMPED), 448 XLAT(CLD_TRAPPED), 449 XLAT(CLD_STOPPED), 450 XLAT(CLD_CONTINUED), 451 XLAT_END 452}; 453 454static const struct xlat sigpoll_codes[] = { 455 XLAT(POLL_IN), 456 XLAT(POLL_OUT), 457 XLAT(POLL_MSG), 458 XLAT(POLL_ERR), 459 XLAT(POLL_PRI), 460 XLAT(POLL_HUP), 461 XLAT_END 462}; 463 464static const struct xlat sigprof_codes[] = { 465#ifdef PROF_SIG 466 XLAT(PROF_SIG), 467#endif 468 XLAT_END 469}; 470 471#ifdef SIGEMT 472static const struct xlat sigemt_codes[] = { 473#ifdef EMT_TAGOVF 474 XLAT(EMT_TAGOVF), 475#endif 476 XLAT_END 477}; 478#endif 479 480static const struct xlat sigsegv_codes[] = { 481 XLAT(SEGV_MAPERR), 482 XLAT(SEGV_ACCERR), 483 XLAT_END 484}; 485 486static const struct xlat sigbus_codes[] = { 487 XLAT(BUS_ADRALN), 488 XLAT(BUS_ADRERR), 489 XLAT(BUS_OBJERR), 490 XLAT_END 491}; 492 493void 494printsiginfo(siginfo_t *sip, int verbose) 495{ 496 const char *code; 497 498 if (sip->si_signo == 0) { 499 tprints("{}"); 500 return; 501 } 502 tprints("{si_signo="); 503 printsignal(sip->si_signo); 504 code = xlookup(siginfo_codes, sip->si_code); 505 if (!code) { 506 switch (sip->si_signo) { 507 case SIGTRAP: 508 code = xlookup(sigtrap_codes, sip->si_code); 509 break; 510 case SIGCHLD: 511 code = xlookup(sigchld_codes, sip->si_code); 512 break; 513 case SIGPOLL: 514 code = xlookup(sigpoll_codes, sip->si_code); 515 break; 516 case SIGPROF: 517 code = xlookup(sigprof_codes, sip->si_code); 518 break; 519 case SIGILL: 520 code = xlookup(sigill_codes, sip->si_code); 521 break; 522#ifdef SIGEMT 523 case SIGEMT: 524 code = xlookup(sigemt_codes, sip->si_code); 525 break; 526#endif 527 case SIGFPE: 528 code = xlookup(sigfpe_codes, sip->si_code); 529 break; 530 case SIGSEGV: 531 code = xlookup(sigsegv_codes, sip->si_code); 532 break; 533 case SIGBUS: 534 code = xlookup(sigbus_codes, sip->si_code); 535 break; 536 } 537 } 538 if (code) 539 tprintf(", si_code=%s", code); 540 else 541 tprintf(", si_code=%#x", sip->si_code); 542#ifdef SI_NOINFO 543 if (sip->si_code != SI_NOINFO) 544#endif 545 { 546 if (sip->si_errno) { 547 if (sip->si_errno < 0 || sip->si_errno >= nerrnos) 548 tprintf(", si_errno=%d", sip->si_errno); 549 else 550 tprintf(", si_errno=%s", 551 errnoent[sip->si_errno]); 552 } 553#ifdef SI_FROMUSER 554 if (SI_FROMUSER(sip)) { 555 tprintf(", si_pid=%lu, si_uid=%lu", 556 (unsigned long) sip->si_pid, 557 (unsigned long) sip->si_uid); 558 switch (sip->si_code) { 559#ifdef SI_USER 560 case SI_USER: 561 break; 562#endif 563#ifdef SI_TKILL 564 case SI_TKILL: 565 break; 566#endif 567#ifdef SI_TIMER 568 case SI_TIMER: 569 tprintf(", si_value=%d", sip->si_int); 570 break; 571#endif 572 default: 573 if (!sip->si_ptr) 574 break; 575 if (!verbose) 576 tprints(", ..."); 577 else 578 tprintf(", si_value={int=%u, ptr=%#lx}", 579 sip->si_int, 580 (unsigned long) sip->si_ptr); 581 break; 582 } 583 } 584 else 585#endif /* SI_FROMUSER */ 586 { 587 switch (sip->si_signo) { 588 case SIGCHLD: 589 tprintf(", si_pid=%ld, si_status=", 590 (long) sip->si_pid); 591 if (sip->si_code == CLD_EXITED) 592 tprintf("%d", sip->si_status); 593 else 594 printsignal(sip->si_status); 595 if (!verbose) 596 tprints(", ..."); 597 else 598 tprintf(", si_utime=%llu, si_stime=%llu", 599 (unsigned long long) sip->si_utime, 600 (unsigned long long) sip->si_stime); 601 break; 602 case SIGILL: case SIGFPE: 603 case SIGSEGV: case SIGBUS: 604 tprintf(", si_addr=%#lx", 605 (unsigned long) sip->si_addr); 606 break; 607 case SIGPOLL: 608 switch (sip->si_code) { 609 case POLL_IN: case POLL_OUT: case POLL_MSG: 610 tprintf(", si_band=%ld", 611 (long) sip->si_band); 612 break; 613 } 614 break; 615 default: 616 if (sip->si_pid || sip->si_uid) 617 tprintf(", si_pid=%lu, si_uid=%lu", 618 (unsigned long) sip->si_pid, 619 (unsigned long) sip->si_uid); 620 if (!sip->si_ptr) 621 break; 622 if (!verbose) 623 tprints(", ..."); 624 else { 625 tprintf(", si_value={int=%u, ptr=%#lx}", 626 sip->si_int, 627 (unsigned long) sip->si_ptr); 628 } 629 630 } 631 } 632 } 633 tprints("}"); 634} 635 636void 637printsiginfo_at(struct tcb *tcp, long addr) 638{ 639 siginfo_t si; 640 if (!addr) { 641 tprints("NULL"); 642 return; 643 } 644 if (syserror(tcp)) { 645 tprintf("%#lx", addr); 646 return; 647 } 648 if (umove(tcp, addr, &si) < 0) { 649 tprints("{???}"); 650 return; 651 } 652 printsiginfo(&si, verbose(tcp)); 653} 654 655int 656sys_sigsetmask(struct tcb *tcp) 657{ 658 if (entering(tcp)) { 659 tprints(sprintsigmask_long("", tcp->u_arg[0])); 660 } 661 else if (!syserror(tcp)) { 662 tcp->auxstr = sprintsigmask_long("old mask ", tcp->u_rval); 663 return RVAL_HEX | RVAL_STR; 664 } 665 return 0; 666} 667 668#ifdef HAVE_SIGACTION 669 670struct old_sigaction { 671 /* sa_handler may be a libc #define, need to use other name: */ 672#ifdef MIPS 673 unsigned int sa_flags; 674 void (*__sa_handler)(int); 675 /* Kernel treats sa_mask as an array of longs. */ 676 unsigned long sa_mask[NSIG / sizeof(long) ? NSIG / sizeof(long) : 1]; 677#else 678 void (*__sa_handler)(int); 679 unsigned long sa_mask; 680 unsigned long sa_flags; 681 void (*sa_restorer)(void); 682#endif /* !MIPS */ 683}; 684 685static void 686decode_old_sigaction(struct tcb *tcp, long addr) 687{ 688 struct old_sigaction sa; 689 690 if (!addr) { 691 tprints("NULL"); 692 return; 693 } 694 if (!verbose(tcp) || (exiting(tcp) && syserror(tcp))) { 695 tprintf("%#lx", addr); 696 return; 697 } 698 if (umove(tcp, addr, &sa) < 0) { 699 tprints("{...}"); 700 return; 701 } 702 703 /* Architectures using function pointers, like 704 * hppa, may need to manipulate the function pointer 705 * to compute the result of a comparison. However, 706 * the __sa_handler function pointer exists only in 707 * the address space of the traced process, and can't 708 * be manipulated by strace. In order to prevent the 709 * compiler from generating code to manipulate 710 * __sa_handler we cast the function pointers to long. */ 711 if ((long)sa.__sa_handler == (long)SIG_ERR) 712 tprints("{SIG_ERR, "); 713 else if ((long)sa.__sa_handler == (long)SIG_DFL) 714 tprints("{SIG_DFL, "); 715 else if ((long)sa.__sa_handler == (long)SIG_IGN) 716 tprints("{SIG_IGN, "); 717 else 718 tprintf("{%#lx, ", (long) sa.__sa_handler); 719#ifdef MIPS 720 tprints(sprintsigmask("", (sigset_t *)sa.sa_mask)); 721#else 722 tprints(sprintsigmask_long("", sa.sa_mask)); 723#endif 724 tprints(", "); 725 printflags(sigact_flags, sa.sa_flags, "SA_???"); 726#ifdef SA_RESTORER 727 if (sa.sa_flags & SA_RESTORER) 728 tprintf(", %p", sa.sa_restorer); 729#endif 730 tprints("}"); 731} 732 733int 734sys_sigaction(struct tcb *tcp) 735{ 736 if (entering(tcp)) { 737 printsignal(tcp->u_arg[0]); 738 tprints(", "); 739 decode_old_sigaction(tcp, tcp->u_arg[1]); 740 tprints(", "); 741 } else 742 decode_old_sigaction(tcp, tcp->u_arg[2]); 743 return 0; 744} 745 746int 747sys_signal(struct tcb *tcp) 748{ 749 if (entering(tcp)) { 750 printsignal(tcp->u_arg[0]); 751 tprints(", "); 752 switch (tcp->u_arg[1]) { 753 case (long) SIG_ERR: 754 tprints("SIG_ERR"); 755 break; 756 case (long) SIG_DFL: 757 tprints("SIG_DFL"); 758 break; 759 case (long) SIG_IGN: 760 tprints("SIG_IGN"); 761 break; 762 default: 763 tprintf("%#lx", tcp->u_arg[1]); 764 } 765 return 0; 766 } 767 else if (!syserror(tcp)) { 768 switch (tcp->u_rval) { 769 case (long) SIG_ERR: 770 tcp->auxstr = "SIG_ERR"; break; 771 case (long) SIG_DFL: 772 tcp->auxstr = "SIG_DFL"; break; 773 case (long) SIG_IGN: 774 tcp->auxstr = "SIG_IGN"; break; 775 default: 776 tcp->auxstr = NULL; 777 } 778 return RVAL_HEX | RVAL_STR; 779 } 780 return 0; 781} 782 783#endif /* HAVE_SIGACTION */ 784 785int 786sys_sigreturn(struct tcb *tcp) 787{ 788#if defined(ARM) 789 if (entering(tcp)) { 790 struct arm_sigcontext { 791 unsigned long trap_no; 792 unsigned long error_code; 793 unsigned long oldmask; 794 unsigned long arm_r0; 795 unsigned long arm_r1; 796 unsigned long arm_r2; 797 unsigned long arm_r3; 798 unsigned long arm_r4; 799 unsigned long arm_r5; 800 unsigned long arm_r6; 801 unsigned long arm_r7; 802 unsigned long arm_r8; 803 unsigned long arm_r9; 804 unsigned long arm_r10; 805 unsigned long arm_fp; 806 unsigned long arm_ip; 807 unsigned long arm_sp; 808 unsigned long arm_lr; 809 unsigned long arm_pc; 810 unsigned long arm_cpsr; 811 unsigned long fault_address; 812 }; 813 struct arm_ucontext { 814 unsigned long uc_flags; 815 unsigned long uc_link; /* struct ucontext* */ 816 /* The next three members comprise stack_t struct: */ 817 unsigned long ss_sp; /* void* */ 818 unsigned long ss_flags; /* int */ 819 unsigned long ss_size; /* size_t */ 820 struct arm_sigcontext sc; 821 /* These two members are sigset_t: */ 822 unsigned long uc_sigmask[2]; 823 /* more fields follow, which we aren't interested in */ 824 }; 825 struct arm_ucontext uc; 826 sigset_t sigm; 827 if (umove(tcp, arm_regs.ARM_sp, &uc) < 0) 828 return 0; 829 /* Kernel fills out uc.sc.oldmask too when it sets up signal stack, 830 * but for sigmask restore, sigreturn syscall uses uc.uc_sigmask instead. 831 * tprints(sprintsigmask_long(") (mask ", uc.sc.oldmask)); 832 */ 833 sigemptyset(&sigm); 834 ((uint32_t*)&sigm)[0] = uc.uc_sigmask[0]; 835 ((uint32_t*)&sigm)[1] = uc.uc_sigmask[1]; 836 tprints(sprintsigmask(") (mask ", &sigm)); 837 } 838#elif defined(S390) || defined(S390X) 839 if (entering(tcp)) { 840 long usp; 841 struct sigcontext sc; 842 if (upeek(tcp->pid, PT_GPR15, &usp) < 0) 843 return 0; 844 if (umove(tcp, usp + __SIGNAL_FRAMESIZE, &sc) < 0) 845 return 0; 846 tprints(sprintsigmask(") (mask ", (sigset_t *)&sc.oldmask[0])); 847 } 848#elif defined(I386) || defined(X86_64) 849# if defined(X86_64) 850 if (current_personality == 0) /* 64-bit */ 851 return 0; 852# endif 853 if (entering(tcp)) { 854 struct i386_sigcontext_struct { 855 uint16_t gs, __gsh; 856 uint16_t fs, __fsh; 857 uint16_t es, __esh; 858 uint16_t ds, __dsh; 859 uint32_t edi; 860 uint32_t esi; 861 uint32_t ebp; 862 uint32_t esp; 863 uint32_t ebx; 864 uint32_t edx; 865 uint32_t ecx; 866 uint32_t eax; 867 uint32_t trapno; 868 uint32_t err; 869 uint32_t eip; 870 uint16_t cs, __csh; 871 uint32_t eflags; 872 uint32_t esp_at_signal; 873 uint16_t ss, __ssh; 874 uint32_t i387; 875 uint32_t oldmask; 876 uint32_t cr2; 877 }; 878 struct i386_fpstate { 879 uint32_t cw; 880 uint32_t sw; 881 uint32_t tag; 882 uint32_t ipoff; 883 uint32_t cssel; 884 uint32_t dataoff; 885 uint32_t datasel; 886 uint8_t st[8][10]; /* 8*10 bytes: FP regs */ 887 uint16_t status; 888 uint16_t magic; 889 uint32_t fxsr_env[6]; 890 uint32_t mxcsr; 891 uint32_t reserved; 892 uint8_t stx[8][16]; /* 8*16 bytes: FP regs, each padded to 16 bytes */ 893 uint8_t xmm[8][16]; /* 8 XMM regs */ 894 uint32_t padding1[44]; 895 uint32_t padding2[12]; /* union with struct _fpx_sw_bytes */ 896 }; 897 struct { 898 struct i386_sigcontext_struct sc; 899 struct i386_fpstate fp; 900 uint32_t extramask[1]; 901 } signal_stack; 902 /* On i386, sc is followed on stack by struct fpstate 903 * and after it an additional u32 extramask[1] which holds 904 * upper half of the mask. 905 */ 906 union { 907 sigset_t sig; 908 uint32_t mask[2]; 909 } sigmask; 910 if (umove(tcp, *i386_esp_ptr, &signal_stack) < 0) 911 return 0; 912 sigemptyset(&sigmask.sig); 913 sigmask.mask[0] = signal_stack.sc.oldmask; 914 sigmask.mask[1] = signal_stack.extramask[0]; 915 tprints(sprintsigmask(") (mask ", &sigmask.sig)); 916 } 917#elif defined(IA64) 918 if (entering(tcp)) { 919 struct sigcontext sc; 920 long sp; 921 sigset_t sigm; 922 /* offset of sigcontext in the kernel's sigframe structure: */ 923# define SIGFRAME_SC_OFFSET 0x90 924 if (upeek(tcp->pid, PT_R12, &sp) < 0) 925 return 0; 926 if (umove(tcp, sp + 16 + SIGFRAME_SC_OFFSET, &sc) < 0) 927 return 0; 928 sigemptyset(&sigm); 929 memcpy(&sigm, &sc.sc_mask, NSIG / 8); 930 tprints(sprintsigmask(") (mask ", &sigm)); 931 } 932#elif defined(POWERPC) 933 if (entering(tcp)) { 934 long esp; 935 struct sigcontext sc; 936 937 esp = ppc_regs.gpr[1]; 938 939 /* Skip dummy stack frame. */ 940#ifdef POWERPC64 941 if (current_personality == 0) 942 esp += 128; 943 else 944 esp += 64; 945#else 946 esp += 64; 947#endif 948 if (umove(tcp, esp, &sc) < 0) 949 return 0; 950 tprints(sprintsigmask_long(") (mask ", sc.oldmask)); 951 } 952#elif defined(M68K) 953 if (entering(tcp)) { 954 long usp; 955 struct sigcontext sc; 956 if (upeek(tcp->pid, 4*PT_USP, &usp) < 0) 957 return 0; 958 if (umove(tcp, usp, &sc) < 0) 959 return 0; 960 tprints(sprintsigmask_long(") (mask ", sc.sc_mask)); 961 } 962#elif defined(ALPHA) 963 if (entering(tcp)) { 964 long fp; 965 struct sigcontext sc; 966 if (upeek(tcp->pid, REG_FP, &fp) < 0) 967 return 0; 968 if (umove(tcp, fp, &sc) < 0) 969 return 0; 970 tprints(sprintsigmask_long(") (mask ", sc.sc_mask)); 971 } 972#elif defined(SPARC) || defined(SPARC64) 973 if (entering(tcp)) { 974 long i1; 975 m_siginfo_t si; 976 i1 = sparc_regs.u_regs[U_REG_O1]; 977 if (umove(tcp, i1, &si) < 0) { 978 perror_msg("sigreturn: umove"); 979 return 0; 980 } 981 tprints(sprintsigmask_long(") (mask ", si.si_mask)); 982 } 983#elif defined(LINUX_MIPSN32) || defined(LINUX_MIPSN64) 984 /* This decodes rt_sigreturn. The 64-bit ABIs do not have 985 sigreturn. */ 986 if (entering(tcp)) { 987 long sp; 988 struct ucontext uc; 989 sigset_t sigm; 990 if (upeek(tcp->pid, REG_SP, &sp) < 0) 991 return 0; 992 /* There are six words followed by a 128-byte siginfo. */ 993 sp = sp + 6 * 4 + 128; 994 if (umove(tcp, sp, &uc) < 0) 995 return 0; 996 tprints(sprintsigmask_long(") (mask ", *(long *) &uc.uc_sigmask)); 997 } 998#elif defined(MIPS) 999 if (entering(tcp)) { 1000 long sp; 1001 struct pt_regs regs; 1002 m_siginfo_t si; 1003 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) { 1004 perror_msg("sigreturn: PTRACE_GETREGS"); 1005 return 0; 1006 } 1007 sp = regs.regs[29]; 1008 if (umove(tcp, sp, &si) < 0) 1009 return 0; 1010 tprints(sprintsigmask_long(") (mask ", si.si_mask)); 1011 } 1012#elif defined(CRISV10) || defined(CRISV32) 1013 if (entering(tcp)) { 1014 struct sigcontext sc; 1015 long regs[PT_MAX+1]; 1016 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long)regs) < 0) { 1017 perror_msg("sigreturn: PTRACE_GETREGS"); 1018 return 0; 1019 } 1020 if (umove(tcp, regs[PT_USP], &sc) < 0) 1021 return 0; 1022 tprints(sprintsigmask_long(") (mask ", sc.oldmask)); 1023 } 1024#elif defined(TILE) 1025 if (entering(tcp)) { 1026 struct ucontext uc; 1027 sigset_t sigm; 1028 1029 /* offset of ucontext in the kernel's sigframe structure */ 1030# define SIGFRAME_UC_OFFSET C_ABI_SAVE_AREA_SIZE + sizeof(siginfo_t) 1031 if (umove(tcp, tile_regs.sp + SIGFRAME_UC_OFFSET, &uc) < 0) 1032 return 0; 1033 sigemptyset(&sigm); 1034 memcpy(&sigm, &uc.uc_sigmask, NSIG / 8); 1035 tprints(sprintsigmask(") (mask ", &sigm)); 1036 } 1037#elif defined(MICROBLAZE) 1038 /* TODO: Verify that this is correct... */ 1039 if (entering(tcp)) { 1040 struct sigcontext sc; 1041 long sp; 1042 /* Read r1, the stack pointer. */ 1043 if (upeek(tcp->pid, 1 * 4, &sp) < 0) 1044 return 0; 1045 if (umove(tcp, sp, &sc) < 0) 1046 return 0; 1047 tprints(sprintsigmask_long(") (mask ", sc.oldmask)); 1048 } 1049#elif defined(XTENSA) 1050 /* Xtensa only has rt_sys_sigreturn */ 1051#elif defined(ARC) 1052 /* ARC syscall ABI only supports rt_sys_sigreturn */ 1053#else 1054# warning No sys_sigreturn() for this architecture 1055# warning (no problem, just a reminder :-) 1056#endif 1057 return 0; 1058} 1059 1060int 1061sys_siggetmask(struct tcb *tcp) 1062{ 1063 if (exiting(tcp)) { 1064 tcp->auxstr = sprintsigmask_long("mask ", tcp->u_rval); 1065 } 1066 return RVAL_HEX | RVAL_STR; 1067} 1068 1069int 1070sys_sigsuspend(struct tcb *tcp) 1071{ 1072 if (entering(tcp)) { 1073 tprints(sprintsigmask_long("", tcp->u_arg[2])); 1074 } 1075 return 0; 1076} 1077 1078#if !defined SS_ONSTACK 1079#define SS_ONSTACK 1 1080#define SS_DISABLE 2 1081#endif 1082 1083static const struct xlat sigaltstack_flags[] = { 1084 XLAT(SS_ONSTACK), 1085 XLAT(SS_DISABLE), 1086 XLAT_END 1087}; 1088 1089static void 1090print_stack_t(struct tcb *tcp, unsigned long addr) 1091{ 1092 stack_t ss; 1093 1094 if (!addr) { 1095 tprints("NULL"); 1096 } else if (umove(tcp, addr, &ss) < 0) { 1097 tprintf("%#lx", addr); 1098 } else { 1099 tprintf("{ss_sp=%#lx, ss_flags=", (unsigned long) ss.ss_sp); 1100 printflags(sigaltstack_flags, ss.ss_flags, "SS_???"); 1101 tprintf(", ss_size=%lu}", (unsigned long) ss.ss_size); 1102 } 1103} 1104 1105int 1106sys_sigaltstack(struct tcb *tcp) 1107{ 1108 if (entering(tcp)) { 1109 print_stack_t(tcp, tcp->u_arg[0]); 1110 } 1111 else { 1112 tprints(", "); 1113 print_stack_t(tcp, tcp->u_arg[1]); 1114 } 1115 return 0; 1116} 1117 1118#ifdef HAVE_SIGACTION 1119 1120/* "Old" sigprocmask, which operates with word-sized signal masks */ 1121int 1122sys_sigprocmask(struct tcb *tcp) 1123{ 1124# ifdef ALPHA 1125 if (entering(tcp)) { 1126 /* 1127 * Alpha/OSF is different: it doesn't pass in two pointers, 1128 * but rather passes in the new bitmask as an argument and 1129 * then returns the old bitmask. This "works" because we 1130 * only have 64 signals to worry about. If you want more, 1131 * use of the rt_sigprocmask syscall is required. 1132 * Alpha: 1133 * old = osf_sigprocmask(how, new); 1134 * Everyone else: 1135 * ret = sigprocmask(how, &new, &old, ...); 1136 */ 1137 printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???"); 1138 tprints(sprintsigmask_long(", ", tcp->u_arg[1])); 1139 } 1140 else if (!syserror(tcp)) { 1141 tcp->auxstr = sprintsigmask_long("old mask ", tcp->u_rval); 1142 return RVAL_HEX | RVAL_STR; 1143 } 1144# else /* !ALPHA */ 1145 if (entering(tcp)) { 1146 printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???"); 1147 tprints(", "); 1148 print_sigset_addr_len(tcp, tcp->u_arg[1], current_wordsize); 1149 tprints(", "); 1150 } 1151 else { 1152 if (syserror(tcp)) 1153 tprintf("%#lx", tcp->u_arg[2]); 1154 else 1155 print_sigset_addr_len(tcp, tcp->u_arg[2], current_wordsize); 1156 } 1157# endif /* !ALPHA */ 1158 return 0; 1159} 1160 1161#endif /* HAVE_SIGACTION */ 1162 1163int 1164sys_kill(struct tcb *tcp) 1165{ 1166 if (entering(tcp)) { 1167 tprintf("%ld, %s", 1168 widen_to_long(tcp->u_arg[0]), 1169 signame(tcp->u_arg[1]) 1170 ); 1171 } 1172 return 0; 1173} 1174 1175int 1176sys_tgkill(struct tcb *tcp) 1177{ 1178 if (entering(tcp)) { 1179 tprintf("%ld, %ld, %s", 1180 widen_to_long(tcp->u_arg[0]), 1181 widen_to_long(tcp->u_arg[1]), 1182 signame(tcp->u_arg[2]) 1183 ); 1184 } 1185 return 0; 1186} 1187 1188int 1189sys_sigpending(struct tcb *tcp) 1190{ 1191 if (exiting(tcp)) { 1192 if (syserror(tcp)) 1193 tprintf("%#lx", tcp->u_arg[0]); 1194 else 1195 print_sigset_addr_len(tcp, tcp->u_arg[0], current_wordsize); 1196 } 1197 return 0; 1198} 1199 1200int 1201sys_rt_sigprocmask(struct tcb *tcp) 1202{ 1203 /* Note: arg[3] is the length of the sigset. Kernel requires NSIG / 8 */ 1204 if (entering(tcp)) { 1205 printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???"); 1206 tprints(", "); 1207 print_sigset_addr_len(tcp, tcp->u_arg[1], tcp->u_arg[3]); 1208 tprints(", "); 1209 } 1210 else { 1211 if (syserror(tcp)) 1212 tprintf("%#lx", tcp->u_arg[2]); 1213 else 1214 print_sigset_addr_len(tcp, tcp->u_arg[2], tcp->u_arg[3]); 1215 tprintf(", %lu", tcp->u_arg[3]); 1216 } 1217 return 0; 1218} 1219 1220/* Structure describing the action to be taken when a signal arrives. */ 1221struct new_sigaction 1222{ 1223 /* sa_handler may be a libc #define, need to use other name: */ 1224#ifdef MIPS 1225 unsigned int sa_flags; 1226 void (*__sa_handler)(int); 1227#else 1228 void (*__sa_handler)(int); 1229 unsigned long sa_flags; 1230 void (*sa_restorer)(void); 1231#endif /* !MIPS */ 1232 /* Kernel treats sa_mask as an array of longs. */ 1233 unsigned long sa_mask[NSIG / sizeof(long) ? NSIG / sizeof(long) : 1]; 1234}; 1235/* Same for i386-on-x86_64 and similar cases */ 1236struct new_sigaction32 1237{ 1238 uint32_t __sa_handler; 1239 uint32_t sa_flags; 1240 uint32_t sa_restorer; 1241 uint32_t sa_mask[2 * (NSIG / sizeof(long) ? NSIG / sizeof(long) : 1)]; 1242}; 1243 1244static void 1245decode_new_sigaction(struct tcb *tcp, long addr) 1246{ 1247 struct new_sigaction sa; 1248 sigset_t sigset; 1249 int r; 1250 1251 if (!addr) { 1252 tprints("NULL"); 1253 return; 1254 } 1255 if (!verbose(tcp) || (exiting(tcp) && syserror(tcp))) { 1256 tprintf("%#lx", addr); 1257 return; 1258 } 1259#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4 1260 if (current_wordsize != sizeof(sa.sa_flags) && current_wordsize == 4) { 1261 struct new_sigaction32 sa32; 1262 r = umove(tcp, addr, &sa32); 1263 if (r >= 0) { 1264 memset(&sa, 0, sizeof(sa)); 1265 sa.__sa_handler = (void*)(unsigned long)sa32.__sa_handler; 1266 sa.sa_flags = sa32.sa_flags; 1267 sa.sa_restorer = (void*)(unsigned long)sa32.sa_restorer; 1268 /* Kernel treats sa_mask as an array of longs. 1269 * For 32-bit process, "long" is uint32_t, thus, for example, 1270 * 32th bit in sa_mask will end up as bit 0 in sa_mask[1]. 1271 * But for (64-bit) kernel, 32th bit in sa_mask is 1272 * 32th bit in 0th (64-bit) long! 1273 * For little-endian, it's the same. 1274 * For big-endian, we swap 32-bit words. 1275 */ 1276 sa.sa_mask[0] = sa32.sa_mask[0] + ((long)(sa32.sa_mask[1]) << 32); 1277 } 1278 } else 1279#endif 1280 { 1281 r = umove(tcp, addr, &sa); 1282 } 1283 if (r < 0) { 1284 tprints("{...}"); 1285 return; 1286 } 1287 /* Architectures using function pointers, like 1288 * hppa, may need to manipulate the function pointer 1289 * to compute the result of a comparison. However, 1290 * the __sa_handler function pointer exists only in 1291 * the address space of the traced process, and can't 1292 * be manipulated by strace. In order to prevent the 1293 * compiler from generating code to manipulate 1294 * __sa_handler we cast the function pointers to long. */ 1295 if ((long)sa.__sa_handler == (long)SIG_ERR) 1296 tprints("{SIG_ERR, "); 1297 else if ((long)sa.__sa_handler == (long)SIG_DFL) 1298 tprints("{SIG_DFL, "); 1299 else if ((long)sa.__sa_handler == (long)SIG_IGN) 1300 tprints("{SIG_IGN, "); 1301 else 1302 tprintf("{%#lx, ", (long) sa.__sa_handler); 1303 /* 1304 * Sigset size is in tcp->u_arg[4] (SPARC) 1305 * or in tcp->u_arg[3] (all other), 1306 * but kernel won't handle sys_rt_sigaction 1307 * with wrong sigset size (just returns EINVAL instead). 1308 * We just fetch the right size, which is NSIG / 8. 1309 */ 1310 sigemptyset(&sigset); 1311 memcpy(&sigset, &sa.sa_mask, NSIG / 8); 1312 printsigmask(&sigset); 1313 tprints(", "); 1314 1315 printflags(sigact_flags, sa.sa_flags, "SA_???"); 1316#ifdef SA_RESTORER 1317 if (sa.sa_flags & SA_RESTORER) 1318 tprintf(", %p", sa.sa_restorer); 1319#endif 1320 tprints("}"); 1321} 1322 1323int 1324sys_rt_sigaction(struct tcb *tcp) 1325{ 1326 if (entering(tcp)) { 1327 printsignal(tcp->u_arg[0]); 1328 tprints(", "); 1329 decode_new_sigaction(tcp, tcp->u_arg[1]); 1330 tprints(", "); 1331 } else { 1332 decode_new_sigaction(tcp, tcp->u_arg[2]); 1333#if defined(SPARC) || defined(SPARC64) 1334 tprintf(", %#lx, %lu", tcp->u_arg[3], tcp->u_arg[4]); 1335#elif defined(ALPHA) 1336 tprintf(", %lu, %#lx", tcp->u_arg[3], tcp->u_arg[4]); 1337#else 1338 tprintf(", %lu", tcp->u_arg[3]); 1339#endif 1340 } 1341 return 0; 1342} 1343 1344int 1345sys_rt_sigpending(struct tcb *tcp) 1346{ 1347 if (exiting(tcp)) { 1348 /* 1349 * One of the few syscalls where sigset size (arg[1]) 1350 * is allowed to be <= NSIG / 8, not strictly ==. 1351 * This allows non-rt sigpending() syscall 1352 * to reuse rt_sigpending() code in kernel. 1353 */ 1354 if (syserror(tcp)) 1355 tprintf("%#lx", tcp->u_arg[0]); 1356 else 1357 print_sigset_addr_len(tcp, tcp->u_arg[0], tcp->u_arg[1]); 1358 tprintf(", %lu", tcp->u_arg[1]); 1359 } 1360 return 0; 1361} 1362 1363int 1364sys_rt_sigsuspend(struct tcb *tcp) 1365{ 1366 if (entering(tcp)) { 1367 /* NB: kernel requires arg[1] == NSIG / 8 */ 1368 print_sigset_addr_len(tcp, tcp->u_arg[0], tcp->u_arg[1]); 1369 tprintf(", %lu", tcp->u_arg[1]); 1370 } 1371 return 0; 1372} 1373 1374static void 1375print_sigqueueinfo(struct tcb *tcp, int sig, unsigned long uinfo) 1376{ 1377 printsignal(sig); 1378 tprints(", "); 1379 printsiginfo_at(tcp, uinfo); 1380} 1381 1382int 1383sys_rt_sigqueueinfo(struct tcb *tcp) 1384{ 1385 if (entering(tcp)) { 1386 tprintf("%lu, ", tcp->u_arg[0]); 1387 print_sigqueueinfo(tcp, tcp->u_arg[1], tcp->u_arg[2]); 1388 } 1389 return 0; 1390} 1391 1392int 1393sys_rt_tgsigqueueinfo(struct tcb *tcp) 1394{ 1395 if (entering(tcp)) { 1396 tprintf("%lu, %lu, ", tcp->u_arg[0], tcp->u_arg[1]); 1397 print_sigqueueinfo(tcp, tcp->u_arg[2], tcp->u_arg[3]); 1398 } 1399 return 0; 1400} 1401 1402int sys_rt_sigtimedwait(struct tcb *tcp) 1403{ 1404 /* NB: kernel requires arg[3] == NSIG / 8 */ 1405 if (entering(tcp)) { 1406 print_sigset_addr_len(tcp, tcp->u_arg[0], tcp->u_arg[3]); 1407 tprints(", "); 1408 /* This is the only "return" parameter, */ 1409 if (tcp->u_arg[1] != 0) 1410 return 0; 1411 /* ... if it's NULL, can decode all on entry */ 1412 tprints("NULL, "); 1413 } 1414 else if (tcp->u_arg[1] != 0) { 1415 /* syscall exit, and u_arg[1] wasn't NULL */ 1416 printsiginfo_at(tcp, tcp->u_arg[1]); 1417 tprints(", "); 1418 } 1419 else { 1420 /* syscall exit, and u_arg[1] was NULL */ 1421 return 0; 1422 } 1423 print_timespec(tcp, tcp->u_arg[2]); 1424 tprintf(", %lu", tcp->u_arg[3]); 1425 return 0; 1426}; 1427 1428int 1429sys_restart_syscall(struct tcb *tcp) 1430{ 1431 if (entering(tcp)) 1432 tprints("<... resuming interrupted call ...>"); 1433 return 0; 1434} 1435 1436static int 1437do_signalfd(struct tcb *tcp, int flags_arg) 1438{ 1439 /* NB: kernel requires arg[2] == NSIG / 8 */ 1440 if (entering(tcp)) { 1441 printfd(tcp, tcp->u_arg[0]); 1442 tprints(", "); 1443 print_sigset_addr_len(tcp, tcp->u_arg[1], tcp->u_arg[2]); 1444 tprintf(", %lu", tcp->u_arg[2]); 1445 if (flags_arg >= 0) { 1446 tprints(", "); 1447 printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???"); 1448 } 1449 } 1450 return 0; 1451} 1452 1453int 1454sys_signalfd(struct tcb *tcp) 1455{ 1456 return do_signalfd(tcp, -1); 1457} 1458 1459int 1460sys_signalfd4(struct tcb *tcp) 1461{ 1462 return do_signalfd(tcp, 3); 1463} 1464