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