1 /* adjtimex() tick adjustment test
2  *		by:   John Stultz <john.stultz@linaro.org>
3  *		(C) Copyright Linaro Limited 2015
4  *		Licensed under the GPLv2
5  *
6  *  To build:
7  *	$ gcc adjtick.c -o adjtick -lrt
8  *
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.
13  *
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.
18  */
19 #include <stdio.h>
20 #include <unistd.h>
21 #include <stdlib.h>
22 #include <sys/time.h>
23 #include <sys/timex.h>
24 #include <time.h>
25 
26 #include "../kselftest.h"
27 
28 #define CLOCK_MONOTONIC_RAW	4
29 
30 #define NSEC_PER_SEC		1000000000LL
31 #define USEC_PER_SEC		1000000
32 
33 #define MILLION			1000000
34 
35 long systick;
36 
llabs(long long val)37 long long llabs(long long val)
38 {
39 	if (val < 0)
40 		val = -val;
41 	return val;
42 }
43 
ts_to_nsec(struct timespec ts)44 unsigned long long ts_to_nsec(struct timespec ts)
45 {
46 	return ts.tv_sec * NSEC_PER_SEC + ts.tv_nsec;
47 }
48 
nsec_to_ts(long long ns)49 struct timespec nsec_to_ts(long long ns)
50 {
51 	struct timespec ts;
52 
53 	ts.tv_sec = ns/NSEC_PER_SEC;
54 	ts.tv_nsec = ns%NSEC_PER_SEC;
55 
56 	return ts;
57 }
58 
diff_timespec(struct timespec start,struct timespec end)59 long long diff_timespec(struct timespec start, struct timespec end)
60 {
61 	long long start_ns, end_ns;
62 
63 	start_ns = ts_to_nsec(start);
64 	end_ns = ts_to_nsec(end);
65 
66 	return end_ns - start_ns;
67 }
68 
get_monotonic_and_raw(struct timespec * mon,struct timespec * raw)69 void get_monotonic_and_raw(struct timespec *mon, struct timespec *raw)
70 {
71 	struct timespec start, mid, end;
72 	long long diff = 0, tmp;
73 	int i;
74 
75 	clock_gettime(CLOCK_MONOTONIC, mon);
76 	clock_gettime(CLOCK_MONOTONIC_RAW, raw);
77 
78 	/* Try to get a more tightly bound pairing */
79 	for (i = 0; i < 3; i++) {
80 		long long newdiff;
81 
82 		clock_gettime(CLOCK_MONOTONIC, &start);
83 		clock_gettime(CLOCK_MONOTONIC_RAW, &mid);
84 		clock_gettime(CLOCK_MONOTONIC, &end);
85 
86 		newdiff = diff_timespec(start, end);
87 		if (diff == 0 || newdiff < diff) {
88 			diff = newdiff;
89 			*raw = mid;
90 			tmp = (ts_to_nsec(start) + ts_to_nsec(end))/2;
91 			*mon = nsec_to_ts(tmp);
92 		}
93 	}
94 }
95 
get_ppm_drift(void)96 long long get_ppm_drift(void)
97 {
98 	struct timespec mon_start, raw_start, mon_end, raw_end;
99 	long long delta1, delta2, eppm;
100 
101 	get_monotonic_and_raw(&mon_start, &raw_start);
102 
103 	sleep(15);
104 
105 	get_monotonic_and_raw(&mon_end, &raw_end);
106 
107 	delta1 = diff_timespec(mon_start, mon_end);
108 	delta2 = diff_timespec(raw_start, raw_end);
109 
110 	eppm = (delta1*MILLION)/delta2 - MILLION;
111 
112 	return eppm;
113 }
114 
check_tick_adj(long tickval)115 int check_tick_adj(long tickval)
116 {
117 	long long eppm, ppm;
118 	struct timex tx1;
119 
120 	tx1.modes	 = ADJ_TICK;
121 	tx1.modes	|= ADJ_OFFSET;
122 	tx1.modes	|= ADJ_FREQUENCY;
123 	tx1.modes	|= ADJ_STATUS;
124 
125 	tx1.status	= STA_PLL;
126 	tx1.offset	= 0;
127 	tx1.freq	= 0;
128 	tx1.tick	= tickval;
129 
130 	adjtimex(&tx1);
131 
132 	sleep(1);
133 
134 	ppm = ((long long)tickval * MILLION)/systick - MILLION;
135 	printf("Estimating tick (act: %ld usec, %lld ppm): ", tickval, ppm);
136 
137 	eppm = get_ppm_drift();
138 	printf("%lld usec, %lld ppm", systick + (systick * eppm / MILLION), eppm);
139 	fflush(stdout);
140 
141 	tx1.modes = 0;
142 	adjtimex(&tx1);
143 
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");
147 		return -1;
148 	}
149 
150 	/*
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.
158 	 */
159 	if (llabs(eppm - ppm) > 100) {
160 		printf("	[FAILED]\n");
161 		return -1;
162 	}
163 	printf("	[OK]\n");
164 
165 	return  0;
166 }
167 
main(int argc,char ** argv)168 int main(int argc, char **argv)
169 {
170 	struct timespec raw;
171 	long tick, max, interval, err;
172 	struct timex tx1;
173 
174 	err = 0;
175 	setbuf(stdout, NULL);
176 
177 	if (clock_gettime(CLOCK_MONOTONIC_RAW, &raw)) {
178 		printf("ERR: NO CLOCK_MONOTONIC_RAW\n");
179 		return -1;
180 	}
181 
182 	printf("Each iteration takes about 15 seconds\n");
183 
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 */
188 
189 	for (tick = (systick - max); tick < (systick + max); tick += interval) {
190 		if (check_tick_adj(tick)) {
191 			err = 1;
192 			break;
193 		}
194 	}
195 
196 	/* Reset things to zero */
197 	tx1.modes	 = ADJ_TICK;
198 	tx1.modes	|= ADJ_OFFSET;
199 	tx1.modes	|= ADJ_FREQUENCY;
200 
201 	tx1.offset	 = 0;
202 	tx1.freq	 = 0;
203 	tx1.tick	 = systick;
204 
205 	adjtimex(&tx1);
206 
207 	if (err)
208 		return ksft_exit_fail();
209 
210 	return ksft_exit_pass();
211 }
212