1 /* $NetBSD: t_siginfo.c,v 1.24 2014/11/04 00:20:19 justin Exp $ */
2
3 /*-
4 * Copyright (c) 2010 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include <atf-c.h>
30
31 #ifdef __NetBSD__
32 #include <sys/inttypes.h>
33 #endif
34 #include <sys/resource.h>
35 #include <sys/sysctl.h>
36 #include <sys/time.h>
37 #include <sys/ucontext.h>
38 #include <sys/wait.h>
39
40 #include <assert.h>
41 #include <signal.h>
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <string.h>
45 #include <unistd.h>
46 #include <setjmp.h>
47 #include <float.h>
48
49 #ifdef HAVE_FENV
50 #include <fenv.h>
51 #elif defined(_FLOAT_IEEE754)
52 #include <ieeefp.h>
53 #endif
54
55 #include "isqemu.h"
56
57 /* for sigbus */
58 volatile char *addr;
59
60 /* for sigchild */
61 pid_t child;
62 int code;
63 int status;
64
65 /* for sigfpe */
66 sig_atomic_t fltdiv_signalled = 0;
67 sig_atomic_t intdiv_signalled = 0;
68
69 static void
sig_debug(int signo,siginfo_t * info,ucontext_t * ctx)70 sig_debug(int signo, siginfo_t *info, ucontext_t *ctx)
71 {
72 unsigned int i;
73
74 printf("%d %p %p\n", signo, info, ctx);
75 if (info != NULL) {
76 printf("si_signo=%d\n", info->si_signo);
77 printf("si_errno=%d\n", info->si_errno);
78 printf("si_code=%d\n", info->si_code);
79 printf("si_value.sival_int=%d\n", info->si_value.sival_int);
80 }
81 if (ctx != NULL) {
82 printf("uc_flags 0x%x\n", ctx->uc_flags);
83 printf("uc_link %p\n", ctx->uc_link);
84 for (i = 0; i < __arraycount(ctx->uc_sigmask.__bits); i++)
85 printf("uc_sigmask[%d] 0x%x\n", i,
86 ctx->uc_sigmask.__bits[i]);
87 printf("uc_stack %p %lu 0x%x\n", ctx->uc_stack.ss_sp,
88 (unsigned long)ctx->uc_stack.ss_size,
89 ctx->uc_stack.ss_flags);
90 #ifdef __NetBSD__
91 for (i = 0; i < __arraycount(ctx->uc_mcontext.__gregs); i++)
92 printf("uc_mcontext.greg[%d] 0x%lx\n", i,
93 (long)ctx->uc_mcontext.__gregs[i]);
94 #endif
95 }
96 }
97
98 static void
sigalrm_action(int signo,siginfo_t * info,void * ptr)99 sigalrm_action(int signo, siginfo_t *info, void *ptr)
100 {
101
102 sig_debug(signo, info, (ucontext_t *)ptr);
103
104 ATF_REQUIRE_EQ(info->si_signo, SIGALRM);
105 ATF_REQUIRE_EQ(info->si_code, SI_TIMER);
106 ATF_REQUIRE_EQ(info->si_value.sival_int, ITIMER_REAL);
107
108 atf_tc_pass();
109 /* NOTREACHED */
110 }
111
112 ATF_TC(sigalarm);
113
ATF_TC_HEAD(sigalarm,tc)114 ATF_TC_HEAD(sigalarm, tc)
115 {
116
117 atf_tc_set_md_var(tc, "descr",
118 "Checks that signal trampoline correctly calls SIGALRM handler");
119 }
120
ATF_TC_BODY(sigalarm,tc)121 ATF_TC_BODY(sigalarm, tc)
122 {
123 struct sigaction sa;
124 sa.sa_flags = SA_SIGINFO;
125 sa.sa_sigaction = sigalrm_action;
126 sigemptyset(&sa.sa_mask);
127 sigaction(SIGALRM, &sa, NULL);
128 for (;;) {
129 alarm(1);
130 sleep(1);
131 }
132 atf_tc_fail("SIGALRM handler wasn't called");
133 }
134
135 static void
sigchild_action(int signo,siginfo_t * info,void * ptr)136 sigchild_action(int signo, siginfo_t *info, void *ptr)
137 {
138 if (info != NULL) {
139 printf("info=%p\n", info);
140 printf("ptr=%p\n", ptr);
141 printf("si_signo=%d\n", info->si_signo);
142 printf("si_errno=%d\n", info->si_errno);
143 printf("si_code=%d\n", info->si_code);
144 printf("si_uid=%d\n", info->si_uid);
145 printf("si_pid=%d\n", info->si_pid);
146 printf("si_status=%d\n", info->si_status);
147 #ifdef __NetBSD__
148 printf("si_utime=%lu\n", (unsigned long int)info->si_utime);
149 printf("si_stime=%lu\n", (unsigned long int)info->si_stime);
150 #endif
151 }
152 ATF_REQUIRE_EQ(info->si_code, code);
153 ATF_REQUIRE_EQ(info->si_signo, SIGCHLD);
154 ATF_REQUIRE_EQ(info->si_uid, getuid());
155 ATF_REQUIRE_EQ(info->si_pid, child);
156 if (WIFEXITED(info->si_status))
157 ATF_REQUIRE_EQ(WEXITSTATUS(info->si_status), status);
158 else if (WIFSTOPPED(info->si_status))
159 ATF_REQUIRE_EQ(WSTOPSIG(info->si_status), status);
160 else if (WIFSIGNALED(info->si_status))
161 ATF_REQUIRE_EQ(WTERMSIG(info->si_status), status);
162 }
163
164 static void
setchildhandler(void (* action)(int,siginfo_t *,void *))165 setchildhandler(void (*action)(int, siginfo_t *, void *))
166 {
167 struct sigaction sa;
168 sa.sa_flags = SA_SIGINFO;
169 sa.sa_sigaction = action;
170 sigemptyset(&sa.sa_mask);
171 sigaction(SIGCHLD, &sa, NULL);
172 }
173
174 static void
sigchild_setup(void)175 sigchild_setup(void)
176 {
177 sigset_t set;
178 struct rlimit rlim;
179
180 (void)getrlimit(RLIMIT_CORE, &rlim);
181 rlim.rlim_cur = rlim.rlim_max;
182 (void)setrlimit(RLIMIT_CORE, &rlim);
183
184 setchildhandler(sigchild_action);
185 sigemptyset(&set);
186 sigaddset(&set, SIGCHLD);
187 sigprocmask(SIG_BLOCK, &set, NULL);
188 }
189
190 ATF_TC(sigchild_normal);
ATF_TC_HEAD(sigchild_normal,tc)191 ATF_TC_HEAD(sigchild_normal, tc)
192 {
193
194 atf_tc_set_md_var(tc, "descr",
195 "Checks that signal trampoline correctly calls SIGCHLD handler "
196 "when child exits normally");
197 }
198
ATF_TC_BODY(sigchild_normal,tc)199 ATF_TC_BODY(sigchild_normal, tc)
200 {
201 sigset_t set;
202
203 sigchild_setup();
204
205 status = 25;
206 code = CLD_EXITED;
207
208 switch ((child = fork())) {
209 case 0:
210 sleep(1);
211 exit(status);
212 case -1:
213 atf_tc_fail("fork failed");
214 default:
215 sigemptyset(&set);
216 sigsuspend(&set);
217 }
218 }
219
220 ATF_TC(sigchild_dump);
ATF_TC_HEAD(sigchild_dump,tc)221 ATF_TC_HEAD(sigchild_dump, tc)
222 {
223
224 atf_tc_set_md_var(tc, "descr",
225 "Checks that signal trampoline correctly calls SIGCHLD handler "
226 "when child segfaults");
227 }
228
ATF_TC_BODY(sigchild_dump,tc)229 ATF_TC_BODY(sigchild_dump, tc)
230 {
231 sigset_t set;
232
233 sigchild_setup();
234
235 status = SIGSEGV;
236 code = CLD_DUMPED;
237
238 switch ((child = fork())) {
239 case 0:
240 sleep(1);
241 *(volatile long *)0 = 0;
242 atf_tc_fail("Child did not segfault");
243 /* NOTREACHED */
244 case -1:
245 atf_tc_fail("fork failed");
246 default:
247 sigemptyset(&set);
248 sigsuspend(&set);
249 }
250 }
251
252 ATF_TC(sigchild_kill);
ATF_TC_HEAD(sigchild_kill,tc)253 ATF_TC_HEAD(sigchild_kill, tc)
254 {
255
256 atf_tc_set_md_var(tc, "descr",
257 "Checks that signal trampoline correctly calls SIGCHLD handler "
258 "when child is killed");
259 }
260
ATF_TC_BODY(sigchild_kill,tc)261 ATF_TC_BODY(sigchild_kill, tc)
262 {
263 sigset_t set;
264
265 sigchild_setup();
266
267 status = SIGPIPE;
268 code = CLD_KILLED;
269
270 switch ((child = fork())) {
271 case 0:
272 sigemptyset(&set);
273 sigsuspend(&set);
274 break;
275 case -1:
276 atf_tc_fail("fork failed");
277 default:
278 kill(child, SIGPIPE);
279 sigemptyset(&set);
280 sigsuspend(&set);
281 }
282 }
283
284 static sigjmp_buf sigfpe_flt_env;
285 static void
sigfpe_flt_action(int signo,siginfo_t * info,void * ptr)286 sigfpe_flt_action(int signo, siginfo_t *info, void *ptr)
287 {
288
289 sig_debug(signo, info, (ucontext_t *)ptr);
290
291 if (fltdiv_signalled++ != 0)
292 atf_tc_fail("FPE handler called more than once");
293
294 ATF_REQUIRE_EQ(info->si_signo, SIGFPE);
295 ATF_REQUIRE_EQ(info->si_code, FPE_FLTDIV);
296 ATF_REQUIRE_EQ(info->si_errno, 0);
297
298 siglongjmp(sigfpe_flt_env, 1);
299 }
300
301 ATF_TC(sigfpe_flt);
ATF_TC_HEAD(sigfpe_flt,tc)302 ATF_TC_HEAD(sigfpe_flt, tc)
303 {
304
305 atf_tc_set_md_var(tc, "descr",
306 "Checks that signal trampoline correctly calls SIGFPE handler "
307 "for floating div-by-zero");
308 }
309
ATF_TC_BODY(sigfpe_flt,tc)310 ATF_TC_BODY(sigfpe_flt, tc)
311 {
312 struct sigaction sa;
313 double d = strtod("0", NULL);
314
315 if (isQEMU())
316 atf_tc_skip("Test does not run correctly under QEMU");
317 #if defined(__powerpc__)
318 atf_tc_skip("Test not valid on powerpc");
319 #endif
320 if (sigsetjmp(sigfpe_flt_env, 0) == 0) {
321 sa.sa_flags = SA_SIGINFO;
322 sa.sa_sigaction = sigfpe_flt_action;
323 sigemptyset(&sa.sa_mask);
324 sigaction(SIGFPE, &sa, NULL);
325 #ifdef HAVE_FENV
326 feenableexcept(FE_ALL_EXCEPT);
327 #elif defined(_FLOAT_IEEE754)
328 fpsetmask(FP_X_INV|FP_X_DZ|FP_X_OFL|FP_X_UFL|FP_X_IMP);
329 #endif
330 printf("%g\n", 1 / d);
331 }
332 if (fltdiv_signalled == 0)
333 atf_tc_fail("FPE signal handler was not invoked");
334 }
335
336 static sigjmp_buf sigfpe_int_env;
337 static void
sigfpe_int_action(int signo,siginfo_t * info,void * ptr)338 sigfpe_int_action(int signo, siginfo_t *info, void *ptr)
339 {
340
341 sig_debug(signo, info, (ucontext_t *)ptr);
342
343 if (intdiv_signalled++ != 0)
344 atf_tc_fail("INTDIV handler called more than once");
345
346 ATF_REQUIRE_EQ(info->si_signo, SIGFPE);
347 ATF_REQUIRE_EQ(info->si_code, FPE_INTDIV);
348 atf_tc_expect_pass();
349 ATF_REQUIRE_EQ(info->si_errno, 0);
350
351 siglongjmp(sigfpe_int_env, 1);
352 }
353
354 ATF_TC(sigfpe_int);
ATF_TC_HEAD(sigfpe_int,tc)355 ATF_TC_HEAD(sigfpe_int, tc)
356 {
357
358 atf_tc_set_md_var(tc, "descr",
359 "Checks that signal trampoline correctly calls SIGFPE handler "
360 "for integer div-by-zero (PR port-i386/43655)");
361 }
362
ATF_TC_BODY(sigfpe_int,tc)363 ATF_TC_BODY(sigfpe_int, tc)
364 {
365 struct sigaction sa;
366 long l = strtol("0", NULL, 10);
367
368 #if defined(__powerpc__)
369 atf_tc_skip("Test not valid on powerpc");
370 #endif
371 if (sigsetjmp(sigfpe_int_env, 0) == 0) {
372 sa.sa_flags = SA_SIGINFO;
373 sa.sa_sigaction = sigfpe_int_action;
374 sigemptyset(&sa.sa_mask);
375 sigaction(SIGFPE, &sa, NULL);
376 #ifdef HAVE_FENV
377 feenableexcept(FE_ALL_EXCEPT);
378 #elif defined(_FLOAT_IEEE754)
379 fpsetmask(FP_X_INV|FP_X_DZ|FP_X_OFL|FP_X_UFL|FP_X_IMP);
380 #endif
381 printf("%ld\n", 1 / l);
382 }
383 if (intdiv_signalled == 0)
384 atf_tc_fail("FPE signal handler was not invoked");
385 }
386
387 static void
sigsegv_action(int signo,siginfo_t * info,void * ptr)388 sigsegv_action(int signo, siginfo_t *info, void *ptr)
389 {
390
391 sig_debug(signo, info, (ucontext_t *)ptr);
392
393 ATF_REQUIRE_EQ(info->si_signo, SIGSEGV);
394 ATF_REQUIRE_EQ(info->si_errno, 0);
395 ATF_REQUIRE_EQ(info->si_code, SEGV_MAPERR);
396 ATF_REQUIRE_EQ(info->si_addr, (void *)0);
397
398 atf_tc_pass();
399 /* NOTREACHED */
400 }
401
402 ATF_TC(sigsegv);
ATF_TC_HEAD(sigsegv,tc)403 ATF_TC_HEAD(sigsegv, tc)
404 {
405
406 atf_tc_set_md_var(tc, "descr",
407 "Checks that signal trampoline correctly calls SIGSEGV handler");
408 }
409
ATF_TC_BODY(sigsegv,tc)410 ATF_TC_BODY(sigsegv, tc)
411 {
412 struct sigaction sa;
413
414 sa.sa_flags = SA_SIGINFO;
415 sa.sa_sigaction = sigsegv_action;
416 sigemptyset(&sa.sa_mask);
417 sigaction(SIGSEGV, &sa, NULL);
418
419 *(volatile long *)0 = 0;
420 atf_tc_fail("Test did not fault as expected");
421 }
422
423 static void
sigbus_action(int signo,siginfo_t * info,void * ptr)424 sigbus_action(int signo, siginfo_t *info, void *ptr)
425 {
426
427 printf("si_addr = %p\n", info->si_addr);
428 sig_debug(signo, info, (ucontext_t *)ptr);
429
430 ATF_REQUIRE_EQ(info->si_signo, SIGBUS);
431 ATF_REQUIRE_EQ(info->si_errno, 0);
432 ATF_REQUIRE_EQ(info->si_code, BUS_ADRALN);
433
434 #if defined(__i386__) || defined(__x86_64__)
435 atf_tc_expect_fail("x86 architecture does not correctly "
436 "report the address where the unaligned access occured");
437 #endif
438 ATF_REQUIRE_EQ(info->si_addr, (volatile void *)addr);
439
440 atf_tc_pass();
441 /* NOTREACHED */
442 }
443
444 ATF_TC(sigbus_adraln);
ATF_TC_HEAD(sigbus_adraln,tc)445 ATF_TC_HEAD(sigbus_adraln, tc)
446 {
447
448 atf_tc_set_md_var(tc, "descr",
449 "Checks that signal trampoline correctly calls SIGBUS handler "
450 "for invalid address alignment");
451 }
452
ATF_TC_BODY(sigbus_adraln,tc)453 ATF_TC_BODY(sigbus_adraln, tc)
454 {
455 struct sigaction sa;
456
457 #if defined(__alpha__)
458 int rv, val;
459 size_t len = sizeof(val);
460 rv = sysctlbyname("machdep.unaligned_sigbus", &val, &len, NULL, 0);
461 ATF_REQUIRE(rv == 0);
462 if (val == 0)
463 atf_tc_skip("SIGBUS signal not enabled for unaligned accesses");
464 #endif
465
466 sa.sa_flags = SA_SIGINFO;
467 sa.sa_sigaction = sigbus_action;
468 sigemptyset(&sa.sa_mask);
469 sigaction(SIGBUS, &sa, NULL);
470
471 /* Enable alignment checks for x86. 0x40000 is PSL_AC. */
472 #if defined(__i386__)
473 __asm__("pushf; orl $0x40000, (%esp); popf");
474 #elif defined(__amd64__)
475 __asm__("pushf; orl $0x40000, (%rsp); popf");
476 #endif
477
478 addr = calloc(2, sizeof(int));
479 ATF_REQUIRE(addr != NULL);
480
481 if (isQEMU())
482 atf_tc_expect_fail("QEMU fails to trap unaligned accesses");
483
484 /* Force an unaligned access */
485 addr++;
486 printf("now trying to access unaligned address %p\n", addr);
487 ATF_REQUIRE_EQ(*(volatile int *)addr, 0);
488
489 atf_tc_fail("Test did not fault as expected");
490 }
491
ATF_TP_ADD_TCS(tp)492 ATF_TP_ADD_TCS(tp)
493 {
494
495 ATF_TP_ADD_TC(tp, sigalarm);
496 ATF_TP_ADD_TC(tp, sigchild_normal);
497 ATF_TP_ADD_TC(tp, sigchild_dump);
498 ATF_TP_ADD_TC(tp, sigchild_kill);
499 ATF_TP_ADD_TC(tp, sigfpe_flt);
500 ATF_TP_ADD_TC(tp, sigfpe_int);
501 ATF_TP_ADD_TC(tp, sigsegv);
502 ATF_TP_ADD_TC(tp, sigbus_adraln);
503
504 return atf_no_error();
505 }
506