granicus.if.org Git - strace/blob - tests/rt_sigsuspend.c

   1 /*
   2  * This file is part of rt_sigsuspend strace test.
   3  *
   4  * Copyright (c) 2016 Dmitry V. Levin <ldv@altlinux.org>
   5  * Copyright (c) 2016-2019 The strace developers.
   6  * All rights reserved.
   7  *
   8  * SPDX-License-Identifier: GPL-2.0-or-later
   9  */
  10
  11 #include "tests.h"
  12 #include "scno.h"
  13
  14 #ifdef __NR_rt_sigsuspend
  15
  16 # include <assert.h>
  17 # include <errno.h>
  18 # include <signal.h>
  19 # include <stdio.h>
  20 # include <stdint.h>
  21 # include <string.h>
  22 # include <unistd.h>
  23
  24 static long
  25 k_sigsuspend(const sigset_t *const set, const unsigned long size)
  26 {
  27         return syscall(__NR_rt_sigsuspend, set, size);
  28 }
  29
  30 static void
  31 iterate(const char *const text, const int sig,
  32         const void *const set, unsigned int size)
  33 {
  34         const void *mask;
  35
  36         for (mask = set;; size >>= 1, mask += size) {
  37                 raise(sig);
  38                 assert(k_sigsuspend(mask, size) == -1);
  39                 if (EINTR == errno) {
  40                         tprintf("rt_sigsuspend(%s, %u) = ? ERESTARTNOHAND"
  41                                 " (To be restarted if no handler)\n",
  42                                 text, size);
  43                 } else {
  44                         if (size < sizeof(long))
  45                                 tprintf("rt_sigsuspend(%p, %u)"
  46                                         " = -1 EINVAL (%m)\n",
  47                                         mask, size);
  48                         else
  49                                 tprintf("rt_sigsuspend(%s, %u)"
  50                                         " = -1 EINVAL (%m)\n",
  51                                         set == mask ? text : "~[]", size);
  52                 }
  53                 if (!size)
  54                         break;
  55         }
  56 }
  57
  58 static void
  59 handler(int signo)
  60 {
  61 }
  62
  63 int
  64 main(void)
  65 {
  66         tprintf("%s", "");
  67
  68         const unsigned int big_size = 1024 / 8;
  69         void *k_set = tail_alloc(big_size);
  70         memset(k_set, 0, big_size);
  71
  72         TAIL_ALLOC_OBJECT_CONST_PTR(sigset_t, libc_set);
  73         sigemptyset(libc_set);
  74         sigaddset(libc_set, SIGUSR1);
  75         if (sigprocmask(SIG_SETMASK, libc_set, NULL))
  76                 perror_msg_and_fail("sigprocmask");
  77
  78         const struct sigaction sa = {
  79                 .sa_handler = handler
  80         };
  81         if (sigaction(SIGUSR1, &sa, NULL))
  82                 perror_msg_and_fail("sigaction");
  83
  84         raise(SIGUSR1);
  85         unsigned int set_size = big_size;
  86         for (; set_size; set_size >>= 1, k_set += set_size) {
  87                 assert(k_sigsuspend(k_set, set_size) == -1);
  88                 if (EINTR == errno)
  89                         break;
  90                 tprintf("rt_sigsuspend(%p, %u) = -1 EINVAL (%m)\n",
  91                         k_set, set_size);
  92         }
  93         if (!set_size)
  94                 perror_msg_and_fail("rt_sigsuspend");
  95         tprintf("rt_sigsuspend([], %u) = ? ERESTARTNOHAND"
  96                 " (To be restarted if no handler)\n", set_size);
  97
  98         sigemptyset(libc_set);
  99         sigaddset(libc_set, SIGUSR2);
 100         memcpy(k_set, libc_set, set_size);
 101         raise(SIGUSR1);
 102         assert(k_sigsuspend(k_set, set_size) == -1);
 103         assert(EINTR == errno);
 104         tprintf("rt_sigsuspend([USR2], %u) = ? ERESTARTNOHAND"
 105                 " (To be restarted if no handler)\n", set_size);
 106
 107         sigaddset(libc_set, SIGHUP);
 108         memcpy(k_set, libc_set, set_size);
 109         raise(SIGUSR1);
 110         assert(k_sigsuspend(k_set, set_size) == -1);
 111         assert(EINTR == errno);
 112         tprintf("rt_sigsuspend([HUP USR2], %u) = ? ERESTARTNOHAND"
 113                 " (To be restarted if no handler)\n", set_size);
 114
 115         sigaddset(libc_set, SIGINT);
 116         memcpy(k_set, libc_set, set_size);
 117         raise(SIGUSR1);
 118         assert(k_sigsuspend(k_set, set_size) == -1);
 119         assert(EINTR == errno);
 120         tprintf("rt_sigsuspend([HUP INT USR2], %u) = ? ERESTARTNOHAND"
 121                 " (To be restarted if no handler)\n", set_size);
 122
 123         memset(libc_set, -1, sizeof(*libc_set));
 124         sigdelset(libc_set, SIGUSR1);
 125         memcpy(k_set, libc_set, set_size);
 126         raise(SIGUSR1);
 127         assert(k_sigsuspend(k_set, set_size) == -1);
 128         assert(EINTR == errno);
 129         tprintf("rt_sigsuspend(~[USR1], %u) = ? ERESTARTNOHAND"
 130                 " (To be restarted if no handler)\n", set_size);
 131
 132         assert(k_sigsuspend(k_set - set_size, set_size << 1) == -1);
 133         tprintf("rt_sigsuspend(%p, %u) = -1 EINVAL (%m)\n",
 134                 k_set - set_size, set_size << 1);
 135
 136         iterate("~[USR1]", SIGUSR1, k_set, set_size >> 1);
 137
 138         tprintf("+++ exited with 0 +++\n");
 139         return 0;
 140 }
 141
 142 #else
 143
 144 SKIP_MAIN_UNDEFINED("__NR_rt_sigsuspend")
 145
 146 #endif