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 unsigned long ksym_addr;
48 #ifdef CONFIG_PROFILE_KSYM_TRACER
49 unsigned long counter;
51 struct hlist_node ksym_hlist;
54 static struct trace_array *ksym_trace_array;
56 static unsigned int ksym_filter_entry_count;
57 static unsigned int ksym_tracing_enabled;
59 static HLIST_HEAD(ksym_filter_head);
61 static DEFINE_MUTEX(ksym_tracer_mutex);
63 #ifdef CONFIG_PROFILE_KSYM_TRACER
65 #define MAX_UL_INT 0xffffffff
67 void ksym_collect_stats(unsigned long hbp_hit_addr)
69 struct hlist_node *node;
70 struct trace_ksym *entry;
73 hlist_for_each_entry_rcu(entry, node, &ksym_filter_head, ksym_hlist) {
74 if ((entry->ksym_addr == hbp_hit_addr) &&
75 (entry->counter <= MAX_UL_INT)) {
82 #endif /* CONFIG_PROFILE_KSYM_TRACER */
84 void ksym_hbp_handler(struct perf_event *hbp, void *data)
86 struct ring_buffer_event *event;
87 struct ksym_trace_entry *entry;
88 struct pt_regs *regs = data;
89 struct ring_buffer *buffer;
92 if (!ksym_tracing_enabled)
95 buffer = ksym_trace_array->buffer;
99 event = trace_buffer_lock_reserve(buffer, TRACE_KSYM,
100 sizeof(*entry), 0, pc);
104 entry = ring_buffer_event_data(event);
105 entry->ip = instruction_pointer(regs);
106 entry->type = hw_breakpoint_type(hbp);
107 entry->addr = hw_breakpoint_addr(hbp);
108 strlcpy(entry->cmd, current->comm, TASK_COMM_LEN);
110 #ifdef CONFIG_PROFILE_KSYM_TRACER
111 ksym_collect_stats(hw_breakpoint_addr(hbp));
112 #endif /* CONFIG_PROFILE_KSYM_TRACER */
114 trace_buffer_unlock_commit(buffer, event, 0, pc);
117 /* Valid access types are represented as
119 * rw- : Set Read/Write Access Breakpoint
120 * -w- : Set Write Access Breakpoint
121 * --- : Clear Breakpoints
122 * --x : Set Execution Break points (Not available yet)
125 static int ksym_trace_get_access_type(char *str)
130 access |= HW_BREAKPOINT_R;
133 access |= HW_BREAKPOINT_W;
136 access |= HW_BREAKPOINT_X;
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);
195 entry->ksym_addr = addr;
196 entry->len = HW_BREAKPOINT_LEN_4;
199 entry->ksym_hbp = register_wide_hw_breakpoint(entry->ksym_addr,
200 entry->len, entry->type,
201 ksym_hbp_handler, true);
202 if (IS_ERR(entry->ksym_hbp)) {
203 entry->ksym_hbp = NULL;
204 ret = PTR_ERR(entry->ksym_hbp);
207 if (!entry->ksym_hbp) {
208 printk(KERN_INFO "ksym_tracer request failed. Try again"
213 hlist_add_head_rcu(&(entry->ksym_hlist), &ksym_filter_head);
214 ksym_filter_entry_count++;
224 static ssize_t ksym_trace_filter_read(struct file *filp, char __user *ubuf,
225 size_t count, loff_t *ppos)
227 struct trace_ksym *entry;
228 struct hlist_node *node;
233 s = kmalloc(sizeof(*s), GFP_KERNEL);
238 mutex_lock(&ksym_tracer_mutex);
240 hlist_for_each_entry(entry, node, &ksym_filter_head, ksym_hlist) {
241 ret = trace_seq_printf(s, "%pS:", (void *)entry->ksym_addr);
242 if (entry->type == HW_BREAKPOINT_W)
243 ret = trace_seq_puts(s, "-w-\n");
244 else if (entry->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 *input_string, *ksymname = NULL;
282 unsigned long ksym_addr = 0;
283 int ret, op, changed = 0;
285 input_string = kzalloc(count + 1, GFP_KERNEL);
289 if (copy_from_user(input_string, buffer, count)) {
293 input_string[count] = '\0';
295 strstrip(input_string);
298 * Clear all breakpoints if:
299 * 1: echo > ksym_trace_filter
300 * 2: echo 0 > ksym_trace_filter
301 * 3: echo "*:---" > ksym_trace_filter
303 if (!input_string[0] || !strcmp(input_string, "0") ||
304 !strcmp(input_string, "*:---")) {
305 __ksym_trace_reset();
310 ret = op = parse_ksym_trace_str(input_string, &ksymname, &ksym_addr);
316 mutex_lock(&ksym_tracer_mutex);
319 hlist_for_each_entry(entry, node, &ksym_filter_head, ksym_hlist) {
320 if (entry->ksym_addr == ksym_addr) {
321 /* Check for malformed request: (6) */
322 if (entry->type != op)
330 unregister_wide_hw_breakpoint(entry->ksym_hbp);
334 register_wide_hw_breakpoint(entry->ksym_addr,
335 entry->len, entry->type,
336 ksym_hbp_handler, true);
337 if (IS_ERR(entry->ksym_hbp))
338 entry->ksym_hbp = NULL;
339 if (!entry->ksym_hbp)
342 ksym_filter_entry_count--;
343 hlist_del_rcu(&(entry->ksym_hlist));
349 /* Check for malformed request: (4) */
352 ret = process_new_ksym_entry(ksymname, op, ksym_addr);
355 mutex_unlock(&ksym_tracer_mutex);
364 static const struct file_operations ksym_tracing_fops = {
365 .open = tracing_open_generic,
366 .read = ksym_trace_filter_read,
367 .write = ksym_trace_filter_write,
370 static void ksym_trace_reset(struct trace_array *tr)
372 ksym_tracing_enabled = 0;
373 __ksym_trace_reset();
376 static int ksym_trace_init(struct trace_array *tr)
380 for_each_online_cpu(cpu)
381 tracing_reset(tr, cpu);
382 ksym_tracing_enabled = 1;
383 ksym_trace_array = tr;
388 static void ksym_trace_print_header(struct seq_file *m)
391 "# TASK-PID CPU# Symbol "
398 static enum print_line_t ksym_trace_output(struct trace_iterator *iter)
400 struct trace_entry *entry = iter->ent;
401 struct trace_seq *s = &iter->seq;
402 struct ksym_trace_entry *field;
403 char str[KSYM_SYMBOL_LEN];
406 if (entry->type != TRACE_KSYM)
407 return TRACE_TYPE_UNHANDLED;
409 trace_assign_type(field, entry);
411 ret = trace_seq_printf(s, "%11s-%-5d [%03d] %pS", field->cmd,
412 entry->pid, iter->cpu, (char *)field->addr);
414 return TRACE_TYPE_PARTIAL_LINE;
416 switch (field->type) {
417 case HW_BREAKPOINT_W:
418 ret = trace_seq_printf(s, " W ");
420 case HW_BREAKPOINT_R | HW_BREAKPOINT_W:
421 ret = trace_seq_printf(s, " RW ");
424 return TRACE_TYPE_PARTIAL_LINE;
428 return TRACE_TYPE_PARTIAL_LINE;
430 sprint_symbol(str, field->ip);
431 ret = trace_seq_printf(s, "%s\n", str);
433 return TRACE_TYPE_PARTIAL_LINE;
435 return TRACE_TYPE_HANDLED;
438 struct tracer ksym_tracer __read_mostly =
440 .name = "ksym_tracer",
441 .init = ksym_trace_init,
442 .reset = ksym_trace_reset,
443 #ifdef CONFIG_FTRACE_SELFTEST
444 .selftest = trace_selftest_startup_ksym,
446 .print_header = ksym_trace_print_header,
447 .print_line = ksym_trace_output
450 __init static int init_ksym_trace(void)
452 struct dentry *d_tracer;
453 struct dentry *entry;
455 d_tracer = tracing_init_dentry();
456 ksym_filter_entry_count = 0;
458 entry = debugfs_create_file("ksym_trace_filter", 0644, d_tracer,
459 NULL, &ksym_tracing_fops);
461 pr_warning("Could not create debugfs "
462 "'ksym_trace_filter' file\n");
464 return register_tracer(&ksym_tracer);
466 device_initcall(init_ksym_trace);
469 #ifdef CONFIG_PROFILE_KSYM_TRACER
470 static int ksym_tracer_stat_headers(struct seq_file *m)
472 seq_puts(m, " Access Type ");
473 seq_puts(m, " Symbol Counter\n");
474 seq_puts(m, " ----------- ");
475 seq_puts(m, " ------ -------\n");
479 static int ksym_tracer_stat_show(struct seq_file *m, void *v)
481 struct hlist_node *stat = v;
482 struct trace_ksym *entry;
484 char fn_name[KSYM_NAME_LEN];
486 entry = hlist_entry(stat, struct trace_ksym, ksym_hlist);
488 access_type = entry->type;
490 switch (access_type) {
491 case HW_BREAKPOINT_W:
494 case HW_BREAKPOINT_R | HW_BREAKPOINT_W:
501 if (lookup_symbol_name(entry->ksym_addr, fn_name) >= 0)
502 seq_printf(m, " %-36s", fn_name);
504 seq_printf(m, " %-36s", "<NA>");
505 seq_printf(m, " %15lu\n", entry->counter);
510 static void *ksym_tracer_stat_start(struct tracer_stat *trace)
512 return ksym_filter_head.first;
516 ksym_tracer_stat_next(void *v, int idx)
518 struct hlist_node *stat = v;
523 static struct tracer_stat ksym_tracer_stats = {
524 .name = "ksym_tracer",
525 .stat_start = ksym_tracer_stat_start,
526 .stat_next = ksym_tracer_stat_next,
527 .stat_headers = ksym_tracer_stat_headers,
528 .stat_show = ksym_tracer_stat_show
531 __init static int ksym_tracer_stat_init(void)
535 ret = register_stat_tracer(&ksym_tracer_stats);
537 printk(KERN_WARNING "Warning: could not register "
538 "ksym tracer stats\n");
544 fs_initcall(ksym_tracer_stat_init);
545 #endif /* CONFIG_PROFILE_KSYM_TRACER */