2 * trace_ksym.c - Kernel Symbol Tracer
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 * Copyright (C) IBM Corporation, 2009
21 #include <linux/kallsyms.h>
22 #include <linux/uaccess.h>
23 #include <linux/debugfs.h>
24 #include <linux/ftrace.h>
25 #include <linux/module.h>
28 #include "trace_output.h"
31 #include <linux/hw_breakpoint.h>
32 #include <asm/hw_breakpoint.h>
34 #include <asm/atomic.h>
37 * For now, let us restrict the no. of symbols traced simultaneously to number
38 * of available hardware breakpoint registers.
40 #define KSYM_TRACER_MAX HBP_NUM
42 #define KSYM_TRACER_OP_LEN 3 /* rw- */
45 struct perf_event
**ksym_hbp
;
46 struct perf_event_attr attr
;
47 #ifdef CONFIG_PROFILE_KSYM_TRACER
50 struct hlist_node ksym_hlist
;
53 static struct trace_array
*ksym_trace_array
;
55 static unsigned int ksym_filter_entry_count
;
56 static unsigned int ksym_tracing_enabled
;
58 static HLIST_HEAD(ksym_filter_head
);
60 static DEFINE_MUTEX(ksym_tracer_mutex
);
62 #ifdef CONFIG_PROFILE_KSYM_TRACER
64 #define MAX_UL_INT 0xffffffff
66 void ksym_collect_stats(unsigned long hbp_hit_addr
)
68 struct hlist_node
*node
;
69 struct trace_ksym
*entry
;
72 hlist_for_each_entry_rcu(entry
, node
, &ksym_filter_head
, ksym_hlist
) {
73 if (entry
->attr
.bp_addr
== hbp_hit_addr
) {
74 atomic64_inc(&entry
->counter
);
80 #endif /* CONFIG_PROFILE_KSYM_TRACER */
82 void ksym_hbp_handler(struct perf_event
*hbp
, int nmi
,
83 struct perf_sample_data
*data
,
86 struct ring_buffer_event
*event
;
87 struct ksym_trace_entry
*entry
;
88 struct ring_buffer
*buffer
;
91 if (!ksym_tracing_enabled
)
94 buffer
= ksym_trace_array
->buffer
;
98 event
= trace_buffer_lock_reserve(buffer
, TRACE_KSYM
,
99 sizeof(*entry
), 0, pc
);
103 entry
= ring_buffer_event_data(event
);
104 entry
->ip
= instruction_pointer(regs
);
105 entry
->type
= hw_breakpoint_type(hbp
);
106 entry
->addr
= hw_breakpoint_addr(hbp
);
107 strlcpy(entry
->cmd
, current
->comm
, TASK_COMM_LEN
);
109 #ifdef CONFIG_PROFILE_KSYM_TRACER
110 ksym_collect_stats(hw_breakpoint_addr(hbp
));
111 #endif /* CONFIG_PROFILE_KSYM_TRACER */
113 trace_buffer_unlock_commit(buffer
, event
, 0, pc
);
116 /* Valid access types are represented as
118 * rw- : Set Read/Write Access Breakpoint
119 * -w- : Set Write Access Breakpoint
120 * --- : Clear Breakpoints
121 * --x : Set Execution Break points (Not available yet)
124 static int ksym_trace_get_access_type(char *str
)
129 access
|= HW_BREAKPOINT_R
;
132 access
|= HW_BREAKPOINT_W
;
135 access
|= HW_BREAKPOINT_X
;
138 case HW_BREAKPOINT_R
:
139 case HW_BREAKPOINT_W
:
140 case HW_BREAKPOINT_W
| HW_BREAKPOINT_R
:
148 * There can be several possible malformed requests and we attempt to capture
149 * all of them. We enumerate some of the rules
150 * 1. We will not allow kernel symbols with ':' since it is used as a delimiter.
151 * i.e. multiple ':' symbols disallowed. Possible uses are of the form
152 * <module>:<ksym_name>:<op>.
153 * 2. No delimiter symbol ':' in the input string
154 * 3. Spurious operator symbols or symbols not in their respective positions
155 * 4. <ksym_name>:--- i.e. clear breakpoint request when ksym_name not in file
156 * 5. Kernel symbol not a part of /proc/kallsyms
157 * 6. Duplicate requests
159 static int parse_ksym_trace_str(char *input_string
, char **ksymname
,
164 *ksymname
= strsep(&input_string
, ":");
165 *addr
= kallsyms_lookup_name(*ksymname
);
167 /* Check for malformed request: (2), (1) and (5) */
168 if ((!input_string
) ||
169 (strlen(input_string
) != KSYM_TRACER_OP_LEN
) ||
173 ret
= ksym_trace_get_access_type(input_string
);
178 int process_new_ksym_entry(char *ksymname
, int op
, unsigned long addr
)
180 struct trace_ksym
*entry
;
183 if (ksym_filter_entry_count
>= KSYM_TRACER_MAX
) {
184 printk(KERN_ERR
"ksym_tracer: Maximum limit:(%d) reached. No"
185 " new requests for tracing can be accepted now.\n",
190 entry
= kzalloc(sizeof(struct trace_ksym
), GFP_KERNEL
);
194 hw_breakpoint_init(&entry
->attr
);
196 entry
->attr
.bp_type
= op
;
197 entry
->attr
.bp_addr
= addr
;
198 entry
->attr
.bp_len
= HW_BREAKPOINT_LEN_4
;
200 entry
->ksym_hbp
= register_wide_hw_breakpoint(&entry
->attr
,
203 if (IS_ERR(entry
->ksym_hbp
)) {
204 ret
= PTR_ERR(entry
->ksym_hbp
);
205 printk(KERN_INFO
"ksym_tracer request failed. Try again"
210 hlist_add_head_rcu(&(entry
->ksym_hlist
), &ksym_filter_head
);
211 ksym_filter_entry_count
++;
221 static ssize_t
ksym_trace_filter_read(struct file
*filp
, char __user
*ubuf
,
222 size_t count
, loff_t
*ppos
)
224 struct trace_ksym
*entry
;
225 struct hlist_node
*node
;
230 s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
235 mutex_lock(&ksym_tracer_mutex
);
237 hlist_for_each_entry(entry
, node
, &ksym_filter_head
, ksym_hlist
) {
238 ret
= trace_seq_printf(s
, "%pS:",
239 (void *)(unsigned long)entry
->attr
.bp_addr
);
240 if (entry
->attr
.bp_type
== HW_BREAKPOINT_R
)
241 ret
= trace_seq_puts(s
, "r--\n");
242 else if (entry
->attr
.bp_type
== HW_BREAKPOINT_W
)
243 ret
= trace_seq_puts(s
, "-w-\n");
244 else if (entry
->attr
.bp_type
== (HW_BREAKPOINT_W
| HW_BREAKPOINT_R
))
245 ret
= trace_seq_puts(s
, "rw-\n");
249 cnt
= simple_read_from_buffer(ubuf
, count
, ppos
, s
->buffer
, s
->len
);
251 mutex_unlock(&ksym_tracer_mutex
);
258 static void __ksym_trace_reset(void)
260 struct trace_ksym
*entry
;
261 struct hlist_node
*node
, *node1
;
263 mutex_lock(&ksym_tracer_mutex
);
264 hlist_for_each_entry_safe(entry
, node
, node1
, &ksym_filter_head
,
266 unregister_wide_hw_breakpoint(entry
->ksym_hbp
);
267 ksym_filter_entry_count
--;
268 hlist_del_rcu(&(entry
->ksym_hlist
));
272 mutex_unlock(&ksym_tracer_mutex
);
275 static ssize_t
ksym_trace_filter_write(struct file
*file
,
276 const char __user
*buffer
,
277 size_t count
, loff_t
*ppos
)
279 struct trace_ksym
*entry
;
280 struct hlist_node
*node
;
281 char *buf
, *input_string
, *ksymname
= NULL
;
282 unsigned long ksym_addr
= 0;
283 int ret
, op
, changed
= 0;
285 buf
= kzalloc(count
+ 1, GFP_KERNEL
);
290 if (copy_from_user(buf
, buffer
, count
))
294 input_string
= strstrip(buf
);
297 * Clear all breakpoints if:
298 * 1: echo > ksym_trace_filter
299 * 2: echo 0 > ksym_trace_filter
300 * 3: echo "*:---" > ksym_trace_filter
302 if (!input_string
[0] || !strcmp(input_string
, "0") ||
303 !strcmp(input_string
, "*:---")) {
304 __ksym_trace_reset();
309 ret
= op
= parse_ksym_trace_str(input_string
, &ksymname
, &ksym_addr
);
313 mutex_lock(&ksym_tracer_mutex
);
316 hlist_for_each_entry(entry
, node
, &ksym_filter_head
, ksym_hlist
) {
317 if (entry
->attr
.bp_addr
== ksym_addr
) {
318 /* Check for malformed request: (6) */
319 if (entry
->attr
.bp_type
!= op
)
327 unregister_wide_hw_breakpoint(entry
->ksym_hbp
);
328 entry
->attr
.bp_type
= op
;
332 register_wide_hw_breakpoint(&entry
->attr
,
334 if (IS_ERR(entry
->ksym_hbp
))
335 ret
= PTR_ERR(entry
->ksym_hbp
);
339 /* Error or "symbol:---" case: drop it */
340 ksym_filter_entry_count
--;
341 hlist_del_rcu(&(entry
->ksym_hlist
));
346 /* Check for malformed request: (4) */
348 ret
= process_new_ksym_entry(ksymname
, op
, ksym_addr
);
351 mutex_unlock(&ksym_tracer_mutex
);
354 return !ret
? count
: ret
;
357 static const struct file_operations ksym_tracing_fops
= {
358 .open
= tracing_open_generic
,
359 .read
= ksym_trace_filter_read
,
360 .write
= ksym_trace_filter_write
,
363 static void ksym_trace_reset(struct trace_array
*tr
)
365 ksym_tracing_enabled
= 0;
366 __ksym_trace_reset();
369 static int ksym_trace_init(struct trace_array
*tr
)
373 for_each_online_cpu(cpu
)
374 tracing_reset(tr
, cpu
);
375 ksym_tracing_enabled
= 1;
376 ksym_trace_array
= tr
;
381 static void ksym_trace_print_header(struct seq_file
*m
)
384 "# TASK-PID CPU# Symbol "
391 static enum print_line_t
ksym_trace_output(struct trace_iterator
*iter
)
393 struct trace_entry
*entry
= iter
->ent
;
394 struct trace_seq
*s
= &iter
->seq
;
395 struct ksym_trace_entry
*field
;
396 char str
[KSYM_SYMBOL_LEN
];
399 if (entry
->type
!= TRACE_KSYM
)
400 return TRACE_TYPE_UNHANDLED
;
402 trace_assign_type(field
, entry
);
404 ret
= trace_seq_printf(s
, "%11s-%-5d [%03d] %pS", field
->cmd
,
405 entry
->pid
, iter
->cpu
, (char *)field
->addr
);
407 return TRACE_TYPE_PARTIAL_LINE
;
409 switch (field
->type
) {
410 case HW_BREAKPOINT_R
:
411 ret
= trace_seq_printf(s
, " R ");
413 case HW_BREAKPOINT_W
:
414 ret
= trace_seq_printf(s
, " W ");
416 case HW_BREAKPOINT_R
| HW_BREAKPOINT_W
:
417 ret
= trace_seq_printf(s
, " RW ");
420 return TRACE_TYPE_PARTIAL_LINE
;
424 return TRACE_TYPE_PARTIAL_LINE
;
426 sprint_symbol(str
, field
->ip
);
427 ret
= trace_seq_printf(s
, "%s\n", str
);
429 return TRACE_TYPE_PARTIAL_LINE
;
431 return TRACE_TYPE_HANDLED
;
434 struct tracer ksym_tracer __read_mostly
=
436 .name
= "ksym_tracer",
437 .init
= ksym_trace_init
,
438 .reset
= ksym_trace_reset
,
439 #ifdef CONFIG_FTRACE_SELFTEST
440 .selftest
= trace_selftest_startup_ksym
,
442 .print_header
= ksym_trace_print_header
,
443 .print_line
= ksym_trace_output
446 #ifdef CONFIG_PROFILE_KSYM_TRACER
447 static int ksym_profile_show(struct seq_file
*m
, void *v
)
449 struct hlist_node
*node
;
450 struct trace_ksym
*entry
;
452 char fn_name
[KSYM_NAME_LEN
];
454 seq_puts(m
, " Access Type ");
455 seq_puts(m
, " Symbol Counter\n");
456 seq_puts(m
, " ----------- ");
457 seq_puts(m
, " ------ -------\n");
460 hlist_for_each_entry_rcu(entry
, node
, &ksym_filter_head
, ksym_hlist
) {
462 access_type
= entry
->attr
.bp_type
;
464 switch (access_type
) {
465 case HW_BREAKPOINT_R
:
468 case HW_BREAKPOINT_W
:
471 case HW_BREAKPOINT_R
| HW_BREAKPOINT_W
:
478 if (lookup_symbol_name(entry
->attr
.bp_addr
, fn_name
) >= 0)
479 seq_printf(m
, " %-36s", fn_name
);
481 seq_printf(m
, " %-36s", "<NA>");
482 seq_printf(m
, " %15llu\n",
483 (unsigned long long)atomic64_read(&entry
->counter
));
490 static int ksym_profile_open(struct inode
*node
, struct file
*file
)
492 return single_open(file
, ksym_profile_show
, NULL
);
495 static const struct file_operations ksym_profile_fops
= {
496 .open
= ksym_profile_open
,
499 .release
= single_release
,
501 #endif /* CONFIG_PROFILE_KSYM_TRACER */
503 __init
static int init_ksym_trace(void)
505 struct dentry
*d_tracer
;
507 d_tracer
= tracing_init_dentry();
509 trace_create_file("ksym_trace_filter", 0644, d_tracer
,
510 NULL
, &ksym_tracing_fops
);
512 #ifdef CONFIG_PROFILE_KSYM_TRACER
513 trace_create_file("ksym_profile", 0444, d_tracer
,
514 NULL
, &ksym_profile_fops
);
517 return register_tracer(&ksym_tracer
);
519 device_initcall(init_ksym_trace
);