tools/testing/selftests/timers/posix_timers.c

   1 /*
   2  * Copyright (C) 2013 Red Hat, Inc., Frederic Weisbecker <fweisbec@redhat.com>
   3  *
   4  * Licensed under the terms of the GNU GPL License version 2
   5  *
   6  * Selftests for a few posix timers interface.
   7  *
   8  * Kernel loop code stolen from Steven Rostedt <srostedt@redhat.com>
   9  */
  10
  11 #include <sys/time.h>
  12 #include <stdio.h>
  13 #include <signal.h>
  14 #include <unistd.h>
  15 #include <time.h>
  16 #include <pthread.h>
  17
  18 #include "../kselftest.h"
  19
  20 #define DELAY 2
  21 #define USECS_PER_SEC 1000000
  22
  23 static volatile int done;
  24
  25 /* Busy loop in userspace to elapse ITIMER_VIRTUAL */
  26 static void user_loop(void)
  27 {
  28         while (!done);
  29 }
  30
  31 /*
  32  * Try to spend as much time as possible in kernelspace
  33  * to elapse ITIMER_PROF.
  34  */
  35 static void kernel_loop(void)
  36 {
  37         void *addr = sbrk(0);
  38         int err = 0;
  39
  40         while (!done && !err) {
  41                 err = brk(addr + 4096);
  42                 err |= brk(addr);
  43         }
  44 }
  45
  46 /*
  47  * Sleep until ITIMER_REAL expiration.
  48  */
  49 static void idle_loop(void)
  50 {
  51         pause();
  52 }
  53
  54 static void sig_handler(int nr)
  55 {
  56         done = 1;
  57 }
  58
  59 /*
  60  * Check the expected timer expiration matches the GTOD elapsed delta since
  61  * we armed the timer. Keep a 0.5 sec error margin due to various jitter.
  62  */
  63 static int check_diff(struct timeval start, struct timeval end)
  64 {
  65         long long diff;
  66
  67         diff = end.tv_usec - start.tv_usec;
  68         diff += (end.tv_sec - start.tv_sec) * USECS_PER_SEC;
  69
  70         if (abs(diff - DELAY * USECS_PER_SEC) > USECS_PER_SEC / 2) {
  71                 printf("Diff too high: %lld..", diff);
  72                 return -1;
  73         }
  74
  75         return 0;
  76 }
  77
  78 static int check_itimer(int which)
  79 {
  80         int err;
  81         struct timeval start, end;
  82         struct itimerval val = {
  83                 .it_value.tv_sec = DELAY,
  84         };
  85
  86         printf("Check itimer ");
  87
  88         if (which == ITIMER_VIRTUAL)
  89                 printf("virtual... ");
  90         else if (which == ITIMER_PROF)
  91                 printf("prof... ");
  92         else if (which == ITIMER_REAL)
  93                 printf("real... ");
  94
  95         fflush(stdout);
  96
  97         done = 0;
  98
  99         if (which == ITIMER_VIRTUAL)
 100                 signal(SIGVTALRM, sig_handler);
 101         else if (which == ITIMER_PROF)
 102                 signal(SIGPROF, sig_handler);
 103         else if (which == ITIMER_REAL)
 104                 signal(SIGALRM, sig_handler);
 105
 106         err = gettimeofday(&start, NULL);
 107         if (err < 0) {
 108                 perror("Can't call gettimeofday()\n");
 109                 return -1;
 110         }
 111
 112         err = setitimer(which, &val, NULL);
 113         if (err < 0) {
 114                 perror("Can't set timer\n");
 115                 return -1;
 116         }
 117
 118         if (which == ITIMER_VIRTUAL)
 119                 user_loop();
 120         else if (which == ITIMER_PROF)
 121                 kernel_loop();
 122         else if (which == ITIMER_REAL)
 123                 idle_loop();
 124
 125         err = gettimeofday(&end, NULL);
 126         if (err < 0) {
 127                 perror("Can't call gettimeofday()\n");
 128                 return -1;
 129         }
 130
 131         if (!check_diff(start, end))
 132                 printf("[OK]\n");
 133         else
 134                 printf("[FAIL]\n");
 135
 136         return 0;
 137 }
 138
 139 static int check_timer_create(int which)
 140 {
 141         int err;
 142         timer_t id;
 143         struct timeval start, end;
 144         struct itimerspec val = {
 145                 .it_value.tv_sec = DELAY,
 146         };
 147
 148         printf("Check timer_create() ");
 149         if (which == CLOCK_THREAD_CPUTIME_ID) {
 150                 printf("per thread... ");
 151         } else if (which == CLOCK_PROCESS_CPUTIME_ID) {
 152                 printf("per process... ");
 153         }
 154         fflush(stdout);
 155
 156         done = 0;
 157         err = timer_create(which, NULL, &id);
 158         if (err < 0) {
 159                 perror("Can't create timer\n");
 160                 return -1;
 161         }
 162         signal(SIGALRM, sig_handler);
 163
 164         err = gettimeofday(&start, NULL);
 165         if (err < 0) {
 166                 perror("Can't call gettimeofday()\n");
 167                 return -1;
 168         }
 169
 170         err = timer_settime(id, 0, &val, NULL);
 171         if (err < 0) {
 172                 perror("Can't set timer\n");
 173                 return -1;
 174         }
 175
 176         user_loop();
 177
 178         err = gettimeofday(&end, NULL);
 179         if (err < 0) {
 180                 perror("Can't call gettimeofday()\n");
 181                 return -1;
 182         }
 183
 184         if (!check_diff(start, end))
 185                 printf("[OK]\n");
 186         else
 187                 printf("[FAIL]\n");
 188
 189         return 0;
 190 }
 191
 192 int main(int argc, char **argv)
 193 {
 194         printf("Testing posix timers. False negative may happen on CPU execution \n");
 195         printf("based timers if other threads run on the CPU...\n");
 196
 197         if (check_itimer(ITIMER_VIRTUAL) < 0)
 198                 return ksft_exit_fail();
 199
 200         if (check_itimer(ITIMER_PROF) < 0)
 201                 return ksft_exit_fail();
 202
 203         if (check_itimer(ITIMER_REAL) < 0)
 204                 return ksft_exit_fail();
 205
 206         if (check_timer_create(CLOCK_THREAD_CPUTIME_ID) < 0)
 207                 return ksft_exit_fail();
 208
 209         /*
 210          * It's unfortunately hard to reliably test a timer expiration
 211          * on parallel multithread cputime. We could arm it to expire
 212          * on DELAY * nr_threads, with nr_threads busy looping, then wait
 213          * the normal DELAY since the time is elapsing nr_threads faster.
 214          * But for that we need to ensure we have real physical free CPUs
 215          * to ensure true parallelism. So test only one thread until we
 216          * find a better solution.
 217          */
 218         if (check_timer_create(CLOCK_PROCESS_CPUTIME_ID) < 0)
 219                 return ksft_exit_fail();
 220
 221         return ksft_exit_pass();
 222 }