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
25
26
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <time.h>
30 #include <sys/time.h>
31 #include <sys/timex.h>
32 #include <string.h>
33 #include <signal.h>
34 #include <unistd.h>
35 #ifdef KTEST
36 #include "../kselftest.h"
37 #else
ksft_exit_pass(void)38 static inline int ksft_exit_pass(void)
39 {
40 exit(0);
41 }
ksft_exit_fail(void)42 static inline int ksft_exit_fail(void)
43 {
44 exit(1);
45 }
46 #endif
47
48 #define NSEC_PER_SEC 1000000000LL
49 #define USEC_PER_SEC 1000000LL
50
51 #define ADJ_SETOFFSET 0x0100
52
53 #include <sys/syscall.h>
clock_adjtime(clockid_t id,struct timex * tx)54 static int clock_adjtime(clockid_t id, struct timex *tx)
55 {
56 return syscall(__NR_clock_adjtime, id, tx);
57 }
58
59
60 /* clear NTP time_status & time_state */
clear_time_state(void)61 int clear_time_state(void)
62 {
63 struct timex tx;
64 int ret;
65
66 tx.modes = ADJ_STATUS;
67 tx.status = 0;
68 ret = adjtimex(&tx);
69 return ret;
70 }
71
72 #define NUM_FREQ_VALID 32
73 #define NUM_FREQ_OUTOFRANGE 4
74 #define NUM_FREQ_INVALID 2
75
76 long valid_freq[NUM_FREQ_VALID] = {
77 -499<<16,
78 -450<<16,
79 -400<<16,
80 -350<<16,
81 -300<<16,
82 -250<<16,
83 -200<<16,
84 -150<<16,
85 -100<<16,
86 -75<<16,
87 -50<<16,
88 -25<<16,
89 -10<<16,
90 -5<<16,
91 -1<<16,
92 -1000,
93 1<<16,
94 5<<16,
95 10<<16,
96 25<<16,
97 50<<16,
98 75<<16,
99 100<<16,
100 150<<16,
101 200<<16,
102 250<<16,
103 300<<16,
104 350<<16,
105 400<<16,
106 450<<16,
107 499<<16,
108 };
109
110 long outofrange_freq[NUM_FREQ_OUTOFRANGE] = {
111 -1000<<16,
112 -550<<16,
113 550<<16,
114 1000<<16,
115 };
116
117 #define LONG_MAX (~0UL>>1)
118 #define LONG_MIN (-LONG_MAX - 1)
119
120 long invalid_freq[NUM_FREQ_INVALID] = {
121 LONG_MAX,
122 LONG_MIN,
123 };
124
validate_freq(void)125 int validate_freq(void)
126 {
127 struct timex tx;
128 int ret, pass = 0;
129 int i;
130
131 clear_time_state();
132
133 memset(&tx, 0, sizeof(struct timex));
134 /* Set the leap second insert flag */
135
136 printf("Testing ADJ_FREQ... ");
137 for (i = 0; i < NUM_FREQ_VALID; i++) {
138 tx.modes = ADJ_FREQUENCY;
139 tx.freq = valid_freq[i];
140
141 ret = adjtimex(&tx);
142 if (ret < 0) {
143 printf("[FAIL]\n");
144 printf("Error: adjtimex(ADJ_FREQ, %ld - %ld ppm\n",
145 valid_freq[i], valid_freq[i]>>16);
146 pass = -1;
147 goto out;
148 }
149 tx.modes = 0;
150 ret = adjtimex(&tx);
151 if (tx.freq != valid_freq[i]) {
152 printf("Warning: freq value %ld not what we set it (%ld)!\n",
153 tx.freq, valid_freq[i]);
154 }
155 }
156 for (i = 0; i < NUM_FREQ_OUTOFRANGE; i++) {
157 tx.modes = ADJ_FREQUENCY;
158 tx.freq = outofrange_freq[i];
159
160 ret = adjtimex(&tx);
161 if (ret < 0) {
162 printf("[FAIL]\n");
163 printf("Error: adjtimex(ADJ_FREQ, %ld - %ld ppm\n",
164 outofrange_freq[i], outofrange_freq[i]>>16);
165 pass = -1;
166 goto out;
167 }
168 tx.modes = 0;
169 ret = adjtimex(&tx);
170 if (tx.freq == outofrange_freq[i]) {
171 printf("[FAIL]\n");
172 printf("ERROR: out of range value %ld actually set!\n",
173 tx.freq);
174 pass = -1;
175 goto out;
176 }
177 }
178
179
180 if (sizeof(long) == 8) { /* this case only applies to 64bit systems */
181 for (i = 0; i < NUM_FREQ_INVALID; i++) {
182 tx.modes = ADJ_FREQUENCY;
183 tx.freq = invalid_freq[i];
184 ret = adjtimex(&tx);
185 if (ret >= 0) {
186 printf("[FAIL]\n");
187 printf("Error: No failure on invalid ADJ_FREQUENCY %ld\n",
188 invalid_freq[i]);
189 pass = -1;
190 goto out;
191 }
192 }
193 }
194
195 printf("[OK]\n");
196 out:
197 /* reset freq to zero */
198 tx.modes = ADJ_FREQUENCY;
199 tx.freq = 0;
200 ret = adjtimex(&tx);
201
202 return pass;
203 }
204
205
set_offset(long long offset,int use_nano)206 int set_offset(long long offset, int use_nano)
207 {
208 struct timex tmx = {};
209 int ret;
210
211 tmx.modes = ADJ_SETOFFSET;
212 if (use_nano) {
213 tmx.modes |= ADJ_NANO;
214
215 tmx.time.tv_sec = offset / NSEC_PER_SEC;
216 tmx.time.tv_usec = offset % NSEC_PER_SEC;
217
218 if (offset < 0 && tmx.time.tv_usec) {
219 tmx.time.tv_sec -= 1;
220 tmx.time.tv_usec += NSEC_PER_SEC;
221 }
222 } else {
223 tmx.time.tv_sec = offset / USEC_PER_SEC;
224 tmx.time.tv_usec = offset % USEC_PER_SEC;
225
226 if (offset < 0 && tmx.time.tv_usec) {
227 tmx.time.tv_sec -= 1;
228 tmx.time.tv_usec += USEC_PER_SEC;
229 }
230 }
231
232 ret = clock_adjtime(CLOCK_REALTIME, &tmx);
233 if (ret < 0) {
234 printf("(sec: %ld usec: %ld) ", tmx.time.tv_sec, tmx.time.tv_usec);
235 printf("[FAIL]\n");
236 return -1;
237 }
238 return 0;
239 }
240
set_bad_offset(long sec,long usec,int use_nano)241 int set_bad_offset(long sec, long usec, int use_nano)
242 {
243 struct timex tmx = {};
244 int ret;
245
246 tmx.modes = ADJ_SETOFFSET;
247 if (use_nano)
248 tmx.modes |= ADJ_NANO;
249
250 tmx.time.tv_sec = sec;
251 tmx.time.tv_usec = usec;
252 ret = clock_adjtime(CLOCK_REALTIME, &tmx);
253 if (ret >= 0) {
254 printf("Invalid (sec: %ld usec: %ld) did not fail! ", tmx.time.tv_sec, tmx.time.tv_usec);
255 printf("[FAIL]\n");
256 return -1;
257 }
258 return 0;
259 }
260
validate_set_offset(void)261 int validate_set_offset(void)
262 {
263 printf("Testing ADJ_SETOFFSET... ");
264
265 /* Test valid values */
266 if (set_offset(NSEC_PER_SEC - 1, 1))
267 return -1;
268
269 if (set_offset(-NSEC_PER_SEC + 1, 1))
270 return -1;
271
272 if (set_offset(-NSEC_PER_SEC - 1, 1))
273 return -1;
274
275 if (set_offset(5 * NSEC_PER_SEC, 1))
276 return -1;
277
278 if (set_offset(-5 * NSEC_PER_SEC, 1))
279 return -1;
280
281 if (set_offset(5 * NSEC_PER_SEC + NSEC_PER_SEC / 2, 1))
282 return -1;
283
284 if (set_offset(-5 * NSEC_PER_SEC - NSEC_PER_SEC / 2, 1))
285 return -1;
286
287 if (set_offset(USEC_PER_SEC - 1, 0))
288 return -1;
289
290 if (set_offset(-USEC_PER_SEC + 1, 0))
291 return -1;
292
293 if (set_offset(-USEC_PER_SEC - 1, 0))
294 return -1;
295
296 if (set_offset(5 * USEC_PER_SEC, 0))
297 return -1;
298
299 if (set_offset(-5 * USEC_PER_SEC, 0))
300 return -1;
301
302 if (set_offset(5 * USEC_PER_SEC + USEC_PER_SEC / 2, 0))
303 return -1;
304
305 if (set_offset(-5 * USEC_PER_SEC - USEC_PER_SEC / 2, 0))
306 return -1;
307
308 /* Test invalid values */
309 if (set_bad_offset(0, -1, 1))
310 return -1;
311 if (set_bad_offset(0, -1, 0))
312 return -1;
313 if (set_bad_offset(0, 2 * NSEC_PER_SEC, 1))
314 return -1;
315 if (set_bad_offset(0, 2 * USEC_PER_SEC, 0))
316 return -1;
317 if (set_bad_offset(0, NSEC_PER_SEC, 1))
318 return -1;
319 if (set_bad_offset(0, USEC_PER_SEC, 0))
320 return -1;
321 if (set_bad_offset(0, -NSEC_PER_SEC, 1))
322 return -1;
323 if (set_bad_offset(0, -USEC_PER_SEC, 0))
324 return -1;
325
326 printf("[OK]\n");
327 return 0;
328 }
329
main(int argc,char ** argv)330 int main(int argc, char **argv)
331 {
332 if (validate_freq())
333 return ksft_exit_fail();
334
335 if (validate_set_offset())
336 return ksft_exit_fail();
337
338 return ksft_exit_pass();
339 }
340