forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
400 lines
8.9 KiB
400 lines
8.9 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* trace binary printk |
|
* |
|
* Copyright (C) 2008 Lai Jiangshan <[email protected]> |
|
* |
|
*/ |
|
#include <linux/seq_file.h> |
|
#include <linux/security.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 "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; |
|
|
|
if (!fmt) |
|
return ERR_PTR(-EINVAL); |
|
|
|
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; |
|
|
|
/* allocate the trace_printk per cpu buffers */ |
|
if (start != end) |
|
trace_printk_init_buffers(); |
|
|
|
mutex_lock(&btrace_mutex); |
|
for (iter = start; iter < end; iter++) { |
|
struct trace_bprintk_fmt *tb_fmt = lookup_format(*iter); |
|
if (tb_fmt) { |
|
if (!IS_ERR(tb_fmt)) |
|
*iter = tb_fmt->fmt; |
|
continue; |
|
} |
|
|
|
fmt = NULL; |
|
tb_fmt = kmalloc(sizeof(*tb_fmt), GFP_KERNEL); |
|
if (tb_fmt) { |
|
fmt = kmalloc(strlen(*iter) + 1, GFP_KERNEL); |
|
if (fmt) { |
|
list_add_tail(&tb_fmt->list, &trace_bprintk_fmt_list); |
|
strcpy(fmt, *iter); |
|
tb_fmt->fmt = fmt; |
|
} else |
|
kfree(tb_fmt); |
|
} |
|
*iter = fmt; |
|
|
|
} |
|
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 NOTIFY_OK; |
|
} |
|
|
|
/* |
|
* 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 container_of() 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 NOTIFY_OK; |
|
} |
|
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 */ |
|
|
|
static bool __read_mostly trace_printk_enabled = true; |
|
|
|
void trace_printk_control(bool enabled) |
|
{ |
|
trace_printk_enabled = enabled; |
|
} |
|
|
|
__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_printk_enabled) |
|
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_printk_enabled) |
|
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_printk_enabled) |
|
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_printk_enabled) |
|
return 0; |
|
|
|
return trace_vprintk(ip, fmt, ap); |
|
} |
|
EXPORT_SYMBOL_GPL(__ftrace_vprintk); |
|
|
|
bool trace_is_tracepoint_string(const char *str) |
|
{ |
|
const char **ptr = __start___tracepoint_str; |
|
|
|
for (ptr = __start___tracepoint_str; ptr < __stop___tracepoint_str; ptr++) { |
|
if (str == *ptr) |
|
return true; |
|
} |
|
return false; |
|
} |
|
|
|
static const char **find_next(void *v, loff_t *pos) |
|
{ |
|
const char **fmt = v; |
|
int start_index; |
|
int last_index; |
|
|
|
start_index = __stop___trace_bprintk_fmt - __start___trace_bprintk_fmt; |
|
|
|
if (*pos < start_index) |
|
return __start___trace_bprintk_fmt + *pos; |
|
|
|
/* |
|
* The __tracepoint_str section is treated the same as the |
|
* __trace_printk_fmt section. The difference is that the |
|
* __trace_printk_fmt section should only be used by trace_printk() |
|
* in a debugging environment, as if anything exists in that section |
|
* the trace_prink() helper buffers are allocated, which would just |
|
* waste space in a production environment. |
|
* |
|
* The __tracepoint_str sections on the other hand are used by |
|
* tracepoints which need to map pointers to their strings to |
|
* the ASCII text for userspace. |
|
*/ |
|
last_index = start_index; |
|
start_index = __stop___tracepoint_str - __start___tracepoint_str; |
|
|
|
if (*pos < last_index + start_index) |
|
return __start___tracepoint_str + (*pos - last_index); |
|
|
|
start_index += last_index; |
|
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; |
|
|
|
if (!*fmt) |
|
return 0; |
|
|
|
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_putc(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) |
|
{ |
|
int ret; |
|
|
|
ret = security_locked_down(LOCKDOWN_TRACEFS); |
|
if (ret) |
|
return ret; |
|
|
|
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) |
|
{ |
|
int ret; |
|
|
|
ret = tracing_init_dentry(); |
|
if (ret) |
|
return 0; |
|
|
|
trace_create_file("printk_formats", 0444, NULL, |
|
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);
|
|
|