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