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