rt/tst-timer4.c

   1 /* Tests for POSIX timer implementation.
   2    Copyright (C) 2004-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public License as
   7    published by the Free Software Foundation; either version 2.1 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If
  17    not, see <https://www.gnu.org/licenses/>.  */
  18
  19 #include <errno.h>
  20 #include <signal.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <time.h>
  24 #include <unistd.h>
  25 #include <stdint.h>
  26 #if _POSIX_THREADS && defined SA_SIGINFO
  27 # include <pthread.h>
  28
  29 # ifndef TEST_CLOCK
  30 #  define TEST_CLOCK            CLOCK_REALTIME
  31 # endif
  32
  33 pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
  34 pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
  35
  36 timer_t timer_none, timer_sig1, timer_sig2, timer_thr1, timer_thr2;
  37
  38 int thr1_cnt, thr1_err;
  39 union sigval thr1_sigval;
  40 struct timespec thr1_ts;
  41
  42 static void
  43 thr1 (union sigval sigval)
  44 {
  45   pthread_mutex_lock (&lock);
  46   thr1_err = clock_gettime (TEST_CLOCK, &thr1_ts);
  47   if (thr1_cnt >= 5)
  48     {
  49       struct itimerspec it = { };
  50       thr1_err |= timer_settime (timer_thr1, 0, &it, NULL);
  51     }
  52   thr1_sigval = sigval;
  53   ++thr1_cnt;
  54   pthread_cond_signal (&cond);
  55   pthread_mutex_unlock (&lock);
  56 }
  57
  58 int thr2_cnt, thr2_err;
  59 union sigval thr2_sigval;
  60 size_t thr2_guardsize;
  61 struct timespec thr2_ts;
  62
  63 static void
  64 thr2 (union sigval sigval)
  65 {
  66   pthread_attr_t nattr;
  67   int err = 0;
  68   size_t guardsize = -1;
  69   int ret = pthread_getattr_np (pthread_self (), &nattr);
  70   if (ret)
  71     {
  72       errno = ret;
  73       printf ("*** pthread_getattr_np failed: %m\n");
  74       err = 1;
  75     }
  76   else
  77     {
  78       ret = pthread_attr_getguardsize (&nattr, &guardsize);
  79       if (ret)
  80         {
  81           errno = ret;
  82           printf ("*** pthread_attr_getguardsize failed: %m\n");
  83           err = 1;
  84         }
  85       if (pthread_attr_destroy (&nattr) != 0)
  86         {
  87           puts ("*** pthread_attr_destroy failed");
  88           err = 1;
  89         }
  90     }
  91   pthread_mutex_lock (&lock);
  92   thr2_err = clock_gettime (TEST_CLOCK, &thr2_ts) | err;
  93   if (thr2_cnt >= 5)
  94     {
  95       struct itimerspec it = { };
  96       thr2_err |= timer_settime (timer_thr2, 0, &it, NULL);
  97     }
  98   thr2_sigval = sigval;
  99   ++thr2_cnt;
 100   thr2_guardsize = guardsize;
 101   pthread_cond_signal (&cond);
 102   pthread_mutex_unlock (&lock);
 103 }
 104
 105 volatile int sig1_cnt, sig1_err;
 106 volatile union sigval sig1_sigval;
 107 struct timespec sig1_ts;
 108
 109 static void
 110 sig1_handler (int sig, siginfo_t *info, void *ctx)
 111 {
 112   int err = 0;
 113   if (sig != SIGRTMIN) err |= 1 << 0;
 114   if (info->si_signo != SIGRTMIN) err |= 1 << 1;
 115   if (info->si_code != SI_TIMER) err |= 1 << 2;
 116   if (clock_gettime (TEST_CLOCK, &sig1_ts) != 0)
 117     err |= 1 << 3;
 118   if (sig1_cnt >= 5)
 119     {
 120       struct itimerspec it = { };
 121       if (timer_settime (timer_sig1, 0, &it, NULL))
 122         err |= 1 << 4;
 123     }
 124   sig1_err |= err;
 125   sig1_sigval = info->si_value;
 126   ++sig1_cnt;
 127 }
 128
 129 volatile int sig2_cnt, sig2_err;
 130 volatile union sigval sig2_sigval;
 131 struct timespec sig2_ts;
 132
 133 static void
 134 sig2_handler (int sig, siginfo_t *info, void *ctx)
 135 {
 136   int err = 0;
 137   if (sig != SIGRTMIN + 1) err |= 1 << 0;
 138   if (info->si_signo != SIGRTMIN + 1) err |= 1 << 1;
 139   if (info->si_code != SI_TIMER) err |= 1 << 2;
 140   if (clock_gettime (TEST_CLOCK, &sig2_ts) != 0)
 141     err |= 1 << 3;
 142   if (sig2_cnt >= 5)
 143     {
 144       struct itimerspec it = { };
 145       if (timer_settime (timer_sig2, 0, &it, NULL))
 146         err |= 1 << 4;
 147     }
 148   sig2_err |= err;
 149   sig2_sigval = info->si_value;
 150   ++sig2_cnt;
 151 }
 152
 153 /* Check if end is later or equal to start + nsec.  */
 154 static int
 155 check_ts (const char *name, const struct timespec *start,
 156           const struct timespec *end, long msec)
 157 {
 158   struct timespec ts = *start;
 159
 160   ts.tv_sec += msec / 1000000;
 161   ts.tv_nsec += (msec % 1000000) * 1000;
 162   if (ts.tv_nsec >= 1000000000)
 163     {
 164       ++ts.tv_sec;
 165       ts.tv_nsec -= 1000000000;
 166     }
 167   if (end->tv_sec < ts.tv_sec
 168       || (end->tv_sec == ts.tv_sec && end->tv_nsec < ts.tv_nsec))
 169     {
 170       printf ("\
 171 *** timer %s invoked too soon: %ld.%09jd instead of expected %ld.%09jd\n",
 172               name, (long) end->tv_sec, (intmax_t) end->tv_nsec,
 173               (long) ts.tv_sec, (intmax_t) ts.tv_nsec);
 174       return 1;
 175     }
 176   else
 177     return 0;
 178 }
 179
 180 #define TEST_FUNCTION do_test ()
 181 static int
 182 do_test (void)
 183 {
 184   int result = 0;
 185
 186 #ifdef TEST_CLOCK_MISSING
 187   const char *missing = TEST_CLOCK_MISSING (TEST_CLOCK);
 188   if (missing != NULL)
 189     {
 190       printf ("%s missing, skipping test\n", missing);
 191       return 0;
 192     }
 193 #endif
 194
 195   struct timespec ts;
 196   if (clock_gettime (TEST_CLOCK, &ts) != 0)
 197     {
 198       printf ("*** clock_gettime failed: %m\n");
 199       result = 1;
 200     }
 201   else
 202     printf ("clock_gettime returned timespec = { %ld, %jd }\n",
 203             (long) ts.tv_sec, (intmax_t) ts.tv_nsec);
 204
 205   if (clock_getres (TEST_CLOCK, &ts) != 0)
 206     {
 207       printf ("*** clock_getres failed: %m\n");
 208       result = 1;
 209     }
 210   else
 211     printf ("clock_getres returned timespec = { %ld, %jd }\n",
 212             (long) ts.tv_sec, (intmax_t) ts.tv_nsec);
 213
 214   struct sigevent ev;
 215   memset (&ev, 0x11, sizeof (ev));
 216   ev.sigev_notify = SIGEV_NONE;
 217   if (timer_create (TEST_CLOCK, &ev, &timer_none) != 0)
 218     {
 219       printf ("*** timer_create for timer_none failed: %m\n");
 220       return 1;
 221     }
 222
 223   struct sigaction sa = { .sa_sigaction = sig1_handler,
 224                           .sa_flags = SA_SIGINFO };
 225   sigemptyset (&sa.sa_mask);
 226   sigaction (SIGRTMIN, &sa, NULL);
 227   sa.sa_sigaction = sig2_handler;
 228   sigaction (SIGRTMIN + 1, &sa, NULL);
 229
 230   memset (&ev, 0x22, sizeof (ev));
 231   ev.sigev_notify = SIGEV_SIGNAL;
 232   ev.sigev_signo = SIGRTMIN;
 233   ev.sigev_value.sival_ptr = &ev;
 234   if (timer_create (TEST_CLOCK, &ev, &timer_sig1) != 0)
 235     {
 236       printf ("*** timer_create for timer_sig1 failed: %m\n");
 237       return 1;
 238     }
 239
 240   memset (&ev, 0x33, sizeof (ev));
 241   ev.sigev_notify = SIGEV_SIGNAL;
 242   ev.sigev_signo = SIGRTMIN + 1;
 243   ev.sigev_value.sival_int = 163;
 244   if (timer_create (TEST_CLOCK, &ev, &timer_sig2) != 0)
 245     {
 246       printf ("*** timer_create for timer_sig2 failed: %m\n");
 247       return 1;
 248     }
 249
 250   memset (&ev, 0x44, sizeof (ev));
 251   ev.sigev_notify = SIGEV_THREAD;
 252   ev.sigev_notify_function = thr1;
 253   ev.sigev_notify_attributes = NULL;
 254   ev.sigev_value.sival_ptr = &ev;
 255   if (timer_create (TEST_CLOCK, &ev, &timer_thr1) != 0)
 256     {
 257       printf ("*** timer_create for timer_thr1 failed: %m\n");
 258       return 1;
 259     }
 260
 261   pthread_attr_t nattr;
 262   if (pthread_attr_init (&nattr)
 263       || pthread_attr_setguardsize (&nattr, 0))
 264     {
 265       puts ("*** pthread_attr_t setup failed");
 266       result = 1;
 267     }
 268
 269   memset (&ev, 0x55, sizeof (ev));
 270   ev.sigev_notify = SIGEV_THREAD;
 271   ev.sigev_notify_function = thr2;
 272   ev.sigev_notify_attributes = &nattr;
 273   ev.sigev_value.sival_int = 111;
 274   if (timer_create (TEST_CLOCK, &ev, &timer_thr2) != 0)
 275     {
 276       printf ("*** timer_create for timer_thr2 failed: %m\n");
 277       return 1;
 278     }
 279
 280   int ret = timer_getoverrun (timer_thr1);
 281   if (ret != 0)
 282     {
 283       if (ret == -1)
 284         printf ("*** timer_getoverrun failed: %m\n");
 285       else
 286         printf ("*** timer_getoverrun returned %d != 0\n", ret);
 287       result = 1;
 288     }
 289
 290   struct itimerspec it;
 291   it.it_value.tv_sec = 0;
 292   it.it_value.tv_nsec = -26;
 293   it.it_interval.tv_sec = 0;
 294   it.it_interval.tv_nsec = 0;
 295   if (timer_settime (timer_sig1, 0, &it, NULL) == 0)
 296     {
 297       puts ("*** timer_settime with negative tv_nsec unexpectedly succeeded");
 298       result = 1;
 299     }
 300   else if (errno != EINVAL)
 301     {
 302       printf ("*** timer_settime with negative tv_nsec did not fail with "
 303               "EINVAL: %m\n");
 304       result = 1;
 305     }
 306
 307   it.it_value.tv_nsec = 100000;
 308   it.it_interval.tv_nsec = 1000000000;
 309   if (timer_settime (timer_sig2, 0, &it, NULL) == 0)
 310     {
 311       puts ("\
 312 *** timer_settime with tv_nsec 1000000000 unexpectedly succeeded");
 313       result = 1;
 314     }
 315   else if (errno != EINVAL)
 316     {
 317       printf ("*** timer_settime with tv_nsec 1000000000 did not fail with "
 318               "EINVAL: %m\n");
 319       result = 1;
 320     }
 321
 322 #if 0
 323   it.it_value.tv_nsec = 0;
 324   it.it_interval.tv_nsec = -26;
 325   if (timer_settime (timer_thr1, 0, &it, NULL) != 0)
 326     {
 327       printf ("\
 328 !!! timer_settime with it_value 0 it_interval invalid failed: %m\n");
 329       /* FIXME: is this mandated by POSIX?
 330       result = 1; */
 331     }
 332
 333   it.it_interval.tv_nsec = 3000000000;
 334   if (timer_settime (timer_thr2, 0, &it, NULL) != 0)
 335     {
 336       printf ("\
 337 !!! timer_settime with it_value 0 it_interval invalid failed: %m\n");
 338       /* FIXME: is this mandated by POSIX?
 339       result = 1; */
 340     }
 341 #endif
 342
 343   struct timespec startts;
 344   if (clock_gettime (TEST_CLOCK, &startts) != 0)
 345     {
 346       printf ("*** clock_gettime failed: %m\n");
 347       result = 1;
 348     }
 349
 350   it.it_value.tv_nsec = 100000000;
 351   it.it_interval.tv_nsec = 0;
 352   if (timer_settime (timer_none, 0, &it, NULL) != 0)
 353     {
 354       printf ("*** timer_settime timer_none failed: %m\n");
 355       result = 1;
 356     }
 357
 358   it.it_value.tv_nsec = 200000000;
 359   if (timer_settime (timer_thr1, 0, &it, NULL) != 0)
 360     {
 361       printf ("*** timer_settime timer_thr1 failed: %m\n");
 362       result = 1;
 363     }
 364
 365   it.it_value.tv_nsec = 300000000;
 366   if (timer_settime (timer_thr2, 0, &it, NULL) != 0)
 367     {
 368       printf ("*** timer_settime timer_thr2 failed: %m\n");
 369       result = 1;
 370     }
 371
 372   it.it_value.tv_nsec = 400000000;
 373   if (timer_settime (timer_sig1, 0, &it, NULL) != 0)
 374     {
 375       printf ("*** timer_settime timer_sig1 failed: %m\n");
 376       result = 1;
 377     }
 378
 379   it.it_value.tv_nsec = 500000000;
 380   if (TEMP_FAILURE_RETRY (timer_settime (timer_sig2, 0, &it, NULL)) != 0)
 381     {
 382       printf ("*** timer_settime timer_sig2 failed: %m\n");
 383       result = 1;
 384     }
 385
 386   pthread_mutex_lock (&lock);
 387   while (thr1_cnt == 0 || thr2_cnt == 0)
 388     pthread_cond_wait (&cond, &lock);
 389   pthread_mutex_unlock (&lock);
 390
 391   while (sig1_cnt == 0 || sig2_cnt == 0)
 392     {
 393       ts.tv_sec = 0;
 394       ts.tv_nsec = 100000000;
 395       nanosleep (&ts, NULL);
 396     }
 397
 398   pthread_mutex_lock (&lock);
 399
 400   if (thr1_cnt != 1)
 401     {
 402       printf ("*** thr1 not called exactly once, but %d times\n", thr1_cnt);
 403       result = 1;
 404     }
 405   else if (thr1_err)
 406     {
 407       puts ("*** an error occurred in thr1");
 408       result = 1;
 409     }
 410   else if (thr1_sigval.sival_ptr != &ev)
 411     {
 412       printf ("*** thr1_sigval.sival_ptr %p != %p\n",
 413               thr1_sigval.sival_ptr, &ev);
 414       result = 1;
 415     }
 416   else if (check_ts ("thr1", &startts, &thr1_ts, 200000))
 417     result = 1;
 418
 419   if (thr2_cnt != 1)
 420     {
 421       printf ("*** thr2 not called exactly once, but %d times\n", thr2_cnt);
 422       result = 1;
 423     }
 424   else if (thr2_err)
 425     {
 426       puts ("*** an error occurred in thr2");
 427       result = 1;
 428     }
 429   else if (thr2_sigval.sival_int != 111)
 430     {
 431       printf ("*** thr2_sigval.sival_ptr %d != 111\n", thr2_sigval.sival_int);
 432       result = 1;
 433     }
 434   else if (check_ts ("thr2", &startts, &thr2_ts, 300000))
 435     result = 1;
 436   else if (thr2_guardsize != 0)
 437     {
 438       printf ("*** thr2 guardsize %zd != 0\n", thr2_guardsize);
 439       result = 1;
 440     }
 441
 442   pthread_mutex_unlock (&lock);
 443
 444   if (sig1_cnt != 1)
 445     {
 446       printf ("*** sig1 not called exactly once, but %d times\n", sig1_cnt);
 447       result = 1;
 448     }
 449   else if (sig1_err)
 450     {
 451       printf ("*** errors occurred in sig1 handler %x\n", sig1_err);
 452       result = 1;
 453     }
 454   else if (sig1_sigval.sival_ptr != &ev)
 455     {
 456       printf ("*** sig1_sigval.sival_ptr %p != %p\n",
 457               sig1_sigval.sival_ptr, &ev);
 458       result = 1;
 459     }
 460   else if (check_ts ("sig1", &startts, &sig1_ts, 400000))
 461     result = 1;
 462
 463   if (sig2_cnt != 1)
 464     {
 465       printf ("*** sig2 not called exactly once, but %d times\n", sig2_cnt);
 466       result = 1;
 467     }
 468   else if (sig2_err)
 469     {
 470       printf ("*** errors occurred in sig2 handler %x\n", sig2_err);
 471       result = 1;
 472     }
 473   else if (sig2_sigval.sival_int != 163)
 474     {
 475       printf ("*** sig2_sigval.sival_ptr %d != 163\n", sig2_sigval.sival_int);
 476       result = 1;
 477     }
 478   else if (check_ts ("sig2", &startts, &sig2_ts, 500000))
 479     result = 1;
 480
 481   if (timer_gettime (timer_none, &it) != 0)
 482     {
 483       printf ("*** timer_gettime timer_none failed: %m\n");
 484       result = 1;
 485     }
 486   else if (it.it_value.tv_sec || it.it_value.tv_nsec
 487            || it.it_interval.tv_sec || it.it_interval.tv_nsec)
 488     {
 489       printf ("\
 490 *** timer_gettime timer_none returned { %ld.%09jd, %ld.%09jd }\n",
 491               (long) it.it_value.tv_sec, (intmax_t) it.it_value.tv_nsec,
 492               (long) it.it_interval.tv_sec, (intmax_t) it.it_interval.tv_nsec);
 493       result = 1;
 494     }
 495
 496   if (clock_gettime (TEST_CLOCK, &startts) != 0)
 497     {
 498       printf ("*** clock_gettime failed: %m\n");
 499       result = 1;
 500     }
 501
 502   it.it_value.tv_sec = 1;
 503   it.it_value.tv_nsec = 0;
 504   it.it_interval.tv_sec = 0;
 505   it.it_interval.tv_nsec = 100000000;
 506   if (timer_settime (timer_none, 0, &it, NULL) != 0)
 507     {
 508       printf ("*** timer_settime timer_none failed: %m\n");
 509       result = 1;
 510     }
 511
 512   it.it_value.tv_nsec = 100000000;
 513   it.it_interval.tv_nsec = 200000000;
 514   if (timer_settime (timer_thr1, 0, &it, NULL) != 0)
 515     {
 516       printf ("*** timer_settime timer_thr1 failed: %m\n");
 517       result = 1;
 518     }
 519
 520   it.it_value.tv_nsec = 200000000;
 521   it.it_interval.tv_nsec = 300000000;
 522   if (timer_settime (timer_thr2, 0, &it, NULL) != 0)
 523     {
 524       printf ("*** timer_settime timer_thr2 failed: %m\n");
 525       result = 1;
 526     }
 527
 528   it.it_value.tv_nsec = 300000000;
 529   it.it_interval.tv_nsec = 400000000;
 530   if (timer_settime (timer_sig1, 0, &it, NULL) != 0)
 531     {
 532       printf ("*** timer_settime timer_sig1 failed: %m\n");
 533       result = 1;
 534     }
 535
 536   it.it_value.tv_nsec = 400000000;
 537   it.it_interval.tv_nsec = 500000000;
 538   if (TEMP_FAILURE_RETRY (timer_settime (timer_sig2, 0, &it, NULL)) != 0)
 539     {
 540       printf ("*** timer_settime timer_sig2 failed: %m\n");
 541       result = 1;
 542     }
 543
 544   pthread_mutex_lock (&lock);
 545   while (thr1_cnt < 6 || thr2_cnt < 6)
 546     pthread_cond_wait (&cond, &lock);
 547   pthread_mutex_unlock (&lock);
 548
 549   while (sig1_cnt < 6 || sig2_cnt < 6)
 550     {
 551       ts.tv_sec = 0;
 552       ts.tv_nsec = 100000000;
 553       nanosleep (&ts, NULL);
 554     }
 555
 556   pthread_mutex_lock (&lock);
 557
 558   if (thr1_err)
 559     {
 560       puts ("*** an error occurred in thr1");
 561       result = 1;
 562     }
 563   else if (check_ts ("thr1", &startts, &thr1_ts, 1100000 + 4 * 200000))
 564     result = 1;
 565
 566   if (thr2_err)
 567     {
 568       puts ("*** an error occurred in thr2");
 569       result = 1;
 570     }
 571   else if (check_ts ("thr2", &startts, &thr2_ts, 1200000 + 4 * 300000))
 572     result = 1;
 573   else if (thr2_guardsize != 0)
 574     {
 575       printf ("*** thr2 guardsize %zd != 0\n", thr2_guardsize);
 576       result = 1;
 577     }
 578
 579   pthread_mutex_unlock (&lock);
 580
 581   if (sig1_err)
 582     {
 583       printf ("*** errors occurred in sig1 handler %x\n", sig1_err);
 584       result = 1;
 585     }
 586   else if (check_ts ("sig1", &startts, &sig1_ts, 1300000 + 4 * 400000))
 587     result = 1;
 588
 589   if (sig2_err)
 590     {
 591       printf ("*** errors occurred in sig2 handler %x\n", sig2_err);
 592       result = 1;
 593     }
 594   else if (check_ts ("sig2", &startts, &sig2_ts, 1400000 + 4 * 500000))
 595     result = 1;
 596
 597   if (timer_gettime (timer_none, &it) != 0)
 598     {
 599       printf ("*** timer_gettime timer_none failed: %m\n");
 600       result = 1;
 601     }
 602   else if (it.it_interval.tv_sec || it.it_interval.tv_nsec != 100000000)
 603     {
 604       printf ("\
 605 !!! second timer_gettime timer_none returned it_interval %ld.%09jd\n",
 606               (long) it.it_interval.tv_sec, (intmax_t) it.it_interval.tv_nsec);
 607       /* FIXME: For now disabled.
 608       result = 1; */
 609     }
 610
 611   if (timer_delete (timer_none) != 0)
 612     {
 613       printf ("*** timer_delete for timer_none failed: %m\n");
 614       result = 1;
 615     }
 616
 617   if (timer_delete (timer_sig1) != 0)
 618     {
 619       printf ("*** timer_delete for timer_sig1 failed: %m\n");
 620       result = 1;
 621     }
 622
 623   if (timer_delete (timer_sig2) != 0)
 624     {
 625       printf ("*** timer_delete for timer_sig2 failed: %m\n");
 626       result = 1;
 627     }
 628
 629   if (timer_delete (timer_thr1) != 0)
 630     {
 631       printf ("*** timer_delete for timer_thr1 failed: %m\n");
 632       result = 1;
 633     }
 634
 635   if (timer_delete (timer_thr2) != 0)
 636     {
 637       printf ("*** timer_delete for timer_thr2 failed: %m\n");
 638       result = 1;
 639     }
 640   return result;
 641 }
 642
 643 #elif defined TEST_CLOCK_MISSING
 644 /* This just ensures that any functions called in TEST_CLOCK_MISSING
 645    are not diagnosed as unused.  */
 646 # define TEST_FUNCTION (TEST_CLOCK_MISSING (TEST_CLOCK), 0)
 647 #else
 648 # define TEST_FUNCTION 0
 649 #endif
 650
 651 #include "../test-skeleton.c"