Merge branch 'linus' into tracing/core
[linux-2.6.git] / kernel / trace / trace_stat.c
1 /*
2  * Infrastructure for statistic tracing (histogram output).
3  *
4  * Copyright (C) 2008-2009 Frederic Weisbecker <fweisbec@gmail.com>
5  *
6  * Based on the code from trace_branch.c which is
7  * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
8  *
9  */
10
11
12 #include <linux/list.h>
13 #include <linux/rbtree.h>
14 #include <linux/debugfs.h>
15 #include "trace_stat.h"
16 #include "trace.h"
17
18
19 /*
20  * List of stat red-black nodes from a tracer
21  * We use a such tree to sort quickly the stat
22  * entries from the tracer.
23  */
24 struct stat_node {
25         struct rb_node          node;
26         void                    *stat;
27 };
28
29 /* A stat session is the stats output in one file */
30 struct stat_session {
31         struct list_head        session_list;
32         struct tracer_stat      *ts;
33         struct rb_root          stat_root;
34         struct mutex            stat_mutex;
35         struct dentry           *file;
36 };
37
38 /* All of the sessions currently in use. Each stat file embed one session */
39 static LIST_HEAD(all_stat_sessions);
40 static DEFINE_MUTEX(all_stat_sessions_mutex);
41
42 /* The root directory for all stat files */
43 static struct dentry            *stat_dir;
44
45 /*
46  * Iterate through the rbtree using a post order traversal path
47  * to release the next node.
48  * It won't necessary release one at each iteration
49  * but it will at least advance closer to the next one
50  * to be released.
51  */
52 static struct rb_node *release_next(struct tracer_stat *ts,
53                                     struct rb_node *node)
54 {
55         struct stat_node *snode;
56         struct rb_node *parent = rb_parent(node);
57
58         if (node->rb_left)
59                 return node->rb_left;
60         else if (node->rb_right)
61                 return node->rb_right;
62         else {
63                 if (!parent)
64                         ;
65                 else if (parent->rb_left == node)
66                         parent->rb_left = NULL;
67                 else
68                         parent->rb_right = NULL;
69
70                 snode = container_of(node, struct stat_node, node);
71                 if (ts->stat_release)
72                         ts->stat_release(snode->stat);
73                 kfree(snode);
74
75                 return parent;
76         }
77 }
78
79 static void __reset_stat_session(struct stat_session *session)
80 {
81         struct rb_node *node = session->stat_root.rb_node;
82
83         while (node)
84                 node = release_next(session->ts, node);
85
86         session->stat_root = RB_ROOT;
87 }
88
89 static void reset_stat_session(struct stat_session *session)
90 {
91         mutex_lock(&session->stat_mutex);
92         __reset_stat_session(session);
93         mutex_unlock(&session->stat_mutex);
94 }
95
96 static void destroy_session(struct stat_session *session)
97 {
98         debugfs_remove(session->file);
99         __reset_stat_session(session);
100         mutex_destroy(&session->stat_mutex);
101         kfree(session);
102 }
103
104 typedef int (*cmp_stat_t)(void *, void *);
105
106 static int insert_stat(struct rb_root *root, void *stat, cmp_stat_t cmp)
107 {
108         struct rb_node **new = &(root->rb_node), *parent = NULL;
109         struct stat_node *data;
110
111         data = kzalloc(sizeof(*data), GFP_KERNEL);
112         if (!data)
113                 return -ENOMEM;
114         data->stat = stat;
115
116         /*
117          * Figure out where to put new node
118          * This is a descendent sorting
119          */
120         while (*new) {
121                 struct stat_node *this;
122                 int result;
123
124                 this = container_of(*new, struct stat_node, node);
125                 result = cmp(data->stat, this->stat);
126
127                 parent = *new;
128                 if (result >= 0)
129                         new = &((*new)->rb_left);
130                 else
131                         new = &((*new)->rb_right);
132         }
133
134         rb_link_node(&data->node, parent, new);
135         rb_insert_color(&data->node, root);
136         return 0;
137 }
138
139 /*
140  * For tracers that don't provide a stat_cmp callback.
141  * This one will force an insertion as right-most node
142  * in the rbtree.
143  */
144 static int dummy_cmp(void *p1, void *p2)
145 {
146         return -1;
147 }
148
149 /*
150  * Initialize the stat rbtree at each trace_stat file opening.
151  * All of these copies and sorting are required on all opening
152  * since the stats could have changed between two file sessions.
153  */
154 static int stat_seq_init(struct stat_session *session)
155 {
156         struct tracer_stat *ts = session->ts;
157         struct rb_root *root = &session->stat_root;
158         void *stat;
159         int ret = 0;
160         int i;
161
162         mutex_lock(&session->stat_mutex);
163         __reset_stat_session(session);
164
165         if (!ts->stat_cmp)
166                 ts->stat_cmp = dummy_cmp;
167
168         stat = ts->stat_start(ts);
169         if (!stat)
170                 goto exit;
171
172         ret = insert_stat(root, stat, ts->stat_cmp);
173         if (ret)
174                 goto exit;
175
176         /*
177          * Iterate over the tracer stat entries and store them in an rbtree.
178          */
179         for (i = 1; ; i++) {
180                 stat = ts->stat_next(stat, i);
181
182                 /* End of insertion */
183                 if (!stat)
184                         break;
185
186                 ret = insert_stat(root, stat, ts->stat_cmp);
187                 if (ret)
188                         goto exit_free_rbtree;
189         }
190
191 exit:
192         mutex_unlock(&session->stat_mutex);
193         return ret;
194
195 exit_free_rbtree:
196         __reset_stat_session(session);
197         mutex_unlock(&session->stat_mutex);
198         return ret;
199 }
200
201
202 static void *stat_seq_start(struct seq_file *s, loff_t *pos)
203 {
204         struct stat_session *session = s->private;
205         struct rb_node *node;
206         int i;
207
208         /* Prevent from tracer switch or rbtree modification */
209         mutex_lock(&session->stat_mutex);
210
211         /* If we are in the beginning of the file, print the headers */
212         if (!*pos && session->ts->stat_headers)
213                 return SEQ_START_TOKEN;
214
215         node = rb_first(&session->stat_root);
216         for (i = 0; node && i < *pos; i++)
217                 node = rb_next(node);
218
219         return node;
220 }
221
222 static void *stat_seq_next(struct seq_file *s, void *p, loff_t *pos)
223 {
224         struct stat_session *session = s->private;
225         struct rb_node *node = p;
226
227         (*pos)++;
228
229         if (p == SEQ_START_TOKEN)
230                 return rb_first(&session->stat_root);
231
232         return rb_next(node);
233 }
234
235 static void stat_seq_stop(struct seq_file *s, void *p)
236 {
237         struct stat_session *session = s->private;
238         mutex_unlock(&session->stat_mutex);
239 }
240
241 static int stat_seq_show(struct seq_file *s, void *v)
242 {
243         struct stat_session *session = s->private;
244         struct stat_node *l = container_of(v, struct stat_node, node);
245
246         if (v == SEQ_START_TOKEN)
247                 return session->ts->stat_headers(s);
248
249         return session->ts->stat_show(s, l->stat);
250 }
251
252 static const struct seq_operations trace_stat_seq_ops = {
253         .start          = stat_seq_start,
254         .next           = stat_seq_next,
255         .stop           = stat_seq_stop,
256         .show           = stat_seq_show
257 };
258
259 /* The session stat is refilled and resorted at each stat file opening */
260 static int tracing_stat_open(struct inode *inode, struct file *file)
261 {
262         int ret;
263         struct seq_file *m;
264         struct stat_session *session = inode->i_private;
265
266         ret = stat_seq_init(session);
267         if (ret)
268                 return ret;
269
270         ret = seq_open(file, &trace_stat_seq_ops);
271         if (ret) {
272                 reset_stat_session(session);
273                 return ret;
274         }
275
276         m = file->private_data;
277         m->private = session;
278         return ret;
279 }
280
281 /*
282  * Avoid consuming memory with our now useless rbtree.
283  */
284 static int tracing_stat_release(struct inode *i, struct file *f)
285 {
286         struct stat_session *session = i->i_private;
287
288         reset_stat_session(session);
289
290         return seq_release(i, f);
291 }
292
293 static const struct file_operations tracing_stat_fops = {
294         .open           = tracing_stat_open,
295         .read           = seq_read,
296         .llseek         = seq_lseek,
297         .release        = tracing_stat_release
298 };
299
300 static int tracing_stat_init(void)
301 {
302         struct dentry *d_tracing;
303
304         d_tracing = tracing_init_dentry();
305
306         stat_dir = debugfs_create_dir("trace_stat", d_tracing);
307         if (!stat_dir)
308                 pr_warning("Could not create debugfs "
309                            "'trace_stat' entry\n");
310         return 0;
311 }
312
313 static int init_stat_file(struct stat_session *session)
314 {
315         if (!stat_dir && tracing_stat_init())
316                 return -ENODEV;
317
318         session->file = debugfs_create_file(session->ts->name, 0644,
319                                             stat_dir,
320                                             session, &tracing_stat_fops);
321         if (!session->file)
322                 return -ENOMEM;
323         return 0;
324 }
325
326 int register_stat_tracer(struct tracer_stat *trace)
327 {
328         struct stat_session *session, *node;
329         int ret;
330
331         if (!trace)
332                 return -EINVAL;
333
334         if (!trace->stat_start || !trace->stat_next || !trace->stat_show)
335                 return -EINVAL;
336
337         /* Already registered? */
338         mutex_lock(&all_stat_sessions_mutex);
339         list_for_each_entry(node, &all_stat_sessions, session_list) {
340                 if (node->ts == trace) {
341                         mutex_unlock(&all_stat_sessions_mutex);
342                         return -EINVAL;
343                 }
344         }
345         mutex_unlock(&all_stat_sessions_mutex);
346
347         /* Init the session */
348         session = kzalloc(sizeof(*session), GFP_KERNEL);
349         if (!session)
350                 return -ENOMEM;
351
352         session->ts = trace;
353         INIT_LIST_HEAD(&session->session_list);
354         mutex_init(&session->stat_mutex);
355
356         ret = init_stat_file(session);
357         if (ret) {
358                 destroy_session(session);
359                 return ret;
360         }
361
362         /* Register */
363         mutex_lock(&all_stat_sessions_mutex);
364         list_add_tail(&session->session_list, &all_stat_sessions);
365         mutex_unlock(&all_stat_sessions_mutex);
366
367         return 0;
368 }
369
370 void unregister_stat_tracer(struct tracer_stat *trace)
371 {
372         struct stat_session *node, *tmp;
373
374         mutex_lock(&all_stat_sessions_mutex);
375         list_for_each_entry_safe(node, tmp, &all_stat_sessions, session_list) {
376                 if (node->ts == trace) {
377                         list_del(&node->session_list);
378                         destroy_session(node);
379                         break;
380                 }
381         }
382         mutex_unlock(&all_stat_sessions_mutex);
383 }