Ingo Molnar | 289f480 | 2007-02-16 01:28:15 -0800 | [diff] [blame] | 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 | typedef void (*print_fn_t)(struct seq_file *m, unsigned int *classes); |
| 24 | |
| 25 | DECLARE_PER_CPU(struct hrtimer_cpu_base, hrtimer_bases); |
| 26 | |
| 27 | /* |
| 28 | * This allows printing both to /proc/timer_list and |
| 29 | * to the console (on SysRq-Q): |
| 30 | */ |
| 31 | #define SEQ_printf(m, x...) \ |
| 32 | do { \ |
| 33 | if (m) \ |
| 34 | seq_printf(m, x); \ |
| 35 | else \ |
| 36 | printk(x); \ |
| 37 | } while (0) |
| 38 | |
| 39 | static void print_name_offset(struct seq_file *m, void *sym) |
| 40 | { |
| 41 | unsigned long addr = (unsigned long)sym; |
| 42 | char namebuf[KSYM_NAME_LEN+1]; |
| 43 | unsigned long size, offset; |
| 44 | const char *sym_name; |
| 45 | char *modname; |
| 46 | |
| 47 | sym_name = kallsyms_lookup(addr, &size, &offset, &modname, namebuf); |
| 48 | if (sym_name) |
| 49 | SEQ_printf(m, "%s", sym_name); |
| 50 | else |
| 51 | SEQ_printf(m, "<%p>", sym); |
| 52 | } |
| 53 | |
| 54 | static void |
| 55 | print_timer(struct seq_file *m, struct hrtimer *timer, int idx, u64 now) |
| 56 | { |
| 57 | #ifdef CONFIG_TIMER_STATS |
| 58 | char tmp[TASK_COMM_LEN + 1]; |
| 59 | #endif |
| 60 | SEQ_printf(m, " #%d: ", idx); |
| 61 | print_name_offset(m, timer); |
| 62 | SEQ_printf(m, ", "); |
| 63 | print_name_offset(m, timer->function); |
| 64 | SEQ_printf(m, ", S:%02lx", timer->state); |
| 65 | #ifdef CONFIG_TIMER_STATS |
| 66 | SEQ_printf(m, ", "); |
| 67 | print_name_offset(m, timer->start_site); |
| 68 | memcpy(tmp, timer->start_comm, TASK_COMM_LEN); |
| 69 | tmp[TASK_COMM_LEN] = 0; |
| 70 | SEQ_printf(m, ", %s/%d", tmp, timer->start_pid); |
| 71 | #endif |
| 72 | SEQ_printf(m, "\n"); |
| 73 | SEQ_printf(m, " # expires at %Ld nsecs [in %Ld nsecs]\n", |
| 74 | (unsigned long long)ktime_to_ns(timer->expires), |
| 75 | (unsigned long long)(ktime_to_ns(timer->expires) - now)); |
| 76 | } |
| 77 | |
| 78 | static void |
| 79 | print_active_timers(struct seq_file *m, struct hrtimer_clock_base *base, |
| 80 | u64 now) |
| 81 | { |
| 82 | struct hrtimer *timer, tmp; |
| 83 | unsigned long next = 0, i; |
| 84 | struct rb_node *curr; |
| 85 | unsigned long flags; |
| 86 | |
| 87 | next_one: |
| 88 | i = 0; |
| 89 | spin_lock_irqsave(&base->cpu_base->lock, flags); |
| 90 | |
| 91 | curr = base->first; |
| 92 | /* |
| 93 | * Crude but we have to do this O(N*N) thing, because |
| 94 | * we have to unlock the base when printing: |
| 95 | */ |
| 96 | while (curr && i < next) { |
| 97 | curr = rb_next(curr); |
| 98 | i++; |
| 99 | } |
| 100 | |
| 101 | if (curr) { |
| 102 | |
| 103 | timer = rb_entry(curr, struct hrtimer, node); |
| 104 | tmp = *timer; |
| 105 | spin_unlock_irqrestore(&base->cpu_base->lock, flags); |
| 106 | |
| 107 | print_timer(m, &tmp, i, now); |
| 108 | next++; |
| 109 | goto next_one; |
| 110 | } |
| 111 | spin_unlock_irqrestore(&base->cpu_base->lock, flags); |
| 112 | } |
| 113 | |
| 114 | static void |
| 115 | print_base(struct seq_file *m, struct hrtimer_clock_base *base, u64 now) |
| 116 | { |
| 117 | SEQ_printf(m, " .index: %d\n", |
| 118 | base->index); |
| 119 | SEQ_printf(m, " .resolution: %Ld nsecs\n", |
| 120 | (unsigned long long)ktime_to_ns(base->resolution)); |
| 121 | SEQ_printf(m, " .get_time: "); |
| 122 | print_name_offset(m, base->get_time); |
| 123 | SEQ_printf(m, "\n"); |
| 124 | #ifdef CONFIG_HIGH_RES_TIMERS |
| 125 | SEQ_printf(m, " .offset: %Ld nsecs\n", |
| 126 | ktime_to_ns(base->offset)); |
| 127 | #endif |
| 128 | SEQ_printf(m, "active timers:\n"); |
| 129 | print_active_timers(m, base, now); |
| 130 | } |
| 131 | |
| 132 | static void print_cpu(struct seq_file *m, int cpu, u64 now) |
| 133 | { |
| 134 | struct hrtimer_cpu_base *cpu_base = &per_cpu(hrtimer_bases, cpu); |
| 135 | int i; |
| 136 | |
| 137 | SEQ_printf(m, "\ncpu: %d\n", cpu); |
| 138 | for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) { |
| 139 | SEQ_printf(m, " clock %d:\n", i); |
| 140 | print_base(m, cpu_base->clock_base + i, now); |
| 141 | } |
| 142 | #define P(x) \ |
| 143 | SEQ_printf(m, " .%-15s: %Ld\n", #x, (u64)(cpu_base->x)) |
| 144 | #define P_ns(x) \ |
| 145 | SEQ_printf(m, " .%-15s: %Ld nsecs\n", #x, \ |
| 146 | (u64)(ktime_to_ns(cpu_base->x))) |
| 147 | |
| 148 | #ifdef CONFIG_HIGH_RES_TIMERS |
| 149 | P_ns(expires_next); |
| 150 | P(hres_active); |
| 151 | P(nr_events); |
| 152 | #endif |
| 153 | #undef P |
| 154 | #undef P_ns |
| 155 | |
| 156 | #ifdef CONFIG_TICK_ONESHOT |
| 157 | # define P(x) \ |
| 158 | SEQ_printf(m, " .%-15s: %Ld\n", #x, (u64)(ts->x)) |
| 159 | # define P_ns(x) \ |
| 160 | SEQ_printf(m, " .%-15s: %Ld nsecs\n", #x, \ |
| 161 | (u64)(ktime_to_ns(ts->x))) |
| 162 | { |
| 163 | struct tick_sched *ts = tick_get_tick_sched(cpu); |
| 164 | P(nohz_mode); |
| 165 | P_ns(idle_tick); |
| 166 | P(tick_stopped); |
| 167 | P(idle_jiffies); |
| 168 | P(idle_calls); |
| 169 | P(idle_sleeps); |
| 170 | P_ns(idle_entrytime); |
| 171 | P_ns(idle_sleeptime); |
| 172 | P(last_jiffies); |
| 173 | P(next_jiffies); |
| 174 | P_ns(idle_expires); |
| 175 | SEQ_printf(m, "jiffies: %Ld\n", (u64)jiffies); |
| 176 | } |
| 177 | #endif |
| 178 | |
| 179 | #undef P |
| 180 | #undef P_ns |
| 181 | } |
| 182 | |
| 183 | #ifdef CONFIG_GENERIC_CLOCKEVENTS |
| 184 | static void |
| 185 | print_tickdevice(struct seq_file *m, struct tick_device *td) |
| 186 | { |
| 187 | struct clock_event_device *dev = td->evtdev; |
| 188 | |
| 189 | SEQ_printf(m, "\nTick Device: mode: %d\n", td->mode); |
| 190 | |
| 191 | SEQ_printf(m, "Clock Event Device: "); |
| 192 | if (!dev) { |
| 193 | SEQ_printf(m, "<NULL>\n"); |
| 194 | return; |
| 195 | } |
| 196 | SEQ_printf(m, "%s\n", dev->name); |
| 197 | SEQ_printf(m, " max_delta_ns: %ld\n", dev->max_delta_ns); |
| 198 | SEQ_printf(m, " min_delta_ns: %ld\n", dev->min_delta_ns); |
| 199 | SEQ_printf(m, " mult: %ld\n", dev->mult); |
| 200 | SEQ_printf(m, " shift: %d\n", dev->shift); |
| 201 | SEQ_printf(m, " mode: %d\n", dev->mode); |
| 202 | SEQ_printf(m, " next_event: %Ld nsecs\n", |
| 203 | (unsigned long long) ktime_to_ns(dev->next_event)); |
| 204 | |
| 205 | SEQ_printf(m, " set_next_event: "); |
| 206 | print_name_offset(m, dev->set_next_event); |
| 207 | SEQ_printf(m, "\n"); |
| 208 | |
| 209 | SEQ_printf(m, " set_mode: "); |
| 210 | print_name_offset(m, dev->set_mode); |
| 211 | SEQ_printf(m, "\n"); |
| 212 | |
| 213 | SEQ_printf(m, " event_handler: "); |
| 214 | print_name_offset(m, dev->event_handler); |
| 215 | SEQ_printf(m, "\n"); |
| 216 | } |
| 217 | |
| 218 | static void timer_list_show_tickdevices(struct seq_file *m) |
| 219 | { |
| 220 | int cpu; |
| 221 | |
| 222 | #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST |
| 223 | print_tickdevice(m, tick_get_broadcast_device()); |
| 224 | SEQ_printf(m, "tick_broadcast_mask: %08lx\n", |
| 225 | tick_get_broadcast_mask()->bits[0]); |
| 226 | #ifdef CONFIG_TICK_ONESHOT |
| 227 | SEQ_printf(m, "tick_broadcast_oneshot_mask: %08lx\n", |
| 228 | tick_get_broadcast_oneshot_mask()->bits[0]); |
| 229 | #endif |
| 230 | SEQ_printf(m, "\n"); |
| 231 | #endif |
| 232 | for_each_online_cpu(cpu) |
| 233 | print_tickdevice(m, tick_get_device(cpu)); |
| 234 | SEQ_printf(m, "\n"); |
| 235 | } |
| 236 | #else |
| 237 | static void timer_list_show_tickdevices(struct seq_file *m) { } |
| 238 | #endif |
| 239 | |
| 240 | static int timer_list_show(struct seq_file *m, void *v) |
| 241 | { |
| 242 | u64 now = ktime_to_ns(ktime_get()); |
| 243 | int cpu; |
| 244 | |
| 245 | SEQ_printf(m, "Timer List Version: v0.3\n"); |
| 246 | SEQ_printf(m, "HRTIMER_MAX_CLOCK_BASES: %d\n", HRTIMER_MAX_CLOCK_BASES); |
| 247 | SEQ_printf(m, "now at %Ld nsecs\n", (unsigned long long)now); |
| 248 | |
| 249 | for_each_online_cpu(cpu) |
| 250 | print_cpu(m, cpu, now); |
| 251 | |
| 252 | SEQ_printf(m, "\n"); |
| 253 | timer_list_show_tickdevices(m); |
| 254 | |
| 255 | return 0; |
| 256 | } |
| 257 | |
| 258 | void sysrq_timer_list_show(void) |
| 259 | { |
| 260 | timer_list_show(NULL, NULL); |
| 261 | } |
| 262 | |
| 263 | static int timer_list_open(struct inode *inode, struct file *filp) |
| 264 | { |
| 265 | return single_open(filp, timer_list_show, NULL); |
| 266 | } |
| 267 | |
| 268 | static struct file_operations timer_list_fops = { |
| 269 | .open = timer_list_open, |
| 270 | .read = seq_read, |
| 271 | .llseek = seq_lseek, |
| 272 | .release = seq_release, |
| 273 | }; |
| 274 | |
| 275 | static int __init init_timer_list_procfs(void) |
| 276 | { |
| 277 | struct proc_dir_entry *pe; |
| 278 | |
| 279 | pe = create_proc_entry("timer_list", 0644, NULL); |
| 280 | if (!pe) |
| 281 | return -ENOMEM; |
| 282 | |
| 283 | pe->proc_fops = &timer_list_fops; |
| 284 | |
| 285 | return 0; |
| 286 | } |
| 287 | __initcall(init_timer_list_procfs); |