2006-10-01 08:28:22 +02:00
|
|
|
/*
|
|
|
|
* NTP state machine interfaces and logic.
|
|
|
|
*
|
|
|
|
* This code was mainly moved from kernel/timer.c and kernel/time.c
|
|
|
|
* Please see those files for relevant copyright info and historical
|
|
|
|
* changelogs.
|
|
|
|
*/
|
2007-07-16 08:40:39 +02:00
|
|
|
#include <linux/capability.h>
|
2008-05-01 13:34:41 +02:00
|
|
|
#include <linux/clocksource.h>
|
2008-09-22 23:42:40 +02:00
|
|
|
#include <linux/workqueue.h>
|
2008-02-20 07:58:42 +01:00
|
|
|
#include <linux/hrtimer.h>
|
|
|
|
#include <linux/jiffies.h>
|
|
|
|
#include <linux/math64.h>
|
|
|
|
#include <linux/timex.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/mm.h>
|
2006-10-01 08:28:22 +02:00
|
|
|
|
2006-10-01 08:28:22 +02:00
|
|
|
/*
|
2008-02-20 07:58:42 +01:00
|
|
|
* NTP timekeeping variables:
|
2006-10-01 08:28:22 +02:00
|
|
|
*/
|
|
|
|
|
2008-02-20 07:58:42 +01:00
|
|
|
/* USER_HZ period (usecs): */
|
|
|
|
unsigned long tick_usec = TICK_USEC;
|
|
|
|
|
|
|
|
/* ACTHZ period (nsecs): */
|
|
|
|
unsigned long tick_nsec;
|
2008-05-01 13:34:41 +02:00
|
|
|
|
2008-02-20 07:58:42 +01:00
|
|
|
u64 tick_length;
|
|
|
|
static u64 tick_length_base;
|
|
|
|
|
|
|
|
static struct hrtimer leap_timer;
|
|
|
|
|
2009-02-22 12:11:11 +01:00
|
|
|
#define MAX_TICKADJ 500LL /* usecs */
|
2008-02-20 07:58:42 +01:00
|
|
|
#define MAX_TICKADJ_SCALED \
|
2009-02-22 12:11:11 +01:00
|
|
|
(((MAX_TICKADJ * NSEC_PER_USEC) << NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ)
|
2006-10-01 08:28:22 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* phase-lock loop variables
|
|
|
|
*/
|
2008-02-20 07:58:42 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* clock synchronization status
|
|
|
|
*
|
|
|
|
* (TIME_ERROR prevents overwriting the CMOS clock)
|
|
|
|
*/
|
|
|
|
static int time_state = TIME_OK;
|
|
|
|
|
|
|
|
/* clock status bits: */
|
|
|
|
int time_status = STA_UNSYNC;
|
|
|
|
|
|
|
|
/* TAI offset (secs): */
|
|
|
|
static long time_tai;
|
|
|
|
|
|
|
|
/* time adjustment (nsecs): */
|
|
|
|
static s64 time_offset;
|
|
|
|
|
|
|
|
/* pll time constant: */
|
|
|
|
static long time_constant = 2;
|
|
|
|
|
|
|
|
/* maximum error (usecs): */
|
|
|
|
long time_maxerror = NTP_PHASE_LIMIT;
|
|
|
|
|
|
|
|
/* estimated error (usecs): */
|
|
|
|
long time_esterror = NTP_PHASE_LIMIT;
|
|
|
|
|
|
|
|
/* frequency offset (scaled nsecs/secs): */
|
|
|
|
static s64 time_freq;
|
|
|
|
|
|
|
|
/* time at last adjustment (secs): */
|
|
|
|
static long time_reftime;
|
|
|
|
|
|
|
|
long time_adjust;
|
|
|
|
|
|
|
|
static long ntp_tick_adj;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NTP methods:
|
|
|
|
*/
|
2006-10-01 08:28:22 +02:00
|
|
|
|
2009-02-22 12:42:59 +01:00
|
|
|
/*
|
|
|
|
* Update (tick_length, tick_length_base, tick_nsec), based
|
|
|
|
* on (tick_usec, ntp_tick_adj, time_freq):
|
|
|
|
*/
|
2006-10-01 08:28:29 +02:00
|
|
|
static void ntp_update_frequency(void)
|
|
|
|
{
|
2009-02-22 12:42:59 +01:00
|
|
|
u64 second_length;
|
2009-02-22 12:17:36 +01:00
|
|
|
u64 new_base;
|
2009-02-22 12:42:59 +01:00
|
|
|
|
|
|
|
second_length = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ)
|
|
|
|
<< NTP_SCALE_SHIFT;
|
|
|
|
|
|
|
|
second_length += (s64)ntp_tick_adj << NTP_SCALE_SHIFT;
|
|
|
|
second_length += time_freq;
|
2006-10-01 08:28:29 +02:00
|
|
|
|
2009-02-22 12:42:59 +01:00
|
|
|
tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
|
2009-02-22 12:17:36 +01:00
|
|
|
new_base = div_u64(second_length, NTP_INTERVAL_FREQ);
|
2009-02-19 01:02:22 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't wait for the next second_overflow, apply
|
2009-02-22 12:17:36 +01:00
|
|
|
* the change to the tick length immediately:
|
2009-02-19 01:02:22 +01:00
|
|
|
*/
|
2009-02-22 12:17:36 +01:00
|
|
|
tick_length += new_base - tick_length_base;
|
|
|
|
tick_length_base = new_base;
|
2006-10-01 08:28:29 +02:00
|
|
|
}
|
|
|
|
|
2009-02-22 13:22:23 +01:00
|
|
|
static inline s64 ntp_update_offset_fll(s64 offset64, long secs)
|
2009-02-22 12:57:49 +01:00
|
|
|
{
|
|
|
|
time_status &= ~STA_MODE;
|
|
|
|
|
|
|
|
if (secs < MINSEC)
|
2009-02-22 13:22:23 +01:00
|
|
|
return 0;
|
2009-02-22 12:57:49 +01:00
|
|
|
|
|
|
|
if (!(time_status & STA_FLL) && (secs <= MAXSEC))
|
2009-02-22 13:22:23 +01:00
|
|
|
return 0;
|
2009-02-22 12:57:49 +01:00
|
|
|
|
|
|
|
time_status |= STA_MODE;
|
|
|
|
|
2009-02-22 13:22:23 +01:00
|
|
|
return div_s64(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs);
|
2009-02-22 12:57:49 +01:00
|
|
|
}
|
|
|
|
|
2008-05-01 13:34:32 +02:00
|
|
|
static void ntp_update_offset(long offset)
|
|
|
|
{
|
|
|
|
s64 freq_adj;
|
2009-02-22 12:57:49 +01:00
|
|
|
s64 offset64;
|
|
|
|
long secs;
|
2008-05-01 13:34:32 +02:00
|
|
|
|
|
|
|
if (!(time_status & STA_PLL))
|
|
|
|
return;
|
|
|
|
|
2008-05-01 13:34:33 +02:00
|
|
|
if (!(time_status & STA_NANO))
|
2008-05-01 13:34:36 +02:00
|
|
|
offset *= NSEC_PER_USEC;
|
2008-05-01 13:34:32 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Scale the phase adjustment and
|
|
|
|
* clamp to the operating range.
|
|
|
|
*/
|
2008-05-01 13:34:36 +02:00
|
|
|
offset = min(offset, MAXPHASE);
|
|
|
|
offset = max(offset, -MAXPHASE);
|
2008-05-01 13:34:32 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Select how the frequency is to be controlled
|
|
|
|
* and in which mode (PLL or FLL).
|
|
|
|
*/
|
2009-02-22 12:57:49 +01:00
|
|
|
secs = xtime.tv_sec - time_reftime;
|
2009-02-22 13:38:40 +01:00
|
|
|
if (unlikely(time_status & STA_FREQHOLD))
|
2009-02-22 13:29:09 +01:00
|
|
|
secs = 0;
|
|
|
|
|
2008-05-01 13:34:32 +02:00
|
|
|
time_reftime = xtime.tv_sec;
|
|
|
|
|
2009-02-22 12:57:49 +01:00
|
|
|
offset64 = offset;
|
|
|
|
freq_adj = (offset64 * secs) <<
|
|
|
|
(NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant));
|
|
|
|
|
2009-02-22 13:22:23 +01:00
|
|
|
freq_adj += ntp_update_offset_fll(offset64, secs);
|
2009-02-22 12:57:49 +01:00
|
|
|
|
|
|
|
freq_adj = min(freq_adj + time_freq, MAXFREQ_SCALED);
|
|
|
|
|
|
|
|
time_freq = max(freq_adj, -MAXFREQ_SCALED);
|
|
|
|
|
|
|
|
time_offset = div_s64(offset64 << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ);
|
2008-05-01 13:34:32 +02:00
|
|
|
}
|
|
|
|
|
2006-10-01 08:28:22 +02:00
|
|
|
/**
|
|
|
|
* ntp_clear - Clears the NTP state variables
|
|
|
|
*
|
|
|
|
* Must be called while holding a write on the xtime_lock
|
|
|
|
*/
|
|
|
|
void ntp_clear(void)
|
|
|
|
{
|
2008-02-20 07:58:42 +01:00
|
|
|
time_adjust = 0; /* stop active adjtime() */
|
|
|
|
time_status |= STA_UNSYNC;
|
|
|
|
time_maxerror = NTP_PHASE_LIMIT;
|
|
|
|
time_esterror = NTP_PHASE_LIMIT;
|
2006-10-01 08:28:22 +02:00
|
|
|
|
|
|
|
ntp_update_frequency();
|
|
|
|
|
2008-02-20 07:58:42 +01:00
|
|
|
tick_length = tick_length_base;
|
|
|
|
time_offset = 0;
|
2006-10-01 08:28:22 +02:00
|
|
|
}
|
|
|
|
|
2006-10-01 08:28:22 +02:00
|
|
|
/*
|
2008-05-01 13:34:41 +02:00
|
|
|
* Leap second processing. If in leap-insert state at the end of the
|
|
|
|
* day, the system clock is set back one second; if in leap-delete
|
|
|
|
* state, the system clock is set ahead one second.
|
2006-10-01 08:28:22 +02:00
|
|
|
*/
|
2008-05-01 13:34:41 +02:00
|
|
|
static enum hrtimer_restart ntp_leap_second(struct hrtimer *timer)
|
2006-10-01 08:28:22 +02:00
|
|
|
{
|
2008-05-01 13:34:41 +02:00
|
|
|
enum hrtimer_restart res = HRTIMER_NORESTART;
|
2006-10-01 08:28:22 +02:00
|
|
|
|
2008-11-25 12:43:51 +01:00
|
|
|
write_seqlock(&xtime_lock);
|
2006-10-01 08:28:22 +02:00
|
|
|
|
|
|
|
switch (time_state) {
|
|
|
|
case TIME_OK:
|
|
|
|
break;
|
|
|
|
case TIME_INS:
|
2008-05-01 13:34:41 +02:00
|
|
|
xtime.tv_sec--;
|
|
|
|
wall_to_monotonic.tv_sec++;
|
|
|
|
time_state = TIME_OOP;
|
2008-02-20 07:58:42 +01:00
|
|
|
printk(KERN_NOTICE
|
|
|
|
"Clock: inserting leap second 23:59:60 UTC\n");
|
2008-09-02 00:02:30 +02:00
|
|
|
hrtimer_add_expires_ns(&leap_timer, NSEC_PER_SEC);
|
2008-05-01 13:34:41 +02:00
|
|
|
res = HRTIMER_RESTART;
|
2006-10-01 08:28:22 +02:00
|
|
|
break;
|
|
|
|
case TIME_DEL:
|
2008-05-01 13:34:41 +02:00
|
|
|
xtime.tv_sec++;
|
|
|
|
time_tai--;
|
|
|
|
wall_to_monotonic.tv_sec--;
|
|
|
|
time_state = TIME_WAIT;
|
2008-02-20 07:58:42 +01:00
|
|
|
printk(KERN_NOTICE
|
|
|
|
"Clock: deleting leap second 23:59:59 UTC\n");
|
2006-10-01 08:28:22 +02:00
|
|
|
break;
|
|
|
|
case TIME_OOP:
|
2008-05-01 13:34:37 +02:00
|
|
|
time_tai++;
|
2006-10-01 08:28:22 +02:00
|
|
|
time_state = TIME_WAIT;
|
2008-05-01 13:34:41 +02:00
|
|
|
/* fall through */
|
2006-10-01 08:28:22 +02:00
|
|
|
case TIME_WAIT:
|
|
|
|
if (!(time_status & (STA_INS | STA_DEL)))
|
2008-05-01 13:34:32 +02:00
|
|
|
time_state = TIME_OK;
|
2008-05-01 13:34:41 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
update_vsyscall(&xtime, clock);
|
|
|
|
|
2008-11-25 12:43:51 +01:00
|
|
|
write_sequnlock(&xtime_lock);
|
2008-05-01 13:34:41 +02:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this routine handles the overflow of the microsecond field
|
|
|
|
*
|
|
|
|
* The tricky bits of code to handle the accurate clock support
|
|
|
|
* were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame.
|
|
|
|
* They were originally developed for SUN and DEC kernels.
|
|
|
|
* All the kudos should go to Dave for this stuff.
|
|
|
|
*/
|
|
|
|
void second_overflow(void)
|
|
|
|
{
|
|
|
|
s64 time_adj;
|
|
|
|
|
|
|
|
/* Bump the maxerror field */
|
|
|
|
time_maxerror += MAXFREQ / NSEC_PER_USEC;
|
|
|
|
if (time_maxerror > NTP_PHASE_LIMIT) {
|
|
|
|
time_maxerror = NTP_PHASE_LIMIT;
|
|
|
|
time_status |= STA_UNSYNC;
|
2006-10-01 08:28:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-10-01 08:28:28 +02:00
|
|
|
* Compute the phase adjustment for the next second. The offset is
|
|
|
|
* reduced by a fixed factor times the time constant.
|
2006-10-01 08:28:22 +02:00
|
|
|
*/
|
2008-02-20 07:58:42 +01:00
|
|
|
tick_length = tick_length_base;
|
|
|
|
time_adj = shift_right(time_offset, SHIFT_PLL + time_constant);
|
|
|
|
time_offset -= time_adj;
|
|
|
|
tick_length += time_adj;
|
2006-10-01 08:28:22 +02:00
|
|
|
|
2009-02-22 12:06:57 +01:00
|
|
|
if (!time_adjust)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (time_adjust > MAX_TICKADJ) {
|
|
|
|
time_adjust -= MAX_TICKADJ;
|
|
|
|
tick_length += MAX_TICKADJ_SCALED;
|
|
|
|
return;
|
2006-10-01 08:28:22 +02:00
|
|
|
}
|
2009-02-22 12:06:57 +01:00
|
|
|
|
|
|
|
if (time_adjust < -MAX_TICKADJ) {
|
|
|
|
time_adjust += MAX_TICKADJ;
|
|
|
|
tick_length -= MAX_TICKADJ_SCALED;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
tick_length += (s64)(time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)
|
|
|
|
<< NTP_SCALE_SHIFT;
|
|
|
|
time_adjust = 0;
|
2006-10-01 08:28:22 +02:00
|
|
|
}
|
|
|
|
|
2007-07-21 13:37:37 +02:00
|
|
|
#ifdef CONFIG_GENERIC_CMOS_UPDATE
|
2006-10-01 08:28:22 +02:00
|
|
|
|
2007-07-21 13:37:37 +02:00
|
|
|
/* Disable the cmos update - used by virtualization and embedded */
|
|
|
|
int no_sync_cmos_clock __read_mostly;
|
|
|
|
|
2008-09-22 23:42:40 +02:00
|
|
|
static void sync_cmos_clock(struct work_struct *work);
|
2007-07-21 13:37:37 +02:00
|
|
|
|
2008-09-22 23:42:40 +02:00
|
|
|
static DECLARE_DELAYED_WORK(sync_cmos_work, sync_cmos_clock);
|
2007-07-21 13:37:37 +02:00
|
|
|
|
2008-09-22 23:42:40 +02:00
|
|
|
static void sync_cmos_clock(struct work_struct *work)
|
2007-07-21 13:37:37 +02:00
|
|
|
{
|
|
|
|
struct timespec now, next;
|
|
|
|
int fail = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we have an externally synchronized Linux clock, then update
|
|
|
|
* CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
|
|
|
|
* called as close as possible to 500 ms before the new second starts.
|
|
|
|
* This code is run on a timer. If the clock is set, that timer
|
|
|
|
* may not expire at the correct time. Thus, we adjust...
|
|
|
|
*/
|
2008-02-20 07:58:42 +01:00
|
|
|
if (!ntp_synced()) {
|
2007-07-21 13:37:37 +02:00
|
|
|
/*
|
|
|
|
* Not synced, exit, do not restart a timer (if one is
|
|
|
|
* running, let it run out).
|
|
|
|
*/
|
|
|
|
return;
|
2008-02-20 07:58:42 +01:00
|
|
|
}
|
2007-07-21 13:37:37 +02:00
|
|
|
|
|
|
|
getnstimeofday(&now);
|
ntp: fix typo that makes sync_cmos_clock erratic
Fix a typo in ntp.c that has caused updating of the persistent (RTC)
clock when synced to NTP to behave erratically.
When debugging a freeze that arises on my AMD64 machines when I
run the ntpd service, I added a number of printk's to monitor the
sync_cmos_clock procedure. I discovered that it was not syncing to
cmos RTC every 11 minutes as documented, but instead would keep trying
every second for hours at a time. The reason turned out to be a typo
in sync_cmos_clock, where it attempts to ensure that
update_persistent_clock is called very close to 500 msec. after a 1
second boundary (required by the PC RTC's spec). That typo referred to
"xtime" in one spot, rather than "now", which is derived from "xtime"
but not equal to it. This makes the test erratic, creating a
"coin-flip" that decides when update_persistent_clock is called - when
it is called, which is rarely, it may be at any time during the one
second period, rather than close to 500 msec, so the value written is
needlessly incorrect, too.
Signed-off-by: David P. Reed
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2007-11-14 23:49:21 +01:00
|
|
|
if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2)
|
2007-07-21 13:37:37 +02:00
|
|
|
fail = update_persistent_clock(now);
|
|
|
|
|
2008-09-05 23:05:31 +02:00
|
|
|
next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec - (TICK_NSEC / 2);
|
2007-07-21 13:37:37 +02:00
|
|
|
if (next.tv_nsec <= 0)
|
|
|
|
next.tv_nsec += NSEC_PER_SEC;
|
|
|
|
|
|
|
|
if (!fail)
|
|
|
|
next.tv_sec = 659;
|
|
|
|
else
|
|
|
|
next.tv_sec = 0;
|
|
|
|
|
|
|
|
if (next.tv_nsec >= NSEC_PER_SEC) {
|
|
|
|
next.tv_sec++;
|
|
|
|
next.tv_nsec -= NSEC_PER_SEC;
|
|
|
|
}
|
2008-09-22 23:42:40 +02:00
|
|
|
schedule_delayed_work(&sync_cmos_work, timespec_to_jiffies(&next));
|
2007-07-21 13:37:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void notify_cmos_timer(void)
|
2006-10-01 08:28:22 +02:00
|
|
|
{
|
2007-09-12 00:24:03 +02:00
|
|
|
if (!no_sync_cmos_clock)
|
2008-09-22 23:42:40 +02:00
|
|
|
schedule_delayed_work(&sync_cmos_work, 0);
|
2006-10-01 08:28:22 +02:00
|
|
|
}
|
|
|
|
|
2007-07-21 13:37:37 +02:00
|
|
|
#else
|
|
|
|
static inline void notify_cmos_timer(void) { }
|
|
|
|
#endif
|
|
|
|
|
2009-02-22 15:35:18 +01:00
|
|
|
/*
|
|
|
|
* Start the leap seconds timer:
|
|
|
|
*/
|
|
|
|
static inline void ntp_start_leap_timer(struct timespec *ts)
|
|
|
|
{
|
|
|
|
long now = ts->tv_sec;
|
|
|
|
|
|
|
|
if (time_status & STA_INS) {
|
|
|
|
time_state = TIME_INS;
|
|
|
|
now += 86400 - now % 86400;
|
|
|
|
hrtimer_start(&leap_timer, ktime_set(now, 0), HRTIMER_MODE_ABS);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (time_status & STA_DEL) {
|
|
|
|
time_state = TIME_DEL;
|
|
|
|
now += 86400 - (now + 1) % 86400;
|
|
|
|
hrtimer_start(&leap_timer, ktime_set(now, 0), HRTIMER_MODE_ABS);
|
|
|
|
}
|
|
|
|
}
|
2009-02-22 15:15:32 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Propagate a new txc->status value into the NTP state:
|
|
|
|
*/
|
|
|
|
static inline void process_adj_status(struct timex *txc, struct timespec *ts)
|
|
|
|
{
|
|
|
|
if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) {
|
|
|
|
time_state = TIME_OK;
|
|
|
|
time_status = STA_UNSYNC;
|
|
|
|
}
|
|
|
|
/* only set allowed bits */
|
|
|
|
time_status &= STA_RONLY;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we turn on PLL adjustments then reset the
|
|
|
|
* reference time to current time.
|
|
|
|
*/
|
|
|
|
if (!(time_status & STA_PLL) && (txc->status & STA_PLL))
|
|
|
|
time_reftime = xtime.tv_sec;
|
|
|
|
|
|
|
|
time_status |= txc->status & ~STA_RONLY;
|
|
|
|
|
|
|
|
switch (time_state) {
|
|
|
|
case TIME_OK:
|
2009-02-22 15:35:18 +01:00
|
|
|
ntp_start_leap_timer(ts);
|
2009-02-22 15:15:32 +01:00
|
|
|
break;
|
|
|
|
case TIME_INS:
|
|
|
|
case TIME_DEL:
|
|
|
|
time_state = TIME_OK;
|
2009-02-22 15:35:18 +01:00
|
|
|
ntp_start_leap_timer(ts);
|
2009-02-22 15:15:32 +01:00
|
|
|
case TIME_WAIT:
|
|
|
|
if (!(time_status & (STA_INS | STA_DEL)))
|
|
|
|
time_state = TIME_OK;
|
|
|
|
break;
|
|
|
|
case TIME_OOP:
|
|
|
|
hrtimer_restart(&leap_timer);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Called with the xtime lock held, so we can access and modify
|
|
|
|
* all the global NTP state:
|
|
|
|
*/
|
|
|
|
static inline void process_adjtimex_modes(struct timex *txc, struct timespec *ts)
|
|
|
|
{
|
|
|
|
if (txc->modes & ADJ_STATUS)
|
|
|
|
process_adj_status(txc, ts);
|
|
|
|
|
|
|
|
if (txc->modes & ADJ_NANO)
|
|
|
|
time_status |= STA_NANO;
|
2009-02-22 15:35:18 +01:00
|
|
|
|
2009-02-22 15:15:32 +01:00
|
|
|
if (txc->modes & ADJ_MICRO)
|
|
|
|
time_status &= ~STA_NANO;
|
|
|
|
|
|
|
|
if (txc->modes & ADJ_FREQUENCY) {
|
|
|
|
time_freq = (s64)txc->freq * PPM_SCALE;
|
|
|
|
time_freq = min(time_freq, MAXFREQ_SCALED);
|
|
|
|
time_freq = max(time_freq, -MAXFREQ_SCALED);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (txc->modes & ADJ_MAXERROR)
|
|
|
|
time_maxerror = txc->maxerror;
|
2009-02-22 15:35:18 +01:00
|
|
|
|
2009-02-22 15:15:32 +01:00
|
|
|
if (txc->modes & ADJ_ESTERROR)
|
|
|
|
time_esterror = txc->esterror;
|
|
|
|
|
|
|
|
if (txc->modes & ADJ_TIMECONST) {
|
|
|
|
time_constant = txc->constant;
|
|
|
|
if (!(time_status & STA_NANO))
|
|
|
|
time_constant += 4;
|
|
|
|
time_constant = min(time_constant, (long)MAXTC);
|
|
|
|
time_constant = max(time_constant, 0l);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (txc->modes & ADJ_TAI && txc->constant > 0)
|
|
|
|
time_tai = txc->constant;
|
|
|
|
|
|
|
|
if (txc->modes & ADJ_OFFSET)
|
|
|
|
ntp_update_offset(txc->offset);
|
2009-02-22 15:35:18 +01:00
|
|
|
|
2009-02-22 15:15:32 +01:00
|
|
|
if (txc->modes & ADJ_TICK)
|
|
|
|
tick_usec = txc->tick;
|
|
|
|
|
|
|
|
if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET))
|
|
|
|
ntp_update_frequency();
|
|
|
|
}
|
|
|
|
|
2008-02-20 07:58:42 +01:00
|
|
|
/*
|
|
|
|
* adjtimex mainly allows reading (and writing, if superuser) of
|
2006-10-01 08:28:22 +02:00
|
|
|
* kernel time-keeping variables. used by xntpd.
|
|
|
|
*/
|
|
|
|
int do_adjtimex(struct timex *txc)
|
|
|
|
{
|
2008-05-01 13:34:33 +02:00
|
|
|
struct timespec ts;
|
2006-10-01 08:28:22 +02:00
|
|
|
int result;
|
|
|
|
|
2008-08-21 01:46:08 +02:00
|
|
|
/* Validate the data before disabling interrupts */
|
|
|
|
if (txc->modes & ADJ_ADJTIME) {
|
2008-05-01 13:34:33 +02:00
|
|
|
/* singleshot must not be used with any other mode bits */
|
2008-08-21 01:46:08 +02:00
|
|
|
if (!(txc->modes & ADJ_OFFSET_SINGLESHOT))
|
2006-10-01 08:28:22 +02:00
|
|
|
return -EINVAL;
|
2008-08-21 01:46:08 +02:00
|
|
|
if (!(txc->modes & ADJ_OFFSET_READONLY) &&
|
|
|
|
!capable(CAP_SYS_TIME))
|
|
|
|
return -EPERM;
|
|
|
|
} else {
|
|
|
|
/* In order to modify anything, you gotta be super-user! */
|
|
|
|
if (txc->modes && !capable(CAP_SYS_TIME))
|
|
|
|
return -EPERM;
|
|
|
|
|
2008-02-20 07:58:42 +01:00
|
|
|
/*
|
|
|
|
* if the quartz is off by more than 10% then
|
|
|
|
* something is VERY wrong!
|
|
|
|
*/
|
2008-08-21 01:46:08 +02:00
|
|
|
if (txc->modes & ADJ_TICK &&
|
|
|
|
(txc->tick < 900000/USER_HZ ||
|
|
|
|
txc->tick > 1100000/USER_HZ))
|
2009-02-22 15:35:18 +01:00
|
|
|
return -EINVAL;
|
2008-08-21 01:46:08 +02:00
|
|
|
|
|
|
|
if (txc->modes & ADJ_STATUS && time_state != TIME_OK)
|
|
|
|
hrtimer_cancel(&leap_timer);
|
2007-11-26 20:42:19 +01:00
|
|
|
}
|
2006-10-01 08:28:22 +02:00
|
|
|
|
2008-05-01 13:34:41 +02:00
|
|
|
getnstimeofday(&ts);
|
|
|
|
|
2006-10-01 08:28:22 +02:00
|
|
|
write_seqlock_irq(&xtime_lock);
|
|
|
|
|
2008-08-21 01:46:08 +02:00
|
|
|
if (txc->modes & ADJ_ADJTIME) {
|
|
|
|
long save_adjust = time_adjust;
|
|
|
|
|
|
|
|
if (!(txc->modes & ADJ_OFFSET_READONLY)) {
|
|
|
|
/* adjtime() is independent from ntp_adjtime() */
|
|
|
|
time_adjust = txc->offset;
|
|
|
|
ntp_update_frequency();
|
|
|
|
}
|
|
|
|
txc->offset = save_adjust;
|
2009-02-22 15:35:18 +01:00
|
|
|
} else {
|
2008-05-01 13:34:32 +02:00
|
|
|
|
2009-02-22 15:35:18 +01:00
|
|
|
/* If there are input parameters, then process them: */
|
|
|
|
if (txc->modes)
|
|
|
|
process_adjtimex_modes(txc, &ts);
|
2008-05-01 13:34:33 +02:00
|
|
|
|
2009-02-22 15:35:18 +01:00
|
|
|
txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
|
2008-08-21 01:46:08 +02:00
|
|
|
NTP_SCALE_SHIFT);
|
2009-02-22 15:35:18 +01:00
|
|
|
if (!(time_status & STA_NANO))
|
|
|
|
txc->offset /= NSEC_PER_USEC;
|
|
|
|
}
|
2008-08-21 01:46:08 +02:00
|
|
|
|
2008-05-01 13:34:33 +02:00
|
|
|
result = time_state; /* mostly `TIME_OK' */
|
2008-05-01 13:34:32 +02:00
|
|
|
if (time_status & (STA_UNSYNC|STA_CLOCKERR))
|
2006-10-01 08:28:22 +02:00
|
|
|
result = TIME_ERROR;
|
|
|
|
|
2008-09-22 23:42:44 +02:00
|
|
|
txc->freq = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) *
|
|
|
|
(s64)PPM_SCALE_INV, NTP_SCALE_SHIFT);
|
2006-10-01 08:28:22 +02:00
|
|
|
txc->maxerror = time_maxerror;
|
|
|
|
txc->esterror = time_esterror;
|
|
|
|
txc->status = time_status;
|
|
|
|
txc->constant = time_constant;
|
2006-10-01 08:28:29 +02:00
|
|
|
txc->precision = 1;
|
2008-05-01 13:34:34 +02:00
|
|
|
txc->tolerance = MAXFREQ_SCALED / PPM_SCALE;
|
2006-10-01 08:28:22 +02:00
|
|
|
txc->tick = tick_usec;
|
2008-05-01 13:34:37 +02:00
|
|
|
txc->tai = time_tai;
|
2006-10-01 08:28:22 +02:00
|
|
|
|
|
|
|
/* PPS is not implemented, so these are zero */
|
|
|
|
txc->ppsfreq = 0;
|
|
|
|
txc->jitter = 0;
|
|
|
|
txc->shift = 0;
|
|
|
|
txc->stabil = 0;
|
|
|
|
txc->jitcnt = 0;
|
|
|
|
txc->calcnt = 0;
|
|
|
|
txc->errcnt = 0;
|
|
|
|
txc->stbcnt = 0;
|
2009-02-22 15:35:18 +01:00
|
|
|
|
2006-10-01 08:28:22 +02:00
|
|
|
write_sequnlock_irq(&xtime_lock);
|
2008-05-01 13:34:32 +02:00
|
|
|
|
2008-05-01 13:34:33 +02:00
|
|
|
txc->time.tv_sec = ts.tv_sec;
|
|
|
|
txc->time.tv_usec = ts.tv_nsec;
|
|
|
|
if (!(time_status & STA_NANO))
|
|
|
|
txc->time.tv_usec /= NSEC_PER_USEC;
|
2008-05-01 13:34:32 +02:00
|
|
|
|
2007-07-21 13:37:37 +02:00
|
|
|
notify_cmos_timer();
|
2008-05-01 13:34:32 +02:00
|
|
|
|
|
|
|
return result;
|
2006-10-01 08:28:22 +02:00
|
|
|
}
|
time: remove obsolete CLOCK_TICK_ADJUST
The first version of the ntp_interval/tick_length inconsistent usage patch was
recently merged as bbe4d18ac2e058c56adb0cd71f49d9ed3216a405
http://git.kernel.org/gitweb.cgi?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=bbe4d18ac2e058c56adb0cd71f49d9ed3216a405
While the fix did greatly improve the situation, it was correctly pointed out
by Roman that it does have a small bug: If the users change clocksources after
the system has been running and NTP has made corrections, the correctoins made
against the old clocksource will be applied against the new clocksource,
causing error.
The second attempt, which corrects the issue in the NTP_INTERVAL_LENGTH
definition has also made it up-stream as commit
e13a2e61dd5152f5499d2003470acf9c838eab84
http://git.kernel.org/gitweb.cgi?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=e13a2e61dd5152f5499d2003470acf9c838eab84
Roman has correctly pointed out that CLOCK_TICK_ADJUST is calculated
based on the PIT's frequency, and isn't really relevant to non-PIT
driven clocksources (that is, clocksources other then jiffies and pit).
This patch reverts both of those changes, and simply removes
CLOCK_TICK_ADJUST.
This does remove the granularity error correction for users of PIT and Jiffies
clocksource users, but the granularity error but for the majority of users, it
should be within the 500ppm range NTP can accommodate for.
For systems that have granularity errors greater then 500ppm, the
"ntp_tick_adj=" boot option can be used to compensate.
[johnstul@us.ibm.com: provided changelog]
[mattilinnanvuori@yahoo.com: maek ntp_tick_adj static]
Signed-off-by: Roman Zippel <zippel@linux-m68k.org>
Acked-by: john stultz <johnstul@us.ibm.com>
Signed-off-by: Matti Linnanvuori <mattilinnanvuori@yahoo.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Cc: mingo@elte.hu
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-03-05 00:14:26 +01:00
|
|
|
|
|
|
|
static int __init ntp_tick_adj_setup(char *str)
|
|
|
|
{
|
|
|
|
ntp_tick_adj = simple_strtol(str, NULL, 0);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__setup("ntp_tick_adj=", ntp_tick_adj_setup);
|
2008-05-01 13:34:41 +02:00
|
|
|
|
|
|
|
void __init ntp_init(void)
|
|
|
|
{
|
|
|
|
ntp_clear();
|
|
|
|
hrtimer_init(&leap_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
|
|
|
|
leap_timer.function = ntp_leap_second;
|
|
|
|
}
|