kernel/tools/testing/selftests/timers/leap-a-day.c

   1 /* Leap second stress test
   2  *              by: John Stultz (john.stultz@linaro.org)
   3  *              (C) Copyright IBM 2012
   4  *              (C) Copyright 2013, 2015 Linaro Limited
   5  *              Licensed under the GPLv2
   6  *
   7  *  This test signals the kernel to insert a leap second
   8  *  every day at midnight GMT. This allows for stessing the
   9  *  kernel's leap-second behavior, as well as how well applications
  10  *  handle the leap-second discontinuity.
  11  *
  12  *  Usage: leap-a-day [-s] [-i <num>]
  13  *
  14  *  Options:
  15  *      -s:     Each iteration, set the date to 10 seconds before midnight GMT.
  16  *              This speeds up the number of leapsecond transitions tested,
  17  *              but because it calls settimeofday frequently, advancing the
  18  *              time by 24 hours every ~16 seconds, it may cause application
  19  *              disruption.
  20  *
  21  *      -i:     Number of iterations to run (default: infinite)
  22  *
  23  *  Other notes: Disabling NTP prior to running this is advised, as the two
  24  *               may conflict in their commands to the kernel.
  25  *
  26  *  To build:
  27  *      $ gcc leap-a-day.c -o leap-a-day -lrt
  28  *
  29  *   This program is free software: you can redistribute it and/or modify
  30  *   it under the terms of the GNU General Public License as published by
  31  *   the Free Software Foundation, either version 2 of the License, or
  32  *   (at your option) any later version.
  33  *
  34  *   This program is distributed in the hope that it will be useful,
  35  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  36  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  37  *   GNU General Public License for more details.
  38  */
  39
  40
  41
  42 #include <stdio.h>
  43 #include <stdlib.h>
  44 #include <time.h>
  45 #include <sys/time.h>
  46 #include <sys/timex.h>
  47 #include <string.h>
  48 #include <signal.h>
  49 #include <unistd.h>
  50 #ifdef KTEST
  51 #include "../kselftest.h"
  52 #else
  53 static inline int ksft_exit_pass(void)
  54 {
  55         exit(0);
  56 }
  57 static inline int ksft_exit_fail(void)
  58 {
  59         exit(1);
  60 }
  61 #endif
  62
  63 #define NSEC_PER_SEC 1000000000ULL
  64 #define CLOCK_TAI 11
  65
  66 /* returns 1 if a <= b, 0 otherwise */
  67 static inline int in_order(struct timespec a, struct timespec b)
  68 {
  69         if (a.tv_sec < b.tv_sec)
  70                 return 1;
  71         if (a.tv_sec > b.tv_sec)
  72                 return 0;
  73         if (a.tv_nsec > b.tv_nsec)
  74                 return 0;
  75         return 1;
  76 }
  77
  78 struct timespec timespec_add(struct timespec ts, unsigned long long ns)
  79 {
  80         ts.tv_nsec += ns;
  81         while (ts.tv_nsec >= NSEC_PER_SEC) {
  82                 ts.tv_nsec -= NSEC_PER_SEC;
  83                 ts.tv_sec++;
  84         }
  85         return ts;
  86 }
  87
  88 char *time_state_str(int state)
  89 {
  90         switch (state) {
  91         case TIME_OK:   return "TIME_OK";
  92         case TIME_INS:  return "TIME_INS";
  93         case TIME_DEL:  return "TIME_DEL";
  94         case TIME_OOP:  return "TIME_OOP";
  95         case TIME_WAIT: return "TIME_WAIT";
  96         case TIME_BAD:  return "TIME_BAD";
  97         }
  98         return "ERROR";
  99 }
 100
 101 /* clear NTP time_status & time_state */
 102 int clear_time_state(void)
 103 {
 104         struct timex tx;
 105         int ret;
 106
 107         /*
 108          * We have to call adjtime twice here, as kernels
 109          * prior to 6b1859dba01c7 (included in 3.5 and
 110          * -stable), had an issue with the state machine
 111          * and wouldn't clear the STA_INS/DEL flag directly.
 112          */
 113         tx.modes = ADJ_STATUS;
 114         tx.status = STA_PLL;
 115         ret = adjtimex(&tx);
 116
 117         /* Clear maxerror, as it can cause UNSYNC to be set */
 118         tx.modes = ADJ_MAXERROR;
 119         tx.maxerror = 0;
 120         ret = adjtimex(&tx);
 121
 122         /* Clear the status */
 123         tx.modes = ADJ_STATUS;
 124         tx.status = 0;
 125         ret = adjtimex(&tx);
 126
 127         return ret;
 128 }
 129
 130 /* Make sure we cleanup on ctrl-c */
 131 void handler(int unused)
 132 {
 133         clear_time_state();
 134         exit(0);
 135 }
 136
 137 /* Test for known hrtimer failure */
 138 void test_hrtimer_failure(void)
 139 {
 140         struct timespec now, target;
 141
 142         clock_gettime(CLOCK_REALTIME, &now);
 143         target = timespec_add(now, NSEC_PER_SEC/2);
 144         clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &target, NULL);
 145         clock_gettime(CLOCK_REALTIME, &now);
 146
 147         if (!in_order(target, now))
 148                 printf("ERROR: hrtimer early expiration failure observed.\n");
 149 }
 150
 151 int main(int argc, char **argv)
 152 {
 153         int settime = 0;
 154         int tai_time = 0;
 155         int insert = 1;
 156         int iterations = -1;
 157         int opt;
 158
 159         /* Process arguments */
 160         while ((opt = getopt(argc, argv, "sti:")) != -1) {
 161                 switch (opt) {
 162                 case 's':
 163                         printf("Setting time to speed up testing\n");
 164                         settime = 1;
 165                         break;
 166                 case 'i':
 167                         iterations = atoi(optarg);
 168                         break;
 169                 case 't':
 170                         tai_time = 1;
 171                         break;
 172                 default:
 173                         printf("Usage: %s [-s] [-i <iterations>]\n", argv[0]);
 174                         printf("        -s: Set time to right before leap second each iteration\n");
 175                         printf("        -i: Number of iterations\n");
 176                         printf("        -t: Print TAI time\n");
 177                         exit(-1);
 178                 }
 179         }
 180
 181         /* Make sure TAI support is present if -t was used */
 182         if (tai_time) {
 183                 struct timespec ts;
 184
 185                 if (clock_gettime(CLOCK_TAI, &ts)) {
 186                         printf("System doesn't support CLOCK_TAI\n");
 187                         ksft_exit_fail();
 188                 }
 189         }
 190
 191         signal(SIGINT, handler);
 192         signal(SIGKILL, handler);
 193
 194         if (iterations < 0)
 195                 printf("This runs continuously. Press ctrl-c to stop\n");
 196         else
 197                 printf("Running for %i iterations. Press ctrl-c to stop\n", iterations);
 198
 199         printf("\n");
 200         while (1) {
 201                 int ret;
 202                 struct timespec ts;
 203                 struct timex tx;
 204                 time_t now, next_leap;
 205
 206                 /* Get the current time */
 207                 clock_gettime(CLOCK_REALTIME, &ts);
 208
 209                 /* Calculate the next possible leap second 23:59:60 GMT */
 210                 next_leap = ts.tv_sec;
 211                 next_leap += 86400 - (next_leap % 86400);
 212
 213                 if (settime) {
 214                         struct timeval tv;
 215
 216                         tv.tv_sec = next_leap - 10;
 217                         tv.tv_usec = 0;
 218                         settimeofday(&tv, NULL);
 219                         printf("Setting time to %s", ctime(&tv.tv_sec));
 220                 }
 221
 222                 /* Reset NTP time state */
 223                 clear_time_state();
 224
 225                 /* Set the leap second insert flag */
 226                 tx.modes = ADJ_STATUS;
 227                 if (insert)
 228                         tx.status = STA_INS;
 229                 else
 230                         tx.status = STA_DEL;
 231                 ret = adjtimex(&tx);
 232                 if (ret < 0) {
 233                         printf("Error: Problem setting STA_INS/STA_DEL!: %s\n",
 234                                                         time_state_str(ret));
 235                         return ksft_exit_fail();
 236                 }
 237
 238                 /* Validate STA_INS was set */
 239                 tx.modes = 0;
 240                 ret = adjtimex(&tx);
 241                 if (tx.status != STA_INS && tx.status != STA_DEL) {
 242                         printf("Error: STA_INS/STA_DEL not set!: %s\n",
 243                                                         time_state_str(ret));
 244                         return ksft_exit_fail();
 245                 }
 246
 247                 if (tai_time) {
 248                         printf("Using TAI time,"
 249                                 " no inconsistencies should be seen!\n");
 250                 }
 251
 252                 printf("Scheduling leap second for %s", ctime(&next_leap));
 253
 254                 /* Wake up 3 seconds before leap */
 255                 ts.tv_sec = next_leap - 3;
 256                 ts.tv_nsec = 0;
 257
 258                 while (clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &ts, NULL))
 259                         printf("Something woke us up, returning to sleep\n");
 260
 261                 /* Validate STA_INS is still set */
 262                 tx.modes = 0;
 263                 ret = adjtimex(&tx);
 264                 if (tx.status != STA_INS && tx.status != STA_DEL) {
 265                         printf("Something cleared STA_INS/STA_DEL, setting it again.\n");
 266                         tx.modes = ADJ_STATUS;
 267                         if (insert)
 268                                 tx.status = STA_INS;
 269                         else
 270                                 tx.status = STA_DEL;
 271                         ret = adjtimex(&tx);
 272                 }
 273
 274                 /* Check adjtimex output every half second */
 275                 now = tx.time.tv_sec;
 276                 while (now < next_leap + 2) {
 277                         char buf[26];
 278                         struct timespec tai;
 279
 280                         tx.modes = 0;
 281                         ret = adjtimex(&tx);
 282
 283                         if (tai_time) {
 284                                 clock_gettime(CLOCK_TAI, &tai);
 285                                 printf("%ld sec, %9ld ns\t%s\n",
 286                                                 tai.tv_sec,
 287                                                 tai.tv_nsec,
 288                                                 time_state_str(ret));
 289                         } else {
 290                                 ctime_r(&tx.time.tv_sec, buf);
 291                                 buf[strlen(buf)-1] = 0; /*remove trailing\n */
 292
 293                                 printf("%s + %6ld us (%i)\t%s\n",
 294                                                 buf,
 295                                                 tx.time.tv_usec,
 296                                                 tx.tai,
 297                                                 time_state_str(ret));
 298                         }
 299                         now = tx.time.tv_sec;
 300                         /* Sleep for another half second */
 301                         ts.tv_sec = 0;
 302                         ts.tv_nsec = NSEC_PER_SEC / 2;
 303                         clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, NULL);
 304                 }
 305                 /* Switch to using other mode */
 306                 insert = !insert;
 307
 308                 /* Note if kernel has known hrtimer failure */
 309                 test_hrtimer_failure();
 310
 311                 printf("Leap complete\n\n");
 312
 313                 if ((iterations != -1) && !(--iterations))
 314                         break;
 315         }
 316
 317         clear_time_state();
 318         return ksft_exit_pass();
 319 }