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(ts);
  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                 session->ts->stat_headers(s);
 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         return seq_list_next(p, &session->stat_list, pos);
 176 }
 177
 178 static void stat_seq_stop(struct seq_file *s, void *p)
 179 {
 180         struct tracer_stat_session *session = s->private;
 181         mutex_unlock(&session->stat_mutex);
 182 }
 183
 184 static int stat_seq_show(struct seq_file *s, void *v)
 185 {
 186         struct tracer_stat_session *session = s->private;
 187         struct trace_stat_list *l = list_entry(v, struct trace_stat_list, list);
 188
 189         return session->ts->stat_show(s, l->stat);
 190 }
 191
 192 static const struct seq_operations trace_stat_seq_ops = {
 193         .start          = stat_seq_start,
 194         .next           = stat_seq_next,
 195         .stop           = stat_seq_stop,
 196         .show           = stat_seq_show
 197 };
 198
 199 /* The session stat is refilled and resorted at each stat file opening */
 200 static int tracing_stat_open(struct inode *inode, struct file *file)
 201 {
 202         int ret;
 203
 204         struct tracer_stat_session *session = inode->i_private;
 205
 206         ret = seq_open(file, &trace_stat_seq_ops);
 207         if (!ret) {
 208                 struct seq_file *m = file->private_data;
 209                 m->private = session;
 210                 ret = stat_seq_init(session);
 211         }
 212
 213         return ret;
 214 }
 215
 216 /*
 217  * Avoid consuming memory with our now useless list.
 218  */
 219 static int tracing_stat_release(struct inode *i, struct file *f)
 220 {
 221         struct tracer_stat_session *session = i->i_private;
 222
 223         mutex_lock(&session->stat_mutex);
 224         reset_stat_session(session);
 225         mutex_unlock(&session->stat_mutex);
 226
 227         return 0;
 228 }
 229
 230 static const struct file_operations tracing_stat_fops = {
 231         .open           = tracing_stat_open,
 232         .read           = seq_read,
 233         .llseek         = seq_lseek,
 234         .release        = tracing_stat_release
 235 };
 236
 237 static int tracing_stat_init(void)
 238 {
 239         struct dentry *d_tracing;
 240
 241         d_tracing = tracing_init_dentry();
 242
 243         stat_dir = debugfs_create_dir("trace_stat", d_tracing);
 244         if (!stat_dir)
 245                 pr_warning("Could not create debugfs "
 246                            "'trace_stat' entry\n");
 247         return 0;
 248 }
 249
 250 static int init_stat_file(struct tracer_stat_session *session)
 251 {
 252         if (!stat_dir && tracing_stat_init())
 253                 return -ENODEV;
 254
 255         session->file = debugfs_create_file(session->ts->name, 0644,
 256                                             stat_dir,
 257                                             session, &tracing_stat_fops);
 258         if (!session->file)
 259                 return -ENOMEM;
 260         return 0;
 261 }
 262
 263 int register_stat_tracer(struct tracer_stat *trace)
 264 {
 265         struct tracer_stat_session *session, *node, *tmp;
 266         int ret;
 267
 268         if (!trace)
 269                 return -EINVAL;
 270
 271         if (!trace->stat_start || !trace->stat_next || !trace->stat_show)
 272                 return -EINVAL;
 273
 274         /* Already registered? */
 275         mutex_lock(&all_stat_sessions_mutex);
 276         list_for_each_entry_safe(node, tmp, &all_stat_sessions, session_list) {
 277                 if (node->ts == trace) {
 278                         mutex_unlock(&all_stat_sessions_mutex);
 279                         return -EINVAL;
 280                 }
 281         }
 282         mutex_unlock(&all_stat_sessions_mutex);
 283
 284         /* Init the session */
 285         session = kmalloc(sizeof(struct tracer_stat_session), GFP_KERNEL);
 286         if (!session)
 287                 return -ENOMEM;
 288
 289         session->ts = trace;
 290         INIT_LIST_HEAD(&session->session_list);
 291         INIT_LIST_HEAD(&session->stat_list);
 292         mutex_init(&session->stat_mutex);
 293         session->file = NULL;
 294
 295         ret = init_stat_file(session);
 296         if (ret) {
 297                 destroy_session(session);
 298                 return ret;
 299         }
 300
 301         /* Register */
 302         mutex_lock(&all_stat_sessions_mutex);
 303         list_add_tail(&session->session_list, &all_stat_sessions);
 304         mutex_unlock(&all_stat_sessions_mutex);
 305
 306         return 0;
 307 }
 308
 309 void unregister_stat_tracer(struct tracer_stat *trace)
 310 {
 311         struct tracer_stat_session *node, *tmp;
 312
 313         mutex_lock(&all_stat_sessions_mutex);
 314         list_for_each_entry_safe(node, tmp, &all_stat_sessions, session_list) {
 315                 if (node->ts == trace) {
 316                         list_del(&node->session_list);
 317                         destroy_session(node);
 318                         break;
 319                 }
 320         }
 321         mutex_unlock(&all_stat_sessions_mutex);
 322 }