]>
Commit | Line | Data |
---|---|---|
1 | // SPDX-License-Identifier: GPL-2.0 | |
2 | /* | |
3 | * NTP state machine interfaces and logic. | |
4 | * | |
5 | * This code was mainly moved from kernel/timer.c and kernel/time.c | |
6 | * Please see those files for relevant copyright info and historical | |
7 | * changelogs. | |
8 | */ | |
9 | #include <linux/capability.h> | |
10 | #include <linux/clocksource.h> | |
11 | #include <linux/workqueue.h> | |
12 | #include <linux/hrtimer.h> | |
13 | #include <linux/jiffies.h> | |
14 | #include <linux/math64.h> | |
15 | #include <linux/timex.h> | |
16 | #include <linux/time.h> | |
17 | #include <linux/mm.h> | |
18 | #include <linux/module.h> | |
19 | #include <linux/rtc.h> | |
20 | #include <linux/math64.h> | |
21 | ||
22 | #include "ntp_internal.h" | |
23 | #include "timekeeping_internal.h" | |
24 | ||
25 | ||
26 | /* | |
27 | * NTP timekeeping variables: | |
28 | * | |
29 | * Note: All of the NTP state is protected by the timekeeping locks. | |
30 | */ | |
31 | ||
32 | ||
33 | /* USER_HZ period (usecs): */ | |
34 | unsigned long tick_usec = USER_TICK_USEC; | |
35 | ||
36 | /* SHIFTED_HZ period (nsecs): */ | |
37 | unsigned long tick_nsec; | |
38 | ||
39 | static u64 tick_length; | |
40 | static u64 tick_length_base; | |
41 | ||
42 | #define SECS_PER_DAY 86400 | |
43 | #define MAX_TICKADJ 500LL /* usecs */ | |
44 | #define MAX_TICKADJ_SCALED \ | |
45 | (((MAX_TICKADJ * NSEC_PER_USEC) << NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ) | |
46 | ||
47 | /* | |
48 | * phase-lock loop variables | |
49 | */ | |
50 | ||
51 | /* | |
52 | * clock synchronization status | |
53 | * | |
54 | * (TIME_ERROR prevents overwriting the CMOS clock) | |
55 | */ | |
56 | static int time_state = TIME_OK; | |
57 | ||
58 | /* clock status bits: */ | |
59 | static int time_status = STA_UNSYNC; | |
60 | ||
61 | /* time adjustment (nsecs): */ | |
62 | static s64 time_offset; | |
63 | ||
64 | /* pll time constant: */ | |
65 | static long time_constant = 2; | |
66 | ||
67 | /* maximum error (usecs): */ | |
68 | static long time_maxerror = NTP_PHASE_LIMIT; | |
69 | ||
70 | /* estimated error (usecs): */ | |
71 | static long time_esterror = NTP_PHASE_LIMIT; | |
72 | ||
73 | /* frequency offset (scaled nsecs/secs): */ | |
74 | static s64 time_freq; | |
75 | ||
76 | /* time at last adjustment (secs): */ | |
77 | static time64_t time_reftime; | |
78 | ||
79 | static long time_adjust; | |
80 | ||
81 | /* constant (boot-param configurable) NTP tick adjustment (upscaled) */ | |
82 | static s64 ntp_tick_adj; | |
83 | ||
84 | /* second value of the next pending leapsecond, or TIME64_MAX if no leap */ | |
85 | static time64_t ntp_next_leap_sec = TIME64_MAX; | |
86 | ||
87 | #ifdef CONFIG_NTP_PPS | |
88 | ||
89 | /* | |
90 | * The following variables are used when a pulse-per-second (PPS) signal | |
91 | * is available. They establish the engineering parameters of the clock | |
92 | * discipline loop when controlled by the PPS signal. | |
93 | */ | |
94 | #define PPS_VALID 10 /* PPS signal watchdog max (s) */ | |
95 | #define PPS_POPCORN 4 /* popcorn spike threshold (shift) */ | |
96 | #define PPS_INTMIN 2 /* min freq interval (s) (shift) */ | |
97 | #define PPS_INTMAX 8 /* max freq interval (s) (shift) */ | |
98 | #define PPS_INTCOUNT 4 /* number of consecutive good intervals to | |
99 | increase pps_shift or consecutive bad | |
100 | intervals to decrease it */ | |
101 | #define PPS_MAXWANDER 100000 /* max PPS freq wander (ns/s) */ | |
102 | ||
103 | static int pps_valid; /* signal watchdog counter */ | |
104 | static long pps_tf[3]; /* phase median filter */ | |
105 | static long pps_jitter; /* current jitter (ns) */ | |
106 | static struct timespec64 pps_fbase; /* beginning of the last freq interval */ | |
107 | static int pps_shift; /* current interval duration (s) (shift) */ | |
108 | static int pps_intcnt; /* interval counter */ | |
109 | static s64 pps_freq; /* frequency offset (scaled ns/s) */ | |
110 | static long pps_stabil; /* current stability (scaled ns/s) */ | |
111 | ||
112 | /* | |
113 | * PPS signal quality monitors | |
114 | */ | |
115 | static long pps_calcnt; /* calibration intervals */ | |
116 | static long pps_jitcnt; /* jitter limit exceeded */ | |
117 | static long pps_stbcnt; /* stability limit exceeded */ | |
118 | static long pps_errcnt; /* calibration errors */ | |
119 | ||
120 | ||
121 | /* PPS kernel consumer compensates the whole phase error immediately. | |
122 | * Otherwise, reduce the offset by a fixed factor times the time constant. | |
123 | */ | |
124 | static inline s64 ntp_offset_chunk(s64 offset) | |
125 | { | |
126 | if (time_status & STA_PPSTIME && time_status & STA_PPSSIGNAL) | |
127 | return offset; | |
128 | else | |
129 | return shift_right(offset, SHIFT_PLL + time_constant); | |
130 | } | |
131 | ||
132 | static inline void pps_reset_freq_interval(void) | |
133 | { | |
134 | /* the PPS calibration interval may end | |
135 | surprisingly early */ | |
136 | pps_shift = PPS_INTMIN; | |
137 | pps_intcnt = 0; | |
138 | } | |
139 | ||
140 | /** | |
141 | * pps_clear - Clears the PPS state variables | |
142 | */ | |
143 | static inline void pps_clear(void) | |
144 | { | |
145 | pps_reset_freq_interval(); | |
146 | pps_tf[0] = 0; | |
147 | pps_tf[1] = 0; | |
148 | pps_tf[2] = 0; | |
149 | pps_fbase.tv_sec = pps_fbase.tv_nsec = 0; | |
150 | pps_freq = 0; | |
151 | } | |
152 | ||
153 | /* Decrease pps_valid to indicate that another second has passed since | |
154 | * the last PPS signal. When it reaches 0, indicate that PPS signal is | |
155 | * missing. | |
156 | */ | |
157 | static inline void pps_dec_valid(void) | |
158 | { | |
159 | if (pps_valid > 0) | |
160 | pps_valid--; | |
161 | else { | |
162 | time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER | | |
163 | STA_PPSWANDER | STA_PPSERROR); | |
164 | pps_clear(); | |
165 | } | |
166 | } | |
167 | ||
168 | static inline void pps_set_freq(s64 freq) | |
169 | { | |
170 | pps_freq = freq; | |
171 | } | |
172 | ||
173 | static inline int is_error_status(int status) | |
174 | { | |
175 | return (status & (STA_UNSYNC|STA_CLOCKERR)) | |
176 | /* PPS signal lost when either PPS time or | |
177 | * PPS frequency synchronization requested | |
178 | */ | |
179 | || ((status & (STA_PPSFREQ|STA_PPSTIME)) | |
180 | && !(status & STA_PPSSIGNAL)) | |
181 | /* PPS jitter exceeded when | |
182 | * PPS time synchronization requested */ | |
183 | || ((status & (STA_PPSTIME|STA_PPSJITTER)) | |
184 | == (STA_PPSTIME|STA_PPSJITTER)) | |
185 | /* PPS wander exceeded or calibration error when | |
186 | * PPS frequency synchronization requested | |
187 | */ | |
188 | || ((status & STA_PPSFREQ) | |
189 | && (status & (STA_PPSWANDER|STA_PPSERROR))); | |
190 | } | |
191 | ||
192 | static inline void pps_fill_timex(struct timex *txc) | |
193 | { | |
194 | txc->ppsfreq = shift_right((pps_freq >> PPM_SCALE_INV_SHIFT) * | |
195 | PPM_SCALE_INV, NTP_SCALE_SHIFT); | |
196 | txc->jitter = pps_jitter; | |
197 | if (!(time_status & STA_NANO)) | |
198 | txc->jitter /= NSEC_PER_USEC; | |
199 | txc->shift = pps_shift; | |
200 | txc->stabil = pps_stabil; | |
201 | txc->jitcnt = pps_jitcnt; | |
202 | txc->calcnt = pps_calcnt; | |
203 | txc->errcnt = pps_errcnt; | |
204 | txc->stbcnt = pps_stbcnt; | |
205 | } | |
206 | ||
207 | #else /* !CONFIG_NTP_PPS */ | |
208 | ||
209 | static inline s64 ntp_offset_chunk(s64 offset) | |
210 | { | |
211 | return shift_right(offset, SHIFT_PLL + time_constant); | |
212 | } | |
213 | ||
214 | static inline void pps_reset_freq_interval(void) {} | |
215 | static inline void pps_clear(void) {} | |
216 | static inline void pps_dec_valid(void) {} | |
217 | static inline void pps_set_freq(s64 freq) {} | |
218 | ||
219 | static inline int is_error_status(int status) | |
220 | { | |
221 | return status & (STA_UNSYNC|STA_CLOCKERR); | |
222 | } | |
223 | ||
224 | static inline void pps_fill_timex(struct timex *txc) | |
225 | { | |
226 | /* PPS is not implemented, so these are zero */ | |
227 | txc->ppsfreq = 0; | |
228 | txc->jitter = 0; | |
229 | txc->shift = 0; | |
230 | txc->stabil = 0; | |
231 | txc->jitcnt = 0; | |
232 | txc->calcnt = 0; | |
233 | txc->errcnt = 0; | |
234 | txc->stbcnt = 0; | |
235 | } | |
236 | ||
237 | #endif /* CONFIG_NTP_PPS */ | |
238 | ||
239 | ||
240 | /** | |
241 | * ntp_synced - Returns 1 if the NTP status is not UNSYNC | |
242 | * | |
243 | */ | |
244 | static inline int ntp_synced(void) | |
245 | { | |
246 | return !(time_status & STA_UNSYNC); | |
247 | } | |
248 | ||
249 | ||
250 | /* | |
251 | * NTP methods: | |
252 | */ | |
253 | ||
254 | /* | |
255 | * Update (tick_length, tick_length_base, tick_nsec), based | |
256 | * on (tick_usec, ntp_tick_adj, time_freq): | |
257 | */ | |
258 | static void ntp_update_frequency(void) | |
259 | { | |
260 | u64 second_length; | |
261 | u64 new_base; | |
262 | ||
263 | second_length = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ) | |
264 | << NTP_SCALE_SHIFT; | |
265 | ||
266 | second_length += ntp_tick_adj; | |
267 | second_length += time_freq; | |
268 | ||
269 | tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT; | |
270 | new_base = div_u64(second_length, NTP_INTERVAL_FREQ); | |
271 | ||
272 | /* | |
273 | * Don't wait for the next second_overflow, apply | |
274 | * the change to the tick length immediately: | |
275 | */ | |
276 | tick_length += new_base - tick_length_base; | |
277 | tick_length_base = new_base; | |
278 | } | |
279 | ||
280 | static inline s64 ntp_update_offset_fll(s64 offset64, long secs) | |
281 | { | |
282 | time_status &= ~STA_MODE; | |
283 | ||
284 | if (secs < MINSEC) | |
285 | return 0; | |
286 | ||
287 | if (!(time_status & STA_FLL) && (secs <= MAXSEC)) | |
288 | return 0; | |
289 | ||
290 | time_status |= STA_MODE; | |
291 | ||
292 | return div64_long(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs); | |
293 | } | |
294 | ||
295 | static void ntp_update_offset(long offset) | |
296 | { | |
297 | s64 freq_adj; | |
298 | s64 offset64; | |
299 | long secs; | |
300 | ||
301 | if (!(time_status & STA_PLL)) | |
302 | return; | |
303 | ||
304 | if (!(time_status & STA_NANO)) { | |
305 | /* Make sure the multiplication below won't overflow */ | |
306 | offset = clamp(offset, -USEC_PER_SEC, USEC_PER_SEC); | |
307 | offset *= NSEC_PER_USEC; | |
308 | } | |
309 | ||
310 | /* | |
311 | * Scale the phase adjustment and | |
312 | * clamp to the operating range. | |
313 | */ | |
314 | offset = clamp(offset, -MAXPHASE, MAXPHASE); | |
315 | ||
316 | /* | |
317 | * Select how the frequency is to be controlled | |
318 | * and in which mode (PLL or FLL). | |
319 | */ | |
320 | secs = (long)(__ktime_get_real_seconds() - time_reftime); | |
321 | if (unlikely(time_status & STA_FREQHOLD)) | |
322 | secs = 0; | |
323 | ||
324 | time_reftime = __ktime_get_real_seconds(); | |
325 | ||
326 | offset64 = offset; | |
327 | freq_adj = ntp_update_offset_fll(offset64, secs); | |
328 | ||
329 | /* | |
330 | * Clamp update interval to reduce PLL gain with low | |
331 | * sampling rate (e.g. intermittent network connection) | |
332 | * to avoid instability. | |
333 | */ | |
334 | if (unlikely(secs > 1 << (SHIFT_PLL + 1 + time_constant))) | |
335 | secs = 1 << (SHIFT_PLL + 1 + time_constant); | |
336 | ||
337 | freq_adj += (offset64 * secs) << | |
338 | (NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant)); | |
339 | ||
340 | freq_adj = min(freq_adj + time_freq, MAXFREQ_SCALED); | |
341 | ||
342 | time_freq = max(freq_adj, -MAXFREQ_SCALED); | |
343 | ||
344 | time_offset = div_s64(offset64 << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ); | |
345 | } | |
346 | ||
347 | /** | |
348 | * ntp_clear - Clears the NTP state variables | |
349 | */ | |
350 | void ntp_clear(void) | |
351 | { | |
352 | time_adjust = 0; /* stop active adjtime() */ | |
353 | time_status |= STA_UNSYNC; | |
354 | time_maxerror = NTP_PHASE_LIMIT; | |
355 | time_esterror = NTP_PHASE_LIMIT; | |
356 | ||
357 | ntp_update_frequency(); | |
358 | ||
359 | tick_length = tick_length_base; | |
360 | time_offset = 0; | |
361 | ||
362 | ntp_next_leap_sec = TIME64_MAX; | |
363 | /* Clear PPS state variables */ | |
364 | pps_clear(); | |
365 | } | |
366 | ||
367 | ||
368 | u64 ntp_tick_length(void) | |
369 | { | |
370 | return tick_length; | |
371 | } | |
372 | ||
373 | /** | |
374 | * ntp_get_next_leap - Returns the next leapsecond in CLOCK_REALTIME ktime_t | |
375 | * | |
376 | * Provides the time of the next leapsecond against CLOCK_REALTIME in | |
377 | * a ktime_t format. Returns KTIME_MAX if no leapsecond is pending. | |
378 | */ | |
379 | ktime_t ntp_get_next_leap(void) | |
380 | { | |
381 | ktime_t ret; | |
382 | ||
383 | if ((time_state == TIME_INS) && (time_status & STA_INS)) | |
384 | return ktime_set(ntp_next_leap_sec, 0); | |
385 | ret = KTIME_MAX; | |
386 | return ret; | |
387 | } | |
388 | ||
389 | /* | |
390 | * this routine handles the overflow of the microsecond field | |
391 | * | |
392 | * The tricky bits of code to handle the accurate clock support | |
393 | * were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame. | |
394 | * They were originally developed for SUN and DEC kernels. | |
395 | * All the kudos should go to Dave for this stuff. | |
396 | * | |
397 | * Also handles leap second processing, and returns leap offset | |
398 | */ | |
399 | int second_overflow(time64_t secs) | |
400 | { | |
401 | s64 delta; | |
402 | int leap = 0; | |
403 | s32 rem; | |
404 | ||
405 | /* | |
406 | * Leap second processing. If in leap-insert state at the end of the | |
407 | * day, the system clock is set back one second; if in leap-delete | |
408 | * state, the system clock is set ahead one second. | |
409 | */ | |
410 | switch (time_state) { | |
411 | case TIME_OK: | |
412 | if (time_status & STA_INS) { | |
413 | time_state = TIME_INS; | |
414 | div_s64_rem(secs, SECS_PER_DAY, &rem); | |
415 | ntp_next_leap_sec = secs + SECS_PER_DAY - rem; | |
416 | } else if (time_status & STA_DEL) { | |
417 | time_state = TIME_DEL; | |
418 | div_s64_rem(secs + 1, SECS_PER_DAY, &rem); | |
419 | ntp_next_leap_sec = secs + SECS_PER_DAY - rem; | |
420 | } | |
421 | break; | |
422 | case TIME_INS: | |
423 | if (!(time_status & STA_INS)) { | |
424 | ntp_next_leap_sec = TIME64_MAX; | |
425 | time_state = TIME_OK; | |
426 | } else if (secs == ntp_next_leap_sec) { | |
427 | leap = -1; | |
428 | time_state = TIME_OOP; | |
429 | printk(KERN_NOTICE | |
430 | "Clock: inserting leap second 23:59:60 UTC\n"); | |
431 | } | |
432 | break; | |
433 | case TIME_DEL: | |
434 | if (!(time_status & STA_DEL)) { | |
435 | ntp_next_leap_sec = TIME64_MAX; | |
436 | time_state = TIME_OK; | |
437 | } else if (secs == ntp_next_leap_sec) { | |
438 | leap = 1; | |
439 | ntp_next_leap_sec = TIME64_MAX; | |
440 | time_state = TIME_WAIT; | |
441 | printk(KERN_NOTICE | |
442 | "Clock: deleting leap second 23:59:59 UTC\n"); | |
443 | } | |
444 | break; | |
445 | case TIME_OOP: | |
446 | ntp_next_leap_sec = TIME64_MAX; | |
447 | time_state = TIME_WAIT; | |
448 | break; | |
449 | case TIME_WAIT: | |
450 | if (!(time_status & (STA_INS | STA_DEL))) | |
451 | time_state = TIME_OK; | |
452 | break; | |
453 | } | |
454 | ||
455 | ||
456 | /* Bump the maxerror field */ | |
457 | time_maxerror += MAXFREQ / NSEC_PER_USEC; | |
458 | if (time_maxerror > NTP_PHASE_LIMIT) { | |
459 | time_maxerror = NTP_PHASE_LIMIT; | |
460 | time_status |= STA_UNSYNC; | |
461 | } | |
462 | ||
463 | /* Compute the phase adjustment for the next second */ | |
464 | tick_length = tick_length_base; | |
465 | ||
466 | delta = ntp_offset_chunk(time_offset); | |
467 | time_offset -= delta; | |
468 | tick_length += delta; | |
469 | ||
470 | /* Check PPS signal */ | |
471 | pps_dec_valid(); | |
472 | ||
473 | if (!time_adjust) | |
474 | goto out; | |
475 | ||
476 | if (time_adjust > MAX_TICKADJ) { | |
477 | time_adjust -= MAX_TICKADJ; | |
478 | tick_length += MAX_TICKADJ_SCALED; | |
479 | goto out; | |
480 | } | |
481 | ||
482 | if (time_adjust < -MAX_TICKADJ) { | |
483 | time_adjust += MAX_TICKADJ; | |
484 | tick_length -= MAX_TICKADJ_SCALED; | |
485 | goto out; | |
486 | } | |
487 | ||
488 | tick_length += (s64)(time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ) | |
489 | << NTP_SCALE_SHIFT; | |
490 | time_adjust = 0; | |
491 | ||
492 | out: | |
493 | return leap; | |
494 | } | |
495 | ||
496 | static void sync_hw_clock(struct work_struct *work); | |
497 | static DECLARE_DELAYED_WORK(sync_work, sync_hw_clock); | |
498 | ||
499 | static void sched_sync_hw_clock(struct timespec64 now, | |
500 | unsigned long target_nsec, bool fail) | |
501 | ||
502 | { | |
503 | struct timespec64 next; | |
504 | ||
505 | ktime_get_real_ts64(&next); | |
506 | if (!fail) | |
507 | next.tv_sec = 659; | |
508 | else { | |
509 | /* | |
510 | * Try again as soon as possible. Delaying long periods | |
511 | * decreases the accuracy of the work queue timer. Due to this | |
512 | * the algorithm is very likely to require a short-sleep retry | |
513 | * after the above long sleep to synchronize ts_nsec. | |
514 | */ | |
515 | next.tv_sec = 0; | |
516 | } | |
517 | ||
518 | /* Compute the needed delay that will get to tv_nsec == target_nsec */ | |
519 | next.tv_nsec = target_nsec - next.tv_nsec; | |
520 | if (next.tv_nsec <= 0) | |
521 | next.tv_nsec += NSEC_PER_SEC; | |
522 | if (next.tv_nsec >= NSEC_PER_SEC) { | |
523 | next.tv_sec++; | |
524 | next.tv_nsec -= NSEC_PER_SEC; | |
525 | } | |
526 | ||
527 | queue_delayed_work(system_power_efficient_wq, &sync_work, | |
528 | timespec64_to_jiffies(&next)); | |
529 | } | |
530 | ||
531 | static void sync_rtc_clock(void) | |
532 | { | |
533 | unsigned long target_nsec; | |
534 | struct timespec64 adjust, now; | |
535 | int rc; | |
536 | ||
537 | if (!IS_ENABLED(CONFIG_RTC_SYSTOHC)) | |
538 | return; | |
539 | ||
540 | ktime_get_real_ts64(&now); | |
541 | ||
542 | adjust = now; | |
543 | if (persistent_clock_is_local) | |
544 | adjust.tv_sec -= (sys_tz.tz_minuteswest * 60); | |
545 | ||
546 | /* | |
547 | * The current RTC in use will provide the target_nsec it wants to be | |
548 | * called at, and does rtc_tv_nsec_ok internally. | |
549 | */ | |
550 | rc = rtc_set_ntp_time(adjust, &target_nsec); | |
551 | if (rc == -ENODEV) | |
552 | return; | |
553 | ||
554 | sched_sync_hw_clock(now, target_nsec, rc); | |
555 | } | |
556 | ||
557 | #ifdef CONFIG_GENERIC_CMOS_UPDATE | |
558 | int __weak update_persistent_clock(struct timespec now) | |
559 | { | |
560 | return -ENODEV; | |
561 | } | |
562 | ||
563 | int __weak update_persistent_clock64(struct timespec64 now64) | |
564 | { | |
565 | struct timespec now; | |
566 | ||
567 | now = timespec64_to_timespec(now64); | |
568 | return update_persistent_clock(now); | |
569 | } | |
570 | #endif | |
571 | ||
572 | static bool sync_cmos_clock(void) | |
573 | { | |
574 | static bool no_cmos; | |
575 | struct timespec64 now; | |
576 | struct timespec64 adjust; | |
577 | int rc = -EPROTO; | |
578 | long target_nsec = NSEC_PER_SEC / 2; | |
579 | ||
580 | if (!IS_ENABLED(CONFIG_GENERIC_CMOS_UPDATE)) | |
581 | return false; | |
582 | ||
583 | if (no_cmos) | |
584 | return false; | |
585 | ||
586 | /* | |
587 | * Historically update_persistent_clock64() has followed x86 | |
588 | * semantics, which match the MC146818A/etc RTC. This RTC will store | |
589 | * 'adjust' and then in .5s it will advance once second. | |
590 | * | |
591 | * Architectures are strongly encouraged to use rtclib and not | |
592 | * implement this legacy API. | |
593 | */ | |
594 | ktime_get_real_ts64(&now); | |
595 | if (rtc_tv_nsec_ok(-1 * target_nsec, &adjust, &now)) { | |
596 | if (persistent_clock_is_local) | |
597 | adjust.tv_sec -= (sys_tz.tz_minuteswest * 60); | |
598 | rc = update_persistent_clock64(adjust); | |
599 | /* | |
600 | * The machine does not support update_persistent_clock64 even | |
601 | * though it defines CONFIG_GENERIC_CMOS_UPDATE. | |
602 | */ | |
603 | if (rc == -ENODEV) { | |
604 | no_cmos = true; | |
605 | return false; | |
606 | } | |
607 | } | |
608 | ||
609 | sched_sync_hw_clock(now, target_nsec, rc); | |
610 | return true; | |
611 | } | |
612 | ||
613 | /* | |
614 | * If we have an externally synchronized Linux clock, then update RTC clock | |
615 | * accordingly every ~11 minutes. Generally RTCs can only store second | |
616 | * precision, but many RTCs will adjust the phase of their second tick to | |
617 | * match the moment of update. This infrastructure arranges to call to the RTC | |
618 | * set at the correct moment to phase synchronize the RTC second tick over | |
619 | * with the kernel clock. | |
620 | */ | |
621 | static void sync_hw_clock(struct work_struct *work) | |
622 | { | |
623 | if (!ntp_synced()) | |
624 | return; | |
625 | ||
626 | if (sync_cmos_clock()) | |
627 | return; | |
628 | ||
629 | sync_rtc_clock(); | |
630 | } | |
631 | ||
632 | void ntp_notify_cmos_timer(void) | |
633 | { | |
634 | if (!ntp_synced()) | |
635 | return; | |
636 | ||
637 | if (IS_ENABLED(CONFIG_GENERIC_CMOS_UPDATE) || | |
638 | IS_ENABLED(CONFIG_RTC_SYSTOHC)) | |
639 | queue_delayed_work(system_power_efficient_wq, &sync_work, 0); | |
640 | } | |
641 | ||
642 | /* | |
643 | * Propagate a new txc->status value into the NTP state: | |
644 | */ | |
645 | static inline void process_adj_status(const struct timex *txc) | |
646 | { | |
647 | if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) { | |
648 | time_state = TIME_OK; | |
649 | time_status = STA_UNSYNC; | |
650 | ntp_next_leap_sec = TIME64_MAX; | |
651 | /* restart PPS frequency calibration */ | |
652 | pps_reset_freq_interval(); | |
653 | } | |
654 | ||
655 | /* | |
656 | * If we turn on PLL adjustments then reset the | |
657 | * reference time to current time. | |
658 | */ | |
659 | if (!(time_status & STA_PLL) && (txc->status & STA_PLL)) | |
660 | time_reftime = __ktime_get_real_seconds(); | |
661 | ||
662 | /* only set allowed bits */ | |
663 | time_status &= STA_RONLY; | |
664 | time_status |= txc->status & ~STA_RONLY; | |
665 | } | |
666 | ||
667 | ||
668 | static inline void process_adjtimex_modes(const struct timex *txc, s32 *time_tai) | |
669 | { | |
670 | if (txc->modes & ADJ_STATUS) | |
671 | process_adj_status(txc); | |
672 | ||
673 | if (txc->modes & ADJ_NANO) | |
674 | time_status |= STA_NANO; | |
675 | ||
676 | if (txc->modes & ADJ_MICRO) | |
677 | time_status &= ~STA_NANO; | |
678 | ||
679 | if (txc->modes & ADJ_FREQUENCY) { | |
680 | time_freq = txc->freq * PPM_SCALE; | |
681 | time_freq = min(time_freq, MAXFREQ_SCALED); | |
682 | time_freq = max(time_freq, -MAXFREQ_SCALED); | |
683 | /* update pps_freq */ | |
684 | pps_set_freq(time_freq); | |
685 | } | |
686 | ||
687 | if (txc->modes & ADJ_MAXERROR) | |
688 | time_maxerror = txc->maxerror; | |
689 | ||
690 | if (txc->modes & ADJ_ESTERROR) | |
691 | time_esterror = txc->esterror; | |
692 | ||
693 | if (txc->modes & ADJ_TIMECONST) { | |
694 | time_constant = txc->constant; | |
695 | if (!(time_status & STA_NANO)) | |
696 | time_constant += 4; | |
697 | time_constant = min(time_constant, (long)MAXTC); | |
698 | time_constant = max(time_constant, 0l); | |
699 | } | |
700 | ||
701 | if (txc->modes & ADJ_TAI && txc->constant > 0) | |
702 | *time_tai = txc->constant; | |
703 | ||
704 | if (txc->modes & ADJ_OFFSET) | |
705 | ntp_update_offset(txc->offset); | |
706 | ||
707 | if (txc->modes & ADJ_TICK) | |
708 | tick_usec = txc->tick; | |
709 | ||
710 | if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET)) | |
711 | ntp_update_frequency(); | |
712 | } | |
713 | ||
714 | ||
715 | /* | |
716 | * adjtimex mainly allows reading (and writing, if superuser) of | |
717 | * kernel time-keeping variables. used by xntpd. | |
718 | */ | |
719 | int __do_adjtimex(struct timex *txc, const struct timespec64 *ts, s32 *time_tai) | |
720 | { | |
721 | int result; | |
722 | ||
723 | if (txc->modes & ADJ_ADJTIME) { | |
724 | long save_adjust = time_adjust; | |
725 | ||
726 | if (!(txc->modes & ADJ_OFFSET_READONLY)) { | |
727 | /* adjtime() is independent from ntp_adjtime() */ | |
728 | time_adjust = txc->offset; | |
729 | ntp_update_frequency(); | |
730 | } | |
731 | txc->offset = save_adjust; | |
732 | } else { | |
733 | ||
734 | /* If there are input parameters, then process them: */ | |
735 | if (txc->modes) | |
736 | process_adjtimex_modes(txc, time_tai); | |
737 | ||
738 | txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ, | |
739 | NTP_SCALE_SHIFT); | |
740 | if (!(time_status & STA_NANO)) | |
741 | txc->offset /= NSEC_PER_USEC; | |
742 | } | |
743 | ||
744 | result = time_state; /* mostly `TIME_OK' */ | |
745 | /* check for errors */ | |
746 | if (is_error_status(time_status)) | |
747 | result = TIME_ERROR; | |
748 | ||
749 | txc->freq = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) * | |
750 | PPM_SCALE_INV, NTP_SCALE_SHIFT); | |
751 | txc->maxerror = time_maxerror; | |
752 | txc->esterror = time_esterror; | |
753 | txc->status = time_status; | |
754 | txc->constant = time_constant; | |
755 | txc->precision = 1; | |
756 | txc->tolerance = MAXFREQ_SCALED / PPM_SCALE; | |
757 | txc->tick = tick_usec; | |
758 | txc->tai = *time_tai; | |
759 | ||
760 | /* fill PPS status fields */ | |
761 | pps_fill_timex(txc); | |
762 | ||
763 | txc->time.tv_sec = (time_t)ts->tv_sec; | |
764 | txc->time.tv_usec = ts->tv_nsec; | |
765 | if (!(time_status & STA_NANO)) | |
766 | txc->time.tv_usec /= NSEC_PER_USEC; | |
767 | ||
768 | /* Handle leapsec adjustments */ | |
769 | if (unlikely(ts->tv_sec >= ntp_next_leap_sec)) { | |
770 | if ((time_state == TIME_INS) && (time_status & STA_INS)) { | |
771 | result = TIME_OOP; | |
772 | txc->tai++; | |
773 | txc->time.tv_sec--; | |
774 | } | |
775 | if ((time_state == TIME_DEL) && (time_status & STA_DEL)) { | |
776 | result = TIME_WAIT; | |
777 | txc->tai--; | |
778 | txc->time.tv_sec++; | |
779 | } | |
780 | if ((time_state == TIME_OOP) && | |
781 | (ts->tv_sec == ntp_next_leap_sec)) { | |
782 | result = TIME_WAIT; | |
783 | } | |
784 | } | |
785 | ||
786 | return result; | |
787 | } | |
788 | ||
789 | #ifdef CONFIG_NTP_PPS | |
790 | ||
791 | /* actually struct pps_normtime is good old struct timespec, but it is | |
792 | * semantically different (and it is the reason why it was invented): | |
793 | * pps_normtime.nsec has a range of ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ] | |
794 | * while timespec.tv_nsec has a range of [0, NSEC_PER_SEC) */ | |
795 | struct pps_normtime { | |
796 | s64 sec; /* seconds */ | |
797 | long nsec; /* nanoseconds */ | |
798 | }; | |
799 | ||
800 | /* normalize the timestamp so that nsec is in the | |
801 | ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ] interval */ | |
802 | static inline struct pps_normtime pps_normalize_ts(struct timespec64 ts) | |
803 | { | |
804 | struct pps_normtime norm = { | |
805 | .sec = ts.tv_sec, | |
806 | .nsec = ts.tv_nsec | |
807 | }; | |
808 | ||
809 | if (norm.nsec > (NSEC_PER_SEC >> 1)) { | |
810 | norm.nsec -= NSEC_PER_SEC; | |
811 | norm.sec++; | |
812 | } | |
813 | ||
814 | return norm; | |
815 | } | |
816 | ||
817 | /* get current phase correction and jitter */ | |
818 | static inline long pps_phase_filter_get(long *jitter) | |
819 | { | |
820 | *jitter = pps_tf[0] - pps_tf[1]; | |
821 | if (*jitter < 0) | |
822 | *jitter = -*jitter; | |
823 | ||
824 | /* TODO: test various filters */ | |
825 | return pps_tf[0]; | |
826 | } | |
827 | ||
828 | /* add the sample to the phase filter */ | |
829 | static inline void pps_phase_filter_add(long err) | |
830 | { | |
831 | pps_tf[2] = pps_tf[1]; | |
832 | pps_tf[1] = pps_tf[0]; | |
833 | pps_tf[0] = err; | |
834 | } | |
835 | ||
836 | /* decrease frequency calibration interval length. | |
837 | * It is halved after four consecutive unstable intervals. | |
838 | */ | |
839 | static inline void pps_dec_freq_interval(void) | |
840 | { | |
841 | if (--pps_intcnt <= -PPS_INTCOUNT) { | |
842 | pps_intcnt = -PPS_INTCOUNT; | |
843 | if (pps_shift > PPS_INTMIN) { | |
844 | pps_shift--; | |
845 | pps_intcnt = 0; | |
846 | } | |
847 | } | |
848 | } | |
849 | ||
850 | /* increase frequency calibration interval length. | |
851 | * It is doubled after four consecutive stable intervals. | |
852 | */ | |
853 | static inline void pps_inc_freq_interval(void) | |
854 | { | |
855 | if (++pps_intcnt >= PPS_INTCOUNT) { | |
856 | pps_intcnt = PPS_INTCOUNT; | |
857 | if (pps_shift < PPS_INTMAX) { | |
858 | pps_shift++; | |
859 | pps_intcnt = 0; | |
860 | } | |
861 | } | |
862 | } | |
863 | ||
864 | /* update clock frequency based on MONOTONIC_RAW clock PPS signal | |
865 | * timestamps | |
866 | * | |
867 | * At the end of the calibration interval the difference between the | |
868 | * first and last MONOTONIC_RAW clock timestamps divided by the length | |
869 | * of the interval becomes the frequency update. If the interval was | |
870 | * too long, the data are discarded. | |
871 | * Returns the difference between old and new frequency values. | |
872 | */ | |
873 | static long hardpps_update_freq(struct pps_normtime freq_norm) | |
874 | { | |
875 | long delta, delta_mod; | |
876 | s64 ftemp; | |
877 | ||
878 | /* check if the frequency interval was too long */ | |
879 | if (freq_norm.sec > (2 << pps_shift)) { | |
880 | time_status |= STA_PPSERROR; | |
881 | pps_errcnt++; | |
882 | pps_dec_freq_interval(); | |
883 | printk_deferred(KERN_ERR | |
884 | "hardpps: PPSERROR: interval too long - %lld s\n", | |
885 | freq_norm.sec); | |
886 | return 0; | |
887 | } | |
888 | ||
889 | /* here the raw frequency offset and wander (stability) is | |
890 | * calculated. If the wander is less than the wander threshold | |
891 | * the interval is increased; otherwise it is decreased. | |
892 | */ | |
893 | ftemp = div_s64(((s64)(-freq_norm.nsec)) << NTP_SCALE_SHIFT, | |
894 | freq_norm.sec); | |
895 | delta = shift_right(ftemp - pps_freq, NTP_SCALE_SHIFT); | |
896 | pps_freq = ftemp; | |
897 | if (delta > PPS_MAXWANDER || delta < -PPS_MAXWANDER) { | |
898 | printk_deferred(KERN_WARNING | |
899 | "hardpps: PPSWANDER: change=%ld\n", delta); | |
900 | time_status |= STA_PPSWANDER; | |
901 | pps_stbcnt++; | |
902 | pps_dec_freq_interval(); | |
903 | } else { /* good sample */ | |
904 | pps_inc_freq_interval(); | |
905 | } | |
906 | ||
907 | /* the stability metric is calculated as the average of recent | |
908 | * frequency changes, but is used only for performance | |
909 | * monitoring | |
910 | */ | |
911 | delta_mod = delta; | |
912 | if (delta_mod < 0) | |
913 | delta_mod = -delta_mod; | |
914 | pps_stabil += (div_s64(((s64)delta_mod) << | |
915 | (NTP_SCALE_SHIFT - SHIFT_USEC), | |
916 | NSEC_PER_USEC) - pps_stabil) >> PPS_INTMIN; | |
917 | ||
918 | /* if enabled, the system clock frequency is updated */ | |
919 | if ((time_status & STA_PPSFREQ) != 0 && | |
920 | (time_status & STA_FREQHOLD) == 0) { | |
921 | time_freq = pps_freq; | |
922 | ntp_update_frequency(); | |
923 | } | |
924 | ||
925 | return delta; | |
926 | } | |
927 | ||
928 | /* correct REALTIME clock phase error against PPS signal */ | |
929 | static void hardpps_update_phase(long error) | |
930 | { | |
931 | long correction = -error; | |
932 | long jitter; | |
933 | ||
934 | /* add the sample to the median filter */ | |
935 | pps_phase_filter_add(correction); | |
936 | correction = pps_phase_filter_get(&jitter); | |
937 | ||
938 | /* Nominal jitter is due to PPS signal noise. If it exceeds the | |
939 | * threshold, the sample is discarded; otherwise, if so enabled, | |
940 | * the time offset is updated. | |
941 | */ | |
942 | if (jitter > (pps_jitter << PPS_POPCORN)) { | |
943 | printk_deferred(KERN_WARNING | |
944 | "hardpps: PPSJITTER: jitter=%ld, limit=%ld\n", | |
945 | jitter, (pps_jitter << PPS_POPCORN)); | |
946 | time_status |= STA_PPSJITTER; | |
947 | pps_jitcnt++; | |
948 | } else if (time_status & STA_PPSTIME) { | |
949 | /* correct the time using the phase offset */ | |
950 | time_offset = div_s64(((s64)correction) << NTP_SCALE_SHIFT, | |
951 | NTP_INTERVAL_FREQ); | |
952 | /* cancel running adjtime() */ | |
953 | time_adjust = 0; | |
954 | } | |
955 | /* update jitter */ | |
956 | pps_jitter += (jitter - pps_jitter) >> PPS_INTMIN; | |
957 | } | |
958 | ||
959 | /* | |
960 | * __hardpps() - discipline CPU clock oscillator to external PPS signal | |
961 | * | |
962 | * This routine is called at each PPS signal arrival in order to | |
963 | * discipline the CPU clock oscillator to the PPS signal. It takes two | |
964 | * parameters: REALTIME and MONOTONIC_RAW clock timestamps. The former | |
965 | * is used to correct clock phase error and the latter is used to | |
966 | * correct the frequency. | |
967 | * | |
968 | * This code is based on David Mills's reference nanokernel | |
969 | * implementation. It was mostly rewritten but keeps the same idea. | |
970 | */ | |
971 | void __hardpps(const struct timespec64 *phase_ts, const struct timespec64 *raw_ts) | |
972 | { | |
973 | struct pps_normtime pts_norm, freq_norm; | |
974 | ||
975 | pts_norm = pps_normalize_ts(*phase_ts); | |
976 | ||
977 | /* clear the error bits, they will be set again if needed */ | |
978 | time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR); | |
979 | ||
980 | /* indicate signal presence */ | |
981 | time_status |= STA_PPSSIGNAL; | |
982 | pps_valid = PPS_VALID; | |
983 | ||
984 | /* when called for the first time, | |
985 | * just start the frequency interval */ | |
986 | if (unlikely(pps_fbase.tv_sec == 0)) { | |
987 | pps_fbase = *raw_ts; | |
988 | return; | |
989 | } | |
990 | ||
991 | /* ok, now we have a base for frequency calculation */ | |
992 | freq_norm = pps_normalize_ts(timespec64_sub(*raw_ts, pps_fbase)); | |
993 | ||
994 | /* check that the signal is in the range | |
995 | * [1s - MAXFREQ us, 1s + MAXFREQ us], otherwise reject it */ | |
996 | if ((freq_norm.sec == 0) || | |
997 | (freq_norm.nsec > MAXFREQ * freq_norm.sec) || | |
998 | (freq_norm.nsec < -MAXFREQ * freq_norm.sec)) { | |
999 | time_status |= STA_PPSJITTER; | |
1000 | /* restart the frequency calibration interval */ | |
1001 | pps_fbase = *raw_ts; | |
1002 | printk_deferred(KERN_ERR "hardpps: PPSJITTER: bad pulse\n"); | |
1003 | return; | |
1004 | } | |
1005 | ||
1006 | /* signal is ok */ | |
1007 | ||
1008 | /* check if the current frequency interval is finished */ | |
1009 | if (freq_norm.sec >= (1 << pps_shift)) { | |
1010 | pps_calcnt++; | |
1011 | /* restart the frequency calibration interval */ | |
1012 | pps_fbase = *raw_ts; | |
1013 | hardpps_update_freq(freq_norm); | |
1014 | } | |
1015 | ||
1016 | hardpps_update_phase(pts_norm.nsec); | |
1017 | ||
1018 | } | |
1019 | #endif /* CONFIG_NTP_PPS */ | |
1020 | ||
1021 | static int __init ntp_tick_adj_setup(char *str) | |
1022 | { | |
1023 | int rc = kstrtos64(str, 0, &ntp_tick_adj); | |
1024 | if (rc) | |
1025 | return rc; | |
1026 | ||
1027 | ntp_tick_adj <<= NTP_SCALE_SHIFT; | |
1028 | return 1; | |
1029 | } | |
1030 | ||
1031 | __setup("ntp_tick_adj=", ntp_tick_adj_setup); | |
1032 | ||
1033 | void __init ntp_init(void) | |
1034 | { | |
1035 | ntp_clear(); | |
1036 | } |