clocksource: fix resume logic

We need to make sure that the clocksources are resumed, when timekeeping is resumed. The current resume logic does not guarantee this. Add a resume function pointer to the clocksource struct, so clocksource drivers which need to reinitialize the clocksource can provide a resume function. Add a resume function, which calls the maybe available clocksource resume functions and resets the watchdog function, so a stable TSC can be used accross suspend/resume.

Thomas Gleixner committed 19 years ago

Commit b52f52a1 parent 4037d453 files · +50 −0Browse files

Unified · Split

3 files

include/linux/clocksource.h +3 −0
kernel/time/clocksource.c +45 −0
kernel/timer.c +2 −0

include/linux/clocksource.h+3−0

  * @shift:		cycle to nanosecond divisor (power of two)
  * @flags:		flags describing special properties
  * @vread:		vsyscall based read
+ * @resume:		resume function for the clocksource, if necessary
  * @cycle_interval:	Used internally by timekeeping core, please ignore.
  * @xtime_interval:	Used internally by timekeeping core, please ignore.
  */
 	u32 shift;
 	unsigned long flags;
 	cycle_t (*vread)(void);
+	void (*resume)(void);
 	/* timekeeping specific data, ignore */
 	cycle_t cycle_interval;
 extern int clocksource_register(struct clocksource*);
 extern struct clocksource* clocksource_get_next(void);
 extern void clocksource_change_rating(struct clocksource *cs, int rating);
+extern void clocksource_resume(void);
 #ifdef CONFIG_GENERIC_TIME_VSYSCALL
 extern void update_vsyscall(struct timespec *ts, struct clocksource *c);

kernel/time/clocksource.c+45−0

@@ -74,6 +74,8 @@ static struct clocksource *watchdog; · 73 unmodified lines
74	static struct timer_list watchdog_timer;	74	static struct timer_list watchdog_timer;
75	static DEFINE_SPINLOCK(watchdog_lock);	75	static DEFINE_SPINLOCK(watchdog_lock);
76	static cycle_t watchdog_last;	76	static cycle_t watchdog_last;
		77	static int watchdog_resumed;
		78
77	/*	79	/*
78	* Interval: 0.5sec Threshold: 0.0625s	80	* Interval: 0.5sec Threshold: 0.0625s
79	*/	81	*/
@@ -98,15 +100,26 @@ static void clocksource_watchdog(unsigned long data) · 18 unmodified lines
98	struct clocksource cs, tmp;	100	struct clocksource cs, tmp;
99	cycle_t csnow, wdnow;	101	cycle_t csnow, wdnow;
100	int64_t wd_nsec, cs_nsec;	102	int64_t wd_nsec, cs_nsec;
		103	int resumed;
101		104
102	spin_lock(&watchdog_lock);	105	spin_lock(&watchdog_lock);
103		106
		107	resumed = watchdog_resumed;
		108	if (unlikely(resumed))
		109	watchdog_resumed = 0;
		110
104	wdnow = watchdog->read();	111	wdnow = watchdog->read();
105	wd_nsec = cyc2ns(watchdog, (wdnow - watchdog_last) & watchdog->mask);	112	wd_nsec = cyc2ns(watchdog, (wdnow - watchdog_last) & watchdog->mask);
106	watchdog_last = wdnow;	113	watchdog_last = wdnow;
107		114
108	list_for_each_entry_safe(cs, tmp, &watchdog_list, wd_list) {	115	list_for_each_entry_safe(cs, tmp, &watchdog_list, wd_list) {
109	csnow = cs->read();	116	csnow = cs->read();
		117
		118	if (unlikely(resumed)) {
		119	cs->wd_last = csnow;
		120	continue;
		121	}
		122
110	/* Initialized ? */	123	/* Initialized ? */
111	if (!(cs->flags & CLOCK_SOURCE_WATCHDOG)) {	124	if (!(cs->flags & CLOCK_SOURCE_WATCHDOG)) {
112	if ((cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) &&	125	if ((cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) &&
@@ -136,6 +149,13 @@ static void clocksource_watchdog(unsigned long data) · 23 unmodified lines
136	}	149	}
137	spin_unlock(&watchdog_lock);	150	spin_unlock(&watchdog_lock);
138	}	151	}
		152	static void clocksource_resume_watchdog(void)
		153	{
		154	spin_lock(&watchdog_lock);
		155	watchdog_resumed = 1;
		156	spin_unlock(&watchdog_lock);
		157	}
		158
139	static void clocksource_check_watchdog(struct clocksource *cs)	159	static void clocksource_check_watchdog(struct clocksource *cs)
140	{	160	{
141	struct clocksource *cse;	161	struct clocksource *cse;
@@ -182,8 +202,33 @@ static void clocksource_check_watchdog(struct clocksource *cs) · 40 unmodified lines
182	if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)	202	if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
183	cs->flags \|= CLOCK_SOURCE_VALID_FOR_HRES;	203	cs->flags \|= CLOCK_SOURCE_VALID_FOR_HRES;
184	}	204	}
		205
		206	static inline void clocksource_resume_watchdog(void) { }
185	#endif	207	#endif
186		208
		209	/**
		210	* clocksource_resume - resume the clocksource(s)
		211	*/
		212	void clocksource_resume(void)
		213	{
		214	struct list_head *tmp;
		215	unsigned long flags;
		216
		217	spin_lock_irqsave(&clocksource_lock, flags);
		218
		219	list_for_each(tmp, &clocksource_list) {
		220	struct clocksource *cs;
		221
		222	cs = list_entry(tmp, struct clocksource, list);
		223	if (cs->resume)
		224	cs->resume();
		225	}
		226
		227	clocksource_resume_watchdog();
		228
		229	spin_unlock_irqrestore(&clocksource_lock, flags);
		230	}
		231
187	/**	232	/**
188	* clocksource_get_next - Returns the selected clocksource	233	* clocksource_get_next - Returns the selected clocksource
189	*	234	*

kernel/timer.c+2−0

@@ -1499,6 +1499,8 @@ unregister_time_interpolator(struct time_interpolator *ti) · 1498 unmodified lines
1499	prev = &curr->next;	1499	prev = &curr->next;
1500	}	1500	}
1501		1501
		1502	clocksource_resume();
		1503
1502	write_seqlock_irqsave(&xtime_lock, flags);	1504	write_seqlock_irqsave(&xtime_lock, flags);
1503	if (ti == time_interpolator) {	1505	if (ti == time_interpolator) {
1504	/* we lost the best time-interpolator: */	1506	/* we lost the best time-interpolator: */