rt/tst-timer4.c

   1 /* Tests for POSIX timer implementation.
   2    Copyright (C) 2004-2014 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Jakub Jelinek <jakub@redhat.com>, 2004
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public License as
   8    published by the Free Software Foundation; either version 2.1 of the
   9    License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; see the file COPYING.LIB.  If
  18    not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include <errno.h>
  21 #include <signal.h>
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <time.h>
  25 #include <unistd.h>
  26 #if _POSIX_THREADS
  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.%09ld instead of expected %ld.%09ld\n",
 172               name, (long) end->tv_sec, end->tv_nsec,
 173               (long) ts.tv_sec, ts.tv_nsec);
 174       return 1;
 175     }
 176   else
 177     return 0;
 178 }
 179
 180 #define TIMEOUT 15
 181 #define TEST_FUNCTION do_test ()
 182 static int
 183 do_test (void)
 184 {
 185   int result = 0;
 186
 187 #ifdef TEST_CLOCK_MISSING
 188   const char *missing = TEST_CLOCK_MISSING (TEST_CLOCK);
 189   if (missing != NULL)
 190     {
 191       printf ("%s missing, skipping test\n", missing);
 192       return 0;
 193     }
 194 #endif
 195
 196   struct timespec ts;
 197   if (clock_gettime (TEST_CLOCK, &ts) != 0)
 198     {
 199       printf ("*** clock_gettime failed: %m\n");
 200       result = 1;
 201     }
 202   else
 203     printf ("clock_gettime returned timespec = { %ld, %ld }\n",
 204             (long) ts.tv_sec, ts.tv_nsec);
 205
 206   if (clock_getres (TEST_CLOCK, &ts) != 0)
 207     {
 208       printf ("*** clock_getres failed: %m\n");
 209       result = 1;
 210     }
 211   else
 212     printf ("clock_getres returned timespec = { %ld, %ld }\n",
 213             (long) ts.tv_sec, ts.tv_nsec);
 214
 215   struct sigevent ev;
 216   memset (&ev, 0x11, sizeof (ev));
 217   ev.sigev_notify = SIGEV_NONE;
 218   if (timer_create (TEST_CLOCK, &ev, &timer_none) != 0)
 219     {
 220       printf ("*** timer_create for timer_none failed: %m\n");
 221       return 1;
 222     }
 223
 224   struct sigaction sa = { .sa_sigaction = sig1_handler,
 225                           .sa_flags = SA_SIGINFO };
 226   sigemptyset (&sa.sa_mask);
 227   sigaction (SIGRTMIN, &sa, NULL);
 228   sa.sa_sigaction = sig2_handler;
 229   sigaction (SIGRTMIN + 1, &sa, NULL);
 230
 231   memset (&ev, 0x22, sizeof (ev));
 232   ev.sigev_notify = SIGEV_SIGNAL;
 233   ev.sigev_signo = SIGRTMIN;
 234   ev.sigev_value.sival_ptr = &ev;
 235   if (timer_create (TEST_CLOCK, &ev, &timer_sig1) != 0)
 236     {
 237       printf ("*** timer_create for timer_sig1 failed: %m\n");
 238       return 1;
 239     }
 240
 241   memset (&ev, 0x33, sizeof (ev));
 242   ev.sigev_notify = SIGEV_SIGNAL;
 243   ev.sigev_signo = SIGRTMIN + 1;
 244   ev.sigev_value.sival_int = 163;
 245   if (timer_create (TEST_CLOCK, &ev, &timer_sig2) != 0)
 246     {
 247       printf ("*** timer_create for timer_sig2 failed: %m\n");
 248       return 1;
 249     }
 250
 251   memset (&ev, 0x44, sizeof (ev));
 252   ev.sigev_notify = SIGEV_THREAD;
 253   ev.sigev_notify_function = thr1;
 254   ev.sigev_notify_attributes = NULL;
 255   ev.sigev_value.sival_ptr = &ev;
 256   if (timer_create (TEST_CLOCK, &ev, &timer_thr1) != 0)
 257     {
 258       printf ("*** timer_create for timer_thr1 failed: %m\n");
 259       return 1;
 260     }
 261
 262   pthread_attr_t nattr;
 263   if (pthread_attr_init (&nattr)
 264       || pthread_attr_setguardsize (&nattr, 0))
 265     {
 266       puts ("*** pthread_attr_t setup failed");
 267       result = 1;
 268     }
 269
 270   memset (&ev, 0x55, sizeof (ev));
 271   ev.sigev_notify = SIGEV_THREAD;
 272   ev.sigev_notify_function = thr2;
 273   ev.sigev_notify_attributes = &nattr;
 274   ev.sigev_value.sival_int = 111;
 275   if (timer_create (TEST_CLOCK, &ev, &timer_thr2) != 0)
 276     {
 277       printf ("*** timer_create for timer_thr2 failed: %m\n");
 278       return 1;
 279     }
 280
 281   int ret = timer_getoverrun (timer_thr1);
 282   if (ret != 0)
 283     {
 284       if (ret == -1)
 285         printf ("*** timer_getoverrun failed: %m\n");
 286       else
 287         printf ("*** timer_getoverrun returned %d != 0\n", ret);
 288       result = 1;
 289     }
 290
 291   struct itimerspec it;
 292   it.it_value.tv_sec = 0;
 293   it.it_value.tv_nsec = -26;
 294   it.it_interval.tv_sec = 0;
 295   it.it_interval.tv_nsec = 0;
 296   if (timer_settime (timer_sig1, 0, &it, NULL) == 0)
 297     {
 298       puts ("*** timer_settime with negative tv_nsec unexpectedly succeeded");
 299       result = 1;
 300     }
 301   else if (errno != EINVAL)
 302     {
 303       printf ("*** timer_settime with negative tv_nsec did not fail with "
 304               "EINVAL: %m\n");
 305       result = 1;
 306     }
 307
 308   it.it_value.tv_nsec = 100000;
 309   it.it_interval.tv_nsec = 1000000000;
 310   if (timer_settime (timer_sig2, 0, &it, NULL) == 0)
 311     {
 312       puts ("\
 313 *** timer_settime with tv_nsec 1000000000 unexpectedly succeeded");
 314       result = 1;
 315     }
 316   else if (errno != EINVAL)
 317     {
 318       printf ("*** timer_settime with tv_nsec 1000000000 did not fail with "
 319               "EINVAL: %m\n");
 320       result = 1;
 321     }
 322
 323 #if 0
 324   it.it_value.tv_nsec = 0;
 325   it.it_interval.tv_nsec = -26;
 326   if (timer_settime (timer_thr1, 0, &it, NULL) != 0)
 327     {
 328       printf ("\
 329 !!! timer_settime with it_value 0 it_interval invalid failed: %m\n");
 330       /* FIXME: is this mandated by POSIX?
 331       result = 1; */
 332     }
 333
 334   it.it_interval.tv_nsec = 3000000000;
 335   if (timer_settime (timer_thr2, 0, &it, NULL) != 0)
 336     {
 337       printf ("\
 338 !!! timer_settime with it_value 0 it_interval invalid failed: %m\n");
 339       /* FIXME: is this mandated by POSIX?
 340       result = 1; */
 341     }
 342 #endif
 343
 344   struct timespec startts;
 345   if (clock_gettime (TEST_CLOCK, &startts) != 0)
 346     {
 347       printf ("*** clock_gettime failed: %m\n");
 348       result = 1;
 349     }
 350
 351   it.it_value.tv_nsec = 100000000;
 352   it.it_interval.tv_nsec = 0;
 353   if (timer_settime (timer_none, 0, &it, NULL) != 0)
 354     {
 355       printf ("*** timer_settime timer_none failed: %m\n");
 356       result = 1;
 357     }
 358
 359   it.it_value.tv_nsec = 200000000;
 360   if (timer_settime (timer_thr1, 0, &it, NULL) != 0)
 361     {
 362       printf ("*** timer_settime timer_thr1 failed: %m\n");
 363       result = 1;
 364     }
 365
 366   it.it_value.tv_nsec = 300000000;
 367   if (timer_settime (timer_thr2, 0, &it, NULL) != 0)
 368     {
 369       printf ("*** timer_settime timer_thr2 failed: %m\n");
 370       result = 1;
 371     }
 372
 373   it.it_value.tv_nsec = 400000000;
 374   if (timer_settime (timer_sig1, 0, &it, NULL) != 0)
 375     {
 376       printf ("*** timer_settime timer_sig1 failed: %m\n");
 377       result = 1;
 378     }
 379
 380   it.it_value.tv_nsec = 500000000;
 381   if (TEMP_FAILURE_RETRY (timer_settime (timer_sig2, 0, &it, NULL)) != 0)
 382     {
 383       printf ("*** timer_settime timer_sig2 failed: %m\n");
 384       result = 1;
 385     }
 386
 387   pthread_mutex_lock (&lock);
 388   while (thr1_cnt == 0 || thr2_cnt == 0)
 389     pthread_cond_wait (&cond, &lock);
 390   pthread_mutex_unlock (&lock);
 391
 392   while (sig1_cnt == 0 || sig2_cnt == 0)
 393     {
 394       ts.tv_sec = 0;
 395       ts.tv_nsec = 100000000;
 396       nanosleep (&ts, NULL);
 397     }
 398
 399   pthread_mutex_lock (&lock);
 400
 401   if (thr1_cnt != 1)
 402     {
 403       printf ("*** thr1 not called exactly once, but %d times\n", thr1_cnt);
 404       result = 1;
 405     }
 406   else if (thr1_err)
 407     {
 408       puts ("*** an error occurred in thr1");
 409       result = 1;
 410     }
 411   else if (thr1_sigval.sival_ptr != &ev)
 412     {
 413       printf ("*** thr1_sigval.sival_ptr %p != %p\n",
 414               thr1_sigval.sival_ptr, &ev);
 415       result = 1;
 416     }
 417   else if (check_ts ("thr1", &startts, &thr1_ts, 200000))
 418     result = 1;
 419
 420   if (thr2_cnt != 1)
 421     {
 422       printf ("*** thr2 not called exactly once, but %d times\n", thr2_cnt);
 423       result = 1;
 424     }
 425   else if (thr2_err)
 426     {
 427       puts ("*** an error occurred in thr2");
 428       result = 1;
 429     }
 430   else if (thr2_sigval.sival_int != 111)
 431     {
 432       printf ("*** thr2_sigval.sival_ptr %d != 111\n", thr2_sigval.sival_int);
 433       result = 1;
 434     }
 435   else if (check_ts ("thr2", &startts, &thr2_ts, 300000))
 436     result = 1;
 437   else if (thr2_guardsize != 0)
 438     {
 439       printf ("*** thr2 guardsize %zd != 0\n", thr2_guardsize);
 440       result = 1;
 441     }
 442
 443   pthread_mutex_unlock (&lock);
 444
 445   if (sig1_cnt != 1)
 446     {
 447       printf ("*** sig1 not called exactly once, but %d times\n", sig1_cnt);
 448       result = 1;
 449     }
 450   else if (sig1_err)
 451     {
 452       printf ("*** errors occurred in sig1 handler %x\n", sig1_err);
 453       result = 1;
 454     }
 455   else if (sig1_sigval.sival_ptr != &ev)
 456     {
 457       printf ("*** sig1_sigval.sival_ptr %p != %p\n",
 458               sig1_sigval.sival_ptr, &ev);
 459       result = 1;
 460     }
 461   else if (check_ts ("sig1", &startts, &sig1_ts, 400000))
 462     result = 1;
 463
 464   if (sig2_cnt != 1)
 465     {
 466       printf ("*** sig2 not called exactly once, but %d times\n", sig2_cnt);
 467       result = 1;
 468     }
 469   else if (sig2_err)
 470     {
 471       printf ("*** errors occurred in sig2 handler %x\n", sig2_err);
 472       result = 1;
 473     }
 474   else if (sig2_sigval.sival_int != 163)
 475     {
 476       printf ("*** sig2_sigval.sival_ptr %d != 163\n", sig2_sigval.sival_int);
 477       result = 1;
 478     }
 479   else if (check_ts ("sig2", &startts, &sig2_ts, 500000))
 480     result = 1;
 481
 482   if (timer_gettime (timer_none, &it) != 0)
 483     {
 484       printf ("*** timer_gettime timer_none failed: %m\n");
 485       result = 1;
 486     }
 487   else if (it.it_value.tv_sec || it.it_value.tv_nsec
 488            || it.it_interval.tv_sec || it.it_interval.tv_nsec)
 489     {
 490       printf ("\
 491 *** timer_gettime timer_none returned { %ld.%09ld, %ld.%09ld }\n",
 492               (long) it.it_value.tv_sec, it.it_value.tv_nsec,
 493               (long) it.it_interval.tv_sec, it.it_interval.tv_nsec);
 494       result = 1;
 495     }
 496
 497   if (clock_gettime (TEST_CLOCK, &startts) != 0)
 498     {
 499       printf ("*** clock_gettime failed: %m\n");
 500       result = 1;
 501     }
 502
 503   it.it_value.tv_sec = 1;
 504   it.it_value.tv_nsec = 0;
 505   it.it_interval.tv_sec = 0;
 506   it.it_interval.tv_nsec = 100000000;
 507   if (timer_settime (timer_none, 0, &it, NULL) != 0)
 508     {
 509       printf ("*** timer_settime timer_none failed: %m\n");
 510       result = 1;
 511     }
 512
 513   it.it_value.tv_nsec = 100000000;
 514   it.it_interval.tv_nsec = 200000000;
 515   if (timer_settime (timer_thr1, 0, &it, NULL) != 0)
 516     {
 517       printf ("*** timer_settime timer_thr1 failed: %m\n");
 518       result = 1;
 519     }
 520
 521   it.it_value.tv_nsec = 200000000;
 522   it.it_interval.tv_nsec = 300000000;
 523   if (timer_settime (timer_thr2, 0, &it, NULL) != 0)
 524     {
 525       printf ("*** timer_settime timer_thr2 failed: %m\n");
 526       result = 1;
 527     }
 528
 529   it.it_value.tv_nsec = 300000000;
 530   it.it_interval.tv_nsec = 400000000;
 531   if (timer_settime (timer_sig1, 0, &it, NULL) != 0)
 532     {
 533       printf ("*** timer_settime timer_sig1 failed: %m\n");
 534       result = 1;
 535     }
 536
 537   it.it_value.tv_nsec = 400000000;
 538   it.it_interval.tv_nsec = 500000000;
 539   if (TEMP_FAILURE_RETRY (timer_settime (timer_sig2, 0, &it, NULL)) != 0)
 540     {
 541       printf ("*** timer_settime timer_sig2 failed: %m\n");
 542       result = 1;
 543     }
 544
 545   pthread_mutex_lock (&lock);
 546   while (thr1_cnt < 6 || thr2_cnt < 6)
 547     pthread_cond_wait (&cond, &lock);
 548   pthread_mutex_unlock (&lock);
 549
 550   while (sig1_cnt < 6 || sig2_cnt < 6)
 551     {
 552       ts.tv_sec = 0;
 553       ts.tv_nsec = 100000000;
 554       nanosleep (&ts, NULL);
 555     }
 556
 557   pthread_mutex_lock (&lock);
 558
 559   if (thr1_err)
 560     {
 561       puts ("*** an error occurred in thr1");
 562       result = 1;
 563     }
 564   else if (check_ts ("thr1", &startts, &thr1_ts, 1100000 + 4 * 200000))
 565     result = 1;
 566
 567   if (thr2_err)
 568     {
 569       puts ("*** an error occurred in thr2");
 570       result = 1;
 571     }
 572   else if (check_ts ("thr2", &startts, &thr2_ts, 1200000 + 4 * 300000))
 573     result = 1;
 574   else if (thr2_guardsize != 0)
 575     {
 576       printf ("*** thr2 guardsize %zd != 0\n", thr2_guardsize);
 577       result = 1;
 578     }
 579
 580   pthread_mutex_unlock (&lock);
 581
 582   if (sig1_err)
 583     {
 584       printf ("*** errors occurred in sig1 handler %x\n", sig1_err);
 585       result = 1;
 586     }
 587   else if (check_ts ("sig1", &startts, &sig1_ts, 1300000 + 4 * 400000))
 588     result = 1;
 589
 590   if (sig2_err)
 591     {
 592       printf ("*** errors occurred in sig2 handler %x\n", sig2_err);
 593       result = 1;
 594     }
 595   else if (check_ts ("sig2", &startts, &sig2_ts, 1400000 + 4 * 500000))
 596     result = 1;
 597
 598   if (timer_gettime (timer_none, &it) != 0)
 599     {
 600       printf ("*** timer_gettime timer_none failed: %m\n");
 601       result = 1;
 602     }
 603   else if (it.it_interval.tv_sec || it.it_interval.tv_nsec != 100000000)
 604     {
 605       printf ("\
 606 !!! second timer_gettime timer_none returned it_interval %ld.%09ld\n",
 607               (long) it.it_interval.tv_sec, it.it_interval.tv_nsec);
 608       /* FIXME: For now disabled.
 609       result = 1; */
 610     }
 611
 612   if (timer_delete (timer_none) != 0)
 613     {
 614       printf ("*** timer_delete for timer_none failed: %m\n");
 615       result = 1;
 616     }
 617
 618   if (timer_delete (timer_sig1) != 0)
 619     {
 620       printf ("*** timer_delete for timer_sig1 failed: %m\n");
 621       result = 1;
 622     }
 623
 624   if (timer_delete (timer_sig2) != 0)
 625     {
 626       printf ("*** timer_delete for timer_sig2 failed: %m\n");
 627       result = 1;
 628     }
 629
 630   if (timer_delete (timer_thr1) != 0)
 631     {
 632       printf ("*** timer_delete for timer_thr1 failed: %m\n");
 633       result = 1;
 634     }
 635
 636   if (timer_delete (timer_thr2) != 0)
 637     {
 638       printf ("*** timer_delete for timer_thr2 failed: %m\n");
 639       result = 1;
 640     }
 641   return result;
 642 }
 643 #else
 644 # define TEST_FUNCTION 0
 645 #endif
 646
 647 #include "../test-skeleton.c"