valid-adjtimex.c

  1/* valid adjtimex test
  2 *              by: John Stultz <john.stultz@linaro.org>
  3 *              (C) Copyright Linaro 2015
  4 *              Licensed under the GPLv2
  5 *
  6 *  This test validates adjtimex interface with valid
  7 *  and invalid test data.
  8 *
  9 *  Usage: valid-adjtimex
 10 *
 11 *  To build:
 12 *	$ gcc valid-adjtimex.c -o valid-adjtimex -lrt
 13 *
 14 *   This program is free software: you can redistribute it and/or modify
 15 *   it under the terms of the GNU General Public License as published by
 16 *   the Free Software Foundation, either version 2 of the License, or
 17 *   (at your option) any later version.
 18 *
 19 *   This program is distributed in the hope that it will be useful,
 20 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 21 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 22 *   GNU General Public License for more details.
 23 */
 24#include <stdio.h>
 25#include <stdlib.h>
 26#include <time.h>
 27#include <sys/time.h>
 28#include <sys/timex.h>
 29#include <string.h>
 30#include <signal.h>
 31#include <unistd.h>
 32#include <include/vdso/time64.h>
 33#include "kselftest.h"
 34
 35#define ADJ_SETOFFSET 0x0100
 36
 37#include <sys/syscall.h>
 38int clock_adjtime(clockid_t id, struct timex *tx)
 39{
 40	return syscall(__NR_clock_adjtime, id, tx);
 41}
 42
 43
 44/* clear NTP time_status & time_state */
 45int clear_time_state(void)
 46{
 47	struct timex tx;
 48	int ret;
 49
 50	tx.modes = ADJ_STATUS;
 51	tx.status = 0;
 52	ret = adjtimex(&tx);
 53	return ret;
 54}
 55
 56#define NUM_FREQ_VALID 32
 57#define NUM_FREQ_OUTOFRANGE 4
 58#define NUM_FREQ_INVALID 2
 59
 60#define SHIFTED_PPM (1 << 16)
 61
 62long valid_freq[NUM_FREQ_VALID] = {
 63	 -499 * SHIFTED_PPM,
 64	 -450 * SHIFTED_PPM,
 65	 -400 * SHIFTED_PPM,
 66	 -350 * SHIFTED_PPM,
 67	 -300 * SHIFTED_PPM,
 68	 -250 * SHIFTED_PPM,
 69	 -200 * SHIFTED_PPM,
 70	 -150 * SHIFTED_PPM,
 71	 -100 * SHIFTED_PPM,
 72	  -75 * SHIFTED_PPM,
 73	  -50 * SHIFTED_PPM,
 74	  -25 * SHIFTED_PPM,
 75	  -10 * SHIFTED_PPM,
 76	   -5 * SHIFTED_PPM,
 77	   -1 * SHIFTED_PPM,
 78	-1000,
 79	    1 * SHIFTED_PPM,
 80	    5 * SHIFTED_PPM,
 81	   10 * SHIFTED_PPM,
 82	   25 * SHIFTED_PPM,
 83	   50 * SHIFTED_PPM,
 84	   75 * SHIFTED_PPM,
 85	  100 * SHIFTED_PPM,
 86	  150 * SHIFTED_PPM,
 87	  200 * SHIFTED_PPM,
 88	  250 * SHIFTED_PPM,
 89	  300 * SHIFTED_PPM,
 90	  350 * SHIFTED_PPM,
 91	  400 * SHIFTED_PPM,
 92	  450 * SHIFTED_PPM,
 93	  499 * SHIFTED_PPM,
 94};
 95
 96long outofrange_freq[NUM_FREQ_OUTOFRANGE] = {
 97	-1000 * SHIFTED_PPM,
 98	 -550 * SHIFTED_PPM,
 99	  550 * SHIFTED_PPM,
100	 1000 * SHIFTED_PPM,
101};
102
103#define LONG_MAX (~0UL>>1)
104#define LONG_MIN (-LONG_MAX - 1)
105
106long invalid_freq[NUM_FREQ_INVALID] = {
107	LONG_MAX,
108	LONG_MIN,
109};
110
111int validate_freq(void)
112{
113	struct timex tx;
114	int ret, pass = 0;
115	int i;
116
117	clear_time_state();
118
119	memset(&tx, 0, sizeof(struct timex));
120	/* Set the leap second insert flag */
121
122	printf("Testing ADJ_FREQ... ");
123	fflush(stdout);
124	for (i = 0; i < NUM_FREQ_VALID; i++) {
125		tx.modes = ADJ_FREQUENCY;
126		tx.freq = valid_freq[i];
127
128		ret = adjtimex(&tx);
129		if (ret < 0) {
130			printf("[FAIL]\n");
131			printf("Error: adjtimex(ADJ_FREQ, %ld - %ld ppm\n",
132				valid_freq[i], valid_freq[i]>>16);
133			pass = -1;
134			goto out;
135		}
136		tx.modes = 0;
137		ret = adjtimex(&tx);
138		if (tx.freq != valid_freq[i]) {
139			printf("Warning: freq value %ld not what we set it (%ld)!\n",
140					tx.freq, valid_freq[i]);
141		}
142	}
143	for (i = 0; i < NUM_FREQ_OUTOFRANGE; i++) {
144		tx.modes = ADJ_FREQUENCY;
145		tx.freq = outofrange_freq[i];
146
147		ret = adjtimex(&tx);
148		if (ret < 0) {
149			printf("[FAIL]\n");
150			printf("Error: adjtimex(ADJ_FREQ, %ld - %ld ppm\n",
151				outofrange_freq[i], outofrange_freq[i]>>16);
152			pass = -1;
153			goto out;
154		}
155		tx.modes = 0;
156		ret = adjtimex(&tx);
157		if (tx.freq == outofrange_freq[i]) {
158			printf("[FAIL]\n");
159			printf("ERROR: out of range value %ld actually set!\n",
160					tx.freq);
161			pass = -1;
162			goto out;
163		}
164	}
165
166
167	if (sizeof(long) == 8) { /* this case only applies to 64bit systems */
168		for (i = 0; i < NUM_FREQ_INVALID; i++) {
169			tx.modes = ADJ_FREQUENCY;
170			tx.freq = invalid_freq[i];
171			ret = adjtimex(&tx);
172			if (ret >= 0) {
173				printf("[FAIL]\n");
174				printf("Error: No failure on invalid ADJ_FREQUENCY %ld\n",
175					invalid_freq[i]);
176				pass = -1;
177				goto out;
178			}
179		}
180	}
181
182	printf("[OK]\n");
183out:
184	/* reset freq to zero */
185	tx.modes = ADJ_FREQUENCY;
186	tx.freq = 0;
187	ret = adjtimex(&tx);
188
189	return pass;
190}
191
192
193int set_offset(long long offset, int use_nano)
194{
195	struct timex tmx = {};
196	int ret;
197
198	tmx.modes = ADJ_SETOFFSET;
199	if (use_nano) {
200		tmx.modes |= ADJ_NANO;
201
202		tmx.time.tv_sec = offset / NSEC_PER_SEC;
203		tmx.time.tv_usec = offset % NSEC_PER_SEC;
204
205		if (offset < 0 && tmx.time.tv_usec) {
206			tmx.time.tv_sec -= 1;
207			tmx.time.tv_usec += NSEC_PER_SEC;
208		}
209	} else {
210		tmx.time.tv_sec = offset / USEC_PER_SEC;
211		tmx.time.tv_usec = offset % USEC_PER_SEC;
212
213		if (offset < 0 && tmx.time.tv_usec) {
214			tmx.time.tv_sec -= 1;
215			tmx.time.tv_usec += USEC_PER_SEC;
216		}
217	}
218
219	ret = clock_adjtime(CLOCK_REALTIME, &tmx);
220	if (ret < 0) {
221		printf("(sec: %ld  usec: %ld) ", tmx.time.tv_sec, tmx.time.tv_usec);
222		printf("[FAIL]\n");
223		return -1;
224	}
225	return 0;
226}
227
228int set_bad_offset(long sec, long usec, int use_nano)
229{
230	struct timex tmx = {};
231	int ret;
232
233	tmx.modes = ADJ_SETOFFSET;
234	if (use_nano)
235		tmx.modes |= ADJ_NANO;
236
237	tmx.time.tv_sec = sec;
238	tmx.time.tv_usec = usec;
239	ret = clock_adjtime(CLOCK_REALTIME, &tmx);
240	if (ret >= 0) {
241		printf("Invalid (sec: %ld  usec: %ld) did not fail! ", tmx.time.tv_sec, tmx.time.tv_usec);
242		printf("[FAIL]\n");
243		return -1;
244	}
245	return 0;
246}
247
248int validate_set_offset(void)
249{
250	printf("Testing ADJ_SETOFFSET... ");
251	fflush(stdout);
252
253	/* Test valid values */
254	if (set_offset(NSEC_PER_SEC - 1, 1))
255		return -1;
256
257	if (set_offset(-NSEC_PER_SEC + 1, 1))
258		return -1;
259
260	if (set_offset(-NSEC_PER_SEC - 1, 1))
261		return -1;
262
263	if (set_offset(5 * NSEC_PER_SEC, 1))
264		return -1;
265
266	if (set_offset(-5 * NSEC_PER_SEC, 1))
267		return -1;
268
269	if (set_offset(5 * NSEC_PER_SEC + NSEC_PER_SEC / 2, 1))
270		return -1;
271
272	if (set_offset(-5 * NSEC_PER_SEC - NSEC_PER_SEC / 2, 1))
273		return -1;
274
275	if (set_offset(USEC_PER_SEC - 1, 0))
276		return -1;
277
278	if (set_offset(-USEC_PER_SEC + 1, 0))
279		return -1;
280
281	if (set_offset(-USEC_PER_SEC - 1, 0))
282		return -1;
283
284	if (set_offset(5 * USEC_PER_SEC, 0))
285		return -1;
286
287	if (set_offset(-5 * USEC_PER_SEC, 0))
288		return -1;
289
290	if (set_offset(5 * USEC_PER_SEC + USEC_PER_SEC / 2, 0))
291		return -1;
292
293	if (set_offset(-5 * USEC_PER_SEC - USEC_PER_SEC / 2, 0))
294		return -1;
295
296	/* Test invalid values */
297	if (set_bad_offset(0, -1, 1))
298		return -1;
299	if (set_bad_offset(0, -1, 0))
300		return -1;
301	if (set_bad_offset(0, 2 * NSEC_PER_SEC, 1))
302		return -1;
303	if (set_bad_offset(0, 2 * USEC_PER_SEC, 0))
304		return -1;
305	if (set_bad_offset(0, NSEC_PER_SEC, 1))
306		return -1;
307	if (set_bad_offset(0, USEC_PER_SEC, 0))
308		return -1;
309	if (set_bad_offset(0, -NSEC_PER_SEC, 1))
310		return -1;
311	if (set_bad_offset(0, -USEC_PER_SEC, 0))
312		return -1;
313
314	printf("[OK]\n");
315	return 0;
316}
317
318int main(int argc, char **argv)
319{
320	if (validate_freq())
321		ksft_exit_fail();
322
323	if (validate_set_offset())
324		ksft_exit_fail();
325
326	ksft_exit_pass();
327}