1 /*
2 * Copyright (C) 2014 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 <setjmp.h>
20 #include <stdlib.h>
21 #include <sys/syscall.h>
22 #include <unistd.h>
23
24 #include <android-base/silent_death_test.h>
25
26 #include "SignalUtils.h"
27
28 using setjmp_DeathTest = SilentDeathTest;
29
TEST(setjmp,setjmp_smoke)30 TEST(setjmp, setjmp_smoke) {
31 int value;
32 jmp_buf jb;
33 if ((value = setjmp(jb)) == 0) {
34 longjmp(jb, 123);
35 FAIL(); // Unreachable.
36 } else {
37 ASSERT_EQ(123, value);
38 }
39 }
40
TEST(setjmp,_setjmp_smoke)41 TEST(setjmp, _setjmp_smoke) {
42 int value;
43 jmp_buf jb;
44 if ((value = _setjmp(jb)) == 0) {
45 _longjmp(jb, 456);
46 FAIL(); // Unreachable.
47 } else {
48 ASSERT_EQ(456, value);
49 }
50 }
51
TEST(setjmp,sigsetjmp_0_smoke)52 TEST(setjmp, sigsetjmp_0_smoke) {
53 int value;
54 sigjmp_buf jb;
55 if ((value = sigsetjmp(jb, 0)) == 0) {
56 siglongjmp(jb, 789);
57 FAIL(); // Unreachable.
58 } else {
59 ASSERT_EQ(789, value);
60 }
61 }
62
TEST(setjmp,sigsetjmp_1_smoke)63 TEST(setjmp, sigsetjmp_1_smoke) {
64 int value;
65 sigjmp_buf jb;
66 if ((value = sigsetjmp(jb, 0)) == 0) {
67 siglongjmp(jb, 0xabc);
68 FAIL(); // Unreachable.
69 } else {
70 ASSERT_EQ(0xabc, value);
71 }
72 }
73
74 // Two distinct signal sets.
75 struct SigSets {
SigSetsSigSets76 SigSets() : one(MakeSigSet(0)), two(MakeSigSet(1)) {
77 }
78
MakeSigSetSigSets79 static sigset64_t MakeSigSet(int offset) {
80 sigset64_t ss;
81 sigemptyset64(&ss);
82 sigaddset64(&ss, SIGUSR1 + offset);
83 // TIMER_SIGNAL.
84 sigaddset64(&ss, __SIGRTMIN);
85 sigaddset64(&ss, SIGRTMIN + offset);
86 return ss;
87 }
88
89 sigset64_t one;
90 sigset64_t two;
91 };
92
AssertSigmaskEquals(const sigset64_t & expected)93 void AssertSigmaskEquals(const sigset64_t& expected) {
94 sigset64_t actual;
95 sigprocmask64(SIG_SETMASK, nullptr, &actual);
96 size_t end = sizeof(expected) * 8;
97 for (size_t i = 1; i <= end; ++i) {
98 EXPECT_EQ(sigismember64(&expected, i), sigismember64(&actual, i)) << i;
99 }
100 }
101
TEST(setjmp,_setjmp_signal_mask)102 TEST(setjmp, _setjmp_signal_mask) {
103 SignalMaskRestorer smr;
104
105 // _setjmp/_longjmp do not save/restore the signal mask.
106 SigSets ss;
107 sigprocmask64(SIG_SETMASK, &ss.one, nullptr);
108 jmp_buf jb;
109 if (_setjmp(jb) == 0) {
110 sigprocmask64(SIG_SETMASK, &ss.two, nullptr);
111 _longjmp(jb, 1);
112 FAIL(); // Unreachable.
113 } else {
114 AssertSigmaskEquals(ss.two);
115 }
116 }
117
TEST(setjmp,setjmp_signal_mask)118 TEST(setjmp, setjmp_signal_mask) {
119 SignalMaskRestorer smr;
120
121 // setjmp/longjmp do save/restore the signal mask on bionic, but not on glibc.
122 // This is a BSD versus System V historical accident. POSIX leaves the
123 // behavior unspecified, so any code that cares needs to use sigsetjmp.
124 SigSets ss;
125 sigprocmask64(SIG_SETMASK, &ss.one, nullptr);
126 jmp_buf jb;
127 if (setjmp(jb) == 0) {
128 sigprocmask64(SIG_SETMASK, &ss.two, nullptr);
129 longjmp(jb, 1);
130 FAIL(); // Unreachable.
131 } else {
132 #if defined(__BIONIC__)
133 // bionic behaves like BSD and does save/restore the signal mask.
134 AssertSigmaskEquals(ss.one);
135 #else
136 // glibc behaves like System V and doesn't save/restore the signal mask.
137 AssertSigmaskEquals(ss.two);
138 #endif
139 }
140 }
141
TEST(setjmp,sigsetjmp_0_signal_mask)142 TEST(setjmp, sigsetjmp_0_signal_mask) {
143 SignalMaskRestorer smr;
144
145 // sigsetjmp(0)/siglongjmp do not save/restore the signal mask.
146 SigSets ss;
147 sigprocmask64(SIG_SETMASK, &ss.one, nullptr);
148 sigjmp_buf sjb;
149 if (sigsetjmp(sjb, 0) == 0) {
150 sigprocmask64(SIG_SETMASK, &ss.two, nullptr);
151 siglongjmp(sjb, 1);
152 FAIL(); // Unreachable.
153 } else {
154 AssertSigmaskEquals(ss.two);
155 }
156 }
157
TEST(setjmp,sigsetjmp_1_signal_mask)158 TEST(setjmp, sigsetjmp_1_signal_mask) {
159 SignalMaskRestorer smr;
160
161 // sigsetjmp(1)/siglongjmp does save/restore the signal mask.
162 SigSets ss;
163 sigprocmask64(SIG_SETMASK, &ss.one, nullptr);
164 sigjmp_buf sjb;
165 if (sigsetjmp(sjb, 1) == 0) {
166 sigprocmask64(SIG_SETMASK, &ss.two, nullptr);
167 siglongjmp(sjb, 1);
168 FAIL(); // Unreachable.
169 } else {
170 AssertSigmaskEquals(ss.one);
171 }
172 }
173
174 #if defined(__aarch64__)
175 #define SET_FREG(n, v) asm volatile("fmov d"#n ", "#v : : : "d"#n)
176 #define CLEAR_FREG(n) asm volatile("fmov d"#n ", xzr" : : : "d"#n)
177 #define SET_FREGS \
178 SET_FREG(8, 8.0); SET_FREG(9, 9.0); SET_FREG(10, 10.0); SET_FREG(11, 11.0); \
179 SET_FREG(12, 12.0); SET_FREG(13, 13.0); SET_FREG(14, 14.0); SET_FREG(15, 15.0);
180 #define CLEAR_FREGS \
181 CLEAR_FREG(8); CLEAR_FREG(9); CLEAR_FREG(10); CLEAR_FREG(11); \
182 CLEAR_FREG(12); CLEAR_FREG(13); CLEAR_FREG(14); CLEAR_FREG(15);
183 #define GET_FREG(n) ({ double _r; asm volatile("fmov %0, d"#n : "=r"(_r) : :); _r; })
184 #define CHECK_FREGS \
185 EXPECT_EQ(8.0, GET_FREG(8)); EXPECT_EQ(9.0, GET_FREG(9)); \
186 EXPECT_EQ(10.0, GET_FREG(10)); EXPECT_EQ(11.0, GET_FREG(11)); \
187 EXPECT_EQ(12.0, GET_FREG(12)); EXPECT_EQ(13.0, GET_FREG(13)); \
188 EXPECT_EQ(14.0, GET_FREG(14)); EXPECT_EQ(15.0, GET_FREG(15));
189 #elif defined(__arm__)
190 #define SET_FREG(n, v) \
191 ({ const double _v{v}; asm volatile("fcpyd d"#n ", %P0" : : "w"(_v) : "d"#n); })
192 #define SET_FREGS \
193 SET_FREG(8, 8); SET_FREG(9, 9); SET_FREG(10, 10); SET_FREG(11, 11); \
194 SET_FREG(12, 12); SET_FREG(13, 13); SET_FREG(14, 14); SET_FREG(15, 15);
195 #define CLEAR_FREGS \
196 SET_FREG(8, 0); SET_FREG(9, 0); SET_FREG(10, 0); SET_FREG(11, 0); \
197 SET_FREG(12, 0); SET_FREG(13, 0); SET_FREG(14, 0); SET_FREG(15, 0);
198 #define GET_FREG(n) ({ double _r; asm volatile("fcpyd %P0, d"#n : "=w"(_r) : :); _r;})
199 #define CHECK_FREGS \
200 EXPECT_EQ(8.0, GET_FREG(8)); EXPECT_EQ(9.0, GET_FREG(9)); \
201 EXPECT_EQ(10.0, GET_FREG(10)); EXPECT_EQ(11.0, GET_FREG(11)); \
202 EXPECT_EQ(12.0, GET_FREG(12)); EXPECT_EQ(13.0, GET_FREG(13)); \
203 EXPECT_EQ(14.0, GET_FREG(14)); EXPECT_EQ(15.0, GET_FREG(15));
204 #else
205 /* The other architectures don't save/restore fp registers. */
206 #define SET_FREGS
207 #define CLEAR_FREGS
208 #define CHECK_FREGS
209 #endif
210
TEST(setjmp,setjmp_fp_registers)211 TEST(setjmp, setjmp_fp_registers) {
212 int value;
213 jmp_buf jb;
214 SET_FREGS;
215 if ((value = setjmp(jb)) == 0) {
216 CLEAR_FREGS;
217 longjmp(jb, 123);
218 FAIL(); // Unreachable.
219 } else {
220 ASSERT_EQ(123, value);
221 CHECK_FREGS;
222 }
223 }
224
225 #if defined(__arm__)
226 #define __JB_SIGFLAG 0
227 #elif defined(__aarch64__)
228 #define __JB_SIGFLAG 0
229 #elif defined(__i386__)
230 #define __JB_SIGFLAG 8
231 #elif defined(__x86_64)
232 #define __JB_SIGFLAG 8
233 #endif
234
TEST_F(setjmp_DeathTest,setjmp_cookie)235 TEST_F(setjmp_DeathTest, setjmp_cookie) {
236 jmp_buf jb;
237 int value = setjmp(jb);
238 ASSERT_EQ(0, value);
239
240 long* sigflag = reinterpret_cast<long*>(jb) + __JB_SIGFLAG;
241
242 // Make sure there's actually a cookie.
243 EXPECT_NE(0, *sigflag & ~1);
244
245 // Wipe it out
246 *sigflag &= 1;
247 EXPECT_DEATH(longjmp(jb, 0), "");
248 }
249
TEST_F(setjmp_DeathTest,setjmp_cookie_checksum)250 TEST_F(setjmp_DeathTest, setjmp_cookie_checksum) {
251 jmp_buf jb;
252 int value = setjmp(jb);
253
254 if (value == 0) {
255 // Flip a bit.
256 reinterpret_cast<long*>(jb)[1] ^= 1;
257
258 EXPECT_DEATH(longjmp(jb, 1), "checksum mismatch");
259 } else {
260 fprintf(stderr, "setjmp_cookie_checksum: longjmp succeeded?");
261 }
262 }
263
call_longjmp(jmp_buf buf)264 __attribute__((noinline)) void call_longjmp(jmp_buf buf) {
265 longjmp(buf, 123);
266 }
267
TEST(setjmp,setjmp_stack)268 TEST(setjmp, setjmp_stack) {
269 jmp_buf buf;
270 int value = setjmp(buf);
271 if (value == 0) call_longjmp(buf);
272 EXPECT_EQ(123, value);
273 }
274
TEST(setjmp,bug_152210274)275 TEST(setjmp, bug_152210274) {
276 // Ensure that we never have a mangled value in the stack pointer.
277 #if defined(__BIONIC__)
278 struct sigaction sa = {.sa_flags = SA_SIGINFO, .sa_sigaction = [](int, siginfo_t*, void*) {}};
279 ASSERT_EQ(0, sigaction(SIGPROF, &sa, 0));
280
281 constexpr size_t kNumThreads = 20;
282
283 // Start a bunch of threads calling setjmp/longjmp.
284 auto jumper = [](void* arg) -> void* {
285 sigset_t set;
286 sigemptyset(&set);
287 sigaddset(&set, SIGPROF);
288 pthread_sigmask(SIG_UNBLOCK, &set, nullptr);
289
290 jmp_buf buf;
291 for (size_t count = 0; count < 100000; ++count) {
292 if (setjmp(buf) != 0) {
293 perror("setjmp");
294 abort();
295 }
296 if (*static_cast<pid_t*>(arg) == 100) longjmp(buf, 1);
297 }
298 return nullptr;
299 };
300 pid_t tids[kNumThreads] = {};
301 for (size_t i = 0; i < kNumThreads; ++i) {
302 pthread_t t;
303 ASSERT_EQ(0, pthread_create(&t, nullptr, jumper, &tids[i]));
304 tids[i] = pthread_gettid_np(t);
305 }
306
307 // Start the interrupter thread.
308 auto interrupter = [](void* arg) -> void* {
309 pid_t* tids = static_cast<pid_t*>(arg);
310 for (size_t count = 0; count < 1000; ++count) {
311 for (size_t i = 0; i < kNumThreads; i++) {
312 if (tgkill(getpid(), tids[i], SIGPROF) == -1 && errno != ESRCH) {
313 perror("tgkill failed");
314 abort();
315 }
316 }
317 usleep(100);
318 }
319 return nullptr;
320 };
321 pthread_t t;
322 ASSERT_EQ(0, pthread_create(&t, nullptr, interrupter, tids));
323 pthread_join(t, nullptr);
324 #else
325 GTEST_SKIP() << "tests uses functions not in glibc";
326 #endif
327 }
328