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 <sys/errno.h>
48 #include <string.h>
49 #include <signal.h>
50 #include <unistd.h>
51 #ifdef KTEST
52 #include "../kselftest.h"
53 #else
ksft_exit_pass(void)54 static inline int ksft_exit_pass(void)
55 {
56 exit(0);
57 }
ksft_exit_fail(void)58 static inline int ksft_exit_fail(void)
59 {
60 exit(1);
61 }
62 #endif
63
64 #define NSEC_PER_SEC 1000000000ULL
65 #define CLOCK_TAI 11
66
67 time_t next_leap;
68 int error_found;
69
70 /* returns 1 if a <= b, 0 otherwise */
in_order(struct timespec a,struct timespec b)71 static inline int in_order(struct timespec a, struct timespec b)
72 {
73 if (a.tv_sec < b.tv_sec)
74 return 1;
75 if (a.tv_sec > b.tv_sec)
76 return 0;
77 if (a.tv_nsec > b.tv_nsec)
78 return 0;
79 return 1;
80 }
81
timespec_add(struct timespec ts,unsigned long long ns)82 struct timespec timespec_add(struct timespec ts, unsigned long long ns)
83 {
84 ts.tv_nsec += ns;
85 while (ts.tv_nsec >= NSEC_PER_SEC) {
86 ts.tv_nsec -= NSEC_PER_SEC;
87 ts.tv_sec++;
88 }
89 return ts;
90 }
91
time_state_str(int state)92 char *time_state_str(int state)
93 {
94 switch (state) {
95 case TIME_OK: return "TIME_OK";
96 case TIME_INS: return "TIME_INS";
97 case TIME_DEL: return "TIME_DEL";
98 case TIME_OOP: return "TIME_OOP";
99 case TIME_WAIT: return "TIME_WAIT";
100 case TIME_BAD: return "TIME_BAD";
101 }
102 return "ERROR";
103 }
104
105 /* clear NTP time_status & time_state */
clear_time_state(void)106 int clear_time_state(void)
107 {
108 struct timex tx;
109 int ret;
110
111 /*
112 * We have to call adjtime twice here, as kernels
113 * prior to 6b1859dba01c7 (included in 3.5 and
114 * -stable), had an issue with the state machine
115 * and wouldn't clear the STA_INS/DEL flag directly.
116 */
117 tx.modes = ADJ_STATUS;
118 tx.status = STA_PLL;
119 ret = adjtimex(&tx);
120
121 /* Clear maxerror, as it can cause UNSYNC to be set */
122 tx.modes = ADJ_MAXERROR;
123 tx.maxerror = 0;
124 ret = adjtimex(&tx);
125
126 /* Clear the status */
127 tx.modes = ADJ_STATUS;
128 tx.status = 0;
129 ret = adjtimex(&tx);
130
131 return ret;
132 }
133
134 /* Make sure we cleanup on ctrl-c */
handler(int unused)135 void handler(int unused)
136 {
137 clear_time_state();
138 exit(0);
139 }
140
sigalarm(int signo)141 void sigalarm(int signo)
142 {
143 struct timex tx;
144 int ret;
145
146 tx.modes = 0;
147 ret = adjtimex(&tx);
148
149 if (tx.time.tv_sec < next_leap) {
150 printf("Error: Early timer expiration! (Should be %ld)\n", next_leap);
151 error_found = 1;
152 printf("adjtimex: %10ld sec + %6ld us (%i)\t%s\n",
153 tx.time.tv_sec,
154 tx.time.tv_usec,
155 tx.tai,
156 time_state_str(ret));
157 }
158 if (ret != TIME_WAIT) {
159 printf("Error: Timer seeing incorrect NTP state? (Should be TIME_WAIT)\n");
160 error_found = 1;
161 printf("adjtimex: %10ld sec + %6ld us (%i)\t%s\n",
162 tx.time.tv_sec,
163 tx.time.tv_usec,
164 tx.tai,
165 time_state_str(ret));
166 }
167 }
168
169
170 /* Test for known hrtimer failure */
test_hrtimer_failure(void)171 void test_hrtimer_failure(void)
172 {
173 struct timespec now, target;
174
175 clock_gettime(CLOCK_REALTIME, &now);
176 target = timespec_add(now, NSEC_PER_SEC/2);
177 clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &target, NULL);
178 clock_gettime(CLOCK_REALTIME, &now);
179
180 if (!in_order(target, now)) {
181 printf("ERROR: hrtimer early expiration failure observed.\n");
182 error_found = 1;
183 }
184 }
185
main(int argc,char ** argv)186 int main(int argc, char **argv)
187 {
188 timer_t tm1;
189 struct itimerspec its1;
190 struct sigevent se;
191 struct sigaction act;
192 int signum = SIGRTMAX;
193 int settime = 0;
194 int tai_time = 0;
195 int insert = 1;
196 int iterations = -1;
197 int opt;
198
199 /* Process arguments */
200 while ((opt = getopt(argc, argv, "sti:")) != -1) {
201 switch (opt) {
202 case 's':
203 printf("Setting time to speed up testing\n");
204 settime = 1;
205 break;
206 case 'i':
207 iterations = atoi(optarg);
208 break;
209 case 't':
210 tai_time = 1;
211 break;
212 default:
213 printf("Usage: %s [-s] [-i <iterations>]\n", argv[0]);
214 printf(" -s: Set time to right before leap second each iteration\n");
215 printf(" -i: Number of iterations\n");
216 printf(" -t: Print TAI time\n");
217 exit(-1);
218 }
219 }
220
221 /* Make sure TAI support is present if -t was used */
222 if (tai_time) {
223 struct timespec ts;
224
225 if (clock_gettime(CLOCK_TAI, &ts)) {
226 printf("System doesn't support CLOCK_TAI\n");
227 ksft_exit_fail();
228 }
229 }
230
231 signal(SIGINT, handler);
232 signal(SIGKILL, handler);
233
234 /* Set up timer signal handler: */
235 sigfillset(&act.sa_mask);
236 act.sa_flags = 0;
237 act.sa_handler = sigalarm;
238 sigaction(signum, &act, NULL);
239
240 if (iterations < 0)
241 printf("This runs continuously. Press ctrl-c to stop\n");
242 else
243 printf("Running for %i iterations. Press ctrl-c to stop\n", iterations);
244
245 printf("\n");
246 while (1) {
247 int ret;
248 struct timespec ts;
249 struct timex tx;
250 time_t now;
251
252 /* Get the current time */
253 clock_gettime(CLOCK_REALTIME, &ts);
254
255 /* Calculate the next possible leap second 23:59:60 GMT */
256 next_leap = ts.tv_sec;
257 next_leap += 86400 - (next_leap % 86400);
258
259 if (settime) {
260 struct timeval tv;
261
262 tv.tv_sec = next_leap - 10;
263 tv.tv_usec = 0;
264 settimeofday(&tv, NULL);
265 printf("Setting time to %s", ctime(&tv.tv_sec));
266 }
267
268 /* Reset NTP time state */
269 clear_time_state();
270
271 /* Set the leap second insert flag */
272 tx.modes = ADJ_STATUS;
273 if (insert)
274 tx.status = STA_INS;
275 else
276 tx.status = STA_DEL;
277 ret = adjtimex(&tx);
278 if (ret < 0) {
279 printf("Error: Problem setting STA_INS/STA_DEL!: %s\n",
280 time_state_str(ret));
281 return ksft_exit_fail();
282 }
283
284 /* Validate STA_INS was set */
285 tx.modes = 0;
286 ret = adjtimex(&tx);
287 if (tx.status != STA_INS && tx.status != STA_DEL) {
288 printf("Error: STA_INS/STA_DEL not set!: %s\n",
289 time_state_str(ret));
290 return ksft_exit_fail();
291 }
292
293 if (tai_time) {
294 printf("Using TAI time,"
295 " no inconsistencies should be seen!\n");
296 }
297
298 printf("Scheduling leap second for %s", ctime(&next_leap));
299
300 /* Set up timer */
301 printf("Setting timer for %ld - %s", next_leap, ctime(&next_leap));
302 memset(&se, 0, sizeof(se));
303 se.sigev_notify = SIGEV_SIGNAL;
304 se.sigev_signo = signum;
305 se.sigev_value.sival_int = 0;
306 if (timer_create(CLOCK_REALTIME, &se, &tm1) == -1) {
307 printf("Error: timer_create failed\n");
308 return ksft_exit_fail();
309 }
310 its1.it_value.tv_sec = next_leap;
311 its1.it_value.tv_nsec = 0;
312 its1.it_interval.tv_sec = 0;
313 its1.it_interval.tv_nsec = 0;
314 timer_settime(tm1, TIMER_ABSTIME, &its1, NULL);
315
316 /* Wake up 3 seconds before leap */
317 ts.tv_sec = next_leap - 3;
318 ts.tv_nsec = 0;
319
320
321 while (clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &ts, NULL))
322 printf("Something woke us up, returning to sleep\n");
323
324 /* Validate STA_INS is still set */
325 tx.modes = 0;
326 ret = adjtimex(&tx);
327 if (tx.status != STA_INS && tx.status != STA_DEL) {
328 printf("Something cleared STA_INS/STA_DEL, setting it again.\n");
329 tx.modes = ADJ_STATUS;
330 if (insert)
331 tx.status = STA_INS;
332 else
333 tx.status = STA_DEL;
334 ret = adjtimex(&tx);
335 }
336
337 /* Check adjtimex output every half second */
338 now = tx.time.tv_sec;
339 while (now < next_leap + 2) {
340 char buf[26];
341 struct timespec tai;
342 int ret;
343
344 tx.modes = 0;
345 ret = adjtimex(&tx);
346
347 if (tai_time) {
348 clock_gettime(CLOCK_TAI, &tai);
349 printf("%ld sec, %9ld ns\t%s\n",
350 tai.tv_sec,
351 tai.tv_nsec,
352 time_state_str(ret));
353 } else {
354 ctime_r(&tx.time.tv_sec, buf);
355 buf[strlen(buf)-1] = 0; /*remove trailing\n */
356
357 printf("%s + %6ld us (%i)\t%s\n",
358 buf,
359 tx.time.tv_usec,
360 tx.tai,
361 time_state_str(ret));
362 }
363 now = tx.time.tv_sec;
364 /* Sleep for another half second */
365 ts.tv_sec = 0;
366 ts.tv_nsec = NSEC_PER_SEC / 2;
367 clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, NULL);
368 }
369 /* Switch to using other mode */
370 insert = !insert;
371
372 /* Note if kernel has known hrtimer failure */
373 test_hrtimer_failure();
374
375 printf("Leap complete\n");
376 if (error_found) {
377 printf("Errors observed\n");
378 clear_time_state();
379 return ksft_exit_fail();
380 }
381 printf("\n");
382 if ((iterations != -1) && !(--iterations))
383 break;
384 }
385
386 clear_time_state();
387 return ksft_exit_pass();
388 }
389