![Steven Rostedt](/assets/img/avatar_default.png)
The fix to fix the printk_formats of modules broke the printk_formats of trace_printks in the kernel. The update of what to show via the seq_file was only updated if the passed in fmt was NULL, which happens only on the first iteration. The result was showing the first format every time instead of iterating through the available formats. Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
345 lines
7.6 KiB
C
345 lines
7.6 KiB
C
/*
|
|
* trace binary printk
|
|
*
|
|
* Copyright (C) 2008 Lai Jiangshan <laijs@cn.fujitsu.com>
|
|
*
|
|
*/
|
|
#include <linux/seq_file.h>
|
|
#include <linux/debugfs.h>
|
|
#include <linux/uaccess.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/ftrace.h>
|
|
#include <linux/string.h>
|
|
#include <linux/module.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/ctype.h>
|
|
#include <linux/list.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/fs.h>
|
|
|
|
#include "trace.h"
|
|
|
|
#ifdef CONFIG_MODULES
|
|
|
|
/*
|
|
* modules trace_printk()'s formats are autosaved in struct trace_bprintk_fmt
|
|
* which are queued on trace_bprintk_fmt_list.
|
|
*/
|
|
static LIST_HEAD(trace_bprintk_fmt_list);
|
|
|
|
/* serialize accesses to trace_bprintk_fmt_list */
|
|
static DEFINE_MUTEX(btrace_mutex);
|
|
|
|
struct trace_bprintk_fmt {
|
|
struct list_head list;
|
|
const char *fmt;
|
|
};
|
|
|
|
static inline struct trace_bprintk_fmt *lookup_format(const char *fmt)
|
|
{
|
|
struct trace_bprintk_fmt *pos;
|
|
list_for_each_entry(pos, &trace_bprintk_fmt_list, list) {
|
|
if (!strcmp(pos->fmt, fmt))
|
|
return pos;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static
|
|
void hold_module_trace_bprintk_format(const char **start, const char **end)
|
|
{
|
|
const char **iter;
|
|
char *fmt;
|
|
|
|
mutex_lock(&btrace_mutex);
|
|
for (iter = start; iter < end; iter++) {
|
|
struct trace_bprintk_fmt *tb_fmt = lookup_format(*iter);
|
|
if (tb_fmt) {
|
|
*iter = tb_fmt->fmt;
|
|
continue;
|
|
}
|
|
|
|
tb_fmt = kmalloc(sizeof(*tb_fmt), GFP_KERNEL);
|
|
if (tb_fmt)
|
|
fmt = kmalloc(strlen(*iter) + 1, GFP_KERNEL);
|
|
if (tb_fmt && fmt) {
|
|
list_add_tail(&tb_fmt->list, &trace_bprintk_fmt_list);
|
|
strcpy(fmt, *iter);
|
|
tb_fmt->fmt = fmt;
|
|
*iter = tb_fmt->fmt;
|
|
} else {
|
|
kfree(tb_fmt);
|
|
*iter = NULL;
|
|
}
|
|
}
|
|
mutex_unlock(&btrace_mutex);
|
|
}
|
|
|
|
static int module_trace_bprintk_format_notify(struct notifier_block *self,
|
|
unsigned long val, void *data)
|
|
{
|
|
struct module *mod = data;
|
|
if (mod->num_trace_bprintk_fmt) {
|
|
const char **start = mod->trace_bprintk_fmt_start;
|
|
const char **end = start + mod->num_trace_bprintk_fmt;
|
|
|
|
if (val == MODULE_STATE_COMING)
|
|
hold_module_trace_bprintk_format(start, end);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* The debugfs/tracing/printk_formats file maps the addresses with
|
|
* the ASCII formats that are used in the bprintk events in the
|
|
* buffer. For userspace tools to be able to decode the events from
|
|
* the buffer, they need to be able to map the address with the format.
|
|
*
|
|
* The addresses of the bprintk formats are in their own section
|
|
* __trace_printk_fmt. But for modules we copy them into a link list.
|
|
* The code to print the formats and their addresses passes around the
|
|
* address of the fmt string. If the fmt address passed into the seq
|
|
* functions is within the kernel core __trace_printk_fmt section, then
|
|
* it simply uses the next pointer in the list.
|
|
*
|
|
* When the fmt pointer is outside the kernel core __trace_printk_fmt
|
|
* section, then we need to read the link list pointers. The trick is
|
|
* we pass the address of the string to the seq function just like
|
|
* we do for the kernel core formats. To get back the structure that
|
|
* holds the format, we simply use containerof() and then go to the
|
|
* next format in the list.
|
|
*/
|
|
static const char **
|
|
find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)
|
|
{
|
|
struct trace_bprintk_fmt *mod_fmt;
|
|
|
|
if (list_empty(&trace_bprintk_fmt_list))
|
|
return NULL;
|
|
|
|
/*
|
|
* v will point to the address of the fmt record from t_next
|
|
* v will be NULL from t_start.
|
|
* If this is the first pointer or called from start
|
|
* then we need to walk the list.
|
|
*/
|
|
if (!v || start_index == *pos) {
|
|
struct trace_bprintk_fmt *p;
|
|
|
|
/* search the module list */
|
|
list_for_each_entry(p, &trace_bprintk_fmt_list, list) {
|
|
if (start_index == *pos)
|
|
return &p->fmt;
|
|
start_index++;
|
|
}
|
|
/* pos > index */
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* v points to the address of the fmt field in the mod list
|
|
* structure that holds the module print format.
|
|
*/
|
|
mod_fmt = container_of(v, typeof(*mod_fmt), fmt);
|
|
if (mod_fmt->list.next == &trace_bprintk_fmt_list)
|
|
return NULL;
|
|
|
|
mod_fmt = container_of(mod_fmt->list.next, typeof(*mod_fmt), list);
|
|
|
|
return &mod_fmt->fmt;
|
|
}
|
|
|
|
static void format_mod_start(void)
|
|
{
|
|
mutex_lock(&btrace_mutex);
|
|
}
|
|
|
|
static void format_mod_stop(void)
|
|
{
|
|
mutex_unlock(&btrace_mutex);
|
|
}
|
|
|
|
#else /* !CONFIG_MODULES */
|
|
__init static int
|
|
module_trace_bprintk_format_notify(struct notifier_block *self,
|
|
unsigned long val, void *data)
|
|
{
|
|
return 0;
|
|
}
|
|
static inline const char **
|
|
find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)
|
|
{
|
|
return NULL;
|
|
}
|
|
static inline void format_mod_start(void) { }
|
|
static inline void format_mod_stop(void) { }
|
|
#endif /* CONFIG_MODULES */
|
|
|
|
|
|
__initdata_or_module static
|
|
struct notifier_block module_trace_bprintk_format_nb = {
|
|
.notifier_call = module_trace_bprintk_format_notify,
|
|
};
|
|
|
|
int __trace_bprintk(unsigned long ip, const char *fmt, ...)
|
|
{
|
|
int ret;
|
|
va_list ap;
|
|
|
|
if (unlikely(!fmt))
|
|
return 0;
|
|
|
|
if (!(trace_flags & TRACE_ITER_PRINTK))
|
|
return 0;
|
|
|
|
va_start(ap, fmt);
|
|
ret = trace_vbprintk(ip, fmt, ap);
|
|
va_end(ap);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(__trace_bprintk);
|
|
|
|
int __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap)
|
|
{
|
|
if (unlikely(!fmt))
|
|
return 0;
|
|
|
|
if (!(trace_flags & TRACE_ITER_PRINTK))
|
|
return 0;
|
|
|
|
return trace_vbprintk(ip, fmt, ap);
|
|
}
|
|
EXPORT_SYMBOL_GPL(__ftrace_vbprintk);
|
|
|
|
int __trace_printk(unsigned long ip, const char *fmt, ...)
|
|
{
|
|
int ret;
|
|
va_list ap;
|
|
|
|
if (!(trace_flags & TRACE_ITER_PRINTK))
|
|
return 0;
|
|
|
|
va_start(ap, fmt);
|
|
ret = trace_vprintk(ip, fmt, ap);
|
|
va_end(ap);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(__trace_printk);
|
|
|
|
int __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap)
|
|
{
|
|
if (!(trace_flags & TRACE_ITER_PRINTK))
|
|
return 0;
|
|
|
|
return trace_vprintk(ip, fmt, ap);
|
|
}
|
|
EXPORT_SYMBOL_GPL(__ftrace_vprintk);
|
|
|
|
static const char **find_next(void *v, loff_t *pos)
|
|
{
|
|
const char **fmt = v;
|
|
int start_index;
|
|
|
|
start_index = __stop___trace_bprintk_fmt - __start___trace_bprintk_fmt;
|
|
|
|
if (*pos < start_index)
|
|
return __start___trace_bprintk_fmt + *pos;
|
|
|
|
return find_next_mod_format(start_index, v, fmt, pos);
|
|
}
|
|
|
|
static void *
|
|
t_start(struct seq_file *m, loff_t *pos)
|
|
{
|
|
format_mod_start();
|
|
return find_next(NULL, pos);
|
|
}
|
|
|
|
static void *t_next(struct seq_file *m, void * v, loff_t *pos)
|
|
{
|
|
(*pos)++;
|
|
return find_next(v, pos);
|
|
}
|
|
|
|
static int t_show(struct seq_file *m, void *v)
|
|
{
|
|
const char **fmt = v;
|
|
const char *str = *fmt;
|
|
int i;
|
|
|
|
seq_printf(m, "0x%lx : \"", *(unsigned long *)fmt);
|
|
|
|
/*
|
|
* Tabs and new lines need to be converted.
|
|
*/
|
|
for (i = 0; str[i]; i++) {
|
|
switch (str[i]) {
|
|
case '\n':
|
|
seq_puts(m, "\\n");
|
|
break;
|
|
case '\t':
|
|
seq_puts(m, "\\t");
|
|
break;
|
|
case '\\':
|
|
seq_puts(m, "\\");
|
|
break;
|
|
case '"':
|
|
seq_puts(m, "\\\"");
|
|
break;
|
|
default:
|
|
seq_putc(m, str[i]);
|
|
}
|
|
}
|
|
seq_puts(m, "\"\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void t_stop(struct seq_file *m, void *p)
|
|
{
|
|
format_mod_stop();
|
|
}
|
|
|
|
static const struct seq_operations show_format_seq_ops = {
|
|
.start = t_start,
|
|
.next = t_next,
|
|
.show = t_show,
|
|
.stop = t_stop,
|
|
};
|
|
|
|
static int
|
|
ftrace_formats_open(struct inode *inode, struct file *file)
|
|
{
|
|
return seq_open(file, &show_format_seq_ops);
|
|
}
|
|
|
|
static const struct file_operations ftrace_formats_fops = {
|
|
.open = ftrace_formats_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = seq_release,
|
|
};
|
|
|
|
static __init int init_trace_printk_function_export(void)
|
|
{
|
|
struct dentry *d_tracer;
|
|
|
|
d_tracer = tracing_init_dentry();
|
|
if (!d_tracer)
|
|
return 0;
|
|
|
|
trace_create_file("printk_formats", 0444, d_tracer,
|
|
NULL, &ftrace_formats_fops);
|
|
|
|
return 0;
|
|
}
|
|
|
|
fs_initcall(init_trace_printk_function_export);
|
|
|
|
static __init int init_trace_printk(void)
|
|
{
|
|
return register_module_notifier(&module_trace_bprintk_format_nb);
|
|
}
|
|
|
|
early_initcall(init_trace_printk);
|