SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 }