1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
/*
* trace binary printk
*
* Copyright (C) 2008 Lai Jiangshan <laijs@cn.fujitsu.com>
*
*/
#include <linux/kernel.h>
#include <linux/ftrace.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/seq_file.h>
#include <linux/fs.h>
#include <linux/marker.h>
#include <linux/uaccess.h>
#include "trace.h"
#ifdef CONFIG_MODULES
/* binary printk basic */
static DEFINE_MUTEX(btrace_mutex);
/*
* modules trace_bprintk()'s formats are autosaved in struct trace_bprintk_fmt
* which are queued on trace_bprintk_fmt_list.
*/
static LIST_HEAD(trace_bprintk_fmt_list);
struct trace_bprintk_fmt {
struct list_head list;
char fmt[0];
};
static inline void lock_btrace(void)
{
mutex_lock(&btrace_mutex);
}
static inline void unlock_btrace(void)
{
mutex_unlock(&btrace_mutex);
}
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;
lock_btrace();
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(offsetof(struct trace_bprintk_fmt, fmt)
+ strlen(*iter) + 1, GFP_KERNEL);
if (tb_fmt) {
list_add_tail(&tb_fmt->list, &trace_bprintk_fmt_list);
strcpy(tb_fmt->fmt, *iter);
*iter = tb_fmt->fmt;
} else
*iter = NULL;
}
unlock_btrace();
}
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;
}
#else /* !CONFIG_MODULES */
__init static int
module_trace_bprintk_format_notify(struct notifier_block *self,
unsigned long val, void *data)
{
return 0;
}
#endif /* CONFIG_MODULES */
__initdata_or_module static
struct notifier_block module_trace_bprintk_format_nb = {
.notifier_call = module_trace_bprintk_format_notify,
};
/* events tracer */
int trace_bprintk_enable;
static void start_bprintk_trace(struct trace_array *tr)
{
tracing_reset_online_cpus(tr);
trace_bprintk_enable = 1;
}
static void stop_bprintk_trace(struct trace_array *tr)
{
trace_bprintk_enable = 0;
tracing_reset_online_cpus(tr);
}
static int init_bprintk_trace(struct trace_array *tr)
{
start_bprintk_trace(tr);
return 0;
}
static struct tracer bprintk_trace __read_mostly =
{
.name = "events",
.init = init_bprintk_trace,
.reset = stop_bprintk_trace,
.start = start_bprintk_trace,
.stop = stop_bprintk_trace,
};
static __init int init_bprintk(void)
{
int ret = register_module_notifier(&module_trace_bprintk_format_nb);
if (ret)
return ret;
ret = register_tracer(&bprintk_trace);
if (ret)
unregister_module_notifier(&module_trace_bprintk_format_nb);
return ret;
}
device_initcall(init_bprintk);
|
