#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/clocksource.h>

#include <linux/cpu.h>

#include <linux/delay.h>

#include <linux/device.h>

#include <linux/init.h>

#include <linux/kthread.h>

#include <linux/module.h>

#include <linux/prandom.h>

#include <linux/sched.h>

#include <linux/tick.h>

#include <linux/topology.h>

#include "tick-internal.h"

#include "timekeeping_internal.h"

static void clocksource_enqueue(struct clocksource *cs);

static noinline u64 cycles_to_nsec_safe(struct clocksource *cs, u64 start, u64 end)

{

u64 delta = clocksource_delta(end, start, cs->mask, cs->max_raw_delta);

if (likely(delta < cs->max_cycles))

return clocksource_cyc2ns(delta, cs->mult, cs->shift);

return mul_u64_u32_shr(delta, cs->mult, cs->shift);

}

clocks_calc_mult_shift(u32 *mult, u32 *shift, u32 from, u32 to, u32 maxsec)

{

u64 tmp;

u32 sft, sftacc= 32;

/*

tmp = ((u64)maxsec * from) >> 32;

while (tmp) {

tmp >>=1;

sftacc--;

}

/*

for (sft = 32; sft > 0; sft--) {

tmp = (u64) to << sft;

tmp += from / 2;

do_div(tmp, from);

if ((tmp >> sftacc) == 0)

break;

}

*mult = tmp;

*shift = sft;

}

EXPORT_SYMBOL_GPL(clocks_calc_mult_shift);

static struct clocksource *curr_clocksource;

static struct clocksource *suspend_clocksource;

static LIST_HEAD(clocksource_list);

static DEFINE_MUTEX(clocksource_mutex);

static char override_name[CS_NAME_LEN];

static int finished_booting;

static u64 suspend_start;

#ifdef CONFIG_CLOCKSOURCE_WATCHDOG

static void clocksource_watchdog_work(struct work_struct *work);

static void clocksource_select(void);

static LIST_HEAD(watchdog_list);

static struct clocksource *watchdog;

static struct timer_list watchdog_timer;

static DECLARE_WORK(watchdog_work, clocksource_watchdog_work);

static DEFINE_SPINLOCK(watchdog_lock);

static int watchdog_running;

static atomic_t watchdog_reset_pending;

#define WATCHDOG_INTERVAL (HZ >> 1)

#define WATCHDOG_INTERVAL_NS (WATCHDOG_INTERVAL * (NSEC_PER_SEC / HZ))

#define WATCHDOG_READOUT_MAX_NS (50U * NSEC_PER_USEC)

#define WATCHDOG_DEFAULT_TIMEOUT_NS (50U * NSEC_PER_USEC)

#define WATCHDOG_NUMA_MULTIPLIER_NS ((u64)(WATCHDOG_DEFAULT_TIMEOUT_NS / LOCAL_DISTANCE))

#define WATCHDOG_NUMA_MAX_TIMEOUT_NS ((u64)(500U * NSEC_PER_USEC))

#define SHIFT_500PPM 11

#define SHIFT_4000PPM 8

#define WATCHDOG_FREQ_RETRIES 3

#define WATCHDOG_REMOTE_MAX_SEQ 10

static inline void clocksource_watchdog_lock(unsigned long *flags)

{

spin_lock_irqsave(&watchdog_lock, *flags);

}

static inline void clocksource_watchdog_unlock(unsigned long *flags)

{

spin_unlock_irqrestore(&watchdog_lock, *flags);

}

static int clocksource_watchdog_kthread(void *data);

static void clocksource_watchdog_work(struct work_struct *work)

{

/*

kthread_run(clocksource_watchdog_kthread, NULL, "kwatchdog");

}

static void clocksource_change_rating(struct clocksource *cs, int rating)

{

list_del(&cs->list);

cs->rating = rating;

clocksource_enqueue(cs);

}

static void __clocksource_unstable(struct clocksource *cs)

{

cs->flags &= ~(CLOCK_SOURCE_VALID_FOR_HRES | CLOCK_SOURCE_WATCHDOG);

cs->flags |= CLOCK_SOURCE_UNSTABLE;

/*

if (list_empty(&cs->list)) {

cs->rating = 0;

return;

}

if (cs->mark_unstable)

cs->mark_unstable(cs);

/* kick clocksource_watchdog_kthread() */

if (finished_booting)

schedule_work(&watchdog_work);

}

void clocksource_mark_unstable(struct clocksource *cs)

{

unsigned long flags;

spin_lock_irqsave(&watchdog_lock, flags);

if (!(cs->flags & CLOCK_SOURCE_UNSTABLE)) {

if (!list_empty(&cs->list) && list_empty(&cs->wd_list))

list_add(&cs->wd_list, &watchdog_list);

__clocksource_unstable(cs);

}

spin_unlock_irqrestore(&watchdog_lock, flags);

}

static inline void clocksource_reset_watchdog(void)

{

struct clocksource *cs;

list_for_each_entry(cs, &watchdog_list, wd_list)

cs->flags &= ~CLOCK_SOURCE_WATCHDOG;

}

enum wd_result {

WD_SUCCESS,

WD_FREQ_NO_WATCHDOG,

WD_FREQ_TIMEOUT,

WD_FREQ_RESET,

WD_FREQ_SKEWED,

WD_CPU_TIMEOUT,

WD_CPU_SKEWED,

};

struct watchdog_cpu_data {

/* Keep first as it is 32 byte aligned */

call_single_data_t csd;

atomic_t remote_inprogress;

enum wd_result result;

u64 cpu_ts[2];

struct clocksource *cs;

/* Ensure that the sequence is in a separate cache line */

atomic_t seq ____cacheline_aligned;

/* Set by the control CPU according to NUMA distance */

u64 timeout_ns;

};

struct watchdog_data {

raw_spinlock_t lock;

enum wd_result result;

u64 wd_seq;

u64 wd_delta;

u64 cs_delta;

u64 cpu_ts[2];

unsigned int curr_cpu;

} ____cacheline_aligned_in_smp;

static void watchdog_check_skew_remote(void *unused);

static DEFINE_PER_CPU_ALIGNED(struct watchdog_cpu_data, watchdog_cpu_data) = {

.csd = CSD_INIT(watchdog_check_skew_remote, NULL),

};

static struct watchdog_data watchdog_data = {

.lock = __RAW_SPIN_LOCK_UNLOCKED(watchdog_data.lock),

};

static inline void watchdog_set_result(struct watchdog_cpu_data *wd, enum wd_result result)

{

guard(raw_spinlock)(&watchdog_data.lock);

if (!wd->result) {

atomic_set(&wd->seq, WATCHDOG_REMOTE_MAX_SEQ);

WRITE_ONCE(wd->result, result);

}

}

static bool watchdog_wait_seq(struct watchdog_cpu_data *wd, u64 start, int seq)

{

for(int cnt = 0; atomic_read(&wd->seq) < seq; cnt++) {

/* Bail if the other side set an error result */

if (READ_ONCE(wd->result) != WD_SUCCESS)

return false;

/* Prevent endless loops if the other CPU does not react. */

if (cnt == 5000) {

u64 nsecs = ktime_get_raw_fast_ns();

if (nsecs - start >=wd->timeout_ns) {

watchdog_set_result(wd, WD_CPU_TIMEOUT);

return false;

}

cnt = 0;

}

cpu_relax();

}

return seq < WATCHDOG_REMOTE_MAX_SEQ;

}

static void watchdog_check_skew(struct watchdog_cpu_data *wd, int index)

{

u64 prev, now, delta, start = ktime_get_raw_fast_ns();

int local = index, remote = (index + 1) & 0x1;

struct clocksource *cs = wd->cs;

/* Set the local timestamp so that the first iteration works correctly */

wd->cpu_ts[local] = cs->read(cs);

/* Signal arrival */

atomic_inc(&wd->seq);

for (int seq = local + 2; seq < WATCHDOG_REMOTE_MAX_SEQ; seq += 2) {

if (!watchdog_wait_seq(wd, start, seq))

return;

/* Capture local timestamp before possible non-local coherency overhead */

now = cs->read(cs);

/* Store local timestamp before reading remote to limit coherency stalls */

wd->cpu_ts[local] = now;

prev = wd->cpu_ts[remote];

delta = (now - prev) & cs->mask;

if (delta > cs->max_raw_delta) {

watchdog_set_result(wd, WD_CPU_SKEWED);

return;

}

/* Hand over to the remote CPU */

atomic_inc(&wd->seq);

}

}

static void watchdog_check_skew_remote(void *unused)

{

struct watchdog_cpu_data *wd = this_cpu_ptr(&watchdog_cpu_data);

atomic_inc(&wd->remote_inprogress);

watchdog_check_skew(wd, 1);

atomic_dec(&wd->remote_inprogress);

}

static inline bool wd_csd_locked(struct watchdog_cpu_data *wd)

{

return READ_ONCE(wd->csd.node.u_flags) & CSD_FLAG_LOCK;

}

static inline u64 wd_get_remote_timeout(unsigned int remote_cpu)

{

unsigned int n1, n2;

u64 ns;

if (nr_node_ids == 1)

return WATCHDOG_DEFAULT_TIMEOUT_NS;

n1 = cpu_to_node(smp_processor_id());

n2 = cpu_to_node(remote_cpu);

ns = WATCHDOG_NUMA_MULTIPLIER_NS * node_distance(n1, n2);

return min(ns, WATCHDOG_NUMA_MAX_TIMEOUT_NS);

}

static void __watchdog_check_cpu_skew(struct clocksource *cs, unsigned int cpu)

{

struct watchdog_cpu_data *wd;

wd = per_cpu_ptr(&watchdog_cpu_data, cpu);

if (atomic_read(&wd->remote_inprogress) || wd_csd_locked(wd)) {

watchdog_data.result = WD_CPU_TIMEOUT;

return;

}

atomic_set(&wd->seq, 0);

wd->result = WD_SUCCESS;

wd->cs = cs;

/* Store the current CPU ID for the watchdog test unit */

cs->wd_cpu = smp_processor_id();

wd->timeout_ns = wd_get_remote_timeout(cpu);

/* Kick the remote CPU into the watchdog function */

if (WARN_ON_ONCE(smp_call_function_single_async(cpu, &wd->csd))) {

watchdog_data.result = WD_CPU_TIMEOUT;

return;

}

scoped_guard(irq)

watchdog_check_skew(wd, 0);

scoped_guard(raw_spinlock_irq, &watchdog_data.lock) {

watchdog_data.result = wd->result;

memcpy(watchdog_data.cpu_ts, wd->cpu_ts, sizeof(wd->cpu_ts));

}

}

static void watchdog_check_cpu_skew(struct clocksource *cs)

{

unsigned int cpu = watchdog_data.curr_cpu;

cpu = cpumask_next_wrap(cpu, cpu_online_mask);

watchdog_data.curr_cpu = cpu;

/* Skip the current CPU. Handles num_online_cpus() == 1 as well */

if (cpu == smp_processor_id())

return;

/* Don't interfere with the test mechanics */

if ((cs->flags & CLOCK_SOURCE_WDTEST) && !(cs->flags & CLOCK_SOURCE_WDTEST_PERCPU))

return;

__watchdog_check_cpu_skew(cs, cpu);

}

static bool watchdog_check_freq(struct clocksource *cs, bool reset_pending)

{

unsigned int ppm_shift = SHIFT_4000PPM;

u64 wd_ts0, wd_ts1, cs_ts;

watchdog_data.result = WD_SUCCESS;

if (!watchdog) {

watchdog_data.result = WD_FREQ_NO_WATCHDOG;

return false;

}

if (cs->flags & CLOCK_SOURCE_WDTEST_PERCPU)

return true;

/*

if (watchdog->flags & CLOCK_SOURCE_CALIBRATED && cs->flags & CLOCK_SOURCE_CALIBRATED)

ppm_shift = SHIFT_500PPM;

for (int retries = 0; retries < WATCHDOG_FREQ_RETRIES; retries++) {

s64 wd_last, cs_last, wd_seq, wd_delta, cs_delta, max_delta;

scoped_guard(irq) {

wd_ts0 = watchdog->read(watchdog);

cs_ts = cs->read(cs);

wd_ts1 = watchdog->read(watchdog);

}

wd_last = cs->wd_last;

cs_last = cs->cs_last;

/* Validate the watchdog readout window */

wd_seq = cycles_to_nsec_safe(watchdog, wd_ts0, wd_ts1);

if (wd_seq > WATCHDOG_READOUT_MAX_NS) {

/* Store for printout in case all retries fail */

watchdog_data.wd_seq = wd_seq;

continue;

}

/* Store for subsequent processing */

cs->wd_last = wd_ts0;

cs->cs_last = cs_ts;

/* First round or reset pending? */

if (!(cs->flags & CLOCK_SOURCE_WATCHDOG) || reset_pending)

goto reset;

/* Calculate the nanosecond deltas from the last invocation */

wd_delta = cycles_to_nsec_safe(watchdog, wd_last, wd_ts0);

cs_delta = cycles_to_nsec_safe(cs, cs_last, cs_ts);

watchdog_data.wd_delta = wd_delta;

watchdog_data.cs_delta = cs_delta;

/*

max_delta = max(wd_delta, cs_delta);

if (max_delta > cs->max_idle_ns || max_delta > watchdog->max_idle_ns)

goto reset;

/*

if (abs(wd_delta - cs_delta) < (max_delta >> ppm_shift) + wd_seq)

return true;

watchdog_data.result = WD_FREQ_SKEWED;

return false;

}

watchdog_data.result = WD_FREQ_TIMEOUT;

return false;

reset:

cs->flags |= CLOCK_SOURCE_WATCHDOG;

watchdog_data.result = WD_FREQ_RESET;

return false;

}

static void clocksource_tick_stable(struct clocksource *cs)

{

if (cs == curr_clocksource && cs->tick_stable)

cs->tick_stable(cs);

}

static void clocksource_enable_highres(struct clocksource *cs)

{

if ((cs->flags & CLOCK_SOURCE_VALID_FOR_HRES) ||

!(cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) ||

!watchdog || !(watchdog->flags & CLOCK_SOURCE_IS_CONTINUOUS))

return;

/* Mark it valid for high-res. */

cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;

/*

if (!finished_booting)

return;

if (cs->flags & CLOCK_SOURCE_WDTEST)

return;

/*

if (cs != curr_clocksource) {

cs->flags |= CLOCK_SOURCE_RESELECT;

schedule_work(&watchdog_work);

} else {

tick_clock_notify();

}

}

static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 2);

static void watchdog_print_freq_timeout(struct clocksource *cs)

{

if (!__ratelimit(&ratelimit_state))

return;

pr_info("Watchdog %s read timed out. Readout sequence took: %lluns\n",

watchdog->name, watchdog_data.wd_seq);

}

static void watchdog_print_freq_skew(struct clocksource *cs)

{

pr_warn("Marking clocksource %s unstable due to frequency skew\n", cs->name);

pr_warn("Watchdog %20s interval: %16lluns\n", watchdog->name, watchdog_data.wd_delta);

pr_warn("Clocksource %20s interval: %16lluns\n", cs->name, watchdog_data.cs_delta);

}

static void watchdog_handle_remote_timeout(struct clocksource *cs)

{

pr_info_once("Watchdog remote CPU %u read timed out\n", watchdog_data.curr_cpu);

}

static void watchdog_print_remote_skew(struct clocksource *cs)

{

pr_warn("Marking clocksource %s unstable due to inter CPU skew\n", cs->name);

if (watchdog_data.cpu_ts[0] < watchdog_data.cpu_ts[1]) {

pr_warn("CPU%u %16llu < CPU%u %16llu (cycles)\n", smp_processor_id(),

watchdog_data.cpu_ts[0], watchdog_data.curr_cpu, watchdog_data.cpu_ts[1]);

} else {

pr_warn("CPU%u %16llu < CPU%u %16llu (cycles)\n", watchdog_data.curr_cpu,

watchdog_data.cpu_ts[1], smp_processor_id(), watchdog_data.cpu_ts[0]);

}

}

static void watchdog_check_result(struct clocksource *cs)

{

switch (watchdog_data.result) {

case WD_SUCCESS:

clocksource_tick_stable(cs);

clocksource_enable_highres(cs);

return;

case WD_FREQ_TIMEOUT:

watchdog_print_freq_timeout(cs);

/* Try again later and invalidate the reference timestamps. */

cs->flags &= ~CLOCK_SOURCE_WATCHDOG;

return;

case WD_FREQ_NO_WATCHDOG:

case WD_FREQ_RESET:

/*

return;

case WD_FREQ_SKEWED:

watchdog_print_freq_skew(cs);

break;

case WD_CPU_TIMEOUT:

/* Remote check timed out. Try again next cycle. */

watchdog_handle_remote_timeout(cs);

return;

case WD_CPU_SKEWED:

watchdog_print_remote_skew(cs);

break;

}

__clocksource_unstable(cs);

}

static void clocksource_watchdog(struct timer_list *unused)

{

struct clocksource *cs;

bool reset_pending;

guard(spinlock)(&watchdog_lock);

if (!watchdog_running)

return;

reset_pending = atomic_read(&watchdog_reset_pending);

list_for_each_entry(cs, &watchdog_list, wd_list) {

/* Clocksource already marked unstable? */

if (cs->flags & CLOCK_SOURCE_UNSTABLE) {

if (finished_booting)

schedule_work(&watchdog_work);

continue;

}

/* Compare against watchdog clocksource if available */

if (watchdog_check_freq(cs, reset_pending)) {

/* Check for inter CPU skew */

watchdog_check_cpu_skew(cs);

}

watchdog_check_result(cs);

}

/* Clear after the full clocksource walk */

if (reset_pending)

atomic_dec(&watchdog_reset_pending);

/* Could have been rearmed by a stop/start cycle */

if (!timer_pending(&watchdog_timer)) {

watchdog_timer.expires += WATCHDOG_INTERVAL;

add_timer_local(&watchdog_timer);

}

}

static inline void clocksource_start_watchdog(void)

{

if (watchdog_running || list_empty(&watchdog_list))

return;

timer_setup(&watchdog_timer, clocksource_watchdog, TIMER_PINNED);

watchdog_timer.expires = jiffies + WATCHDOG_INTERVAL;

add_timer_on(&watchdog_timer, get_boot_cpu_id());

watchdog_running = 1;

}

static inline void clocksource_stop_watchdog(void)

{

if (!watchdog_running || !list_empty(&watchdog_list))

return;

timer_delete(&watchdog_timer);

watchdog_running = 0;

}

static void clocksource_resume_watchdog(void)

{

atomic_inc(&watchdog_reset_pending);

}

static void clocksource_enqueue_watchdog(struct clocksource *cs)

{

INIT_LIST_HEAD(&cs->wd_list);

if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) {

/* cs is a clocksource to be watched. */

list_add(&cs->wd_list, &watchdog_list);

cs->flags &= ~CLOCK_SOURCE_WATCHDOG;

} else {

/* cs is a watchdog. */

if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)

cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;

}

}

static void clocksource_select_watchdog(bool fallback)

{

struct clocksource *cs, *old_wd;

unsigned long flags;

spin_lock_irqsave(&watchdog_lock, flags);

/* save current watchdog */

old_wd = watchdog;

if (fallback)

watchdog = NULL;

list_for_each_entry(cs, &clocksource_list, list) {

/* cs is a clocksource to be watched. */

if (cs->flags & CLOCK_SOURCE_MUST_VERIFY)

continue;

/*

if (!(cs->flags & CLOCK_SOURCE_IS_CONTINUOUS))

continue;

/* Skip current if we were requested for a fallback. */

if (fallback && cs == old_wd)

continue;

/* Pick the best watchdog. */

if (!watchdog || cs->rating > watchdog->rating)

watchdog = cs;

}

/* If we failed to find a fallback restore the old one. */

if (!watchdog)

watchdog = old_wd;

/* If we changed the watchdog we need to reset cycles. */

if (watchdog != old_wd)

clocksource_reset_watchdog();

/* Check if the watchdog timer needs to be started. */

clocksource_start_watchdog();

spin_unlock_irqrestore(&watchdog_lock, flags);

}

static void clocksource_dequeue_watchdog(struct clocksource *cs)

{

if (cs != watchdog) {

if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) {

/* cs is a watched clocksource. */

list_del_init(&cs->wd_list);

/* Check if the watchdog timer needs to be stopped. */

clocksource_stop_watchdog();

}

}

}

static int __clocksource_watchdog_kthread(void)

{

struct clocksource *cs, *tmp;

unsigned long flags;

int select = 0;

spin_lock_irqsave(&watchdog_lock, flags);

list_for_each_entry_safe(cs, tmp, &watchdog_list, wd_list) {

if (cs->flags & CLOCK_SOURCE_UNSTABLE) {

list_del_init(&cs->wd_list);

clocksource_change_rating(cs, 0);

select = 1;

}

if (cs->flags & CLOCK_SOURCE_RESELECT) {

cs->flags &= ~CLOCK_SOURCE_RESELECT;

select = 1;

}

}

/* Check if the watchdog timer needs to be stopped. */

clocksource_stop_watchdog();

spin_unlock_irqrestore(&watchdog_lock, flags);

return select;

}

static int clocksource_watchdog_kthread(void *data)

{

mutex_lock(&clocksource_mutex);

if (__clocksource_watchdog_kthread())

clocksource_select();

mutex_unlock(&clocksource_mutex);

return 0;

}

static bool clocksource_is_watchdog(struct clocksource *cs)

{

return cs == watchdog;

}

#else /* CONFIG_CLOCKSOURCE_WATCHDOG */

static void clocksource_enqueue_watchdog(struct clocksource *cs)

{

if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)

cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;

}

static void clocksource_select_watchdog(bool fallback) { }

static inline void clocksource_dequeue_watchdog(struct clocksource *cs) { }

static inline void clocksource_resume_watchdog(void) { }

static inline int __clocksource_watchdog_kthread(void) { return 0; }

static bool clocksource_is_watchdog(struct clocksource *cs) { return false; }

void clocksource_mark_unstable(struct clocksource *cs) { }

static inline void clocksource_watchdog_lock(unsigned long *flags) { }

static inline void clocksource_watchdog_unlock(unsigned long *flags) { }

#endif /* CONFIG_CLOCKSOURCE_WATCHDOG */

static bool clocksource_is_suspend(struct clocksource *cs)

{

return cs == suspend_clocksource;

}

static void __clocksource_suspend_select(struct clocksource *cs)

{

/*

if (!(cs->flags & CLOCK_SOURCE_SUSPEND_NONSTOP))

return;

/*

if (cs->suspend || cs->resume) {

pr_warn("Nonstop clocksource %s should not supply suspend/resume interfaces\n",

cs->name);

}

/* Pick the best rating. */

if (!suspend_clocksource || cs->rating > suspend_clocksource->rating)

suspend_clocksource = cs;

}

static void clocksource_suspend_select(bool fallback)

{

struct clocksource *cs, *old_suspend;

old_suspend = suspend_clocksource;

if (fallback)

suspend_clocksource = NULL;

list_for_each_entry(cs, &clocksource_list, list) {

/* Skip current if we were requested for a fallback. */

if (fallback && cs == old_suspend)

continue;

__clocksource_suspend_select(cs);

}

}

void clocksource_start_suspend_timing(struct clocksource *cs, u64 start_cycles)

{

if (!suspend_clocksource)

return;

/*

if (clocksource_is_suspend(cs)) {

suspend_start = start_cycles;

return;

}

if (suspend_clocksource->enable &&

suspend_clocksource->enable(suspend_clocksource)) {

pr_warn_once("Failed to enable the non-suspend-able clocksource.\n");

return;

}

suspend_start = suspend_clocksource->read(suspend_clocksource);

}

u64 clocksource_stop_suspend_timing(struct clocksource *cs, u64 cycle_now)

{

u64 now, nsec = 0;

if (!suspend_clocksource)

return 0;

/*

if (clocksource_is_suspend(cs))

now = cycle_now;

else

now = suspend_clocksource->read(suspend_clocksource);

if (now > suspend_start)

nsec = cycles_to_nsec_safe(suspend_clocksource, suspend_start, now);

/*

if (!clocksource_is_suspend(cs) && suspend_clocksource->disable)

suspend_clocksource->disable(suspend_clocksource);

return nsec;

}

void clocksource_suspend(void)

{

struct clocksource *cs;

list_for_each_entry_reverse(cs, &clocksource_list, list)

if (cs->suspend)

cs->suspend(cs);

}

void clocksource_resume(void)

{

struct clocksource *cs;

list_for_each_entry(cs, &clocksource_list, list)

if (cs->resume)

cs->resume(cs);

clocksource_resume_watchdog();

}

void clocksource_touch_watchdog(void)

{