time/tst-cpuclock1.c

   1 /* Test program for process CPU clocks.
   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
   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 <stdio.h>
  20 #include <stdlib.h>
  21 #include <time.h>
  22 #include <unistd.h>
  23 #include <fcntl.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <signal.h>
  27 #include <stdint.h>
  28 #include <sys/wait.h>
  29
  30 /* This function is intended to rack up both user and system time.  */
  31 static void
  32 chew_cpu (void)
  33 {
  34   while (1)
  35     {
  36       static volatile char buf[4096];
  37       for (int i = 0; i < 100; ++i)
  38         for (size_t j = 0; j < sizeof buf; ++j)
  39           buf[j] = 0xaa;
  40       int nullfd = open ("/dev/null", O_WRONLY);
  41       for (int i = 0; i < 100; ++i)
  42         for (size_t j = 0; j < sizeof buf; ++j)
  43           buf[j] = 0xbb;
  44       write (nullfd, (char *) buf, sizeof buf);
  45       close (nullfd);
  46       if (getppid () == 1)
  47         _exit (2);
  48     }
  49 }
  50
  51 static int
  52 do_test (void)
  53 {
  54   int result = 0;
  55   clockid_t cl;
  56   int e;
  57   pid_t dead_child, child;
  58
  59   /* Fork a child and let it die, to give us a PID known not be valid
  60      (assuming PIDs don't wrap around during the test).  */
  61   {
  62     dead_child = fork ();
  63     if (dead_child == 0)
  64       _exit (0);
  65     if (dead_child < 0)
  66       {
  67         perror ("fork");
  68         return 1;
  69       }
  70     int x;
  71     if (wait (&x) != dead_child)
  72       {
  73         perror ("wait");
  74         return 2;
  75       }
  76   }
  77
  78   /* POSIX says we should get ESRCH for this.  */
  79   e = clock_getcpuclockid (dead_child, &cl);
  80   if (e != ENOSYS && e != ESRCH && e != EPERM)
  81     {
  82       printf ("clock_getcpuclockid on dead PID %d => %s\n",
  83               dead_child, strerror (e));
  84       result = 1;
  85     }
  86
  87   /* Now give us a live child eating up CPU time.  */
  88   child = fork ();
  89   if (child == 0)
  90     {
  91       chew_cpu ();
  92       _exit (1);
  93     }
  94   if (child < 0)
  95     {
  96       perror ("fork");
  97       return 1;
  98     }
  99
 100   e = clock_getcpuclockid (child, &cl);
 101   if (e == EPERM)
 102     {
 103       puts ("clock_getcpuclockid does not support other processes");
 104       goto done;
 105     }
 106   if (e != 0)
 107     {
 108       printf ("clock_getcpuclockid on live PID %d => %s\n",
 109               child, strerror (e));
 110       result = 1;
 111       goto done;
 112     }
 113
 114   const clockid_t child_clock = cl;
 115   struct timespec res;
 116   if (clock_getres (child_clock, &res) < 0)
 117     {
 118       printf ("clock_getres on live PID %d clock %lx => %s\n",
 119               child, (unsigned long int) child_clock, strerror (errno));
 120       result = 1;
 121       goto done;
 122     }
 123   printf ("live PID %d clock %lx resolution %ju.%.9ju\n",
 124           child, (unsigned long int) child_clock,
 125           (uintmax_t) res.tv_sec, (uintmax_t) res.tv_nsec);
 126
 127   struct timespec before;
 128   if (clock_gettime (child_clock, &before) < 0)
 129     {
 130       printf ("clock_gettime on live PID %d clock %lx => %s\n",
 131               child, (unsigned long int) child_clock, strerror (errno));
 132       result = 1;
 133       goto done;
 134     }
 135   /* Should be close to 0.0.  */
 136   printf ("live PID %d before sleep => %ju.%.9ju\n",
 137           child, (uintmax_t) before.tv_sec, (uintmax_t) before.tv_nsec);
 138
 139   struct timespec sleeptime = { .tv_nsec = 100000000 };
 140   e = clock_nanosleep (child_clock, 0, &sleeptime, NULL);
 141   if (e == EINVAL || e == ENOTSUP || e == ENOSYS)
 142     {
 143       printf ("clock_nanosleep not supported for other process clock: %s\n",
 144               strerror (e));
 145     }
 146   else if (e != 0)
 147     {
 148       printf ("clock_nanosleep on other process clock: %s\n", strerror (e));
 149       result = 1;
 150     }
 151   else
 152     {
 153       struct timespec afterns;
 154       if (clock_gettime (child_clock, &afterns) < 0)
 155         {
 156           printf ("clock_gettime on live PID %d clock %lx => %s\n",
 157                   child, (unsigned long int) child_clock, strerror (errno));
 158           result = 1;
 159         }
 160       else
 161         {
 162           printf ("live PID %d after sleep => %ju.%.9ju\n",
 163                   child, (uintmax_t) afterns.tv_sec,
 164                   (uintmax_t) afterns.tv_nsec);
 165         }
 166     }
 167
 168   if (kill (child, SIGKILL) != 0)
 169     {
 170       perror ("kill");
 171       result = 2;
 172       goto done;
 173     }
 174
 175   /* Wait long enough to let the child finish dying.  */
 176
 177   sleeptime.tv_nsec = 200000000;
 178   if (nanosleep (&sleeptime, NULL) != 0)
 179     {
 180       perror ("nanosleep");
 181       result = 1;
 182       goto done;
 183     }
 184
 185   struct timespec dead;
 186   if (clock_gettime (child_clock, &dead) < 0)
 187     {
 188       printf ("clock_gettime on dead PID %d clock %lx => %s\n",
 189               child, (unsigned long int) child_clock, strerror (errno));
 190       result = 1;
 191       goto done;
 192     }
 193   /* Should be close to 0.1.  */
 194   printf ("dead PID %d => %ju.%.9ju\n",
 195           child, (uintmax_t) dead.tv_sec, (uintmax_t) dead.tv_nsec);
 196
 197   /* Now reap the child and verify that its clock is no longer valid.  */
 198   {
 199     int x;
 200     if (waitpid (child, &x, 0) != child)
 201       {
 202         perror ("waitpid");
 203         result = 1;
 204       }
 205   }
 206
 207   if (clock_gettime (child_clock, &dead) == 0)
 208     {
 209       printf ("clock_gettime on reaped PID %d clock %lx => %ju%.9ju\n",
 210               child, (unsigned long int) child_clock,
 211               (uintmax_t) dead.tv_sec, (uintmax_t) dead.tv_nsec);
 212       result = 1;
 213     }
 214   else
 215     {
 216       if (errno != EINVAL)
 217         result = 1;
 218       printf ("clock_gettime on reaped PID %d clock %lx => %s\n",
 219               child, (unsigned long int) child_clock, strerror (errno));
 220     }
 221
 222   if (clock_getres (child_clock, &dead) == 0)
 223     {
 224       printf ("clock_getres on reaped PID %d clock %lx => %ju%.9ju\n",
 225               child, (unsigned long int) child_clock,
 226               (uintmax_t) dead.tv_sec, (uintmax_t) dead.tv_nsec);
 227       result = 1;
 228     }
 229   else
 230     {
 231       if (errno != EINVAL)
 232         result = 1;
 233       printf ("clock_getres on reaped PID %d clock %lx => %s\n",
 234               child, (unsigned long int) child_clock, strerror (errno));
 235     }
 236
 237   return result;
 238
 239  done:
 240   {
 241     if (kill (child, SIGKILL) != 0 && errno != ESRCH)
 242       {
 243         perror ("kill");
 244         return 2;
 245       }
 246     int x;
 247     if (waitpid (child, &x, 0) != child && errno != ECHILD)
 248       {
 249         perror ("waitpid");
 250         return 2;
 251       }
 252   }
 253
 254   return result;
 255 }
 256
 257
 258 #define TEST_FUNCTION do_test ()
 259 #include "../test-skeleton.c"