Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit 84a78a6504f5c5394a8e558702e5b54131f01d14

Authored by Nathan Zimmer 2013-08-29 07:35:14 +0800

Committed by Linus Torvalds 2013-08-29 10:26:38 +0800

timer_list: correct the iterator for timer_list

Correct an issue with /proc/timer_list reported by Holger.

When reading from the proc file with a sufficiently small buffer, 2k so
not really that small, there was one could get hung trying to read the
file a chunk at a time.

The timer_list_start function failed to account for the possibility that
the offset was adjusted outside the timer_list_next.

Signed-off-by: Nathan Zimmer <nzimmer@sgi.com>
Reported-by: Holger Hans Peter Freyther <holger@freyther.de>
Cc: John Stultz <john.stultz@linaro.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Berke Durak <berke.durak@xiphos.com>
Cc: Jeff Layton <jlayton@redhat.com>
Tested-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: <stable@vger.kernel.org> # 3.10.x
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 1 changed file with 24 additions and 17 deletions Inline Diff

kernel/time/timer_list.c

kernel/time/timer_list.c

Diff comments View file @ 84a78a6

1	/*	1	/*
2	* kernel/time/timer_list.c	2	* kernel/time/timer_list.c
3	*	3	*
4	* List pending timers	4	* List pending timers
5	*	5	*
6	* Copyright(C) 2006, Red Hat, Inc., Ingo Molnar	6	* Copyright(C) 2006, Red Hat, Inc., Ingo Molnar
7	*	7	*
8	* This program is free software; you can redistribute it and/or modify	8	* This program is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License version 2 as	9	* it under the terms of the GNU General Public License version 2 as
10	* published by the Free Software Foundation.	10	* published by the Free Software Foundation.
11	*/	11	*/
12		12
13	#include <linux/proc_fs.h>	13	#include <linux/proc_fs.h>
14	#include <linux/module.h>	14	#include <linux/module.h>
15	#include <linux/spinlock.h>	15	#include <linux/spinlock.h>
16	#include <linux/sched.h>	16	#include <linux/sched.h>
17	#include <linux/seq_file.h>	17	#include <linux/seq_file.h>
18	#include <linux/kallsyms.h>	18	#include <linux/kallsyms.h>
19	#include <linux/tick.h>	19	#include <linux/tick.h>
20		20
21	#include <asm/uaccess.h>	21	#include <asm/uaccess.h>
22		22
23		23
24	struct timer_list_iter {	24	struct timer_list_iter {
25	int cpu;	25	int cpu;
26	bool second_pass;	26	bool second_pass;
27	u64 now;	27	u64 now;
28	};	28	};
29		29
30	typedef void (print_fn_t)(struct seq_file m, unsigned int *classes);	30	typedef void (print_fn_t)(struct seq_file m, unsigned int *classes);
31		31
32	DECLARE_PER_CPU(struct hrtimer_cpu_base, hrtimer_bases);	32	DECLARE_PER_CPU(struct hrtimer_cpu_base, hrtimer_bases);
33		33
34	/*	34	/*
35	* This allows printing both to /proc/timer_list and	35	* This allows printing both to /proc/timer_list and
36	* to the console (on SysRq-Q):	36	* to the console (on SysRq-Q):
37	*/	37	*/
38	#define SEQ_printf(m, x...) \	38	#define SEQ_printf(m, x...) \
39	do { \	39	do { \
40	if (m) \	40	if (m) \
41	seq_printf(m, x); \	41	seq_printf(m, x); \
42	else \	42	else \
43	printk(x); \	43	printk(x); \
44	} while (0)	44	} while (0)
45		45
46	static void print_name_offset(struct seq_file m, void sym)	46	static void print_name_offset(struct seq_file m, void sym)
47	{	47	{
48	char symname[KSYM_NAME_LEN];	48	char symname[KSYM_NAME_LEN];
49		49
50	if (lookup_symbol_name((unsigned long)sym, symname) < 0)	50	if (lookup_symbol_name((unsigned long)sym, symname) < 0)
51	SEQ_printf(m, "<%pK>", sym);	51	SEQ_printf(m, "<%pK>", sym);
52	else	52	else
53	SEQ_printf(m, "%s", symname);	53	SEQ_printf(m, "%s", symname);
54	}	54	}
55		55
56	static void	56	static void
57	print_timer(struct seq_file m, struct hrtimer taddr, struct hrtimer *timer,	57	print_timer(struct seq_file m, struct hrtimer taddr, struct hrtimer *timer,
58	int idx, u64 now)	58	int idx, u64 now)
59	{	59	{
60	#ifdef CONFIG_TIMER_STATS	60	#ifdef CONFIG_TIMER_STATS
61	char tmp[TASK_COMM_LEN + 1];	61	char tmp[TASK_COMM_LEN + 1];
62	#endif	62	#endif
63	SEQ_printf(m, " #%d: ", idx);	63	SEQ_printf(m, " #%d: ", idx);
64	print_name_offset(m, taddr);	64	print_name_offset(m, taddr);
65	SEQ_printf(m, ", ");	65	SEQ_printf(m, ", ");
66	print_name_offset(m, timer->function);	66	print_name_offset(m, timer->function);
67	SEQ_printf(m, ", S:%02lx", timer->state);	67	SEQ_printf(m, ", S:%02lx", timer->state);
68	#ifdef CONFIG_TIMER_STATS	68	#ifdef CONFIG_TIMER_STATS
69	SEQ_printf(m, ", ");	69	SEQ_printf(m, ", ");
70	print_name_offset(m, timer->start_site);	70	print_name_offset(m, timer->start_site);
71	memcpy(tmp, timer->start_comm, TASK_COMM_LEN);	71	memcpy(tmp, timer->start_comm, TASK_COMM_LEN);
72	tmp[TASK_COMM_LEN] = 0;	72	tmp[TASK_COMM_LEN] = 0;
73	SEQ_printf(m, ", %s/%d", tmp, timer->start_pid);	73	SEQ_printf(m, ", %s/%d", tmp, timer->start_pid);
74	#endif	74	#endif
75	SEQ_printf(m, "\n");	75	SEQ_printf(m, "\n");
76	SEQ_printf(m, " # expires at %Lu-%Lu nsecs [in %Ld to %Ld nsecs]\n",	76	SEQ_printf(m, " # expires at %Lu-%Lu nsecs [in %Ld to %Ld nsecs]\n",
77	(unsigned long long)ktime_to_ns(hrtimer_get_softexpires(timer)),	77	(unsigned long long)ktime_to_ns(hrtimer_get_softexpires(timer)),
78	(unsigned long long)ktime_to_ns(hrtimer_get_expires(timer)),	78	(unsigned long long)ktime_to_ns(hrtimer_get_expires(timer)),
79	(long long)(ktime_to_ns(hrtimer_get_softexpires(timer)) - now),	79	(long long)(ktime_to_ns(hrtimer_get_softexpires(timer)) - now),
80	(long long)(ktime_to_ns(hrtimer_get_expires(timer)) - now));	80	(long long)(ktime_to_ns(hrtimer_get_expires(timer)) - now));
81	}	81	}
82		82
83	static void	83	static void
84	print_active_timers(struct seq_file m, struct hrtimer_clock_base base,	84	print_active_timers(struct seq_file m, struct hrtimer_clock_base base,
85	u64 now)	85	u64 now)
86	{	86	{
87	struct hrtimer *timer, tmp;	87	struct hrtimer *timer, tmp;
88	unsigned long next = 0, i;	88	unsigned long next = 0, i;
89	struct timerqueue_node *curr;	89	struct timerqueue_node *curr;
90	unsigned long flags;	90	unsigned long flags;
91		91
92	next_one:	92	next_one:
93	i = 0;	93	i = 0;
94	raw_spin_lock_irqsave(&base->cpu_base->lock, flags);	94	raw_spin_lock_irqsave(&base->cpu_base->lock, flags);
95		95
96	curr = timerqueue_getnext(&base->active);	96	curr = timerqueue_getnext(&base->active);
97	/*	97	/*
98	* Crude but we have to do this O(N*N) thing, because	98	* Crude but we have to do this O(N*N) thing, because
99	* we have to unlock the base when printing:	99	* we have to unlock the base when printing:
100	*/	100	*/
101	while (curr && i < next) {	101	while (curr && i < next) {
102	curr = timerqueue_iterate_next(curr);	102	curr = timerqueue_iterate_next(curr);
103	i++;	103	i++;
104	}	104	}
105		105
106	if (curr) {	106	if (curr) {
107		107
108	timer = container_of(curr, struct hrtimer, node);	108	timer = container_of(curr, struct hrtimer, node);
109	tmp = *timer;	109	tmp = *timer;
110	raw_spin_unlock_irqrestore(&base->cpu_base->lock, flags);	110	raw_spin_unlock_irqrestore(&base->cpu_base->lock, flags);
111		111
112	print_timer(m, timer, &tmp, i, now);	112	print_timer(m, timer, &tmp, i, now);
113	next++;	113	next++;
114	goto next_one;	114	goto next_one;
115	}	115	}
116	raw_spin_unlock_irqrestore(&base->cpu_base->lock, flags);	116	raw_spin_unlock_irqrestore(&base->cpu_base->lock, flags);
117	}	117	}
118		118
119	static void	119	static void
120	print_base(struct seq_file m, struct hrtimer_clock_base base, u64 now)	120	print_base(struct seq_file m, struct hrtimer_clock_base base, u64 now)
121	{	121	{
122	SEQ_printf(m, " .base: %pK\n", base);	122	SEQ_printf(m, " .base: %pK\n", base);
123	SEQ_printf(m, " .index: %d\n",	123	SEQ_printf(m, " .index: %d\n",
124	base->index);	124	base->index);
125	SEQ_printf(m, " .resolution: %Lu nsecs\n",	125	SEQ_printf(m, " .resolution: %Lu nsecs\n",
126	(unsigned long long)ktime_to_ns(base->resolution));	126	(unsigned long long)ktime_to_ns(base->resolution));
127	SEQ_printf(m, " .get_time: ");	127	SEQ_printf(m, " .get_time: ");
128	print_name_offset(m, base->get_time);	128	print_name_offset(m, base->get_time);
129	SEQ_printf(m, "\n");	129	SEQ_printf(m, "\n");
130	#ifdef CONFIG_HIGH_RES_TIMERS	130	#ifdef CONFIG_HIGH_RES_TIMERS
131	SEQ_printf(m, " .offset: %Lu nsecs\n",	131	SEQ_printf(m, " .offset: %Lu nsecs\n",
132	(unsigned long long) ktime_to_ns(base->offset));	132	(unsigned long long) ktime_to_ns(base->offset));
133	#endif	133	#endif
134	SEQ_printf(m, "active timers:\n");	134	SEQ_printf(m, "active timers:\n");
135	print_active_timers(m, base, now);	135	print_active_timers(m, base, now);
136	}	136	}
137		137
138	static void print_cpu(struct seq_file *m, int cpu, u64 now)	138	static void print_cpu(struct seq_file *m, int cpu, u64 now)
139	{	139	{
140	struct hrtimer_cpu_base *cpu_base = &per_cpu(hrtimer_bases, cpu);	140	struct hrtimer_cpu_base *cpu_base = &per_cpu(hrtimer_bases, cpu);
141	int i;	141	int i;
142		142
143	SEQ_printf(m, "cpu: %d\n", cpu);	143	SEQ_printf(m, "cpu: %d\n", cpu);
144	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {	144	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {
145	SEQ_printf(m, " clock %d:\n", i);	145	SEQ_printf(m, " clock %d:\n", i);
146	print_base(m, cpu_base->clock_base + i, now);	146	print_base(m, cpu_base->clock_base + i, now);
147	}	147	}
148	#define P(x) \	148	#define P(x) \
149	SEQ_printf(m, " .%-15s: %Lu\n", #x, \	149	SEQ_printf(m, " .%-15s: %Lu\n", #x, \
150	(unsigned long long)(cpu_base->x))	150	(unsigned long long)(cpu_base->x))
151	#define P_ns(x) \	151	#define P_ns(x) \
152	SEQ_printf(m, " .%-15s: %Lu nsecs\n", #x, \	152	SEQ_printf(m, " .%-15s: %Lu nsecs\n", #x, \
153	(unsigned long long)(ktime_to_ns(cpu_base->x)))	153	(unsigned long long)(ktime_to_ns(cpu_base->x)))
154		154
155	#ifdef CONFIG_HIGH_RES_TIMERS	155	#ifdef CONFIG_HIGH_RES_TIMERS
156	P_ns(expires_next);	156	P_ns(expires_next);
157	P(hres_active);	157	P(hres_active);
158	P(nr_events);	158	P(nr_events);
159	P(nr_retries);	159	P(nr_retries);
160	P(nr_hangs);	160	P(nr_hangs);
161	P_ns(max_hang_time);	161	P_ns(max_hang_time);
162	#endif	162	#endif
163	#undef P	163	#undef P
164	#undef P_ns	164	#undef P_ns
165		165
166	#ifdef CONFIG_TICK_ONESHOT	166	#ifdef CONFIG_TICK_ONESHOT
167	# define P(x) \	167	# define P(x) \
168	SEQ_printf(m, " .%-15s: %Lu\n", #x, \	168	SEQ_printf(m, " .%-15s: %Lu\n", #x, \
169	(unsigned long long)(ts->x))	169	(unsigned long long)(ts->x))
170	# define P_ns(x) \	170	# define P_ns(x) \
171	SEQ_printf(m, " .%-15s: %Lu nsecs\n", #x, \	171	SEQ_printf(m, " .%-15s: %Lu nsecs\n", #x, \
172	(unsigned long long)(ktime_to_ns(ts->x)))	172	(unsigned long long)(ktime_to_ns(ts->x)))
173	{	173	{
174	struct tick_sched *ts = tick_get_tick_sched(cpu);	174	struct tick_sched *ts = tick_get_tick_sched(cpu);
175	P(nohz_mode);	175	P(nohz_mode);
176	P_ns(last_tick);	176	P_ns(last_tick);
177	P(tick_stopped);	177	P(tick_stopped);
178	P(idle_jiffies);	178	P(idle_jiffies);
179	P(idle_calls);	179	P(idle_calls);
180	P(idle_sleeps);	180	P(idle_sleeps);
181	P_ns(idle_entrytime);	181	P_ns(idle_entrytime);
182	P_ns(idle_waketime);	182	P_ns(idle_waketime);
183	P_ns(idle_exittime);	183	P_ns(idle_exittime);
184	P_ns(idle_sleeptime);	184	P_ns(idle_sleeptime);
185	P_ns(iowait_sleeptime);	185	P_ns(iowait_sleeptime);
186	P(last_jiffies);	186	P(last_jiffies);
187	P(next_jiffies);	187	P(next_jiffies);
188	P_ns(idle_expires);	188	P_ns(idle_expires);
189	SEQ_printf(m, "jiffies: %Lu\n",	189	SEQ_printf(m, "jiffies: %Lu\n",
190	(unsigned long long)jiffies);	190	(unsigned long long)jiffies);
191	}	191	}
192	#endif	192	#endif
193		193
194	#undef P	194	#undef P
195	#undef P_ns	195	#undef P_ns
196	SEQ_printf(m, "\n");	196	SEQ_printf(m, "\n");
197	}	197	}
198		198
199	#ifdef CONFIG_GENERIC_CLOCKEVENTS	199	#ifdef CONFIG_GENERIC_CLOCKEVENTS
200	static void	200	static void
201	print_tickdevice(struct seq_file m, struct tick_device td, int cpu)	201	print_tickdevice(struct seq_file m, struct tick_device td, int cpu)
202	{	202	{
203	struct clock_event_device *dev = td->evtdev;	203	struct clock_event_device *dev = td->evtdev;
204		204
205	SEQ_printf(m, "Tick Device: mode: %d\n", td->mode);	205	SEQ_printf(m, "Tick Device: mode: %d\n", td->mode);
206	if (cpu < 0)	206	if (cpu < 0)
207	SEQ_printf(m, "Broadcast device\n");	207	SEQ_printf(m, "Broadcast device\n");
208	else	208	else
209	SEQ_printf(m, "Per CPU device: %d\n", cpu);	209	SEQ_printf(m, "Per CPU device: %d\n", cpu);
210		210
211	SEQ_printf(m, "Clock Event Device: ");	211	SEQ_printf(m, "Clock Event Device: ");
212	if (!dev) {	212	if (!dev) {
213	SEQ_printf(m, "<NULL>\n");	213	SEQ_printf(m, "<NULL>\n");
214	return;	214	return;
215	}	215	}
216	SEQ_printf(m, "%s\n", dev->name);	216	SEQ_printf(m, "%s\n", dev->name);
217	SEQ_printf(m, " max_delta_ns: %llu\n",	217	SEQ_printf(m, " max_delta_ns: %llu\n",
218	(unsigned long long) dev->max_delta_ns);	218	(unsigned long long) dev->max_delta_ns);
219	SEQ_printf(m, " min_delta_ns: %llu\n",	219	SEQ_printf(m, " min_delta_ns: %llu\n",
220	(unsigned long long) dev->min_delta_ns);	220	(unsigned long long) dev->min_delta_ns);
221	SEQ_printf(m, " mult: %u\n", dev->mult);	221	SEQ_printf(m, " mult: %u\n", dev->mult);
222	SEQ_printf(m, " shift: %u\n", dev->shift);	222	SEQ_printf(m, " shift: %u\n", dev->shift);
223	SEQ_printf(m, " mode: %d\n", dev->mode);	223	SEQ_printf(m, " mode: %d\n", dev->mode);
224	SEQ_printf(m, " next_event: %Ld nsecs\n",	224	SEQ_printf(m, " next_event: %Ld nsecs\n",
225	(unsigned long long) ktime_to_ns(dev->next_event));	225	(unsigned long long) ktime_to_ns(dev->next_event));
226		226
227	SEQ_printf(m, " set_next_event: ");	227	SEQ_printf(m, " set_next_event: ");
228	print_name_offset(m, dev->set_next_event);	228	print_name_offset(m, dev->set_next_event);
229	SEQ_printf(m, "\n");	229	SEQ_printf(m, "\n");
230		230
231	SEQ_printf(m, " set_mode: ");	231	SEQ_printf(m, " set_mode: ");
232	print_name_offset(m, dev->set_mode);	232	print_name_offset(m, dev->set_mode);
233	SEQ_printf(m, "\n");	233	SEQ_printf(m, "\n");
234		234
235	SEQ_printf(m, " event_handler: ");	235	SEQ_printf(m, " event_handler: ");
236	print_name_offset(m, dev->event_handler);	236	print_name_offset(m, dev->event_handler);
237	SEQ_printf(m, "\n");	237	SEQ_printf(m, "\n");
238	SEQ_printf(m, " retries: %lu\n", dev->retries);	238	SEQ_printf(m, " retries: %lu\n", dev->retries);
239	SEQ_printf(m, "\n");	239	SEQ_printf(m, "\n");
240	}	240	}
241		241
242	static void timer_list_show_tickdevices_header(struct seq_file *m)	242	static void timer_list_show_tickdevices_header(struct seq_file *m)
243	{	243	{
244	#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST	244	#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
245	print_tickdevice(m, tick_get_broadcast_device(), -1);	245	print_tickdevice(m, tick_get_broadcast_device(), -1);
246	SEQ_printf(m, "tick_broadcast_mask: %08lx\n",	246	SEQ_printf(m, "tick_broadcast_mask: %08lx\n",
247	cpumask_bits(tick_get_broadcast_mask())[0]);	247	cpumask_bits(tick_get_broadcast_mask())[0]);
248	#ifdef CONFIG_TICK_ONESHOT	248	#ifdef CONFIG_TICK_ONESHOT
249	SEQ_printf(m, "tick_broadcast_oneshot_mask: %08lx\n",	249	SEQ_printf(m, "tick_broadcast_oneshot_mask: %08lx\n",
250	cpumask_bits(tick_get_broadcast_oneshot_mask())[0]);	250	cpumask_bits(tick_get_broadcast_oneshot_mask())[0]);
251	#endif	251	#endif
252	SEQ_printf(m, "\n");	252	SEQ_printf(m, "\n");
253	#endif	253	#endif
254	}	254	}
255	#endif	255	#endif
256		256
257	static inline void timer_list_header(struct seq_file *m, u64 now)	257	static inline void timer_list_header(struct seq_file *m, u64 now)
258	{	258	{
259	SEQ_printf(m, "Timer List Version: v0.7\n");	259	SEQ_printf(m, "Timer List Version: v0.7\n");
260	SEQ_printf(m, "HRTIMER_MAX_CLOCK_BASES: %d\n", HRTIMER_MAX_CLOCK_BASES);	260	SEQ_printf(m, "HRTIMER_MAX_CLOCK_BASES: %d\n", HRTIMER_MAX_CLOCK_BASES);
261	SEQ_printf(m, "now at %Ld nsecs\n", (unsigned long long)now);	261	SEQ_printf(m, "now at %Ld nsecs\n", (unsigned long long)now);
262	SEQ_printf(m, "\n");	262	SEQ_printf(m, "\n");
263	}	263	}
264		264
265	static int timer_list_show(struct seq_file m, void v)	265	static int timer_list_show(struct seq_file m, void v)
266	{	266	{
267	struct timer_list_iter *iter = v;	267	struct timer_list_iter *iter = v;
268	u64 now = ktime_to_ns(ktime_get());
269		268
270	if (iter->cpu == -1 && !iter->second_pass)	269	if (iter->cpu == -1 && !iter->second_pass)
271	timer_list_header(m, now);	270	timer_list_header(m, iter->now);
272	else if (!iter->second_pass)	271	else if (!iter->second_pass)
273	print_cpu(m, iter->cpu, iter->now);	272	print_cpu(m, iter->cpu, iter->now);
274	#ifdef CONFIG_GENERIC_CLOCKEVENTS	273	#ifdef CONFIG_GENERIC_CLOCKEVENTS
275	else if (iter->cpu == -1 && iter->second_pass)	274	else if (iter->cpu == -1 && iter->second_pass)
276	timer_list_show_tickdevices_header(m);	275	timer_list_show_tickdevices_header(m);
277	else	276	else
278	print_tickdevice(m, tick_get_device(iter->cpu), iter->cpu);	277	print_tickdevice(m, tick_get_device(iter->cpu), iter->cpu);
279	#endif	278	#endif
280	return 0;	279	return 0;
281	}	280	}
282		281
283	void sysrq_timer_list_show(void)	282	void sysrq_timer_list_show(void)
284	{	283	{
285	u64 now = ktime_to_ns(ktime_get());	284	u64 now = ktime_to_ns(ktime_get());
286	int cpu;	285	int cpu;
287		286
288	timer_list_header(NULL, now);	287	timer_list_header(NULL, now);
289		288
290	for_each_online_cpu(cpu)	289	for_each_online_cpu(cpu)
291	print_cpu(NULL, cpu, now);	290	print_cpu(NULL, cpu, now);
292		291
293	#ifdef CONFIG_GENERIC_CLOCKEVENTS	292	#ifdef CONFIG_GENERIC_CLOCKEVENTS
294	timer_list_show_tickdevices_header(NULL);	293	timer_list_show_tickdevices_header(NULL);
295	for_each_online_cpu(cpu)	294	for_each_online_cpu(cpu)
296	print_tickdevice(NULL, tick_get_device(cpu), cpu);	295	print_tickdevice(NULL, tick_get_device(cpu), cpu);
297	#endif	296	#endif
298	return;	297	return;
299	}	298	}
300		299
301	static void timer_list_start(struct seq_file file, loff_t *offset)	300	static void move_iter(struct timer_list_iter iter, loff_t offset)
302	{	301	{
303	struct timer_list_iter *iter = file->private;	302	for (; offset; offset--) {
304		303	iter->cpu = cpumask_next(iter->cpu, cpu_online_mask);
305	if (!*offset) {	304	if (iter->cpu >= nr_cpu_ids) {
306	iter->cpu = -1;
307	iter->now = ktime_to_ns(ktime_get());
308	} else if (iter->cpu >= nr_cpu_ids) {
309	#ifdef CONFIG_GENERIC_CLOCKEVENTS	305	#ifdef CONFIG_GENERIC_CLOCKEVENTS
310	if (!iter->second_pass) {	306	if (!iter->second_pass) {
311	iter->cpu = -1;	307	iter->cpu = -1;
312	iter->second_pass = true;	308	iter->second_pass = true;
313	} else	309	} else
314	return NULL;	310	return NULL;
315	#else	311	#else
316	return NULL;	312	return NULL;
317	#endif	313	#endif
		314	}
318	}	315	}
319	return iter;	316	return iter;
320	}	317	}
321		318
		319	static void timer_list_start(struct seq_file file, loff_t *offset)
		320	{
		321	struct timer_list_iter *iter = file->private;
		322
		323	if (!*offset)
		324	iter->now = ktime_to_ns(ktime_get());
		325	iter->cpu = -1;
		326	iter->second_pass = false;
		327	return move_iter(iter, *offset);
		328	}
		329
322	static void timer_list_next(struct seq_file file, void v, loff_t offset)	330	static void timer_list_next(struct seq_file file, void v, loff_t offset)
323	{	331	{
324	struct timer_list_iter *iter = file->private;	332	struct timer_list_iter *iter = file->private;
325	iter->cpu = cpumask_next(iter->cpu, cpu_online_mask);
326	++*offset;	333	++*offset;
327	return timer_list_start(file, offset);	334	return move_iter(iter, 1);
328	}	335	}
329		336
330	static void timer_list_stop(struct seq_file seq, void v)	337	static void timer_list_stop(struct seq_file seq, void v)
331	{	338	{
332	}	339	}
333		340
334	static const struct seq_operations timer_list_sops = {	341	static const struct seq_operations timer_list_sops = {
335	.start = timer_list_start,	342	.start = timer_list_start,
336	.next = timer_list_next,	343	.next = timer_list_next,
337	.stop = timer_list_stop,	344	.stop = timer_list_stop,
338	.show = timer_list_show,	345	.show = timer_list_show,
339	};	346	};
340		347
341	static int timer_list_open(struct inode inode, struct file filp)	348	static int timer_list_open(struct inode inode, struct file filp)
342	{	349	{
343	return seq_open_private(filp, &timer_list_sops,	350	return seq_open_private(filp, &timer_list_sops,
344	sizeof(struct timer_list_iter));	351	sizeof(struct timer_list_iter));
345	}	352	}
346		353
347	static const struct file_operations timer_list_fops = {	354	static const struct file_operations timer_list_fops = {
348	.open = timer_list_open,	355	.open = timer_list_open,
349	.read = seq_read,	356	.read = seq_read,
350	.llseek = seq_lseek,	357	.llseek = seq_lseek,
351	.release = seq_release_private,	358	.release = seq_release_private,
352	};	359	};
353		360
354	static int __init init_timer_list_procfs(void)	361	static int __init init_timer_list_procfs(void)
355	{	362	{
356	struct proc_dir_entry *pe;	363	struct proc_dir_entry *pe;
357		364
358	pe = proc_create("timer_list", 0444, NULL, &timer_list_fops);	365	pe = proc_create("timer_list", 0444, NULL, &timer_list_fops);
359	if (!pe)	366	if (!pe)