time/tst-itimer.c

   1 /* Basic tests for getitimer and setitimer.
   2    Copyright (C) 2021-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
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the 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; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <array_length.h>
  20 #include <errno.h>
  21 #include <stdlib.h>
  22 #include <sys/time.h>
  23 #include <support/check.h>
  24 #include <support/support.h>
  25 #include <support/xsignal.h>
  26 #include <unistd.h>
  27 #include <time.h>
  28
  29 static sig_atomic_t cnt;
  30
  31 static void
  32 alrm_handler (int sig)
  33 {
  34   if (++cnt > 3)
  35     cnt = 3;
  36 }
  37
  38 static void
  39 intr_sleep (int sec)
  40 {
  41   struct timespec ts = { .tv_sec = sec, .tv_nsec = 0 };
  42   while (nanosleep (&ts, &ts) == -1 && errno == EINTR)
  43     ;
  44 }
  45
  46 static int
  47 do_test (void)
  48 {
  49   struct itimerval it, it_old;
  50   const int timers[] = { ITIMER_REAL, ITIMER_VIRTUAL, ITIMER_PROF };
  51   for (int i = 0; i < array_length (timers); i++)
  52     {
  53       TEST_COMPARE (getitimer (timers[i], &it), 0);
  54
  55       /* No timer set, all value should be 0.  */
  56       TEST_COMPARE (it.it_interval.tv_sec, 0);
  57       TEST_COMPARE (it.it_interval.tv_usec, 0);
  58       TEST_COMPARE (it.it_value.tv_sec, 0);
  59       TEST_COMPARE (it.it_value.tv_usec, 0);
  60
  61       it.it_interval.tv_sec = 10;
  62       it.it_interval.tv_usec = 20;
  63       TEST_COMPARE (setitimer (timers[i], &it, NULL), 0);
  64
  65       TEST_COMPARE (setitimer (timers[i], &(struct itimerval) { 0 }, &it_old),
  66                     0);
  67       /* ITIMER_REAL returns { 0, 0 } for single-shot timers, while
  68          other timers returns setitimer value.  */
  69       if (timers[i] == ITIMER_REAL)
  70         {
  71           TEST_COMPARE (it_old.it_interval.tv_sec, 0);
  72           TEST_COMPARE (it_old.it_interval.tv_usec, 0);
  73         }
  74       else
  75         {
  76           TEST_COMPARE (it_old.it_interval.tv_sec, 10);
  77           /* Some systems might use a different precision for ITIMER_VIRTUAL
  78              and ITIMER_IPROF and thus the value might be adjusted.  To avoid
  79              trying to guess the resolution, we do not check it.  */
  80         }
  81
  82       /* Create a periodic timer and check if the return value is the one
  83          previously set.  */
  84       it.it_interval.tv_sec = 10;
  85       it.it_interval.tv_usec = 20;
  86       it.it_value.tv_sec = 30;
  87       it.it_value.tv_usec = 40;
  88       TEST_COMPARE (setitimer (timers[i], &it, NULL), 0);
  89
  90       TEST_COMPARE (setitimer (timers[i], &(struct itimerval) { 0 }, &it_old),
  91                     0);
  92       TEST_COMPARE (it.it_interval.tv_sec, it_old.it_interval.tv_sec);
  93       if (timers[i] == ITIMER_REAL)
  94         TEST_COMPARE (it.it_interval.tv_usec, it_old.it_interval.tv_usec);
  95
  96       if (sizeof (time_t) == 4)
  97         continue;
  98
  99       /* Same as before, but with a 64 bit time_t value.  */
 100       it.it_interval.tv_sec = (time_t) 0x1ffffffffull;
 101       it.it_interval.tv_usec = 20;
 102       it.it_value.tv_sec = 0;
 103       it.it_value.tv_usec = 0;
 104
 105       /* Linux does not provide 64 bit time_t support for getitimer and
 106          setitimer on architectures with 32 bit time_t support.  */
 107       if (support_itimer_support_time64())
 108         {
 109           TEST_COMPARE (setitimer (timers[i], &it, NULL), 0);
 110           TEST_COMPARE (setitimer (timers[i], &(struct itimerval) { 0 },
 111                                    &it_old),
 112                         0);
 113           /* ITIMER_REAL returns { 0, 0 } for single-sort timers, while other
 114              timers returns setitimer value.  */
 115           if (timers[i] == ITIMER_REAL)
 116             {
 117               TEST_COMPARE (it_old.it_interval.tv_sec, 0ull);
 118               TEST_COMPARE (it_old.it_interval.tv_usec, 0);
 119             }
 120         }
 121       else
 122         {
 123           TEST_COMPARE (setitimer (timers[i], &it, NULL), -1);
 124           TEST_COMPARE (errno, EOVERFLOW);
 125         }
 126
 127       /* Create a periodic timer and check if the return value is the one
 128          previously set.  */
 129       it.it_interval.tv_sec = (time_t) 0x1ffffffffull;
 130       it.it_interval.tv_usec = 20;
 131       it.it_value.tv_sec = 30;
 132       it.it_value.tv_usec = 40;
 133       if (support_itimer_support_time64())
 134         {
 135           TEST_COMPARE (setitimer (timers[i], &it, NULL), 0);
 136
 137           TEST_COMPARE (setitimer (timers[i], &(struct itimerval) { 0 },
 138                                    &it_old),
 139                         0);
 140           if (timers[i] == ITIMER_REAL)
 141             {
 142               TEST_COMPARE (it.it_interval.tv_sec, it_old.it_interval.tv_sec);
 143               TEST_COMPARE (it.it_interval.tv_usec, it_old.it_interval.tv_usec);
 144             }
 145         }
 146       else
 147         {
 148           TEST_COMPARE (setitimer (timers[i], &it, NULL), -1);
 149           TEST_COMPARE (errno, EOVERFLOW);
 150         }
 151   }
 152
 153   {
 154     struct sigaction sa = { .sa_handler = alrm_handler, .sa_flags = 0 };
 155     sigemptyset (&sa.sa_mask);
 156     xsigaction (SIGALRM, &sa, NULL);
 157   }
 158
 159   /* Setup a timer to 0.1s and sleep for 1s and check to 3 signal handler
 160      execution.  */
 161   it.it_interval.tv_sec = 0;
 162   it.it_interval.tv_usec = 100000;
 163   it.it_value.tv_sec = 0;
 164   it.it_value.tv_usec = 100000;
 165
 166   /* Check ITIMER_VIRTUAL and ITIMER_PROF would require to generate load
 167      and be subject to system load.  */
 168   cnt = 0;
 169   TEST_COMPARE (setitimer (ITIMER_REAL, &it, NULL), 0);
 170   intr_sleep (1);
 171   TEST_COMPARE (cnt, 3);
 172   TEST_COMPARE (setitimer (ITIMER_REAL, &(struct itimerval) { 0 }, NULL), 0);
 173
 174   return 0;
 175 }
 176
 177 #include <support/test-driver.c>