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         int last_index;
 248
 249         start_index = __stop___trace_bprintk_fmt - __start___trace_bprintk_fmt;
 250
 251         if (*pos < start_index)
 252                 return __start___trace_bprintk_fmt + *pos;
 253
 254         /*
 255          * The __tracepoint_str section is treated the same as the
 256          * __trace_printk_fmt section. The difference is that the
 257          * __trace_printk_fmt section should only be used by trace_printk()
 258          * in a debugging environment, as if anything exists in that section
 259          * the trace_prink() helper buffers are allocated, which would just
 260          * waste space in a production environment.
 261          *
 262          * The __tracepoint_str sections on the other hand are used by
 263          * tracepoints which need to map pointers to their strings to
 264          * the ASCII text for userspace.
 265          */
 266         last_index = start_index;
 267         start_index = __stop___tracepoint_str - __start___tracepoint_str;
 268
 269         if (*pos < last_index + start_index)
 270                 return __start___tracepoint_str + (*pos - last_index);
 271
 272         return find_next_mod_format(start_index, v, fmt, pos);
 273 }
 274
 275 static void *
 276 t_start(struct seq_file *m, loff_t *pos)
 277 {
 278         format_mod_start();
 279         return find_next(NULL, pos);
 280 }
 281
 282 static void *t_next(struct seq_file *m, void * v, loff_t *pos)
 283 {
 284         (*pos)++;
 285         return find_next(v, pos);
 286 }
 287
 288 static int t_show(struct seq_file *m, void *v)
 289 {
 290         const char **fmt = v;
 291         const char *str = *fmt;
 292         int i;
 293
 294         seq_printf(m, "0x%lx : \"", *(unsigned long *)fmt);
 295
 296         /*
 297          * Tabs and new lines need to be converted.
 298          */
 299         for (i = 0; str[i]; i++) {
 300                 switch (str[i]) {
 301                 case '\n':
 302                         seq_puts(m, "\\n");
 303                         break;
 304                 case '\t':
 305                         seq_puts(m, "\\t");
 306                         break;
 307                 case '\\':
 308                         seq_puts(m, "\\");
 309                         break;
 310                 case '"':
 311                         seq_puts(m, "\\\"");
 312                         break;
 313                 default:
 314                         seq_putc(m, str[i]);
 315                 }
 316         }
 317         seq_puts(m, "\"\n");
 318
 319         return 0;
 320 }
 321
 322 static void t_stop(struct seq_file *m, void *p)
 323 {
 324         format_mod_stop();
 325 }
 326
 327 static const struct seq_operations show_format_seq_ops = {
 328         .start = t_start,
 329         .next = t_next,
 330         .show = t_show,
 331         .stop = t_stop,
 332 };
 333
 334 static int
 335 ftrace_formats_open(struct inode *inode, struct file *file)
 336 {
 337         return seq_open(file, &show_format_seq_ops);
 338 }
 339
 340 static const struct file_operations ftrace_formats_fops = {
 341         .open = ftrace_formats_open,
 342         .read = seq_read,
 343         .llseek = seq_lseek,
 344         .release = seq_release,
 345 };
 346
 347 static __init int init_trace_printk_function_export(void)
 348 {
 349         struct dentry *d_tracer;
 350
 351         d_tracer = tracing_init_dentry();
 352         if (!d_tracer)
 353                 return 0;
 354
 355         trace_create_file("printk_formats", 0444, d_tracer,
 356                                     NULL, &ftrace_formats_fops);
 357
 358         return 0;
 359 }
 360
 361 fs_initcall(init_trace_printk_function_export);
 362
 363 static __init int init_trace_printk(void)
 364 {
 365         return register_module_notifier(&module_trace_bprintk_format_nb);
 366 }
 367
 368 early_initcall(init_trace_printk);