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>
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
38 # warning NSIG is not defined, using 32
44 /* The libc headers do not define this constant since it should only be
45 used by the implementation. So we define it here. */
47 # ifdef ASM_SA_RESTORER
48 # define SA_RESTORER ASM_SA_RESTORER
53 * Some architectures define SA_RESTORER in their headers,
54 * but do not actually have sa_restorer.
56 * Some architectures, otherwise, do not define SA_RESTORER in their headers,
57 * but actually have sa_restorer.
60 # if defined HPPA || defined IA64
61 # define HAVE_SA_RESTORER 0
63 # define HAVE_SA_RESTORER 1
65 #else /* !SA_RESTORER */
66 # if defined SPARC || defined SPARC64 || defined M68K
67 # define HAVE_SA_RESTORER 1
69 # define HAVE_SA_RESTORER 0
73 #include "xlat/sigact_flags.h"
74 #include "xlat/sigprocmaskcmds.h"
76 /* Anonymous realtime signals. */
78 /* Linux kernel >= 3.18 defines SIGRTMIN to 32 on all architectures. */
79 # define ASM_SIGRTMIN 32
82 /* Under glibc 2.1, SIGRTMAX et al are functions, but __SIGRTMAX is a
83 constant. This is what we want. Otherwise, just use SIGRTMAX. */
86 # define __SIGRTMAX SIGRTMAX
90 # define ASM_SIGRTMAX __SIGRTMAX
94 /* Note on the size of sigset_t:
96 * In glibc, sigset_t is an array with space for 1024 bits (!),
97 * even though all arches supported by Linux have only 64 signals
98 * except MIPS, which has 128. IOW, it is 128 bytes long.
100 * In-kernel sigset_t is sized correctly (it is either 64 or 128 bit long).
101 * However, some old syscall return only 32 lower bits (one word).
102 * Example: sys_sigpending vs sys_rt_sigpending.
104 * Be aware of this fact when you try to
105 * memcpy(&tcp->u_arg[1], &something, sizeof(sigset_t))
106 * - sizeof(sigset_t) is much bigger than you think,
107 * it may overflow tcp->u_arg[] array, and it may try to copy more data
108 * than is really available in <something>.
110 * umoven(tcp, addr, sizeof(sigset_t), &sigset)
111 * may be a bad idea: it'll try to read much more data than needed
112 * to fetch a sigset_t.
113 * Use (NSIG / 8) as a size instead.
117 signame(const int sig)
119 static char buf[sizeof("SIGRT_%u") + sizeof(int)*3];
122 const unsigned int s = sig;
127 if (s >= ASM_SIGRTMIN && s <= (unsigned int) ASM_SIGRTMAX) {
128 sprintf(buf, "SIGRT_%u", s - ASM_SIGRTMIN);
133 sprintf(buf, "%d", sig);
138 popcount32(const uint32_t *a, unsigned int size)
140 unsigned int count = 0;
142 for (; size; ++a, --size) {
145 #ifdef HAVE___BUILTIN_POPCOUNT
146 count += __builtin_popcount(x);
157 sprintsigmask_n(const char *prefix, const void *sig_mask, unsigned int bytes)
160 * The maximum number of signal names to be printed is NSIG * 2 / 3.
161 * Most of signal names have length 7,
162 * average length of signal names is less than 7.
163 * The length of prefix string does not exceed 16.
165 static char outstr[128 + 8 * (NSIG * 2 / 3)];
168 const uint32_t *mask;
169 uint32_t inverted_mask[NSIG / 32];
174 s = stpcpy(outstr, prefix);
177 /* length of signal mask in 4-byte words */
178 size = (bytes >= NSIG / 8) ? NSIG / 32 : (bytes + 3) / 4;
180 /* check whether 2/3 or more bits are set */
181 if (popcount32(mask, size) >= size * 32 * 2 / 3) {
182 /* show those signals that are NOT in the mask */
184 for (j = 0; j < size; ++j)
185 inverted_mask[j] = ~mask[j];
186 mask = inverted_mask;
191 for (i = 0; (i = next_set_bit(mask, i, size * 32)) >= 0; ) {
194 if ((unsigned) i < nsignals) {
195 s = stpcpy(s, signalent[i] + 3);
198 else if (i >= ASM_SIGRTMIN && i <= ASM_SIGRTMAX) {
199 s += sprintf(s, "RT_%u", i - ASM_SIGRTMIN);
203 s += sprintf(s, "%u", i);
214 #define sprintsigmask_val(prefix, mask) \
215 sprintsigmask_n((prefix), &(mask), sizeof(mask))
217 #define tprintsigmask_val(prefix, mask) \
218 tprints(sprintsigmask_n((prefix), &(mask), sizeof(mask)))
223 tprints(signame(nr));
227 print_sigset_addr_len_limit(struct tcb *tcp, long addr, long len, long min_len)
230 * Here len is usually equal to NSIG / 8 or current_wordsize.
231 * But we code this defensively:
233 if (len < min_len || len > NSIG / 8) {
237 int mask[NSIG / 8 / sizeof(int)] = {};
238 if (umoven_or_printaddr(tcp, addr, len, mask))
240 tprints(sprintsigmask_n("", mask, len));
244 print_sigset_addr_len(struct tcb *tcp, long addr, long len)
246 print_sigset_addr_len_limit(tcp, addr, len, current_wordsize);
252 tprintsigmask_val("", tcp->u_arg[0]);
254 else if (!syserror(tcp)) {
255 tcp->auxstr = sprintsigmask_val("old mask ", tcp->u_rval);
256 return RVAL_HEX | RVAL_STR;
261 #ifdef HAVE_SIGACTION
263 struct old_sigaction {
264 /* sa_handler may be a libc #define, need to use other name: */
266 unsigned int sa_flags;
267 void (*__sa_handler)(int);
268 /* Kernel treats sa_mask as an array of longs. */
269 unsigned long sa_mask[NSIG / sizeof(long) ? NSIG / sizeof(long) : 1];
271 void (*__sa_handler)(int);
272 unsigned long sa_mask;
273 unsigned long sa_flags;
276 void (*sa_restorer)(void);
280 struct old_sigaction32 {
281 /* sa_handler may be a libc #define, need to use other name: */
282 uint32_t __sa_handler;
286 uint32_t sa_restorer;
291 decode_old_sigaction(struct tcb *tcp, long addr)
293 struct old_sigaction sa;
295 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
296 if (current_wordsize != sizeof(sa.__sa_handler) && current_wordsize == 4) {
297 struct old_sigaction32 sa32;
299 if (umove_or_printaddr(tcp, addr, &sa32))
302 memset(&sa, 0, sizeof(sa));
303 sa.__sa_handler = (void*)(uintptr_t)sa32.__sa_handler;
304 sa.sa_flags = sa32.sa_flags;
305 #if HAVE_SA_RESTORER && defined SA_RESTORER
306 sa.sa_restorer = (void*)(uintptr_t)sa32.sa_restorer;
308 sa.sa_mask = sa32.sa_mask;
311 if (umove_or_printaddr(tcp, addr, &sa))
314 /* Architectures using function pointers, like
315 * hppa, may need to manipulate the function pointer
316 * to compute the result of a comparison. However,
317 * the __sa_handler function pointer exists only in
318 * the address space of the traced process, and can't
319 * be manipulated by strace. In order to prevent the
320 * compiler from generating code to manipulate
321 * __sa_handler we cast the function pointers to long. */
323 if ((long)sa.__sa_handler == (long)SIG_ERR)
325 else if ((long)sa.__sa_handler == (long)SIG_DFL)
327 else if ((long)sa.__sa_handler == (long)SIG_IGN)
330 printaddr((long) sa.__sa_handler);
333 tprintsigmask_addr("", sa.sa_mask);
335 tprintsigmask_val("", sa.sa_mask);
338 printflags(sigact_flags, sa.sa_flags, "SA_???");
339 #if HAVE_SA_RESTORER && defined SA_RESTORER
340 if (sa.sa_flags & SA_RESTORER)
341 tprintf(", %p", sa.sa_restorer);
349 printsignal(tcp->u_arg[0]);
351 decode_old_sigaction(tcp, tcp->u_arg[1]);
354 decode_old_sigaction(tcp, tcp->u_arg[2]);
361 printsignal(tcp->u_arg[0]);
363 switch (tcp->u_arg[1]) {
374 printaddr(tcp->u_arg[1]);
378 else if (!syserror(tcp)) {
379 switch (tcp->u_rval) {
381 tcp->auxstr = "SIG_ERR"; break;
383 tcp->auxstr = "SIG_DFL"; break;
385 tcp->auxstr = "SIG_IGN"; break;
389 return RVAL_HEX | RVAL_STR;
394 #endif /* HAVE_SIGACTION */
399 tcp->auxstr = sprintsigmask_val("mask ", tcp->u_rval);
401 return RVAL_HEX | RVAL_STR;
406 tprintsigmask_val("", tcp->u_arg[2]);
411 #ifdef HAVE_SIGACTION
413 /* "Old" sigprocmask, which operates with word-sized signal masks */
414 SYS_FUNC(sigprocmask)
419 * Alpha/OSF is different: it doesn't pass in two pointers,
420 * but rather passes in the new bitmask as an argument and
421 * then returns the old bitmask. This "works" because we
422 * only have 64 signals to worry about. If you want more,
423 * use of the rt_sigprocmask syscall is required.
425 * old = osf_sigprocmask(how, new);
427 * ret = sigprocmask(how, &new, &old, ...);
429 printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???");
430 tprintsigmask_val(", ", tcp->u_arg[1]);
432 else if (!syserror(tcp)) {
433 tcp->auxstr = sprintsigmask_val("old mask ", tcp->u_rval);
434 return RVAL_HEX | RVAL_STR;
438 printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???");
440 print_sigset_addr_len(tcp, tcp->u_arg[1], current_wordsize);
444 print_sigset_addr_len(tcp, tcp->u_arg[2], current_wordsize);
450 #endif /* HAVE_SIGACTION */
456 signame(tcp->u_arg[1]));
463 tprintf("%d, %d, %s",
466 signame(tcp->u_arg[2]));
474 print_sigset_addr_len(tcp, tcp->u_arg[0], current_wordsize);
478 SYS_FUNC(rt_sigprocmask)
480 /* Note: arg[3] is the length of the sigset. Kernel requires NSIG / 8 */
482 printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???");
484 print_sigset_addr_len(tcp, tcp->u_arg[1], tcp->u_arg[3]);
488 print_sigset_addr_len(tcp, tcp->u_arg[2], tcp->u_arg[3]);
489 tprintf(", %lu", tcp->u_arg[3]);
494 /* Structure describing the action to be taken when a signal arrives. */
497 /* sa_handler may be a libc #define, need to use other name: */
499 unsigned int sa_flags;
500 void (*__sa_handler)(int);
502 void (*__sa_handler)(int);
503 unsigned long sa_flags;
506 void (*sa_restorer)(void);
508 /* Kernel treats sa_mask as an array of longs. */
509 unsigned long sa_mask[NSIG / sizeof(long) ? NSIG / sizeof(long) : 1];
511 /* Same for i386-on-x86_64 and similar cases */
512 struct new_sigaction32
514 uint32_t __sa_handler;
517 uint32_t sa_restorer;
519 uint32_t sa_mask[2 * (NSIG / sizeof(long) ? NSIG / sizeof(long) : 1)];
523 decode_new_sigaction(struct tcb *tcp, long addr)
525 struct new_sigaction sa;
527 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
528 if (current_wordsize != sizeof(sa.sa_flags) && current_wordsize == 4) {
529 struct new_sigaction32 sa32;
531 if (umove_or_printaddr(tcp, addr, &sa32))
534 memset(&sa, 0, sizeof(sa));
535 sa.__sa_handler = (void*)(unsigned long)sa32.__sa_handler;
536 sa.sa_flags = sa32.sa_flags;
537 #if HAVE_SA_RESTORER && defined SA_RESTORER
538 sa.sa_restorer = (void*)(unsigned long)sa32.sa_restorer;
540 /* Kernel treats sa_mask as an array of longs.
541 * For 32-bit process, "long" is uint32_t, thus, for example,
542 * 32th bit in sa_mask will end up as bit 0 in sa_mask[1].
543 * But for (64-bit) kernel, 32th bit in sa_mask is
544 * 32th bit in 0th (64-bit) long!
545 * For little-endian, it's the same.
546 * For big-endian, we swap 32-bit words.
548 sa.sa_mask[0] = sa32.sa_mask[0] + ((long)(sa32.sa_mask[1]) << 32);
551 if (umove_or_printaddr(tcp, addr, &sa))
554 /* Architectures using function pointers, like
555 * hppa, may need to manipulate the function pointer
556 * to compute the result of a comparison. However,
557 * the __sa_handler function pointer exists only in
558 * the address space of the traced process, and can't
559 * be manipulated by strace. In order to prevent the
560 * compiler from generating code to manipulate
561 * __sa_handler we cast the function pointers to long. */
562 if ((long)sa.__sa_handler == (long)SIG_ERR)
563 tprints("{SIG_ERR, ");
564 else if ((long)sa.__sa_handler == (long)SIG_DFL)
565 tprints("{SIG_DFL, ");
566 else if ((long)sa.__sa_handler == (long)SIG_IGN)
567 tprints("{SIG_IGN, ");
569 tprintf("{%#lx, ", (long) sa.__sa_handler);
571 * Sigset size is in tcp->u_arg[4] (SPARC)
572 * or in tcp->u_arg[3] (all other),
573 * but kernel won't handle sys_rt_sigaction
574 * with wrong sigset size (just returns EINVAL instead).
575 * We just fetch the right size, which is NSIG / 8.
577 tprintsigmask_val("", sa.sa_mask);
580 printflags(sigact_flags, sa.sa_flags, "SA_???");
581 #if HAVE_SA_RESTORER && defined SA_RESTORER
582 if (sa.sa_flags & SA_RESTORER)
583 tprintf(", %p", sa.sa_restorer);
588 SYS_FUNC(rt_sigaction)
591 printsignal(tcp->u_arg[0]);
593 decode_new_sigaction(tcp, tcp->u_arg[1]);
596 decode_new_sigaction(tcp, tcp->u_arg[2]);
597 #if defined(SPARC) || defined(SPARC64)
598 tprintf(", %#lx, %lu", tcp->u_arg[3], tcp->u_arg[4]);
600 tprintf(", %lu, %#lx", tcp->u_arg[3], tcp->u_arg[4]);
602 tprintf(", %lu", tcp->u_arg[3]);
608 SYS_FUNC(rt_sigpending)
612 * One of the few syscalls where sigset size (arg[1])
613 * is allowed to be <= NSIG / 8, not strictly ==.
614 * This allows non-rt sigpending() syscall
615 * to reuse rt_sigpending() code in kernel.
617 print_sigset_addr_len_limit(tcp, tcp->u_arg[0],
619 tprintf(", %lu", tcp->u_arg[1]);
624 SYS_FUNC(rt_sigsuspend)
626 /* NB: kernel requires arg[1] == NSIG / 8 */
627 print_sigset_addr_len(tcp, tcp->u_arg[0], tcp->u_arg[1]);
628 tprintf(", %lu", tcp->u_arg[1]);
634 print_sigqueueinfo(struct tcb *tcp, int sig, unsigned long uinfo)
638 printsiginfo_at(tcp, uinfo);
641 SYS_FUNC(rt_sigqueueinfo)
643 tprintf("%d, ", (int) tcp->u_arg[0]);
644 print_sigqueueinfo(tcp, tcp->u_arg[1], tcp->u_arg[2]);
649 SYS_FUNC(rt_tgsigqueueinfo)
651 tprintf("%d, %d, ", (int) tcp->u_arg[0], (int) tcp->u_arg[1]);
652 print_sigqueueinfo(tcp, tcp->u_arg[2], tcp->u_arg[3]);
657 SYS_FUNC(rt_sigtimedwait)
659 /* NB: kernel requires arg[3] == NSIG / 8 */
661 print_sigset_addr_len(tcp, tcp->u_arg[0], tcp->u_arg[3]);
663 if (!tcp->u_arg[1]) {
665 * This is the only "return" parameter,
666 * if it's NULL, decode all parameters on entry.
669 print_timespec(tcp, tcp->u_arg[2]);
670 tprintf(", %lu", tcp->u_arg[3]);
673 tcp->auxstr = sprint_timespec(tcp, tcp->u_arg[2]);
677 printsiginfo_at(tcp, tcp->u_arg[1]);
678 tprintf(", %s, %lu", tcp->auxstr, tcp->u_arg[3]);
682 if (!syserror(tcp) && tcp->u_rval) {
683 tcp->auxstr = signame(tcp->u_rval);
690 SYS_FUNC(restart_syscall)
692 tprintf("<... resuming interrupted %s ...>",
693 tcp->s_prev_ent ? tcp->s_prev_ent->sys_name : "system call");