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