signal.c revision 60fe8c139c6f2febefe595781812ddf0864a6ab8
1/* 2 * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl> 3 * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl> 4 * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com> 5 * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl> 6 * Copyright (c) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation 7 * Linux for s390 port by D.J. Barrow 8 * <barrow_dj@mail.yahoo.com,djbarrow@de.ibm.com> 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. The name of the author may not be used to endorse or promote products 20 * derived from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 * 33 * $Id$ 34 */ 35 36#include "defs.h" 37 38#include <stdint.h> 39#include <signal.h> 40#include <sys/user.h> 41#include <fcntl.h> 42 43#ifdef SVR4 44#include <sys/ucontext.h> 45#endif /* SVR4 */ 46 47#ifdef HAVE_SYS_REG_H 48# include <sys/reg.h> 49#ifndef PTRACE_PEEKUSR 50# define PTRACE_PEEKUSR PTRACE_PEEKUSER 51#endif 52#ifndef PTRACE_POKEUSR 53# define PTRACE_POKEUSR PTRACE_POKEUSER 54#endif 55#elif defined(HAVE_LINUX_PTRACE_H) 56#undef PTRACE_SYSCALL 57# ifdef HAVE_STRUCT_IA64_FPREG 58# define ia64_fpreg XXX_ia64_fpreg 59# endif 60# ifdef HAVE_STRUCT_PT_ALL_USER_REGS 61# define pt_all_user_regs XXX_pt_all_user_regs 62# endif 63#include <linux/ptrace.h> 64# undef ia64_fpreg 65# undef pt_all_user_regs 66#endif 67 68 69#ifdef LINUX 70 71#ifdef IA64 72# include <asm/ptrace_offsets.h> 73#endif 74 75#if defined (LINUX) && defined (SPARC64) 76# undef PTRACE_GETREGS 77# define PTRACE_GETREGS PTRACE_GETREGS64 78# undef PTRACE_SETREGS 79# define PTRACE_SETREGS PTRACE_SETREGS64 80#endif /* LINUX && SPARC64 */ 81 82#if defined (SPARC) || defined (SPARC64) || defined (MIPS) 83typedef struct { 84 struct pt_regs si_regs; 85 int si_mask; 86} m_siginfo_t; 87#elif defined HAVE_ASM_SIGCONTEXT_H 88#if !defined(IA64) && !defined(X86_64) 89#include <asm/sigcontext.h> 90#endif /* !IA64 && !X86_64 */ 91#else /* !HAVE_ASM_SIGCONTEXT_H */ 92#if defined I386 && !defined HAVE_STRUCT_SIGCONTEXT_STRUCT 93struct sigcontext_struct { 94 unsigned short gs, __gsh; 95 unsigned short fs, __fsh; 96 unsigned short es, __esh; 97 unsigned short ds, __dsh; 98 unsigned long edi; 99 unsigned long esi; 100 unsigned long ebp; 101 unsigned long esp; 102 unsigned long ebx; 103 unsigned long edx; 104 unsigned long ecx; 105 unsigned long eax; 106 unsigned long trapno; 107 unsigned long err; 108 unsigned long eip; 109 unsigned short cs, __csh; 110 unsigned long eflags; 111 unsigned long esp_at_signal; 112 unsigned short ss, __ssh; 113 unsigned long i387; 114 unsigned long oldmask; 115 unsigned long cr2; 116}; 117#else /* !I386 */ 118#if defined M68K && !defined HAVE_STRUCT_SIGCONTEXT 119struct sigcontext 120{ 121 unsigned long sc_mask; 122 unsigned long sc_usp; 123 unsigned long sc_d0; 124 unsigned long sc_d1; 125 unsigned long sc_a0; 126 unsigned long sc_a1; 127 unsigned short sc_sr; 128 unsigned long sc_pc; 129 unsigned short sc_formatvec; 130}; 131#endif /* M68K */ 132#endif /* !I386 */ 133#endif /* !HAVE_ASM_SIGCONTEXT_H */ 134 135#ifndef NSIG 136#warning: NSIG is not defined, using 32 137#define NSIG 32 138#endif 139#ifdef ARM 140/* Ugh. Is this really correct? ARM has no RT signals?! */ 141#undef NSIG 142#define NSIG 32 143#endif 144 145#endif /* LINUX */ 146 147#if defined(SUNOS4) || defined(FREEBSD) 148 149static const struct xlat sigvec_flags[] = { 150 { SV_ONSTACK, "SV_ONSTACK" }, 151 { SV_INTERRUPT, "SV_INTERRUPT" }, 152 { SV_RESETHAND, "SV_RESETHAND" }, 153 { SA_NOCLDSTOP, "SA_NOCLDSTOP" }, 154 { 0, NULL }, 155}; 156 157#endif /* SUNOS4 || FREEBSD */ 158 159#ifdef HAVE_SIGACTION 160 161#if defined LINUX && (defined I386 || defined X86_64) 162/* The libc headers do not define this constant since it should only be 163 used by the implementation. So we define it here. */ 164# ifndef SA_RESTORER 165# define SA_RESTORER 0x04000000 166# endif 167#endif 168 169static const struct xlat sigact_flags[] = { 170#ifdef SA_RESTORER 171 { SA_RESTORER, "SA_RESTORER" }, 172#endif 173#ifdef SA_STACK 174 { SA_STACK, "SA_STACK" }, 175#endif 176#ifdef SA_RESTART 177 { SA_RESTART, "SA_RESTART" }, 178#endif 179#ifdef SA_INTERRUPT 180 { SA_INTERRUPT, "SA_INTERRUPT" }, 181#endif 182#ifdef SA_NODEFER 183 { SA_NODEFER, "SA_NODEFER" }, 184#endif 185#if defined SA_NOMASK && SA_NODEFER != SA_NOMASK 186 { SA_NOMASK, "SA_NOMASK" }, 187#endif 188#ifdef SA_RESETHAND 189 { SA_RESETHAND, "SA_RESETHAND" }, 190#endif 191#if defined SA_ONESHOT && SA_ONESHOT != SA_RESETHAND 192 { SA_ONESHOT, "SA_ONESHOT" }, 193#endif 194#ifdef SA_SIGINFO 195 { SA_SIGINFO, "SA_SIGINFO" }, 196#endif 197#ifdef SA_RESETHAND 198 { SA_RESETHAND, "SA_RESETHAND" }, 199#endif 200#ifdef SA_ONSTACK 201 { SA_ONSTACK, "SA_ONSTACK" }, 202#endif 203#ifdef SA_NODEFER 204 { SA_NODEFER, "SA_NODEFER" }, 205#endif 206#ifdef SA_NOCLDSTOP 207 { SA_NOCLDSTOP, "SA_NOCLDSTOP" }, 208#endif 209#ifdef SA_NOCLDWAIT 210 { SA_NOCLDWAIT, "SA_NOCLDWAIT" }, 211#endif 212#ifdef _SA_BSDCALL 213 { _SA_BSDCALL, "_SA_BSDCALL" }, 214#endif 215#ifdef SA_NOPTRACE 216 { SA_NOPTRACE, "SA_NOPTRACE" }, 217#endif 218 { 0, NULL }, 219}; 220 221static const struct xlat sigprocmaskcmds[] = { 222 { SIG_BLOCK, "SIG_BLOCK" }, 223 { SIG_UNBLOCK, "SIG_UNBLOCK" }, 224 { SIG_SETMASK, "SIG_SETMASK" }, 225#ifdef SIG_SETMASK32 226 { SIG_SETMASK32,"SIG_SETMASK32" }, 227#endif 228 { 0, NULL }, 229}; 230 231#endif /* HAVE_SIGACTION */ 232 233/* Anonymous realtime signals. */ 234/* Under glibc 2.1, SIGRTMIN et al are functions, but __SIGRTMIN is a 235 constant. This is what we want. Otherwise, just use SIGRTMIN. */ 236#ifdef SIGRTMIN 237#ifndef __SIGRTMIN 238#define __SIGRTMIN SIGRTMIN 239#define __SIGRTMAX SIGRTMAX /* likewise */ 240#endif 241#endif 242 243/* Note on the size of sigset_t: 244 * 245 * In glibc, sigset_t is an array with space for 1024 bits (!), 246 * even though all arches supported by Linux have only 64 signals 247 * except MIPS, which has 128. IOW, it is 128 bytes long. 248 * 249 * In-kernel sigset_t is sized correctly (it is either 64 or 128 bit long). 250 * However, some old syscall return only 32 lower bits (one word). 251 * Example: sys_sigpending vs sys_rt_sigpending. 252 * 253 * Be aware of this fact when you try to 254 * memcpy(&tcp->u_arg[1], &something, sizeof(sigset_t)) 255 * - sizeof(sigset_t) is much bigger than you think, 256 * it may overflow tcp->u_arg[] array, and it may try to copy more data 257 * than is really available in <something>. 258 * Similarly, 259 * umoven(tcp, addr, sizeof(sigset_t), &sigset) 260 * may be a bad idea: it'll try to read much more data than needed 261 * to fetch a sigset_t. 262 * Use (NSIG / 8) as a size instead. 263 */ 264 265const char * 266signame(int sig) 267{ 268 static char buf[sizeof("SIGRT_%d") + sizeof(int)*3]; 269 270 if (sig >= 0 && sig < nsignals) 271 return signalent[sig]; 272#ifdef SIGRTMIN 273 if (sig >= __SIGRTMIN && sig <= __SIGRTMAX) { 274 sprintf(buf, "SIGRT_%d", (int)(sig - __SIGRTMIN)); 275 return buf; 276 } 277#endif 278 sprintf(buf, "%d", sig); 279 return buf; 280} 281 282#ifndef UNIXWARE 283static void 284long_to_sigset(long l, sigset_t *s) 285{ 286 sigemptyset(s); 287 *(long *)s = l; 288} 289#endif 290 291static int 292copy_sigset_len(struct tcb *tcp, long addr, sigset_t *s, int len) 293{ 294 if (len > sizeof(*s)) 295 len = sizeof(*s); 296 sigemptyset(s); 297 if (umoven(tcp, addr, len, (char *)s) < 0) 298 return -1; 299 return 0; 300} 301 302#ifdef LINUX 303/* Original sigset is unsigned long */ 304#define copy_sigset(tcp, addr, s) copy_sigset_len(tcp, addr, s, sizeof(long)) 305#else 306#define copy_sigset(tcp, addr, s) copy_sigset_len(tcp, addr, s, sizeof(sigset_t)) 307#endif 308 309static const char * 310sprintsigmask(const char *str, sigset_t *mask, int rt) 311/* set might include realtime sigs */ 312{ 313 /* Was [8 * sizeof(sigset_t) * 8], but 314 * glibc sigset_t is huge (1024 bits = 128 *bytes*), 315 * and we were ending up with 8k (!) buffer here. 316 * 317 * No Unix system can have sig > 255 318 * (waitpid API won't be able to indicate death from one) 319 * and sig 0 doesn't exist either. 320 * Therefore max possible no of sigs is 255: 1..255 321 */ 322 static char outstr[8 * 255]; 323 324 int i, nsigs; 325 int maxsigs; 326 const char *format; 327 char *s; 328 329 strcpy(outstr, str); 330 s = outstr + strlen(outstr); 331 nsigs = 0; 332 maxsigs = nsignals; 333#ifdef __SIGRTMAX 334 if (rt) 335 maxsigs = __SIGRTMAX; /* instead */ 336#endif 337 for (i = 1; i < maxsigs; i++) { 338 if (sigismember(mask, i) == 1) 339 nsigs++; 340 } 341 if (nsigs >= nsignals * 2 / 3) { 342 *s++ = '~'; 343 for (i = 1; i < maxsigs; i++) { 344 switch (sigismember(mask, i)) { 345 case 1: 346 sigdelset(mask, i); 347 break; 348 case 0: 349 sigaddset(mask, i); 350 break; 351 } 352 } 353 } 354 format = "%s"; 355 *s++ = '['; 356 for (i = 1; i < maxsigs; i++) { 357 if (sigismember(mask, i) == 1) { 358 /* real-time signals on solaris don't have 359 * signalent entries 360 */ 361 if (i < nsignals) { 362 sprintf(s, format, signalent[i] + 3); 363 } 364#ifdef SIGRTMIN 365 else if (i >= __SIGRTMIN && i <= __SIGRTMAX) { 366 char tsig[40]; 367 sprintf(tsig, "RT_%u", i - __SIGRTMIN); 368 sprintf(s, format, tsig); 369 } 370#endif /* SIGRTMIN */ 371 else { 372 char tsig[32]; 373 sprintf(tsig, "%u", i); 374 sprintf(s, format, tsig); 375 } 376 s += strlen(s); 377 format = " %s"; 378 } 379 } 380 *s++ = ']'; 381 *s = '\0'; 382 return outstr; 383} 384 385static void 386printsigmask(sigset_t *mask, int rt) 387{ 388 tprints(sprintsigmask("", mask, rt)); 389} 390 391void 392printsignal(int nr) 393{ 394 tprints(signame(nr)); 395} 396 397void 398print_sigset(struct tcb *tcp, long addr, int rt) 399{ 400 sigset_t ss; 401 402 if (!addr) 403 tprints("NULL"); 404 else if (copy_sigset(tcp, addr, &ss) < 0) 405 tprintf("%#lx", addr); 406 else 407 printsigmask(&ss, rt); 408} 409 410#ifdef LINUX 411 412#ifndef ILL_ILLOPC 413#define ILL_ILLOPC 1 /* illegal opcode */ 414#define ILL_ILLOPN 2 /* illegal operand */ 415#define ILL_ILLADR 3 /* illegal addressing mode */ 416#define ILL_ILLTRP 4 /* illegal trap */ 417#define ILL_PRVOPC 5 /* privileged opcode */ 418#define ILL_PRVREG 6 /* privileged register */ 419#define ILL_COPROC 7 /* coprocessor error */ 420#define ILL_BADSTK 8 /* internal stack error */ 421#define FPE_INTDIV 1 /* integer divide by zero */ 422#define FPE_INTOVF 2 /* integer overflow */ 423#define FPE_FLTDIV 3 /* floating point divide by zero */ 424#define FPE_FLTOVF 4 /* floating point overflow */ 425#define FPE_FLTUND 5 /* floating point underflow */ 426#define FPE_FLTRES 6 /* floating point inexact result */ 427#define FPE_FLTINV 7 /* floating point invalid operation */ 428#define FPE_FLTSUB 8 /* subscript out of range */ 429#define SEGV_MAPERR 1 /* address not mapped to object */ 430#define SEGV_ACCERR 2 /* invalid permissions for mapped object */ 431#define BUS_ADRALN 1 /* invalid address alignment */ 432#define BUS_ADRERR 2 /* non-existant physical address */ 433#define BUS_OBJERR 3 /* object specific hardware error */ 434#define TRAP_BRKPT 1 /* process breakpoint */ 435#define TRAP_TRACE 2 /* process trace trap */ 436#define CLD_EXITED 1 /* child has exited */ 437#define CLD_KILLED 2 /* child was killed */ 438#define CLD_DUMPED 3 /* child terminated abnormally */ 439#define CLD_TRAPPED 4 /* traced child has trapped */ 440#define CLD_STOPPED 5 /* child has stopped */ 441#define CLD_CONTINUED 6 /* stopped child has continued */ 442#define POLL_IN 1 /* data input available */ 443#define POLL_OUT 2 /* output buffers available */ 444#define POLL_MSG 3 /* input message available */ 445#define POLL_ERR 4 /* i/o error */ 446#define POLL_PRI 5 /* high priority input available */ 447#define POLL_HUP 6 /* device disconnected */ 448#define SI_KERNEL 0x80 /* sent by kernel */ 449#define SI_USER 0 /* sent by kill, sigsend, raise */ 450#define SI_QUEUE -1 /* sent by sigqueue */ 451#define SI_TIMER -2 /* sent by timer expiration */ 452#define SI_MESGQ -3 /* sent by real time mesq state change */ 453#define SI_ASYNCIO -4 /* sent by AIO completion */ 454#define SI_SIGIO -5 /* sent by SIGIO */ 455#define SI_TKILL -6 /* sent by tkill */ 456#define SI_ASYNCNL -60 /* sent by asynch name lookup completion */ 457 458#define SI_FROMUSER(sip) ((sip)->si_code <= 0) 459 460#endif /* LINUX */ 461 462#if __GLIBC_MINOR__ < 1 463/* Type for data associated with a signal. */ 464typedef union sigval 465{ 466 int sival_int; 467 void *sival_ptr; 468} sigval_t; 469 470# define __SI_MAX_SIZE 128 471# define __SI_PAD_SIZE ((__SI_MAX_SIZE / sizeof(int)) - 3) 472 473typedef struct siginfo 474{ 475 int si_signo; /* Signal number. */ 476 int si_errno; /* If non-zero, an errno value associated with 477 this signal, as defined in <errno.h>. */ 478 int si_code; /* Signal code. */ 479 480 union 481 { 482 int _pad[__SI_PAD_SIZE]; 483 484 /* kill(). */ 485 struct 486 { 487 __pid_t si_pid; /* Sending process ID. */ 488 __uid_t si_uid; /* Real user ID of sending process. */ 489 } _kill; 490 491 /* POSIX.1b timers. */ 492 struct 493 { 494 unsigned int _timer1; 495 unsigned int _timer2; 496 } _timer; 497 498 /* POSIX.1b signals. */ 499 struct 500 { 501 __pid_t si_pid; /* Sending process ID. */ 502 __uid_t si_uid; /* Real user ID of sending process. */ 503 sigval_t si_sigval; /* Signal value. */ 504 } _rt; 505 506 /* SIGCHLD. */ 507 struct 508 { 509 __pid_t si_pid; /* Which child. */ 510 int si_status; /* Exit value or signal. */ 511 __clock_t si_utime; 512 __clock_t si_stime; 513 } _sigchld; 514 515 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS. */ 516 struct 517 { 518 void *si_addr; /* Faulting insn/memory ref. */ 519 } _sigfault; 520 521 /* SIGPOLL. */ 522 struct 523 { 524 int si_band; /* Band event for SIGPOLL. */ 525 int si_fd; 526 } _sigpoll; 527 } _sifields; 528} siginfo_t; 529 530#define si_pid _sifields._kill.si_pid 531#define si_uid _sifields._kill.si_uid 532#define si_status _sifields._sigchld.si_status 533#define si_utime _sifields._sigchld.si_utime 534#define si_stime _sifields._sigchld.si_stime 535#define si_value _sifields._rt.si_sigval 536#define si_int _sifields._rt.si_sigval.sival_int 537#define si_ptr _sifields._rt.si_sigval.sival_ptr 538#define si_addr _sifields._sigfault.si_addr 539#define si_band _sifields._sigpoll.si_band 540#define si_fd _sifields._sigpoll.si_fd 541 542#endif 543 544#endif 545 546#if defined (SVR4) || defined (LINUX) 547 548static const struct xlat siginfo_codes[] = { 549#ifdef SI_KERNEL 550 { SI_KERNEL, "SI_KERNEL" }, 551#endif 552#ifdef SI_USER 553 { SI_USER, "SI_USER" }, 554#endif 555#ifdef SI_QUEUE 556 { SI_QUEUE, "SI_QUEUE" }, 557#endif 558#ifdef SI_TIMER 559 { SI_TIMER, "SI_TIMER" }, 560#endif 561#ifdef SI_MESGQ 562 { SI_MESGQ, "SI_MESGQ" }, 563#endif 564#ifdef SI_ASYNCIO 565 { SI_ASYNCIO, "SI_ASYNCIO" }, 566#endif 567#ifdef SI_SIGIO 568 { SI_SIGIO, "SI_SIGIO" }, 569#endif 570#ifdef SI_TKILL 571 { SI_TKILL, "SI_TKILL" }, 572#endif 573#ifdef SI_ASYNCNL 574 { SI_ASYNCNL, "SI_ASYNCNL" }, 575#endif 576#ifdef SI_NOINFO 577 { SI_NOINFO, "SI_NOINFO" }, 578#endif 579#ifdef SI_LWP 580 { SI_LWP, "SI_LWP" }, 581#endif 582 { 0, NULL }, 583}; 584 585static const struct xlat sigill_codes[] = { 586 { ILL_ILLOPC, "ILL_ILLOPC" }, 587 { ILL_ILLOPN, "ILL_ILLOPN" }, 588 { ILL_ILLADR, "ILL_ILLADR" }, 589 { ILL_ILLTRP, "ILL_ILLTRP" }, 590 { ILL_PRVOPC, "ILL_PRVOPC" }, 591 { ILL_PRVREG, "ILL_PRVREG" }, 592 { ILL_COPROC, "ILL_COPROC" }, 593 { ILL_BADSTK, "ILL_BADSTK" }, 594 { 0, NULL }, 595}; 596 597static const struct xlat sigfpe_codes[] = { 598 { FPE_INTDIV, "FPE_INTDIV" }, 599 { FPE_INTOVF, "FPE_INTOVF" }, 600 { FPE_FLTDIV, "FPE_FLTDIV" }, 601 { FPE_FLTOVF, "FPE_FLTOVF" }, 602 { FPE_FLTUND, "FPE_FLTUND" }, 603 { FPE_FLTRES, "FPE_FLTRES" }, 604 { FPE_FLTINV, "FPE_FLTINV" }, 605 { FPE_FLTSUB, "FPE_FLTSUB" }, 606 { 0, NULL }, 607}; 608 609static const struct xlat sigtrap_codes[] = { 610 { TRAP_BRKPT, "TRAP_BRKPT" }, 611 { TRAP_TRACE, "TRAP_TRACE" }, 612 { 0, NULL }, 613}; 614 615static const struct xlat sigchld_codes[] = { 616 { CLD_EXITED, "CLD_EXITED" }, 617 { CLD_KILLED, "CLD_KILLED" }, 618 { CLD_DUMPED, "CLD_DUMPED" }, 619 { CLD_TRAPPED, "CLD_TRAPPED" }, 620 { CLD_STOPPED, "CLD_STOPPED" }, 621 { CLD_CONTINUED,"CLD_CONTINUED" }, 622 { 0, NULL }, 623}; 624 625static const struct xlat sigpoll_codes[] = { 626 { POLL_IN, "POLL_IN" }, 627 { POLL_OUT, "POLL_OUT" }, 628 { POLL_MSG, "POLL_MSG" }, 629 { POLL_ERR, "POLL_ERR" }, 630 { POLL_PRI, "POLL_PRI" }, 631 { POLL_HUP, "POLL_HUP" }, 632 { 0, NULL }, 633}; 634 635static const struct xlat sigprof_codes[] = { 636#ifdef PROF_SIG 637 { PROF_SIG, "PROF_SIG" }, 638#endif 639 { 0, NULL }, 640}; 641 642#ifdef SIGEMT 643static const struct xlat sigemt_codes[] = { 644#ifdef EMT_TAGOVF 645 { EMT_TAGOVF, "EMT_TAGOVF" }, 646#endif 647 { 0, NULL }, 648}; 649#endif 650 651static const struct xlat sigsegv_codes[] = { 652 { SEGV_MAPERR, "SEGV_MAPERR" }, 653 { SEGV_ACCERR, "SEGV_ACCERR" }, 654 { 0, NULL }, 655}; 656 657static const struct xlat sigbus_codes[] = { 658 { BUS_ADRALN, "BUS_ADRALN" }, 659 { BUS_ADRERR, "BUS_ADRERR" }, 660 { BUS_OBJERR, "BUS_OBJERR" }, 661 { 0, NULL }, 662}; 663 664void 665printsiginfo(siginfo_t *sip, int verbose) 666{ 667 const char *code; 668 669 if (sip->si_signo == 0) { 670 tprints("{}"); 671 return; 672 } 673 tprints("{si_signo="); 674 printsignal(sip->si_signo); 675 code = xlookup(siginfo_codes, sip->si_code); 676 if (!code) { 677 switch (sip->si_signo) { 678 case SIGTRAP: 679 code = xlookup(sigtrap_codes, sip->si_code); 680 break; 681 case SIGCHLD: 682 code = xlookup(sigchld_codes, sip->si_code); 683 break; 684 case SIGPOLL: 685 code = xlookup(sigpoll_codes, sip->si_code); 686 break; 687 case SIGPROF: 688 code = xlookup(sigprof_codes, sip->si_code); 689 break; 690 case SIGILL: 691 code = xlookup(sigill_codes, sip->si_code); 692 break; 693#ifdef SIGEMT 694 case SIGEMT: 695 code = xlookup(sigemt_codes, sip->si_code); 696 break; 697#endif 698 case SIGFPE: 699 code = xlookup(sigfpe_codes, sip->si_code); 700 break; 701 case SIGSEGV: 702 code = xlookup(sigsegv_codes, sip->si_code); 703 break; 704 case SIGBUS: 705 code = xlookup(sigbus_codes, sip->si_code); 706 break; 707 } 708 } 709 if (code) 710 tprintf(", si_code=%s", code); 711 else 712 tprintf(", si_code=%#x", sip->si_code); 713#ifdef SI_NOINFO 714 if (sip->si_code != SI_NOINFO) 715#endif 716 { 717 if (sip->si_errno) { 718 if (sip->si_errno < 0 || sip->si_errno >= nerrnos) 719 tprintf(", si_errno=%d", sip->si_errno); 720 else 721 tprintf(", si_errno=%s", 722 errnoent[sip->si_errno]); 723 } 724#ifdef SI_FROMUSER 725 if (SI_FROMUSER(sip)) { 726 tprintf(", si_pid=%lu, si_uid=%lu", 727 (unsigned long) sip->si_pid, 728 (unsigned long) sip->si_uid); 729 switch (sip->si_code) { 730#ifdef SI_USER 731 case SI_USER: 732 break; 733#endif 734#ifdef SI_TKILL 735 case SI_TKILL: 736 break; 737#endif 738#ifdef SI_TIMER 739 case SI_TIMER: 740 tprintf(", si_value=%d", sip->si_int); 741 break; 742#endif 743#ifdef LINUX 744 default: 745 if (!sip->si_ptr) 746 break; 747 if (!verbose) 748 tprints(", ..."); 749 else 750 tprintf(", si_value={int=%u, ptr=%#lx}", 751 sip->si_int, 752 (unsigned long) sip->si_ptr); 753 break; 754#endif 755 } 756 } 757 else 758#endif /* SI_FROMUSER */ 759 { 760 switch (sip->si_signo) { 761 case SIGCHLD: 762 tprintf(", si_pid=%ld, si_status=", 763 (long) sip->si_pid); 764 if (sip->si_code == CLD_EXITED) 765 tprintf("%d", sip->si_status); 766 else 767 printsignal(sip->si_status); 768#if LINUX 769 if (!verbose) 770 tprints(", ..."); 771 else 772 tprintf(", si_utime=%lu, si_stime=%lu", 773 sip->si_utime, 774 sip->si_stime); 775#endif 776 break; 777 case SIGILL: case SIGFPE: 778 case SIGSEGV: case SIGBUS: 779 tprintf(", si_addr=%#lx", 780 (unsigned long) sip->si_addr); 781 break; 782 case SIGPOLL: 783 switch (sip->si_code) { 784 case POLL_IN: case POLL_OUT: case POLL_MSG: 785 tprintf(", si_band=%ld", 786 (long) sip->si_band); 787 break; 788 } 789 break; 790#ifdef LINUX 791 default: 792 if (sip->si_pid || sip->si_uid) 793 tprintf(", si_pid=%lu, si_uid=%lu", 794 (unsigned long) sip->si_pid, 795 (unsigned long) sip->si_uid); 796 if (!sip->si_ptr) 797 break; 798 if (!verbose) 799 tprints(", ..."); 800 else { 801 tprintf(", si_value={int=%u, ptr=%#lx}", 802 sip->si_int, 803 (unsigned long) sip->si_ptr); 804 } 805#endif 806 807 } 808 } 809 } 810 tprints("}"); 811} 812 813#endif /* SVR4 || LINUX */ 814 815#if defined(SUNOS4) || defined(FREEBSD) 816 817int 818sys_sigvec(struct tcb *tcp) 819{ 820 struct sigvec sv; 821 long addr; 822 823 if (entering(tcp)) { 824 printsignal(tcp->u_arg[0]); 825 tprints(", "); 826 addr = tcp->u_arg[1]; 827 } else { 828 addr = tcp->u_arg[2]; 829 } 830 if (addr == 0) 831 tprints("NULL"); 832 else if (!verbose(tcp)) 833 tprintf("%#lx", addr); 834 else if (umove(tcp, addr, &sv) < 0) 835 tprints("{...}"); 836 else { 837 switch ((int) sv.sv_handler) { 838 case (int) SIG_ERR: 839 tprints("{SIG_ERR}"); 840 break; 841 case (int) SIG_DFL: 842 tprints("{SIG_DFL}"); 843 break; 844 case (int) SIG_IGN: 845 if (tcp->u_arg[0] == SIGTRAP) { 846 tcp->flags |= TCB_SIGTRAPPED; 847 kill(tcp->pid, SIGSTOP); 848 } 849 tprints("{SIG_IGN}"); 850 break; 851 case (int) SIG_HOLD: 852 if (tcp->u_arg[0] == SIGTRAP) { 853 tcp->flags |= TCB_SIGTRAPPED; 854 kill(tcp->pid, SIGSTOP); 855 } 856 tprints("SIG_HOLD"); 857 break; 858 default: 859 if (tcp->u_arg[0] == SIGTRAP) { 860 tcp->flags |= TCB_SIGTRAPPED; 861 kill(tcp->pid, SIGSTOP); 862 } 863 tprintf("{%#lx, ", (unsigned long) sv.sv_handler); 864 printsigmask(&sv.sv_mask, 0); 865 tprints(", "); 866 printflags(sigvec_flags, sv.sv_flags, "SV_???"); 867 tprints("}"); 868 } 869 } 870 if (entering(tcp)) 871 tprints(", "); 872 return 0; 873} 874 875int 876sys_sigpause(struct tcb *tcp) 877{ 878 if (entering(tcp)) { /* WTA: UD had a bug here: he forgot the braces */ 879 sigset_t sigm; 880 long_to_sigset(tcp->u_arg[0], &sigm); 881 printsigmask(&sigm, 0); 882 } 883 return 0; 884} 885 886int 887sys_sigstack(struct tcb *tcp) 888{ 889 struct sigstack ss; 890 long addr; 891 892 if (entering(tcp)) 893 addr = tcp->u_arg[0]; 894 else 895 addr = tcp->u_arg[1]; 896 if (addr == 0) 897 tprints("NULL"); 898 else if (umove(tcp, addr, &ss) < 0) 899 tprintf("%#lx", addr); 900 else { 901 tprintf("{ss_sp %#lx ", (unsigned long) ss.ss_sp); 902 tprintf("ss_onstack %s}", ss.ss_onstack ? "YES" : "NO"); 903 } 904 if (entering(tcp)) 905 tprints(", "); 906 return 0; 907} 908 909int 910sys_sigcleanup(struct tcb *tcp) 911{ 912 return 0; 913} 914 915#endif /* SUNOS4 || FREEBSD */ 916 917#ifndef SVR4 918 919int 920sys_sigsetmask(struct tcb *tcp) 921{ 922 if (entering(tcp)) { 923 sigset_t sigm; 924 long_to_sigset(tcp->u_arg[0], &sigm); 925 printsigmask(&sigm, 0); 926#ifndef USE_PROCFS 927 if ((tcp->u_arg[0] & sigmask(SIGTRAP))) { 928 /* Mark attempt to block SIGTRAP */ 929 tcp->flags |= TCB_SIGTRAPPED; 930 /* Send unblockable signal */ 931 kill(tcp->pid, SIGSTOP); 932 } 933#endif /* !USE_PROCFS */ 934 } 935 else if (!syserror(tcp)) { 936 sigset_t sigm; 937 long_to_sigset(tcp->u_rval, &sigm); 938 tcp->auxstr = sprintsigmask("old mask ", &sigm, 0); 939 940 return RVAL_HEX | RVAL_STR; 941 } 942 return 0; 943} 944 945#if defined(SUNOS4) || defined(FREEBSD) 946int 947sys_sigblock(struct tcb *tcp) 948{ 949 return sys_sigsetmask(tcp); 950} 951#endif /* SUNOS4 || FREEBSD */ 952 953#endif /* !SVR4 */ 954 955#ifdef HAVE_SIGACTION 956 957#ifdef LINUX 958struct old_sigaction { 959 __sighandler_t __sa_handler; 960 unsigned long sa_mask; 961 unsigned long sa_flags; 962 void (*sa_restorer)(void); 963}; 964#define SA_HANDLER __sa_handler 965#endif /* LINUX */ 966 967#ifndef SA_HANDLER 968#define SA_HANDLER sa_handler 969#endif 970 971int 972sys_sigaction(struct tcb *tcp) 973{ 974 long addr; 975#ifdef LINUX 976 sigset_t sigset; 977 struct old_sigaction sa; 978#else 979 struct sigaction sa; 980#endif 981 982 983 if (entering(tcp)) { 984 printsignal(tcp->u_arg[0]); 985 tprints(", "); 986 addr = tcp->u_arg[1]; 987 } else 988 addr = tcp->u_arg[2]; 989 if (addr == 0) 990 tprints("NULL"); 991 else if (!verbose(tcp)) 992 tprintf("%#lx", addr); 993 else if (umove(tcp, addr, &sa) < 0) 994 tprints("{...}"); 995 else { 996 /* Architectures using function pointers, like 997 * hppa, may need to manipulate the function pointer 998 * to compute the result of a comparison. However, 999 * the SA_HANDLER function pointer exists only in 1000 * the address space of the traced process, and can't 1001 * be manipulated by strace. In order to prevent the 1002 * compiler from generating code to manipulate 1003 * SA_HANDLER we cast the function pointers to long. */ 1004 if ((long)sa.SA_HANDLER == (long)SIG_ERR) 1005 tprints("{SIG_ERR, "); 1006 else if ((long)sa.SA_HANDLER == (long)SIG_DFL) 1007 tprints("{SIG_DFL, "); 1008 else if ((long)sa.SA_HANDLER == (long)SIG_IGN) { 1009#ifndef USE_PROCFS 1010 if (tcp->u_arg[0] == SIGTRAP) { 1011 tcp->flags |= TCB_SIGTRAPPED; 1012 kill(tcp->pid, SIGSTOP); 1013 } 1014#endif /* !USE_PROCFS */ 1015 tprints("{SIG_IGN, "); 1016 } 1017 else { 1018#ifndef USE_PROCFS 1019 if (tcp->u_arg[0] == SIGTRAP) { 1020 tcp->flags |= TCB_SIGTRAPPED; 1021 kill(tcp->pid, SIGSTOP); 1022 } 1023#endif /* !USE_PROCFS */ 1024 tprintf("{%#lx, ", (long) sa.SA_HANDLER); 1025#ifndef LINUX 1026 printsigmask(&sa.sa_mask, 0); 1027#else 1028 long_to_sigset(sa.sa_mask, &sigset); 1029 printsigmask(&sigset, 0); 1030#endif 1031 tprints(", "); 1032 printflags(sigact_flags, sa.sa_flags, "SA_???"); 1033#ifdef SA_RESTORER 1034 if (sa.sa_flags & SA_RESTORER) 1035 tprintf(", %p", sa.sa_restorer); 1036#endif 1037 tprints("}"); 1038 } 1039 } 1040 if (entering(tcp)) 1041 tprints(", "); 1042#ifdef LINUX 1043 else 1044 tprintf(", %#lx", (unsigned long) sa.sa_restorer); 1045#endif 1046 return 0; 1047} 1048 1049int 1050sys_signal(struct tcb *tcp) 1051{ 1052 if (entering(tcp)) { 1053 printsignal(tcp->u_arg[0]); 1054 tprints(", "); 1055 switch (tcp->u_arg[1]) { 1056 case (long) SIG_ERR: 1057 tprints("SIG_ERR"); 1058 break; 1059 case (long) SIG_DFL: 1060 tprints("SIG_DFL"); 1061 break; 1062 case (long) SIG_IGN: 1063#ifndef USE_PROCFS 1064 if (tcp->u_arg[0] == SIGTRAP) { 1065 tcp->flags |= TCB_SIGTRAPPED; 1066 kill(tcp->pid, SIGSTOP); 1067 } 1068#endif /* !USE_PROCFS */ 1069 tprints("SIG_IGN"); 1070 break; 1071 default: 1072#ifndef USE_PROCFS 1073 if (tcp->u_arg[0] == SIGTRAP) { 1074 tcp->flags |= TCB_SIGTRAPPED; 1075 kill(tcp->pid, SIGSTOP); 1076 } 1077#endif /* !USE_PROCFS */ 1078 tprintf("%#lx", tcp->u_arg[1]); 1079 } 1080 return 0; 1081 } 1082 else if (!syserror(tcp)) { 1083 switch (tcp->u_rval) { 1084 case (long) SIG_ERR: 1085 tcp->auxstr = "SIG_ERR"; break; 1086 case (long) SIG_DFL: 1087 tcp->auxstr = "SIG_DFL"; break; 1088 case (long) SIG_IGN: 1089 tcp->auxstr = "SIG_IGN"; break; 1090 default: 1091 tcp->auxstr = NULL; 1092 } 1093 return RVAL_HEX | RVAL_STR; 1094 } 1095 return 0; 1096} 1097 1098#ifdef SVR4 1099int 1100sys_sighold(struct tcb *tcp) 1101{ 1102 if (entering(tcp)) { 1103 printsignal(tcp->u_arg[0]); 1104 } 1105 return 0; 1106} 1107#endif /* SVR4 */ 1108 1109#endif /* HAVE_SIGACTION */ 1110 1111#ifdef LINUX 1112 1113int 1114sys_sigreturn(struct tcb *tcp) 1115{ 1116#if defined(ARM) 1117 if (entering(tcp)) { 1118 struct pt_regs regs; 1119 struct sigcontext_struct sc; 1120 tcp->u_arg[0] = 0; 1121 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (void *)®s) == -1) 1122 return 0; 1123 if (umove(tcp, regs.ARM_sp, &sc) < 0) 1124 return 0; 1125 tcp->u_arg[0] = 1; 1126 tcp->u_arg[1] = sc.oldmask; 1127 } else { 1128 sigset_t sigm; 1129 tcp->u_rval = tcp->u_error = 0; 1130 if (tcp->u_arg[0] == 0) 1131 return 0; 1132 long_to_sigset(tcp->u_arg[1], &sigm); 1133 tcp->auxstr = sprintsigmask("mask now ", &sigm, 0); 1134 return RVAL_NONE | RVAL_STR; 1135 } 1136 return 0; 1137#elif defined(S390) || defined(S390X) 1138 if (entering(tcp)) { 1139 long usp; 1140 struct sigcontext_struct sc; 1141 tcp->u_arg[0] = 0; 1142 if (upeek(tcp, PT_GPR15, &usp) < 0) 1143 return 0; 1144 if (umove(tcp, usp+__SIGNAL_FRAMESIZE, &sc) < 0) 1145 return 0; 1146 tcp->u_arg[0] = 1; 1147 memcpy(&tcp->u_arg[1], &sc.oldmask[0], NSIG / 8); 1148 } else { 1149 tcp->u_rval = tcp->u_error = 0; 1150 if (tcp->u_arg[0] == 0) 1151 return 0; 1152 tcp->auxstr = sprintsigmask("mask now ", (sigset_t *)&tcp->u_arg[1], 0); 1153 return RVAL_NONE | RVAL_STR; 1154 } 1155 return 0; 1156#elif defined(I386) 1157 if (entering(tcp)) { 1158 long esp; 1159 struct sigcontext_struct sc; 1160 tcp->u_arg[0] = 0; 1161 if (upeek(tcp, 4*UESP, &esp) < 0) 1162 return 0; 1163 if (umove(tcp, esp, &sc) < 0) 1164 return 0; 1165 tcp->u_arg[0] = 1; 1166 tcp->u_arg[1] = sc.oldmask; 1167 } 1168 else { 1169 sigset_t sigm; 1170 tcp->u_rval = tcp->u_error = 0; 1171 if (tcp->u_arg[0] == 0) 1172 return 0; 1173 long_to_sigset(tcp->u_arg[1], &sigm); 1174 tcp->auxstr = sprintsigmask("mask now ", &sigm, 0); 1175 return RVAL_NONE | RVAL_STR; 1176 } 1177 return 0; 1178#elif defined(IA64) 1179 if (entering(tcp)) { 1180 struct sigcontext sc; 1181 long sp; 1182 /* offset of sigcontext in the kernel's sigframe structure: */ 1183# define SIGFRAME_SC_OFFSET 0x90 1184 tcp->u_arg[0] = 0; 1185 if (upeek(tcp, PT_R12, &sp) < 0) 1186 return 0; 1187 if (umove(tcp, sp + 16 + SIGFRAME_SC_OFFSET, &sc) < 0) 1188 return 0; 1189 tcp->u_arg[0] = 1; 1190 memcpy(tcp->u_arg + 1, &sc.sc_mask, NSIG / 8); 1191 } 1192 else { 1193 sigset_t sigm; 1194 tcp->u_rval = tcp->u_error = 0; 1195 if (tcp->u_arg[0] == 0) 1196 return 0; 1197 sigemptyset(&sigm); 1198 memcpy(&sigm, tcp->u_arg + 1, NSIG / 8); 1199 tcp->auxstr = sprintsigmask("mask now ", &sigm, 0); 1200 return RVAL_NONE | RVAL_STR; 1201 } 1202 return 0; 1203#elif defined(POWERPC) 1204 if (entering(tcp)) { 1205 long esp; 1206 struct sigcontext_struct sc; 1207 tcp->u_arg[0] = 0; 1208 if (upeek(tcp, sizeof(unsigned long)*PT_R1, &esp) < 0) 1209 return 0; 1210 /* Skip dummy stack frame. */ 1211#ifdef POWERPC64 1212 if (current_personality == 0) 1213 esp += 128; 1214 else 1215 esp += 64; 1216#else 1217 esp += 64; 1218#endif 1219 if (umove(tcp, esp, &sc) < 0) 1220 return 0; 1221 tcp->u_arg[0] = 1; 1222 tcp->u_arg[1] = sc.oldmask; 1223 } 1224 else { 1225 sigset_t sigm; 1226 tcp->u_rval = tcp->u_error = 0; 1227 if (tcp->u_arg[0] == 0) 1228 return 0; 1229 long_to_sigset(tcp->u_arg[1], &sigm); 1230 tcp->auxstr = sprintsigmask("mask now ", &sigm, 0); 1231 return RVAL_NONE | RVAL_STR; 1232 } 1233 return 0; 1234#elif defined(M68K) 1235 if (entering(tcp)) { 1236 long usp; 1237 struct sigcontext sc; 1238 tcp->u_arg[0] = 0; 1239 if (upeek(tcp, 4*PT_USP, &usp) < 0) 1240 return 0; 1241 if (umove(tcp, usp, &sc) < 0) 1242 return 0; 1243 tcp->u_arg[0] = 1; 1244 tcp->u_arg[1] = sc.sc_mask; 1245 } 1246 else { 1247 sigset_t sigm; 1248 tcp->u_rval = tcp->u_error = 0; 1249 if (tcp->u_arg[0] == 0) 1250 return 0; 1251 long_to_sigset(tcp->u_arg[1], &sigm); 1252 tcp->auxstr = sprintsigmask("mask now ", &sigm, 0); 1253 return RVAL_NONE | RVAL_STR; 1254 } 1255 return 0; 1256#elif defined(ALPHA) 1257 if (entering(tcp)) { 1258 long fp; 1259 struct sigcontext_struct sc; 1260 tcp->u_arg[0] = 0; 1261 if (upeek(tcp, REG_FP, &fp) < 0) 1262 return 0; 1263 if (umove(tcp, fp, &sc) < 0) 1264 return 0; 1265 tcp->u_arg[0] = 1; 1266 tcp->u_arg[1] = sc.sc_mask; 1267 } 1268 else { 1269 sigset_t sigm; 1270 tcp->u_rval = tcp->u_error = 0; 1271 if (tcp->u_arg[0] == 0) 1272 return 0; 1273 long_to_sigset(tcp->u_arg[1], &sigm); 1274 tcp->auxstr = sprintsigmask("mask now ", &sigm, 0); 1275 return RVAL_NONE | RVAL_STR; 1276 } 1277 return 0; 1278#elif defined (SPARC) || defined (SPARC64) 1279 if (entering(tcp)) { 1280 long i1; 1281 struct pt_regs regs; 1282 m_siginfo_t si; 1283 tcp->u_arg[0] = 0; 1284 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) { 1285 perror("sigreturn: PTRACE_GETREGS"); 1286 return 0; 1287 } 1288 i1 = regs.u_regs[U_REG_O1]; 1289 if (umove(tcp, i1, &si) < 0) { 1290 perror("sigreturn: umove"); 1291 return 0; 1292 } 1293 tcp->u_arg[0] = 1; 1294 tcp->u_arg[1] = si.si_mask; 1295 } else { 1296 sigset_t sigm; 1297 tcp->u_rval = tcp->u_error = 0; 1298 if (tcp->u_arg[0] == 0) 1299 return 0; 1300 long_to_sigset(tcp->u_arg[1], &sigm); 1301 tcp->auxstr = sprintsigmask("mask now ", &sigm, 0); 1302 return RVAL_NONE | RVAL_STR; 1303 } 1304 return 0; 1305#elif defined (LINUX_MIPSN32) || defined (LINUX_MIPSN64) 1306 /* This decodes rt_sigreturn. The 64-bit ABIs do not have 1307 sigreturn. */ 1308 if (entering(tcp)) { 1309 long sp; 1310 struct ucontext uc; 1311 tcp->u_arg[0] = 0; 1312 if (upeek(tcp, REG_SP, &sp) < 0) 1313 return 0; 1314 /* There are six words followed by a 128-byte siginfo. */ 1315 sp = sp + 6 * 4 + 128; 1316 if (umove(tcp, sp, &uc) < 0) 1317 return 0; 1318 tcp->u_arg[0] = 1; 1319 tcp->u_arg[1] = *(long *) &uc.uc_sigmask; 1320 } else { 1321 sigset_t sigm; 1322 tcp->u_rval = tcp->u_error = 0; 1323 if (tcp->u_arg[0] == 0) 1324 return 0; 1325 long_to_sigset(tcp->u_arg[1], &sigm); 1326 tcp->auxstr = sprintsigmask("mask now ", &sigm, 0); 1327 return RVAL_NONE | RVAL_STR; 1328 } 1329 return 0; 1330#elif defined(MIPS) 1331 if (entering(tcp)) { 1332 long sp; 1333 struct pt_regs regs; 1334 m_siginfo_t si; 1335 tcp->u_arg[0] = 0; 1336 if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) { 1337 perror("sigreturn: PTRACE_GETREGS"); 1338 return 0; 1339 } 1340 sp = regs.regs[29]; 1341 if (umove(tcp, sp, &si) < 0) 1342 return 0; 1343 tcp->u_arg[0] = 1; 1344 tcp->u_arg[1] = si.si_mask; 1345 } else { 1346 sigset_t sigm; 1347 tcp->u_rval = tcp->u_error = 0; 1348 if (tcp->u_arg[0] == 0) 1349 return 0; 1350 long_to_sigset(tcp->u_arg[1], &sigm); 1351 tcp->auxstr = sprintsigmask("mask now ", &sigm, 0); 1352 return RVAL_NONE | RVAL_STR; 1353 } 1354 return 0; 1355#elif defined(CRISV10) || defined(CRISV32) 1356 if (entering(tcp)) { 1357 struct sigcontext sc; 1358 long regs[PT_MAX+1]; 1359 tcp->u_arg[0] = 0; 1360 if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long)regs) < 0) { 1361 perror("sigreturn: PTRACE_GETREGS"); 1362 return 0; 1363 } 1364 if (umove(tcp, regs[PT_USP], &sc) < 0) 1365 return 0; 1366 tcp->u_arg[0] = 1; 1367 tcp->u_arg[1] = sc.oldmask; 1368 } else { 1369 sigset_t sigm; 1370 tcp->u_rval = tcp->u_error = 0; 1371 if (tcp->u_arg[0] == 0) 1372 return 0; 1373 long_to_sigset(tcp->u_arg[1], &sigm); 1374 tcp->auxstr = sprintsigmask("mask now ", &sigm, 0); 1375 return RVAL_NONE | RVAL_STR; 1376 } 1377 return 0; 1378#elif defined(TILE) 1379 if (entering(tcp)) { 1380 struct ucontext uc; 1381 long sp; 1382 1383 /* offset of ucontext in the kernel's sigframe structure */ 1384# define SIGFRAME_UC_OFFSET C_ABI_SAVE_AREA_SIZE + sizeof(struct siginfo) 1385 tcp->u_arg[0] = 0; 1386 if (upeek(tcp, PTREGS_OFFSET_SP, &sp) < 0) 1387 return 0; 1388 if (umove(tcp, sp + SIGFRAME_UC_OFFSET, &uc) < 0) 1389 return 0; 1390 tcp->u_arg[0] = 1; 1391 memcpy(tcp->u_arg + 1, &uc.uc_sigmask, NSIG / 8); 1392 } 1393 else { 1394 sigset_t sigm; 1395 tcp->u_rval = tcp->u_error = 0; 1396 if (tcp->u_arg[0] == 0) 1397 return 0; 1398 sigemptyset(&sigm); 1399 memcpy(&sigm, tcp->u_arg + 1, NSIG / 8); 1400 tcp->auxstr = sprintsigmask("mask now ", &sigm, 0); 1401 return RVAL_NONE | RVAL_STR; 1402 } 1403 return 0; 1404#elif defined(MICROBLAZE) 1405 /* TODO: Verify that this is correct... */ 1406 if (entering(tcp)) { 1407 struct sigcontext sc; 1408 long sp; 1409 tcp->u_arg[0] = 0; 1410 /* Read r1, the stack pointer. */ 1411 if (upeek(tcp, 1 * 4, &sp) < 0) 1412 return 0; 1413 if (umove(tcp, sp, &sc) < 0) 1414 return 0; 1415 tcp->u_arg[0] = 1; 1416 tcp->u_arg[1] = sc.oldmask; 1417 } else { 1418 sigset_t sigm; 1419 tcp->u_rval = tcp->u_error = 0; 1420 if (tcp->u_arg[0] == 0) 1421 return 0; 1422 long_to_sigset(tcp->u_arg[1], &sigm); 1423 tcp->auxstr = sprintsigmask("mask now ", &sigm, 0); 1424 return RVAL_NONE | RVAL_STR; 1425 } 1426 return 0; 1427#else 1428#warning No sys_sigreturn() for this architecture 1429#warning (no problem, just a reminder :-) 1430 return 0; 1431#endif 1432} 1433 1434int 1435sys_siggetmask(struct tcb *tcp) 1436{ 1437 if (exiting(tcp)) { 1438 sigset_t sigm; 1439 long_to_sigset(tcp->u_rval, &sigm); 1440 tcp->auxstr = sprintsigmask("mask ", &sigm, 0); 1441 } 1442 return RVAL_HEX | RVAL_STR; 1443} 1444 1445int 1446sys_sigsuspend(struct tcb *tcp) 1447{ 1448 if (entering(tcp)) { 1449 sigset_t sigm; 1450 long_to_sigset(tcp->u_arg[2], &sigm); 1451 printsigmask(&sigm, 0); 1452 } 1453 return 0; 1454} 1455 1456#endif /* LINUX */ 1457 1458#if defined(SVR4) || defined(FREEBSD) 1459 1460int 1461sys_sigsuspend(struct tcb *tcp) 1462{ 1463 sigset_t sigset; 1464 1465 if (entering(tcp)) { 1466 if (umove(tcp, tcp->u_arg[0], &sigset) < 0) 1467 tprints("[?]"); 1468 else 1469 printsigmask(&sigset, 0); 1470 } 1471 return 0; 1472} 1473#ifndef FREEBSD 1474static const struct xlat ucontext_flags[] = { 1475 { UC_SIGMASK, "UC_SIGMASK" }, 1476 { UC_STACK, "UC_STACK" }, 1477 { UC_CPU, "UC_CPU" }, 1478#ifdef UC_FPU 1479 { UC_FPU, "UC_FPU" }, 1480#endif 1481#ifdef UC_INTR 1482 { UC_INTR, "UC_INTR" }, 1483#endif 1484 { 0, NULL }, 1485}; 1486#endif /* !FREEBSD */ 1487#endif /* SVR4 || FREEBSD */ 1488 1489#if defined SVR4 || defined LINUX || defined FREEBSD 1490#if defined LINUX && !defined SS_ONSTACK 1491#define SS_ONSTACK 1 1492#define SS_DISABLE 2 1493#if __GLIBC_MINOR__ == 0 1494typedef struct 1495{ 1496 __ptr_t ss_sp; 1497 int ss_flags; 1498 size_t ss_size; 1499} stack_t; 1500#endif 1501#endif 1502#ifdef FREEBSD 1503#define stack_t struct sigaltstack 1504#endif 1505 1506static const struct xlat sigaltstack_flags[] = { 1507 { SS_ONSTACK, "SS_ONSTACK" }, 1508 { SS_DISABLE, "SS_DISABLE" }, 1509 { 0, NULL }, 1510}; 1511#endif 1512 1513#ifdef SVR4 1514static void 1515printcontext(struct tcb *tcp, ucontext_t *ucp) 1516{ 1517 tprints("{"); 1518 if (!abbrev(tcp)) { 1519 tprints("uc_flags="); 1520 printflags(ucontext_flags, ucp->uc_flags, "UC_???"); 1521 tprintf(", uc_link=%#lx, ", (unsigned long) ucp->uc_link); 1522 } 1523 tprints("uc_sigmask="); 1524 printsigmask(&ucp->uc_sigmask, 0); 1525 if (!abbrev(tcp)) { 1526 tprintf(", uc_stack={ss_sp=%#lx, ss_size=%d, ss_flags=", 1527 (unsigned long) ucp->uc_stack.ss_sp, 1528 ucp->uc_stack.ss_size); 1529 printflags(sigaltstack_flags, ucp->uc_stack.ss_flags, "SS_???"); 1530 tprints("}"); 1531 } 1532 tprints(", ...}"); 1533} 1534 1535int 1536sys_getcontext(struct tcb *tcp) 1537{ 1538 ucontext_t uc; 1539 1540 if (exiting(tcp)) { 1541 if (tcp->u_error) 1542 tprintf("%#lx", tcp->u_arg[0]); 1543 else if (!tcp->u_arg[0]) 1544 tprints("NULL"); 1545 else if (umove(tcp, tcp->u_arg[0], &uc) < 0) 1546 tprints("{...}"); 1547 else 1548 printcontext(tcp, &uc); 1549 } 1550 return 0; 1551} 1552 1553int 1554sys_setcontext(struct tcb *tcp) 1555{ 1556 ucontext_t uc; 1557 1558 if (entering(tcp)) { 1559 if (!tcp->u_arg[0]) 1560 tprints("NULL"); 1561 else if (umove(tcp, tcp->u_arg[0], &uc) < 0) 1562 tprints("{...}"); 1563 else 1564 printcontext(tcp, &uc); 1565 } 1566 else { 1567 tcp->u_rval = tcp->u_error = 0; 1568 if (tcp->u_arg[0] == 0) 1569 return 0; 1570 return RVAL_NONE; 1571 } 1572 return 0; 1573} 1574 1575#endif /* SVR4 */ 1576 1577#if defined(LINUX) || defined(FREEBSD) 1578 1579static int 1580print_stack_t(struct tcb *tcp, unsigned long addr) 1581{ 1582 stack_t ss; 1583 if (umove(tcp, addr, &ss) < 0) 1584 return -1; 1585 tprintf("{ss_sp=%#lx, ss_flags=", (unsigned long) ss.ss_sp); 1586 printflags(sigaltstack_flags, ss.ss_flags, "SS_???"); 1587 tprintf(", ss_size=%lu}", (unsigned long) ss.ss_size); 1588 return 0; 1589} 1590 1591int 1592sys_sigaltstack(struct tcb *tcp) 1593{ 1594 if (entering(tcp)) { 1595 if (tcp->u_arg[0] == 0) 1596 tprints("NULL"); 1597 else if (print_stack_t(tcp, tcp->u_arg[0]) < 0) 1598 return -1; 1599 } 1600 else { 1601 tprints(", "); 1602 if (tcp->u_arg[1] == 0) 1603 tprints("NULL"); 1604 else if (print_stack_t(tcp, tcp->u_arg[1]) < 0) 1605 return -1; 1606 } 1607 return 0; 1608} 1609#endif 1610 1611#ifdef HAVE_SIGACTION 1612 1613int 1614sys_sigprocmask(struct tcb *tcp) 1615{ 1616#ifdef ALPHA 1617 if (entering(tcp)) { 1618 printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???"); 1619 tprints(", "); 1620 printsigmask(tcp->u_arg[1], 0); 1621 } 1622 else if (!syserror(tcp)) { 1623 tcp->auxstr = sprintsigmask("old mask ", tcp->u_rval, 0); 1624 return RVAL_HEX | RVAL_STR; 1625 } 1626#else /* !ALPHA */ 1627 if (entering(tcp)) { 1628#ifdef SVR4 1629 if (tcp->u_arg[0] == 0) 1630 tprints("0"); 1631 else 1632#endif /* SVR4 */ 1633 printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???"); 1634 tprints(", "); 1635 print_sigset(tcp, tcp->u_arg[1], 0); 1636 tprints(", "); 1637 } 1638 else { 1639 if (!tcp->u_arg[2]) 1640 tprints("NULL"); 1641 else if (syserror(tcp)) 1642 tprintf("%#lx", tcp->u_arg[2]); 1643 else 1644 print_sigset(tcp, tcp->u_arg[2], 0); 1645 } 1646#endif /* !ALPHA */ 1647 return 0; 1648} 1649 1650#endif /* HAVE_SIGACTION */ 1651 1652int 1653sys_kill(struct tcb *tcp) 1654{ 1655 if (entering(tcp)) { 1656 long pid = tcp->u_arg[0]; 1657#if SUPPORTED_PERSONALITIES > 1 1658 /* Sign-extend a 32-bit value when that's what it is. */ 1659 if (personality_wordsize[current_personality] < sizeof pid) 1660 pid = (long) (int) pid; 1661#endif 1662 tprintf("%ld, %s", pid, signame(tcp->u_arg[1])); 1663 } 1664 return 0; 1665} 1666 1667#if defined(FREEBSD) || defined(SUNOS4) 1668int 1669sys_killpg(struct tcb *tcp) 1670{ 1671 return sys_kill(tcp); 1672} 1673#endif /* FREEBSD || SUNOS4 */ 1674 1675#ifdef LINUX 1676int 1677sys_tgkill(struct tcb *tcp) 1678{ 1679 if (entering(tcp)) { 1680 tprintf("%ld, %ld, %s", 1681 tcp->u_arg[0], tcp->u_arg[1], signame(tcp->u_arg[2])); 1682 } 1683 return 0; 1684} 1685#endif 1686 1687int 1688sys_sigpending(struct tcb *tcp) 1689{ 1690 sigset_t sigset; 1691 1692 if (exiting(tcp)) { 1693 if (syserror(tcp)) 1694 tprintf("%#lx", tcp->u_arg[0]); 1695 else if (copy_sigset(tcp, tcp->u_arg[0], &sigset) < 0) 1696 tprints("[?]"); 1697 else 1698 printsigmask(&sigset, 0); 1699 } 1700 return 0; 1701} 1702 1703#ifdef SVR4 1704int sys_sigwait(struct tcb *tcp) 1705{ 1706 sigset_t sigset; 1707 1708 if (entering(tcp)) { 1709 if (copy_sigset(tcp, tcp->u_arg[0], &sigset) < 0) 1710 tprints("[?]"); 1711 else 1712 printsigmask(&sigset, 0); 1713 } 1714 else { 1715 if (!syserror(tcp)) { 1716 tcp->auxstr = signalent[tcp->u_rval]; 1717 return RVAL_DECIMAL | RVAL_STR; 1718 } 1719 } 1720 return 0; 1721} 1722#endif /* SVR4 */ 1723 1724#ifdef LINUX 1725 1726int 1727sys_rt_sigprocmask(struct tcb *tcp) 1728{ 1729 sigset_t sigset; 1730 1731 /* Note: arg[3] is the length of the sigset. */ 1732 if (entering(tcp)) { 1733 printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???"); 1734 tprints(", "); 1735 if (!tcp->u_arg[1]) 1736 tprints("NULL, "); 1737 else if (copy_sigset_len(tcp, tcp->u_arg[1], &sigset, tcp->u_arg[3]) < 0) 1738 tprintf("%#lx, ", tcp->u_arg[1]); 1739 else { 1740 printsigmask(&sigset, 1); 1741 tprints(", "); 1742 } 1743 } 1744 else { 1745 if (!tcp->u_arg[2]) 1746 tprints("NULL"); 1747 else if (syserror(tcp)) 1748 tprintf("%#lx", tcp->u_arg[2]); 1749 else if (copy_sigset_len(tcp, tcp->u_arg[2], &sigset, tcp->u_arg[3]) < 0) 1750 tprints("[?]"); 1751 else 1752 printsigmask(&sigset, 1); 1753 tprintf(", %lu", tcp->u_arg[3]); 1754 } 1755 return 0; 1756} 1757 1758 1759/* Structure describing the action to be taken when a signal arrives. */ 1760struct new_sigaction 1761{ 1762 __sighandler_t __sa_handler; 1763 unsigned long sa_flags; 1764 void (*sa_restorer) (void); 1765 /* Kernel treats sa_mask as an array of longs. */ 1766 unsigned long sa_mask[NSIG / sizeof(long) ? NSIG / sizeof(long) : 1]; 1767}; 1768/* Same for i386-on-x86_64 and similar cases */ 1769struct new_sigaction32 1770{ 1771 uint32_t __sa_handler; 1772 uint32_t sa_flags; 1773 uint32_t sa_restorer; 1774 uint32_t sa_mask[2 * (NSIG / sizeof(long) ? NSIG / sizeof(long) : 1)]; 1775}; 1776 1777 1778int 1779sys_rt_sigaction(struct tcb *tcp) 1780{ 1781 struct new_sigaction sa; 1782 sigset_t sigset; 1783 long addr; 1784 int r; 1785 1786 if (entering(tcp)) { 1787 printsignal(tcp->u_arg[0]); 1788 tprints(", "); 1789 addr = tcp->u_arg[1]; 1790 } else 1791 addr = tcp->u_arg[2]; 1792 1793 if (addr == 0) { 1794 tprints("NULL"); 1795 goto after_sa; 1796 } 1797 if (!verbose(tcp)) { 1798 tprintf("%#lx", addr); 1799 goto after_sa; 1800 } 1801#if SUPPORTED_PERSONALITIES > 1 1802 if (personality_wordsize[current_personality] != sizeof(sa.sa_flags) 1803 && personality_wordsize[current_personality] == 4 1804 ) { 1805 struct new_sigaction32 sa32; 1806 r = umove(tcp, addr, &sa32); 1807 if (r >= 0) { 1808 memset(&sa, 0, sizeof(sa)); 1809 sa.__sa_handler = (void*)(unsigned long)sa32.__sa_handler; 1810 sa.sa_flags = sa32.sa_flags; 1811 sa.sa_restorer = (void*)(unsigned long)sa32.sa_restorer; 1812 /* Kernel treats sa_mask as an array of longs. 1813 * For 32-bit process, "long" is uint32_t, thus, for example, 1814 * 32th bit in sa_mask will end up as bit 0 in sa_mask[1]. 1815 * But for (64-bit) kernel, 32th bit in sa_mask is 1816 * 32th bit in 0th (64-bit) long! 1817 * For little-endian, it's the same. 1818 * For big-endian, we swap 32-bit words. 1819 */ 1820 sa.sa_mask[0] = sa32.sa_mask[0] + ((long)(sa32.sa_mask[1]) << 32); 1821 } 1822 } else 1823#endif 1824 { 1825 r = umove(tcp, addr, &sa); 1826 } 1827 if (r < 0) { 1828 tprints("{...}"); 1829 goto after_sa; 1830 } 1831 /* Architectures using function pointers, like 1832 * hppa, may need to manipulate the function pointer 1833 * to compute the result of a comparison. However, 1834 * the SA_HANDLER function pointer exists only in 1835 * the address space of the traced process, and can't 1836 * be manipulated by strace. In order to prevent the 1837 * compiler from generating code to manipulate 1838 * SA_HANDLER we cast the function pointers to long. */ 1839 if ((long)sa.__sa_handler == (long)SIG_ERR) 1840 tprints("{SIG_ERR, "); 1841 else if ((long)sa.__sa_handler == (long)SIG_DFL) 1842 tprints("{SIG_DFL, "); 1843 else if ((long)sa.__sa_handler == (long)SIG_IGN) 1844 tprints("{SIG_IGN, "); 1845 else 1846 tprintf("{%#lx, ", (long) sa.__sa_handler); 1847 /* Questionable code below. 1848 * Kernel won't handle sys_rt_sigaction 1849 * with wrong sigset size (just returns EINVAL) 1850 * therefore tcp->u_arg[3(4)] _must_ be NSIG / 8 here, 1851 * and we always use smaller memcpy. */ 1852 sigemptyset(&sigset); 1853#ifdef LINUXSPARC 1854 if (tcp->u_arg[4] <= sizeof(sigset)) 1855 memcpy(&sigset, &sa.sa_mask, tcp->u_arg[4]); 1856#else 1857 if (tcp->u_arg[3] <= sizeof(sigset)) 1858 memcpy(&sigset, &sa.sa_mask, tcp->u_arg[3]); 1859#endif 1860 else 1861 memcpy(&sigset, &sa.sa_mask, sizeof(sigset)); 1862 printsigmask(&sigset, 1); 1863 tprints(", "); 1864 printflags(sigact_flags, sa.sa_flags, "SA_???"); 1865#ifdef SA_RESTORER 1866 if (sa.sa_flags & SA_RESTORER) 1867 tprintf(", %p", sa.sa_restorer); 1868#endif 1869 tprints("}"); 1870 1871 after_sa: 1872 if (entering(tcp)) 1873 tprints(", "); 1874 else 1875#ifdef LINUXSPARC 1876 tprintf(", %#lx, %lu", tcp->u_arg[3], tcp->u_arg[4]); 1877#elif defined(ALPHA) 1878 tprintf(", %lu, %#lx", tcp->u_arg[3], tcp->u_arg[4]); 1879#else 1880 tprintf(", %lu", tcp->u_arg[3]); 1881#endif 1882 return 0; 1883} 1884 1885int 1886sys_rt_sigpending(struct tcb *tcp) 1887{ 1888 sigset_t sigset; 1889 1890 if (exiting(tcp)) { 1891 if (syserror(tcp)) 1892 tprintf("%#lx", tcp->u_arg[0]); 1893 else if (copy_sigset_len(tcp, tcp->u_arg[0], 1894 &sigset, tcp->u_arg[1]) < 0) 1895 tprints("[?]"); 1896 else 1897 printsigmask(&sigset, 1); 1898 } 1899 return 0; 1900} 1901 1902int 1903sys_rt_sigsuspend(struct tcb *tcp) 1904{ 1905 if (entering(tcp)) { 1906 sigset_t sigm; 1907 if (copy_sigset_len(tcp, tcp->u_arg[0], &sigm, tcp->u_arg[1]) < 0) 1908 tprints("[?]"); 1909 else 1910 printsigmask(&sigm, 1); 1911 } 1912 return 0; 1913} 1914 1915int 1916sys_rt_sigqueueinfo(struct tcb *tcp) 1917{ 1918 if (entering(tcp)) { 1919 siginfo_t si; 1920 tprintf("%lu, ", tcp->u_arg[0]); 1921 printsignal(tcp->u_arg[1]); 1922 tprints(", "); 1923 if (umove(tcp, tcp->u_arg[2], &si) < 0) 1924 tprintf("%#lx", tcp->u_arg[2]); 1925 else 1926 printsiginfo(&si, verbose(tcp)); 1927 } 1928 return 0; 1929} 1930 1931int sys_rt_sigtimedwait(struct tcb *tcp) 1932{ 1933 if (entering(tcp)) { 1934 sigset_t sigset; 1935 1936 if (copy_sigset_len(tcp, tcp->u_arg[0], 1937 &sigset, tcp->u_arg[3]) < 0) 1938 tprints("[?]"); 1939 else 1940 printsigmask(&sigset, 1); 1941 tprints(", "); 1942 /* This is the only "return" parameter, */ 1943 if (tcp->u_arg[1] != 0) 1944 return 0; 1945 /* ... if it's NULL, can decode all on entry */ 1946 tprints("NULL, "); 1947 } 1948 else if (tcp->u_arg[1] != 0) { 1949 /* syscall exit, and u_arg[1] wasn't NULL */ 1950 if (syserror(tcp)) 1951 tprintf("%#lx, ", tcp->u_arg[1]); 1952 else { 1953 siginfo_t si; 1954 if (umove(tcp, tcp->u_arg[1], &si) < 0) 1955 tprintf("%#lx, ", tcp->u_arg[1]); 1956 else { 1957 printsiginfo(&si, verbose(tcp)); 1958 tprints(", "); 1959 } 1960 } 1961 } 1962 else { 1963 /* syscall exit, and u_arg[1] was NULL */ 1964 return 0; 1965 } 1966 print_timespec(tcp, tcp->u_arg[2]); 1967 tprintf(", %d", (int) tcp->u_arg[3]); 1968 return 0; 1969}; 1970 1971int 1972sys_restart_syscall(struct tcb *tcp) 1973{ 1974 if (entering(tcp)) 1975 tprints("<... resuming interrupted call ...>"); 1976 return 0; 1977} 1978 1979static int 1980do_signalfd(struct tcb *tcp, int flags_arg) 1981{ 1982 if (entering(tcp)) { 1983 printfd(tcp, tcp->u_arg[0]); 1984 tprints(", "); 1985 print_sigset(tcp, tcp->u_arg[1], 1); 1986 tprintf(", %lu", tcp->u_arg[2]); 1987 if (flags_arg >= 0) { 1988 tprints(", "); 1989 printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???"); 1990 } 1991 } 1992 return 0; 1993} 1994 1995int 1996sys_signalfd(struct tcb *tcp) 1997{ 1998 return do_signalfd(tcp, -1); 1999} 2000 2001int 2002sys_signalfd4(struct tcb *tcp) 2003{ 2004 return do_signalfd(tcp, 3); 2005} 2006#endif /* LINUX */ 2007