1 /* adjtimex() tick adjustment test
2 * by: John Stultz <john.stultz@linaro.org>
3 * (C) Copyright Linaro Limited 2015
4 * Licensed under the GPLv2
7 * $ gcc adjtick.c -o adjtick -lrt
9 * This program is free software: you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation, either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
23 #include <sys/timex.h>
26 #include "../kselftest.h"
28 #define CLOCK_MONOTONIC_RAW 4
30 #define NSEC_PER_SEC 1000000000LL
31 #define USEC_PER_SEC 1000000
33 #define MILLION 1000000
37 long long llabs(long long val)
44 unsigned long long ts_to_nsec(struct timespec ts)
46 return ts.tv_sec * NSEC_PER_SEC + ts.tv_nsec;
49 struct timespec nsec_to_ts(long long ns)
53 ts.tv_sec = ns/NSEC_PER_SEC;
54 ts.tv_nsec = ns%NSEC_PER_SEC;
59 long long diff_timespec(struct timespec start, struct timespec end)
61 long long start_ns, end_ns;
63 start_ns = ts_to_nsec(start);
64 end_ns = ts_to_nsec(end);
66 return end_ns - start_ns;
69 void get_monotonic_and_raw(struct timespec *mon, struct timespec *raw)
71 struct timespec start, mid, end;
72 long long diff = 0, tmp;
75 clock_gettime(CLOCK_MONOTONIC, mon);
76 clock_gettime(CLOCK_MONOTONIC_RAW, raw);
78 /* Try to get a more tightly bound pairing */
79 for (i = 0; i < 3; i++) {
82 clock_gettime(CLOCK_MONOTONIC, &start);
83 clock_gettime(CLOCK_MONOTONIC_RAW, &mid);
84 clock_gettime(CLOCK_MONOTONIC, &end);
86 newdiff = diff_timespec(start, end);
87 if (diff == 0 || newdiff < diff) {
90 tmp = (ts_to_nsec(start) + ts_to_nsec(end))/2;
91 *mon = nsec_to_ts(tmp);
96 long long get_ppm_drift(void)
98 struct timespec mon_start, raw_start, mon_end, raw_end;
99 long long delta1, delta2, eppm;
101 get_monotonic_and_raw(&mon_start, &raw_start);
105 get_monotonic_and_raw(&mon_end, &raw_end);
107 delta1 = diff_timespec(mon_start, mon_end);
108 delta2 = diff_timespec(raw_start, raw_end);
110 eppm = (delta1*MILLION)/delta2 - MILLION;
115 int check_tick_adj(long tickval)
120 tx1.modes = ADJ_TICK;
121 tx1.modes |= ADJ_OFFSET;
122 tx1.modes |= ADJ_FREQUENCY;
123 tx1.modes |= ADJ_STATUS;
125 tx1.status = STA_PLL;
134 ppm = ((long long)tickval * MILLION)/systick - MILLION;
135 printf("Estimating tick (act: %ld usec, %lld ppm): ", tickval, ppm);
137 eppm = get_ppm_drift();
138 printf("%lld usec, %lld ppm", systick + (systick * eppm / MILLION), eppm);
144 if (tx1.offset || tx1.freq || tx1.tick != tickval) {
145 printf(" [ERROR]\n");
146 printf("\tUnexpected adjtimex return values, make sure ntpd is not running.\n");
151 * Here we use 100ppm difference as an error bound.
152 * We likely should see better, but some coarse clocksources
153 * cannot match the HZ tick size accurately, so we have a
154 * internal correction factor that doesn't scale exactly
155 * with the adjustment, resulting in > 10ppm error during
156 * a 10% adjustment. 100ppm also gives us more breathing
157 * room for interruptions during the measurement.
159 if (llabs(eppm - ppm) > 100) {
160 printf(" [FAILED]\n");
168 int main(int argv, char **argc)
171 long tick, max, interval, err;
175 setbuf(stdout, NULL);
177 if (clock_gettime(CLOCK_MONOTONIC_RAW, &raw)) {
178 printf("ERR: NO CLOCK_MONOTONIC_RAW\n");
182 printf("Each iteration takes about 15 seconds\n");
184 systick = sysconf(_SC_CLK_TCK);
185 systick = USEC_PER_SEC/sysconf(_SC_CLK_TCK);
186 max = systick/10; /* +/- 10% */
187 interval = max/4; /* in 4 steps each side */
189 for (tick = (systick - max); tick < (systick + max); tick += interval) {
190 if (check_tick_adj(tick)) {
196 /* Reset things to zero */
197 tx1.modes = ADJ_TICK;
198 tx1.modes |= ADJ_OFFSET;
199 tx1.modes |= ADJ_FREQUENCY;
208 return ksft_exit_fail();
210 return ksft_exit_pass();