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/kernel.h>
   8 #include <linux/ftrace.h>
   9 #include <linux/string.h>
  10 #include <linux/ctype.h>
  11 #include <linux/list.h>
  12 #include <linux/mutex.h>
  13 #include <linux/slab.h>
  14 #include <linux/module.h>
  15 #include <linux/seq_file.h>
  16 #include <linux/fs.h>
  17 #include <linux/marker.h>
  18 #include <linux/uaccess.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         char fmt[0];
  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
  53         mutex_lock(&btrace_mutex);
  54         for (iter = start; iter < end; iter++) {
  55                 struct trace_bprintk_fmt *tb_fmt = lookup_format(*iter);
  56                 if (tb_fmt) {
  57                         *iter = tb_fmt->fmt;
  58                         continue;
  59                 }
  60
  61                 tb_fmt = kmalloc(offsetof(struct trace_bprintk_fmt, fmt)
  62                                 + strlen(*iter) + 1, GFP_KERNEL);
  63                 if (tb_fmt) {
  64                         list_add_tail(&tb_fmt->list, &trace_bprintk_fmt_list);
  65                         strcpy(tb_fmt->fmt, *iter);
  66                         *iter = tb_fmt->fmt;
  67                 } else
  68                         *iter = NULL;
  69         }
  70         mutex_unlock(&btrace_mutex);
  71 }
  72
  73 static int module_trace_bprintk_format_notify(struct notifier_block *self,
  74                 unsigned long val, void *data)
  75 {
  76         struct module *mod = data;
  77         if (mod->num_trace_bprintk_fmt) {
  78                 const char **start = mod->trace_bprintk_fmt_start;
  79                 const char **end = start + mod->num_trace_bprintk_fmt;
  80
  81                 if (val == MODULE_STATE_COMING)
  82                         hold_module_trace_bprintk_format(start, end);
  83         }
  84         return 0;
  85 }
  86
  87 #else /* !CONFIG_MODULES */
  88 __init static int
  89 module_trace_bprintk_format_notify(struct notifier_block *self,
  90                 unsigned long val, void *data)
  91 {
  92         return 0;
  93 }
  94 #endif /* CONFIG_MODULES */
  95
  96
  97 __initdata_or_module static
  98 struct notifier_block module_trace_bprintk_format_nb = {
  99         .notifier_call = module_trace_bprintk_format_notify,
 100 };
 101
 102 int __trace_printk(unsigned long ip, const char *fmt, ...)
 103  {
 104         int ret;
 105         va_list ap;
 106
 107         if (unlikely(!fmt))
 108                 return 0;
 109
 110         if (!(trace_flags & TRACE_ITER_PRINTK))
 111                 return 0;
 112
 113         va_start(ap, fmt);
 114         ret = trace_vprintk(ip, task_curr_ret_stack(current), fmt, ap);
 115         va_end(ap);
 116         return ret;
 117 }
 118 EXPORT_SYMBOL_GPL(__trace_printk);
 119
 120 int __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap)
 121  {
 122         if (unlikely(!fmt))
 123                 return 0;
 124
 125         if (!(trace_flags & TRACE_ITER_PRINTK))
 126                 return 0;
 127
 128         return trace_vprintk(ip, task_curr_ret_stack(current), fmt, ap);
 129 }
 130 EXPORT_SYMBOL_GPL(__ftrace_vprintk);
 131
 132
 133 static __init int init_trace_printk(void)
 134 {
 135         return register_module_notifier(&module_trace_bprintk_format_nb);
 136 }
 137
 138 early_initcall(init_trace_printk);