blob: d2321891538f53425430565fe68197b5cde93d12 [file] [log] [blame]
john stultz4c7ee8d2006-09-30 23:28:22 -07001/*
john stultz4c7ee8d2006-09-30 23:28:22 -07002 * 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 */
Alexey Dobriyanaa0ac362007-07-15 23:40:39 -07008#include <linux/capability.h>
Roman Zippel7dffa3c2008-05-01 04:34:41 -07009#include <linux/clocksource.h>
Maciej W. Rozyckieb3f9382008-09-22 14:42:40 -070010#include <linux/workqueue.h>
Ingo Molnar53bbfa92008-02-20 07:58:42 +010011#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>
john stultz4c7ee8d2006-09-30 23:28:22 -070017
Roman Zippelb0ee7552006-09-30 23:28:22 -070018/*
Ingo Molnar53bbfa92008-02-20 07:58:42 +010019 * NTP timekeeping variables:
Roman Zippelb0ee7552006-09-30 23:28:22 -070020 */
Roman Zippelb0ee7552006-09-30 23:28:22 -070021
Ingo Molnar53bbfa92008-02-20 07:58:42 +010022/* USER_HZ period (usecs): */
23unsigned long tick_usec = TICK_USEC;
Roman Zippel7dffa3c2008-05-01 04:34:41 -070024
Ingo Molnar53bbfa92008-02-20 07:58:42 +010025/* ACTHZ period (nsecs): */
26unsigned long tick_nsec;
27
28u64 tick_length;
29static u64 tick_length_base;
30
31static struct hrtimer leap_timer;
32
Ingo Molnarbbd12672009-02-22 12:11:11 +010033#define MAX_TICKADJ 500LL /* usecs */
Ingo Molnar53bbfa92008-02-20 07:58:42 +010034#define MAX_TICKADJ_SCALED \
Ingo Molnarbbd12672009-02-22 12:11:11 +010035 (((MAX_TICKADJ * NSEC_PER_USEC) << NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ)
john stultz4c7ee8d2006-09-30 23:28:22 -070036
37/*
38 * phase-lock loop variables
39 */
Ingo Molnar53bbfa92008-02-20 07:58:42 +010040
41/*
42 * clock synchronization status
43 *
44 * (TIME_ERROR prevents overwriting the CMOS clock)
45 */
46static int time_state = TIME_OK;
47
48/* clock status bits: */
49int time_status = STA_UNSYNC;
50
51/* TAI offset (secs): */
52static long time_tai;
53
54/* time adjustment (nsecs): */
55static s64 time_offset;
56
57/* pll time constant: */
58static long time_constant = 2;
59
60/* maximum error (usecs): */
john stultz1f5b8f82010-01-28 15:02:41 -080061static long time_maxerror = NTP_PHASE_LIMIT;
Ingo Molnar53bbfa92008-02-20 07:58:42 +010062
63/* estimated error (usecs): */
john stultz1f5b8f82010-01-28 15:02:41 -080064static long time_esterror = NTP_PHASE_LIMIT;
Ingo Molnar53bbfa92008-02-20 07:58:42 +010065
66/* frequency offset (scaled nsecs/secs): */
67static s64 time_freq;
68
69/* time at last adjustment (secs): */
70static long time_reftime;
71
John Stultze1292ba2010-03-18 20:19:27 -070072static long time_adjust;
Ingo Molnar53bbfa92008-02-20 07:58:42 +010073
Ingo Molnar069569e2009-02-22 16:03:37 +010074/* constant (boot-param configurable) NTP tick adjustment (upscaled) */
75static s64 ntp_tick_adj;
Ingo Molnar53bbfa92008-02-20 07:58:42 +010076
77/*
78 * NTP methods:
79 */
john stultz4c7ee8d2006-09-30 23:28:22 -070080
Ingo Molnar9ce616a2009-02-22 12:42:59 +010081/*
82 * Update (tick_length, tick_length_base, tick_nsec), based
83 * on (tick_usec, ntp_tick_adj, time_freq):
84 */
Adrian Bunk70bc42f2006-09-30 23:28:29 -070085static void ntp_update_frequency(void)
86{
Ingo Molnar9ce616a2009-02-22 12:42:59 +010087 u64 second_length;
Ingo Molnarbc26c312009-02-22 12:17:36 +010088 u64 new_base;
Adrian Bunk70bc42f2006-09-30 23:28:29 -070089
Ingo Molnar9ce616a2009-02-22 12:42:59 +010090 second_length = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ)
91 << NTP_SCALE_SHIFT;
92
Ingo Molnar069569e2009-02-22 16:03:37 +010093 second_length += ntp_tick_adj;
Ingo Molnar9ce616a2009-02-22 12:42:59 +010094 second_length += time_freq;
95
Ingo Molnar9ce616a2009-02-22 12:42:59 +010096 tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
Ingo Molnarbc26c312009-02-22 12:17:36 +010097 new_base = div_u64(second_length, NTP_INTERVAL_FREQ);
john stultzfdcedf72009-02-18 16:02:22 -080098
99 /*
100 * Don't wait for the next second_overflow, apply
Ingo Molnarbc26c312009-02-22 12:17:36 +0100101 * the change to the tick length immediately:
john stultzfdcedf72009-02-18 16:02:22 -0800102 */
Ingo Molnarbc26c312009-02-22 12:17:36 +0100103 tick_length += new_base - tick_length_base;
104 tick_length_base = new_base;
Adrian Bunk70bc42f2006-09-30 23:28:29 -0700105}
106
Ingo Molnar478b7aa2009-02-22 13:22:23 +0100107static inline s64 ntp_update_offset_fll(s64 offset64, long secs)
Ingo Molnarf9398902009-02-22 12:57:49 +0100108{
109 time_status &= ~STA_MODE;
110
111 if (secs < MINSEC)
Ingo Molnar478b7aa2009-02-22 13:22:23 +0100112 return 0;
Ingo Molnarf9398902009-02-22 12:57:49 +0100113
114 if (!(time_status & STA_FLL) && (secs <= MAXSEC))
Ingo Molnar478b7aa2009-02-22 13:22:23 +0100115 return 0;
Ingo Molnarf9398902009-02-22 12:57:49 +0100116
Ingo Molnarf9398902009-02-22 12:57:49 +0100117 time_status |= STA_MODE;
118
Ingo Molnar478b7aa2009-02-22 13:22:23 +0100119 return div_s64(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs);
Ingo Molnarf9398902009-02-22 12:57:49 +0100120}
121
Roman Zippelee9851b2008-05-01 04:34:32 -0700122static void ntp_update_offset(long offset)
123{
Roman Zippelee9851b2008-05-01 04:34:32 -0700124 s64 freq_adj;
Ingo Molnarf9398902009-02-22 12:57:49 +0100125 s64 offset64;
126 long secs;
Roman Zippelee9851b2008-05-01 04:34:32 -0700127
128 if (!(time_status & STA_PLL))
129 return;
130
Roman Zippeleea83d82008-05-01 04:34:33 -0700131 if (!(time_status & STA_NANO))
Roman Zippel9f14f662008-05-01 04:34:36 -0700132 offset *= NSEC_PER_USEC;
Roman Zippelee9851b2008-05-01 04:34:32 -0700133
134 /*
135 * Scale the phase adjustment and
136 * clamp to the operating range.
137 */
Roman Zippel9f14f662008-05-01 04:34:36 -0700138 offset = min(offset, MAXPHASE);
139 offset = max(offset, -MAXPHASE);
Roman Zippelee9851b2008-05-01 04:34:32 -0700140
141 /*
142 * Select how the frequency is to be controlled
143 * and in which mode (PLL or FLL).
144 */
John Stultz7e1b5842010-01-28 20:20:44 -0800145 secs = get_seconds() - time_reftime;
Ingo Molnar10dd31a2009-02-22 13:38:40 +0100146 if (unlikely(time_status & STA_FREQHOLD))
Ingo Molnarc7986ac2009-02-22 13:29:09 +0100147 secs = 0;
148
John Stultz7e1b5842010-01-28 20:20:44 -0800149 time_reftime = get_seconds();
Roman Zippelee9851b2008-05-01 04:34:32 -0700150
Ingo Molnarf9398902009-02-22 12:57:49 +0100151 offset64 = offset;
Miroslav Lichvar8af3c152010-09-07 16:43:46 +0200152 freq_adj = ntp_update_offset_fll(offset64, secs);
Roman Zippel9f14f662008-05-01 04:34:36 -0700153
Miroslav Lichvar8af3c152010-09-07 16:43:46 +0200154 /*
155 * Clamp update interval to reduce PLL gain with low
156 * sampling rate (e.g. intermittent network connection)
157 * to avoid instability.
158 */
159 if (unlikely(secs > 1 << (SHIFT_PLL + 1 + time_constant)))
160 secs = 1 << (SHIFT_PLL + 1 + time_constant);
161
162 freq_adj += (offset64 * secs) <<
163 (NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant));
Ingo Molnarf9398902009-02-22 12:57:49 +0100164
165 freq_adj = min(freq_adj + time_freq, MAXFREQ_SCALED);
166
167 time_freq = max(freq_adj, -MAXFREQ_SCALED);
168
169 time_offset = div_s64(offset64 << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ);
Roman Zippelee9851b2008-05-01 04:34:32 -0700170}
171
Roman Zippelb0ee7552006-09-30 23:28:22 -0700172/**
173 * ntp_clear - Clears the NTP state variables
174 *
175 * Must be called while holding a write on the xtime_lock
176 */
177void ntp_clear(void)
178{
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100179 time_adjust = 0; /* stop active adjtime() */
180 time_status |= STA_UNSYNC;
181 time_maxerror = NTP_PHASE_LIMIT;
182 time_esterror = NTP_PHASE_LIMIT;
Roman Zippelb0ee7552006-09-30 23:28:22 -0700183
184 ntp_update_frequency();
185
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100186 tick_length = tick_length_base;
187 time_offset = 0;
Roman Zippelb0ee7552006-09-30 23:28:22 -0700188}
189
john stultz4c7ee8d2006-09-30 23:28:22 -0700190/*
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700191 * Leap second processing. If in leap-insert state at the end of the
192 * day, the system clock is set back one second; if in leap-delete
193 * state, the system clock is set ahead one second.
194 */
195static enum hrtimer_restart ntp_leap_second(struct hrtimer *timer)
196{
197 enum hrtimer_restart res = HRTIMER_NORESTART;
198
Peter Zijlstraca109492008-11-25 12:43:51 +0100199 write_seqlock(&xtime_lock);
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700200
201 switch (time_state) {
202 case TIME_OK:
203 break;
204 case TIME_INS:
John Stultz31089c12009-08-14 15:47:18 +0200205 timekeeping_leap_insert(-1);
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700206 time_state = TIME_OOP;
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100207 printk(KERN_NOTICE
208 "Clock: inserting leap second 23:59:60 UTC\n");
Arjan van de Vencc584b22008-09-01 15:02:30 -0700209 hrtimer_add_expires_ns(&leap_timer, NSEC_PER_SEC);
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700210 res = HRTIMER_RESTART;
211 break;
212 case TIME_DEL:
John Stultz31089c12009-08-14 15:47:18 +0200213 timekeeping_leap_insert(1);
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700214 time_tai--;
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700215 time_state = TIME_WAIT;
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100216 printk(KERN_NOTICE
217 "Clock: deleting leap second 23:59:59 UTC\n");
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700218 break;
219 case TIME_OOP:
220 time_tai++;
221 time_state = TIME_WAIT;
222 /* fall through */
223 case TIME_WAIT:
224 if (!(time_status & (STA_INS | STA_DEL)))
225 time_state = TIME_OK;
226 break;
227 }
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700228
Peter Zijlstraca109492008-11-25 12:43:51 +0100229 write_sequnlock(&xtime_lock);
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700230
231 return res;
232}
233
234/*
john stultz4c7ee8d2006-09-30 23:28:22 -0700235 * this routine handles the overflow of the microsecond field
236 *
237 * The tricky bits of code to handle the accurate clock support
238 * were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame.
239 * They were originally developed for SUN and DEC kernels.
240 * All the kudos should go to Dave for this stuff.
241 */
242void second_overflow(void)
243{
Ingo Molnar39854fe2009-02-22 16:06:58 +0100244 s64 delta;
john stultz4c7ee8d2006-09-30 23:28:22 -0700245
246 /* Bump the maxerror field */
Roman Zippel074b3b82008-05-01 04:34:34 -0700247 time_maxerror += MAXFREQ / NSEC_PER_USEC;
john stultz4c7ee8d2006-09-30 23:28:22 -0700248 if (time_maxerror > NTP_PHASE_LIMIT) {
249 time_maxerror = NTP_PHASE_LIMIT;
250 time_status |= STA_UNSYNC;
251 }
252
253 /*
Roman Zippelf1992392006-09-30 23:28:28 -0700254 * Compute the phase adjustment for the next second. The offset is
255 * reduced by a fixed factor times the time constant.
john stultz4c7ee8d2006-09-30 23:28:22 -0700256 */
Ingo Molnar39854fe2009-02-22 16:06:58 +0100257 tick_length = tick_length_base;
258
259 delta = shift_right(time_offset, SHIFT_PLL + time_constant);
260 time_offset -= delta;
261 tick_length += delta;
john stultz4c7ee8d2006-09-30 23:28:22 -0700262
Ingo Molnar3c972c22009-02-22 12:06:57 +0100263 if (!time_adjust)
264 return;
265
266 if (time_adjust > MAX_TICKADJ) {
267 time_adjust -= MAX_TICKADJ;
268 tick_length += MAX_TICKADJ_SCALED;
269 return;
john stultz4c7ee8d2006-09-30 23:28:22 -0700270 }
Ingo Molnar3c972c22009-02-22 12:06:57 +0100271
272 if (time_adjust < -MAX_TICKADJ) {
273 time_adjust += MAX_TICKADJ;
274 tick_length -= MAX_TICKADJ_SCALED;
275 return;
276 }
277
278 tick_length += (s64)(time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)
279 << NTP_SCALE_SHIFT;
280 time_adjust = 0;
john stultz4c7ee8d2006-09-30 23:28:22 -0700281}
282
Thomas Gleixner82644452007-07-21 04:37:37 -0700283#ifdef CONFIG_GENERIC_CMOS_UPDATE
john stultz4c7ee8d2006-09-30 23:28:22 -0700284
Thomas Gleixner82644452007-07-21 04:37:37 -0700285/* Disable the cmos update - used by virtualization and embedded */
286int no_sync_cmos_clock __read_mostly;
287
Maciej W. Rozyckieb3f9382008-09-22 14:42:40 -0700288static void sync_cmos_clock(struct work_struct *work);
Thomas Gleixner82644452007-07-21 04:37:37 -0700289
Maciej W. Rozyckieb3f9382008-09-22 14:42:40 -0700290static DECLARE_DELAYED_WORK(sync_cmos_work, sync_cmos_clock);
Thomas Gleixner82644452007-07-21 04:37:37 -0700291
Maciej W. Rozyckieb3f9382008-09-22 14:42:40 -0700292static void sync_cmos_clock(struct work_struct *work)
john stultz4c7ee8d2006-09-30 23:28:22 -0700293{
Thomas Gleixner82644452007-07-21 04:37:37 -0700294 struct timespec now, next;
295 int fail = 1;
296
297 /*
298 * If we have an externally synchronized Linux clock, then update
299 * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
300 * called as close as possible to 500 ms before the new second starts.
301 * This code is run on a timer. If the clock is set, that timer
302 * may not expire at the correct time. Thus, we adjust...
303 */
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100304 if (!ntp_synced()) {
Thomas Gleixner82644452007-07-21 04:37:37 -0700305 /*
306 * Not synced, exit, do not restart a timer (if one is
307 * running, let it run out).
308 */
309 return;
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100310 }
Thomas Gleixner82644452007-07-21 04:37:37 -0700311
312 getnstimeofday(&now);
David P. Reedfa6a1a52007-11-14 17:49:21 -0500313 if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2)
Thomas Gleixner82644452007-07-21 04:37:37 -0700314 fail = update_persistent_clock(now);
315
Maciej W. Rozycki4ff4b9e2008-09-05 14:05:31 -0700316 next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec - (TICK_NSEC / 2);
Thomas Gleixner82644452007-07-21 04:37:37 -0700317 if (next.tv_nsec <= 0)
318 next.tv_nsec += NSEC_PER_SEC;
319
320 if (!fail)
321 next.tv_sec = 659;
322 else
323 next.tv_sec = 0;
324
325 if (next.tv_nsec >= NSEC_PER_SEC) {
326 next.tv_sec++;
327 next.tv_nsec -= NSEC_PER_SEC;
328 }
Maciej W. Rozyckieb3f9382008-09-22 14:42:40 -0700329 schedule_delayed_work(&sync_cmos_work, timespec_to_jiffies(&next));
john stultz4c7ee8d2006-09-30 23:28:22 -0700330}
331
Thomas Gleixner82644452007-07-21 04:37:37 -0700332static void notify_cmos_timer(void)
333{
Tony Breeds298a5df2007-09-11 15:24:03 -0700334 if (!no_sync_cmos_clock)
Maciej W. Rozyckieb3f9382008-09-22 14:42:40 -0700335 schedule_delayed_work(&sync_cmos_work, 0);
Thomas Gleixner82644452007-07-21 04:37:37 -0700336}
337
338#else
339static inline void notify_cmos_timer(void) { }
340#endif
341
Ingo Molnare9629162009-02-22 15:35:18 +0100342/*
343 * Start the leap seconds timer:
344 */
345static inline void ntp_start_leap_timer(struct timespec *ts)
346{
347 long now = ts->tv_sec;
348
349 if (time_status & STA_INS) {
350 time_state = TIME_INS;
351 now += 86400 - now % 86400;
352 hrtimer_start(&leap_timer, ktime_set(now, 0), HRTIMER_MODE_ABS);
353
354 return;
355 }
356
357 if (time_status & STA_DEL) {
358 time_state = TIME_DEL;
359 now += 86400 - (now + 1) % 86400;
360 hrtimer_start(&leap_timer, ktime_set(now, 0), HRTIMER_MODE_ABS);
361 }
362}
Ingo Molnar80f22572009-02-22 15:15:32 +0100363
364/*
365 * Propagate a new txc->status value into the NTP state:
366 */
367static inline void process_adj_status(struct timex *txc, struct timespec *ts)
368{
Ingo Molnar80f22572009-02-22 15:15:32 +0100369 if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) {
370 time_state = TIME_OK;
371 time_status = STA_UNSYNC;
372 }
Ingo Molnar80f22572009-02-22 15:15:32 +0100373
374 /*
375 * If we turn on PLL adjustments then reset the
376 * reference time to current time.
377 */
378 if (!(time_status & STA_PLL) && (txc->status & STA_PLL))
John Stultz7e1b5842010-01-28 20:20:44 -0800379 time_reftime = get_seconds();
Ingo Molnar80f22572009-02-22 15:15:32 +0100380
John Stultza2a5ac82009-02-26 09:46:14 -0800381 /* only set allowed bits */
382 time_status &= STA_RONLY;
Ingo Molnar80f22572009-02-22 15:15:32 +0100383 time_status |= txc->status & ~STA_RONLY;
384
385 switch (time_state) {
386 case TIME_OK:
Ingo Molnare9629162009-02-22 15:35:18 +0100387 ntp_start_leap_timer(ts);
Ingo Molnar80f22572009-02-22 15:15:32 +0100388 break;
389 case TIME_INS:
390 case TIME_DEL:
391 time_state = TIME_OK;
Ingo Molnare9629162009-02-22 15:35:18 +0100392 ntp_start_leap_timer(ts);
Ingo Molnar80f22572009-02-22 15:15:32 +0100393 case TIME_WAIT:
394 if (!(time_status & (STA_INS | STA_DEL)))
395 time_state = TIME_OK;
396 break;
397 case TIME_OOP:
398 hrtimer_restart(&leap_timer);
399 break;
400 }
401}
402/*
403 * Called with the xtime lock held, so we can access and modify
404 * all the global NTP state:
405 */
406static inline void process_adjtimex_modes(struct timex *txc, struct timespec *ts)
407{
408 if (txc->modes & ADJ_STATUS)
409 process_adj_status(txc, ts);
410
411 if (txc->modes & ADJ_NANO)
412 time_status |= STA_NANO;
Ingo Molnare9629162009-02-22 15:35:18 +0100413
Ingo Molnar80f22572009-02-22 15:15:32 +0100414 if (txc->modes & ADJ_MICRO)
415 time_status &= ~STA_NANO;
416
417 if (txc->modes & ADJ_FREQUENCY) {
Ingo Molnar2b9d1492009-02-22 15:48:43 +0100418 time_freq = txc->freq * PPM_SCALE;
Ingo Molnar80f22572009-02-22 15:15:32 +0100419 time_freq = min(time_freq, MAXFREQ_SCALED);
420 time_freq = max(time_freq, -MAXFREQ_SCALED);
421 }
422
423 if (txc->modes & ADJ_MAXERROR)
424 time_maxerror = txc->maxerror;
Ingo Molnare9629162009-02-22 15:35:18 +0100425
Ingo Molnar80f22572009-02-22 15:15:32 +0100426 if (txc->modes & ADJ_ESTERROR)
427 time_esterror = txc->esterror;
428
429 if (txc->modes & ADJ_TIMECONST) {
430 time_constant = txc->constant;
431 if (!(time_status & STA_NANO))
432 time_constant += 4;
433 time_constant = min(time_constant, (long)MAXTC);
434 time_constant = max(time_constant, 0l);
435 }
436
437 if (txc->modes & ADJ_TAI && txc->constant > 0)
438 time_tai = txc->constant;
439
440 if (txc->modes & ADJ_OFFSET)
441 ntp_update_offset(txc->offset);
Ingo Molnare9629162009-02-22 15:35:18 +0100442
Ingo Molnar80f22572009-02-22 15:15:32 +0100443 if (txc->modes & ADJ_TICK)
444 tick_usec = txc->tick;
445
446 if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET))
447 ntp_update_frequency();
448}
449
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100450/*
451 * adjtimex mainly allows reading (and writing, if superuser) of
john stultz4c7ee8d2006-09-30 23:28:22 -0700452 * kernel time-keeping variables. used by xntpd.
453 */
454int do_adjtimex(struct timex *txc)
455{
Roman Zippeleea83d82008-05-01 04:34:33 -0700456 struct timespec ts;
john stultz4c7ee8d2006-09-30 23:28:22 -0700457 int result;
458
Roman Zippel916c7a82008-08-20 16:46:08 -0700459 /* Validate the data before disabling interrupts */
460 if (txc->modes & ADJ_ADJTIME) {
Roman Zippeleea83d82008-05-01 04:34:33 -0700461 /* singleshot must not be used with any other mode bits */
Roman Zippel916c7a82008-08-20 16:46:08 -0700462 if (!(txc->modes & ADJ_OFFSET_SINGLESHOT))
john stultz4c7ee8d2006-09-30 23:28:22 -0700463 return -EINVAL;
Roman Zippel916c7a82008-08-20 16:46:08 -0700464 if (!(txc->modes & ADJ_OFFSET_READONLY) &&
465 !capable(CAP_SYS_TIME))
466 return -EPERM;
467 } else {
468 /* In order to modify anything, you gotta be super-user! */
469 if (txc->modes && !capable(CAP_SYS_TIME))
470 return -EPERM;
471
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100472 /*
473 * if the quartz is off by more than 10% then
474 * something is VERY wrong!
475 */
Roman Zippel916c7a82008-08-20 16:46:08 -0700476 if (txc->modes & ADJ_TICK &&
477 (txc->tick < 900000/USER_HZ ||
478 txc->tick > 1100000/USER_HZ))
Ingo Molnare9629162009-02-22 15:35:18 +0100479 return -EINVAL;
Roman Zippel916c7a82008-08-20 16:46:08 -0700480
481 if (txc->modes & ADJ_STATUS && time_state != TIME_OK)
482 hrtimer_cancel(&leap_timer);
John Stultz52bfb362007-11-26 20:42:19 +0100483 }
john stultz4c7ee8d2006-09-30 23:28:22 -0700484
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700485 getnstimeofday(&ts);
486
john stultz4c7ee8d2006-09-30 23:28:22 -0700487 write_seqlock_irq(&xtime_lock);
john stultz4c7ee8d2006-09-30 23:28:22 -0700488
Roman Zippel916c7a82008-08-20 16:46:08 -0700489 if (txc->modes & ADJ_ADJTIME) {
490 long save_adjust = time_adjust;
491
492 if (!(txc->modes & ADJ_OFFSET_READONLY)) {
493 /* adjtime() is independent from ntp_adjtime() */
494 time_adjust = txc->offset;
495 ntp_update_frequency();
496 }
497 txc->offset = save_adjust;
Ingo Molnare9629162009-02-22 15:35:18 +0100498 } else {
499
500 /* If there are input parameters, then process them: */
501 if (txc->modes)
502 process_adjtimex_modes(txc, &ts);
503
504 txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
505 NTP_SCALE_SHIFT);
506 if (!(time_status & STA_NANO))
507 txc->offset /= NSEC_PER_USEC;
Roman Zippel916c7a82008-08-20 16:46:08 -0700508 }
Roman Zippel916c7a82008-08-20 16:46:08 -0700509
Roman Zippeleea83d82008-05-01 04:34:33 -0700510 result = time_state; /* mostly `TIME_OK' */
Roman Zippelee9851b2008-05-01 04:34:32 -0700511 if (time_status & (STA_UNSYNC|STA_CLOCKERR))
john stultz4c7ee8d2006-09-30 23:28:22 -0700512 result = TIME_ERROR;
513
Roman Zippeld40e9442008-09-22 14:42:44 -0700514 txc->freq = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) *
Ingo Molnar2b9d1492009-02-22 15:48:43 +0100515 PPM_SCALE_INV, NTP_SCALE_SHIFT);
john stultz4c7ee8d2006-09-30 23:28:22 -0700516 txc->maxerror = time_maxerror;
517 txc->esterror = time_esterror;
518 txc->status = time_status;
519 txc->constant = time_constant;
Adrian Bunk70bc42f2006-09-30 23:28:29 -0700520 txc->precision = 1;
Roman Zippel074b3b82008-05-01 04:34:34 -0700521 txc->tolerance = MAXFREQ_SCALED / PPM_SCALE;
john stultz4c7ee8d2006-09-30 23:28:22 -0700522 txc->tick = tick_usec;
Roman Zippel153b5d02008-05-01 04:34:37 -0700523 txc->tai = time_tai;
john stultz4c7ee8d2006-09-30 23:28:22 -0700524
525 /* PPS is not implemented, so these are zero */
526 txc->ppsfreq = 0;
527 txc->jitter = 0;
528 txc->shift = 0;
529 txc->stabil = 0;
530 txc->jitcnt = 0;
531 txc->calcnt = 0;
532 txc->errcnt = 0;
533 txc->stbcnt = 0;
Ingo Molnare9629162009-02-22 15:35:18 +0100534
john stultz4c7ee8d2006-09-30 23:28:22 -0700535 write_sequnlock_irq(&xtime_lock);
Roman Zippelee9851b2008-05-01 04:34:32 -0700536
Roman Zippeleea83d82008-05-01 04:34:33 -0700537 txc->time.tv_sec = ts.tv_sec;
538 txc->time.tv_usec = ts.tv_nsec;
539 if (!(time_status & STA_NANO))
540 txc->time.tv_usec /= NSEC_PER_USEC;
Roman Zippelee9851b2008-05-01 04:34:32 -0700541
Thomas Gleixner82644452007-07-21 04:37:37 -0700542 notify_cmos_timer();
Roman Zippelee9851b2008-05-01 04:34:32 -0700543
544 return result;
john stultz4c7ee8d2006-09-30 23:28:22 -0700545}
Roman Zippel10a398d2008-03-04 15:14:26 -0800546
547static int __init ntp_tick_adj_setup(char *str)
548{
549 ntp_tick_adj = simple_strtol(str, NULL, 0);
Ingo Molnar069569e2009-02-22 16:03:37 +0100550 ntp_tick_adj <<= NTP_SCALE_SHIFT;
551
Roman Zippel10a398d2008-03-04 15:14:26 -0800552 return 1;
553}
554
555__setup("ntp_tick_adj=", ntp_tick_adj_setup);
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700556
557void __init ntp_init(void)
558{
559 ntp_clear();
560 hrtimer_init(&leap_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
561 leap_timer.function = ntp_leap_second;
562}