2008-05-03 10:29:28 -06:00
|
|
|
/*
|
|
|
|
* sched_clock for unstable cpu clocks
|
|
|
|
*
|
|
|
|
* Copyright (C) 2008 Red Hat, Inc., Peter Zijlstra <pzijlstr@redhat.com>
|
|
|
|
*
|
2008-07-08 22:15:33 -06:00
|
|
|
* Updates and enhancements:
|
|
|
|
* Copyright (C) 2008 Red Hat, Inc. Steven Rostedt <srostedt@redhat.com>
|
|
|
|
*
|
2008-05-03 10:29:28 -06:00
|
|
|
* Based on code by:
|
|
|
|
* Ingo Molnar <mingo@redhat.com>
|
|
|
|
* Guillaume Chazarain <guichaz@gmail.com>
|
|
|
|
*
|
2010-05-25 02:48:51 -06:00
|
|
|
*
|
|
|
|
* What:
|
|
|
|
*
|
|
|
|
* cpu_clock(i) provides a fast (execution time) high resolution
|
|
|
|
* clock with bounded drift between CPUs. The value of cpu_clock(i)
|
|
|
|
* is monotonic for constant i. The timestamp returned is in nanoseconds.
|
|
|
|
*
|
|
|
|
* ######################### BIG FAT WARNING ##########################
|
|
|
|
* # when comparing cpu_clock(i) to cpu_clock(j) for i != j, time can #
|
|
|
|
* # go backwards !! #
|
|
|
|
* ####################################################################
|
|
|
|
*
|
|
|
|
* There is no strict promise about the base, although it tends to start
|
|
|
|
* at 0 on boot (but people really shouldn't rely on that).
|
|
|
|
*
|
|
|
|
* cpu_clock(i) -- can be used from any context, including NMI.
|
|
|
|
* local_clock() -- is cpu_clock() on the current cpu.
|
|
|
|
*
|
2013-11-28 11:31:23 -07:00
|
|
|
* sched_clock_cpu(i)
|
|
|
|
*
|
2010-05-25 02:48:51 -06:00
|
|
|
* How:
|
|
|
|
*
|
|
|
|
* The implementation either uses sched_clock() when
|
|
|
|
* !CONFIG_HAVE_UNSTABLE_SCHED_CLOCK, which means in that case the
|
|
|
|
* sched_clock() is assumed to provide these properties (mostly it means
|
|
|
|
* the architecture provides a globally synchronized highres time source).
|
|
|
|
*
|
|
|
|
* Otherwise it tries to create a semi stable clock from a mixture of other
|
|
|
|
* clocks, including:
|
|
|
|
*
|
|
|
|
* - GTOD (clock monotomic)
|
2008-05-03 10:29:28 -06:00
|
|
|
* - sched_clock()
|
|
|
|
* - explicit idle events
|
|
|
|
*
|
2010-05-25 02:48:51 -06:00
|
|
|
* We use GTOD as base and use sched_clock() deltas to improve resolution. The
|
|
|
|
* deltas are filtered to provide monotonicity and keeping it within an
|
|
|
|
* expected window.
|
2008-05-03 10:29:28 -06:00
|
|
|
*
|
|
|
|
* Furthermore, explicit sleep and wakeup hooks allow us to account for time
|
|
|
|
* that is otherwise invisible (TSC gets stopped).
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
#include <linux/spinlock.h>
|
2008-05-12 13:21:14 -06:00
|
|
|
#include <linux/hardirq.h>
|
2011-05-23 12:51:41 -06:00
|
|
|
#include <linux/export.h>
|
2009-02-26 12:20:29 -07:00
|
|
|
#include <linux/percpu.h>
|
|
|
|
#include <linux/ktime.h>
|
|
|
|
#include <linux/sched.h>
|
2013-11-28 11:38:42 -07:00
|
|
|
#include <linux/static_key.h>
|
2013-12-11 10:55:53 -07:00
|
|
|
#include <linux/workqueue.h>
|
2008-05-03 10:29:28 -06:00
|
|
|
|
2008-07-25 12:45:00 -06:00
|
|
|
/*
|
|
|
|
* Scheduler clock - returns current time in nanosec units.
|
|
|
|
* This is default implementation.
|
|
|
|
* Architectures and sub-architectures can override this.
|
|
|
|
*/
|
|
|
|
unsigned long long __attribute__((weak)) sched_clock(void)
|
|
|
|
{
|
2009-05-08 07:24:49 -06:00
|
|
|
return (unsigned long long)(jiffies - INITIAL_JIFFIES)
|
|
|
|
* (NSEC_PER_SEC / HZ);
|
2008-07-25 12:45:00 -06:00
|
|
|
}
|
2010-04-15 00:54:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(sched_clock);
|
2008-05-03 10:29:28 -06:00
|
|
|
|
2010-11-19 13:11:09 -07:00
|
|
|
__read_mostly int sched_clock_running;
|
2008-08-11 00:59:03 -06:00
|
|
|
|
2008-05-03 10:29:28 -06:00
|
|
|
#ifdef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
|
2013-11-28 11:38:42 -07:00
|
|
|
static struct static_key __sched_clock_stable = STATIC_KEY_INIT;
|
|
|
|
|
|
|
|
int sched_clock_stable(void)
|
|
|
|
{
|
|
|
|
if (static_key_false(&__sched_clock_stable))
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void set_sched_clock_stable(void)
|
|
|
|
{
|
|
|
|
if (!sched_clock_stable())
|
|
|
|
static_key_slow_dec(&__sched_clock_stable);
|
|
|
|
}
|
|
|
|
|
2013-12-11 10:55:53 -07:00
|
|
|
static void __clear_sched_clock_stable(struct work_struct *work)
|
2013-11-28 11:38:42 -07:00
|
|
|
{
|
|
|
|
/* XXX worry about clock continuity */
|
|
|
|
if (sched_clock_stable())
|
|
|
|
static_key_slow_inc(&__sched_clock_stable);
|
|
|
|
}
|
2008-05-03 10:29:28 -06:00
|
|
|
|
2013-12-11 10:55:53 -07:00
|
|
|
static DECLARE_WORK(sched_clock_work, __clear_sched_clock_stable);
|
|
|
|
|
|
|
|
void clear_sched_clock_stable(void)
|
|
|
|
{
|
|
|
|
if (keventd_up())
|
|
|
|
schedule_work(&sched_clock_work);
|
|
|
|
else
|
|
|
|
__clear_sched_clock_stable(&sched_clock_work);
|
|
|
|
}
|
|
|
|
|
2008-05-03 10:29:28 -06:00
|
|
|
struct sched_clock_data {
|
|
|
|
u64 tick_raw;
|
|
|
|
u64 tick_gtod;
|
|
|
|
u64 clock;
|
|
|
|
};
|
|
|
|
|
|
|
|
static DEFINE_PER_CPU_SHARED_ALIGNED(struct sched_clock_data, sched_clock_data);
|
|
|
|
|
|
|
|
static inline struct sched_clock_data *this_scd(void)
|
|
|
|
{
|
|
|
|
return &__get_cpu_var(sched_clock_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct sched_clock_data *cpu_sdc(int cpu)
|
|
|
|
{
|
|
|
|
return &per_cpu(sched_clock_data, cpu);
|
|
|
|
}
|
|
|
|
|
|
|
|
void sched_clock_init(void)
|
|
|
|
{
|
|
|
|
u64 ktime_now = ktime_to_ns(ktime_get());
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
struct sched_clock_data *scd = cpu_sdc(cpu);
|
|
|
|
|
2008-05-29 02:07:15 -06:00
|
|
|
scd->tick_raw = 0;
|
2008-05-03 10:29:28 -06:00
|
|
|
scd->tick_gtod = ktime_now;
|
|
|
|
scd->clock = ktime_now;
|
|
|
|
}
|
2008-05-29 02:07:15 -06:00
|
|
|
|
|
|
|
sched_clock_running = 1;
|
2008-05-03 10:29:28 -06:00
|
|
|
}
|
|
|
|
|
2008-08-25 09:15:34 -06:00
|
|
|
/*
|
2009-02-26 12:20:29 -07:00
|
|
|
* min, max except they take wrapping into account
|
2008-08-25 09:15:34 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
static inline u64 wrap_min(u64 x, u64 y)
|
|
|
|
{
|
|
|
|
return (s64)(x - y) < 0 ? x : y;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u64 wrap_max(u64 x, u64 y)
|
|
|
|
{
|
|
|
|
return (s64)(x - y) > 0 ? x : y;
|
|
|
|
}
|
|
|
|
|
2008-05-03 10:29:28 -06:00
|
|
|
/*
|
|
|
|
* update the percpu scd from the raw @now value
|
|
|
|
*
|
|
|
|
* - filter out backward motion
|
2008-08-25 09:15:34 -06:00
|
|
|
* - use the GTOD tick value to create a window to filter crazy TSC values
|
2008-05-03 10:29:28 -06:00
|
|
|
*/
|
2009-09-18 12:14:01 -06:00
|
|
|
static u64 sched_clock_local(struct sched_clock_data *scd)
|
2008-05-03 10:29:28 -06:00
|
|
|
{
|
2009-09-18 12:14:01 -06:00
|
|
|
u64 now, clock, old_clock, min_clock, max_clock;
|
|
|
|
s64 delta;
|
2008-05-03 10:29:28 -06:00
|
|
|
|
2009-09-18 12:14:01 -06:00
|
|
|
again:
|
|
|
|
now = sched_clock();
|
|
|
|
delta = now - scd->tick_raw;
|
2008-08-25 09:15:34 -06:00
|
|
|
if (unlikely(delta < 0))
|
|
|
|
delta = 0;
|
2008-05-03 10:29:28 -06:00
|
|
|
|
2009-09-18 12:14:01 -06:00
|
|
|
old_clock = scd->clock;
|
|
|
|
|
2008-08-25 09:15:34 -06:00
|
|
|
/*
|
|
|
|
* scd->clock = clamp(scd->tick_gtod + delta,
|
2009-02-26 12:20:29 -07:00
|
|
|
* max(scd->tick_gtod, scd->clock),
|
|
|
|
* scd->tick_gtod + TICK_NSEC);
|
2008-08-25 09:15:34 -06:00
|
|
|
*/
|
2008-05-03 10:29:28 -06:00
|
|
|
|
2008-08-25 09:15:34 -06:00
|
|
|
clock = scd->tick_gtod + delta;
|
2009-09-18 12:14:01 -06:00
|
|
|
min_clock = wrap_max(scd->tick_gtod, old_clock);
|
|
|
|
max_clock = wrap_max(old_clock, scd->tick_gtod + TICK_NSEC);
|
2008-05-03 10:29:28 -06:00
|
|
|
|
2008-08-25 09:15:34 -06:00
|
|
|
clock = wrap_max(clock, min_clock);
|
|
|
|
clock = wrap_min(clock, max_clock);
|
2008-05-03 10:29:28 -06:00
|
|
|
|
2009-09-30 12:36:19 -06:00
|
|
|
if (cmpxchg64(&scd->clock, old_clock, clock) != old_clock)
|
2009-09-18 12:14:01 -06:00
|
|
|
goto again;
|
2008-07-30 02:15:55 -06:00
|
|
|
|
2009-09-18 12:14:01 -06:00
|
|
|
return clock;
|
2008-05-03 10:29:28 -06:00
|
|
|
}
|
|
|
|
|
2009-09-18 12:14:01 -06:00
|
|
|
static u64 sched_clock_remote(struct sched_clock_data *scd)
|
2008-05-03 10:29:28 -06:00
|
|
|
{
|
2009-09-18 12:14:01 -06:00
|
|
|
struct sched_clock_data *my_scd = this_scd();
|
|
|
|
u64 this_clock, remote_clock;
|
|
|
|
u64 *ptr, old_val, val;
|
|
|
|
|
sched_clock: Prevent 64bit inatomicity on 32bit systems
The sched_clock_remote() implementation has the following inatomicity
problem on 32bit systems when accessing the remote scd->clock, which
is a 64bit value.
CPU0 CPU1
sched_clock_local() sched_clock_remote(CPU0)
...
remote_clock = scd[CPU0]->clock
read_low32bit(scd[CPU0]->clock)
cmpxchg64(scd->clock,...)
read_high32bit(scd[CPU0]->clock)
While the update of scd->clock is using an atomic64 mechanism, the
readout on the remote cpu is not, which can cause completely bogus
readouts.
It is a quite rare problem, because it requires the update to hit the
narrow race window between the low/high readout and the update must go
across the 32bit boundary.
The resulting misbehaviour is, that CPU1 will see the sched_clock on
CPU1 ~4 seconds ahead of it's own and update CPU1s sched_clock value
to this bogus timestamp. This stays that way due to the clamping
implementation for about 4 seconds until the synchronization with
CLOCK_MONOTONIC undoes the problem.
The issue is hard to observe, because it might only result in a less
accurate SCHED_OTHER timeslicing behaviour. To create observable
damage on realtime scheduling classes, it is necessary that the bogus
update of CPU1 sched_clock happens in the context of an realtime
thread, which then gets charged 4 seconds of RT runtime, which results
in the RT throttler mechanism to trigger and prevent scheduling of RT
tasks for a little less than 4 seconds. So this is quite unlikely as
well.
The issue was quite hard to decode as the reproduction time is between
2 days and 3 weeks and intrusive tracing makes it less likely, but the
following trace recorded with trace_clock=global, which uses
sched_clock_local(), gave the final hint:
<idle>-0 0d..30 400269.477150: hrtimer_cancel: hrtimer=0xf7061e80
<idle>-0 0d..30 400269.477151: hrtimer_start: hrtimer=0xf7061e80 ...
irq/20-S-587 1d..32 400273.772118: sched_wakeup: comm= ... target_cpu=0
<idle>-0 0dN.30 400273.772118: hrtimer_cancel: hrtimer=0xf7061e80
What happens is that CPU0 goes idle and invokes
sched_clock_idle_sleep_event() which invokes sched_clock_local() and
CPU1 runs a remote wakeup for CPU0 at the same time, which invokes
sched_remote_clock(). The time jump gets propagated to CPU0 via
sched_remote_clock() and stays stale on both cores for ~4 seconds.
There are only two other possibilities, which could cause a stale
sched clock:
1) ktime_get() which reads out CLOCK_MONOTONIC returns a sporadic
wrong value.
2) sched_clock() which reads the TSC returns a sporadic wrong value.
#1 can be excluded because sched_clock would continue to increase for
one jiffy and then go stale.
#2 can be excluded because it would not make the clock jump
forward. It would just result in a stale sched_clock for one jiffy.
After quite some brain twisting and finding the same pattern on other
traces, sched_clock_remote() remained the only place which could cause
such a problem and as explained above it's indeed racy on 32bit
systems.
So while on 64bit systems the readout is atomic, we need to verify the
remote readout on 32bit machines. We need to protect the local->clock
readout in sched_clock_remote() on 32bit as well because an NMI could
hit between the low and the high readout, call sched_clock_local() and
modify local->clock.
Thanks to Siegfried Wulsch for bearing with my debug requests and
going through the tedious tasks of running a bunch of reproducer
systems to generate the debug information which let me decode the
issue.
Reported-by: Siegfried Wulsch <Siegfried.Wulsch@rovema.de>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Steven Rostedt <rostedt@goodmis.org>
Link: http://lkml.kernel.org/r/alpine.LFD.2.02.1304051544160.21884@ionos
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: stable@vger.kernel.org
2013-04-06 02:10:27 -06:00
|
|
|
#if BITS_PER_LONG != 64
|
|
|
|
again:
|
|
|
|
/*
|
|
|
|
* Careful here: The local and the remote clock values need to
|
|
|
|
* be read out atomic as we need to compare the values and
|
|
|
|
* then update either the local or the remote side. So the
|
|
|
|
* cmpxchg64 below only protects one readout.
|
|
|
|
*
|
|
|
|
* We must reread via sched_clock_local() in the retry case on
|
|
|
|
* 32bit as an NMI could use sched_clock_local() via the
|
|
|
|
* tracer and hit between the readout of
|
|
|
|
* the low32bit and the high 32bit portion.
|
|
|
|
*/
|
|
|
|
this_clock = sched_clock_local(my_scd);
|
|
|
|
/*
|
|
|
|
* We must enforce atomic readout on 32bit, otherwise the
|
|
|
|
* update on the remote cpu can hit inbetween the readout of
|
|
|
|
* the low32bit and the high 32bit portion.
|
|
|
|
*/
|
|
|
|
remote_clock = cmpxchg64(&scd->clock, 0, 0);
|
|
|
|
#else
|
|
|
|
/*
|
|
|
|
* On 64bit the read of [my]scd->clock is atomic versus the
|
|
|
|
* update, so we can avoid the above 32bit dance.
|
|
|
|
*/
|
2009-09-18 12:14:01 -06:00
|
|
|
sched_clock_local(my_scd);
|
|
|
|
again:
|
|
|
|
this_clock = my_scd->clock;
|
|
|
|
remote_clock = scd->clock;
|
sched_clock: Prevent 64bit inatomicity on 32bit systems
The sched_clock_remote() implementation has the following inatomicity
problem on 32bit systems when accessing the remote scd->clock, which
is a 64bit value.
CPU0 CPU1
sched_clock_local() sched_clock_remote(CPU0)
...
remote_clock = scd[CPU0]->clock
read_low32bit(scd[CPU0]->clock)
cmpxchg64(scd->clock,...)
read_high32bit(scd[CPU0]->clock)
While the update of scd->clock is using an atomic64 mechanism, the
readout on the remote cpu is not, which can cause completely bogus
readouts.
It is a quite rare problem, because it requires the update to hit the
narrow race window between the low/high readout and the update must go
across the 32bit boundary.
The resulting misbehaviour is, that CPU1 will see the sched_clock on
CPU1 ~4 seconds ahead of it's own and update CPU1s sched_clock value
to this bogus timestamp. This stays that way due to the clamping
implementation for about 4 seconds until the synchronization with
CLOCK_MONOTONIC undoes the problem.
The issue is hard to observe, because it might only result in a less
accurate SCHED_OTHER timeslicing behaviour. To create observable
damage on realtime scheduling classes, it is necessary that the bogus
update of CPU1 sched_clock happens in the context of an realtime
thread, which then gets charged 4 seconds of RT runtime, which results
in the RT throttler mechanism to trigger and prevent scheduling of RT
tasks for a little less than 4 seconds. So this is quite unlikely as
well.
The issue was quite hard to decode as the reproduction time is between
2 days and 3 weeks and intrusive tracing makes it less likely, but the
following trace recorded with trace_clock=global, which uses
sched_clock_local(), gave the final hint:
<idle>-0 0d..30 400269.477150: hrtimer_cancel: hrtimer=0xf7061e80
<idle>-0 0d..30 400269.477151: hrtimer_start: hrtimer=0xf7061e80 ...
irq/20-S-587 1d..32 400273.772118: sched_wakeup: comm= ... target_cpu=0
<idle>-0 0dN.30 400273.772118: hrtimer_cancel: hrtimer=0xf7061e80
What happens is that CPU0 goes idle and invokes
sched_clock_idle_sleep_event() which invokes sched_clock_local() and
CPU1 runs a remote wakeup for CPU0 at the same time, which invokes
sched_remote_clock(). The time jump gets propagated to CPU0 via
sched_remote_clock() and stays stale on both cores for ~4 seconds.
There are only two other possibilities, which could cause a stale
sched clock:
1) ktime_get() which reads out CLOCK_MONOTONIC returns a sporadic
wrong value.
2) sched_clock() which reads the TSC returns a sporadic wrong value.
#1 can be excluded because sched_clock would continue to increase for
one jiffy and then go stale.
#2 can be excluded because it would not make the clock jump
forward. It would just result in a stale sched_clock for one jiffy.
After quite some brain twisting and finding the same pattern on other
traces, sched_clock_remote() remained the only place which could cause
such a problem and as explained above it's indeed racy on 32bit
systems.
So while on 64bit systems the readout is atomic, we need to verify the
remote readout on 32bit machines. We need to protect the local->clock
readout in sched_clock_remote() on 32bit as well because an NMI could
hit between the low and the high readout, call sched_clock_local() and
modify local->clock.
Thanks to Siegfried Wulsch for bearing with my debug requests and
going through the tedious tasks of running a bunch of reproducer
systems to generate the debug information which let me decode the
issue.
Reported-by: Siegfried Wulsch <Siegfried.Wulsch@rovema.de>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Steven Rostedt <rostedt@goodmis.org>
Link: http://lkml.kernel.org/r/alpine.LFD.2.02.1304051544160.21884@ionos
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: stable@vger.kernel.org
2013-04-06 02:10:27 -06:00
|
|
|
#endif
|
2009-09-18 12:14:01 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Use the opportunity that we have both locks
|
|
|
|
* taken to couple the two clocks: we take the
|
|
|
|
* larger time as the latest time for both
|
|
|
|
* runqueues. (this creates monotonic movement)
|
|
|
|
*/
|
|
|
|
if (likely((s64)(remote_clock - this_clock) < 0)) {
|
|
|
|
ptr = &scd->clock;
|
|
|
|
old_val = remote_clock;
|
|
|
|
val = this_clock;
|
2008-05-03 10:29:28 -06:00
|
|
|
} else {
|
2009-09-18 12:14:01 -06:00
|
|
|
/*
|
|
|
|
* Should be rare, but possible:
|
|
|
|
*/
|
|
|
|
ptr = &my_scd->clock;
|
|
|
|
old_val = this_clock;
|
|
|
|
val = remote_clock;
|
2008-05-03 10:29:28 -06:00
|
|
|
}
|
2009-09-18 12:14:01 -06:00
|
|
|
|
2009-09-30 12:36:19 -06:00
|
|
|
if (cmpxchg64(ptr, old_val, val) != old_val)
|
2009-09-18 12:14:01 -06:00
|
|
|
goto again;
|
|
|
|
|
|
|
|
return val;
|
2008-05-03 10:29:28 -06:00
|
|
|
}
|
|
|
|
|
2010-05-25 02:48:51 -06:00
|
|
|
/*
|
|
|
|
* Similar to cpu_clock(), but requires local IRQs to be disabled.
|
|
|
|
*
|
|
|
|
* See cpu_clock().
|
|
|
|
*/
|
2008-05-03 10:29:28 -06:00
|
|
|
u64 sched_clock_cpu(int cpu)
|
|
|
|
{
|
2009-02-26 12:20:29 -07:00
|
|
|
struct sched_clock_data *scd;
|
2009-09-18 12:14:01 -06:00
|
|
|
u64 clock;
|
|
|
|
|
2013-11-28 11:38:42 -07:00
|
|
|
if (sched_clock_stable())
|
2009-02-26 12:20:29 -07:00
|
|
|
return sched_clock();
|
2008-05-29 02:07:15 -06:00
|
|
|
|
|
|
|
if (unlikely(!sched_clock_running))
|
|
|
|
return 0ull;
|
|
|
|
|
2013-11-28 11:31:23 -07:00
|
|
|
preempt_disable();
|
2009-09-18 12:14:01 -06:00
|
|
|
scd = cpu_sdc(cpu);
|
2008-05-03 10:29:28 -06:00
|
|
|
|
2009-09-18 12:14:01 -06:00
|
|
|
if (cpu != smp_processor_id())
|
|
|
|
clock = sched_clock_remote(scd);
|
|
|
|
else
|
|
|
|
clock = sched_clock_local(scd);
|
2013-11-28 11:31:23 -07:00
|
|
|
preempt_enable();
|
2008-04-14 00:50:02 -06:00
|
|
|
|
2008-05-03 10:29:28 -06:00
|
|
|
return clock;
|
|
|
|
}
|
|
|
|
|
|
|
|
void sched_clock_tick(void)
|
|
|
|
{
|
2009-02-26 13:40:16 -07:00
|
|
|
struct sched_clock_data *scd;
|
2008-05-03 10:29:28 -06:00
|
|
|
u64 now, now_gtod;
|
|
|
|
|
2013-11-28 11:38:42 -07:00
|
|
|
if (sched_clock_stable())
|
2009-02-26 13:40:16 -07:00
|
|
|
return;
|
|
|
|
|
2008-05-29 02:07:15 -06:00
|
|
|
if (unlikely(!sched_clock_running))
|
|
|
|
return;
|
|
|
|
|
2008-05-03 10:29:28 -06:00
|
|
|
WARN_ON_ONCE(!irqs_disabled());
|
|
|
|
|
2009-02-26 13:40:16 -07:00
|
|
|
scd = this_scd();
|
2008-05-03 10:29:28 -06:00
|
|
|
now_gtod = ktime_to_ns(ktime_get());
|
2008-07-08 22:15:32 -06:00
|
|
|
now = sched_clock();
|
2008-05-03 10:29:28 -06:00
|
|
|
|
|
|
|
scd->tick_raw = now;
|
|
|
|
scd->tick_gtod = now_gtod;
|
2009-09-18 12:14:01 -06:00
|
|
|
sched_clock_local(scd);
|
2008-05-03 10:29:28 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We are going deep-idle (irqs are disabled):
|
|
|
|
*/
|
|
|
|
void sched_clock_idle_sleep_event(void)
|
|
|
|
{
|
|
|
|
sched_clock_cpu(smp_processor_id());
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(sched_clock_idle_sleep_event);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We just idled delta nanoseconds (called with irqs disabled):
|
|
|
|
*/
|
|
|
|
void sched_clock_idle_wakeup_event(u64 delta_ns)
|
|
|
|
{
|
2008-12-22 15:05:28 -07:00
|
|
|
if (timekeeping_suspended)
|
|
|
|
return;
|
|
|
|
|
2008-08-25 09:15:34 -06:00
|
|
|
sched_clock_tick();
|
2008-05-03 10:29:28 -06:00
|
|
|
touch_softlockup_watchdog();
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(sched_clock_idle_wakeup_event);
|
|
|
|
|
2010-05-25 02:48:51 -06:00
|
|
|
/*
|
|
|
|
* As outlined at the top, provides a fast, high resolution, nanosecond
|
|
|
|
* time source that is monotonic per cpu argument and has bounded drift
|
|
|
|
* between cpus.
|
|
|
|
*
|
|
|
|
* ######################### BIG FAT WARNING ##########################
|
|
|
|
* # when comparing cpu_clock(i) to cpu_clock(j) for i != j, time can #
|
|
|
|
* # go backwards !! #
|
|
|
|
* ####################################################################
|
|
|
|
*/
|
|
|
|
u64 cpu_clock(int cpu)
|
2009-12-13 19:25:02 -07:00
|
|
|
{
|
2013-11-28 11:38:42 -07:00
|
|
|
if (static_key_false(&__sched_clock_stable))
|
|
|
|
return sched_clock_cpu(cpu);
|
|
|
|
|
|
|
|
return sched_clock();
|
2009-12-13 19:25:02 -07:00
|
|
|
}
|
|
|
|
|
2010-05-25 02:48:51 -06:00
|
|
|
/*
|
|
|
|
* Similar to cpu_clock() for the current cpu. Time will only be observed
|
|
|
|
* to be monotonic if care is taken to only compare timestampt taken on the
|
|
|
|
* same CPU.
|
|
|
|
*
|
|
|
|
* See cpu_clock().
|
|
|
|
*/
|
|
|
|
u64 local_clock(void)
|
|
|
|
{
|
2013-11-28 11:38:42 -07:00
|
|
|
if (static_key_false(&__sched_clock_stable))
|
|
|
|
return sched_clock_cpu(raw_smp_processor_id());
|
|
|
|
|
|
|
|
return sched_clock();
|
2010-05-25 02:48:51 -06:00
|
|
|
}
|
|
|
|
|
2009-02-26 13:40:16 -07:00
|
|
|
#else /* CONFIG_HAVE_UNSTABLE_SCHED_CLOCK */
|
|
|
|
|
|
|
|
void sched_clock_init(void)
|
|
|
|
{
|
|
|
|
sched_clock_running = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
u64 sched_clock_cpu(int cpu)
|
|
|
|
{
|
|
|
|
if (unlikely(!sched_clock_running))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return sched_clock();
|
|
|
|
}
|
|
|
|
|
2010-05-25 02:48:51 -06:00
|
|
|
u64 cpu_clock(int cpu)
|
2008-06-27 05:41:15 -06:00
|
|
|
{
|
2013-11-28 11:38:42 -07:00
|
|
|
return sched_clock();
|
2009-12-13 19:25:02 -07:00
|
|
|
}
|
2008-06-27 05:41:15 -06:00
|
|
|
|
2010-05-25 02:48:51 -06:00
|
|
|
u64 local_clock(void)
|
|
|
|
{
|
2013-11-28 11:38:42 -07:00
|
|
|
return sched_clock();
|
2010-05-25 02:48:51 -06:00
|
|
|
}
|
|
|
|
|
2009-12-13 19:25:02 -07:00
|
|
|
#endif /* CONFIG_HAVE_UNSTABLE_SCHED_CLOCK */
|
2008-06-27 05:41:15 -06:00
|
|
|
|
2008-06-27 06:49:35 -06:00
|
|
|
EXPORT_SYMBOL_GPL(cpu_clock);
|
2010-05-25 02:48:51 -06:00
|
|
|
EXPORT_SYMBOL_GPL(local_clock);
|