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

@@ -49,6 +49,7 @@ struct clocksource; · 48 unmodified lines
49	49	* @shift: cycle to nanosecond divisor (power of two)
50	50	* @flags: flags describing special properties
51	51	* @vread: vsyscall based read
	52	+ * @resume: resume function for the clocksource, if necessary
52	53	* @cycle_interval: Used internally by timekeeping core, please ignore.
53	54	* @xtime_interval: Used internally by timekeeping core, please ignore.
54	55	*/
@@ -65,6 +66,7 @@ struct clocksource { · 10 unmodified lines
65	66	u32 shift;
66	67	unsigned long flags;
67	68	cycle_t (*vread)(void);
	69	+ void (*resume)(void);
68	70
69	71	/* timekeeping specific data, ignore */
70	72	cycle_t cycle_interval;
@@ -209,6 +211,7 @@ static inline void clocksource_calculate_interval(struct clocksource *c, · 138 unmodified lines
209	211	extern int clocksource_register(struct clocksource*);
210	212	extern struct clocksource* clocksource_get_next(void);
211	213	extern void clocksource_change_rating(struct clocksource *cs, int rating);
	214	+extern void clocksource_resume(void);
212	215
213	216	#ifdef CONFIG_GENERIC_TIME_VSYSCALL
214	217	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	74	static struct timer_list watchdog_timer;
75	75	static DEFINE_SPINLOCK(watchdog_lock);
76	76	static cycle_t watchdog_last;
	77	+static int watchdog_resumed;
	78	+
77	79	/*
78	80	* Interval: 0.5sec Threshold: 0.0625s
79	81	*/
@@ -98,15 +100,26 @@ static void clocksource_watchdog(unsigned long data) · 18 unmodified lines
98	100	struct clocksource cs, tmp;
99	101	cycle_t csnow, wdnow;
100	102	int64_t wd_nsec, cs_nsec;
	103	+ int resumed;
101	104
102	105	spin_lock(&watchdog_lock);
103	106
	107	+ resumed = watchdog_resumed;
	108	+ if (unlikely(resumed))
	109	+ watchdog_resumed = 0;
	110	+
104	111	wdnow = watchdog->read();
105	112	wd_nsec = cyc2ns(watchdog, (wdnow - watchdog_last) & watchdog->mask);
106	113	watchdog_last = wdnow;
107	114
108	115	list_for_each_entry_safe(cs, tmp, &watchdog_list, wd_list) {
109	116	csnow = cs->read();
	117	+
	118	+ if (unlikely(resumed)) {
	119	+ cs->wd_last = csnow;
	120	+ continue;
	121	+ }
	122	+
110	123	/* Initialized ? */
111	124	if (!(cs->flags & CLOCK_SOURCE_WATCHDOG)) {
112	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	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	159	static void clocksource_check_watchdog(struct clocksource *cs)
140	160	{
141	161	struct clocksource *cse;
@@ -182,8 +202,33 @@ static void clocksource_check_watchdog(struct clocksource *cs) · 40 unmodified lines
182	202	if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
183	203	cs->flags \|= CLOCK_SOURCE_VALID_FOR_HRES;
184	204	}
	205	+
	206	+static inline void clocksource_resume_watchdog(void) { }
185	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	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	1499	prev = &curr->next;
1500	1500	}
1501	1501
	1502	+ clocksource_resume();
	1503	+
1502	1504	write_seqlock_irqsave(&xtime_lock, flags);
1503	1505	if (ti == time_interpolator) {
1504	1506	/* we lost the best time-interpolator: */