granicus.if.org Git - strace/blob - signal.c

   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
  36 #ifndef NSIG
  37 # warning NSIG is not defined, using 32
  38 # define NSIG 32
  39 #elif NSIG < 32
  40 # error NSIG < 32
  41 #endif
  42
  43 /* The libc headers do not define this constant since it should only be
  44    used by the implementation.  So we define it here.  */
  45 #ifndef SA_RESTORER
  46 # ifdef ASM_SA_RESTORER
  47 #  define SA_RESTORER ASM_SA_RESTORER
  48 # endif
  49 #endif
  50
  51 /*
  52  * Some architectures define SA_RESTORER in their headers,
  53  * but do not actually have sa_restorer.
  54  *
  55  * Some architectures, otherwise, do not define SA_RESTORER in their headers,
  56  * but actually have sa_restorer.
  57  */
  58 #ifdef SA_RESTORER
  59 # if defined HPPA || defined IA64
  60 #  define HAVE_SA_RESTORER 0
  61 # else
  62 #  define HAVE_SA_RESTORER 1
  63 # endif
  64 #else /* !SA_RESTORER */
  65 # if defined SPARC || defined SPARC64 || defined M68K
  66 #  define HAVE_SA_RESTORER 1
  67 # else
  68 #  define HAVE_SA_RESTORER 0
  69 # endif
  70 #endif
  71
  72 #include "xlat/sigact_flags.h"
  73 #include "xlat/sigprocmaskcmds.h"
  74
  75 /* Anonymous realtime signals. */
  76 #ifndef ASM_SIGRTMIN
  77 /* Linux kernel >= 3.18 defines SIGRTMIN to 32 on all architectures. */
  78 # define ASM_SIGRTMIN 32
  79 #endif
  80 #ifndef ASM_SIGRTMAX
  81 /* Under glibc 2.1, SIGRTMAX et al are functions, but __SIGRTMAX is a
  82    constant.  This is what we want.  Otherwise, just use SIGRTMAX. */
  83 # ifdef SIGRTMAX
  84 #  ifndef __SIGRTMAX
  85 #   define __SIGRTMAX SIGRTMAX
  86 #  endif
  87 # endif
  88 # ifdef __SIGRTMAX
  89 #  define ASM_SIGRTMAX __SIGRTMAX
  90 # endif
  91 #endif
  92
  93 /* Note on the size of sigset_t:
  94  *
  95  * In glibc, sigset_t is an array with space for 1024 bits (!),
  96  * even though all arches supported by Linux have only 64 signals
  97  * except MIPS, which has 128. IOW, it is 128 bytes long.
  98  *
  99  * In-kernel sigset_t is sized correctly (it is either 64 or 128 bit long).
 100  * However, some old syscall return only 32 lower bits (one word).
 101  * Example: sys_sigpending vs sys_rt_sigpending.
 102  *
 103  * Be aware of this fact when you try to
 104  *     memcpy(&tcp->u_arg[1], &something, sizeof(sigset_t))
 105  * - sizeof(sigset_t) is much bigger than you think,
 106  * it may overflow tcp->u_arg[] array, and it may try to copy more data
 107  * than is really available in <something>.
 108  * Similarly,
 109  *     umoven(tcp, addr, sizeof(sigset_t), &sigset)
 110  * may be a bad idea: it'll try to read much more data than needed
 111  * to fetch a sigset_t.
 112  * Use (NSIG / 8) as a size instead.
 113  */
 114
 115 const char *
 116 signame(const int sig)
 117 {
 118         static char buf[sizeof("SIGRT_%u") + sizeof(int)*3];
 119
 120         if (sig >= 0) {
 121                 const unsigned int s = sig;
 122
 123                 if (s < nsignals)
 124                         return signalent[s];
 125 #ifdef ASM_SIGRTMAX
 126                 if (s >= ASM_SIGRTMIN && s <= ASM_SIGRTMAX) {
 127                         sprintf(buf, "SIGRT_%u", s - ASM_SIGRTMIN);
 128                         return buf;
 129                 }
 130 #endif
 131         }
 132         sprintf(buf, "%d", sig);
 133         return buf;
 134 }
 135
 136 static unsigned int
 137 popcount32(const uint32_t *a, unsigned int size)
 138 {
 139         unsigned int count = 0;
 140
 141         for (; size; ++a, --size) {
 142                 uint32_t x = *a;
 143
 144 #ifdef HAVE___BUILTIN_POPCOUNT
 145                 count += __builtin_popcount(x);
 146 #else
 147                 for (; x; ++count)
 148                         x &= x - 1;
 149 #endif
 150         }
 151
 152         return count;
 153 }
 154
 155 const char *
 156 sprintsigmask_n(const char *prefix, const void *sig_mask, unsigned int bytes)
 157 {
 158         /*
 159          * The maximum number of signal names to be printed is NSIG * 2 / 3.
 160          * Most of signal names have length 7,
 161          * average length of signal names is less than 7.
 162          * The length of prefix string does not exceed 16.
 163          */
 164         static char outstr[128 + 8 * (NSIG * 2 / 3)];
 165
 166         char *s;
 167         const uint32_t *mask;
 168         uint32_t inverted_mask[NSIG / 32];
 169         unsigned int size;
 170         int i;
 171         char sep;
 172
 173         s = stpcpy(outstr, prefix);
 174
 175         mask = sig_mask;
 176         /* length of signal mask in 4-byte words */
 177         size = (bytes >= NSIG / 8) ? NSIG / 32 : (bytes + 3) / 4;
 178
 179         /* check whether 2/3 or more bits are set */
 180         if (popcount32(mask, size) >= size * 32 * 2 / 3) {
 181                 /* show those signals that are NOT in the mask */
 182                 unsigned int j;
 183                 for (j = 0; j < size; ++j)
 184                         inverted_mask[j] = ~mask[j];
 185                 mask = inverted_mask;
 186                 *s++ = '~';
 187         }
 188
 189         sep = '[';
 190         for (i = 0; (i = next_set_bit(mask, i, size * 32)) >= 0; ) {
 191                 ++i;
 192                 *s++ = sep;
 193                 if ((unsigned) i < nsignals) {
 194                         s = stpcpy(s, signalent[i] + 3);
 195                 }
 196 #ifdef ASM_SIGRTMAX
 197                 else if (i >= ASM_SIGRTMIN && i <= ASM_SIGRTMAX) {
 198                         s += sprintf(s, "RT_%u", i - ASM_SIGRTMIN);
 199                 }
 200 #endif
 201                 else {
 202                         s += sprintf(s, "%u", i);
 203                 }
 204                 sep = ' ';
 205         }
 206         if (sep == '[')
 207                 *s++ = sep;
 208         *s++ = ']';
 209         *s = '\0';
 210         return outstr;
 211 }
 212
 213 #define sprintsigmask_val(prefix, mask) \
 214         sprintsigmask_n((prefix), &(mask), sizeof(mask))
 215
 216 #define tprintsigmask_val(prefix, mask) \
 217         tprints(sprintsigmask_n((prefix), &(mask), sizeof(mask)))
 218
 219 void
 220 printsignal(int nr)
 221 {
 222         tprints(signame(nr));
 223 }
 224
 225 void
 226 print_sigset_addr_len(struct tcb *tcp, long addr, long len)
 227 {
 228         char mask[NSIG / 8];
 229
 230         if (!addr) {
 231                 tprints("NULL");
 232                 return;
 233         }
 234         /* Here len is usually equals NSIG / 8 or current_wordsize.
 235          * But we code this defensively:
 236          */
 237         if (len < 0) {
 238  bad:
 239                 tprintf("%#lx", addr);
 240                 return;
 241         }
 242         if (len >= NSIG / 8)
 243                 len = NSIG / 8;
 244         else
 245                 len = (len + 3) & ~3;
 246
 247         if (umoven(tcp, addr, len, mask) < 0)
 248                 goto bad;
 249         tprints(sprintsigmask_n("", mask, len));
 250 }
 251
 252 int
 253 sys_sigsetmask(struct tcb *tcp)
 254 {
 255         if (entering(tcp)) {
 256                 tprintsigmask_val("", tcp->u_arg[0]);
 257         }
 258         else if (!syserror(tcp)) {
 259                 tcp->auxstr = sprintsigmask_val("old mask ", tcp->u_rval);
 260                 return RVAL_HEX | RVAL_STR;
 261         }
 262         return 0;
 263 }
 264
 265 #ifdef HAVE_SIGACTION
 266
 267 struct old_sigaction {
 268         /* sa_handler may be a libc #define, need to use other name: */
 269 #ifdef MIPS
 270         unsigned int sa_flags;
 271         void (*__sa_handler)(int);
 272         /* Kernel treats sa_mask as an array of longs. */
 273         unsigned long sa_mask[NSIG / sizeof(long) ? NSIG / sizeof(long) : 1];
 274 #else
 275         void (*__sa_handler)(int);
 276         unsigned long sa_mask;
 277         unsigned long sa_flags;
 278 #endif /* !MIPS */
 279 #if HAVE_SA_RESTORER
 280         void (*sa_restorer)(void);
 281 #endif
 282 };
 283
 284 struct old_sigaction32 {
 285         /* sa_handler may be a libc #define, need to use other name: */
 286         uint32_t __sa_handler;
 287         uint32_t sa_mask;
 288         uint32_t sa_flags;
 289 #if HAVE_SA_RESTORER
 290         uint32_t sa_restorer;
 291 #endif
 292 };
 293
 294 static void
 295 decode_old_sigaction(struct tcb *tcp, long addr)
 296 {
 297         struct old_sigaction sa;
 298         int r;
 299
 300         if (!addr) {
 301                 tprints("NULL");
 302                 return;
 303         }
 304         if (!verbose(tcp) || (exiting(tcp) && syserror(tcp))) {
 305                 tprintf("%#lx", addr);
 306                 return;
 307         }
 308
 309 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
 310         if (current_wordsize != sizeof(sa.__sa_handler) && current_wordsize == 4) {
 311                 struct old_sigaction32 sa32;
 312                 r = umove(tcp, addr, &sa32);
 313                 if (r >= 0) {
 314                         memset(&sa, 0, sizeof(sa));
 315                         sa.__sa_handler = (void*)(uintptr_t)sa32.__sa_handler;
 316                         sa.sa_flags = sa32.sa_flags;
 317 #if HAVE_SA_RESTORER && defined SA_RESTORER
 318                         sa.sa_restorer = (void*)(uintptr_t)sa32.sa_restorer;
 319 #endif
 320                         sa.sa_mask = sa32.sa_mask;
 321                 }
 322         } else
 323 #endif
 324         {
 325                 r = umove(tcp, addr, &sa);
 326         }
 327         if (r < 0) {
 328                 tprints("{...}");
 329                 return;
 330         }
 331
 332         /* Architectures using function pointers, like
 333          * hppa, may need to manipulate the function pointer
 334          * to compute the result of a comparison. However,
 335          * the __sa_handler function pointer exists only in
 336          * the address space of the traced process, and can't
 337          * be manipulated by strace. In order to prevent the
 338          * compiler from generating code to manipulate
 339          * __sa_handler we cast the function pointers to long. */
 340         if ((long)sa.__sa_handler == (long)SIG_ERR)
 341                 tprints("{SIG_ERR, ");
 342         else if ((long)sa.__sa_handler == (long)SIG_DFL)
 343                 tprints("{SIG_DFL, ");
 344         else if ((long)sa.__sa_handler == (long)SIG_IGN)
 345                 tprints("{SIG_IGN, ");
 346         else
 347                 tprintf("{%#lx, ", (long) sa.__sa_handler);
 348 #ifdef MIPS
 349         tprintsigmask_addr("", sa.sa_mask);
 350 #else
 351         tprintsigmask_val("", sa.sa_mask);
 352 #endif
 353         tprints(", ");
 354         printflags(sigact_flags, sa.sa_flags, "SA_???");
 355 #if HAVE_SA_RESTORER && defined SA_RESTORER
 356         if (sa.sa_flags & SA_RESTORER)
 357                 tprintf(", %p", sa.sa_restorer);
 358 #endif
 359         tprints("}");
 360 }
 361
 362 int
 363 sys_sigaction(struct tcb *tcp)
 364 {
 365         if (entering(tcp)) {
 366                 printsignal(tcp->u_arg[0]);
 367                 tprints(", ");
 368                 decode_old_sigaction(tcp, tcp->u_arg[1]);
 369                 tprints(", ");
 370         } else
 371                 decode_old_sigaction(tcp, tcp->u_arg[2]);
 372         return 0;
 373 }
 374
 375 int
 376 sys_signal(struct tcb *tcp)
 377 {
 378         if (entering(tcp)) {
 379                 printsignal(tcp->u_arg[0]);
 380                 tprints(", ");
 381                 switch (tcp->u_arg[1]) {
 382                 case (long) SIG_ERR:
 383                         tprints("SIG_ERR");
 384                         break;
 385                 case (long) SIG_DFL:
 386                         tprints("SIG_DFL");
 387                         break;
 388                 case (long) SIG_IGN:
 389                         tprints("SIG_IGN");
 390                         break;
 391                 default:
 392                         tprintf("%#lx", tcp->u_arg[1]);
 393                 }
 394                 return 0;
 395         }
 396         else if (!syserror(tcp)) {
 397                 switch (tcp->u_rval) {
 398                 case (long) SIG_ERR:
 399                         tcp->auxstr = "SIG_ERR"; break;
 400                 case (long) SIG_DFL:
 401                         tcp->auxstr = "SIG_DFL"; break;
 402                 case (long) SIG_IGN:
 403                         tcp->auxstr = "SIG_IGN"; break;
 404                 default:
 405                         tcp->auxstr = NULL;
 406                 }
 407                 return RVAL_HEX | RVAL_STR;
 408         }
 409         return 0;
 410 }
 411
 412 #endif /* HAVE_SIGACTION */
 413
 414 int
 415 sys_siggetmask(struct tcb *tcp)
 416 {
 417         if (exiting(tcp)) {
 418                 tcp->auxstr = sprintsigmask_val("mask ", tcp->u_rval);
 419         }
 420         return RVAL_HEX | RVAL_STR;
 421 }
 422
 423 int
 424 sys_sigsuspend(struct tcb *tcp)
 425 {
 426         if (entering(tcp)) {
 427                 tprintsigmask_val("", tcp->u_arg[2]);
 428         }
 429         return 0;
 430 }
 431
 432 #ifdef HAVE_SIGACTION
 433
 434 /* "Old" sigprocmask, which operates with word-sized signal masks */
 435 int
 436 sys_sigprocmask(struct tcb *tcp)
 437 {
 438 # ifdef ALPHA
 439         if (entering(tcp)) {
 440                 /*
 441                  * Alpha/OSF is different: it doesn't pass in two pointers,
 442                  * but rather passes in the new bitmask as an argument and
 443                  * then returns the old bitmask.  This "works" because we
 444                  * only have 64 signals to worry about.  If you want more,
 445                  * use of the rt_sigprocmask syscall is required.
 446                  * Alpha:
 447                  *      old = osf_sigprocmask(how, new);
 448                  * Everyone else:
 449                  *      ret = sigprocmask(how, &new, &old, ...);
 450                  */
 451                 printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???");
 452                 tprintsigmask_val(", ", tcp->u_arg[1]);
 453         }
 454         else if (!syserror(tcp)) {
 455                 tcp->auxstr = sprintsigmask_val("old mask ", tcp->u_rval);
 456                 return RVAL_HEX | RVAL_STR;
 457         }
 458 # else /* !ALPHA */
 459         if (entering(tcp)) {
 460                 printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???");
 461                 tprints(", ");
 462                 print_sigset_addr_len(tcp, tcp->u_arg[1], current_wordsize);
 463                 tprints(", ");
 464         }
 465         else {
 466                 if (syserror(tcp))
 467                         tprintf("%#lx", tcp->u_arg[2]);
 468                 else
 469                         print_sigset_addr_len(tcp, tcp->u_arg[2], current_wordsize);
 470         }
 471 # endif /* !ALPHA */
 472         return 0;
 473 }
 474
 475 #endif /* HAVE_SIGACTION */
 476
 477 int
 478 sys_kill(struct tcb *tcp)
 479 {
 480         if (entering(tcp)) {
 481                 tprintf("%ld, %s",
 482                         widen_to_long(tcp->u_arg[0]),
 483                         signame(tcp->u_arg[1])
 484                 );
 485         }
 486         return 0;
 487 }
 488
 489 int
 490 sys_tgkill(struct tcb *tcp)
 491 {
 492         if (entering(tcp)) {
 493                 tprintf("%ld, %ld, %s",
 494                         widen_to_long(tcp->u_arg[0]),
 495                         widen_to_long(tcp->u_arg[1]),
 496                         signame(tcp->u_arg[2])
 497                 );
 498         }
 499         return 0;
 500 }
 501
 502 int
 503 sys_sigpending(struct tcb *tcp)
 504 {
 505         if (exiting(tcp)) {
 506                 if (syserror(tcp))
 507                         tprintf("%#lx", tcp->u_arg[0]);
 508                 else
 509                         print_sigset_addr_len(tcp, tcp->u_arg[0], current_wordsize);
 510         }
 511         return 0;
 512 }
 513
 514 int
 515 sys_rt_sigprocmask(struct tcb *tcp)
 516 {
 517         /* Note: arg[3] is the length of the sigset. Kernel requires NSIG / 8 */
 518         if (entering(tcp)) {
 519                 printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???");
 520                 tprints(", ");
 521                 print_sigset_addr_len(tcp, tcp->u_arg[1], tcp->u_arg[3]);
 522                 tprints(", ");
 523         }
 524         else {
 525                 if (syserror(tcp))
 526                         tprintf("%#lx", tcp->u_arg[2]);
 527                 else
 528                         print_sigset_addr_len(tcp, tcp->u_arg[2], tcp->u_arg[3]);
 529                 tprintf(", %lu", tcp->u_arg[3]);
 530         }
 531         return 0;
 532 }
 533
 534 /* Structure describing the action to be taken when a signal arrives.  */
 535 struct new_sigaction
 536 {
 537         /* sa_handler may be a libc #define, need to use other name: */
 538 #ifdef MIPS
 539         unsigned int sa_flags;
 540         void (*__sa_handler)(int);
 541 #else
 542         void (*__sa_handler)(int);
 543         unsigned long sa_flags;
 544 #endif /* !MIPS */
 545 #if HAVE_SA_RESTORER
 546         void (*sa_restorer)(void);
 547 #endif
 548         /* Kernel treats sa_mask as an array of longs. */
 549         unsigned long sa_mask[NSIG / sizeof(long) ? NSIG / sizeof(long) : 1];
 550 };
 551 /* Same for i386-on-x86_64 and similar cases */
 552 struct new_sigaction32
 553 {
 554         uint32_t __sa_handler;
 555         uint32_t sa_flags;
 556 #if HAVE_SA_RESTORER
 557         uint32_t sa_restorer;
 558 #endif
 559         uint32_t sa_mask[2 * (NSIG / sizeof(long) ? NSIG / sizeof(long) : 1)];
 560 };
 561
 562 static void
 563 decode_new_sigaction(struct tcb *tcp, long addr)
 564 {
 565         struct new_sigaction sa;
 566         int r;
 567
 568         if (!addr) {
 569                 tprints("NULL");
 570                 return;
 571         }
 572         if (!verbose(tcp) || (exiting(tcp) && syserror(tcp))) {
 573                 tprintf("%#lx", addr);
 574                 return;
 575         }
 576 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
 577         if (current_wordsize != sizeof(sa.sa_flags) && current_wordsize == 4) {
 578                 struct new_sigaction32 sa32;
 579                 r = umove(tcp, addr, &sa32);
 580                 if (r >= 0) {
 581                         memset(&sa, 0, sizeof(sa));
 582                         sa.__sa_handler = (void*)(unsigned long)sa32.__sa_handler;
 583                         sa.sa_flags     = sa32.sa_flags;
 584 #if HAVE_SA_RESTORER && defined SA_RESTORER
 585                         sa.sa_restorer  = (void*)(unsigned long)sa32.sa_restorer;
 586 #endif
 587                         /* Kernel treats sa_mask as an array of longs.
 588                          * For 32-bit process, "long" is uint32_t, thus, for example,
 589                          * 32th bit in sa_mask will end up as bit 0 in sa_mask[1].
 590                          * But for (64-bit) kernel, 32th bit in sa_mask is
 591                          * 32th bit in 0th (64-bit) long!
 592                          * For little-endian, it's the same.
 593                          * For big-endian, we swap 32-bit words.
 594                          */
 595                         sa.sa_mask[0] = sa32.sa_mask[0] + ((long)(sa32.sa_mask[1]) << 32);
 596                 }
 597         } else
 598 #endif
 599         {
 600                 r = umove(tcp, addr, &sa);
 601         }
 602         if (r < 0) {
 603                 tprints("{...}");
 604                 return;
 605         }
 606         /* Architectures using function pointers, like
 607          * hppa, may need to manipulate the function pointer
 608          * to compute the result of a comparison. However,
 609          * the __sa_handler function pointer exists only in
 610          * the address space of the traced process, and can't
 611          * be manipulated by strace. In order to prevent the
 612          * compiler from generating code to manipulate
 613          * __sa_handler we cast the function pointers to long. */
 614         if ((long)sa.__sa_handler == (long)SIG_ERR)
 615                 tprints("{SIG_ERR, ");
 616         else if ((long)sa.__sa_handler == (long)SIG_DFL)
 617                 tprints("{SIG_DFL, ");
 618         else if ((long)sa.__sa_handler == (long)SIG_IGN)
 619                 tprints("{SIG_IGN, ");
 620         else
 621                 tprintf("{%#lx, ", (long) sa.__sa_handler);
 622         /*
 623          * Sigset size is in tcp->u_arg[4] (SPARC)
 624          * or in tcp->u_arg[3] (all other),
 625          * but kernel won't handle sys_rt_sigaction
 626          * with wrong sigset size (just returns EINVAL instead).
 627          * We just fetch the right size, which is NSIG / 8.
 628          */
 629         tprintsigmask_val("", sa.sa_mask);
 630         tprints(", ");
 631
 632         printflags(sigact_flags, sa.sa_flags, "SA_???");
 633 #if HAVE_SA_RESTORER && defined SA_RESTORER
 634         if (sa.sa_flags & SA_RESTORER)
 635                 tprintf(", %p", sa.sa_restorer);
 636 #endif
 637         tprints("}");
 638 }
 639
 640 int
 641 sys_rt_sigaction(struct tcb *tcp)
 642 {
 643         if (entering(tcp)) {
 644                 printsignal(tcp->u_arg[0]);
 645                 tprints(", ");
 646                 decode_new_sigaction(tcp, tcp->u_arg[1]);
 647                 tprints(", ");
 648         } else {
 649                 decode_new_sigaction(tcp, tcp->u_arg[2]);
 650 #if defined(SPARC) || defined(SPARC64)
 651                 tprintf(", %#lx, %lu", tcp->u_arg[3], tcp->u_arg[4]);
 652 #elif defined(ALPHA)
 653                 tprintf(", %lu, %#lx", tcp->u_arg[3], tcp->u_arg[4]);
 654 #else
 655                 tprintf(", %lu", tcp->u_arg[3]);
 656 #endif
 657         }
 658         return 0;
 659 }
 660
 661 int
 662 sys_rt_sigpending(struct tcb *tcp)
 663 {
 664         if (exiting(tcp)) {
 665                 /*
 666                  * One of the few syscalls where sigset size (arg[1])
 667                  * is allowed to be <= NSIG / 8, not strictly ==.
 668                  * This allows non-rt sigpending() syscall
 669                  * to reuse rt_sigpending() code in kernel.
 670                  */
 671                 if (syserror(tcp))
 672                         tprintf("%#lx", tcp->u_arg[0]);
 673                 else
 674                         print_sigset_addr_len(tcp, tcp->u_arg[0], tcp->u_arg[1]);
 675                 tprintf(", %lu", tcp->u_arg[1]);
 676         }
 677         return 0;
 678 }
 679
 680 int
 681 sys_rt_sigsuspend(struct tcb *tcp)
 682 {
 683         if (entering(tcp)) {
 684                 /* NB: kernel requires arg[1] == NSIG / 8 */
 685                 print_sigset_addr_len(tcp, tcp->u_arg[0], tcp->u_arg[1]);
 686                 tprintf(", %lu", tcp->u_arg[1]);
 687         }
 688         return 0;
 689 }
 690
 691 static void
 692 print_sigqueueinfo(struct tcb *tcp, int sig, unsigned long uinfo)
 693 {
 694         printsignal(sig);
 695         tprints(", ");
 696         printsiginfo_at(tcp, uinfo);
 697 }
 698
 699 int
 700 sys_rt_sigqueueinfo(struct tcb *tcp)
 701 {
 702         if (entering(tcp)) {
 703                 tprintf("%lu, ", tcp->u_arg[0]);
 704                 print_sigqueueinfo(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 705         }
 706         return 0;
 707 }
 708
 709 int
 710 sys_rt_tgsigqueueinfo(struct tcb *tcp)
 711 {
 712         if (entering(tcp)) {
 713                 tprintf("%lu, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
 714                 print_sigqueueinfo(tcp, tcp->u_arg[2], tcp->u_arg[3]);
 715         }
 716         return 0;
 717 }
 718
 719 int sys_rt_sigtimedwait(struct tcb *tcp)
 720 {
 721         /* NB: kernel requires arg[3] == NSIG / 8 */
 722         if (entering(tcp)) {
 723                 print_sigset_addr_len(tcp, tcp->u_arg[0], tcp->u_arg[3]);
 724                 tprints(", ");
 725                 /* This is the only "return" parameter, */
 726                 if (tcp->u_arg[1] != 0)
 727                         return 0;
 728                 /* ... if it's NULL, can decode all on entry */
 729                 tprints("NULL, ");
 730         }
 731         else if (tcp->u_arg[1] != 0) {
 732                 /* syscall exit, and u_arg[1] wasn't NULL */
 733                 printsiginfo_at(tcp, tcp->u_arg[1]);
 734                 tprints(", ");
 735         }
 736         else {
 737                 /* syscall exit, and u_arg[1] was NULL */
 738                 return 0;
 739         }
 740         print_timespec(tcp, tcp->u_arg[2]);
 741         tprintf(", %lu", tcp->u_arg[3]);
 742         return 0;
 743 };
 744
 745 int
 746 sys_restart_syscall(struct tcb *tcp)
 747 {
 748         if (entering(tcp)) {
 749                 tprintf("<... resuming interrupted %s ...>",
 750                         tcp->s_prev_ent
 751                         ? tcp->s_prev_ent->sys_name
 752                         : "system call"
 753                 );
 754         }
 755         return 0;
 756 }
 757
 758 static int
 759 do_signalfd(struct tcb *tcp, int flags_arg)
 760 {
 761         /* NB: kernel requires arg[2] == NSIG / 8 */
 762         if (entering(tcp)) {
 763                 printfd(tcp, tcp->u_arg[0]);
 764                 tprints(", ");
 765                 print_sigset_addr_len(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 766                 tprintf(", %lu", tcp->u_arg[2]);
 767                 if (flags_arg >= 0) {
 768                         tprints(", ");
 769                         printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???");
 770                 }
 771         }
 772         return 0;
 773 }
 774
 775 int
 776 sys_signalfd(struct tcb *tcp)
 777 {
 778         return do_signalfd(tcp, -1);
 779 }
 780
 781 int
 782 sys_signalfd4(struct tcb *tcp)
 783 {
 784         return do_signalfd(tcp, 3);
 785 }