linux/kernel/trace/trace_printk.c
<<
>>
Prefs
   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 */
  28static LIST_HEAD(trace_bprintk_fmt_list);
  29
  30/* serialize accesses to trace_bprintk_fmt_list */
  31static DEFINE_MUTEX(btrace_mutex);
  32
  33struct trace_bprintk_fmt {
  34        struct list_head list;
  35        const char *fmt;
  36};
  37
  38static 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
  48static
  49void 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
  83static 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 */
 117static const char **
 118find_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
 157static void format_mod_start(void)
 158{
 159        mutex_lock(&btrace_mutex);
 160}
 161
 162static void format_mod_stop(void)
 163{
 164        mutex_unlock(&btrace_mutex);
 165}
 166
 167#else /* !CONFIG_MODULES */
 168__init static int
 169module_trace_bprintk_format_notify(struct notifier_block *self,
 170                unsigned long val, void *data)
 171{
 172        return 0;
 173}
 174static inline const char **
 175find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)
 176{
 177        return NULL;
 178}
 179static inline void format_mod_start(void) { }
 180static inline void format_mod_stop(void) { }
 181#endif /* CONFIG_MODULES */
 182
 183
 184__initdata_or_module static
 185struct notifier_block module_trace_bprintk_format_nb = {
 186        .notifier_call = module_trace_bprintk_format_notify,
 187};
 188
 189int __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}
 205EXPORT_SYMBOL_GPL(__trace_bprintk);
 206
 207int __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}
 217EXPORT_SYMBOL_GPL(__ftrace_vbprintk);
 218
 219int __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}
 232EXPORT_SYMBOL_GPL(__trace_printk);
 233
 234int __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}
 241EXPORT_SYMBOL_GPL(__ftrace_vprintk);
 242
 243static 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
 256static void *
 257t_start(struct seq_file *m, loff_t *pos)
 258{
 259        format_mod_start();
 260        return find_next(NULL, pos);
 261}
 262
 263static void *t_next(struct seq_file *m, void * v, loff_t *pos)
 264{
 265        (*pos)++;
 266        return find_next(v, pos);
 267}
 268
 269static 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
 303static void t_stop(struct seq_file *m, void *p)
 304{
 305        format_mod_stop();
 306}
 307
 308static 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
 315static int
 316ftrace_formats_open(struct inode *inode, struct file *file)
 317{
 318        return seq_open(file, &show_format_seq_ops);
 319}
 320
 321static 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
 328static __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
 342fs_initcall(init_trace_printk_function_export);
 343
 344static __init int init_trace_printk(void)
 345{
 346        return register_module_notifier(&module_trace_bprintk_format_nb);
 347}
 348
 349early_initcall(init_trace_printk);
 350
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.