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 n = *pos;
 207         int i;
 208
 209         /* Prevent from tracer switch or rbtree modification */
 210         mutex_lock(&session->stat_mutex);
 211
 212         /* If we are in the beginning of the file, print the headers */
 213         if (session->ts->stat_headers) {
 214                 if (n == 0)
 215                         return SEQ_START_TOKEN;
 216                 n--;
 217         }
 218
 219         node = rb_first(&session->stat_root);
 220         for (i = 0; node && i < n; i++)
 221                 node = rb_next(node);
 222
 223         return node;
 224 }
 225
 226 static void *stat_seq_next(struct seq_file *s, void *p, loff_t *pos)
 227 {
 228         struct stat_session *session = s->private;
 229         struct rb_node *node = p;
 230
 231         (*pos)++;
 232
 233         if (p == SEQ_START_TOKEN)
 234                 return rb_first(&session->stat_root);
 235
 236         return rb_next(node);
 237 }
 238
 239 static void stat_seq_stop(struct seq_file *s, void *p)
 240 {
 241         struct stat_session *session = s->private;
 242         mutex_unlock(&session->stat_mutex);
 243 }
 244
 245 static int stat_seq_show(struct seq_file *s, void *v)
 246 {
 247         struct stat_session *session = s->private;
 248         struct stat_node *l = container_of(v, struct stat_node, node);
 249
 250         if (v == SEQ_START_TOKEN)
 251                 return session->ts->stat_headers(s);
 252
 253         return session->ts->stat_show(s, l->stat);
 254 }
 255
 256 static const struct seq_operations trace_stat_seq_ops = {
 257         .start          = stat_seq_start,
 258         .next           = stat_seq_next,
 259         .stop           = stat_seq_stop,
 260         .show           = stat_seq_show
 261 };
 262
 263 /* The session stat is refilled and resorted at each stat file opening */
 264 static int tracing_stat_open(struct inode *inode, struct file *file)
 265 {
 266         int ret;
 267         struct seq_file *m;
 268         struct stat_session *session = inode->i_private;
 269
 270         ret = stat_seq_init(session);
 271         if (ret)
 272                 return ret;
 273
 274         ret = seq_open(file, &trace_stat_seq_ops);
 275         if (ret) {
 276                 reset_stat_session(session);
 277                 return ret;
 278         }
 279
 280         m = file->private_data;
 281         m->private = session;
 282         return ret;
 283 }
 284
 285 /*
 286  * Avoid consuming memory with our now useless rbtree.
 287  */
 288 static int tracing_stat_release(struct inode *i, struct file *f)
 289 {
 290         struct stat_session *session = i->i_private;
 291
 292         reset_stat_session(session);
 293
 294         return seq_release(i, f);
 295 }
 296
 297 static const struct file_operations tracing_stat_fops = {
 298         .open           = tracing_stat_open,
 299         .read           = seq_read,
 300         .llseek         = seq_lseek,
 301         .release        = tracing_stat_release
 302 };
 303
 304 static int tracing_stat_init(void)
 305 {
 306         struct dentry *d_tracing;
 307
 308         d_tracing = tracing_init_dentry();
 309
 310         stat_dir = debugfs_create_dir("trace_stat", d_tracing);
 311         if (!stat_dir)
 312                 pr_warning("Could not create debugfs "
 313                            "'trace_stat' entry\n");
 314         return 0;
 315 }
 316
 317 static int init_stat_file(struct stat_session *session)
 318 {
 319         if (!stat_dir && tracing_stat_init())
 320                 return -ENODEV;
 321
 322         session->file = debugfs_create_file(session->ts->name, 0644,
 323                                             stat_dir,
 324                                             session, &tracing_stat_fops);
 325         if (!session->file)
 326                 return -ENOMEM;
 327         return 0;
 328 }
 329
 330 int register_stat_tracer(struct tracer_stat *trace)
 331 {
 332         struct stat_session *session, *node;
 333         int ret;
 334
 335         if (!trace)
 336                 return -EINVAL;
 337
 338         if (!trace->stat_start || !trace->stat_next || !trace->stat_show)
 339                 return -EINVAL;
 340
 341         /* Already registered? */
 342         mutex_lock(&all_stat_sessions_mutex);
 343         list_for_each_entry(node, &all_stat_sessions, session_list) {
 344                 if (node->ts == trace) {
 345                         mutex_unlock(&all_stat_sessions_mutex);
 346                         return -EINVAL;
 347                 }
 348         }
 349         mutex_unlock(&all_stat_sessions_mutex);
 350
 351         /* Init the session */
 352         session = kzalloc(sizeof(*session), GFP_KERNEL);
 353         if (!session)
 354                 return -ENOMEM;
 355
 356         session->ts = trace;
 357         INIT_LIST_HEAD(&session->session_list);
 358         mutex_init(&session->stat_mutex);
 359
 360         ret = init_stat_file(session);
 361         if (ret) {
 362                 destroy_session(session);
 363                 return ret;
 364         }
 365
 366         /* Register */
 367         mutex_lock(&all_stat_sessions_mutex);
 368         list_add_tail(&session->session_list, &all_stat_sessions);
 369         mutex_unlock(&all_stat_sessions_mutex);
 370
 371         return 0;
 372 }
 373
 374 void unregister_stat_tracer(struct tracer_stat *trace)
 375 {
 376         struct stat_session *node, *tmp;
 377
 378         mutex_lock(&all_stat_sessions_mutex);
 379         list_for_each_entry_safe(node, tmp, &all_stat_sessions, session_list) {
 380                 if (node->ts == trace) {
 381                         list_del(&node->session_list);
 382                         destroy_session(node);
 383                         break;
 384                 }
 385         }
 386         mutex_unlock(&all_stat_sessions_mutex);
 387 }