kernel/trace/trace_printk.c

   1 /*
   2  * trace binary printk
   3  *
   4  * Copyright (C) 2008 Lai Jiangshan <laijs@cn.fujitsu.com>
   5  *
   6  */
   7 #include <linux/seq_file.h>
   8 #include <linux/debugfs.h>
   9 #include <linux/uaccess.h>
  10 #include <linux/kernel.h>
  11 #include <linux/ftrace.h>
  12 #include <linux/string.h>
  13 #include <linux/module.h>
  14 #include <linux/mutex.h>
  15 #include <linux/ctype.h>
  16 #include <linux/list.h>
  17 #include <linux/slab.h>
  18 #include <linux/fs.h>
  19
  20 #include "trace.h"
  21
  22 #ifdef CONFIG_MODULES
  23
  24 /*
  25  * modules trace_printk()'s formats are autosaved in struct trace_bprintk_fmt
  26  * which are queued on trace_bprintk_fmt_list.
  27  */
  28 static LIST_HEAD(trace_bprintk_fmt_list);
  29
  30 /* serialize accesses to trace_bprintk_fmt_list */
  31 static DEFINE_MUTEX(btrace_mutex);
  32
  33 struct trace_bprintk_fmt {
  34         struct list_head list;
  35         const char *fmt;
  36 };
  37
  38 static inline struct trace_bprintk_fmt *lookup_format(const char *fmt)
  39 {
  40         struct trace_bprintk_fmt *pos;
  41         list_for_each_entry(pos, &trace_bprintk_fmt_list, list) {
  42                 if (!strcmp(pos->fmt, fmt))
  43                         return pos;
  44         }
  45         return NULL;
  46 }
  47
  48 static
  49 void hold_module_trace_bprintk_format(const char **start, const char **end)
  50 {
  51         const char **iter;
  52         char *fmt;
  53
  54         mutex_lock(&btrace_mutex);
  55         for (iter = start; iter < end; iter++) {
  56                 struct trace_bprintk_fmt *tb_fmt = lookup_format(*iter);
  57                 if (tb_fmt) {
  58                         *iter = tb_fmt->fmt;
  59                         continue;
  60                 }
  61
  62                 tb_fmt = kmalloc(sizeof(*tb_fmt), GFP_KERNEL);
  63                 if (tb_fmt)
  64                         fmt = kmalloc(strlen(*iter) + 1, GFP_KERNEL);
  65                 if (tb_fmt && fmt) {
  66                         list_add_tail(&tb_fmt->list, &trace_bprintk_fmt_list);
  67                         strcpy(fmt, *iter);
  68                         tb_fmt->fmt = fmt;
  69                         *iter = tb_fmt->fmt;
  70                 } else {
  71                         kfree(tb_fmt);
  72                         *iter = NULL;
  73                 }
  74         }
  75         mutex_unlock(&btrace_mutex);
  76 }
  77
  78 static int module_trace_bprintk_format_notify(struct notifier_block *self,
  79                 unsigned long val, void *data)
  80 {
  81         struct module *mod = data;
  82         if (mod->num_trace_bprintk_fmt) {
  83                 const char **start = mod->trace_bprintk_fmt_start;
  84                 const char **end = start + mod->num_trace_bprintk_fmt;
  85
  86                 if (val == MODULE_STATE_COMING)
  87                         hold_module_trace_bprintk_format(start, end);
  88         }
  89         return 0;
  90 }
  91
  92 /*
  93  * The debugfs/tracing/printk_formats file maps the addresses with
  94  * the ASCII formats that are used in the bprintk events in the
  95  * buffer. For userspace tools to be able to decode the events from
  96  * the buffer, they need to be able to map the address with the format.
  97  *
  98  * The addresses of the bprintk formats are in their own section
  99  * __trace_printk_fmt. But for modules we copy them into a link list.
 100  * The code to print the formats and their addresses passes around the
 101  * address of the fmt string. If the fmt address passed into the seq
 102  * functions is within the kernel core __trace_printk_fmt section, then
 103  * it simply uses the next pointer in the list.
 104  *
 105  * When the fmt pointer is outside the kernel core __trace_printk_fmt
 106  * section, then we need to read the link list pointers. The trick is
 107  * we pass the address of the string to the seq function just like
 108  * we do for the kernel core formats. To get back the structure that
 109  * holds the format, we simply use containerof() and then go to the
 110  * next format in the list.
 111  */
 112 static const char **
 113 find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)
 114 {
 115         struct trace_bprintk_fmt *mod_fmt;
 116
 117         if (list_empty(&trace_bprintk_fmt_list))
 118                 return NULL;
 119
 120         /*
 121          * v will point to the address of the fmt record from t_next
 122          * v will be NULL from t_start.
 123          * If this is the first pointer or called from start
 124          * then we need to walk the list.
 125          */
 126         if (!v || start_index == *pos) {
 127                 struct trace_bprintk_fmt *p;
 128
 129                 /* search the module list */
 130                 list_for_each_entry(p, &trace_bprintk_fmt_list, list) {
 131                         if (start_index == *pos)
 132                                 return &p->fmt;
 133                         start_index++;
 134                 }
 135                 /* pos > index */
 136                 return NULL;
 137         }
 138
 139         /*
 140          * v points to the address of the fmt field in the mod list
 141          * structure that holds the module print format.
 142          */
 143         mod_fmt = container_of(v, typeof(*mod_fmt), fmt);
 144         if (mod_fmt->list.next == &trace_bprintk_fmt_list)
 145                 return NULL;
 146
 147         mod_fmt = container_of(mod_fmt->list.next, typeof(*mod_fmt), list);
 148
 149         return &mod_fmt->fmt;
 150 }
 151
 152 static void format_mod_start(void)
 153 {
 154         mutex_lock(&btrace_mutex);
 155 }
 156
 157 static void format_mod_stop(void)
 158 {
 159         mutex_unlock(&btrace_mutex);
 160 }
 161
 162 #else /* !CONFIG_MODULES */
 163 __init static int
 164 module_trace_bprintk_format_notify(struct notifier_block *self,
 165                 unsigned long val, void *data)
 166 {
 167         return 0;
 168 }
 169 static inline const char **
 170 find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)
 171 {
 172         return NULL;
 173 }
 174 static inline void format_mod_start(void) { }
 175 static inline void format_mod_stop(void) { }
 176 #endif /* CONFIG_MODULES */
 177
 178
 179 __initdata_or_module static
 180 struct notifier_block module_trace_bprintk_format_nb = {
 181         .notifier_call = module_trace_bprintk_format_notify,
 182 };
 183
 184 int __trace_bprintk(unsigned long ip, const char *fmt, ...)
 185  {
 186         int ret;
 187         va_list ap;
 188
 189         if (unlikely(!fmt))
 190                 return 0;
 191
 192         if (!(trace_flags & TRACE_ITER_PRINTK))
 193                 return 0;
 194
 195         va_start(ap, fmt);
 196         ret = trace_vbprintk(ip, fmt, ap);
 197         va_end(ap);
 198         return ret;
 199 }
 200 EXPORT_SYMBOL_GPL(__trace_bprintk);
 201
 202 int __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap)
 203  {
 204         if (unlikely(!fmt))
 205                 return 0;
 206
 207         if (!(trace_flags & TRACE_ITER_PRINTK))
 208                 return 0;
 209
 210         return trace_vbprintk(ip, fmt, ap);
 211 }
 212 EXPORT_SYMBOL_GPL(__ftrace_vbprintk);
 213
 214 int __trace_printk(unsigned long ip, const char *fmt, ...)
 215 {
 216         int ret;
 217         va_list ap;
 218
 219         if (!(trace_flags & TRACE_ITER_PRINTK))
 220                 return 0;
 221
 222         va_start(ap, fmt);
 223         ret = trace_vprintk(ip, fmt, ap);
 224         va_end(ap);
 225         return ret;
 226 }
 227 EXPORT_SYMBOL_GPL(__trace_printk);
 228
 229 int __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap)
 230 {
 231         if (!(trace_flags & TRACE_ITER_PRINTK))
 232                 return 0;
 233
 234         return trace_vprintk(ip, fmt, ap);
 235 }
 236 EXPORT_SYMBOL_GPL(__ftrace_vprintk);
 237
 238 static const char **find_next(void *v, loff_t *pos)
 239 {
 240         const char **fmt = v;
 241         int start_index;
 242
 243         if (!fmt)
 244                 fmt = __start___trace_bprintk_fmt + *pos;
 245
 246         start_index = __stop___trace_bprintk_fmt - __start___trace_bprintk_fmt;
 247
 248         if (*pos < start_index)
 249                 return fmt;
 250
 251         return find_next_mod_format(start_index, v, fmt, pos);
 252 }
 253
 254 static void *
 255 t_start(struct seq_file *m, loff_t *pos)
 256 {
 257         format_mod_start();
 258         return find_next(NULL, pos);
 259 }
 260
 261 static void *t_next(struct seq_file *m, void * v, loff_t *pos)
 262 {
 263         (*pos)++;
 264         return find_next(v, pos);
 265 }
 266
 267 static int t_show(struct seq_file *m, void *v)
 268 {
 269         const char **fmt = v;
 270         const char *str = *fmt;
 271         int i;
 272
 273         seq_printf(m, "0x%lx : \"", *(unsigned long *)fmt);
 274
 275         /*
 276          * Tabs and new lines need to be converted.
 277          */
 278         for (i = 0; str[i]; i++) {
 279                 switch (str[i]) {
 280                 case '\n':
 281                         seq_puts(m, "\\n");
 282                         break;
 283                 case '\t':
 284                         seq_puts(m, "\\t");
 285                         break;
 286                 case '\\':
 287                         seq_puts(m, "\\");
 288                         break;
 289                 case '"':
 290                         seq_puts(m, "\\\"");
 291                         break;
 292                 default:
 293                         seq_putc(m, str[i]);
 294                 }
 295         }
 296         seq_puts(m, "\"\n");
 297
 298         return 0;
 299 }
 300
 301 static void t_stop(struct seq_file *m, void *p)
 302 {
 303         format_mod_stop();
 304 }
 305
 306 static const struct seq_operations show_format_seq_ops = {
 307         .start = t_start,
 308         .next = t_next,
 309         .show = t_show,
 310         .stop = t_stop,
 311 };
 312
 313 static int
 314 ftrace_formats_open(struct inode *inode, struct file *file)
 315 {
 316         return seq_open(file, &show_format_seq_ops);
 317 }
 318
 319 static const struct file_operations ftrace_formats_fops = {
 320         .open = ftrace_formats_open,
 321         .read = seq_read,
 322         .llseek = seq_lseek,
 323         .release = seq_release,
 324 };
 325
 326 static __init int init_trace_printk_function_export(void)
 327 {
 328         struct dentry *d_tracer;
 329
 330         d_tracer = tracing_init_dentry();
 331         if (!d_tracer)
 332                 return 0;
 333
 334         trace_create_file("printk_formats", 0444, d_tracer,
 335                                     NULL, &ftrace_formats_fops);
 336
 337         return 0;
 338 }
 339
 340 fs_initcall(init_trace_printk_function_export);
 341
 342 static __init int init_trace_printk(void)
 343 {
 344         return register_module_notifier(&module_trace_bprintk_format_nb);
 345 }
 346
 347 early_initcall(init_trace_printk);