xref: /linux/kernel/time/ntp.c (revision b8bb76713ec50df2f11efee386e16f93d51e1076) 
1 /*
2  * NTP state machine interfaces and logic.
3  *
4  * This code was mainly moved from kernel/timer.c and kernel/time.c
5  * Please see those files for relevant copyright info and historical
6  * changelogs.
7  */
8 #include <linux/capability.h>
9 #include <linux/clocksource.h>
10 #include <linux/workqueue.h>
11 #include <linux/hrtimer.h>
12 #include <linux/jiffies.h>
13 #include <linux/math64.h>
14 #include <linux/timex.h>
15 #include <linux/time.h>
16 #include <linux/mm.h>
17 
18 /*
19  * NTP timekeeping variables:
20  */
21 
22 /* USER_HZ period (usecs): */
23 unsigned long			tick_usec = TICK_USEC;
24 
25 /* ACTHZ period (nsecs): */
26 unsigned long			tick_nsec;
27 
28 u64				tick_length;
29 static u64			tick_length_base;
30 
31 static struct hrtimer		leap_timer;
32 
33 #define MAX_TICKADJ		500LL		/* usecs */
34 #define MAX_TICKADJ_SCALED \
35 	(((MAX_TICKADJ * NSEC_PER_USEC) << NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ)
36 
37 /*
38  * phase-lock loop variables
39  */
40 
41 /*
42  * clock synchronization status
43  *
44  * (TIME_ERROR prevents overwriting the CMOS clock)
45  */
46 static int			time_state = TIME_OK;
47 
48 /* clock status bits:							*/
49 int				time_status = STA_UNSYNC;
50 
51 /* TAI offset (secs):							*/
52 static long			time_tai;
53 
54 /* time adjustment (nsecs):						*/
55 static s64			time_offset;
56 
57 /* pll time constant:							*/
58 static long			time_constant = 2;
59 
60 /* maximum error (usecs):						*/
61 long				time_maxerror = NTP_PHASE_LIMIT;
62 
63 /* estimated error (usecs):						*/
64 long				time_esterror = NTP_PHASE_LIMIT;
65 
66 /* frequency offset (scaled nsecs/secs):				*/
67 static s64			time_freq;
68 
69 /* time at last adjustment (secs):					*/
70 static long			time_reftime;
71 
72 long				time_adjust;
73 
74 /* constant (boot-param configurable) NTP tick adjustment (upscaled)	*/
75 static s64			ntp_tick_adj;
76 
77 /*
78  * NTP methods:
79  */
80 
81 /*
82  * Update (tick_length, tick_length_base, tick_nsec), based
83  * on (tick_usec, ntp_tick_adj, time_freq):
84  */
85 static void ntp_update_frequency(void)
86 {
87 	u64 second_length;
88 	u64 new_base;
89 
90 	second_length		 = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ)
91 						<< NTP_SCALE_SHIFT;
92 
93 	second_length		+= ntp_tick_adj;
94 	second_length		+= time_freq;
95 
96 	tick_nsec		 = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
97 	new_base		 = div_u64(second_length, NTP_INTERVAL_FREQ);
98 
99 	/*
100 	 * Don't wait for the next second_overflow, apply
101 	 * the change to the tick length immediately:
102 	 */
103 	tick_length		+= new_base - tick_length_base;
104 	tick_length_base	 = new_base;
105 }
106 
107 static inline s64 ntp_update_offset_fll(s64 offset64, long secs)
108 {
109 	time_status &= ~STA_MODE;
110 
111 	if (secs < MINSEC)
112 		return 0;
113 
114 	if (!(time_status & STA_FLL) && (secs <= MAXSEC))
115 		return 0;
116 
117 	time_status |= STA_MODE;
118 
119 	return div_s64(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs);
120 }
121 
122 static void ntp_update_offset(long offset)
123 {
124 	s64 freq_adj;
125 	s64 offset64;
126 	long secs;
127 
128 	if (!(time_status & STA_PLL))
129 		return;
130 
131 	if (!(time_status & STA_NANO))
132 		offset *= NSEC_PER_USEC;
133 
134 	/*
135 	 * Scale the phase adjustment and
136 	 * clamp to the operating range.
137 	 */
138 	offset = min(offset, MAXPHASE);
139 	offset = max(offset, -MAXPHASE);
140 
141 	/*
142 	 * Select how the frequency is to be controlled
143 	 * and in which mode (PLL or FLL).
144 	 */
145 	secs = xtime.tv_sec - time_reftime;
146 	if (unlikely(time_status & STA_FREQHOLD))
147 		secs = 0;
148 
149 	time_reftime = xtime.tv_sec;
150 
151 	offset64    = offset;
152 	freq_adj    = (offset64 * secs) <<
153 			(NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant));
154 
155 	freq_adj    += ntp_update_offset_fll(offset64, secs);
156 
157 	freq_adj    = min(freq_adj + time_freq, MAXFREQ_SCALED);
158 
159 	time_freq   = max(freq_adj, -MAXFREQ_SCALED);
160 
161 	time_offset = div_s64(offset64 << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ);
162 }
163 
164 /**
165  * ntp_clear - Clears the NTP state variables
166  *
167  * Must be called while holding a write on the xtime_lock
168  */
169 void ntp_clear(void)
170 {
171 	time_adjust	= 0;		/* stop active adjtime() */
172 	time_status	|= STA_UNSYNC;
173 	time_maxerror	= NTP_PHASE_LIMIT;
174 	time_esterror	= NTP_PHASE_LIMIT;
175 
176 	ntp_update_frequency();
177 
178 	tick_length	= tick_length_base;
179 	time_offset	= 0;
180 }
181 
182 /*
183  * Leap second processing. If in leap-insert state at the end of the
184  * day, the system clock is set back one second; if in leap-delete
185  * state, the system clock is set ahead one second.
186  */
187 static enum hrtimer_restart ntp_leap_second(struct hrtimer *timer)
188 {
189 	enum hrtimer_restart res = HRTIMER_NORESTART;
190 
191 	write_seqlock(&xtime_lock);
192 
193 	switch (time_state) {
194 	case TIME_OK:
195 		break;
196 	case TIME_INS:
197 		xtime.tv_sec--;
198 		wall_to_monotonic.tv_sec++;
199 		time_state = TIME_OOP;
200 		printk(KERN_NOTICE
201 			"Clock: inserting leap second 23:59:60 UTC\n");
202 		hrtimer_add_expires_ns(&leap_timer, NSEC_PER_SEC);
203 		res = HRTIMER_RESTART;
204 		break;
205 	case TIME_DEL:
206 		xtime.tv_sec++;
207 		time_tai--;
208 		wall_to_monotonic.tv_sec--;
209 		time_state = TIME_WAIT;
210 		printk(KERN_NOTICE
211 			"Clock: deleting leap second 23:59:59 UTC\n");
212 		break;
213 	case TIME_OOP:
214 		time_tai++;
215 		time_state = TIME_WAIT;
216 		/* fall through */
217 	case TIME_WAIT:
218 		if (!(time_status & (STA_INS | STA_DEL)))
219 			time_state = TIME_OK;
220 		break;
221 	}
222 	update_vsyscall(&xtime, clock);
223 
224 	write_sequnlock(&xtime_lock);
225 
226 	return res;
227 }
228 
229 /*
230  * this routine handles the overflow of the microsecond field
231  *
232  * The tricky bits of code to handle the accurate clock support
233  * were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame.
234  * They were originally developed for SUN and DEC kernels.
235  * All the kudos should go to Dave for this stuff.
236  */
237 void second_overflow(void)
238 {
239 	s64 delta;
240 
241 	/* Bump the maxerror field */
242 	time_maxerror += MAXFREQ / NSEC_PER_USEC;
243 	if (time_maxerror > NTP_PHASE_LIMIT) {
244 		time_maxerror = NTP_PHASE_LIMIT;
245 		time_status |= STA_UNSYNC;
246 	}
247 
248 	/*
249 	 * Compute the phase adjustment for the next second. The offset is
250 	 * reduced by a fixed factor times the time constant.
251 	 */
252 	tick_length	 = tick_length_base;
253 
254 	delta		 = shift_right(time_offset, SHIFT_PLL + time_constant);
255 	time_offset	-= delta;
256 	tick_length	+= delta;
257 
258 	if (!time_adjust)
259 		return;
260 
261 	if (time_adjust > MAX_TICKADJ) {
262 		time_adjust -= MAX_TICKADJ;
263 		tick_length += MAX_TICKADJ_SCALED;
264 		return;
265 	}
266 
267 	if (time_adjust < -MAX_TICKADJ) {
268 		time_adjust += MAX_TICKADJ;
269 		tick_length -= MAX_TICKADJ_SCALED;
270 		return;
271 	}
272 
273 	tick_length += (s64)(time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)
274 							 << NTP_SCALE_SHIFT;
275 	time_adjust = 0;
276 }
277 
278 #ifdef CONFIG_GENERIC_CMOS_UPDATE
279 
280 /* Disable the cmos update - used by virtualization and embedded */
281 int no_sync_cmos_clock  __read_mostly;
282 
283 static void sync_cmos_clock(struct work_struct *work);
284 
285 static DECLARE_DELAYED_WORK(sync_cmos_work, sync_cmos_clock);
286 
287 static void sync_cmos_clock(struct work_struct *work)
288 {
289 	struct timespec now, next;
290 	int fail = 1;
291 
292 	/*
293 	 * If we have an externally synchronized Linux clock, then update
294 	 * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
295 	 * called as close as possible to 500 ms before the new second starts.
296 	 * This code is run on a timer.  If the clock is set, that timer
297 	 * may not expire at the correct time.  Thus, we adjust...
298 	 */
299 	if (!ntp_synced()) {
300 		/*
301 		 * Not synced, exit, do not restart a timer (if one is
302 		 * running, let it run out).
303 		 */
304 		return;
305 	}
306 
307 	getnstimeofday(&now);
308 	if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2)
309 		fail = update_persistent_clock(now);
310 
311 	next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec - (TICK_NSEC / 2);
312 	if (next.tv_nsec <= 0)
313 		next.tv_nsec += NSEC_PER_SEC;
314 
315 	if (!fail)
316 		next.tv_sec = 659;
317 	else
318 		next.tv_sec = 0;
319 
320 	if (next.tv_nsec >= NSEC_PER_SEC) {
321 		next.tv_sec++;
322 		next.tv_nsec -= NSEC_PER_SEC;
323 	}
324 	schedule_delayed_work(&sync_cmos_work, timespec_to_jiffies(&next));
325 }
326 
327 static void notify_cmos_timer(void)
328 {
329 	if (!no_sync_cmos_clock)
330 		schedule_delayed_work(&sync_cmos_work, 0);
331 }
332 
333 #else
334 static inline void notify_cmos_timer(void) { }
335 #endif
336 
337 /*
338  * Start the leap seconds timer:
339  */
340 static inline void ntp_start_leap_timer(struct timespec *ts)
341 {
342 	long now = ts->tv_sec;
343 
344 	if (time_status & STA_INS) {
345 		time_state = TIME_INS;
346 		now += 86400 - now % 86400;
347 		hrtimer_start(&leap_timer, ktime_set(now, 0), HRTIMER_MODE_ABS);
348 
349 		return;
350 	}
351 
352 	if (time_status & STA_DEL) {
353 		time_state = TIME_DEL;
354 		now += 86400 - (now + 1) % 86400;
355 		hrtimer_start(&leap_timer, ktime_set(now, 0), HRTIMER_MODE_ABS);
356 	}
357 }
358 
359 /*
360  * Propagate a new txc->status value into the NTP state:
361  */
362 static inline void process_adj_status(struct timex *txc, struct timespec *ts)
363 {
364 	if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) {
365 		time_state = TIME_OK;
366 		time_status = STA_UNSYNC;
367 	}
368 
369 	/*
370 	 * If we turn on PLL adjustments then reset the
371 	 * reference time to current time.
372 	 */
373 	if (!(time_status & STA_PLL) && (txc->status & STA_PLL))
374 		time_reftime = xtime.tv_sec;
375 
376 	/* only set allowed bits */
377 	time_status &= STA_RONLY;
378 	time_status |= txc->status & ~STA_RONLY;
379 
380 	switch (time_state) {
381 	case TIME_OK:
382 		ntp_start_leap_timer(ts);
383 		break;
384 	case TIME_INS:
385 	case TIME_DEL:
386 		time_state = TIME_OK;
387 		ntp_start_leap_timer(ts);
388 	case TIME_WAIT:
389 		if (!(time_status & (STA_INS | STA_DEL)))
390 			time_state = TIME_OK;
391 		break;
392 	case TIME_OOP:
393 		hrtimer_restart(&leap_timer);
394 		break;
395 	}
396 }
397 /*
398  * Called with the xtime lock held, so we can access and modify
399  * all the global NTP state:
400  */
401 static inline void process_adjtimex_modes(struct timex *txc, struct timespec *ts)
402 {
403 	if (txc->modes & ADJ_STATUS)
404 		process_adj_status(txc, ts);
405 
406 	if (txc->modes & ADJ_NANO)
407 		time_status |= STA_NANO;
408 
409 	if (txc->modes & ADJ_MICRO)
410 		time_status &= ~STA_NANO;
411 
412 	if (txc->modes & ADJ_FREQUENCY) {
413 		time_freq = txc->freq * PPM_SCALE;
414 		time_freq = min(time_freq, MAXFREQ_SCALED);
415 		time_freq = max(time_freq, -MAXFREQ_SCALED);
416 	}
417 
418 	if (txc->modes & ADJ_MAXERROR)
419 		time_maxerror = txc->maxerror;
420 
421 	if (txc->modes & ADJ_ESTERROR)
422 		time_esterror = txc->esterror;
423 
424 	if (txc->modes & ADJ_TIMECONST) {
425 		time_constant = txc->constant;
426 		if (!(time_status & STA_NANO))
427 			time_constant += 4;
428 		time_constant = min(time_constant, (long)MAXTC);
429 		time_constant = max(time_constant, 0l);
430 	}
431 
432 	if (txc->modes & ADJ_TAI && txc->constant > 0)
433 		time_tai = txc->constant;
434 
435 	if (txc->modes & ADJ_OFFSET)
436 		ntp_update_offset(txc->offset);
437 
438 	if (txc->modes & ADJ_TICK)
439 		tick_usec = txc->tick;
440 
441 	if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET))
442 		ntp_update_frequency();
443 }
444 
445 /*
446  * adjtimex mainly allows reading (and writing, if superuser) of
447  * kernel time-keeping variables. used by xntpd.
448  */
449 int do_adjtimex(struct timex *txc)
450 {
451 	struct timespec ts;
452 	int result;
453 
454 	/* Validate the data before disabling interrupts */
455 	if (txc->modes & ADJ_ADJTIME) {
456 		/* singleshot must not be used with any other mode bits */
457 		if (!(txc->modes & ADJ_OFFSET_SINGLESHOT))
458 			return -EINVAL;
459 		if (!(txc->modes & ADJ_OFFSET_READONLY) &&
460 		    !capable(CAP_SYS_TIME))
461 			return -EPERM;
462 	} else {
463 		/* In order to modify anything, you gotta be super-user! */
464 		 if (txc->modes && !capable(CAP_SYS_TIME))
465 			return -EPERM;
466 
467 		/*
468 		 * if the quartz is off by more than 10% then
469 		 * something is VERY wrong!
470 		 */
471 		if (txc->modes & ADJ_TICK &&
472 		    (txc->tick <  900000/USER_HZ ||
473 		     txc->tick > 1100000/USER_HZ))
474 			return -EINVAL;
475 
476 		if (txc->modes & ADJ_STATUS && time_state != TIME_OK)
477 			hrtimer_cancel(&leap_timer);
478 	}
479 
480 	getnstimeofday(&ts);
481 
482 	write_seqlock_irq(&xtime_lock);
483 
484 	if (txc->modes & ADJ_ADJTIME) {
485 		long save_adjust = time_adjust;
486 
487 		if (!(txc->modes & ADJ_OFFSET_READONLY)) {
488 			/* adjtime() is independent from ntp_adjtime() */
489 			time_adjust = txc->offset;
490 			ntp_update_frequency();
491 		}
492 		txc->offset = save_adjust;
493 	} else {
494 
495 		/* If there are input parameters, then process them: */
496 		if (txc->modes)
497 			process_adjtimex_modes(txc, &ts);
498 
499 		txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
500 				  NTP_SCALE_SHIFT);
501 		if (!(time_status & STA_NANO))
502 			txc->offset /= NSEC_PER_USEC;
503 	}
504 
505 	result = time_state;	/* mostly `TIME_OK' */
506 	if (time_status & (STA_UNSYNC|STA_CLOCKERR))
507 		result = TIME_ERROR;
508 
509 	txc->freq	   = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) *
510 					 PPM_SCALE_INV, NTP_SCALE_SHIFT);
511 	txc->maxerror	   = time_maxerror;
512 	txc->esterror	   = time_esterror;
513 	txc->status	   = time_status;
514 	txc->constant	   = time_constant;
515 	txc->precision	   = 1;
516 	txc->tolerance	   = MAXFREQ_SCALED / PPM_SCALE;
517 	txc->tick	   = tick_usec;
518 	txc->tai	   = time_tai;
519 
520 	/* PPS is not implemented, so these are zero */
521 	txc->ppsfreq	   = 0;
522 	txc->jitter	   = 0;
523 	txc->shift	   = 0;
524 	txc->stabil	   = 0;
525 	txc->jitcnt	   = 0;
526 	txc->calcnt	   = 0;
527 	txc->errcnt	   = 0;
528 	txc->stbcnt	   = 0;
529 
530 	write_sequnlock_irq(&xtime_lock);
531 
532 	txc->time.tv_sec = ts.tv_sec;
533 	txc->time.tv_usec = ts.tv_nsec;
534 	if (!(time_status & STA_NANO))
535 		txc->time.tv_usec /= NSEC_PER_USEC;
536 
537 	notify_cmos_timer();
538 
539 	return result;
540 }
541 
542 static int __init ntp_tick_adj_setup(char *str)
543 {
544 	ntp_tick_adj = simple_strtol(str, NULL, 0);
545 	ntp_tick_adj <<= NTP_SCALE_SHIFT;
546 
547 	return 1;
548 }
549 
550 __setup("ntp_tick_adj=", ntp_tick_adj_setup);
551 
552 void __init ntp_init(void)
553 {
554 	ntp_clear();
555 	hrtimer_init(&leap_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
556 	leap_timer.function = ntp_leap_second;
557 }
558