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