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"
29 #include "trace_stat.h"
32 #include <linux/hw_breakpoint.h>
33 #include <asm/hw_breakpoint.h>
36 * For now, let us restrict the no. of symbols traced simultaneously to number
37 * of available hardware breakpoint registers.
39 #define KSYM_TRACER_MAX HBP_NUM
41 #define KSYM_TRACER_OP_LEN 3 /* rw- */
44 struct perf_event
**ksym_hbp
;
45 struct perf_event_attr attr
;
46 #ifdef CONFIG_PROFILE_KSYM_TRACER
47 unsigned long counter
;
49 struct hlist_node ksym_hlist
;
52 static struct trace_array
*ksym_trace_array
;
54 static unsigned int ksym_filter_entry_count
;
55 static unsigned int ksym_tracing_enabled
;
57 static HLIST_HEAD(ksym_filter_head
);
59 static DEFINE_MUTEX(ksym_tracer_mutex
);
61 #ifdef CONFIG_PROFILE_KSYM_TRACER
63 #define MAX_UL_INT 0xffffffff
65 void ksym_collect_stats(unsigned long hbp_hit_addr
)
67 struct hlist_node
*node
;
68 struct trace_ksym
*entry
;
71 hlist_for_each_entry_rcu(entry
, node
, &ksym_filter_head
, ksym_hlist
) {
72 if ((entry
->attr
.bp_addr
== hbp_hit_addr
) &&
73 (entry
->counter
<= MAX_UL_INT
)) {
80 #endif /* CONFIG_PROFILE_KSYM_TRACER */
82 void ksym_hbp_handler(struct perf_event
*hbp
, void *data
)
84 struct ring_buffer_event
*event
;
85 struct ksym_trace_entry
*entry
;
86 struct pt_regs
*regs
= data
;
87 struct ring_buffer
*buffer
;
90 if (!ksym_tracing_enabled
)
93 buffer
= ksym_trace_array
->buffer
;
97 event
= trace_buffer_lock_reserve(buffer
, TRACE_KSYM
,
98 sizeof(*entry
), 0, pc
);
102 entry
= ring_buffer_event_data(event
);
103 entry
->ip
= instruction_pointer(regs
);
104 entry
->type
= hw_breakpoint_type(hbp
);
105 entry
->addr
= hw_breakpoint_addr(hbp
);
106 strlcpy(entry
->cmd
, current
->comm
, TASK_COMM_LEN
);
108 #ifdef CONFIG_PROFILE_KSYM_TRACER
109 ksym_collect_stats(hw_breakpoint_addr(hbp
));
110 #endif /* CONFIG_PROFILE_KSYM_TRACER */
112 trace_buffer_unlock_commit(buffer
, event
, 0, pc
);
115 /* Valid access types are represented as
117 * rw- : Set Read/Write Access Breakpoint
118 * -w- : Set Write Access Breakpoint
119 * --- : Clear Breakpoints
120 * --x : Set Execution Break points (Not available yet)
123 static int ksym_trace_get_access_type(char *str
)
128 access
|= HW_BREAKPOINT_R
;
131 access
|= HW_BREAKPOINT_W
;
134 access
|= HW_BREAKPOINT_X
;
137 case HW_BREAKPOINT_R
:
138 case HW_BREAKPOINT_W
:
139 case HW_BREAKPOINT_W
| HW_BREAKPOINT_R
:
147 * There can be several possible malformed requests and we attempt to capture
148 * all of them. We enumerate some of the rules
149 * 1. We will not allow kernel symbols with ':' since it is used as a delimiter.
150 * i.e. multiple ':' symbols disallowed. Possible uses are of the form
151 * <module>:<ksym_name>:<op>.
152 * 2. No delimiter symbol ':' in the input string
153 * 3. Spurious operator symbols or symbols not in their respective positions
154 * 4. <ksym_name>:--- i.e. clear breakpoint request when ksym_name not in file
155 * 5. Kernel symbol not a part of /proc/kallsyms
156 * 6. Duplicate requests
158 static int parse_ksym_trace_str(char *input_string
, char **ksymname
,
163 *ksymname
= strsep(&input_string
, ":");
164 *addr
= kallsyms_lookup_name(*ksymname
);
166 /* Check for malformed request: (2), (1) and (5) */
167 if ((!input_string
) ||
168 (strlen(input_string
) != KSYM_TRACER_OP_LEN
) ||
172 ret
= ksym_trace_get_access_type(input_string
);
177 int process_new_ksym_entry(char *ksymname
, int op
, unsigned long addr
)
179 struct trace_ksym
*entry
;
182 if (ksym_filter_entry_count
>= KSYM_TRACER_MAX
) {
183 printk(KERN_ERR
"ksym_tracer: Maximum limit:(%d) reached. No"
184 " new requests for tracing can be accepted now.\n",
189 entry
= kzalloc(sizeof(struct trace_ksym
), GFP_KERNEL
);
193 hw_breakpoint_init(&entry
->attr
);
195 entry
->attr
.bp_type
= op
;
196 entry
->attr
.bp_addr
= addr
;
197 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:", (void *)entry
->attr
.bp_addr
);
239 if (entry
->attr
.bp_type
== HW_BREAKPOINT_R
)
240 ret
= trace_seq_puts(s
, "r--\n");
241 else if (entry
->attr
.bp_type
== HW_BREAKPOINT_W
)
242 ret
= trace_seq_puts(s
, "-w-\n");
243 else if (entry
->attr
.bp_type
== (HW_BREAKPOINT_W
| HW_BREAKPOINT_R
))
244 ret
= trace_seq_puts(s
, "rw-\n");
248 cnt
= simple_read_from_buffer(ubuf
, count
, ppos
, s
->buffer
, s
->len
);
250 mutex_unlock(&ksym_tracer_mutex
);
257 static void __ksym_trace_reset(void)
259 struct trace_ksym
*entry
;
260 struct hlist_node
*node
, *node1
;
262 mutex_lock(&ksym_tracer_mutex
);
263 hlist_for_each_entry_safe(entry
, node
, node1
, &ksym_filter_head
,
265 unregister_wide_hw_breakpoint(entry
->ksym_hbp
);
266 ksym_filter_entry_count
--;
267 hlist_del_rcu(&(entry
->ksym_hlist
));
271 mutex_unlock(&ksym_tracer_mutex
);
274 static ssize_t
ksym_trace_filter_write(struct file
*file
,
275 const char __user
*buffer
,
276 size_t count
, loff_t
*ppos
)
278 struct trace_ksym
*entry
;
279 struct hlist_node
*node
;
280 char *input_string
, *ksymname
= NULL
;
281 unsigned long ksym_addr
= 0;
282 int ret
, op
, changed
= 0;
284 input_string
= kzalloc(count
+ 1, GFP_KERNEL
);
288 if (copy_from_user(input_string
, buffer
, count
)) {
292 input_string
[count
] = '\0';
294 strstrip(input_string
);
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
);
315 mutex_lock(&ksym_tracer_mutex
);
318 hlist_for_each_entry(entry
, node
, &ksym_filter_head
, ksym_hlist
) {
319 if (entry
->attr
.bp_addr
== ksym_addr
) {
320 /* Check for malformed request: (6) */
321 if (entry
->attr
.bp_type
!= op
)
329 unregister_wide_hw_breakpoint(entry
->ksym_hbp
);
330 entry
->attr
.bp_type
= op
;
334 register_wide_hw_breakpoint(&entry
->attr
,
336 if (IS_ERR(entry
->ksym_hbp
))
337 ret
= PTR_ERR(entry
->ksym_hbp
);
341 /* Error or "symbol:---" case: drop it */
342 ksym_filter_entry_count
--;
343 hlist_del_rcu(&(entry
->ksym_hlist
));
348 /* Check for malformed request: (4) */
351 ret
= process_new_ksym_entry(ksymname
, op
, ksym_addr
);
354 mutex_unlock(&ksym_tracer_mutex
);
363 static const struct file_operations ksym_tracing_fops
= {
364 .open
= tracing_open_generic
,
365 .read
= ksym_trace_filter_read
,
366 .write
= ksym_trace_filter_write
,
369 static void ksym_trace_reset(struct trace_array
*tr
)
371 ksym_tracing_enabled
= 0;
372 __ksym_trace_reset();
375 static int ksym_trace_init(struct trace_array
*tr
)
379 for_each_online_cpu(cpu
)
380 tracing_reset(tr
, cpu
);
381 ksym_tracing_enabled
= 1;
382 ksym_trace_array
= tr
;
387 static void ksym_trace_print_header(struct seq_file
*m
)
390 "# TASK-PID CPU# Symbol "
397 static enum print_line_t
ksym_trace_output(struct trace_iterator
*iter
)
399 struct trace_entry
*entry
= iter
->ent
;
400 struct trace_seq
*s
= &iter
->seq
;
401 struct ksym_trace_entry
*field
;
402 char str
[KSYM_SYMBOL_LEN
];
405 if (entry
->type
!= TRACE_KSYM
)
406 return TRACE_TYPE_UNHANDLED
;
408 trace_assign_type(field
, entry
);
410 ret
= trace_seq_printf(s
, "%11s-%-5d [%03d] %pS", field
->cmd
,
411 entry
->pid
, iter
->cpu
, (char *)field
->addr
);
413 return TRACE_TYPE_PARTIAL_LINE
;
415 switch (field
->type
) {
416 case HW_BREAKPOINT_R
:
417 ret
= trace_seq_printf(s
, " R ");
419 case HW_BREAKPOINT_W
:
420 ret
= trace_seq_printf(s
, " W ");
422 case HW_BREAKPOINT_R
| HW_BREAKPOINT_W
:
423 ret
= trace_seq_printf(s
, " RW ");
426 return TRACE_TYPE_PARTIAL_LINE
;
430 return TRACE_TYPE_PARTIAL_LINE
;
432 sprint_symbol(str
, field
->ip
);
433 ret
= trace_seq_printf(s
, "%s\n", str
);
435 return TRACE_TYPE_PARTIAL_LINE
;
437 return TRACE_TYPE_HANDLED
;
440 struct tracer ksym_tracer __read_mostly
=
442 .name
= "ksym_tracer",
443 .init
= ksym_trace_init
,
444 .reset
= ksym_trace_reset
,
445 #ifdef CONFIG_FTRACE_SELFTEST
446 .selftest
= trace_selftest_startup_ksym
,
448 .print_header
= ksym_trace_print_header
,
449 .print_line
= ksym_trace_output
452 __init
static int init_ksym_trace(void)
454 struct dentry
*d_tracer
;
455 struct dentry
*entry
;
457 d_tracer
= tracing_init_dentry();
458 ksym_filter_entry_count
= 0;
460 entry
= debugfs_create_file("ksym_trace_filter", 0644, d_tracer
,
461 NULL
, &ksym_tracing_fops
);
463 pr_warning("Could not create debugfs "
464 "'ksym_trace_filter' file\n");
466 return register_tracer(&ksym_tracer
);
468 device_initcall(init_ksym_trace
);
471 #ifdef CONFIG_PROFILE_KSYM_TRACER
472 static int ksym_tracer_stat_headers(struct seq_file
*m
)
474 seq_puts(m
, " Access Type ");
475 seq_puts(m
, " Symbol Counter\n");
476 seq_puts(m
, " ----------- ");
477 seq_puts(m
, " ------ -------\n");
481 static int ksym_tracer_stat_show(struct seq_file
*m
, void *v
)
483 struct hlist_node
*stat
= v
;
484 struct trace_ksym
*entry
;
486 char fn_name
[KSYM_NAME_LEN
];
488 entry
= hlist_entry(stat
, struct trace_ksym
, ksym_hlist
);
490 access_type
= entry
->attr
.bp_type
;
492 switch (access_type
) {
493 case HW_BREAKPOINT_R
:
496 case HW_BREAKPOINT_W
:
499 case HW_BREAKPOINT_R
| HW_BREAKPOINT_W
:
506 if (lookup_symbol_name(entry
->attr
.bp_addr
, fn_name
) >= 0)
507 seq_printf(m
, " %-36s", fn_name
);
509 seq_printf(m
, " %-36s", "<NA>");
510 seq_printf(m
, " %15lu\n", entry
->counter
);
515 static void *ksym_tracer_stat_start(struct tracer_stat
*trace
)
517 return ksym_filter_head
.first
;
521 ksym_tracer_stat_next(void *v
, int idx
)
523 struct hlist_node
*stat
= v
;
528 static struct tracer_stat ksym_tracer_stats
= {
529 .name
= "ksym_tracer",
530 .stat_start
= ksym_tracer_stat_start
,
531 .stat_next
= ksym_tracer_stat_next
,
532 .stat_headers
= ksym_tracer_stat_headers
,
533 .stat_show
= ksym_tracer_stat_show
536 __init
static int ksym_tracer_stat_init(void)
540 ret
= register_stat_tracer(&ksym_tracer_stats
);
542 printk(KERN_WARNING
"Warning: could not register "
543 "ksym tracer stats\n");
549 fs_initcall(ksym_tracer_stat_init
);
550 #endif /* CONFIG_PROFILE_KSYM_TRACER */