rt/tst-cpuclock1.c

   1 /* Test program for process CPU clocks.
   2    Copyright (C) 2004 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, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <time.h>
  23 #include <unistd.h>
  24 #include <fcntl.h>
  25 #include <string.h>
  26 #include <errno.h>
  27 #include <signal.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 %lu.%.9lu\n",
 124           child, (unsigned long int) child_clock, res.tv_sec, res.tv_nsec);
 125
 126   struct timespec before, after;
 127   if (clock_gettime (child_clock, &before) < 0)
 128     {
 129       printf ("clock_gettime on live PID %d clock %lx => %s\n",
 130               child, (unsigned long int) child_clock, strerror (errno));
 131       result = 1;
 132       goto done;
 133     }
 134   printf ("live PID %d before sleep => %lu.%.9lu\n",
 135           child, before.tv_sec, before.tv_nsec);
 136
 137   struct timespec sleeptime = { .tv_nsec = 500000000 };
 138   nanosleep (&sleeptime, NULL);
 139
 140   if (clock_gettime (child_clock, &after) < 0)
 141     {
 142       printf ("clock_gettime on live PID %d clock %lx => %s\n",
 143               child, (unsigned long int) child_clock, strerror (errno));
 144       result = 1;
 145       goto done;
 146     }
 147   printf ("live PID %d after sleep => %lu.%.9lu\n",
 148           child, after.tv_sec, after.tv_nsec);
 149
 150   struct timespec diff = { .tv_sec = after.tv_sec - before.tv_sec,
 151                            .tv_nsec = after.tv_nsec - before.tv_nsec };
 152   if (diff.tv_nsec < 0)
 153     {
 154       --diff.tv_sec;
 155       diff.tv_nsec += 1000000000;
 156     }
 157   if (diff.tv_sec != 0
 158       || diff.tv_nsec > 600000000
 159       || diff.tv_nsec < 100000000)
 160     {
 161       printf ("before - after %lu.%.9lu outside reasonable range\n",
 162               diff.tv_sec, diff.tv_nsec);
 163       result = 1;
 164     }
 165
 166   sleeptime.tv_nsec = 100000000;
 167   e = clock_nanosleep (child_clock, 0, &sleeptime, NULL);
 168   if (e == EINVAL || e == ENOTSUP || e == ENOSYS)
 169     {
 170       printf ("clock_nanosleep not supported for other process clock: %s\n",
 171               strerror (e));
 172     }
 173   else if (e != 0)
 174     {
 175       printf ("clock_nanosleep on other process clock: %s\n", strerror (e));
 176       result = 1;
 177     }
 178   else
 179     {
 180       struct timespec afterns;
 181       if (clock_gettime (child_clock, &afterns) < 0)
 182         {
 183           printf ("clock_gettime on live PID %d clock %lx => %s\n",
 184                   child, (unsigned long int) child_clock, strerror (errno));
 185           result = 1;
 186         }
 187       else
 188         {
 189           struct timespec d = { .tv_sec = afterns.tv_sec - after.tv_sec,
 190                                 .tv_nsec = afterns.tv_nsec - after.tv_nsec };
 191           if (d.tv_nsec < 0)
 192             {
 193               --d.tv_sec;
 194               d.tv_nsec += 1000000000;
 195             }
 196           if (d.tv_sec > 0
 197               || d.tv_nsec < sleeptime.tv_nsec
 198               || d.tv_nsec > sleeptime.tv_nsec * 2)
 199             {
 200               printf ("nanosleep time %lu.%.9lu outside reasonable range\n",
 201                       d.tv_sec, d.tv_nsec);
 202               result = 1;
 203             }
 204         }
 205     }
 206
 207   if (kill (child, SIGKILL) != 0)
 208     {
 209       perror ("kill");
 210       result = 2;
 211       goto done;
 212     }
 213
 214   /* Wait long enough to let the child finish dying.  */
 215
 216   sleeptime.tv_nsec = 200000000;
 217   nanosleep (&sleeptime, NULL);
 218
 219   struct timespec dead;
 220   if (clock_gettime (child_clock, &dead) < 0)
 221     {
 222       printf ("clock_gettime on dead PID %d clock %lx => %s\n",
 223               child, (unsigned long int) child_clock, strerror (errno));
 224       result = 1;
 225       goto done;
 226     }
 227   printf ("dead PID %d => %lu.%.9lu\n",
 228           child, dead.tv_sec, dead.tv_nsec);
 229
 230   diff.tv_sec = dead.tv_sec - after.tv_sec;
 231   diff.tv_nsec = dead.tv_nsec - after.tv_nsec;
 232   if (diff.tv_nsec < 0)
 233     {
 234       --diff.tv_sec;
 235       diff.tv_nsec += 1000000000;
 236     }
 237   if (diff.tv_sec != 0 || diff.tv_nsec > 200000000)
 238     {
 239       printf ("dead - after %lu.%.9lu outside reasonable range\n",
 240               diff.tv_sec, diff.tv_nsec);
 241       result = 1;
 242     }
 243
 244   /* Now reap the child and verify that its clock is no longer valid.  */
 245   {
 246     int x;
 247     if (waitpid (child, &x, 0) != child)
 248       {
 249         perror ("waitpid");
 250         result = 1;
 251       }
 252   }
 253
 254   if (clock_gettime (child_clock, &dead) == 0)
 255     {
 256       printf ("clock_gettime on reaped PID %d clock %lx => %lu%.9lu\n",
 257               child, (unsigned long int) child_clock,
 258               dead.tv_sec, dead.tv_nsec);
 259       result = 1;
 260     }
 261   else
 262     {
 263       if (errno != EINVAL)
 264         result = 1;
 265       printf ("clock_gettime on reaped PID %d clock %lx => %s\n",
 266               child, (unsigned long int) child_clock, strerror (errno));
 267     }
 268
 269   if (clock_getres (child_clock, &dead) == 0)
 270     {
 271       printf ("clock_getres on reaped PID %d clock %lx => %lu%.9lu\n",
 272               child, (unsigned long int) child_clock,
 273               dead.tv_sec, dead.tv_nsec);
 274       result = 1;
 275     }
 276   else
 277     {
 278       if (errno != EINVAL)
 279         result = 1;
 280       printf ("clock_getres on reaped PID %d clock %lx => %s\n",
 281               child, (unsigned long int) child_clock, strerror (errno));
 282     }
 283
 284   return result;
 285
 286  done:
 287   {
 288     if (kill (child, SIGKILL) != 0 && errno != ESRCH)
 289       {
 290         perror ("kill");
 291         return 2;
 292       }
 293     int x;
 294     if (waitpid (child, &x, 0) != child && errno != ECHILD)
 295       {
 296         perror ("waitpid");
 297         return 2;
 298       }
 299   }
 300
 301   return result;
 302 }
 303
 304
 305 #define TIMEOUT 5
 306 #define TEST_FUNCTION do_test ()
 307 #include "../test-skeleton.c"