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