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