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