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 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/debugfs.h>
  14 #include "trace_stat.h"
  15 #include "trace.h"
  16
  17
  18 /* List of stat entries from a tracer */
  19 struct trace_stat_list {
  20         struct list_head        list;
  21         void                    *stat;
  22 };
  23
  24 /* A stat session is the stats output in one file */
  25 struct tracer_stat_session {
  26         struct list_head        session_list;
  27         struct tracer_stat      *ts;
  28         struct list_head        stat_list;
  29         struct mutex            stat_mutex;
  30         struct dentry           *file;
  31 };
  32
  33 /* All of the sessions currently in use. Each stat file embed one session */
  34 static LIST_HEAD(all_stat_sessions);
  35 static DEFINE_MUTEX(all_stat_sessions_mutex);
  36
  37 /* The root directory for all stat files */
  38 static struct dentry            *stat_dir;
  39
  40
  41 static void reset_stat_session(struct tracer_stat_session *session)
  42 {
  43         struct trace_stat_list *node, *next;
  44
  45         list_for_each_entry_safe(node, next, &session->stat_list, list)
  46                 kfree(node);
  47
  48         INIT_LIST_HEAD(&session->stat_list);
  49 }
  50
  51 static void destroy_session(struct tracer_stat_session *session)
  52 {
  53         debugfs_remove(session->file);
  54         reset_stat_session(session);
  55         mutex_destroy(&session->stat_mutex);
  56         kfree(session);
  57 }
  58
  59 /*
  60  * For tracers that don't provide a stat_cmp callback.
  61  * This one will force an immediate insertion on tail of
  62  * the list.
  63  */
  64 static int dummy_cmp(void *p1, void *p2)
  65 {
  66         return 1;
  67 }
  68
  69 /*
  70  * Initialize the stat list at each trace_stat file opening.
  71  * All of these copies and sorting are required on all opening
  72  * since the stats could have changed between two file sessions.
  73  */
  74 static int stat_seq_init(struct tracer_stat_session *session)
  75 {
  76         struct trace_stat_list *iter_entry, *new_entry;
  77         struct tracer_stat *ts = session->ts;
  78         void *stat;
  79         int ret = 0;
  80         int i;
  81
  82         mutex_lock(&session->stat_mutex);
  83         reset_stat_session(session);
  84
  85         if (!ts->stat_cmp)
  86                 ts->stat_cmp = dummy_cmp;
  87
  88         stat = ts->stat_start();
  89         if (!stat)
  90                 goto exit;
  91
  92         /*
  93          * The first entry. Actually this is the second, but the first
  94          * one (the stat_list head) is pointless.
  95          */
  96         new_entry = kmalloc(sizeof(struct trace_stat_list), GFP_KERNEL);
  97         if (!new_entry) {
  98                 ret = -ENOMEM;
  99                 goto exit;
 100         }
 101
 102         INIT_LIST_HEAD(&new_entry->list);
 103
 104         list_add(&new_entry->list, &session->stat_list);
 105
 106         new_entry->stat = stat;
 107
 108         /*
 109          * Iterate over the tracer stat entries and store them in a sorted
 110          * list.
 111          */
 112         for (i = 1; ; i++) {
 113                 stat = ts->stat_next(stat, i);
 114
 115                 /* End of insertion */
 116                 if (!stat)
 117                         break;
 118
 119                 new_entry = kmalloc(sizeof(struct trace_stat_list), GFP_KERNEL);
 120                 if (!new_entry) {
 121                         ret = -ENOMEM;
 122                         goto exit_free_list;
 123                 }
 124
 125                 INIT_LIST_HEAD(&new_entry->list);
 126                 new_entry->stat = stat;
 127
 128                 list_for_each_entry(iter_entry, &session->stat_list, list) {
 129
 130                         /* Insertion with a descendent sorting */
 131                         if (ts->stat_cmp(new_entry->stat,
 132                                                 iter_entry->stat) > 0) {
 133
 134                                 list_add_tail(&new_entry->list,
 135                                                 &iter_entry->list);
 136                                 break;
 137
 138                         /* The current smaller value */
 139                         } else if (list_is_last(&iter_entry->list,
 140                                                 &session->stat_list)) {
 141                                 list_add(&new_entry->list, &iter_entry->list);
 142                                 break;
 143                         }
 144                 }
 145         }
 146 exit:
 147         mutex_unlock(&session->stat_mutex);
 148         return ret;
 149
 150 exit_free_list:
 151         reset_stat_session(session);
 152         mutex_unlock(&session->stat_mutex);
 153         return ret;
 154 }
 155
 156
 157 static void *stat_seq_start(struct seq_file *s, loff_t *pos)
 158 {
 159         struct tracer_stat_session *session = s->private;
 160
 161         /* Prevent from tracer switch or stat_list modification */
 162         mutex_lock(&session->stat_mutex);
 163
 164         /* If we are in the beginning of the file, print the headers */
 165         if (!*pos && session->ts->stat_headers)
 166                 return SEQ_START_TOKEN;
 167
 168         return seq_list_start(&session->stat_list, *pos);
 169 }
 170
 171 static void *stat_seq_next(struct seq_file *s, void *p, loff_t *pos)
 172 {
 173         struct tracer_stat_session *session = s->private;
 174
 175         if (p == SEQ_START_TOKEN)
 176                 return seq_list_start(&session->stat_list, *pos);
 177
 178         return seq_list_next(p, &session->stat_list, pos);
 179 }
 180
 181 static void stat_seq_stop(struct seq_file *s, void *p)
 182 {
 183         struct tracer_stat_session *session = s->private;
 184         mutex_unlock(&session->stat_mutex);
 185 }
 186
 187 static int stat_seq_show(struct seq_file *s, void *v)
 188 {
 189         struct tracer_stat_session *session = s->private;
 190         struct trace_stat_list *l = list_entry(v, struct trace_stat_list, list);
 191
 192         if (v == SEQ_START_TOKEN)
 193                 return session->ts->stat_headers(s);
 194
 195         return session->ts->stat_show(s, l->stat);
 196 }
 197
 198 static const struct seq_operations trace_stat_seq_ops = {
 199         .start          = stat_seq_start,
 200         .next           = stat_seq_next,
 201         .stop           = stat_seq_stop,
 202         .show           = stat_seq_show
 203 };
 204
 205 /* The session stat is refilled and resorted at each stat file opening */
 206 static int tracing_stat_open(struct inode *inode, struct file *file)
 207 {
 208         int ret;
 209
 210         struct tracer_stat_session *session = inode->i_private;
 211
 212         ret = seq_open(file, &trace_stat_seq_ops);
 213         if (!ret) {
 214                 struct seq_file *m = file->private_data;
 215                 m->private = session;
 216                 ret = stat_seq_init(session);
 217         }
 218
 219         return ret;
 220 }
 221
 222 /*
 223  * Avoid consuming memory with our now useless list.
 224  */
 225 static int tracing_stat_release(struct inode *i, struct file *f)
 226 {
 227         struct tracer_stat_session *session = i->i_private;
 228
 229         mutex_lock(&session->stat_mutex);
 230         reset_stat_session(session);
 231         mutex_unlock(&session->stat_mutex);
 232
 233         return 0;
 234 }
 235
 236 static const struct file_operations tracing_stat_fops = {
 237         .open           = tracing_stat_open,
 238         .read           = seq_read,
 239         .llseek         = seq_lseek,
 240         .release        = tracing_stat_release
 241 };
 242
 243 static int tracing_stat_init(void)
 244 {
 245         struct dentry *d_tracing;
 246
 247         d_tracing = tracing_init_dentry();
 248
 249         stat_dir = debugfs_create_dir("trace_stat", d_tracing);
 250         if (!stat_dir)
 251                 pr_warning("Could not create debugfs "
 252                            "'trace_stat' entry\n");
 253         return 0;
 254 }
 255
 256 static int init_stat_file(struct tracer_stat_session *session)
 257 {
 258         if (!stat_dir && tracing_stat_init())
 259                 return -ENODEV;
 260
 261         session->file = debugfs_create_file(session->ts->name, 0644,
 262                                             stat_dir,
 263                                             session, &tracing_stat_fops);
 264         if (!session->file)
 265                 return -ENOMEM;
 266         return 0;
 267 }
 268
 269 int register_stat_tracer(struct tracer_stat *trace)
 270 {
 271         struct tracer_stat_session *session, *node, *tmp;
 272         int ret;
 273
 274         if (!trace)
 275                 return -EINVAL;
 276
 277         if (!trace->stat_start || !trace->stat_next || !trace->stat_show)
 278                 return -EINVAL;
 279
 280         /* Already registered? */
 281         mutex_lock(&all_stat_sessions_mutex);
 282         list_for_each_entry_safe(node, tmp, &all_stat_sessions, session_list) {
 283                 if (node->ts == trace) {
 284                         mutex_unlock(&all_stat_sessions_mutex);
 285                         return -EINVAL;
 286                 }
 287         }
 288         mutex_unlock(&all_stat_sessions_mutex);
 289
 290         /* Init the session */
 291         session = kmalloc(sizeof(struct tracer_stat_session), GFP_KERNEL);
 292         if (!session)
 293                 return -ENOMEM;
 294
 295         session->ts = trace;
 296         INIT_LIST_HEAD(&session->session_list);
 297         INIT_LIST_HEAD(&session->stat_list);
 298         mutex_init(&session->stat_mutex);
 299         session->file = NULL;
 300
 301         ret = init_stat_file(session);
 302         if (ret) {
 303                 destroy_session(session);
 304                 return ret;
 305         }
 306
 307         /* Register */
 308         mutex_lock(&all_stat_sessions_mutex);
 309         list_add_tail(&session->session_list, &all_stat_sessions);
 310         mutex_unlock(&all_stat_sessions_mutex);
 311
 312         return 0;
 313 }
 314
 315 void unregister_stat_tracer(struct tracer_stat *trace)
 316 {
 317         struct tracer_stat_session *node, *tmp;
 318
 319         mutex_lock(&all_stat_sessions_mutex);
 320         list_for_each_entry_safe(node, tmp, &all_stat_sessions, session_list) {
 321                 if (node->ts == trace) {
 322                         list_del(&node->session_list);
 323                         destroy_session(node);
 324                         break;
 325                 }
 326         }
 327         mutex_unlock(&all_stat_sessions_mutex);
 328 }