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