2 * kernel/time/timer_stats.c
4 * Collect timer usage statistics.
6 * Copyright(C) 2006, Red Hat, Inc., Ingo Molnar
7 * Copyright(C) 2006 Timesys Corp., Thomas Gleixner <tglx@timesys.com>
9 * timer_stats is based on timer_top, a similar functionality which was part of
10 * Con Kolivas dyntick patch set. It was developed by Daniel Petrini at the
11 * Instituto Nokia de Tecnologia - INdT - Manaus. timer_top's design was based
12 * on dynamic allocation of the statistics entries and linear search based
13 * lookup combined with a global lock, rather than the static array, hash
14 * and per-CPU locking which is used by timer_stats. It was written for the
15 * pre hrtimer kernel code and therefore did not take hrtimers into account.
16 * Nevertheless it provided the base for the timer_stats implementation and
17 * was a helpful source of inspiration. Kudos to Daniel and the Nokia folks
21 * Copyright (C) 2005 Instituto Nokia de Tecnologia - INdT - Manaus
22 * Written by Daniel Petrini <d.pensator@gmail.com>
23 * timer_top.c was released under the GNU General Public License version 2
25 * We export the addresses and counting of timer functions being called,
26 * the pid and cmdline from the owner process if applicable.
28 * Start/stop data collection:
29 * # echo 1[0] >/proc/timer_stats
31 * Display the information collected so far:
32 * # cat /proc/timer_stats
34 * This program is free software; you can redistribute it and/or modify
35 * it under the terms of the GNU General Public License version 2 as
36 * published by the Free Software Foundation.
39 #include <linux/proc_fs.h>
40 #include <linux/module.h>
41 #include <linux/spinlock.h>
42 #include <linux/sched.h>
43 #include <linux/seq_file.h>
44 #include <linux/kallsyms.h>
46 #include <asm/uaccess.h>
49 * This is our basic unit of interest: a timer expiry event identified
50 * by the timer, its start/expire functions and the PID of the task that
51 * started the timer. We count the number of times an event happens:
68 * Number of timeout events:
73 * We save the command-line string to preserve
74 * this information past task exit:
76 char comm
[TASK_COMM_LEN
+ 1];
78 } ____cacheline_aligned_in_smp
;
81 * Spinlock protecting the tables - not taken during lookup:
83 static DEFINE_SPINLOCK(table_lock
);
86 * Per-CPU lookup locks for fast hash lookup:
88 static DEFINE_PER_CPU(spinlock_t
, lookup_lock
);
91 * Mutex to serialize state changes with show-stats activities:
93 static DEFINE_MUTEX(show_mutex
);
96 * Collection status, active/inactive:
98 static int __read_mostly active
;
101 * Beginning/end timestamps of measurement:
103 static ktime_t time_start
, time_stop
;
106 * tstat entry structs only get allocated while collection is
107 * active and never freed during that time - this simplifies
108 * things quite a bit.
110 * They get freed when a new collection period is started.
112 #define MAX_ENTRIES_BITS 10
113 #define MAX_ENTRIES (1UL << MAX_ENTRIES_BITS)
115 static unsigned long nr_entries
;
116 static struct entry entries
[MAX_ENTRIES
];
118 static atomic_t overflow_count
;
120 static void reset_entries(void)
123 memset(entries
, 0, sizeof(entries
));
124 atomic_set(&overflow_count
, 0);
127 static struct entry
*alloc_entry(void)
129 if (nr_entries
>= MAX_ENTRIES
)
132 return entries
+ nr_entries
++;
136 * The entries are in a hash-table, for fast lookup:
138 #define TSTAT_HASH_BITS (MAX_ENTRIES_BITS - 1)
139 #define TSTAT_HASH_SIZE (1UL << TSTAT_HASH_BITS)
140 #define TSTAT_HASH_MASK (TSTAT_HASH_SIZE - 1)
142 #define __tstat_hashfn(entry) \
143 (((unsigned long)(entry)->timer ^ \
144 (unsigned long)(entry)->start_func ^ \
145 (unsigned long)(entry)->expire_func ^ \
146 (unsigned long)(entry)->pid ) & TSTAT_HASH_MASK)
148 #define tstat_hashentry(entry) (tstat_hash_table + __tstat_hashfn(entry))
150 static struct entry
*tstat_hash_table
[TSTAT_HASH_SIZE
] __read_mostly
;
152 static int match_entries(struct entry
*entry1
, struct entry
*entry2
)
154 return entry1
->timer
== entry2
->timer
&&
155 entry1
->start_func
== entry2
->start_func
&&
156 entry1
->expire_func
== entry2
->expire_func
&&
157 entry1
->pid
== entry2
->pid
;
161 * Look up whether an entry matching this item is present
162 * in the hash already. Must be called with irqs off and the
165 static struct entry
*tstat_lookup(struct entry
*entry
, char *comm
)
167 struct entry
**head
, *curr
, *prev
;
169 head
= tstat_hashentry(entry
);
173 * The fastpath is when the entry is already hashed,
174 * we do this with the lookup lock held, but with the
175 * table lock not held:
178 if (match_entries(curr
, entry
))
184 * Slowpath: allocate, set up and link a new hash entry:
189 spin_lock(&table_lock
);
191 * Make sure we have not raced with another CPU:
194 if (match_entries(curr
, entry
))
201 curr
= alloc_entry();
205 memcpy(curr
->comm
, comm
, TASK_COMM_LEN
);
213 spin_unlock(&table_lock
);
219 * timer_stats_update_stats - Update the statistics for a timer.
220 * @timer: pointer to either a timer_list or a hrtimer
221 * @pid: the pid of the task which set up the timer
222 * @startf: pointer to the function which did the timer setup
223 * @timerf: pointer to the timer callback function of the timer
224 * @comm: name of the process which set up the timer
226 * When the timer is already registered, then the event counter is
227 * incremented. Otherwise the timer is registered in a free slot.
229 void timer_stats_update_stats(void *timer
, pid_t pid
, void *startf
,
230 void *timerf
, char * comm
)
233 * It doesnt matter which lock we take:
235 spinlock_t
*lock
= &per_cpu(lookup_lock
, raw_smp_processor_id());
236 struct entry
*entry
, input
;
240 input
.start_func
= startf
;
241 input
.expire_func
= timerf
;
244 spin_lock_irqsave(lock
, flags
);
248 entry
= tstat_lookup(&input
, comm
);
252 atomic_inc(&overflow_count
);
255 spin_unlock_irqrestore(lock
, flags
);
258 static void print_name_offset(struct seq_file
*m
, unsigned long addr
)
260 char symname
[KSYM_NAME_LEN
+1];
262 if (lookup_symbol_name(addr
, symname
) < 0)
263 seq_printf(m
, "<%p>", (void *)addr
);
265 seq_printf(m
, "%s", symname
);
268 static int tstats_show(struct seq_file
*m
, void *v
)
270 struct timespec period
;
277 mutex_lock(&show_mutex
);
279 * If still active then calculate up to now:
282 time_stop
= ktime_get();
284 time
= ktime_sub(time_stop
, time_start
);
286 period
= ktime_to_timespec(time
);
287 ms
= period
.tv_nsec
/ 1000000;
289 seq_puts(m
, "Timer Stats Version: v0.1\n");
290 seq_printf(m
, "Sample period: %ld.%03ld s\n", period
.tv_sec
, ms
);
291 if (atomic_read(&overflow_count
))
292 seq_printf(m
, "Overflow: %d entries\n",
293 atomic_read(&overflow_count
));
295 for (i
= 0; i
< nr_entries
; i
++) {
297 seq_printf(m
, "%4lu, %5d %-16s ",
298 entry
->count
, entry
->pid
, entry
->comm
);
300 print_name_offset(m
, (unsigned long)entry
->start_func
);
302 print_name_offset(m
, (unsigned long)entry
->expire_func
);
305 events
+= entry
->count
;
308 ms
+= period
.tv_sec
* 1000;
312 if (events
&& period
.tv_sec
)
313 seq_printf(m
, "%ld total events, %ld.%ld events/sec\n", events
,
314 events
/ period
.tv_sec
, events
* 1000 / ms
);
316 seq_printf(m
, "%ld total events\n", events
);
318 mutex_unlock(&show_mutex
);
324 * After a state change, make sure all concurrent lookup/update
325 * activities have stopped:
327 static void sync_access(void)
332 for_each_online_cpu(cpu
) {
333 spin_lock_irqsave(&per_cpu(lookup_lock
, cpu
), flags
);
335 spin_unlock_irqrestore(&per_cpu(lookup_lock
, cpu
), flags
);
339 static ssize_t
tstats_write(struct file
*file
, const char __user
*buf
,
340 size_t count
, loff_t
*offs
)
344 if (count
!= 2 || *offs
)
347 if (copy_from_user(ctl
, buf
, count
))
350 mutex_lock(&show_mutex
);
355 time_stop
= ktime_get();
362 time_start
= ktime_get();
369 mutex_unlock(&show_mutex
);
374 static int tstats_open(struct inode
*inode
, struct file
*filp
)
376 return single_open(filp
, tstats_show
, NULL
);
379 static struct file_operations tstats_fops
= {
382 .write
= tstats_write
,
384 .release
= seq_release
,
387 void __init
init_timer_stats(void)
391 for_each_possible_cpu(cpu
)
392 spin_lock_init(&per_cpu(lookup_lock
, cpu
));
395 static int __init
init_tstats_procfs(void)
397 struct proc_dir_entry
*pe
;
399 pe
= create_proc_entry("timer_stats", 0644, NULL
);
403 pe
->proc_fops
= &tstats_fops
;
407 __initcall(init_tstats_procfs
);