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 /* For now, let us restrict the no. of symbols traced simultaneously to number
33 * of available hardware breakpoint registers.
35 #define KSYM_TRACER_MAX HBP_NUM
37 #define KSYM_TRACER_OP_LEN 3 /* rw- */
40 struct hw_breakpoint *ksym_hbp;
41 unsigned long ksym_addr;
42 #ifdef CONFIG_PROFILE_KSYM_TRACER
43 unsigned long counter;
45 struct hlist_node ksym_hlist;
48 static struct trace_array *ksym_trace_array;
50 static unsigned int ksym_filter_entry_count;
51 static unsigned int ksym_tracing_enabled;
53 static HLIST_HEAD(ksym_filter_head);
55 static DEFINE_MUTEX(ksym_tracer_mutex);
57 #ifdef CONFIG_PROFILE_KSYM_TRACER
59 #define MAX_UL_INT 0xffffffff
61 void ksym_collect_stats(unsigned long hbp_hit_addr)
63 struct hlist_node *node;
64 struct trace_ksym *entry;
67 hlist_for_each_entry_rcu(entry, node, &ksym_filter_head, ksym_hlist) {
68 if ((entry->ksym_addr == hbp_hit_addr) &&
69 (entry->counter <= MAX_UL_INT)) {
76 #endif /* CONFIG_PROFILE_KSYM_TRACER */
78 void ksym_hbp_handler(struct hw_breakpoint *hbp, struct pt_regs *regs)
80 struct ring_buffer_event *event;
81 struct trace_array *tr;
82 struct ksym_trace_entry *entry;
85 if (!ksym_tracing_enabled)
88 tr = ksym_trace_array;
91 event = trace_buffer_lock_reserve(tr, TRACE_KSYM,
92 sizeof(*entry), 0, pc);
96 entry = ring_buffer_event_data(event);
97 entry->ip = instruction_pointer(regs);
98 entry->type = hbp->info.type;
99 strlcpy(entry->ksym_name, hbp->info.name, KSYM_SYMBOL_LEN);
100 strlcpy(entry->cmd, current->comm, TASK_COMM_LEN);
102 #ifdef CONFIG_PROFILE_KSYM_TRACER
103 ksym_collect_stats(hbp->info.address);
104 #endif /* CONFIG_PROFILE_KSYM_TRACER */
106 trace_buffer_unlock_commit(tr, event, 0, pc);
109 /* Valid access types are represented as
111 * rw- : Set Read/Write Access Breakpoint
112 * -w- : Set Write Access Breakpoint
113 * --- : Clear Breakpoints
114 * --x : Set Execution Break points (Not available yet)
117 static int ksym_trace_get_access_type(char *str)
123 else if (str[0] != '-')
128 else if (str[1] != '-')
136 access = HW_BREAKPOINT_RW;
139 access = HW_BREAKPOINT_WRITE;
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 strstrip(input_string);
165 *ksymname = strsep(&input_string, ":");
166 *addr = kallsyms_lookup_name(*ksymname);
168 /* Check for malformed request: (2), (1) and (5) */
169 if ((!input_string) ||
170 (strlen(input_string) != KSYM_TRACER_OP_LEN) ||
174 ret = ksym_trace_get_access_type(input_string);
179 int process_new_ksym_entry(char *ksymname, int op, unsigned long addr)
181 struct trace_ksym *entry;
184 if (ksym_filter_entry_count >= KSYM_TRACER_MAX) {
185 printk(KERN_ERR "ksym_tracer: Maximum limit:(%d) reached. No"
186 " new requests for tracing can be accepted now.\n",
191 entry = kzalloc(sizeof(struct trace_ksym), GFP_KERNEL);
195 entry->ksym_hbp = kzalloc(sizeof(struct hw_breakpoint), GFP_KERNEL);
196 if (!entry->ksym_hbp)
199 entry->ksym_hbp->info.name = kstrdup(ksymname, GFP_KERNEL);
200 if (!entry->ksym_hbp->info.name)
203 entry->ksym_hbp->info.type = op;
204 entry->ksym_addr = entry->ksym_hbp->info.address = addr;
206 entry->ksym_hbp->info.len = HW_BREAKPOINT_LEN_4;
208 entry->ksym_hbp->triggered = (void *)ksym_hbp_handler;
210 ret = register_kernel_hw_breakpoint(entry->ksym_hbp);
212 printk(KERN_INFO "ksym_tracer request failed. Try again"
217 hlist_add_head_rcu(&(entry->ksym_hlist), &ksym_filter_head);
218 ksym_filter_entry_count++;
222 kfree(entry->ksym_hbp->info.name);
223 kfree(entry->ksym_hbp);
228 static ssize_t ksym_trace_filter_read(struct file *filp, char __user *ubuf,
229 size_t count, loff_t *ppos)
231 struct trace_ksym *entry;
232 struct hlist_node *node;
237 s = kmalloc(sizeof(*s), GFP_KERNEL);
242 mutex_lock(&ksym_tracer_mutex);
244 hlist_for_each_entry(entry, node, &ksym_filter_head, ksym_hlist) {
245 ret = trace_seq_printf(s, "%s:", entry->ksym_hbp->info.name);
246 if (entry->ksym_hbp->info.type == HW_BREAKPOINT_WRITE)
247 ret = trace_seq_puts(s, "-w-\n");
248 else if (entry->ksym_hbp->info.type == HW_BREAKPOINT_RW)
249 ret = trace_seq_puts(s, "rw-\n");
253 cnt = simple_read_from_buffer(ubuf, count, ppos, s->buffer, s->len);
255 mutex_unlock(&ksym_tracer_mutex);
262 static ssize_t ksym_trace_filter_write(struct file *file,
263 const char __user *buffer,
264 size_t count, loff_t *ppos)
266 struct trace_ksym *entry;
267 struct hlist_node *node;
268 char *input_string, *ksymname = NULL;
269 unsigned long ksym_addr = 0;
270 int ret, op, changed = 0;
272 input_string = kzalloc(count + 1, GFP_KERNEL);
276 if (copy_from_user(input_string, buffer, count)) {
280 input_string[count] = '\0';
282 ret = op = parse_ksym_trace_str(input_string, &ksymname, &ksym_addr);
288 mutex_lock(&ksym_tracer_mutex);
291 hlist_for_each_entry(entry, node, &ksym_filter_head, ksym_hlist) {
292 if (entry->ksym_addr == ksym_addr) {
293 /* Check for malformed request: (6) */
294 if (entry->ksym_hbp->info.type != op)
302 unregister_kernel_hw_breakpoint(entry->ksym_hbp);
303 entry->ksym_hbp->info.type = op;
305 ret = register_kernel_hw_breakpoint(entry->ksym_hbp);
309 ksym_filter_entry_count--;
310 hlist_del_rcu(&(entry->ksym_hlist));
312 kfree(entry->ksym_hbp->info.name);
313 kfree(entry->ksym_hbp);
317 /* Check for malformed request: (4) */
320 ret = process_new_ksym_entry(ksymname, op, ksym_addr);
323 mutex_unlock(&ksym_tracer_mutex);
332 static const struct file_operations ksym_tracing_fops = {
333 .open = tracing_open_generic,
334 .read = ksym_trace_filter_read,
335 .write = ksym_trace_filter_write,
338 static void ksym_trace_reset(struct trace_array *tr)
340 struct trace_ksym *entry;
341 struct hlist_node *node, *node1;
343 ksym_tracing_enabled = 0;
345 mutex_lock(&ksym_tracer_mutex);
346 hlist_for_each_entry_safe(entry, node, node1, &ksym_filter_head,
348 unregister_kernel_hw_breakpoint(entry->ksym_hbp);
349 ksym_filter_entry_count--;
350 hlist_del_rcu(&(entry->ksym_hlist));
352 kfree(entry->ksym_hbp->info.name);
353 kfree(entry->ksym_hbp);
356 mutex_unlock(&ksym_tracer_mutex);
359 static int ksym_trace_init(struct trace_array *tr)
363 for_each_online_cpu(cpu)
364 tracing_reset(tr, cpu);
365 ksym_tracing_enabled = 1;
366 ksym_trace_array = tr;
371 static void ksym_trace_print_header(struct seq_file *m)
374 "# TASK-PID CPU# Symbol "
381 static enum print_line_t ksym_trace_output(struct trace_iterator *iter)
383 struct trace_entry *entry = iter->ent;
384 struct trace_seq *s = &iter->seq;
385 struct ksym_trace_entry *field;
386 char str[KSYM_SYMBOL_LEN];
389 if (entry->type != TRACE_KSYM)
390 return TRACE_TYPE_UNHANDLED;
392 trace_assign_type(field, entry);
394 ret = trace_seq_printf(s, "%11s-%-5d [%03d] %-30s ", field->cmd,
395 entry->pid, iter->cpu, field->ksym_name);
397 return TRACE_TYPE_PARTIAL_LINE;
399 switch (field->type) {
400 case HW_BREAKPOINT_WRITE:
401 ret = trace_seq_printf(s, " W ");
403 case HW_BREAKPOINT_RW:
404 ret = trace_seq_printf(s, " RW ");
407 return TRACE_TYPE_PARTIAL_LINE;
411 return TRACE_TYPE_PARTIAL_LINE;
413 sprint_symbol(str, field->ip);
414 ret = trace_seq_printf(s, "%s\n", str);
416 return TRACE_TYPE_PARTIAL_LINE;
418 return TRACE_TYPE_HANDLED;
421 struct tracer ksym_tracer __read_mostly =
423 .name = "ksym_tracer",
424 .init = ksym_trace_init,
425 .reset = ksym_trace_reset,
426 #ifdef CONFIG_FTRACE_SELFTEST
427 .selftest = trace_selftest_startup_ksym,
429 .print_header = ksym_trace_print_header,
430 .print_line = ksym_trace_output
433 __init static int init_ksym_trace(void)
435 struct dentry *d_tracer;
436 struct dentry *entry;
438 d_tracer = tracing_init_dentry();
439 ksym_filter_entry_count = 0;
441 entry = debugfs_create_file("ksym_trace_filter", 0644, d_tracer,
442 NULL, &ksym_tracing_fops);
444 pr_warning("Could not create debugfs "
445 "'ksym_trace_filter' file\n");
447 return register_tracer(&ksym_tracer);
449 device_initcall(init_ksym_trace);
452 #ifdef CONFIG_PROFILE_KSYM_TRACER
453 static int ksym_tracer_stat_headers(struct seq_file *m)
455 seq_puts(m, " Access Type ");
456 seq_puts(m, " Symbol Counter\n");
457 seq_puts(m, " ----------- ");
458 seq_puts(m, " ------ -------\n");
462 static int ksym_tracer_stat_show(struct seq_file *m, void *v)
464 struct hlist_node *stat = v;
465 struct trace_ksym *entry;
467 char fn_name[KSYM_NAME_LEN];
469 entry = hlist_entry(stat, struct trace_ksym, ksym_hlist);
472 access_type = entry->ksym_hbp->info.type;
474 switch (access_type) {
475 case HW_BREAKPOINT_WRITE:
478 case HW_BREAKPOINT_RW:
485 if (lookup_symbol_name(entry->ksym_addr, fn_name) >= 0)
486 seq_printf(m, " %-36s", fn_name);
488 seq_printf(m, " %-36s", "<NA>");
489 seq_printf(m, " %15lu\n", entry->counter);
494 static void *ksym_tracer_stat_start(struct tracer_stat *trace)
496 return ksym_filter_head.first;
500 ksym_tracer_stat_next(void *v, int idx)
502 struct hlist_node *stat = v;
507 static struct tracer_stat ksym_tracer_stats = {
508 .name = "ksym_tracer",
509 .stat_start = ksym_tracer_stat_start,
510 .stat_next = ksym_tracer_stat_next,
511 .stat_headers = ksym_tracer_stat_headers,
512 .stat_show = ksym_tracer_stat_show
515 __init static int ksym_tracer_stat_init(void)
519 ret = register_stat_tracer(&ksym_tracer_stats);
521 printk(KERN_WARNING "Warning: could not register "
522 "ksym tracer stats\n");
528 fs_initcall(ksym_tracer_stat_init);
529 #endif /* CONFIG_PROFILE_KSYM_TRACER */