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 */
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 
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 
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 */
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 */
124 void handler(int unused)
125 {
126 	clear_time_state();
127 	exit(0);
128 }
129 
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 */
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 
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