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