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/marker.h>
  15 #include <linux/mutex.h>
  16 #include <linux/ctype.h>
  17 #include <linux/list.h>
  18 #include <linux/slab.h>
  19 #include <linux/fs.h>
  20
  21 #include "trace.h"
  22
  23 #ifdef CONFIG_MODULES
  24
  25 /*
  26  * modules trace_printk()'s formats are autosaved in struct trace_bprintk_fmt
  27  * which are queued on trace_bprintk_fmt_list.
  28  */
  29 static LIST_HEAD(trace_bprintk_fmt_list);
  30
  31 /* serialize accesses to trace_bprintk_fmt_list */
  32 static DEFINE_MUTEX(btrace_mutex);
  33
  34 struct trace_bprintk_fmt {
  35         struct list_head list;
  36         char fmt[0];
  37 };
  38
  39 static inline struct trace_bprintk_fmt *lookup_format(const char *fmt)
  40 {
  41         struct trace_bprintk_fmt *pos;
  42         list_for_each_entry(pos, &trace_bprintk_fmt_list, list) {
  43                 if (!strcmp(pos->fmt, fmt))
  44                         return pos;
  45         }
  46         return NULL;
  47 }
  48
  49 static
  50 void hold_module_trace_bprintk_format(const char **start, const char **end)
  51 {
  52         const char **iter;
  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(offsetof(struct trace_bprintk_fmt, fmt)
  63                                 + strlen(*iter) + 1, GFP_KERNEL);
  64                 if (tb_fmt) {
  65                         list_add_tail(&tb_fmt->list, &trace_bprintk_fmt_list);
  66                         strcpy(tb_fmt->fmt, *iter);
  67                         *iter = tb_fmt->fmt;
  68                 } else
  69                         *iter = NULL;
  70         }
  71         mutex_unlock(&btrace_mutex);
  72 }
  73
  74 static int module_trace_bprintk_format_notify(struct notifier_block *self,
  75                 unsigned long val, void *data)
  76 {
  77         struct module *mod = data;
  78         if (mod->num_trace_bprintk_fmt) {
  79                 const char **start = mod->trace_bprintk_fmt_start;
  80                 const char **end = start + mod->num_trace_bprintk_fmt;
  81
  82                 if (val == MODULE_STATE_COMING)
  83                         hold_module_trace_bprintk_format(start, end);
  84         }
  85         return 0;
  86 }
  87
  88 #else /* !CONFIG_MODULES */
  89 __init static int
  90 module_trace_bprintk_format_notify(struct notifier_block *self,
  91                 unsigned long val, void *data)
  92 {
  93         return 0;
  94 }
  95 #endif /* CONFIG_MODULES */
  96
  97
  98 __initdata_or_module static
  99 struct notifier_block module_trace_bprintk_format_nb = {
 100         .notifier_call = module_trace_bprintk_format_notify,
 101 };
 102
 103 int __trace_bprintk(unsigned long ip, const char *fmt, ...)
 104  {
 105         int ret;
 106         va_list ap;
 107
 108         if (unlikely(!fmt))
 109                 return 0;
 110
 111         if (!(trace_flags & TRACE_ITER_PRINTK))
 112                 return 0;
 113
 114         va_start(ap, fmt);
 115         ret = trace_vbprintk(ip, fmt, ap);
 116         va_end(ap);
 117         return ret;
 118 }
 119 EXPORT_SYMBOL_GPL(__trace_bprintk);
 120
 121 int __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap)
 122  {
 123         if (unlikely(!fmt))
 124                 return 0;
 125
 126         if (!(trace_flags & TRACE_ITER_PRINTK))
 127                 return 0;
 128
 129         return trace_vbprintk(ip, fmt, ap);
 130 }
 131 EXPORT_SYMBOL_GPL(__ftrace_vbprintk);
 132
 133 int __trace_printk(unsigned long ip, const char *fmt, ...)
 134 {
 135         int ret;
 136         va_list ap;
 137
 138         if (!(trace_flags & TRACE_ITER_PRINTK))
 139                 return 0;
 140
 141         va_start(ap, fmt);
 142         ret = trace_vprintk(ip, fmt, ap);
 143         va_end(ap);
 144         return ret;
 145 }
 146 EXPORT_SYMBOL_GPL(__trace_printk);
 147
 148 int __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap)
 149 {
 150         if (!(trace_flags & TRACE_ITER_PRINTK))
 151                 return 0;
 152
 153         return trace_vprintk(ip, fmt, ap);
 154 }
 155 EXPORT_SYMBOL_GPL(__ftrace_vprintk);
 156
 157 static void *
 158 t_next(struct seq_file *m, void *v, loff_t *pos)
 159 {
 160         const char **fmt = m->private;
 161         const char **next = fmt;
 162
 163         (*pos)++;
 164
 165         if ((unsigned long)fmt >= (unsigned long)__stop___trace_bprintk_fmt)
 166                 return NULL;
 167
 168         next = fmt;
 169         m->private = ++next;
 170
 171         return fmt;
 172 }
 173
 174 static void *t_start(struct seq_file *m, loff_t *pos)
 175 {
 176         return t_next(m, NULL, pos);
 177 }
 178
 179 static int t_show(struct seq_file *m, void *v)
 180 {
 181         const char **fmt = v;
 182         const char *str = *fmt;
 183         int i;
 184
 185         seq_printf(m, "0x%lx : \"", (unsigned long)fmt);
 186
 187         /*
 188          * Tabs and new lines need to be converted.
 189          */
 190         for (i = 0; str[i]; i++) {
 191                 switch (str[i]) {
 192                 case '\n':
 193                         seq_puts(m, "\\n");
 194                         break;
 195                 case '\t':
 196                         seq_puts(m, "\\t");
 197                         break;
 198                 case '\\':
 199                         seq_puts(m, "\\");
 200                         break;
 201                 case '"':
 202                         seq_puts(m, "\\\"");
 203                         break;
 204                 default:
 205                         seq_putc(m, str[i]);
 206                 }
 207         }
 208         seq_puts(m, "\"\n");
 209
 210         return 0;
 211 }
 212
 213 static void t_stop(struct seq_file *m, void *p)
 214 {
 215 }
 216
 217 static const struct seq_operations show_format_seq_ops = {
 218         .start = t_start,
 219         .next = t_next,
 220         .show = t_show,
 221         .stop = t_stop,
 222 };
 223
 224 static int
 225 ftrace_formats_open(struct inode *inode, struct file *file)
 226 {
 227         int ret;
 228
 229         ret = seq_open(file, &show_format_seq_ops);
 230         if (!ret) {
 231                 struct seq_file *m = file->private_data;
 232
 233                 m->private = __start___trace_bprintk_fmt;
 234         }
 235         return ret;
 236 }
 237
 238 static const struct file_operations ftrace_formats_fops = {
 239         .open = ftrace_formats_open,
 240         .read = seq_read,
 241         .llseek = seq_lseek,
 242         .release = seq_release,
 243 };
 244
 245 static __init int init_trace_printk_function_export(void)
 246 {
 247         struct dentry *d_tracer;
 248         struct dentry *entry;
 249
 250         d_tracer = tracing_init_dentry();
 251         if (!d_tracer)
 252                 return 0;
 253
 254         entry = debugfs_create_file("printk_formats", 0444, d_tracer,
 255                                     NULL, &ftrace_formats_fops);
 256         if (!entry)
 257                 pr_warning("Could not create debugfs "
 258                            "'printk_formats' entry\n");
 259
 260         return 0;
 261 }
 262
 263 fs_initcall(init_trace_printk_function_export);
 264
 265 static __init int init_trace_printk(void)
 266 {
 267         return register_module_notifier(&module_trace_bprintk_format_nb);
 268 }
 269
 270 early_initcall(init_trace_printk);