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 SYS_FUNC(sigsetmask)
 253 {
 254         if (entering(tcp)) {
 255                 tprintsigmask_val("", tcp->u_arg[0]);
 256         }
 257         else if (!syserror(tcp)) {
 258                 tcp->auxstr = sprintsigmask_val("old mask ", tcp->u_rval);
 259                 return RVAL_HEX | RVAL_STR;
 260         }
 261         return 0;
 262 }
 263
 264 #ifdef HAVE_SIGACTION
 265
 266 struct old_sigaction {
 267         /* sa_handler may be a libc #define, need to use other name: */
 268 #ifdef MIPS
 269         unsigned int sa_flags;
 270         void (*__sa_handler)(int);
 271         /* Kernel treats sa_mask as an array of longs. */
 272         unsigned long sa_mask[NSIG / sizeof(long) ? NSIG / sizeof(long) : 1];
 273 #else
 274         void (*__sa_handler)(int);
 275         unsigned long sa_mask;
 276         unsigned long sa_flags;
 277 #endif /* !MIPS */
 278 #if HAVE_SA_RESTORER
 279         void (*sa_restorer)(void);
 280 #endif
 281 };
 282
 283 struct old_sigaction32 {
 284         /* sa_handler may be a libc #define, need to use other name: */
 285         uint32_t __sa_handler;
 286         uint32_t sa_mask;
 287         uint32_t sa_flags;
 288 #if HAVE_SA_RESTORER
 289         uint32_t sa_restorer;
 290 #endif
 291 };
 292
 293 static void
 294 decode_old_sigaction(struct tcb *tcp, long addr)
 295 {
 296         struct old_sigaction sa;
 297         int r;
 298
 299         if (!addr) {
 300                 tprints("NULL");
 301                 return;
 302         }
 303         if (!verbose(tcp) || (exiting(tcp) && syserror(tcp))) {
 304                 tprintf("%#lx", addr);
 305                 return;
 306         }
 307
 308 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
 309         if (current_wordsize != sizeof(sa.__sa_handler) && current_wordsize == 4) {
 310                 struct old_sigaction32 sa32;
 311                 r = umove(tcp, addr, &sa32);
 312                 if (r >= 0) {
 313                         memset(&sa, 0, sizeof(sa));
 314                         sa.__sa_handler = (void*)(uintptr_t)sa32.__sa_handler;
 315                         sa.sa_flags = sa32.sa_flags;
 316 #if HAVE_SA_RESTORER && defined SA_RESTORER
 317                         sa.sa_restorer = (void*)(uintptr_t)sa32.sa_restorer;
 318 #endif
 319                         sa.sa_mask = sa32.sa_mask;
 320                 }
 321         } else
 322 #endif
 323         {
 324                 r = umove(tcp, addr, &sa);
 325         }
 326         if (r < 0) {
 327                 tprints("{...}");
 328                 return;
 329         }
 330
 331         /* Architectures using function pointers, like
 332          * hppa, may need to manipulate the function pointer
 333          * to compute the result of a comparison. However,
 334          * the __sa_handler function pointer exists only in
 335          * the address space of the traced process, and can't
 336          * be manipulated by strace. In order to prevent the
 337          * compiler from generating code to manipulate
 338          * __sa_handler we cast the function pointers to long. */
 339         if ((long)sa.__sa_handler == (long)SIG_ERR)
 340                 tprints("{SIG_ERR, ");
 341         else if ((long)sa.__sa_handler == (long)SIG_DFL)
 342                 tprints("{SIG_DFL, ");
 343         else if ((long)sa.__sa_handler == (long)SIG_IGN)
 344                 tprints("{SIG_IGN, ");
 345         else
 346                 tprintf("{%#lx, ", (long) sa.__sa_handler);
 347 #ifdef MIPS
 348         tprintsigmask_addr("", sa.sa_mask);
 349 #else
 350         tprintsigmask_val("", sa.sa_mask);
 351 #endif
 352         tprints(", ");
 353         printflags(sigact_flags, sa.sa_flags, "SA_???");
 354 #if HAVE_SA_RESTORER && defined SA_RESTORER
 355         if (sa.sa_flags & SA_RESTORER)
 356                 tprintf(", %p", sa.sa_restorer);
 357 #endif
 358         tprints("}");
 359 }
 360
 361 SYS_FUNC(sigaction)
 362 {
 363         if (entering(tcp)) {
 364                 printsignal(tcp->u_arg[0]);
 365                 tprints(", ");
 366                 decode_old_sigaction(tcp, tcp->u_arg[1]);
 367                 tprints(", ");
 368         } else
 369                 decode_old_sigaction(tcp, tcp->u_arg[2]);
 370         return 0;
 371 }
 372
 373 SYS_FUNC(signal)
 374 {
 375         if (entering(tcp)) {
 376                 printsignal(tcp->u_arg[0]);
 377                 tprints(", ");
 378                 switch (tcp->u_arg[1]) {
 379                 case (long) SIG_ERR:
 380                         tprints("SIG_ERR");
 381                         break;
 382                 case (long) SIG_DFL:
 383                         tprints("SIG_DFL");
 384                         break;
 385                 case (long) SIG_IGN:
 386                         tprints("SIG_IGN");
 387                         break;
 388                 default:
 389                         tprintf("%#lx", tcp->u_arg[1]);
 390                 }
 391                 return 0;
 392         }
 393         else if (!syserror(tcp)) {
 394                 switch (tcp->u_rval) {
 395                 case (long) SIG_ERR:
 396                         tcp->auxstr = "SIG_ERR"; break;
 397                 case (long) SIG_DFL:
 398                         tcp->auxstr = "SIG_DFL"; break;
 399                 case (long) SIG_IGN:
 400                         tcp->auxstr = "SIG_IGN"; break;
 401                 default:
 402                         tcp->auxstr = NULL;
 403                 }
 404                 return RVAL_HEX | RVAL_STR;
 405         }
 406         return 0;
 407 }
 408
 409 #endif /* HAVE_SIGACTION */
 410
 411 SYS_FUNC(siggetmask)
 412 {
 413         if (exiting(tcp)) {
 414                 tcp->auxstr = sprintsigmask_val("mask ", tcp->u_rval);
 415         }
 416         return RVAL_HEX | RVAL_STR;
 417 }
 418
 419 SYS_FUNC(sigsuspend)
 420 {
 421         if (entering(tcp)) {
 422                 tprintsigmask_val("", tcp->u_arg[2]);
 423         }
 424         return 0;
 425 }
 426
 427 #ifdef HAVE_SIGACTION
 428
 429 /* "Old" sigprocmask, which operates with word-sized signal masks */
 430 SYS_FUNC(sigprocmask)
 431 {
 432 # ifdef ALPHA
 433         if (entering(tcp)) {
 434                 /*
 435                  * Alpha/OSF is different: it doesn't pass in two pointers,
 436                  * but rather passes in the new bitmask as an argument and
 437                  * then returns the old bitmask.  This "works" because we
 438                  * only have 64 signals to worry about.  If you want more,
 439                  * use of the rt_sigprocmask syscall is required.
 440                  * Alpha:
 441                  *      old = osf_sigprocmask(how, new);
 442                  * Everyone else:
 443                  *      ret = sigprocmask(how, &new, &old, ...);
 444                  */
 445                 printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???");
 446                 tprintsigmask_val(", ", tcp->u_arg[1]);
 447         }
 448         else if (!syserror(tcp)) {
 449                 tcp->auxstr = sprintsigmask_val("old mask ", tcp->u_rval);
 450                 return RVAL_HEX | RVAL_STR;
 451         }
 452 # else /* !ALPHA */
 453         if (entering(tcp)) {
 454                 printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???");
 455                 tprints(", ");
 456                 print_sigset_addr_len(tcp, tcp->u_arg[1], current_wordsize);
 457                 tprints(", ");
 458         }
 459         else {
 460                 if (syserror(tcp))
 461                         tprintf("%#lx", tcp->u_arg[2]);
 462                 else
 463                         print_sigset_addr_len(tcp, tcp->u_arg[2], current_wordsize);
 464         }
 465 # endif /* !ALPHA */
 466         return 0;
 467 }
 468
 469 #endif /* HAVE_SIGACTION */
 470
 471 SYS_FUNC(kill)
 472 {
 473         if (entering(tcp)) {
 474                 tprintf("%ld, %s",
 475                         widen_to_long(tcp->u_arg[0]),
 476                         signame(tcp->u_arg[1])
 477                 );
 478         }
 479         return 0;
 480 }
 481
 482 SYS_FUNC(tgkill)
 483 {
 484         if (entering(tcp)) {
 485                 tprintf("%ld, %ld, %s",
 486                         widen_to_long(tcp->u_arg[0]),
 487                         widen_to_long(tcp->u_arg[1]),
 488                         signame(tcp->u_arg[2])
 489                 );
 490         }
 491         return 0;
 492 }
 493
 494 SYS_FUNC(sigpending)
 495 {
 496         if (exiting(tcp)) {
 497                 if (syserror(tcp))
 498                         tprintf("%#lx", tcp->u_arg[0]);
 499                 else
 500                         print_sigset_addr_len(tcp, tcp->u_arg[0], current_wordsize);
 501         }
 502         return 0;
 503 }
 504
 505 SYS_FUNC(rt_sigprocmask)
 506 {
 507         /* Note: arg[3] is the length of the sigset. Kernel requires NSIG / 8 */
 508         if (entering(tcp)) {
 509                 printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???");
 510                 tprints(", ");
 511                 print_sigset_addr_len(tcp, tcp->u_arg[1], tcp->u_arg[3]);
 512                 tprints(", ");
 513         }
 514         else {
 515                 if (syserror(tcp))
 516                         tprintf("%#lx", tcp->u_arg[2]);
 517                 else
 518                         print_sigset_addr_len(tcp, tcp->u_arg[2], tcp->u_arg[3]);
 519                 tprintf(", %lu", tcp->u_arg[3]);
 520         }
 521         return 0;
 522 }
 523
 524 /* Structure describing the action to be taken when a signal arrives.  */
 525 struct new_sigaction
 526 {
 527         /* sa_handler may be a libc #define, need to use other name: */
 528 #ifdef MIPS
 529         unsigned int sa_flags;
 530         void (*__sa_handler)(int);
 531 #else
 532         void (*__sa_handler)(int);
 533         unsigned long sa_flags;
 534 #endif /* !MIPS */
 535 #if HAVE_SA_RESTORER
 536         void (*sa_restorer)(void);
 537 #endif
 538         /* Kernel treats sa_mask as an array of longs. */
 539         unsigned long sa_mask[NSIG / sizeof(long) ? NSIG / sizeof(long) : 1];
 540 };
 541 /* Same for i386-on-x86_64 and similar cases */
 542 struct new_sigaction32
 543 {
 544         uint32_t __sa_handler;
 545         uint32_t sa_flags;
 546 #if HAVE_SA_RESTORER
 547         uint32_t sa_restorer;
 548 #endif
 549         uint32_t sa_mask[2 * (NSIG / sizeof(long) ? NSIG / sizeof(long) : 1)];
 550 };
 551
 552 static void
 553 decode_new_sigaction(struct tcb *tcp, long addr)
 554 {
 555         struct new_sigaction sa;
 556         int r;
 557
 558         if (!addr) {
 559                 tprints("NULL");
 560                 return;
 561         }
 562         if (!verbose(tcp) || (exiting(tcp) && syserror(tcp))) {
 563                 tprintf("%#lx", addr);
 564                 return;
 565         }
 566 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
 567         if (current_wordsize != sizeof(sa.sa_flags) && current_wordsize == 4) {
 568                 struct new_sigaction32 sa32;
 569                 r = umove(tcp, addr, &sa32);
 570                 if (r >= 0) {
 571                         memset(&sa, 0, sizeof(sa));
 572                         sa.__sa_handler = (void*)(unsigned long)sa32.__sa_handler;
 573                         sa.sa_flags     = sa32.sa_flags;
 574 #if HAVE_SA_RESTORER && defined SA_RESTORER
 575                         sa.sa_restorer  = (void*)(unsigned long)sa32.sa_restorer;
 576 #endif
 577                         /* Kernel treats sa_mask as an array of longs.
 578                          * For 32-bit process, "long" is uint32_t, thus, for example,
 579                          * 32th bit in sa_mask will end up as bit 0 in sa_mask[1].
 580                          * But for (64-bit) kernel, 32th bit in sa_mask is
 581                          * 32th bit in 0th (64-bit) long!
 582                          * For little-endian, it's the same.
 583                          * For big-endian, we swap 32-bit words.
 584                          */
 585                         sa.sa_mask[0] = sa32.sa_mask[0] + ((long)(sa32.sa_mask[1]) << 32);
 586                 }
 587         } else
 588 #endif
 589         {
 590                 r = umove(tcp, addr, &sa);
 591         }
 592         if (r < 0) {
 593                 tprints("{...}");
 594                 return;
 595         }
 596         /* Architectures using function pointers, like
 597          * hppa, may need to manipulate the function pointer
 598          * to compute the result of a comparison. However,
 599          * the __sa_handler function pointer exists only in
 600          * the address space of the traced process, and can't
 601          * be manipulated by strace. In order to prevent the
 602          * compiler from generating code to manipulate
 603          * __sa_handler we cast the function pointers to long. */
 604         if ((long)sa.__sa_handler == (long)SIG_ERR)
 605                 tprints("{SIG_ERR, ");
 606         else if ((long)sa.__sa_handler == (long)SIG_DFL)
 607                 tprints("{SIG_DFL, ");
 608         else if ((long)sa.__sa_handler == (long)SIG_IGN)
 609                 tprints("{SIG_IGN, ");
 610         else
 611                 tprintf("{%#lx, ", (long) sa.__sa_handler);
 612         /*
 613          * Sigset size is in tcp->u_arg[4] (SPARC)
 614          * or in tcp->u_arg[3] (all other),
 615          * but kernel won't handle sys_rt_sigaction
 616          * with wrong sigset size (just returns EINVAL instead).
 617          * We just fetch the right size, which is NSIG / 8.
 618          */
 619         tprintsigmask_val("", sa.sa_mask);
 620         tprints(", ");
 621
 622         printflags(sigact_flags, sa.sa_flags, "SA_???");
 623 #if HAVE_SA_RESTORER && defined SA_RESTORER
 624         if (sa.sa_flags & SA_RESTORER)
 625                 tprintf(", %p", sa.sa_restorer);
 626 #endif
 627         tprints("}");
 628 }
 629
 630 SYS_FUNC(rt_sigaction)
 631 {
 632         if (entering(tcp)) {
 633                 printsignal(tcp->u_arg[0]);
 634                 tprints(", ");
 635                 decode_new_sigaction(tcp, tcp->u_arg[1]);
 636                 tprints(", ");
 637         } else {
 638                 decode_new_sigaction(tcp, tcp->u_arg[2]);
 639 #if defined(SPARC) || defined(SPARC64)
 640                 tprintf(", %#lx, %lu", tcp->u_arg[3], tcp->u_arg[4]);
 641 #elif defined(ALPHA)
 642                 tprintf(", %lu, %#lx", tcp->u_arg[3], tcp->u_arg[4]);
 643 #else
 644                 tprintf(", %lu", tcp->u_arg[3]);
 645 #endif
 646         }
 647         return 0;
 648 }
 649
 650 SYS_FUNC(rt_sigpending)
 651 {
 652         if (exiting(tcp)) {
 653                 /*
 654                  * One of the few syscalls where sigset size (arg[1])
 655                  * is allowed to be <= NSIG / 8, not strictly ==.
 656                  * This allows non-rt sigpending() syscall
 657                  * to reuse rt_sigpending() code in kernel.
 658                  */
 659                 if (syserror(tcp))
 660                         tprintf("%#lx", tcp->u_arg[0]);
 661                 else
 662                         print_sigset_addr_len(tcp, tcp->u_arg[0], tcp->u_arg[1]);
 663                 tprintf(", %lu", tcp->u_arg[1]);
 664         }
 665         return 0;
 666 }
 667
 668 SYS_FUNC(rt_sigsuspend)
 669 {
 670         if (entering(tcp)) {
 671                 /* NB: kernel requires arg[1] == NSIG / 8 */
 672                 print_sigset_addr_len(tcp, tcp->u_arg[0], tcp->u_arg[1]);
 673                 tprintf(", %lu", tcp->u_arg[1]);
 674         }
 675         return 0;
 676 }
 677
 678 static void
 679 print_sigqueueinfo(struct tcb *tcp, int sig, unsigned long uinfo)
 680 {
 681         printsignal(sig);
 682         tprints(", ");
 683         printsiginfo_at(tcp, uinfo);
 684 }
 685
 686 SYS_FUNC(rt_sigqueueinfo)
 687 {
 688         if (entering(tcp)) {
 689                 tprintf("%lu, ", tcp->u_arg[0]);
 690                 print_sigqueueinfo(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 691         }
 692         return 0;
 693 }
 694
 695 SYS_FUNC(rt_tgsigqueueinfo)
 696 {
 697         if (entering(tcp)) {
 698                 tprintf("%lu, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
 699                 print_sigqueueinfo(tcp, tcp->u_arg[2], tcp->u_arg[3]);
 700         }
 701         return 0;
 702 }
 703
 704 SYS_FUNC(rt_sigtimedwait)
 705 {
 706         /* NB: kernel requires arg[3] == NSIG / 8 */
 707         if (entering(tcp)) {
 708                 print_sigset_addr_len(tcp, tcp->u_arg[0], tcp->u_arg[3]);
 709                 tprints(", ");
 710                 /* This is the only "return" parameter, */
 711                 if (tcp->u_arg[1] != 0)
 712                         return 0;
 713                 /* ... if it's NULL, can decode all on entry */
 714                 tprints("NULL, ");
 715         }
 716         else if (tcp->u_arg[1] != 0) {
 717                 /* syscall exit, and u_arg[1] wasn't NULL */
 718                 printsiginfo_at(tcp, tcp->u_arg[1]);
 719                 tprints(", ");
 720         }
 721         else {
 722                 /* syscall exit, and u_arg[1] was NULL */
 723                 return 0;
 724         }
 725         print_timespec(tcp, tcp->u_arg[2]);
 726         tprintf(", %lu", tcp->u_arg[3]);
 727         return 0;
 728 };
 729
 730 SYS_FUNC(restart_syscall)
 731 {
 732         if (entering(tcp)) {
 733                 tprintf("<... resuming interrupted %s ...>",
 734                         tcp->s_prev_ent
 735                         ? tcp->s_prev_ent->sys_name
 736                         : "system call"
 737                 );
 738         }
 739         return 0;
 740 }
 741
 742 static int
 743 do_signalfd(struct tcb *tcp, int flags_arg)
 744 {
 745         /* NB: kernel requires arg[2] == NSIG / 8 */
 746         if (entering(tcp)) {
 747                 printfd(tcp, tcp->u_arg[0]);
 748                 tprints(", ");
 749                 print_sigset_addr_len(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 750                 tprintf(", %lu", tcp->u_arg[2]);
 751                 if (flags_arg >= 0) {
 752                         tprints(", ");
 753                         printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???");
 754                 }
 755         }
 756         return 0;
 757 }
 758
 759 SYS_FUNC(signalfd)
 760 {
 761         return do_signalfd(tcp, -1);
 762 }
 763
 764 SYS_FUNC(signalfd4)
 765 {
 766         return do_signalfd(tcp, 3);
 767 }