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 <errno.h> 18 #include <signal.h> 19 #include <sys/syscall.h> 20 #include <sys/types.h> 21 #include <unistd.h> 22 23 #include <thread> 24 25 #include <gtest/gtest.h> 26 27 #include "ScopedSignalHandler.h" 28 29 static int SIGNAL_MIN() { 30 return 1; // Signals start at 1 (SIGHUP), not 0. 31 } 32 33 template <typename SigSetT> 34 static int SIGNAL_MAX(SigSetT* set) { 35 return sizeof(*set) * 8; 36 } 37 38 template <typename SigSetT> 39 static void TestSigSet1(int (fn)(SigSetT*)) { 40 // NULL sigset_t*/sigset64_t*. 41 SigSetT* set_ptr = NULL; 42 errno = 0; 43 ASSERT_EQ(-1, fn(set_ptr)); 44 ASSERT_EQ(EINVAL, errno); 45 46 // Non-NULL. 47 SigSetT set = {}; 48 errno = 0; 49 ASSERT_EQ(0, fn(&set)); 50 ASSERT_EQ(0, errno); 51 } 52 53 template <typename SigSetT> 54 static void TestSigSet2(int (fn)(SigSetT*, int)) { 55 // NULL sigset_t*/sigset64_t*. 56 SigSetT* set_ptr = NULL; 57 errno = 0; 58 ASSERT_EQ(-1, fn(set_ptr, SIGSEGV)); 59 ASSERT_EQ(EINVAL, errno); 60 61 SigSetT set = {}; 62 63 // Bad signal number: too small. 64 errno = 0; 65 ASSERT_EQ(-1, fn(&set, 0)); 66 ASSERT_EQ(EINVAL, errno); 67 68 // Bad signal number: too high. 69 errno = 0; 70 ASSERT_EQ(-1, fn(&set, SIGNAL_MAX(&set) + 1)); 71 ASSERT_EQ(EINVAL, errno); 72 73 // Good signal numbers, low and high ends of range. 74 errno = 0; 75 ASSERT_EQ(0, fn(&set, SIGNAL_MIN())); 76 ASSERT_EQ(0, errno); 77 ASSERT_EQ(0, fn(&set, SIGNAL_MAX(&set))); 78 ASSERT_EQ(0, errno); 79 } 80 81 TEST(signal, sigaddset_invalid) { 82 TestSigSet2(sigaddset); 83 } 84 85 TEST(signal, sigaddset64_invalid) { 86 #if defined(__BIONIC__) 87 TestSigSet2(sigaddset64); 88 #endif 89 } 90 91 TEST(signal, sigdelset_invalid) { 92 TestSigSet2(sigdelset); 93 } 94 95 TEST(signal, sigdelset64_invalid) { 96 #if defined(__BIONIC__) 97 TestSigSet2(sigdelset64); 98 #endif 99 } 100 101 TEST(signal, sigemptyset_invalid) { 102 TestSigSet1(sigemptyset); 103 } 104 105 TEST(signal, sigemptyset64_invalid) { 106 #if defined(__BIONIC__) 107 TestSigSet1(sigemptyset64); 108 #endif 109 } 110 111 TEST(signal, sigfillset_invalid) { 112 TestSigSet1(sigfillset); 113 } 114 115 TEST(signal, sigfillset64_invalid) { 116 #if defined(__BIONIC__) 117 TestSigSet1(sigfillset64); 118 #endif 119 } 120 121 TEST(signal, sigismember_invalid) { 122 TestSigSet2(sigismember); 123 } 124 125 TEST(signal, sigismember64_invalid) { 126 #if defined(__BIONIC__) 127 TestSigSet2(sigismember64); 128 #endif 129 } 130 131 TEST(signal, raise_invalid) { 132 errno = 0; 133 ASSERT_EQ(-1, raise(-1)); 134 ASSERT_EQ(EINVAL, errno); 135 } 136 137 static void raise_in_signal_handler_helper(int signal_number) { 138 ASSERT_EQ(SIGALRM, signal_number); 139 static int count = 0; 140 if (++count == 1) { 141 raise(SIGALRM); 142 } 143 } 144 145 TEST(signal, raise_in_signal_handler) { 146 ScopedSignalHandler ssh(SIGALRM, raise_in_signal_handler_helper); 147 raise(SIGALRM); 148 } 149 150 TEST(signal, sigwait_SIGALRM) { 151 ScopedSignalHandler ssh(SIGALRM, [](int sig) { ASSERT_EQ(SIGALRM, sig); }); 152 153 sigset_t wait_set; 154 sigemptyset(&wait_set); 155 sigaddset(&wait_set, SIGALRM); 156 157 alarm(1); 158 159 int received_signal; 160 errno = 0; 161 ASSERT_EQ(0, sigwait(&wait_set, &received_signal)); 162 ASSERT_EQ(0, errno); 163 ASSERT_EQ(SIGALRM, received_signal); 164 } 165 166 TEST(signal, sigwait64_SIGRTMIN) { 167 ScopedSignalHandler ssh(SIGRTMIN, [](int sig) { ASSERT_EQ(SIGRTMIN, sig); }); 168 169 sigset64_t wait_set; 170 sigemptyset64(&wait_set); 171 sigaddset64(&wait_set, SIGRTMIN); 172 173 pid_t pid = getpid(); 174 std::thread thread([&pid]() { 175 usleep(5000); 176 kill(pid, SIGRTMIN); 177 }); 178 179 int received_signal; 180 errno = 0; 181 ASSERT_EQ(0, sigwait64(&wait_set, &received_signal)); 182 ASSERT_EQ(0, errno); 183 ASSERT_EQ(SIGRTMIN, received_signal); 184 185 thread.join(); 186 } 187 188 static int g_sigsuspend_signal_handler_call_count = 0; 189 190 TEST(signal, sigsuspend_sigpending) { 191 SignalMaskRestorer smr; 192 193 // Block SIGALRM. 194 sigset_t just_SIGALRM; 195 sigemptyset(&just_SIGALRM); 196 sigaddset(&just_SIGALRM, SIGALRM); 197 ASSERT_EQ(0, sigprocmask(SIG_BLOCK, &just_SIGALRM, nullptr)); 198 199 ScopedSignalHandler ssh(SIGALRM, [](int) { ++g_sigsuspend_signal_handler_call_count; }); 200 201 // There should be no pending signals. 202 sigset_t pending; 203 sigemptyset(&pending); 204 ASSERT_EQ(0, sigpending(&pending)); 205 for (int i = SIGNAL_MIN(); i <= SIGNAL_MAX(&pending); ++i) { 206 EXPECT_FALSE(sigismember(&pending, i)) << i; 207 } 208 209 // Raise SIGALRM and check our signal handler wasn't called. 210 raise(SIGALRM); 211 ASSERT_EQ(0, g_sigsuspend_signal_handler_call_count); 212 213 // We should now have a pending SIGALRM but nothing else. 214 sigemptyset(&pending); 215 ASSERT_EQ(0, sigpending(&pending)); 216 for (int i = SIGNAL_MIN(); i <= SIGNAL_MAX(&pending); ++i) { 217 EXPECT_EQ((i == SIGALRM), sigismember(&pending, i)); 218 } 219 220 // Use sigsuspend to block everything except SIGALRM... 221 sigset_t not_SIGALRM; 222 sigfillset(¬_SIGALRM); 223 sigdelset(¬_SIGALRM, SIGALRM); 224 ASSERT_EQ(-1, sigsuspend(¬_SIGALRM)); 225 ASSERT_EQ(EINTR, errno); 226 // ...and check that we now receive our pending SIGALRM. 227 ASSERT_EQ(1, g_sigsuspend_signal_handler_call_count); 228 } 229 230 static int g_sigsuspend64_signal_handler_call_count = 0; 231 232 TEST(signal, sigsuspend64_sigpending64) { 233 SignalMaskRestorer smr; 234 235 // Block SIGRTMIN. 236 sigset64_t just_SIGRTMIN; 237 sigemptyset64(&just_SIGRTMIN); 238 sigaddset64(&just_SIGRTMIN, SIGRTMIN); 239 ASSERT_EQ(0, sigprocmask64(SIG_BLOCK, &just_SIGRTMIN, nullptr)); 240 241 ScopedSignalHandler ssh(SIGRTMIN, [](int) { ++g_sigsuspend64_signal_handler_call_count; }); 242 243 // There should be no pending signals. 244 sigset64_t pending; 245 sigemptyset64(&pending); 246 ASSERT_EQ(0, sigpending64(&pending)); 247 for (int i = SIGNAL_MIN(); i <= SIGNAL_MAX(&pending); ++i) { 248 EXPECT_FALSE(sigismember64(&pending, i)) << i; 249 } 250 251 // Raise SIGRTMIN and check our signal handler wasn't called. 252 raise(SIGRTMIN); 253 ASSERT_EQ(0, g_sigsuspend64_signal_handler_call_count); 254 255 // We should now have a pending SIGRTMIN but nothing else. 256 sigemptyset64(&pending); 257 ASSERT_EQ(0, sigpending64(&pending)); 258 for (int i = SIGNAL_MIN(); i <= SIGNAL_MAX(&pending); ++i) { 259 EXPECT_EQ((i == SIGRTMIN), sigismember64(&pending, i)); 260 } 261 262 // Use sigsuspend64 to block everything except SIGRTMIN... 263 sigset64_t not_SIGRTMIN; 264 sigfillset64(¬_SIGRTMIN); 265 sigdelset64(¬_SIGRTMIN, SIGRTMIN); 266 ASSERT_EQ(-1, sigsuspend64(¬_SIGRTMIN)); 267 ASSERT_EQ(EINTR, errno); 268 // ...and check that we now receive our pending SIGRTMIN. 269 ASSERT_EQ(1, g_sigsuspend64_signal_handler_call_count); 270 } 271 272 template <typename SigActionT, typename SigSetT> 273 static void TestSigAction(int (sigaction_fn)(int, const SigActionT*, SigActionT*), 274 int (sigaddset_fn)(SigSetT*, int), 275 int sig) { 276 // Both bionic and glibc set SA_RESTORER when talking to the kernel on arm, 277 // arm64, x86, and x86-64. The version of glibc we're using also doesn't 278 // define SA_RESTORER, but luckily it's the same value everywhere, and mips 279 // doesn't use the bit for anything. 280 static const unsigned sa_restorer = 0x4000000; 281 282 // See what's currently set for this signal. 283 SigActionT original_sa = {}; 284 ASSERT_EQ(0, sigaction_fn(sig, NULL, &original_sa)); 285 ASSERT_TRUE(original_sa.sa_handler == NULL); 286 ASSERT_TRUE(original_sa.sa_sigaction == NULL); 287 ASSERT_EQ(0U, original_sa.sa_flags & ~sa_restorer); 288 #ifdef SA_RESTORER 289 ASSERT_EQ(bool(original_sa.sa_flags & sa_restorer), bool(original_sa.sa_restorer)); 290 #endif 291 292 // Set a traditional sa_handler signal handler. 293 auto no_op_signal_handler = [](int) {}; 294 SigActionT sa = {}; 295 sigaddset_fn(&sa.sa_mask, sig); 296 sa.sa_flags = SA_ONSTACK; 297 sa.sa_handler = no_op_signal_handler; 298 ASSERT_EQ(0, sigaction_fn(sig, &sa, NULL)); 299 300 // Check that we can read it back. 301 sa = {}; 302 ASSERT_EQ(0, sigaction_fn(sig, NULL, &sa)); 303 ASSERT_TRUE(sa.sa_handler == no_op_signal_handler); 304 ASSERT_TRUE((void*) sa.sa_sigaction == (void*) sa.sa_handler); 305 ASSERT_EQ(static_cast<unsigned>(SA_ONSTACK), sa.sa_flags & ~sa_restorer); 306 #ifdef SA_RESTORER 307 ASSERT_EQ(bool(sa.sa_flags & sa_restorer), bool(sa.sa_restorer)); 308 #endif 309 310 // Set a new-style sa_sigaction signal handler. 311 auto no_op_sigaction = [](int, siginfo_t*, void*) {}; 312 sa = {}; 313 sigaddset_fn(&sa.sa_mask, sig); 314 sa.sa_flags = SA_ONSTACK | SA_SIGINFO; 315 sa.sa_sigaction = no_op_sigaction; 316 ASSERT_EQ(0, sigaction_fn(sig, &sa, NULL)); 317 318 // Check that we can read it back. 319 sa = {}; 320 ASSERT_EQ(0, sigaction_fn(sig, NULL, &sa)); 321 ASSERT_TRUE(sa.sa_sigaction == no_op_sigaction); 322 ASSERT_TRUE((void*) sa.sa_sigaction == (void*) sa.sa_handler); 323 ASSERT_EQ(static_cast<unsigned>(SA_ONSTACK | SA_SIGINFO), sa.sa_flags & ~sa_restorer); 324 #ifdef SA_RESTORER 325 ASSERT_EQ(bool(sa.sa_flags & sa_restorer), bool(sa.sa_restorer)); 326 #endif 327 328 // Put everything back how it was. 329 ASSERT_EQ(0, sigaction_fn(sig, &original_sa, NULL)); 330 } 331 332 TEST(signal, sigaction) { 333 TestSigAction(sigaction, sigaddset, SIGALRM); 334 } 335 336 TEST(signal, sigaction64_SIGRTMIN) { 337 TestSigAction(sigaction64, sigaddset64, SIGRTMIN); 338 } 339 340 static void ClearSignalMask() { 341 uint64_t sigset = 0; 342 if (syscall(__NR_rt_sigprocmask, SIG_SETMASK, &sigset, nullptr, sizeof(sigset)) != 0) { 343 abort(); 344 } 345 } 346 347 static uint64_t GetSignalMask() { 348 uint64_t sigset; 349 if (syscall(__NR_rt_sigprocmask, SIG_SETMASK, nullptr, &sigset, sizeof(sigset)) != 0) { 350 abort(); 351 } 352 return sigset; 353 } 354 355 enum class SignalMaskFunctionType { 356 RtAware, 357 RtNonaware, 358 }; 359 360 #if defined(__LP64__) || !defined(__BIONIC__) 361 constexpr SignalMaskFunctionType sigset_type = SignalMaskFunctionType::RtAware; 362 #else 363 constexpr SignalMaskFunctionType sigset_type = SignalMaskFunctionType::RtNonaware; 364 #endif 365 366 static void TestSignalMaskFiltered(uint64_t sigset, SignalMaskFunctionType type) { 367 for (int signo = 1; signo <= 64; ++signo) { 368 bool signal_blocked = sigset & (1ULL << (signo - 1)); 369 if (signo == SIGKILL || signo == SIGSTOP) { 370 // SIGKILL and SIGSTOP shouldn't be blocked. 371 EXPECT_EQ(false, signal_blocked) << "signal " << signo; 372 } else if (signo < __SIGRTMIN) { 373 // Everything else should be blocked. 374 EXPECT_EQ(true, signal_blocked) << "signal " << signo; 375 } else if (signo >= __SIGRTMIN && signo < SIGRTMIN) { 376 // Reserved signals must not be blocked. 377 EXPECT_EQ(false, signal_blocked) << "signal " << signo; 378 } else if (type == SignalMaskFunctionType::RtAware) { 379 // Realtime signals should be blocked, unless we blocked using a non-rt aware function. 380 EXPECT_EQ(true, signal_blocked) << "signal " << signo; 381 } 382 } 383 } 384 385 static void TestSignalMaskFunction(std::function<void()> fn, SignalMaskFunctionType fn_type) { 386 ClearSignalMask(); 387 fn(); 388 TestSignalMaskFiltered(GetSignalMask(), fn_type); 389 } 390 391 TEST(signal, sigaction_filter) { 392 ClearSignalMask(); 393 static uint64_t sigset; 394 struct sigaction sa = {}; 395 sa.sa_handler = [](int) { sigset = GetSignalMask(); }; 396 sigfillset(&sa.sa_mask); 397 sigaction(SIGUSR1, &sa, nullptr); 398 raise(SIGUSR1); 399 ASSERT_NE(0ULL, sigset); 400 TestSignalMaskFiltered(sigset, sigset_type); 401 } 402 403 TEST(signal, sigaction64_filter) { 404 ClearSignalMask(); 405 static uint64_t sigset; 406 struct sigaction64 sa = {}; 407 sa.sa_handler = [](int) { sigset = GetSignalMask(); }; 408 sigfillset64(&sa.sa_mask); 409 sigaction64(SIGUSR1, &sa, nullptr); 410 raise(SIGUSR1); 411 ASSERT_NE(0ULL, sigset); 412 TestSignalMaskFiltered(sigset, SignalMaskFunctionType::RtAware); 413 } 414 415 TEST(signal, sigprocmask_setmask_filter) { 416 TestSignalMaskFunction( 417 []() { 418 sigset_t sigset_libc; 419 sigfillset(&sigset_libc); 420 ASSERT_EQ(0, sigprocmask(SIG_SETMASK, &sigset_libc, nullptr)); 421 }, 422 sigset_type); 423 } 424 425 TEST(signal, sigprocmask64_setmask_filter) { 426 TestSignalMaskFunction( 427 []() { 428 sigset64_t sigset_libc; 429 sigfillset64(&sigset_libc); 430 ASSERT_EQ(0, sigprocmask64(SIG_SETMASK, &sigset_libc, nullptr)); 431 }, 432 SignalMaskFunctionType::RtAware); 433 } 434 435 TEST(signal, pthread_sigmask_setmask_filter) { 436 TestSignalMaskFunction( 437 []() { 438 sigset_t sigset_libc; 439 sigfillset(&sigset_libc); 440 ASSERT_EQ(0, pthread_sigmask(SIG_SETMASK, &sigset_libc, nullptr)); 441 }, 442 sigset_type); 443 } 444 445 TEST(signal, pthread_sigmask64_setmask_filter) { 446 TestSignalMaskFunction( 447 []() { 448 sigset64_t sigset_libc; 449 sigfillset64(&sigset_libc); 450 ASSERT_EQ(0, pthread_sigmask64(SIG_SETMASK, &sigset_libc, nullptr)); 451 }, 452 SignalMaskFunctionType::RtAware); 453 } 454 455 TEST(signal, sigprocmask_block_filter) { 456 TestSignalMaskFunction( 457 []() { 458 sigset_t sigset_libc; 459 sigfillset(&sigset_libc); 460 ASSERT_EQ(0, sigprocmask(SIG_BLOCK, &sigset_libc, nullptr)); 461 }, 462 sigset_type); 463 } 464 465 TEST(signal, sigprocmask64_block_filter) { 466 TestSignalMaskFunction( 467 []() { 468 sigset64_t sigset_libc; 469 sigfillset64(&sigset_libc); 470 ASSERT_EQ(0, sigprocmask64(SIG_BLOCK, &sigset_libc, nullptr)); 471 }, 472 SignalMaskFunctionType::RtAware); 473 } 474 475 TEST(signal, pthread_sigmask_block_filter) { 476 TestSignalMaskFunction( 477 []() { 478 sigset_t sigset_libc; 479 sigfillset(&sigset_libc); 480 ASSERT_EQ(0, pthread_sigmask(SIG_BLOCK, &sigset_libc, nullptr)); 481 }, 482 sigset_type); 483 } 484 485 TEST(signal, pthread_sigmask64_block_filter) { 486 TestSignalMaskFunction( 487 []() { 488 sigset64_t sigset_libc; 489 sigfillset64(&sigset_libc); 490 ASSERT_EQ(0, pthread_sigmask64(SIG_BLOCK, &sigset_libc, nullptr)); 491 }, 492 SignalMaskFunctionType::RtAware); 493 } 494 495 // glibc filters out signals via sigfillset, not the actual underlying functions. 496 TEST(signal, sigset_filter) { 497 #if defined(__BIONIC__) 498 TestSignalMaskFunction( 499 []() { 500 for (int i = 1; i <= 64; ++i) { 501 sigset(i, SIG_HOLD); 502 } 503 }, 504 SignalMaskFunctionType::RtAware); 505 #endif 506 } 507 508 TEST(signal, sighold_filter) { 509 #if defined(__BIONIC__) 510 TestSignalMaskFunction( 511 []() { 512 for (int i = 1; i <= 64; ++i) { 513 sighold(i); 514 } 515 }, 516 SignalMaskFunctionType::RtAware); 517 #endif 518 } 519 520 #if defined(__BIONIC__) 521 // Not exposed via headers, but the symbols are available if you declare them yourself. 522 extern "C" int sigblock(int); 523 extern "C" int sigsetmask(int); 524 #endif 525 526 TEST(signal, sigblock_filter) { 527 #if defined(__BIONIC__) 528 TestSignalMaskFunction( 529 []() { 530 int mask = ~0U; 531 ASSERT_EQ(0, sigblock(mask)); 532 }, 533 SignalMaskFunctionType::RtNonaware); 534 #endif 535 } 536 537 TEST(signal, sigsetmask_filter) { 538 #if defined(__BIONIC__) 539 TestSignalMaskFunction( 540 []() { 541 int mask = ~0U; 542 ASSERT_EQ(0, sigsetmask(mask)); 543 }, 544 SignalMaskFunctionType::RtNonaware); 545 #endif 546 } 547 548 TEST(signal, sys_signame) { 549 #if defined(__BIONIC__) 550 ASSERT_TRUE(sys_signame[0] == NULL); 551 ASSERT_STREQ("HUP", sys_signame[SIGHUP]); 552 #else 553 GTEST_LOG_(INFO) << "This test does nothing.\n"; 554 #endif 555 } 556 557 TEST(signal, sys_siglist) { 558 ASSERT_TRUE(sys_siglist[0] == NULL); 559 ASSERT_STREQ("Hangup", sys_siglist[SIGHUP]); 560 } 561 562 TEST(signal, limits) { 563 // This comes from the kernel. 564 ASSERT_EQ(32, __SIGRTMIN); 565 566 // We reserve a non-zero number at the bottom for ourselves. 567 ASSERT_GT(SIGRTMIN, __SIGRTMIN); 568 569 // MIPS has more signals than everyone else. 570 #if defined(__mips__) 571 ASSERT_EQ(128, __SIGRTMAX); 572 #else 573 ASSERT_EQ(64, __SIGRTMAX); 574 #endif 575 576 // We don't currently reserve any at the top. 577 ASSERT_EQ(SIGRTMAX, __SIGRTMAX); 578 } 579 580 static int g_sigqueue_signal_handler_call_count = 0; 581 582 static void SigqueueSignalHandler(int signum, siginfo_t* info, void*) { 583 ASSERT_EQ(SIGALRM, signum); 584 ASSERT_EQ(SIGALRM, info->si_signo); 585 ASSERT_EQ(SI_QUEUE, info->si_code); 586 ASSERT_EQ(1, info->si_value.sival_int); 587 ++g_sigqueue_signal_handler_call_count; 588 } 589 590 TEST(signal, sigqueue) { 591 ScopedSignalHandler ssh(SIGALRM, SigqueueSignalHandler, SA_SIGINFO); 592 sigval_t sigval; 593 sigval.sival_int = 1; 594 errno = 0; 595 ASSERT_EQ(0, sigqueue(getpid(), SIGALRM, sigval)); 596 ASSERT_EQ(0, errno); 597 ASSERT_EQ(1, g_sigqueue_signal_handler_call_count); 598 } 599 600 TEST(signal, sigwaitinfo) { 601 SignalMaskRestorer smr; 602 603 // Block SIGALRM. 604 sigset_t just_SIGALRM; 605 sigemptyset(&just_SIGALRM); 606 sigaddset(&just_SIGALRM, SIGALRM); 607 ASSERT_EQ(0, sigprocmask(SIG_BLOCK, &just_SIGALRM, nullptr)); 608 609 // Raise SIGALRM. 610 sigval_t sigval; 611 sigval.sival_int = 1; 612 ASSERT_EQ(0, sigqueue(getpid(), SIGALRM, sigval)); 613 614 // Get pending SIGALRM. 615 siginfo_t info; 616 errno = 0; 617 ASSERT_EQ(SIGALRM, sigwaitinfo(&just_SIGALRM, &info)); 618 ASSERT_EQ(0, errno); 619 ASSERT_EQ(SIGALRM, info.si_signo); 620 ASSERT_EQ(1, info.si_value.sival_int); 621 } 622 623 TEST(signal, sigwaitinfo64_SIGRTMIN) { 624 SignalMaskRestorer smr; 625 626 // Block SIGRTMIN. 627 sigset64_t just_SIGRTMIN; 628 sigemptyset64(&just_SIGRTMIN); 629 sigaddset64(&just_SIGRTMIN, SIGRTMIN); 630 ASSERT_EQ(0, sigprocmask64(SIG_BLOCK, &just_SIGRTMIN, nullptr)); 631 632 // Raise SIGRTMIN. 633 sigval_t sigval; 634 sigval.sival_int = 1; 635 ASSERT_EQ(0, sigqueue(getpid(), SIGRTMIN, sigval)); 636 637 // Get pending SIGRTMIN. 638 siginfo_t info; 639 errno = 0; 640 ASSERT_EQ(SIGRTMIN, sigwaitinfo64(&just_SIGRTMIN, &info)); 641 ASSERT_EQ(0, errno); 642 ASSERT_EQ(SIGRTMIN, info.si_signo); 643 ASSERT_EQ(1, info.si_value.sival_int); 644 } 645 646 TEST(signal, sigtimedwait) { 647 SignalMaskRestorer smr; 648 649 // Block SIGALRM. 650 sigset_t just_SIGALRM; 651 sigemptyset(&just_SIGALRM); 652 sigaddset(&just_SIGALRM, SIGALRM); 653 ASSERT_EQ(0, sigprocmask(SIG_BLOCK, &just_SIGALRM, nullptr)); 654 655 // Raise SIGALRM. 656 sigval_t sigval = { .sival_int = 1 }; 657 ASSERT_EQ(0, sigqueue(getpid(), SIGALRM, sigval)); 658 659 // Get pending SIGALRM. 660 siginfo_t info; 661 timespec timeout = { .tv_sec = 2, .tv_nsec = 0 }; 662 errno = 0; 663 ASSERT_EQ(SIGALRM, sigtimedwait(&just_SIGALRM, &info, &timeout)); 664 ASSERT_EQ(0, errno); 665 } 666 667 TEST(signal, sigtimedwait64_SIGRTMIN) { 668 SignalMaskRestorer smr; 669 670 // Block SIGRTMIN. 671 sigset64_t just_SIGRTMIN; 672 sigemptyset64(&just_SIGRTMIN); 673 sigaddset64(&just_SIGRTMIN, SIGRTMIN); 674 ASSERT_EQ(0, sigprocmask64(SIG_BLOCK, &just_SIGRTMIN, nullptr)); 675 676 // Raise SIGALRM. 677 sigval_t sigval = { .sival_int = 1 }; 678 ASSERT_EQ(0, sigqueue(getpid(), SIGRTMIN, sigval)); 679 680 // Get pending SIGALRM. 681 siginfo_t info; 682 timespec timeout = { .tv_sec = 2, .tv_nsec = 0 }; 683 errno = 0; 684 ASSERT_EQ(SIGRTMIN, sigtimedwait64(&just_SIGRTMIN, &info, &timeout)); 685 ASSERT_EQ(0, errno); 686 } 687 688 static int64_t NanoTime() { 689 timespec t; 690 clock_gettime(CLOCK_MONOTONIC, &t); 691 return static_cast<int64_t>(t.tv_sec) * 1000000000LL + t.tv_nsec; 692 } 693 694 TEST(signal, sigtimedwait_timeout) { 695 // Block SIGALRM. 696 sigset_t just_SIGALRM; 697 sigemptyset(&just_SIGALRM); 698 sigaddset(&just_SIGALRM, SIGALRM); 699 sigset_t original_set; 700 ASSERT_EQ(0, sigprocmask(SIG_BLOCK, &just_SIGALRM, &original_set)); 701 702 // Wait timeout. 703 int64_t start_time = NanoTime(); 704 siginfo_t info; 705 timespec timeout = { .tv_sec = 0, .tv_nsec = 1000000 }; 706 errno = 0; 707 ASSERT_EQ(-1, sigtimedwait(&just_SIGALRM, &info, &timeout)); 708 ASSERT_EQ(EAGAIN, errno); 709 ASSERT_GE(NanoTime() - start_time, 1000000); 710 711 ASSERT_EQ(0, sigprocmask(SIG_SETMASK, &original_set, NULL)); 712 } 713 714 #if defined(__BIONIC__) 715 TEST(signal, rt_tgsigqueueinfo) { 716 // Test whether rt_tgsigqueueinfo allows sending arbitrary si_code values to self. 717 // If this fails, your kernel needs commit 66dd34a to be backported. 718 static constexpr char error_msg[] = 719 "\nPlease ensure that the following kernel patch has been applied:\n" 720 "* https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=66dd34ad31e5963d72a700ec3f2449291d322921\n"; 721 static siginfo received; 722 723 struct sigaction handler = {}; 724 handler.sa_sigaction = [](int, siginfo_t* siginfo, void*) { received = *siginfo; }; 725 handler.sa_flags = SA_SIGINFO; 726 727 ASSERT_EQ(0, sigaction(SIGUSR1, &handler, nullptr)); 728 729 siginfo sent; 730 memset(&sent, 0, sizeof(sent)); 731 732 sent.si_code = SI_TKILL; 733 ASSERT_EQ(0, syscall(SYS_rt_tgsigqueueinfo, getpid(), gettid(), SIGUSR1, &sent)) 734 << "rt_tgsigqueueinfo failed: " << strerror(errno) << error_msg; 735 ASSERT_EQ(sent.si_code, received.si_code) << "rt_tgsigqueueinfo modified si_code, expected " 736 << sent.si_code << ", received " << received.si_code 737 << error_msg; 738 739 sent.si_code = SI_USER; 740 ASSERT_EQ(0, syscall(SYS_rt_tgsigqueueinfo, getpid(), gettid(), SIGUSR1, &sent)) 741 << "rt_tgsigqueueinfo failed: " << strerror(errno) << error_msg; 742 ASSERT_EQ(sent.si_code, received.si_code) << "rt_tgsigqueueinfo modified si_code, expected " 743 << sent.si_code << ", received " << received.si_code 744 << error_msg; 745 } 746 #endif 747 748 TEST(signal, sigset_size) { 749 // The setjmp implementations for ARM, AArch64, x86, and x86_64 assume that sigset_t can fit in a 750 // long. This is true because ARM and x86 have broken rt signal support, and AArch64 and x86_64 751 // both have a SIGRTMAX defined as 64. 752 #if defined(__arm__) || defined(__aarch64__) || defined(__i386__) || defined(__x86_64__) 753 #if defined(__BIONIC__) 754 static_assert(sizeof(sigset_t) <= sizeof(long), "sigset_t doesn't fit in a long"); 755 #endif 756 static_assert(sizeof(sigset64_t)*8 >= 64, "sigset64_t too small for real-time signals"); 757 #endif 758 } 759 760 TEST(signal, sigignore_EINVAL) { 761 errno = 0; 762 ASSERT_EQ(-1, sigignore(99999)); 763 ASSERT_EQ(EINVAL, errno); 764 } 765 766 TEST(signal, sigignore) { 767 errno = 0; 768 EXPECT_EQ(-1, sigignore(SIGKILL)); 769 EXPECT_EQ(errno, EINVAL); 770 771 errno = 0; 772 EXPECT_EQ(-1, sigignore(SIGSTOP)); 773 EXPECT_EQ(errno, EINVAL); 774 775 ScopedSignalHandler sigalrm{SIGALRM}; 776 ASSERT_EQ(0, sigignore(SIGALRM)); 777 778 struct sigaction sa; 779 ASSERT_EQ(0, sigaction(SIGALRM, nullptr, &sa)); 780 EXPECT_EQ(SIG_IGN, sa.sa_handler); 781 } 782 783 TEST(signal, sighold_EINVAL) { 784 errno = 0; 785 ASSERT_EQ(-1, sighold(99999)); 786 ASSERT_EQ(EINVAL, errno); 787 } 788 789 TEST(signal, sigpause_EINVAL) { 790 errno = 0; 791 ASSERT_EQ(-1, sigpause(99999)); 792 ASSERT_EQ(EINVAL, errno); 793 } 794 795 TEST(signal, sigrelse_EINVAL) { 796 errno = 0; 797 ASSERT_EQ(-1, sigpause(99999)); 798 ASSERT_EQ(EINVAL, errno); 799 } 800 801 static void TestSigholdSigpauseSigrelse(int sig) { 802 static int signal_handler_call_count = 0; 803 ScopedSignalHandler ssh{sig, [](int) { signal_handler_call_count++; }}; 804 SignalMaskRestorer mask_restorer; 805 sigset_t set; 806 807 // sighold(SIGALRM/SIGRTMIN) should add SIGALRM/SIGRTMIN to the signal mask ... 808 ASSERT_EQ(0, sighold(sig)); 809 ASSERT_EQ(0, sigprocmask(SIG_SETMASK, 0, &set)); 810 EXPECT_TRUE(sigismember(&set, sig)); 811 812 // ... preventing our SIGALRM/SIGRTMIN handler from running ... 813 raise(sig); 814 ASSERT_EQ(0, signal_handler_call_count); 815 // ... until sigpause(SIGALRM/SIGRTMIN) temporarily unblocks it. 816 ASSERT_EQ(-1, sigpause(sig)); 817 ASSERT_EQ(EINTR, errno); 818 ASSERT_EQ(1, signal_handler_call_count); 819 820 if (sig >= SIGRTMIN && sizeof(void*) == 8) { 821 // But sigpause(SIGALRM/SIGRTMIN) shouldn't permanently unblock SIGALRM/SIGRTMIN. 822 ASSERT_EQ(0, sigprocmask(SIG_SETMASK, 0, &set)); 823 EXPECT_TRUE(sigismember(&set, sig)); 824 825 // Whereas sigrelse(SIGALRM/SIGRTMIN) should. 826 ASSERT_EQ(0, sigrelse(sig)); 827 ASSERT_EQ(0, sigprocmask(SIG_SETMASK, 0, &set)); 828 EXPECT_FALSE(sigismember(&set, sig)); 829 } else { 830 // sigismember won't work for SIGRTMIN on LP32. 831 } 832 } 833 834 TEST(signal, sighold_sigpause_sigrelse) { 835 TestSigholdSigpauseSigrelse(SIGALRM); 836 } 837 838 TEST(signal, sighold_sigpause_sigrelse_RT) { 839 TestSigholdSigpauseSigrelse(SIGRTMIN); 840 } 841 842 TEST(signal, sigset_EINVAL) { 843 errno = 0; 844 ASSERT_EQ(SIG_ERR, sigset(99999, SIG_DFL)); 845 ASSERT_EQ(EINVAL, errno); 846 } 847 848 TEST(signal, sigset_RT) { 849 static int signal_handler_call_count = 0; 850 auto signal_handler = [](int) { signal_handler_call_count++; }; 851 ScopedSignalHandler ssh{SIGRTMIN, signal_handler}; 852 SignalMaskRestorer mask_restorer; 853 854 ASSERT_EQ(signal_handler, sigset(SIGRTMIN, SIG_HOLD)); 855 #if defined(__LP64__) 856 sigset_t set; 857 ASSERT_EQ(0, sigprocmask(SIG_BLOCK, nullptr, &set)); 858 ASSERT_TRUE(sigismember(&set, SIGRTMIN)); 859 #endif 860 861 ASSERT_EQ(SIG_HOLD, sigset(SIGRTMIN, signal_handler)); 862 ASSERT_EQ(signal_handler, sigset(SIGRTMIN, signal_handler)); 863 ASSERT_EQ(0, signal_handler_call_count); 864 raise(SIGRTMIN); 865 ASSERT_EQ(1, signal_handler_call_count); 866 } 867 868 TEST(signal, sigset) { 869 static int signal_handler_call_count = 0; 870 auto signal_handler = [](int) { signal_handler_call_count++; }; 871 ScopedSignalHandler ssh{SIGALRM, signal_handler}; 872 SignalMaskRestorer mask_restorer; 873 874 ASSERT_EQ(0, signal_handler_call_count); 875 raise(SIGALRM); 876 ASSERT_EQ(1, signal_handler_call_count); 877 878 // Block SIGALRM so the next sigset(SIGARLM) call will return SIG_HOLD. 879 sigset_t set; 880 sigemptyset(&set); 881 sigaddset(&set, SIGALRM); 882 ASSERT_EQ(0, sigprocmask(SIG_BLOCK, &set, nullptr)); 883 884 sigemptyset(&set); 885 ASSERT_EQ(SIG_HOLD, sigset(SIGALRM, signal_handler)); 886 ASSERT_EQ(0, sigprocmask(SIG_BLOCK, nullptr, &set)); 887 EXPECT_FALSE(sigismember(&set, SIGALRM)); 888 889 ASSERT_EQ(signal_handler, sigset(SIGALRM, SIG_IGN)); 890 ASSERT_EQ(0, sigprocmask(SIG_BLOCK, nullptr, &set)); 891 EXPECT_FALSE(sigismember(&set, SIGALRM)); 892 893 ASSERT_EQ(SIG_IGN, sigset(SIGALRM, SIG_DFL)); 894 ASSERT_EQ(0, sigprocmask(SIG_BLOCK, nullptr, &set)); 895 EXPECT_FALSE(sigismember(&set, SIGALRM)); 896 897 ASSERT_EQ(SIG_DFL, sigset(SIGALRM, SIG_HOLD)); 898 ASSERT_EQ(0, sigprocmask(SIG_BLOCK, nullptr, &set)); 899 EXPECT_TRUE(sigismember(&set, SIGALRM)); 900 } 901 902 TEST(signal, killpg_EINVAL) { 903 // POSIX leaves pgrp <= 1 undefined, but glibc fails with EINVAL for < 0 904 // and passes 0 through to kill(2). 905 errno = 0; 906 ASSERT_EQ(-1, killpg(-1, SIGKILL)); 907 ASSERT_EQ(EINVAL, errno); 908 } 909
