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); 288