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