2007-05-08 09:27:59 +02:00
|
|
|
/*
|
|
|
|
* linux/kernel/time/timekeeping.c
|
|
|
|
*
|
|
|
|
* Kernel timekeeping code and accessor functions
|
|
|
|
*
|
|
|
|
* This code was moved from linux/kernel/timer.c.
|
|
|
|
* Please see that file for copyright and history logs.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/percpu.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/sysdev.h>
|
|
|
|
#include <linux/clocksource.h>
|
|
|
|
#include <linux/jiffies.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/tick.h>
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This read-write spinlock protects us from races in SMP while
|
|
|
|
* playing with xtime and avenrun.
|
|
|
|
*/
|
2007-10-17 08:27:16 +02:00
|
|
|
__cacheline_aligned_in_smp DEFINE_SEQLOCK(xtime_lock);
|
2007-05-08 09:27:59 +02:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The current time
|
|
|
|
* wall_to_monotonic is what we need to add to xtime (or xtime corrected
|
|
|
|
* for sub jiffie times) to get to monotonic time. Monotonic is pegged
|
|
|
|
* at zero at system boot time, so wall_to_monotonic will be negative,
|
|
|
|
* however, we will ALWAYS keep the tv_nsec part positive so we can use
|
|
|
|
* the usual normalization.
|
2007-07-16 08:39:41 +02:00
|
|
|
*
|
|
|
|
* wall_to_monotonic is moved after resume from suspend for the monotonic
|
|
|
|
* time not to jump. We need to add total_sleep_time to wall_to_monotonic
|
|
|
|
* to get the real boot based time offset.
|
|
|
|
*
|
|
|
|
* - wall_to_monotonic is no longer the boot time, getboottime must be
|
|
|
|
* used instead.
|
2007-05-08 09:27:59 +02:00
|
|
|
*/
|
|
|
|
struct timespec xtime __attribute__ ((aligned (16)));
|
|
|
|
struct timespec wall_to_monotonic __attribute__ ((aligned (16)));
|
2007-07-16 08:39:41 +02:00
|
|
|
static unsigned long total_sleep_time; /* seconds */
|
2007-05-08 09:27:59 +02:00
|
|
|
|
2007-07-25 03:38:34 +02:00
|
|
|
static struct timespec xtime_cache __attribute__ ((aligned (16)));
|
2008-02-01 17:45:13 +01:00
|
|
|
void update_xtime_cache(u64 nsec)
|
2007-07-25 03:38:34 +02:00
|
|
|
{
|
|
|
|
xtime_cache = xtime;
|
|
|
|
timespec_add_ns(&xtime_cache, nsec);
|
|
|
|
}
|
|
|
|
|
2008-05-01 13:34:41 +02:00
|
|
|
struct clocksource *clock;
|
2007-05-08 09:27:59 +02:00
|
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_GENERIC_TIME
|
|
|
|
/**
|
2008-08-21 01:37:28 +02:00
|
|
|
* clocksource_forward_now - update clock to the current time
|
2007-05-08 09:27:59 +02:00
|
|
|
*
|
2008-08-21 01:37:28 +02:00
|
|
|
* Forward the current clock to update its state since the last call to
|
|
|
|
* update_wall_time(). This is useful before significant clock changes,
|
|
|
|
* as it avoids having to deal with this time offset explicitly.
|
2007-05-08 09:27:59 +02:00
|
|
|
*/
|
2008-08-21 01:37:28 +02:00
|
|
|
static void clocksource_forward_now(void)
|
2007-05-08 09:27:59 +02:00
|
|
|
{
|
|
|
|
cycle_t cycle_now, cycle_delta;
|
2008-08-21 01:37:28 +02:00
|
|
|
s64 nsec;
|
2007-05-08 09:27:59 +02:00
|
|
|
|
|
|
|
cycle_now = clocksource_read(clock);
|
|
|
|
cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
|
2008-08-21 01:37:28 +02:00
|
|
|
clock->cycle_last = cycle_now;
|
2007-05-08 09:27:59 +02:00
|
|
|
|
2008-08-21 01:37:28 +02:00
|
|
|
nsec = cyc2ns(clock, cycle_delta);
|
|
|
|
timespec_add_ns(&xtime, nsec);
|
2008-08-21 01:37:30 +02:00
|
|
|
|
|
|
|
nsec = ((s64)cycle_delta * clock->mult_orig) >> clock->shift;
|
|
|
|
clock->raw_time.tv_nsec += nsec;
|
2007-05-08 09:27:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-30 13:30:01 +01:00
|
|
|
* getnstimeofday - Returns the time of day in a timespec
|
2007-05-08 09:27:59 +02:00
|
|
|
* @ts: pointer to the timespec to be set
|
|
|
|
*
|
2008-01-30 13:30:01 +01:00
|
|
|
* Returns the time of day in a timespec.
|
2007-05-08 09:27:59 +02:00
|
|
|
*/
|
2008-01-30 13:30:01 +01:00
|
|
|
void getnstimeofday(struct timespec *ts)
|
2007-05-08 09:27:59 +02:00
|
|
|
{
|
2008-08-21 01:37:28 +02:00
|
|
|
cycle_t cycle_now, cycle_delta;
|
2007-05-08 09:27:59 +02:00
|
|
|
unsigned long seq;
|
|
|
|
s64 nsecs;
|
|
|
|
|
|
|
|
do {
|
|
|
|
seq = read_seqbegin(&xtime_lock);
|
|
|
|
|
|
|
|
*ts = xtime;
|
2008-08-21 01:37:28 +02:00
|
|
|
|
|
|
|
/* read clocksource: */
|
|
|
|
cycle_now = clocksource_read(clock);
|
|
|
|
|
|
|
|
/* calculate the delta since the last update_wall_time: */
|
|
|
|
cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
|
|
|
|
|
|
|
|
/* convert to nanoseconds: */
|
|
|
|
nsecs = cyc2ns(clock, cycle_delta);
|
2007-05-08 09:27:59 +02:00
|
|
|
|
|
|
|
} while (read_seqretry(&xtime_lock, seq));
|
|
|
|
|
|
|
|
timespec_add_ns(ts, nsecs);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(getnstimeofday);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* do_gettimeofday - Returns the time of day in a timeval
|
|
|
|
* @tv: pointer to the timeval to be set
|
|
|
|
*
|
2008-01-30 13:30:01 +01:00
|
|
|
* NOTE: Users should be converted to using getnstimeofday()
|
2007-05-08 09:27:59 +02:00
|
|
|
*/
|
|
|
|
void do_gettimeofday(struct timeval *tv)
|
|
|
|
{
|
|
|
|
struct timespec now;
|
|
|
|
|
2008-01-30 13:30:01 +01:00
|
|
|
getnstimeofday(&now);
|
2007-05-08 09:27:59 +02:00
|
|
|
tv->tv_sec = now.tv_sec;
|
|
|
|
tv->tv_usec = now.tv_nsec/1000;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(do_gettimeofday);
|
|
|
|
/**
|
|
|
|
* do_settimeofday - Sets the time of day
|
|
|
|
* @tv: pointer to the timespec variable containing the new time
|
|
|
|
*
|
|
|
|
* Sets the time of day to the new time and update NTP and notify hrtimers
|
|
|
|
*/
|
|
|
|
int do_settimeofday(struct timespec *tv)
|
|
|
|
{
|
2008-08-21 01:37:28 +02:00
|
|
|
struct timespec ts_delta;
|
2007-05-08 09:27:59 +02:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
write_seqlock_irqsave(&xtime_lock, flags);
|
|
|
|
|
2008-08-21 01:37:28 +02:00
|
|
|
clocksource_forward_now();
|
|
|
|
|
|
|
|
ts_delta.tv_sec = tv->tv_sec - xtime.tv_sec;
|
|
|
|
ts_delta.tv_nsec = tv->tv_nsec - xtime.tv_nsec;
|
|
|
|
wall_to_monotonic = timespec_sub(wall_to_monotonic, ts_delta);
|
2007-05-08 09:27:59 +02:00
|
|
|
|
2008-08-21 01:37:28 +02:00
|
|
|
xtime = *tv;
|
2007-05-08 09:27:59 +02:00
|
|
|
|
2008-02-01 17:45:13 +01:00
|
|
|
update_xtime_cache(0);
|
2007-05-08 09:27:59 +02:00
|
|
|
|
|
|
|
clock->error = 0;
|
|
|
|
ntp_clear();
|
|
|
|
|
|
|
|
update_vsyscall(&xtime, clock);
|
|
|
|
|
|
|
|
write_sequnlock_irqrestore(&xtime_lock, flags);
|
|
|
|
|
|
|
|
/* signal hrtimers about time change */
|
|
|
|
clock_was_set();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(do_settimeofday);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* change_clocksource - Swaps clocksources if a new one is available
|
|
|
|
*
|
|
|
|
* Accumulates current time interval and initializes new clocksource
|
|
|
|
*/
|
|
|
|
static void change_clocksource(void)
|
|
|
|
{
|
|
|
|
struct clocksource *new;
|
|
|
|
|
|
|
|
new = clocksource_get_next();
|
|
|
|
|
|
|
|
if (clock == new)
|
|
|
|
return;
|
|
|
|
|
2008-08-21 01:37:28 +02:00
|
|
|
clocksource_forward_now();
|
2007-05-08 09:27:59 +02:00
|
|
|
|
2008-08-21 01:37:30 +02:00
|
|
|
new->raw_time = clock->raw_time;
|
|
|
|
|
2007-05-08 09:27:59 +02:00
|
|
|
clock = new;
|
2008-08-21 01:37:28 +02:00
|
|
|
clock->cycle_last = 0;
|
|
|
|
clock->cycle_last = clocksource_read(new);
|
2007-05-08 09:27:59 +02:00
|
|
|
clock->error = 0;
|
|
|
|
clock->xtime_nsec = 0;
|
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
|
|
|
clocksource_calculate_interval(clock, NTP_INTERVAL_LENGTH);
|
2007-05-08 09:27:59 +02:00
|
|
|
|
|
|
|
tick_clock_notify();
|
|
|
|
|
2008-03-24 19:07:15 +01:00
|
|
|
/*
|
|
|
|
* We're holding xtime lock and waking up klogd would deadlock
|
|
|
|
* us on enqueue. So no printing!
|
2007-05-08 09:27:59 +02:00
|
|
|
printk(KERN_INFO "Time: %s clocksource has been installed.\n",
|
|
|
|
clock->name);
|
2008-03-24 19:07:15 +01:00
|
|
|
*/
|
2007-05-08 09:27:59 +02:00
|
|
|
}
|
|
|
|
#else
|
2008-08-21 01:37:28 +02:00
|
|
|
static inline void clocksource_forward_now(void) { }
|
2007-05-08 09:27:59 +02:00
|
|
|
static inline void change_clocksource(void) { }
|
|
|
|
#endif
|
|
|
|
|
2008-08-21 01:37:30 +02:00
|
|
|
/**
|
|
|
|
* getrawmonotonic - Returns the raw monotonic time in a timespec
|
|
|
|
* @ts: pointer to the timespec to be set
|
|
|
|
*
|
|
|
|
* Returns the raw monotonic time (completely un-modified by ntp)
|
|
|
|
*/
|
|
|
|
void getrawmonotonic(struct timespec *ts)
|
|
|
|
{
|
|
|
|
unsigned long seq;
|
|
|
|
s64 nsecs;
|
|
|
|
cycle_t cycle_now, cycle_delta;
|
|
|
|
|
|
|
|
do {
|
|
|
|
seq = read_seqbegin(&xtime_lock);
|
|
|
|
|
|
|
|
/* read clocksource: */
|
|
|
|
cycle_now = clocksource_read(clock);
|
|
|
|
|
|
|
|
/* calculate the delta since the last update_wall_time: */
|
|
|
|
cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
|
|
|
|
|
|
|
|
/* convert to nanoseconds: */
|
|
|
|
nsecs = ((s64)cycle_delta * clock->mult_orig) >> clock->shift;
|
|
|
|
|
|
|
|
*ts = clock->raw_time;
|
|
|
|
|
|
|
|
} while (read_seqretry(&xtime_lock, seq));
|
|
|
|
|
|
|
|
timespec_add_ns(ts, nsecs);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(getrawmonotonic);
|
|
|
|
|
|
|
|
|
2007-05-08 09:27:59 +02:00
|
|
|
/**
|
2008-02-08 13:19:24 +01:00
|
|
|
* timekeeping_valid_for_hres - Check if timekeeping is suitable for hres
|
2007-05-08 09:27:59 +02:00
|
|
|
*/
|
2008-02-08 13:19:24 +01:00
|
|
|
int timekeeping_valid_for_hres(void)
|
2007-05-08 09:27:59 +02:00
|
|
|
{
|
|
|
|
unsigned long seq;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
do {
|
|
|
|
seq = read_seqbegin(&xtime_lock);
|
|
|
|
|
|
|
|
ret = clock->flags & CLOCK_SOURCE_VALID_FOR_HRES;
|
|
|
|
|
|
|
|
} while (read_seqretry(&xtime_lock, seq));
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* read_persistent_clock - Return time in seconds from the persistent clock.
|
|
|
|
*
|
|
|
|
* Weak dummy function for arches that do not yet support it.
|
|
|
|
* Returns seconds from epoch using the battery backed persistent clock.
|
|
|
|
* Returns zero if unsupported.
|
|
|
|
*
|
|
|
|
* XXX - Do be sure to remove it once all arches implement it.
|
|
|
|
*/
|
|
|
|
unsigned long __attribute__((weak)) read_persistent_clock(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* timekeeping_init - Initializes the clocksource and common timekeeping values
|
|
|
|
*/
|
|
|
|
void __init timekeeping_init(void)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned long sec = read_persistent_clock();
|
|
|
|
|
|
|
|
write_seqlock_irqsave(&xtime_lock, flags);
|
|
|
|
|
2008-05-01 13:34:41 +02:00
|
|
|
ntp_init();
|
2007-05-08 09:27:59 +02:00
|
|
|
|
|
|
|
clock = clocksource_get_next();
|
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
|
|
|
clocksource_calculate_interval(clock, NTP_INTERVAL_LENGTH);
|
2007-05-08 09:27:59 +02:00
|
|
|
clock->cycle_last = clocksource_read(clock);
|
|
|
|
|
|
|
|
xtime.tv_sec = sec;
|
|
|
|
xtime.tv_nsec = 0;
|
|
|
|
set_normalized_timespec(&wall_to_monotonic,
|
|
|
|
-xtime.tv_sec, -xtime.tv_nsec);
|
2008-02-01 17:45:13 +01:00
|
|
|
update_xtime_cache(0);
|
2007-07-16 08:39:41 +02:00
|
|
|
total_sleep_time = 0;
|
2007-05-08 09:27:59 +02:00
|
|
|
write_sequnlock_irqrestore(&xtime_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* flag for if timekeeping is suspended */
|
|
|
|
static int timekeeping_suspended;
|
|
|
|
/* time in seconds when suspend began */
|
|
|
|
static unsigned long timekeeping_suspend_time;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* timekeeping_resume - Resumes the generic timekeeping subsystem.
|
|
|
|
* @dev: unused
|
|
|
|
*
|
|
|
|
* This is for the generic clocksource timekeeping.
|
|
|
|
* xtime/wall_to_monotonic/jiffies/etc are
|
|
|
|
* still managed by arch specific suspend/resume code.
|
|
|
|
*/
|
|
|
|
static int timekeeping_resume(struct sys_device *dev)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned long now = read_persistent_clock();
|
|
|
|
|
2007-05-14 11:10:02 +02:00
|
|
|
clocksource_resume();
|
|
|
|
|
2007-05-08 09:27:59 +02:00
|
|
|
write_seqlock_irqsave(&xtime_lock, flags);
|
|
|
|
|
|
|
|
if (now && (now > timekeeping_suspend_time)) {
|
|
|
|
unsigned long sleep_length = now - timekeeping_suspend_time;
|
|
|
|
|
|
|
|
xtime.tv_sec += sleep_length;
|
|
|
|
wall_to_monotonic.tv_sec -= sleep_length;
|
2007-07-16 08:39:41 +02:00
|
|
|
total_sleep_time += sleep_length;
|
2007-05-08 09:27:59 +02:00
|
|
|
}
|
2008-02-01 17:45:13 +01:00
|
|
|
update_xtime_cache(0);
|
2007-05-08 09:27:59 +02:00
|
|
|
/* re-base the last cycle value */
|
2008-04-01 19:45:18 +02:00
|
|
|
clock->cycle_last = 0;
|
2007-05-08 09:27:59 +02:00
|
|
|
clock->cycle_last = clocksource_read(clock);
|
|
|
|
clock->error = 0;
|
|
|
|
timekeeping_suspended = 0;
|
|
|
|
write_sequnlock_irqrestore(&xtime_lock, flags);
|
|
|
|
|
|
|
|
touch_softlockup_watchdog();
|
|
|
|
|
|
|
|
clockevents_notify(CLOCK_EVT_NOTIFY_RESUME, NULL);
|
|
|
|
|
|
|
|
/* Resume hrtimers */
|
|
|
|
hres_timers_resume();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int timekeeping_suspend(struct sys_device *dev, pm_message_t state)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
2007-09-16 15:36:43 +02:00
|
|
|
timekeeping_suspend_time = read_persistent_clock();
|
|
|
|
|
2007-05-08 09:27:59 +02:00
|
|
|
write_seqlock_irqsave(&xtime_lock, flags);
|
2008-08-21 01:37:28 +02:00
|
|
|
clocksource_forward_now();
|
2007-05-08 09:27:59 +02:00
|
|
|
timekeeping_suspended = 1;
|
|
|
|
write_sequnlock_irqrestore(&xtime_lock, flags);
|
|
|
|
|
|
|
|
clockevents_notify(CLOCK_EVT_NOTIFY_SUSPEND, NULL);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* sysfs resume/suspend bits for timekeeping */
|
|
|
|
static struct sysdev_class timekeeping_sysclass = {
|
2007-12-20 02:09:39 +01:00
|
|
|
.name = "timekeeping",
|
2007-05-08 09:27:59 +02:00
|
|
|
.resume = timekeeping_resume,
|
|
|
|
.suspend = timekeeping_suspend,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct sys_device device_timer = {
|
|
|
|
.id = 0,
|
|
|
|
.cls = &timekeeping_sysclass,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init timekeeping_init_device(void)
|
|
|
|
{
|
|
|
|
int error = sysdev_class_register(&timekeeping_sysclass);
|
|
|
|
if (!error)
|
|
|
|
error = sysdev_register(&device_timer);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
device_initcall(timekeeping_init_device);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the error is already larger, we look ahead even further
|
|
|
|
* to compensate for late or lost adjustments.
|
|
|
|
*/
|
|
|
|
static __always_inline int clocksource_bigadjust(s64 error, s64 *interval,
|
|
|
|
s64 *offset)
|
|
|
|
{
|
|
|
|
s64 tick_error, i;
|
|
|
|
u32 look_ahead, adj;
|
|
|
|
s32 error2, mult;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Use the current error value to determine how much to look ahead.
|
|
|
|
* The larger the error the slower we adjust for it to avoid problems
|
|
|
|
* with losing too many ticks, otherwise we would overadjust and
|
|
|
|
* produce an even larger error. The smaller the adjustment the
|
|
|
|
* faster we try to adjust for it, as lost ticks can do less harm
|
2008-02-08 13:19:25 +01:00
|
|
|
* here. This is tuned so that an error of about 1 msec is adjusted
|
2007-05-08 09:27:59 +02:00
|
|
|
* within about 1 sec (or 2^20 nsec in 2^SHIFT_HZ ticks).
|
|
|
|
*/
|
2008-05-01 13:34:38 +02:00
|
|
|
error2 = clock->error >> (NTP_SCALE_SHIFT + 22 - 2 * SHIFT_HZ);
|
2007-05-08 09:27:59 +02:00
|
|
|
error2 = abs(error2);
|
|
|
|
for (look_ahead = 0; error2 > 0; look_ahead++)
|
|
|
|
error2 >>= 2;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now calculate the error in (1 << look_ahead) ticks, but first
|
|
|
|
* remove the single look ahead already included in the error.
|
|
|
|
*/
|
2008-05-01 13:34:39 +02:00
|
|
|
tick_error = tick_length >> (NTP_SCALE_SHIFT - clock->shift + 1);
|
2007-05-08 09:27:59 +02:00
|
|
|
tick_error -= clock->xtime_interval >> 1;
|
|
|
|
error = ((error - tick_error) >> look_ahead) + tick_error;
|
|
|
|
|
|
|
|
/* Finally calculate the adjustment shift value. */
|
|
|
|
i = *interval;
|
|
|
|
mult = 1;
|
|
|
|
if (error < 0) {
|
|
|
|
error = -error;
|
|
|
|
*interval = -*interval;
|
|
|
|
*offset = -*offset;
|
|
|
|
mult = -1;
|
|
|
|
}
|
|
|
|
for (adj = 0; error > i; adj++)
|
|
|
|
error >>= 1;
|
|
|
|
|
|
|
|
*interval <<= adj;
|
|
|
|
*offset <<= adj;
|
|
|
|
return mult << adj;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Adjust the multiplier to reduce the error value,
|
|
|
|
* this is optimized for the most common adjustments of -1,0,1,
|
|
|
|
* for other values we can do a bit more work.
|
|
|
|
*/
|
2007-07-19 10:49:16 +02:00
|
|
|
static void clocksource_adjust(s64 offset)
|
2007-05-08 09:27:59 +02:00
|
|
|
{
|
|
|
|
s64 error, interval = clock->cycle_interval;
|
|
|
|
int adj;
|
|
|
|
|
2008-05-01 13:34:38 +02:00
|
|
|
error = clock->error >> (NTP_SCALE_SHIFT - clock->shift - 1);
|
2007-05-08 09:27:59 +02:00
|
|
|
if (error > interval) {
|
|
|
|
error >>= 2;
|
|
|
|
if (likely(error <= interval))
|
|
|
|
adj = 1;
|
|
|
|
else
|
|
|
|
adj = clocksource_bigadjust(error, &interval, &offset);
|
|
|
|
} else if (error < -interval) {
|
|
|
|
error >>= 2;
|
|
|
|
if (likely(error >= -interval)) {
|
|
|
|
adj = -1;
|
|
|
|
interval = -interval;
|
|
|
|
offset = -offset;
|
|
|
|
} else
|
|
|
|
adj = clocksource_bigadjust(error, &interval, &offset);
|
|
|
|
} else
|
|
|
|
return;
|
|
|
|
|
|
|
|
clock->mult += adj;
|
|
|
|
clock->xtime_interval += interval;
|
|
|
|
clock->xtime_nsec -= offset;
|
|
|
|
clock->error -= (interval - offset) <<
|
2008-05-01 13:34:38 +02:00
|
|
|
(NTP_SCALE_SHIFT - clock->shift);
|
2007-05-08 09:27:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* update_wall_time - Uses the current clocksource to increment the wall time
|
|
|
|
*
|
|
|
|
* Called from the timer interrupt, must hold a write on xtime_lock.
|
|
|
|
*/
|
|
|
|
void update_wall_time(void)
|
|
|
|
{
|
|
|
|
cycle_t offset;
|
|
|
|
|
|
|
|
/* Make sure we're fully resumed: */
|
|
|
|
if (unlikely(timekeeping_suspended))
|
|
|
|
return;
|
|
|
|
|
|
|
|
#ifdef CONFIG_GENERIC_TIME
|
|
|
|
offset = (clocksource_read(clock) - clock->cycle_last) & clock->mask;
|
|
|
|
#else
|
|
|
|
offset = clock->cycle_interval;
|
|
|
|
#endif
|
2008-09-22 23:42:43 +02:00
|
|
|
clock->xtime_nsec = (s64)xtime.tv_nsec << clock->shift;
|
2007-05-08 09:27:59 +02:00
|
|
|
|
|
|
|
/* normally this loop will run just once, however in the
|
|
|
|
* case of lost or late ticks, it will accumulate correctly.
|
|
|
|
*/
|
|
|
|
while (offset >= clock->cycle_interval) {
|
|
|
|
/* accumulate one interval */
|
|
|
|
offset -= clock->cycle_interval;
|
2008-08-21 01:37:28 +02:00
|
|
|
clock->cycle_last += clock->cycle_interval;
|
2007-05-08 09:27:59 +02:00
|
|
|
|
2008-08-21 01:37:28 +02:00
|
|
|
clock->xtime_nsec += clock->xtime_interval;
|
2007-05-08 09:27:59 +02:00
|
|
|
if (clock->xtime_nsec >= (u64)NSEC_PER_SEC << clock->shift) {
|
|
|
|
clock->xtime_nsec -= (u64)NSEC_PER_SEC << clock->shift;
|
|
|
|
xtime.tv_sec++;
|
|
|
|
second_overflow();
|
|
|
|
}
|
|
|
|
|
2008-08-21 01:37:30 +02:00
|
|
|
clock->raw_time.tv_nsec += clock->raw_interval;
|
|
|
|
if (clock->raw_time.tv_nsec >= NSEC_PER_SEC) {
|
|
|
|
clock->raw_time.tv_nsec -= NSEC_PER_SEC;
|
|
|
|
clock->raw_time.tv_sec++;
|
|
|
|
}
|
|
|
|
|
2007-05-08 09:27:59 +02:00
|
|
|
/* accumulate error between NTP and clock interval */
|
2008-05-01 13:34:39 +02:00
|
|
|
clock->error += tick_length;
|
2008-05-01 13:34:38 +02:00
|
|
|
clock->error -= clock->xtime_interval << (NTP_SCALE_SHIFT - clock->shift);
|
2007-05-08 09:27:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* correct the clock when NTP error is too big */
|
2007-07-19 10:49:16 +02:00
|
|
|
clocksource_adjust(offset);
|
2007-05-08 09:27:59 +02:00
|
|
|
|
time: catch xtime_nsec underflows and fix them
Impact: fix time warp bug
Alex Shi, along with Yanmin Zhang have been noticing occasional time
inconsistencies recently. Through their great diagnosis, they found that
the xtime_nsec value used in update_wall_time was occasionally going
negative. After looking through the code for awhile, I realized we have
the possibility for an underflow when three conditions are met in
update_wall_time():
1) We have accumulated a second's worth of nanoseconds, so we
incremented xtime.tv_sec and appropriately decrement xtime_nsec.
(This doesn't cause xtime_nsec to go negative, but it can cause it
to be small).
2) The remaining offset value is large, but just slightly less then
cycle_interval.
3) clocksource_adjust() is speeding up the clock, causing a
corrective amount (compensating for the increase in the multiplier
being multiplied against the unaccumulated offset value) to be
subtracted from xtime_nsec.
This can cause xtime_nsec to underflow.
Unfortunately, since we notify the NTP subsystem via second_overflow()
whenever we accumulate a full second, and this effects the error
accumulation that has already occured, we cannot simply revert the
accumulated second from xtime nor move the second accumulation to after
the clocksource_adjust call without a change in behavior.
This leaves us with (at least) two options:
1) Simply return from clocksource_adjust() without making a change if we
notice the adjustment would cause xtime_nsec to go negative.
This would work, but I'm concerned that if a large adjustment was needed
(due to the error being large), it may be possible to get stuck with an
ever increasing error that becomes too large to correct (since it may
always force xtime_nsec negative). This may just be paranoia on my part.
2) Catch xtime_nsec if it is negative, then add back the amount its
negative to both xtime_nsec and the error.
This second method is consistent with how we've handled earlier rounding
issues, and also has the benefit that the error being added is always in
the oposite direction also always equal or smaller then the correction
being applied. So the risk of a corner case where things get out of
control is lessened.
This patch fixes bug 11970, as tested by Yanmin Zhang
http://bugzilla.kernel.org/show_bug.cgi?id=11970
Reported-by: alex.shi@intel.com
Signed-off-by: John Stultz <johnstul@us.ibm.com>
Acked-by: "Zhang, Yanmin" <yanmin_zhang@linux.intel.com>
Tested-by: "Zhang, Yanmin" <yanmin_zhang@linux.intel.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-12-02 03:34:41 +01:00
|
|
|
/*
|
|
|
|
* Since in the loop above, we accumulate any amount of time
|
|
|
|
* in xtime_nsec over a second into xtime.tv_sec, its possible for
|
|
|
|
* xtime_nsec to be fairly small after the loop. Further, if we're
|
|
|
|
* slightly speeding the clocksource up in clocksource_adjust(),
|
|
|
|
* its possible the required corrective factor to xtime_nsec could
|
|
|
|
* cause it to underflow.
|
|
|
|
*
|
|
|
|
* Now, we cannot simply roll the accumulated second back, since
|
|
|
|
* the NTP subsystem has been notified via second_overflow. So
|
|
|
|
* instead we push xtime_nsec forward by the amount we underflowed,
|
|
|
|
* and add that amount into the error.
|
|
|
|
*
|
|
|
|
* We'll correct this error next time through this function, when
|
|
|
|
* xtime_nsec is not as small.
|
|
|
|
*/
|
|
|
|
if (unlikely((s64)clock->xtime_nsec < 0)) {
|
|
|
|
s64 neg = -(s64)clock->xtime_nsec;
|
|
|
|
clock->xtime_nsec = 0;
|
|
|
|
clock->error += neg << (NTP_SCALE_SHIFT - clock->shift);
|
|
|
|
}
|
|
|
|
|
2008-09-22 23:42:43 +02:00
|
|
|
/* store full nanoseconds into xtime after rounding it up and
|
|
|
|
* add the remainder to the error difference.
|
|
|
|
*/
|
|
|
|
xtime.tv_nsec = ((s64)clock->xtime_nsec >> clock->shift) + 1;
|
2007-05-08 09:27:59 +02:00
|
|
|
clock->xtime_nsec -= (s64)xtime.tv_nsec << clock->shift;
|
2008-09-22 23:42:43 +02:00
|
|
|
clock->error += clock->xtime_nsec << (NTP_SCALE_SHIFT - clock->shift);
|
2007-05-08 09:27:59 +02:00
|
|
|
|
2007-07-25 03:38:34 +02:00
|
|
|
update_xtime_cache(cyc2ns(clock, offset));
|
|
|
|
|
2007-05-08 09:27:59 +02:00
|
|
|
/* check to see if there is a new clocksource to use */
|
|
|
|
change_clocksource();
|
|
|
|
update_vsyscall(&xtime, clock);
|
|
|
|
}
|
2007-07-16 08:39:41 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* getboottime - Return the real time of system boot.
|
|
|
|
* @ts: pointer to the timespec to be set
|
|
|
|
*
|
|
|
|
* Returns the time of day in a timespec.
|
|
|
|
*
|
|
|
|
* This is based on the wall_to_monotonic offset and the total suspend
|
|
|
|
* time. Calls to settimeofday will affect the value returned (which
|
|
|
|
* basically means that however wrong your real time clock is at boot time,
|
|
|
|
* you get the right time here).
|
|
|
|
*/
|
|
|
|
void getboottime(struct timespec *ts)
|
|
|
|
{
|
|
|
|
set_normalized_timespec(ts,
|
|
|
|
- (wall_to_monotonic.tv_sec + total_sleep_time),
|
|
|
|
- wall_to_monotonic.tv_nsec);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* monotonic_to_bootbased - Convert the monotonic time to boot based.
|
|
|
|
* @ts: pointer to the timespec to be converted
|
|
|
|
*/
|
|
|
|
void monotonic_to_bootbased(struct timespec *ts)
|
|
|
|
{
|
|
|
|
ts->tv_sec += total_sleep_time;
|
|
|
|
}
|
2007-07-25 02:47:43 +02:00
|
|
|
|
2007-07-25 03:38:34 +02:00
|
|
|
unsigned long get_seconds(void)
|
|
|
|
{
|
|
|
|
return xtime_cache.tv_sec;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(get_seconds);
|
|
|
|
|
|
|
|
|
2007-07-25 02:47:43 +02:00
|
|
|
struct timespec current_kernel_time(void)
|
|
|
|
{
|
|
|
|
struct timespec now;
|
|
|
|
unsigned long seq;
|
|
|
|
|
|
|
|
do {
|
|
|
|
seq = read_seqbegin(&xtime_lock);
|
|
|
|
|
2007-07-25 03:38:34 +02:00
|
|
|
now = xtime_cache;
|
2007-07-25 02:47:43 +02:00
|
|
|
} while (read_seqretry(&xtime_lock, seq));
|
|
|
|
|
|
|
|
return now;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(current_kernel_time);
|