• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <gtest/gtest.h>
18 
19 #include <errno.h>
20 #include <signal.h>
21 
22 #include "ScopedSignalHandler.h"
23 
SIGNAL_MIN()24 static size_t SIGNAL_MIN() {
25   return 1; // Signals start at 1 (SIGHUP), not 0.
26 }
27 
SIGNAL_MAX()28 static size_t SIGNAL_MAX() {
29   size_t result = SIGRTMAX;
30 
31 #if defined(__BIONIC__) && !defined(__mips__) && !defined(__LP64__)
32   // 32-bit bionic's sigset_t is too small for ARM and x86: 32 bits instead of 64.
33   // This means you can't refer to any of the real-time signals.
34   // See http://b/3038348 and http://b/5828899.
35   result = 32;
36 #else
37   // Otherwise, C libraries should be perfectly capable of using their largest signal.
38   if (sizeof(sigset_t) * 8 < static_cast<size_t>(SIGRTMAX)) {
39     abort();
40   }
41 #endif
42 
43   return result;
44 }
45 
46 template <typename Fn>
TestSigSet1(Fn fn)47 static void TestSigSet1(Fn fn) {
48   // NULL sigset_t*.
49   sigset_t* set_ptr = NULL;
50   errno = 0;
51   ASSERT_EQ(-1, fn(set_ptr));
52   ASSERT_EQ(EINVAL, errno);
53 
54   // Non-NULL.
55   sigset_t set;
56   errno = 0;
57   ASSERT_EQ(0, fn(&set));
58   ASSERT_EQ(0, errno);
59 }
60 
61 template <typename Fn>
TestSigSet2(Fn fn)62 static void TestSigSet2(Fn fn) {
63   // NULL sigset_t*.
64   sigset_t* set_ptr = NULL;
65   errno = 0;
66   ASSERT_EQ(-1, fn(set_ptr, SIGSEGV));
67   ASSERT_EQ(EINVAL, errno);
68 
69   sigset_t set;
70   sigemptyset(&set);
71 
72   // Bad signal number: too small.
73   errno = 0;
74   ASSERT_EQ(-1, fn(&set, 0));
75   ASSERT_EQ(EINVAL, errno);
76 
77   // Bad signal number: too high.
78   errno = 0;
79   ASSERT_EQ(-1, fn(&set, SIGNAL_MAX() + 1));
80   ASSERT_EQ(EINVAL, errno);
81 
82   // Good signal numbers, low and high ends of range.
83   errno = 0;
84   ASSERT_EQ(0, fn(&set, SIGNAL_MIN()));
85   ASSERT_EQ(0, errno);
86   ASSERT_EQ(0, fn(&set, SIGNAL_MAX()));
87   ASSERT_EQ(0, errno);
88 }
89 
TEST(signal,sigismember_invalid)90 TEST(signal, sigismember_invalid) {
91   TestSigSet2(sigismember);
92 }
93 
TEST(signal,sigaddset_invalid)94 TEST(signal, sigaddset_invalid) {
95   TestSigSet2(sigaddset);
96 }
97 
TEST(signal,sigdelset_invalid)98 TEST(signal, sigdelset_invalid) {
99   TestSigSet2(sigdelset);
100 }
101 
TEST(signal,sigemptyset_invalid)102 TEST(signal, sigemptyset_invalid) {
103   TestSigSet1(sigemptyset);
104 }
105 
TEST(signal,sigfillset_invalid)106 TEST(signal, sigfillset_invalid) {
107   TestSigSet1(sigfillset);
108 }
109 
TEST(signal,raise_invalid)110 TEST(signal, raise_invalid) {
111   errno = 0;
112   ASSERT_EQ(-1, raise(-1));
113   ASSERT_EQ(EINVAL, errno);
114 }
115 
raise_in_signal_handler_helper(int signal_number)116 static void raise_in_signal_handler_helper(int signal_number) {
117   ASSERT_EQ(SIGALRM, signal_number);
118   static int count = 0;
119   if (++count == 1) {
120     raise(SIGALRM);
121   }
122 }
123 
TEST(signal,raise_in_signal_handler)124 TEST(signal, raise_in_signal_handler) {
125   ScopedSignalHandler ssh(SIGALRM, raise_in_signal_handler_helper);
126   raise(SIGALRM);
127 }
128 
HandleSIGALRM(int signal_number)129 static void HandleSIGALRM(int signal_number) {
130   ASSERT_EQ(SIGALRM, signal_number);
131 }
132 
TEST(signal,sigwait)133 TEST(signal, sigwait) {
134   ScopedSignalHandler ssh(SIGALRM, HandleSIGALRM);
135 
136   sigset_t wait_set;
137   sigemptyset(&wait_set);
138   sigaddset(&wait_set, SIGALRM);
139 
140   alarm(1);
141 
142   int received_signal;
143   errno = 0;
144   ASSERT_EQ(0, sigwait(&wait_set, &received_signal));
145   ASSERT_EQ(0, errno);
146   ASSERT_EQ(SIGALRM, received_signal);
147 }
148 
149 static int g_sigsuspend_test_helper_call_count = 0;
150 
SigSuspendTestHelper(int)151 static void SigSuspendTestHelper(int) {
152   ++g_sigsuspend_test_helper_call_count;
153 }
154 
TEST(signal,sigsuspend_sigpending)155 TEST(signal, sigsuspend_sigpending) {
156   // Block SIGALRM.
157   sigset_t just_SIGALRM;
158   sigemptyset(&just_SIGALRM);
159   sigaddset(&just_SIGALRM, SIGALRM);
160   sigset_t original_set;
161   ASSERT_EQ(0, sigprocmask(SIG_BLOCK, &just_SIGALRM, &original_set));
162 
163   ScopedSignalHandler ssh(SIGALRM, SigSuspendTestHelper);
164 
165   // There should be no pending signals.
166   sigset_t pending;
167   sigemptyset(&pending);
168   ASSERT_EQ(0, sigpending(&pending));
169   for (size_t i = SIGNAL_MIN(); i <= SIGNAL_MAX(); ++i) {
170     EXPECT_FALSE(sigismember(&pending, i)) << i;
171   }
172 
173   // Raise SIGALRM and check our signal handler wasn't called.
174   raise(SIGALRM);
175   ASSERT_EQ(0, g_sigsuspend_test_helper_call_count);
176 
177   // We should now have a pending SIGALRM but nothing else.
178   sigemptyset(&pending);
179   ASSERT_EQ(0, sigpending(&pending));
180   for (size_t i = SIGNAL_MIN(); i <= SIGNAL_MAX(); ++i) {
181     EXPECT_EQ((i == SIGALRM), sigismember(&pending, i));
182   }
183 
184   // Use sigsuspend to block everything except SIGALRM...
185   sigset_t not_SIGALRM;
186   sigfillset(&not_SIGALRM);
187   sigdelset(&not_SIGALRM, SIGALRM);
188   ASSERT_EQ(-1, sigsuspend(&not_SIGALRM));
189   ASSERT_EQ(EINTR, errno);
190   // ...and check that we now receive our pending SIGALRM.
191   ASSERT_EQ(1, g_sigsuspend_test_helper_call_count);
192 
193   // Restore the original set.
194   ASSERT_EQ(0, sigprocmask(SIG_SETMASK, &original_set, NULL));
195 }
196 
EmptySignalHandler(int)197 static void EmptySignalHandler(int) {}
EmptySignalAction(int,siginfo_t *,void *)198 static void EmptySignalAction(int, siginfo_t*, void*) {}
199 
TEST(signal,sigaction)200 TEST(signal, sigaction) {
201   // See what's currently set for SIGALRM.
202   struct sigaction original_sa;
203   memset(&original_sa, 0, sizeof(original_sa));
204   ASSERT_EQ(0, sigaction(SIGALRM, NULL, &original_sa));
205   ASSERT_TRUE(original_sa.sa_handler == NULL);
206   ASSERT_TRUE(original_sa.sa_sigaction == NULL);
207   ASSERT_TRUE(original_sa.sa_flags == 0);
208 
209   // Set a traditional sa_handler signal handler.
210   struct sigaction sa;
211   memset(&sa, 0, sizeof(sa));
212   sigaddset(&sa.sa_mask, SIGALRM);
213   sa.sa_flags = SA_ONSTACK;
214   sa.sa_handler = EmptySignalHandler;
215   ASSERT_EQ(0, sigaction(SIGALRM, &sa, NULL));
216 
217   // Check that we can read it back.
218   memset(&sa, 0, sizeof(sa));
219   ASSERT_EQ(0, sigaction(SIGALRM, NULL, &sa));
220   ASSERT_TRUE(sa.sa_handler == EmptySignalHandler);
221   ASSERT_TRUE((void*) sa.sa_sigaction == (void*) sa.sa_handler);
222   ASSERT_TRUE(sa.sa_flags == SA_ONSTACK);
223 
224   // Set a new-style sa_sigaction signal handler.
225   memset(&sa, 0, sizeof(sa));
226   sigaddset(&sa.sa_mask, SIGALRM);
227   sa.sa_flags = SA_ONSTACK | SA_SIGINFO;
228   sa.sa_sigaction = EmptySignalAction;
229   ASSERT_EQ(0, sigaction(SIGALRM, &sa, NULL));
230 
231   // Check that we can read it back.
232   memset(&sa, 0, sizeof(sa));
233   ASSERT_EQ(0, sigaction(SIGALRM, NULL, &sa));
234   ASSERT_TRUE(sa.sa_sigaction == EmptySignalAction);
235   ASSERT_TRUE((void*) sa.sa_sigaction == (void*) sa.sa_handler);
236   ASSERT_TRUE(sa.sa_flags == (SA_ONSTACK | SA_SIGINFO));
237 
238   // Put everything back how it was.
239   ASSERT_EQ(0, sigaction(SIGALRM, &original_sa, NULL));
240 }
241 
TEST(signal,sys_signame)242 TEST(signal, sys_signame) {
243 #if defined(__BIONIC__)
244   ASSERT_TRUE(sys_signame[0] == NULL);
245   ASSERT_STREQ("HUP", sys_signame[SIGHUP]);
246 #else
247   GTEST_LOG_(INFO) << "This test does nothing.\n";
248 #endif
249 }
250 
TEST(signal,sys_siglist)251 TEST(signal, sys_siglist) {
252   ASSERT_TRUE(sys_siglist[0] == NULL);
253   ASSERT_STREQ("Hangup", sys_siglist[SIGHUP]);
254 }
255 
TEST(signal,limits)256 TEST(signal, limits) {
257   // This comes from the kernel.
258   ASSERT_EQ(32, __SIGRTMIN);
259 
260   // We reserve a non-zero number at the bottom for ourselves.
261   ASSERT_GT(SIGRTMIN, __SIGRTMIN);
262 
263   // MIPS has more signals than everyone else.
264 #if defined(__mips__)
265   ASSERT_EQ(128, __SIGRTMAX);
266 #else
267   ASSERT_EQ(64, __SIGRTMAX);
268 #endif
269 
270   // We don't currently reserve any at the top.
271   ASSERT_EQ(SIGRTMAX, __SIGRTMAX);
272 }
273