1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2013 Red Hat, Inc., Frederic Weisbecker <fweisbec@redhat.com> 4 * 5 * Selftests for a few posix timers interface. 6 * 7 * Kernel loop code stolen from Steven Rostedt <srostedt@redhat.com> 8 */ 9 #define _GNU_SOURCE 10 #include <sys/time.h> 11 #include <sys/types.h> 12 #include <stdio.h> 13 #include <signal.h> 14 #include <stdint.h> 15 #include <string.h> 16 #include <unistd.h> 17 #include <time.h> 18 #include <include/vdso/time64.h> 19 #include <pthread.h> 20 21 #include "../kselftest.h" 22 23 #define DELAY 2 24 25 static void __fatal_error(const char *test, const char *name, const char *what) 26 { 27 char buf[64]; 28 char *ret_str = NULL; 29 30 ret_str = strerror_r(errno, buf, sizeof(buf)); 31 32 if (name && strlen(name) && ret_str) 33 ksft_exit_fail_msg("%s %s %s %s\n", test, name, what, ret_str); 34 else if (ret_str) 35 ksft_exit_fail_msg("%s %s %s\n", test, what, ret_str); 36 else 37 ksft_exit_fail_msg("%s %s\n", test, what); 38 39 } 40 41 #define fatal_error(name, what) __fatal_error(__func__, name, what) 42 43 static volatile int done; 44 45 /* Busy loop in userspace to elapse ITIMER_VIRTUAL */ 46 static void user_loop(void) 47 { 48 while (!done); 49 } 50 51 /* 52 * Try to spend as much time as possible in kernelspace 53 * to elapse ITIMER_PROF. 54 */ 55 static void kernel_loop(void) 56 { 57 void *addr = sbrk(0); 58 int err = 0; 59 60 while (!done && !err) { 61 err = brk(addr + 4096); 62 err |= brk(addr); 63 } 64 } 65 66 /* 67 * Sleep until ITIMER_REAL expiration. 68 */ 69 static void idle_loop(void) 70 { 71 pause(); 72 } 73 74 static void sig_handler(int nr) 75 { 76 done = 1; 77 } 78 79 /* 80 * Check the expected timer expiration matches the GTOD elapsed delta since 81 * we armed the timer. Keep a 0.5 sec error margin due to various jitter. 82 */ 83 static int check_diff(struct timeval start, struct timeval end) 84 { 85 long long diff; 86 87 diff = end.tv_usec - start.tv_usec; 88 diff += (end.tv_sec - start.tv_sec) * USEC_PER_SEC; 89 90 if (llabs(diff - DELAY * USEC_PER_SEC) > USEC_PER_SEC / 2) { 91 printf("Diff too high: %lld..", diff); 92 return -1; 93 } 94 95 return 0; 96 } 97 98 static void check_itimer(int which, const char *name) 99 { 100 struct timeval start, end; 101 struct itimerval val = { 102 .it_value.tv_sec = DELAY, 103 }; 104 105 done = 0; 106 107 if (which == ITIMER_VIRTUAL) 108 signal(SIGVTALRM, sig_handler); 109 else if (which == ITIMER_PROF) 110 signal(SIGPROF, sig_handler); 111 else if (which == ITIMER_REAL) 112 signal(SIGALRM, sig_handler); 113 114 if (gettimeofday(&start, NULL) < 0) 115 fatal_error(name, "gettimeofday()"); 116 117 if (setitimer(which, &val, NULL) < 0) 118 fatal_error(name, "setitimer()"); 119 120 if (which == ITIMER_VIRTUAL) 121 user_loop(); 122 else if (which == ITIMER_PROF) 123 kernel_loop(); 124 else if (which == ITIMER_REAL) 125 idle_loop(); 126 127 if (gettimeofday(&end, NULL) < 0) 128 fatal_error(name, "gettimeofday()"); 129 130 ksft_test_result(check_diff(start, end) == 0, "%s\n", name); 131 } 132 133 static void check_timer_create(int which, const char *name) 134 { 135 struct timeval start, end; 136 struct itimerspec val = { 137 .it_value.tv_sec = DELAY, 138 }; 139 timer_t id; 140 141 done = 0; 142 143 if (timer_create(which, NULL, &id) < 0) 144 fatal_error(name, "timer_create()"); 145 146 if (signal(SIGALRM, sig_handler) == SIG_ERR) 147 fatal_error(name, "signal()"); 148 149 if (gettimeofday(&start, NULL) < 0) 150 fatal_error(name, "gettimeofday()"); 151 152 if (timer_settime(id, 0, &val, NULL) < 0) 153 fatal_error(name, "timer_settime()"); 154 155 user_loop(); 156 157 if (gettimeofday(&end, NULL) < 0) 158 fatal_error(name, "gettimeofday()"); 159 160 ksft_test_result(check_diff(start, end) == 0, 161 "timer_create() per %s\n", name); 162 } 163 164 static pthread_t ctd_thread; 165 static volatile int ctd_count, ctd_failed; 166 167 static void ctd_sighandler(int sig) 168 { 169 if (pthread_self() != ctd_thread) 170 ctd_failed = 1; 171 ctd_count--; 172 } 173 174 static void *ctd_thread_func(void *arg) 175 { 176 struct itimerspec val = { 177 .it_value.tv_sec = 0, 178 .it_value.tv_nsec = 1000 * 1000, 179 .it_interval.tv_sec = 0, 180 .it_interval.tv_nsec = 1000 * 1000, 181 }; 182 timer_t id; 183 184 /* 1/10 seconds to ensure the leader sleeps */ 185 usleep(10000); 186 187 ctd_count = 100; 188 if (timer_create(CLOCK_PROCESS_CPUTIME_ID, NULL, &id)) 189 fatal_error(NULL, "timer_create()"); 190 if (timer_settime(id, 0, &val, NULL)) 191 fatal_error(NULL, "timer_settime()"); 192 while (ctd_count > 0 && !ctd_failed) 193 ; 194 195 if (timer_delete(id)) 196 fatal_error(NULL, "timer_delete()"); 197 198 return NULL; 199 } 200 201 /* 202 * Test that only the running thread receives the timer signal. 203 */ 204 static void check_timer_distribution(void) 205 { 206 if (signal(SIGALRM, ctd_sighandler) == SIG_ERR) 207 fatal_error(NULL, "signal()"); 208 209 if (pthread_create(&ctd_thread, NULL, ctd_thread_func, NULL)) 210 fatal_error(NULL, "pthread_create()"); 211 212 if (pthread_join(ctd_thread, NULL)) 213 fatal_error(NULL, "pthread_join()"); 214 215 if (!ctd_failed) 216 ksft_test_result_pass("check signal distribution\n"); 217 else if (ksft_min_kernel_version(6, 3)) 218 ksft_test_result_fail("check signal distribution\n"); 219 else 220 ksft_test_result_skip("check signal distribution (old kernel)\n"); 221 } 222 223 struct tmrsig { 224 int signals; 225 int overruns; 226 }; 227 228 static void siginfo_handler(int sig, siginfo_t *si, void *uc) 229 { 230 struct tmrsig *tsig = si ? si->si_ptr : NULL; 231 232 if (tsig) { 233 tsig->signals++; 234 tsig->overruns += si->si_overrun; 235 } 236 } 237 238 static void *ignore_thread(void *arg) 239 { 240 unsigned int *tid = arg; 241 sigset_t set; 242 243 sigemptyset(&set); 244 sigaddset(&set, SIGUSR1); 245 if (sigprocmask(SIG_BLOCK, &set, NULL)) 246 fatal_error(NULL, "sigprocmask(SIG_BLOCK)"); 247 248 *tid = gettid(); 249 sleep(100); 250 251 if (sigprocmask(SIG_UNBLOCK, &set, NULL)) 252 fatal_error(NULL, "sigprocmask(SIG_UNBLOCK)"); 253 return NULL; 254 } 255 256 static void check_sig_ign(int thread) 257 { 258 struct tmrsig tsig = { }; 259 struct itimerspec its; 260 unsigned int tid = 0; 261 struct sigaction sa; 262 struct sigevent sev; 263 pthread_t pthread; 264 timer_t timerid; 265 sigset_t set; 266 267 if (thread) { 268 if (pthread_create(&pthread, NULL, ignore_thread, &tid)) 269 fatal_error(NULL, "pthread_create()"); 270 sleep(1); 271 } 272 273 sa.sa_flags = SA_SIGINFO; 274 sa.sa_sigaction = siginfo_handler; 275 sigemptyset(&sa.sa_mask); 276 if (sigaction(SIGUSR1, &sa, NULL)) 277 fatal_error(NULL, "sigaction()"); 278 279 /* Block the signal */ 280 sigemptyset(&set); 281 sigaddset(&set, SIGUSR1); 282 if (sigprocmask(SIG_BLOCK, &set, NULL)) 283 fatal_error(NULL, "sigprocmask(SIG_BLOCK)"); 284 285 memset(&sev, 0, sizeof(sev)); 286 sev.sigev_notify = SIGEV_SIGNAL; 287 sev.sigev_signo = SIGUSR1; 288 sev.sigev_value.sival_ptr = &tsig; 289 if (thread) { 290 sev.sigev_notify = SIGEV_THREAD_ID; 291 sev._sigev_un._tid = tid; 292 } 293 294 if (timer_create(CLOCK_MONOTONIC, &sev, &timerid)) 295 fatal_error(NULL, "timer_create()"); 296 297 /* Start the timer to expire in 100ms and 100ms intervals */ 298 its.it_value.tv_sec = 0; 299 its.it_value.tv_nsec = 100000000; 300 its.it_interval.tv_sec = 0; 301 its.it_interval.tv_nsec = 100000000; 302 timer_settime(timerid, 0, &its, NULL); 303 304 sleep(1); 305 306 /* Set the signal to be ignored */ 307 if (signal(SIGUSR1, SIG_IGN) == SIG_ERR) 308 fatal_error(NULL, "signal(SIG_IGN)"); 309 310 sleep(1); 311 312 if (thread) { 313 /* Stop the thread first. No signal should be delivered to it */ 314 if (pthread_cancel(pthread)) 315 fatal_error(NULL, "pthread_cancel()"); 316 if (pthread_join(pthread, NULL)) 317 fatal_error(NULL, "pthread_join()"); 318 } 319 320 /* Restore the handler */ 321 if (sigaction(SIGUSR1, &sa, NULL)) 322 fatal_error(NULL, "sigaction()"); 323 324 sleep(1); 325 326 /* Unblock it, which should deliver the signal in the !thread case*/ 327 if (sigprocmask(SIG_UNBLOCK, &set, NULL)) 328 fatal_error(NULL, "sigprocmask(SIG_UNBLOCK)"); 329 330 if (timer_delete(timerid)) 331 fatal_error(NULL, "timer_delete()"); 332 333 if (!thread) { 334 ksft_test_result(tsig.signals == 1 && tsig.overruns == 29, 335 "check_sig_ign SIGEV_SIGNAL\n"); 336 } else { 337 ksft_test_result(tsig.signals == 0 && tsig.overruns == 0, 338 "check_sig_ign SIGEV_THREAD_ID\n"); 339 } 340 } 341 342 static void check_rearm(void) 343 { 344 struct tmrsig tsig = { }; 345 struct itimerspec its; 346 struct sigaction sa; 347 struct sigevent sev; 348 timer_t timerid; 349 sigset_t set; 350 351 sa.sa_flags = SA_SIGINFO; 352 sa.sa_sigaction = siginfo_handler; 353 sigemptyset(&sa.sa_mask); 354 if (sigaction(SIGUSR1, &sa, NULL)) 355 fatal_error(NULL, "sigaction()"); 356 357 /* Block the signal */ 358 sigemptyset(&set); 359 sigaddset(&set, SIGUSR1); 360 if (sigprocmask(SIG_BLOCK, &set, NULL)) 361 fatal_error(NULL, "sigprocmask(SIG_BLOCK)"); 362 363 memset(&sev, 0, sizeof(sev)); 364 sev.sigev_notify = SIGEV_SIGNAL; 365 sev.sigev_signo = SIGUSR1; 366 sev.sigev_value.sival_ptr = &tsig; 367 if (timer_create(CLOCK_MONOTONIC, &sev, &timerid)) 368 fatal_error(NULL, "timer_create()"); 369 370 /* Start the timer to expire in 100ms and 100ms intervals */ 371 its.it_value.tv_sec = 0; 372 its.it_value.tv_nsec = 100000000; 373 its.it_interval.tv_sec = 0; 374 its.it_interval.tv_nsec = 100000000; 375 if (timer_settime(timerid, 0, &its, NULL)) 376 fatal_error(NULL, "timer_settime()"); 377 378 sleep(1); 379 380 /* Reprogram the timer to single shot */ 381 its.it_value.tv_sec = 10; 382 its.it_value.tv_nsec = 0; 383 its.it_interval.tv_sec = 0; 384 its.it_interval.tv_nsec = 0; 385 if (timer_settime(timerid, 0, &its, NULL)) 386 fatal_error(NULL, "timer_settime()"); 387 388 /* Unblock it, which should not deliver a signal */ 389 if (sigprocmask(SIG_UNBLOCK, &set, NULL)) 390 fatal_error(NULL, "sigprocmask(SIG_UNBLOCK)"); 391 392 if (timer_delete(timerid)) 393 fatal_error(NULL, "timer_delete()"); 394 395 ksft_test_result(!tsig.signals, "check_rearm\n"); 396 } 397 398 static void check_delete(void) 399 { 400 struct tmrsig tsig = { }; 401 struct itimerspec its; 402 struct sigaction sa; 403 struct sigevent sev; 404 timer_t timerid; 405 sigset_t set; 406 407 sa.sa_flags = SA_SIGINFO; 408 sa.sa_sigaction = siginfo_handler; 409 sigemptyset(&sa.sa_mask); 410 if (sigaction(SIGUSR1, &sa, NULL)) 411 fatal_error(NULL, "sigaction()"); 412 413 /* Block the signal */ 414 sigemptyset(&set); 415 sigaddset(&set, SIGUSR1); 416 if (sigprocmask(SIG_BLOCK, &set, NULL)) 417 fatal_error(NULL, "sigprocmask(SIG_BLOCK)"); 418 419 memset(&sev, 0, sizeof(sev)); 420 sev.sigev_notify = SIGEV_SIGNAL; 421 sev.sigev_signo = SIGUSR1; 422 sev.sigev_value.sival_ptr = &tsig; 423 if (timer_create(CLOCK_MONOTONIC, &sev, &timerid)) 424 fatal_error(NULL, "timer_create()"); 425 426 /* Start the timer to expire in 100ms and 100ms intervals */ 427 its.it_value.tv_sec = 0; 428 its.it_value.tv_nsec = 100000000; 429 its.it_interval.tv_sec = 0; 430 its.it_interval.tv_nsec = 100000000; 431 if (timer_settime(timerid, 0, &its, NULL)) 432 fatal_error(NULL, "timer_settime()"); 433 434 sleep(1); 435 436 if (timer_delete(timerid)) 437 fatal_error(NULL, "timer_delete()"); 438 439 /* Unblock it, which should not deliver a signal */ 440 if (sigprocmask(SIG_UNBLOCK, &set, NULL)) 441 fatal_error(NULL, "sigprocmask(SIG_UNBLOCK)"); 442 443 ksft_test_result(!tsig.signals, "check_delete\n"); 444 } 445 446 static inline int64_t calcdiff_ns(struct timespec t1, struct timespec t2) 447 { 448 int64_t diff; 449 450 diff = NSEC_PER_SEC * (int64_t)((int) t1.tv_sec - (int) t2.tv_sec); 451 diff += ((int) t1.tv_nsec - (int) t2.tv_nsec); 452 return diff; 453 } 454 455 static void check_sigev_none(int which, const char *name) 456 { 457 struct timespec start, now; 458 struct itimerspec its; 459 struct sigevent sev; 460 timer_t timerid; 461 462 memset(&sev, 0, sizeof(sev)); 463 sev.sigev_notify = SIGEV_NONE; 464 465 if (timer_create(which, &sev, &timerid)) 466 fatal_error(name, "timer_create()"); 467 468 /* Start the timer to expire in 100ms and 100ms intervals */ 469 its.it_value.tv_sec = 0; 470 its.it_value.tv_nsec = 100000000; 471 its.it_interval.tv_sec = 0; 472 its.it_interval.tv_nsec = 100000000; 473 timer_settime(timerid, 0, &its, NULL); 474 475 if (clock_gettime(which, &start)) 476 fatal_error(name, "clock_gettime()"); 477 478 do { 479 if (clock_gettime(which, &now)) 480 fatal_error(name, "clock_gettime()"); 481 } while (calcdiff_ns(now, start) < NSEC_PER_SEC); 482 483 if (timer_gettime(timerid, &its)) 484 fatal_error(name, "timer_gettime()"); 485 486 if (timer_delete(timerid)) 487 fatal_error(name, "timer_delete()"); 488 489 ksft_test_result(its.it_value.tv_sec || its.it_value.tv_nsec, 490 "check_sigev_none %s\n", name); 491 } 492 493 static void check_gettime(int which, const char *name) 494 { 495 struct itimerspec its, prev; 496 struct timespec start, now; 497 struct sigevent sev; 498 timer_t timerid; 499 int wraps = 0; 500 sigset_t set; 501 502 /* Block the signal */ 503 sigemptyset(&set); 504 sigaddset(&set, SIGUSR1); 505 if (sigprocmask(SIG_BLOCK, &set, NULL)) 506 fatal_error(name, "sigprocmask(SIG_BLOCK)"); 507 508 memset(&sev, 0, sizeof(sev)); 509 sev.sigev_notify = SIGEV_SIGNAL; 510 sev.sigev_signo = SIGUSR1; 511 512 if (timer_create(which, &sev, &timerid)) 513 fatal_error(name, "timer_create()"); 514 515 /* Start the timer to expire in 100ms and 100ms intervals */ 516 its.it_value.tv_sec = 0; 517 its.it_value.tv_nsec = 100000000; 518 its.it_interval.tv_sec = 0; 519 its.it_interval.tv_nsec = 100000000; 520 if (timer_settime(timerid, 0, &its, NULL)) 521 fatal_error(name, "timer_settime()"); 522 523 if (timer_gettime(timerid, &prev)) 524 fatal_error(name, "timer_gettime()"); 525 526 if (clock_gettime(which, &start)) 527 fatal_error(name, "clock_gettime()"); 528 529 do { 530 if (clock_gettime(which, &now)) 531 fatal_error(name, "clock_gettime()"); 532 if (timer_gettime(timerid, &its)) 533 fatal_error(name, "timer_gettime()"); 534 if (its.it_value.tv_nsec > prev.it_value.tv_nsec) 535 wraps++; 536 prev = its; 537 538 } while (calcdiff_ns(now, start) < NSEC_PER_SEC); 539 540 if (timer_delete(timerid)) 541 fatal_error(name, "timer_delete()"); 542 543 ksft_test_result(wraps > 1, "check_gettime %s\n", name); 544 } 545 546 static void check_overrun(int which, const char *name) 547 { 548 struct timespec start, now; 549 struct tmrsig tsig = { }; 550 struct itimerspec its; 551 struct sigaction sa; 552 struct sigevent sev; 553 timer_t timerid; 554 sigset_t set; 555 556 sa.sa_flags = SA_SIGINFO; 557 sa.sa_sigaction = siginfo_handler; 558 sigemptyset(&sa.sa_mask); 559 if (sigaction(SIGUSR1, &sa, NULL)) 560 fatal_error(name, "sigaction()"); 561 562 /* Block the signal */ 563 sigemptyset(&set); 564 sigaddset(&set, SIGUSR1); 565 if (sigprocmask(SIG_BLOCK, &set, NULL)) 566 fatal_error(name, "sigprocmask(SIG_BLOCK)"); 567 568 memset(&sev, 0, sizeof(sev)); 569 sev.sigev_notify = SIGEV_SIGNAL; 570 sev.sigev_signo = SIGUSR1; 571 sev.sigev_value.sival_ptr = &tsig; 572 if (timer_create(which, &sev, &timerid)) 573 fatal_error(name, "timer_create()"); 574 575 /* Start the timer to expire in 100ms and 100ms intervals */ 576 its.it_value.tv_sec = 0; 577 its.it_value.tv_nsec = 100000000; 578 its.it_interval.tv_sec = 0; 579 its.it_interval.tv_nsec = 100000000; 580 if (timer_settime(timerid, 0, &its, NULL)) 581 fatal_error(name, "timer_settime()"); 582 583 if (clock_gettime(which, &start)) 584 fatal_error(name, "clock_gettime()"); 585 586 do { 587 if (clock_gettime(which, &now)) 588 fatal_error(name, "clock_gettime()"); 589 } while (calcdiff_ns(now, start) < NSEC_PER_SEC); 590 591 /* Unblock it, which should deliver a signal */ 592 if (sigprocmask(SIG_UNBLOCK, &set, NULL)) 593 fatal_error(name, "sigprocmask(SIG_UNBLOCK)"); 594 595 if (timer_delete(timerid)) 596 fatal_error(name, "timer_delete()"); 597 598 ksft_test_result(tsig.signals == 1 && tsig.overruns == 9, 599 "check_overrun %s\n", name); 600 } 601 602 int main(int argc, char **argv) 603 { 604 ksft_print_header(); 605 ksft_set_plan(18); 606 607 ksft_print_msg("Testing posix timers. False negative may happen on CPU execution \n"); 608 ksft_print_msg("based timers if other threads run on the CPU...\n"); 609 610 check_itimer(ITIMER_VIRTUAL, "ITIMER_VIRTUAL"); 611 check_itimer(ITIMER_PROF, "ITIMER_PROF"); 612 check_itimer(ITIMER_REAL, "ITIMER_REAL"); 613 check_timer_create(CLOCK_THREAD_CPUTIME_ID, "CLOCK_THREAD_CPUTIME_ID"); 614 615 /* 616 * It's unfortunately hard to reliably test a timer expiration 617 * on parallel multithread cputime. We could arm it to expire 618 * on DELAY * nr_threads, with nr_threads busy looping, then wait 619 * the normal DELAY since the time is elapsing nr_threads faster. 620 * But for that we need to ensure we have real physical free CPUs 621 * to ensure true parallelism. So test only one thread until we 622 * find a better solution. 623 */ 624 check_timer_create(CLOCK_PROCESS_CPUTIME_ID, "CLOCK_PROCESS_CPUTIME_ID"); 625 check_timer_distribution(); 626 627 check_sig_ign(0); 628 check_sig_ign(1); 629 check_rearm(); 630 check_delete(); 631 check_sigev_none(CLOCK_MONOTONIC, "CLOCK_MONOTONIC"); 632 check_sigev_none(CLOCK_PROCESS_CPUTIME_ID, "CLOCK_PROCESS_CPUTIME_ID"); 633 check_gettime(CLOCK_MONOTONIC, "CLOCK_MONOTONIC"); 634 check_gettime(CLOCK_PROCESS_CPUTIME_ID, "CLOCK_PROCESS_CPUTIME_ID"); 635 check_gettime(CLOCK_THREAD_CPUTIME_ID, "CLOCK_THREAD_CPUTIME_ID"); 636 check_overrun(CLOCK_MONOTONIC, "CLOCK_MONOTONIC"); 637 check_overrun(CLOCK_PROCESS_CPUTIME_ID, "CLOCK_PROCESS_CPUTIME_ID"); 638 check_overrun(CLOCK_THREAD_CPUTIME_ID, "CLOCK_THREAD_CPUTIME_ID"); 639 640 ksft_finished(); 641 } 642