1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <errno.h>
18#include <signal.h>
19#include <sys/syscall.h>
20#include <sys/types.h>
21#include <unistd.h>
22
23#include <thread>
24
25#include <gtest/gtest.h>
26
27#include "ScopedSignalHandler.h"
28
29static int SIGNAL_MIN() {
30  return 1; // Signals start at 1 (SIGHUP), not 0.
31}
32
33template <typename SigSetT>
34static int SIGNAL_MAX(SigSetT* set) {
35  return sizeof(*set) * 8;
36}
37
38template <typename SigSetT>
39static void TestSigSet1(int (fn)(SigSetT*)) {
40  // NULL sigset_t*/sigset64_t*.
41  SigSetT* set_ptr = NULL;
42  errno = 0;
43  ASSERT_EQ(-1, fn(set_ptr));
44  ASSERT_EQ(EINVAL, errno);
45
46  // Non-NULL.
47  SigSetT set = {};
48  errno = 0;
49  ASSERT_EQ(0, fn(&set));
50  ASSERT_EQ(0, errno);
51}
52
53template <typename SigSetT>
54static void TestSigSet2(int (fn)(SigSetT*, int)) {
55  // NULL sigset_t*/sigset64_t*.
56  SigSetT* set_ptr = NULL;
57  errno = 0;
58  ASSERT_EQ(-1, fn(set_ptr, SIGSEGV));
59  ASSERT_EQ(EINVAL, errno);
60
61  SigSetT set = {};
62
63  // Bad signal number: too small.
64  errno = 0;
65  ASSERT_EQ(-1, fn(&set, 0));
66  ASSERT_EQ(EINVAL, errno);
67
68  // Bad signal number: too high.
69  errno = 0;
70  ASSERT_EQ(-1, fn(&set, SIGNAL_MAX(&set) + 1));
71  ASSERT_EQ(EINVAL, errno);
72
73  // Good signal numbers, low and high ends of range.
74  errno = 0;
75  ASSERT_EQ(0, fn(&set, SIGNAL_MIN()));
76  ASSERT_EQ(0, errno);
77  ASSERT_EQ(0, fn(&set, SIGNAL_MAX(&set)));
78  ASSERT_EQ(0, errno);
79}
80
81TEST(signal, sigaddset_invalid) {
82  TestSigSet2(sigaddset);
83}
84
85TEST(signal, sigaddset64_invalid) {
86#if defined(__BIONIC__)
87  TestSigSet2(sigaddset64);
88#endif
89}
90
91TEST(signal, sigdelset_invalid) {
92  TestSigSet2(sigdelset);
93}
94
95TEST(signal, sigdelset64_invalid) {
96#if defined(__BIONIC__)
97  TestSigSet2(sigdelset64);
98#endif
99}
100
101TEST(signal, sigemptyset_invalid) {
102  TestSigSet1(sigemptyset);
103}
104
105TEST(signal, sigemptyset64_invalid) {
106#if defined(__BIONIC__)
107  TestSigSet1(sigemptyset64);
108#endif
109}
110
111TEST(signal, sigfillset_invalid) {
112  TestSigSet1(sigfillset);
113}
114
115TEST(signal, sigfillset64_invalid) {
116#if defined(__BIONIC__)
117  TestSigSet1(sigfillset64);
118#endif
119}
120
121TEST(signal, sigismember_invalid) {
122  TestSigSet2(sigismember);
123}
124
125TEST(signal, sigismember64_invalid) {
126#if defined(__BIONIC__)
127  TestSigSet2(sigismember64);
128#endif
129}
130
131TEST(signal, raise_invalid) {
132  errno = 0;
133  ASSERT_EQ(-1, raise(-1));
134  ASSERT_EQ(EINVAL, errno);
135}
136
137static void raise_in_signal_handler_helper(int signal_number) {
138  ASSERT_EQ(SIGALRM, signal_number);
139  static int count = 0;
140  if (++count == 1) {
141    raise(SIGALRM);
142  }
143}
144
145TEST(signal, raise_in_signal_handler) {
146  ScopedSignalHandler ssh(SIGALRM, raise_in_signal_handler_helper);
147  raise(SIGALRM);
148}
149
150TEST(signal, sigwait_SIGALRM) {
151  ScopedSignalHandler ssh(SIGALRM, [](int sig) { ASSERT_EQ(SIGALRM, sig); });
152
153  sigset_t wait_set;
154  sigemptyset(&wait_set);
155  sigaddset(&wait_set, SIGALRM);
156
157  alarm(1);
158
159  int received_signal;
160  errno = 0;
161  ASSERT_EQ(0, sigwait(&wait_set, &received_signal));
162  ASSERT_EQ(0, errno);
163  ASSERT_EQ(SIGALRM, received_signal);
164}
165
166TEST(signal, sigwait64_SIGRTMIN) {
167  ScopedSignalHandler ssh(SIGRTMIN, [](int sig) { ASSERT_EQ(SIGRTMIN, sig); });
168
169  sigset64_t wait_set;
170  sigemptyset64(&wait_set);
171  sigaddset64(&wait_set, SIGRTMIN);
172
173  pid_t pid = getpid();
174  std::thread thread([&pid]() {
175    usleep(5000);
176    kill(pid, SIGRTMIN);
177  });
178
179  int received_signal;
180  errno = 0;
181  ASSERT_EQ(0, sigwait64(&wait_set, &received_signal));
182  ASSERT_EQ(0, errno);
183  ASSERT_EQ(SIGRTMIN, received_signal);
184
185  thread.join();
186}
187
188static int g_sigsuspend_signal_handler_call_count = 0;
189
190TEST(signal, sigsuspend_sigpending) {
191  SignalMaskRestorer smr;
192
193  // Block SIGALRM.
194  sigset_t just_SIGALRM;
195  sigemptyset(&just_SIGALRM);
196  sigaddset(&just_SIGALRM, SIGALRM);
197  ASSERT_EQ(0, sigprocmask(SIG_BLOCK, &just_SIGALRM, nullptr));
198
199  ScopedSignalHandler ssh(SIGALRM, [](int) { ++g_sigsuspend_signal_handler_call_count; });
200
201  // There should be no pending signals.
202  sigset_t pending;
203  sigemptyset(&pending);
204  ASSERT_EQ(0, sigpending(&pending));
205  for (int i = SIGNAL_MIN(); i <= SIGNAL_MAX(&pending); ++i) {
206    EXPECT_FALSE(sigismember(&pending, i)) << i;
207  }
208
209  // Raise SIGALRM and check our signal handler wasn't called.
210  raise(SIGALRM);
211  ASSERT_EQ(0, g_sigsuspend_signal_handler_call_count);
212
213  // We should now have a pending SIGALRM but nothing else.
214  sigemptyset(&pending);
215  ASSERT_EQ(0, sigpending(&pending));
216  for (int i = SIGNAL_MIN(); i <= SIGNAL_MAX(&pending); ++i) {
217    EXPECT_EQ((i == SIGALRM), sigismember(&pending, i));
218  }
219
220  // Use sigsuspend to block everything except SIGALRM...
221  sigset_t not_SIGALRM;
222  sigfillset(&not_SIGALRM);
223  sigdelset(&not_SIGALRM, SIGALRM);
224  ASSERT_EQ(-1, sigsuspend(&not_SIGALRM));
225  ASSERT_EQ(EINTR, errno);
226  // ...and check that we now receive our pending SIGALRM.
227  ASSERT_EQ(1, g_sigsuspend_signal_handler_call_count);
228}
229
230static int g_sigsuspend64_signal_handler_call_count = 0;
231
232TEST(signal, sigsuspend64_sigpending64) {
233  SignalMaskRestorer smr;
234
235  // Block SIGRTMIN.
236  sigset64_t just_SIGRTMIN;
237  sigemptyset64(&just_SIGRTMIN);
238  sigaddset64(&just_SIGRTMIN, SIGRTMIN);
239  ASSERT_EQ(0, sigprocmask64(SIG_BLOCK, &just_SIGRTMIN, nullptr));
240
241  ScopedSignalHandler ssh(SIGRTMIN, [](int) { ++g_sigsuspend64_signal_handler_call_count; });
242
243  // There should be no pending signals.
244  sigset64_t pending;
245  sigemptyset64(&pending);
246  ASSERT_EQ(0, sigpending64(&pending));
247  for (int i = SIGNAL_MIN(); i <= SIGNAL_MAX(&pending); ++i) {
248    EXPECT_FALSE(sigismember64(&pending, i)) << i;
249  }
250
251  // Raise SIGRTMIN and check our signal handler wasn't called.
252  raise(SIGRTMIN);
253  ASSERT_EQ(0, g_sigsuspend64_signal_handler_call_count);
254
255  // We should now have a pending SIGRTMIN but nothing else.
256  sigemptyset64(&pending);
257  ASSERT_EQ(0, sigpending64(&pending));
258  for (int i = SIGNAL_MIN(); i <= SIGNAL_MAX(&pending); ++i) {
259    EXPECT_EQ((i == SIGRTMIN), sigismember64(&pending, i));
260  }
261
262  // Use sigsuspend64 to block everything except SIGRTMIN...
263  sigset64_t not_SIGRTMIN;
264  sigfillset64(&not_SIGRTMIN);
265  sigdelset64(&not_SIGRTMIN, SIGRTMIN);
266  ASSERT_EQ(-1, sigsuspend64(&not_SIGRTMIN));
267  ASSERT_EQ(EINTR, errno);
268  // ...and check that we now receive our pending SIGRTMIN.
269  ASSERT_EQ(1, g_sigsuspend64_signal_handler_call_count);
270}
271
272template <typename SigActionT, typename SigSetT>
273static void TestSigAction(int (sigaction_fn)(int, const SigActionT*, SigActionT*),
274                          int (sigaddset_fn)(SigSetT*, int),
275                          int sig) {
276  // Both bionic and glibc set SA_RESTORER when talking to the kernel on arm,
277  // arm64, x86, and x86-64. The version of glibc we're using also doesn't
278  // define SA_RESTORER, but luckily it's the same value everywhere, and mips
279  // doesn't use the bit for anything.
280  static const unsigned sa_restorer = 0x4000000;
281
282  // See what's currently set for this signal.
283  SigActionT original_sa = {};
284  ASSERT_EQ(0, sigaction_fn(sig, NULL, &original_sa));
285  ASSERT_TRUE(original_sa.sa_handler == NULL);
286  ASSERT_TRUE(original_sa.sa_sigaction == NULL);
287  ASSERT_EQ(0U, original_sa.sa_flags & ~sa_restorer);
288#ifdef SA_RESTORER
289  ASSERT_EQ(bool(original_sa.sa_flags & sa_restorer), bool(original_sa.sa_restorer));
290#endif
291
292  // Set a traditional sa_handler signal handler.
293  auto no_op_signal_handler = [](int) {};
294  SigActionT sa = {};
295  sigaddset_fn(&sa.sa_mask, sig);
296  sa.sa_flags = SA_ONSTACK;
297  sa.sa_handler = no_op_signal_handler;
298  ASSERT_EQ(0, sigaction_fn(sig, &sa, NULL));
299
300  // Check that we can read it back.
301  sa = {};
302  ASSERT_EQ(0, sigaction_fn(sig, NULL, &sa));
303  ASSERT_TRUE(sa.sa_handler == no_op_signal_handler);
304  ASSERT_TRUE((void*) sa.sa_sigaction == (void*) sa.sa_handler);
305  ASSERT_EQ(static_cast<unsigned>(SA_ONSTACK), sa.sa_flags & ~sa_restorer);
306#ifdef SA_RESTORER
307  ASSERT_EQ(bool(sa.sa_flags & sa_restorer), bool(sa.sa_restorer));
308#endif
309
310  // Set a new-style sa_sigaction signal handler.
311  auto no_op_sigaction = [](int, siginfo_t*, void*) {};
312  sa = {};
313  sigaddset_fn(&sa.sa_mask, sig);
314  sa.sa_flags = SA_ONSTACK | SA_SIGINFO;
315  sa.sa_sigaction = no_op_sigaction;
316  ASSERT_EQ(0, sigaction_fn(sig, &sa, NULL));
317
318  // Check that we can read it back.
319  sa = {};
320  ASSERT_EQ(0, sigaction_fn(sig, NULL, &sa));
321  ASSERT_TRUE(sa.sa_sigaction == no_op_sigaction);
322  ASSERT_TRUE((void*) sa.sa_sigaction == (void*) sa.sa_handler);
323  ASSERT_EQ(static_cast<unsigned>(SA_ONSTACK | SA_SIGINFO), sa.sa_flags & ~sa_restorer);
324#ifdef SA_RESTORER
325  ASSERT_EQ(bool(sa.sa_flags & sa_restorer), bool(sa.sa_restorer));
326#endif
327
328  // Put everything back how it was.
329  ASSERT_EQ(0, sigaction_fn(sig, &original_sa, NULL));
330}
331
332TEST(signal, sigaction) {
333  TestSigAction(sigaction, sigaddset, SIGALRM);
334}
335
336TEST(signal, sigaction64_SIGRTMIN) {
337  TestSigAction(sigaction64, sigaddset64, SIGRTMIN);
338}
339
340static void ClearSignalMask() {
341  uint64_t sigset = 0;
342  if (syscall(__NR_rt_sigprocmask, SIG_SETMASK, &sigset, nullptr, sizeof(sigset)) != 0) {
343    abort();
344  }
345}
346
347static uint64_t GetSignalMask() {
348  uint64_t sigset;
349  if (syscall(__NR_rt_sigprocmask, SIG_SETMASK, nullptr, &sigset, sizeof(sigset)) != 0) {
350    abort();
351  }
352  return sigset;
353}
354
355enum class SignalMaskFunctionType {
356  RtAware,
357  RtNonaware,
358};
359
360#if defined(__LP64__) || !defined(__BIONIC__)
361constexpr SignalMaskFunctionType sigset_type = SignalMaskFunctionType::RtAware;
362#else
363constexpr SignalMaskFunctionType sigset_type = SignalMaskFunctionType::RtNonaware;
364#endif
365
366static void TestSignalMaskFiltered(uint64_t sigset, SignalMaskFunctionType type) {
367  for (int signo = 1; signo <= 64; ++signo) {
368    bool signal_blocked = sigset & (1ULL << (signo - 1));
369    if (signo == SIGKILL || signo == SIGSTOP) {
370      // SIGKILL and SIGSTOP shouldn't be blocked.
371      EXPECT_EQ(false, signal_blocked) << "signal " << signo;
372    } else if (signo < __SIGRTMIN) {
373      // Everything else should be blocked.
374      EXPECT_EQ(true, signal_blocked) << "signal " << signo;
375    } else if (signo >= __SIGRTMIN && signo < SIGRTMIN) {
376      // Reserved signals must not be blocked.
377      EXPECT_EQ(false, signal_blocked) << "signal " << signo;
378    } else if (type == SignalMaskFunctionType::RtAware) {
379      // Realtime signals should be blocked, unless we blocked using a non-rt aware function.
380      EXPECT_EQ(true, signal_blocked) << "signal " << signo;
381    }
382  }
383}
384
385static void TestSignalMaskFunction(std::function<void()> fn, SignalMaskFunctionType fn_type) {
386  ClearSignalMask();
387  fn();
388  TestSignalMaskFiltered(GetSignalMask(), fn_type);
389}
390
391TEST(signal, sigaction_filter) {
392  ClearSignalMask();
393  static uint64_t sigset;
394  struct sigaction sa = {};
395  sa.sa_handler = [](int) { sigset = GetSignalMask(); };
396  sigfillset(&sa.sa_mask);
397  sigaction(SIGUSR1, &sa, nullptr);
398  raise(SIGUSR1);
399  ASSERT_NE(0ULL, sigset);
400  TestSignalMaskFiltered(sigset, sigset_type);
401}
402
403TEST(signal, sigaction64_filter) {
404  ClearSignalMask();
405  static uint64_t sigset;
406  struct sigaction64 sa = {};
407  sa.sa_handler = [](int) { sigset = GetSignalMask(); };
408  sigfillset64(&sa.sa_mask);
409  sigaction64(SIGUSR1, &sa, nullptr);
410  raise(SIGUSR1);
411  ASSERT_NE(0ULL, sigset);
412  TestSignalMaskFiltered(sigset, SignalMaskFunctionType::RtAware);
413}
414
415TEST(signal, sigprocmask_setmask_filter) {
416  TestSignalMaskFunction(
417      []() {
418        sigset_t sigset_libc;
419        sigfillset(&sigset_libc);
420        ASSERT_EQ(0, sigprocmask(SIG_SETMASK, &sigset_libc, nullptr));
421      },
422      sigset_type);
423}
424
425TEST(signal, sigprocmask64_setmask_filter) {
426  TestSignalMaskFunction(
427      []() {
428        sigset64_t sigset_libc;
429        sigfillset64(&sigset_libc);
430        ASSERT_EQ(0, sigprocmask64(SIG_SETMASK, &sigset_libc, nullptr));
431      },
432      SignalMaskFunctionType::RtAware);
433}
434
435TEST(signal, pthread_sigmask_setmask_filter) {
436  TestSignalMaskFunction(
437      []() {
438        sigset_t sigset_libc;
439        sigfillset(&sigset_libc);
440        ASSERT_EQ(0, pthread_sigmask(SIG_SETMASK, &sigset_libc, nullptr));
441      },
442      sigset_type);
443}
444
445TEST(signal, pthread_sigmask64_setmask_filter) {
446  TestSignalMaskFunction(
447      []() {
448        sigset64_t sigset_libc;
449        sigfillset64(&sigset_libc);
450        ASSERT_EQ(0, pthread_sigmask64(SIG_SETMASK, &sigset_libc, nullptr));
451      },
452      SignalMaskFunctionType::RtAware);
453}
454
455TEST(signal, sigprocmask_block_filter) {
456  TestSignalMaskFunction(
457      []() {
458        sigset_t sigset_libc;
459        sigfillset(&sigset_libc);
460        ASSERT_EQ(0, sigprocmask(SIG_BLOCK, &sigset_libc, nullptr));
461      },
462      sigset_type);
463}
464
465TEST(signal, sigprocmask64_block_filter) {
466  TestSignalMaskFunction(
467      []() {
468        sigset64_t sigset_libc;
469        sigfillset64(&sigset_libc);
470        ASSERT_EQ(0, sigprocmask64(SIG_BLOCK, &sigset_libc, nullptr));
471      },
472      SignalMaskFunctionType::RtAware);
473}
474
475TEST(signal, pthread_sigmask_block_filter) {
476  TestSignalMaskFunction(
477      []() {
478        sigset_t sigset_libc;
479        sigfillset(&sigset_libc);
480        ASSERT_EQ(0, pthread_sigmask(SIG_BLOCK, &sigset_libc, nullptr));
481      },
482      sigset_type);
483}
484
485TEST(signal, pthread_sigmask64_block_filter) {
486  TestSignalMaskFunction(
487      []() {
488        sigset64_t sigset_libc;
489        sigfillset64(&sigset_libc);
490        ASSERT_EQ(0, pthread_sigmask64(SIG_BLOCK, &sigset_libc, nullptr));
491      },
492      SignalMaskFunctionType::RtAware);
493}
494
495// glibc filters out signals via sigfillset, not the actual underlying functions.
496TEST(signal, sigset_filter) {
497#if defined(__BIONIC__)
498  TestSignalMaskFunction(
499      []() {
500        for (int i = 1; i <= 64; ++i) {
501          sigset(i, SIG_HOLD);
502        }
503      },
504      SignalMaskFunctionType::RtAware);
505#endif
506}
507
508TEST(signal, sighold_filter) {
509#if defined(__BIONIC__)
510  TestSignalMaskFunction(
511      []() {
512        for (int i = 1; i <= 64; ++i) {
513          sighold(i);
514        }
515      },
516      SignalMaskFunctionType::RtAware);
517#endif
518}
519
520#if defined(__BIONIC__)
521// Not exposed via headers, but the symbols are available if you declare them yourself.
522extern "C" int sigblock(int);
523extern "C" int sigsetmask(int);
524#endif
525
526TEST(signal, sigblock_filter) {
527#if defined(__BIONIC__)
528  TestSignalMaskFunction(
529      []() {
530        int mask = ~0U;
531        ASSERT_EQ(0, sigblock(mask));
532      },
533      SignalMaskFunctionType::RtNonaware);
534#endif
535}
536
537TEST(signal, sigsetmask_filter) {
538#if defined(__BIONIC__)
539  TestSignalMaskFunction(
540      []() {
541        int mask = ~0U;
542        ASSERT_EQ(0, sigsetmask(mask));
543      },
544      SignalMaskFunctionType::RtNonaware);
545#endif
546}
547
548TEST(signal, sys_signame) {
549#if defined(__BIONIC__)
550  ASSERT_TRUE(sys_signame[0] == NULL);
551  ASSERT_STREQ("HUP", sys_signame[SIGHUP]);
552#else
553  GTEST_LOG_(INFO) << "This test does nothing.\n";
554#endif
555}
556
557TEST(signal, sys_siglist) {
558  ASSERT_TRUE(sys_siglist[0] == NULL);
559  ASSERT_STREQ("Hangup", sys_siglist[SIGHUP]);
560}
561
562TEST(signal, limits) {
563  // This comes from the kernel.
564  ASSERT_EQ(32, __SIGRTMIN);
565
566  // We reserve a non-zero number at the bottom for ourselves.
567  ASSERT_GT(SIGRTMIN, __SIGRTMIN);
568
569  // MIPS has more signals than everyone else.
570#if defined(__mips__)
571  ASSERT_EQ(128, __SIGRTMAX);
572#else
573  ASSERT_EQ(64, __SIGRTMAX);
574#endif
575
576  // We don't currently reserve any at the top.
577  ASSERT_EQ(SIGRTMAX, __SIGRTMAX);
578}
579
580static int g_sigqueue_signal_handler_call_count = 0;
581
582static void SigqueueSignalHandler(int signum, siginfo_t* info, void*) {
583  ASSERT_EQ(SIGALRM, signum);
584  ASSERT_EQ(SIGALRM, info->si_signo);
585  ASSERT_EQ(SI_QUEUE, info->si_code);
586  ASSERT_EQ(1, info->si_value.sival_int);
587  ++g_sigqueue_signal_handler_call_count;
588}
589
590TEST(signal, sigqueue) {
591  ScopedSignalHandler ssh(SIGALRM, SigqueueSignalHandler, SA_SIGINFO);
592  sigval_t sigval;
593  sigval.sival_int = 1;
594  errno = 0;
595  ASSERT_EQ(0, sigqueue(getpid(), SIGALRM, sigval));
596  ASSERT_EQ(0, errno);
597  ASSERT_EQ(1, g_sigqueue_signal_handler_call_count);
598}
599
600TEST(signal, sigwaitinfo) {
601  SignalMaskRestorer smr;
602
603  // Block SIGALRM.
604  sigset_t just_SIGALRM;
605  sigemptyset(&just_SIGALRM);
606  sigaddset(&just_SIGALRM, SIGALRM);
607  ASSERT_EQ(0, sigprocmask(SIG_BLOCK, &just_SIGALRM, nullptr));
608
609  // Raise SIGALRM.
610  sigval_t sigval;
611  sigval.sival_int = 1;
612  ASSERT_EQ(0, sigqueue(getpid(), SIGALRM, sigval));
613
614  // Get pending SIGALRM.
615  siginfo_t info;
616  errno = 0;
617  ASSERT_EQ(SIGALRM, sigwaitinfo(&just_SIGALRM, &info));
618  ASSERT_EQ(0, errno);
619  ASSERT_EQ(SIGALRM, info.si_signo);
620  ASSERT_EQ(1, info.si_value.sival_int);
621}
622
623TEST(signal, sigwaitinfo64_SIGRTMIN) {
624  SignalMaskRestorer smr;
625
626  // Block SIGRTMIN.
627  sigset64_t just_SIGRTMIN;
628  sigemptyset64(&just_SIGRTMIN);
629  sigaddset64(&just_SIGRTMIN, SIGRTMIN);
630  ASSERT_EQ(0, sigprocmask64(SIG_BLOCK, &just_SIGRTMIN, nullptr));
631
632  // Raise SIGRTMIN.
633  sigval_t sigval;
634  sigval.sival_int = 1;
635  ASSERT_EQ(0, sigqueue(getpid(), SIGRTMIN, sigval));
636
637  // Get pending SIGRTMIN.
638  siginfo_t info;
639  errno = 0;
640  ASSERT_EQ(SIGRTMIN, sigwaitinfo64(&just_SIGRTMIN, &info));
641  ASSERT_EQ(0, errno);
642  ASSERT_EQ(SIGRTMIN, info.si_signo);
643  ASSERT_EQ(1, info.si_value.sival_int);
644}
645
646TEST(signal, sigtimedwait) {
647  SignalMaskRestorer smr;
648
649  // Block SIGALRM.
650  sigset_t just_SIGALRM;
651  sigemptyset(&just_SIGALRM);
652  sigaddset(&just_SIGALRM, SIGALRM);
653  ASSERT_EQ(0, sigprocmask(SIG_BLOCK, &just_SIGALRM, nullptr));
654
655  // Raise SIGALRM.
656  sigval_t sigval = { .sival_int = 1 };
657  ASSERT_EQ(0, sigqueue(getpid(), SIGALRM, sigval));
658
659  // Get pending SIGALRM.
660  siginfo_t info;
661  timespec timeout = { .tv_sec = 2, .tv_nsec = 0 };
662  errno = 0;
663  ASSERT_EQ(SIGALRM, sigtimedwait(&just_SIGALRM, &info, &timeout));
664  ASSERT_EQ(0, errno);
665}
666
667TEST(signal, sigtimedwait64_SIGRTMIN) {
668  SignalMaskRestorer smr;
669
670  // Block SIGRTMIN.
671  sigset64_t just_SIGRTMIN;
672  sigemptyset64(&just_SIGRTMIN);
673  sigaddset64(&just_SIGRTMIN, SIGRTMIN);
674  ASSERT_EQ(0, sigprocmask64(SIG_BLOCK, &just_SIGRTMIN, nullptr));
675
676  // Raise SIGALRM.
677  sigval_t sigval = { .sival_int = 1 };
678  ASSERT_EQ(0, sigqueue(getpid(), SIGRTMIN, sigval));
679
680  // Get pending SIGALRM.
681  siginfo_t info;
682  timespec timeout = { .tv_sec = 2, .tv_nsec = 0 };
683  errno = 0;
684  ASSERT_EQ(SIGRTMIN, sigtimedwait64(&just_SIGRTMIN, &info, &timeout));
685  ASSERT_EQ(0, errno);
686}
687
688static int64_t NanoTime() {
689  timespec t;
690  clock_gettime(CLOCK_MONOTONIC, &t);
691  return static_cast<int64_t>(t.tv_sec) * 1000000000LL + t.tv_nsec;
692}
693
694TEST(signal, sigtimedwait_timeout) {
695  // Block SIGALRM.
696  sigset_t just_SIGALRM;
697  sigemptyset(&just_SIGALRM);
698  sigaddset(&just_SIGALRM, SIGALRM);
699  sigset_t original_set;
700  ASSERT_EQ(0, sigprocmask(SIG_BLOCK, &just_SIGALRM, &original_set));
701
702  // Wait timeout.
703  int64_t start_time = NanoTime();
704  siginfo_t info;
705  timespec timeout = { .tv_sec = 0, .tv_nsec = 1000000 };
706  errno = 0;
707  ASSERT_EQ(-1, sigtimedwait(&just_SIGALRM, &info, &timeout));
708  ASSERT_EQ(EAGAIN, errno);
709  ASSERT_GE(NanoTime() - start_time, 1000000);
710
711  ASSERT_EQ(0, sigprocmask(SIG_SETMASK, &original_set, NULL));
712}
713
714#if defined(__BIONIC__)
715TEST(signal, rt_tgsigqueueinfo) {
716  // Test whether rt_tgsigqueueinfo allows sending arbitrary si_code values to self.
717  // If this fails, your kernel needs commit 66dd34a to be backported.
718  static constexpr char error_msg[] =
719    "\nPlease ensure that the following kernel patch has been applied:\n"
720    "* https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=66dd34ad31e5963d72a700ec3f2449291d322921\n";
721  static siginfo received;
722
723  struct sigaction handler = {};
724  handler.sa_sigaction = [](int, siginfo_t* siginfo, void*) { received = *siginfo; };
725  handler.sa_flags = SA_SIGINFO;
726
727  ASSERT_EQ(0, sigaction(SIGUSR1, &handler, nullptr));
728
729  siginfo sent;
730  memset(&sent, 0, sizeof(sent));
731
732  sent.si_code = SI_TKILL;
733  ASSERT_EQ(0, syscall(SYS_rt_tgsigqueueinfo, getpid(), gettid(), SIGUSR1, &sent))
734    << "rt_tgsigqueueinfo failed: " << strerror(errno) << error_msg;
735  ASSERT_EQ(sent.si_code, received.si_code) << "rt_tgsigqueueinfo modified si_code, expected "
736                                            << sent.si_code << ", received " << received.si_code
737                                            << error_msg;
738
739  sent.si_code = SI_USER;
740  ASSERT_EQ(0, syscall(SYS_rt_tgsigqueueinfo, getpid(), gettid(), SIGUSR1, &sent))
741    << "rt_tgsigqueueinfo failed: " << strerror(errno) << error_msg;
742  ASSERT_EQ(sent.si_code, received.si_code) << "rt_tgsigqueueinfo modified si_code, expected "
743                                            << sent.si_code << ", received " << received.si_code
744                                            << error_msg;
745}
746#endif
747
748TEST(signal, sigset_size) {
749  // The setjmp implementations for ARM, AArch64, x86, and x86_64 assume that sigset_t can fit in a
750  // long. This is true because ARM and x86 have broken rt signal support, and AArch64 and x86_64
751  // both have a SIGRTMAX defined as 64.
752#if defined(__arm__) || defined(__aarch64__) || defined(__i386__) || defined(__x86_64__)
753#if defined(__BIONIC__)
754  static_assert(sizeof(sigset_t) <= sizeof(long), "sigset_t doesn't fit in a long");
755#endif
756  static_assert(sizeof(sigset64_t)*8 >= 64, "sigset64_t too small for real-time signals");
757#endif
758}
759
760TEST(signal, sigignore_EINVAL) {
761  errno = 0;
762  ASSERT_EQ(-1, sigignore(99999));
763  ASSERT_EQ(EINVAL, errno);
764}
765
766TEST(signal, sigignore) {
767  errno = 0;
768  EXPECT_EQ(-1, sigignore(SIGKILL));
769  EXPECT_EQ(errno, EINVAL);
770
771  errno = 0;
772  EXPECT_EQ(-1, sigignore(SIGSTOP));
773  EXPECT_EQ(errno, EINVAL);
774
775  ScopedSignalHandler sigalrm{SIGALRM};
776  ASSERT_EQ(0, sigignore(SIGALRM));
777
778  struct sigaction sa;
779  ASSERT_EQ(0, sigaction(SIGALRM, nullptr, &sa));
780  EXPECT_EQ(SIG_IGN, sa.sa_handler);
781}
782
783TEST(signal, sighold_EINVAL) {
784  errno = 0;
785  ASSERT_EQ(-1, sighold(99999));
786  ASSERT_EQ(EINVAL, errno);
787}
788
789TEST(signal, sigpause_EINVAL) {
790  errno = 0;
791  ASSERT_EQ(-1, sigpause(99999));
792  ASSERT_EQ(EINVAL, errno);
793}
794
795TEST(signal, sigrelse_EINVAL) {
796  errno = 0;
797  ASSERT_EQ(-1, sigpause(99999));
798  ASSERT_EQ(EINVAL, errno);
799}
800
801static void TestSigholdSigpauseSigrelse(int sig) {
802  static int signal_handler_call_count = 0;
803  ScopedSignalHandler ssh{sig, [](int) { signal_handler_call_count++; }};
804  SignalMaskRestorer mask_restorer;
805  sigset_t set;
806
807  // sighold(SIGALRM/SIGRTMIN) should add SIGALRM/SIGRTMIN to the signal mask ...
808  ASSERT_EQ(0, sighold(sig));
809  ASSERT_EQ(0, sigprocmask(SIG_SETMASK, 0, &set));
810  EXPECT_TRUE(sigismember(&set, sig));
811
812  // ... preventing our SIGALRM/SIGRTMIN handler from running ...
813  raise(sig);
814  ASSERT_EQ(0, signal_handler_call_count);
815  // ... until sigpause(SIGALRM/SIGRTMIN) temporarily unblocks it.
816  ASSERT_EQ(-1, sigpause(sig));
817  ASSERT_EQ(EINTR, errno);
818  ASSERT_EQ(1, signal_handler_call_count);
819
820  if (sig >= SIGRTMIN && sizeof(void*) == 8) {
821    // But sigpause(SIGALRM/SIGRTMIN) shouldn't permanently unblock SIGALRM/SIGRTMIN.
822    ASSERT_EQ(0, sigprocmask(SIG_SETMASK, 0, &set));
823    EXPECT_TRUE(sigismember(&set, sig));
824
825    // Whereas sigrelse(SIGALRM/SIGRTMIN) should.
826    ASSERT_EQ(0, sigrelse(sig));
827    ASSERT_EQ(0, sigprocmask(SIG_SETMASK, 0, &set));
828    EXPECT_FALSE(sigismember(&set, sig));
829  } else {
830    // sigismember won't work for SIGRTMIN on LP32.
831  }
832}
833
834TEST(signal, sighold_sigpause_sigrelse) {
835  TestSigholdSigpauseSigrelse(SIGALRM);
836}
837
838TEST(signal, sighold_sigpause_sigrelse_RT) {
839  TestSigholdSigpauseSigrelse(SIGRTMIN);
840}
841
842TEST(signal, sigset_EINVAL) {
843  errno = 0;
844  ASSERT_EQ(SIG_ERR, sigset(99999, SIG_DFL));
845  ASSERT_EQ(EINVAL, errno);
846}
847
848TEST(signal, sigset_RT) {
849  static int signal_handler_call_count = 0;
850  auto signal_handler = [](int) { signal_handler_call_count++; };
851  ScopedSignalHandler ssh{SIGRTMIN, signal_handler};
852  SignalMaskRestorer mask_restorer;
853
854  ASSERT_EQ(signal_handler, sigset(SIGRTMIN, SIG_HOLD));
855#if defined(__LP64__)
856  sigset_t set;
857  ASSERT_EQ(0, sigprocmask(SIG_BLOCK, nullptr, &set));
858  ASSERT_TRUE(sigismember(&set, SIGRTMIN));
859#endif
860
861  ASSERT_EQ(SIG_HOLD, sigset(SIGRTMIN, signal_handler));
862  ASSERT_EQ(signal_handler, sigset(SIGRTMIN, signal_handler));
863  ASSERT_EQ(0, signal_handler_call_count);
864  raise(SIGRTMIN);
865  ASSERT_EQ(1, signal_handler_call_count);
866}
867
868TEST(signal, sigset) {
869  static int signal_handler_call_count = 0;
870  auto signal_handler = [](int) { signal_handler_call_count++; };
871  ScopedSignalHandler ssh{SIGALRM, signal_handler};
872  SignalMaskRestorer mask_restorer;
873
874  ASSERT_EQ(0, signal_handler_call_count);
875  raise(SIGALRM);
876  ASSERT_EQ(1, signal_handler_call_count);
877
878  // Block SIGALRM so the next sigset(SIGARLM) call will return SIG_HOLD.
879  sigset_t set;
880  sigemptyset(&set);
881  sigaddset(&set, SIGALRM);
882  ASSERT_EQ(0, sigprocmask(SIG_BLOCK, &set, nullptr));
883
884  sigemptyset(&set);
885  ASSERT_EQ(SIG_HOLD, sigset(SIGALRM, signal_handler));
886  ASSERT_EQ(0, sigprocmask(SIG_BLOCK, nullptr, &set));
887  EXPECT_FALSE(sigismember(&set, SIGALRM));
888
889  ASSERT_EQ(signal_handler, sigset(SIGALRM, SIG_IGN));
890  ASSERT_EQ(0, sigprocmask(SIG_BLOCK, nullptr, &set));
891  EXPECT_FALSE(sigismember(&set, SIGALRM));
892
893  ASSERT_EQ(SIG_IGN, sigset(SIGALRM, SIG_DFL));
894  ASSERT_EQ(0, sigprocmask(SIG_BLOCK, nullptr, &set));
895  EXPECT_FALSE(sigismember(&set, SIGALRM));
896
897  ASSERT_EQ(SIG_DFL, sigset(SIGALRM, SIG_HOLD));
898  ASSERT_EQ(0, sigprocmask(SIG_BLOCK, nullptr, &set));
899  EXPECT_TRUE(sigismember(&set, SIGALRM));
900}
901
902TEST(signal, killpg_EINVAL) {
903  // POSIX leaves pgrp <= 1 undefined, but glibc fails with EINVAL for < 0
904  // and passes 0 through to kill(2).
905  errno = 0;
906  ASSERT_EQ(-1, killpg(-1, SIGKILL));
907  ASSERT_EQ(EINVAL, errno);
908}
909