t_siginfo.c revision 1.38
1 /* $NetBSD: t_siginfo.c,v 1.38 2020/02/21 22:25:50 kamil 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 #include <sys/resource.h> 32 #include <sys/sysctl.h> 33 #include <sys/time.h> 34 #include <sys/ucontext.h> 35 #include <sys/wait.h> 36 37 #include <assert.h> 38 #include <float.h> 39 #include <inttypes.h> 40 #include <setjmp.h> 41 #include <signal.h> 42 #include <stdio.h> 43 #include <stdlib.h> 44 #include <string.h> 45 #include <unistd.h> 46 47 #include <fenv.h> 48 #ifdef __HAVE_FENV 49 #include <ieeefp.h> /* only need for ARM Cortex/Neon hack */ 50 #elif defined(_FLOAT_IEEE754) 51 #include <ieeefp.h> 52 #endif 53 54 #include "isqemu.h" 55 56 /* for sigbus */ 57 volatile char *addr; 58 59 /* for sigchild */ 60 pid_t child; 61 int code; 62 int status; 63 64 /* for sigfpe */ 65 sig_atomic_t fltdiv_signalled = 0; 66 sig_atomic_t intdiv_signalled = 0; 67 68 static void 69 sig_debug(int signo, siginfo_t *info, ucontext_t *ctx) 70 { 71 unsigned int i; 72 73 printf("%d %p %p\n", signo, info, ctx); 74 if (info != NULL) { 75 printf("si_signo=%d\n", info->si_signo); 76 printf("si_errno=%d\n", info->si_errno); 77 printf("si_code=%d\n", info->si_code); 78 printf("si_value.sival_int=%d\n", info->si_value.sival_int); 79 } 80 if (ctx != NULL) { 81 printf("uc_flags 0x%x\n", ctx->uc_flags); 82 printf("uc_link %p\n", ctx->uc_link); 83 for (i = 0; i < __arraycount(ctx->uc_sigmask.__bits); i++) 84 printf("uc_sigmask[%d] 0x%x\n", i, 85 ctx->uc_sigmask.__bits[i]); 86 printf("uc_stack %p %lu 0x%x\n", ctx->uc_stack.ss_sp, 87 (unsigned long)ctx->uc_stack.ss_size, 88 ctx->uc_stack.ss_flags); 89 for (i = 0; i < __arraycount(ctx->uc_mcontext.__gregs); i++) 90 printf("uc_mcontext.greg[%d] 0x%lx\n", i, 91 (long)ctx->uc_mcontext.__gregs[i]); 92 } 93 } 94 95 static void 96 sigalrm_action(int signo, siginfo_t *info, void *ptr) 97 { 98 99 sig_debug(signo, info, (ucontext_t *)ptr); 100 101 ATF_REQUIRE_EQ(info->si_signo, SIGALRM); 102 ATF_REQUIRE_EQ(info->si_code, SI_TIMER); 103 ATF_REQUIRE_EQ(info->si_value.sival_int, ITIMER_REAL); 104 105 atf_tc_pass(); 106 /* NOTREACHED */ 107 } 108 109 ATF_TC(sigalarm); 110 111 ATF_TC_HEAD(sigalarm, tc) 112 { 113 114 atf_tc_set_md_var(tc, "descr", 115 "Checks that signal trampoline correctly calls SIGALRM handler"); 116 } 117 118 ATF_TC_BODY(sigalarm, tc) 119 { 120 struct sigaction sa; 121 sa.sa_flags = SA_SIGINFO; 122 sa.sa_sigaction = sigalrm_action; 123 sigemptyset(&sa.sa_mask); 124 sigaction(SIGALRM, &sa, NULL); 125 for (;;) { 126 alarm(1); 127 sleep(1); 128 } 129 atf_tc_fail("SIGALRM handler wasn't called"); 130 } 131 132 static void 133 sigchild_action(int signo, siginfo_t *info, void *ptr) 134 { 135 if (info != NULL) { 136 printf("info=%p\n", info); 137 printf("ptr=%p\n", ptr); 138 printf("si_signo=%d\n", info->si_signo); 139 printf("si_errno=%d\n", info->si_errno); 140 printf("si_code=%d\n", info->si_code); 141 printf("si_uid=%d\n", info->si_uid); 142 printf("si_pid=%d\n", info->si_pid); 143 printf("si_status=%d\n", info->si_status); 144 printf("si_utime=%lu\n", (unsigned long int)info->si_utime); 145 printf("si_stime=%lu\n", (unsigned long int)info->si_stime); 146 } 147 ATF_REQUIRE_EQ(info->si_code, code); 148 ATF_REQUIRE_EQ(info->si_signo, SIGCHLD); 149 ATF_REQUIRE_EQ(info->si_uid, getuid()); 150 ATF_REQUIRE_EQ(info->si_pid, child); 151 if (WIFEXITED(info->si_status)) 152 ATF_REQUIRE_EQ(WEXITSTATUS(info->si_status), status); 153 else if (WIFSTOPPED(info->si_status)) 154 ATF_REQUIRE_EQ(WSTOPSIG(info->si_status), status); 155 else if (WIFSIGNALED(info->si_status)) 156 ATF_REQUIRE_EQ(WTERMSIG(info->si_status), status); 157 } 158 159 static void 160 setchildhandler(void (*action)(int, siginfo_t *, void *)) 161 { 162 struct sigaction sa; 163 sa.sa_flags = SA_SIGINFO; 164 sa.sa_sigaction = action; 165 sigemptyset(&sa.sa_mask); 166 sigaction(SIGCHLD, &sa, NULL); 167 } 168 169 static void 170 sigchild_setup(void) 171 { 172 sigset_t set; 173 struct rlimit rlim; 174 175 (void)getrlimit(RLIMIT_CORE, &rlim); 176 rlim.rlim_cur = rlim.rlim_max; 177 (void)setrlimit(RLIMIT_CORE, &rlim); 178 179 setchildhandler(sigchild_action); 180 sigemptyset(&set); 181 sigaddset(&set, SIGCHLD); 182 sigprocmask(SIG_BLOCK, &set, NULL); 183 } 184 185 ATF_TC(sigchild_normal); 186 ATF_TC_HEAD(sigchild_normal, tc) 187 { 188 189 atf_tc_set_md_var(tc, "descr", 190 "Checks that signal trampoline correctly calls SIGCHLD handler " 191 "when child exits normally"); 192 } 193 194 ATF_TC_BODY(sigchild_normal, tc) 195 { 196 sigset_t set; 197 198 sigchild_setup(); 199 200 status = 25; 201 code = CLD_EXITED; 202 203 switch ((child = fork())) { 204 case 0: 205 sleep(1); 206 exit(status); 207 case -1: 208 atf_tc_fail("fork failed"); 209 default: 210 sigemptyset(&set); 211 sigsuspend(&set); 212 } 213 } 214 215 ATF_TC(sigchild_dump); 216 ATF_TC_HEAD(sigchild_dump, tc) 217 { 218 219 atf_tc_set_md_var(tc, "descr", 220 "Checks that signal trampoline correctly calls SIGCHLD handler " 221 "when child segfaults"); 222 } 223 224 ATF_TC_BODY(sigchild_dump, tc) 225 { 226 sigset_t set; 227 228 sigchild_setup(); 229 230 status = SIGSEGV; 231 code = CLD_DUMPED; 232 233 switch ((child = fork())) { 234 case 0: 235 sleep(1); 236 *(volatile long *)0 = 0; 237 atf_tc_fail("Child did not segfault"); 238 /* NOTREACHED */ 239 case -1: 240 atf_tc_fail("fork failed"); 241 default: 242 sigemptyset(&set); 243 sigsuspend(&set); 244 } 245 } 246 247 ATF_TC(sigchild_kill); 248 ATF_TC_HEAD(sigchild_kill, tc) 249 { 250 251 atf_tc_set_md_var(tc, "descr", 252 "Checks that signal trampoline correctly calls SIGCHLD handler " 253 "when child is killed"); 254 } 255 256 ATF_TC_BODY(sigchild_kill, tc) 257 { 258 sigset_t set; 259 260 sigchild_setup(); 261 262 status = SIGPIPE; 263 code = CLD_KILLED; 264 265 switch ((child = fork())) { 266 case 0: 267 sigemptyset(&set); 268 sigsuspend(&set); 269 break; 270 case -1: 271 atf_tc_fail("fork failed"); 272 default: 273 kill(child, SIGPIPE); 274 sigemptyset(&set); 275 sigsuspend(&set); 276 } 277 } 278 279 static sigjmp_buf sigfpe_flt_env; 280 static void 281 sigfpe_flt_action(int signo, siginfo_t *info, void *ptr) 282 { 283 284 sig_debug(signo, info, (ucontext_t *)ptr); 285 286 if (fltdiv_signalled++ != 0) 287 atf_tc_fail("FPE handler called more than once"); 288 289 ATF_REQUIRE_EQ(info->si_signo, SIGFPE); 290 ATF_REQUIRE_EQ(info->si_code, FPE_FLTDIV); 291 ATF_REQUIRE_EQ(info->si_errno, 0); 292 293 siglongjmp(sigfpe_flt_env, 1); 294 } 295 296 ATF_TC(sigfpe_flt); 297 ATF_TC_HEAD(sigfpe_flt, tc) 298 { 299 300 atf_tc_set_md_var(tc, "descr", 301 "Checks that signal trampoline correctly calls SIGFPE handler " 302 "for floating div-by-zero"); 303 } 304 305 ATF_TC_BODY(sigfpe_flt, tc) 306 { 307 struct sigaction sa; 308 double d = strtod("0", NULL); 309 310 if (isQEMU()) 311 atf_tc_skip("Test does not run correctly under QEMU"); 312 #if (__arm__ && !__SOFTFP__) || __aarch64__ 313 /* 314 * Some NEON fpus do not trap on IEEE 754 FP exceptions. 315 * skip these tests if running on them and compiled for 316 * hard float. 317 */ 318 if (0 == fpsetmask(fpsetmask(FP_X_INV))) 319 atf_tc_skip("FPU does not implement traps on FP exceptions"); 320 #endif 321 if (sigsetjmp(sigfpe_flt_env, 0) == 0) { 322 sa.sa_flags = SA_SIGINFO; 323 sa.sa_sigaction = sigfpe_flt_action; 324 sigemptyset(&sa.sa_mask); 325 sigaction(SIGFPE, &sa, NULL); 326 #ifdef __HAVE_FENV 327 feenableexcept(FE_ALL_EXCEPT); 328 #elif defined(_FLOAT_IEEE754) 329 fpsetmask(FP_X_INV|FP_X_DZ|FP_X_OFL|FP_X_UFL|FP_X_IMP); 330 #endif 331 printf("%g\n", 1 / d); 332 } 333 if (fltdiv_signalled == 0) 334 atf_tc_fail("FPE signal handler was not invoked"); 335 } 336 337 static sigjmp_buf sigfpe_int_env; 338 static void 339 sigfpe_int_action(int signo, siginfo_t *info, void *ptr) 340 { 341 342 sig_debug(signo, info, (ucontext_t *)ptr); 343 344 if (intdiv_signalled++ != 0) 345 atf_tc_fail("INTDIV handler called more than once"); 346 347 ATF_REQUIRE_EQ(info->si_signo, SIGFPE); 348 ATF_REQUIRE_EQ(info->si_code, FPE_INTDIV); 349 atf_tc_expect_pass(); 350 ATF_REQUIRE_EQ(info->si_errno, 0); 351 352 siglongjmp(sigfpe_int_env, 1); 353 } 354 355 ATF_TC(sigfpe_int); 356 ATF_TC_HEAD(sigfpe_int, tc) 357 { 358 359 atf_tc_set_md_var(tc, "descr", 360 "Checks that signal trampoline correctly calls SIGFPE handler " 361 "for integer div-by-zero (PR port-i386/43655)"); 362 } 363 364 #if defined(__clang__) 365 __attribute__((no_sanitize("undefined"))) 366 #else 367 __attribute__((no_sanitize_undefined)) 368 #endif 369 static long int 370 sigfpe_int_division(long int a, long int b) 371 { 372 373 return a / b; 374 } 375 376 ATF_TC_BODY(sigfpe_int, tc) 377 { 378 struct sigaction sa; 379 long l = strtol("0", NULL, 10); 380 381 #if defined(__powerpc__) || defined(__aarch64__) 382 atf_tc_skip("Integer division by zero doesn't trap"); 383 #endif 384 if (sigsetjmp(sigfpe_int_env, 0) == 0) { 385 sa.sa_flags = SA_SIGINFO; 386 sa.sa_sigaction = sigfpe_int_action; 387 sigemptyset(&sa.sa_mask); 388 sigaction(SIGFPE, &sa, NULL); 389 #ifdef __HAVE_FENV 390 feenableexcept(FE_ALL_EXCEPT); 391 #elif defined(_FLOAT_IEEE754) 392 fpsetmask(FP_X_INV|FP_X_DZ|FP_X_OFL|FP_X_UFL|FP_X_IMP); 393 #endif 394 printf("%ld\n", sigfpe_int_division(1, l)); 395 } 396 if (intdiv_signalled == 0) 397 atf_tc_fail("FPE signal handler was not invoked"); 398 } 399 400 static void 401 sigsegv_action(int signo, siginfo_t *info, void *ptr) 402 { 403 404 sig_debug(signo, info, (ucontext_t *)ptr); 405 406 ATF_REQUIRE_EQ(info->si_signo, SIGSEGV); 407 ATF_REQUIRE_EQ(info->si_errno, 0); 408 ATF_REQUIRE_EQ(info->si_code, SEGV_MAPERR); 409 ATF_REQUIRE_EQ(info->si_addr, (void *)0); 410 411 atf_tc_pass(); 412 /* NOTREACHED */ 413 } 414 415 ATF_TC(sigsegv); 416 ATF_TC_HEAD(sigsegv, tc) 417 { 418 419 atf_tc_set_md_var(tc, "descr", 420 "Checks that signal trampoline correctly calls SIGSEGV handler"); 421 } 422 423 ATF_TC_BODY(sigsegv, tc) 424 { 425 struct sigaction sa; 426 427 sa.sa_flags = SA_SIGINFO; 428 sa.sa_sigaction = sigsegv_action; 429 sigemptyset(&sa.sa_mask); 430 sigaction(SIGSEGV, &sa, NULL); 431 432 *(volatile long *)0 = 0; 433 atf_tc_fail("Test did not fault as expected"); 434 } 435 436 static void 437 sigbus_action(int signo, siginfo_t *info, void *ptr) 438 { 439 440 printf("si_addr = %p\n", info->si_addr); 441 sig_debug(signo, info, (ucontext_t *)ptr); 442 443 ATF_REQUIRE_EQ(info->si_signo, SIGBUS); 444 ATF_REQUIRE_EQ(info->si_errno, 0); 445 ATF_REQUIRE_EQ(info->si_code, BUS_ADRALN); 446 447 #if defined(__i386__) || defined(__x86_64__) 448 atf_tc_expect_fail("x86 architecture does not correctly " 449 "report the address where the unaligned access occured"); 450 #endif 451 ATF_REQUIRE_EQ(info->si_addr, (volatile void *)addr); 452 453 atf_tc_pass(); 454 /* NOTREACHED */ 455 } 456 457 ATF_TC(sigbus_adraln); 458 ATF_TC_HEAD(sigbus_adraln, tc) 459 { 460 461 atf_tc_set_md_var(tc, "descr", 462 "Checks that signal trampoline correctly calls SIGBUS handler " 463 "for invalid address alignment"); 464 } 465 466 ATF_TC_BODY(sigbus_adraln, tc) 467 { 468 struct sigaction sa; 469 470 #if defined(__alpha__) || defined(__arm__) 471 int rv, val; 472 size_t len = sizeof(val); 473 rv = sysctlbyname("machdep.unaligned_sigbus", &val, &len, NULL, 0); 474 ATF_REQUIRE(rv == 0); 475 if (val == 0) 476 atf_tc_skip("No SIGBUS signal for unaligned accesses"); 477 #endif 478 479 /* m68k (except sun2) never issue SIGBUS (PR lib/49653), 480 * same for armv8 or newer */ 481 if (strcmp(MACHINE_ARCH, "m68k") == 0 || 482 strcmp(MACHINE_ARCH, "aarch64") == 0) 483 atf_tc_skip("No SIGBUS signal for unaligned accesses"); 484 485 sa.sa_flags = SA_SIGINFO; 486 sa.sa_sigaction = sigbus_action; 487 sigemptyset(&sa.sa_mask); 488 sigaction(SIGBUS, &sa, NULL); 489 490 /* Enable alignment checks for x86. 0x40000 is PSL_AC. */ 491 #if defined(__i386__) 492 __asm__("pushf; orl $0x40000, (%esp); popf"); 493 #elif defined(__amd64__) 494 __asm__("pushf; orl $0x40000, (%rsp); popf"); 495 #endif 496 497 addr = calloc(2, sizeof(int)); 498 ATF_REQUIRE(addr != NULL); 499 500 if (isQEMU()) 501 atf_tc_expect_fail("QEMU fails to trap unaligned accesses"); 502 503 /* Force an unaligned access */ 504 addr++; 505 printf("now trying to access unaligned address %p\n", addr); 506 ATF_REQUIRE_EQ(*(volatile int *)addr, 0); 507 508 atf_tc_fail("Test did not fault as expected"); 509 } 510 511 ATF_TP_ADD_TCS(tp) 512 { 513 514 ATF_TP_ADD_TC(tp, sigalarm); 515 ATF_TP_ADD_TC(tp, sigchild_normal); 516 ATF_TP_ADD_TC(tp, sigchild_dump); 517 ATF_TP_ADD_TC(tp, sigchild_kill); 518 ATF_TP_ADD_TC(tp, sigfpe_flt); 519 ATF_TP_ADD_TC(tp, sigfpe_int); 520 ATF_TP_ADD_TC(tp, sigsegv); 521 ATF_TP_ADD_TC(tp, sigbus_adraln); 522 523 return atf_no_error(); 524 } 525
Indexes created Thu Oct 02 14:10:14 GMT 2025