1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * This test checks the response of the system clock to frequency 4 * steps made with adjtimex(). The frequency error and stability of 5 * the CLOCK_MONOTONIC clock relative to the CLOCK_MONOTONIC_RAW clock 6 * is measured in two intervals following the step. The test fails if 7 * values from the second interval exceed specified limits. 8 * 9 * Copyright (C) Miroslav Lichvar <mlichvar@redhat.com> 2017 10 */ 11 12 #include <math.h> 13 #include <stdio.h> 14 #include <sys/timex.h> 15 #include <time.h> 16 #include <unistd.h> 17 18 #include "../kselftest.h" 19 20 #define SAMPLES 100 21 #define SAMPLE_READINGS 10 22 #define MEAN_SAMPLE_INTERVAL 0.1 23 #define STEP_INTERVAL 1.0 24 #define MAX_PRECISION 500e-9 25 #define MAX_FREQ_ERROR 0.02e-6 26 #define MAX_STDDEV 50e-9 27 28 #ifndef ADJ_SETOFFSET 29 #define ADJ_SETOFFSET 0x0100 30 #endif 31 32 struct sample { 33 double offset; 34 double time; 35 }; 36 37 static time_t mono_raw_base; 38 static time_t mono_base; 39 static long user_hz; 40 static double precision; 41 static double mono_freq_offset; 42 43 static double diff_timespec(struct timespec *ts1, struct timespec *ts2) 44 { 45 return ts1->tv_sec - ts2->tv_sec + (ts1->tv_nsec - ts2->tv_nsec) / 1e9; 46 } 47 48 static double get_sample(struct sample *sample) 49 { 50 double delay, mindelay = 0.0; 51 struct timespec ts1, ts2, ts3; 52 int i; 53 54 for (i = 0; i < SAMPLE_READINGS; i++) { 55 clock_gettime(CLOCK_MONOTONIC_RAW, &ts1); 56 clock_gettime(CLOCK_MONOTONIC, &ts2); 57 clock_gettime(CLOCK_MONOTONIC_RAW, &ts3); 58 59 ts1.tv_sec -= mono_raw_base; 60 ts2.tv_sec -= mono_base; 61 ts3.tv_sec -= mono_raw_base; 62 63 delay = diff_timespec(&ts3, &ts1); 64 if (delay <= 1e-9) { 65 i--; 66 continue; 67 } 68 69 if (!i || delay < mindelay) { 70 sample->offset = diff_timespec(&ts2, &ts1); 71 sample->offset -= delay / 2.0; 72 sample->time = ts1.tv_sec + ts1.tv_nsec / 1e9; 73 mindelay = delay; 74 } 75 } 76 77 return mindelay; 78 } 79 80 static void reset_ntp_error(void) 81 { 82 struct timex txc; 83 84 txc.modes = ADJ_SETOFFSET; 85 txc.time.tv_sec = 0; 86 txc.time.tv_usec = 0; 87 88 if (adjtimex(&txc) < 0) { 89 perror("[FAIL] adjtimex"); 90 ksft_exit_fail(); 91 } 92 } 93 94 static void set_frequency(double freq) 95 { 96 struct timex txc; 97 int tick_offset; 98 99 tick_offset = 1e6 * freq / user_hz; 100 101 txc.modes = ADJ_TICK | ADJ_FREQUENCY; 102 txc.tick = 1000000 / user_hz + tick_offset; 103 txc.freq = (1e6 * freq - user_hz * tick_offset) * (1 << 16); 104 105 if (adjtimex(&txc) < 0) { 106 perror("[FAIL] adjtimex"); 107 ksft_exit_fail(); 108 } 109 } 110 111 static void regress(struct sample *samples, int n, double *intercept, 112 double *slope, double *r_stddev, double *r_max) 113 { 114 double x, y, r, x_sum, y_sum, xy_sum, x2_sum, r2_sum; 115 int i; 116 117 x_sum = 0.0, y_sum = 0.0, xy_sum = 0.0, x2_sum = 0.0; 118 119 for (i = 0; i < n; i++) { 120 x = samples[i].time; 121 y = samples[i].offset; 122 123 x_sum += x; 124 y_sum += y; 125 xy_sum += x * y; 126 x2_sum += x * x; 127 } 128 129 *slope = (xy_sum - x_sum * y_sum / n) / (x2_sum - x_sum * x_sum / n); 130 *intercept = (y_sum - *slope * x_sum) / n; 131 132 *r_max = 0.0, r2_sum = 0.0; 133 134 for (i = 0; i < n; i++) { 135 x = samples[i].time; 136 y = samples[i].offset; 137 r = fabs(x * *slope + *intercept - y); 138 if (*r_max < r) 139 *r_max = r; 140 r2_sum += r * r; 141 } 142 143 *r_stddev = sqrt(r2_sum / n); 144 } 145 146 static int run_test(int calibration, double freq_base, double freq_step) 147 { 148 struct sample samples[SAMPLES]; 149 double intercept, slope, stddev1, max1, stddev2, max2; 150 double freq_error1, freq_error2; 151 int i; 152 153 set_frequency(freq_base); 154 155 for (i = 0; i < 10; i++) 156 usleep(1e6 * MEAN_SAMPLE_INTERVAL / 10); 157 158 reset_ntp_error(); 159 160 set_frequency(freq_base + freq_step); 161 162 for (i = 0; i < 10; i++) 163 usleep(rand() % 2000000 * STEP_INTERVAL / 10); 164 165 set_frequency(freq_base); 166 167 for (i = 0; i < SAMPLES; i++) { 168 usleep(rand() % 2000000 * MEAN_SAMPLE_INTERVAL); 169 get_sample(&samples[i]); 170 } 171 172 if (calibration) { 173 regress(samples, SAMPLES, &intercept, &slope, &stddev1, &max1); 174 mono_freq_offset = slope; 175 printf("CLOCK_MONOTONIC_RAW frequency offset: %11.3f ppm\n", 176 1e6 * mono_freq_offset); 177 return 0; 178 } 179 180 regress(samples, SAMPLES / 2, &intercept, &slope, &stddev1, &max1); 181 freq_error1 = slope * (1.0 - mono_freq_offset) - mono_freq_offset - 182 freq_base; 183 184 regress(samples + SAMPLES / 2, SAMPLES / 2, &intercept, &slope, 185 &stddev2, &max2); 186 freq_error2 = slope * (1.0 - mono_freq_offset) - mono_freq_offset - 187 freq_base; 188 189 printf("%6.0f %+10.3f %6.0f %7.0f %+10.3f %6.0f %7.0f\t", 190 1e6 * freq_step, 191 1e6 * freq_error1, 1e9 * stddev1, 1e9 * max1, 192 1e6 * freq_error2, 1e9 * stddev2, 1e9 * max2); 193 194 if (fabs(freq_error2) > MAX_FREQ_ERROR || stddev2 > MAX_STDDEV) { 195 printf("[FAIL]\n"); 196 return 1; 197 } 198 199 printf("[OK]\n"); 200 return 0; 201 } 202 203 static void init_test(void) 204 { 205 struct timespec ts; 206 struct sample sample; 207 208 if (clock_gettime(CLOCK_MONOTONIC_RAW, &ts)) { 209 perror("[FAIL] clock_gettime(CLOCK_MONOTONIC_RAW)"); 210 ksft_exit_fail(); 211 } 212 213 mono_raw_base = ts.tv_sec; 214 215 if (clock_gettime(CLOCK_MONOTONIC, &ts)) { 216 perror("[FAIL] clock_gettime(CLOCK_MONOTONIC)"); 217 ksft_exit_fail(); 218 } 219 220 mono_base = ts.tv_sec; 221 222 user_hz = sysconf(_SC_CLK_TCK); 223 224 precision = get_sample(&sample) / 2.0; 225 printf("CLOCK_MONOTONIC_RAW+CLOCK_MONOTONIC precision: %.0f ns\t\t", 226 1e9 * precision); 227 228 if (precision > MAX_PRECISION) 229 ksft_exit_skip("precision: %.0f ns > MAX_PRECISION: %.0f ns\n", 230 1e9 * precision, 1e9 * MAX_PRECISION); 231 232 printf("[OK]\n"); 233 srand(ts.tv_sec ^ ts.tv_nsec); 234 235 run_test(1, 0.0, 0.0); 236 } 237 238 int main(int argc, char **argv) 239 { 240 double freq_base, freq_step; 241 int i, j, fails = 0; 242 243 init_test(); 244 245 printf("Checking response to frequency step:\n"); 246 printf(" Step 1st interval 2nd interval\n"); 247 printf(" Freq Dev Max Freq Dev Max\n"); 248 249 for (i = 2; i >= 0; i--) { 250 for (j = 0; j < 5; j++) { 251 freq_base = (rand() % (1 << 24) - (1 << 23)) / 65536e6; 252 freq_step = 10e-6 * (1 << (6 * i)); 253 fails += run_test(0, freq_base, freq_step); 254 } 255 } 256 257 set_frequency(0.0); 258 259 if (fails) 260 return ksft_exit_fail(); 261 262 return ksft_exit_pass(); 263 } 264