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