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 } 320