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