[linux-2.6-block.git] / kernel / trace / trace_ksym.c

/*
 * trace_ksym.c - Kernel Symbol Tracer
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * Copyright (C) IBM Corporation, 2009
 */

#include <linux/kallsyms.h>
#include <linux/uaccess.h>
#include <linux/debugfs.h>
#include <linux/ftrace.h>
#include <linux/module.h>
#include <linux/fs.h>

#include "trace_output.h"
#include "trace_stat.h"
#include "trace.h"

#include <linux/hw_breakpoint.h>
#include <asm/hw_breakpoint.h>

/*
 * For now, let us restrict the no. of symbols traced simultaneously to number
 * of available hardware breakpoint registers.
 */
#define KSYM_TRACER_MAX HBP_NUM

#define KSYM_TRACER_OP_LEN 3 /* rw- */

struct trace_ksym {
	struct perf_event	**ksym_hbp;
	unsigned long		ksym_addr;
	int			type;
	int			len;
#ifdef CONFIG_PROFILE_KSYM_TRACER
	unsigned long		counter;
#endif
	struct hlist_node	ksym_hlist;
};

static struct trace_array *ksym_trace_array;

static unsigned int ksym_filter_entry_count;
static unsigned int ksym_tracing_enabled;

static HLIST_HEAD(ksym_filter_head);

static DEFINE_MUTEX(ksym_tracer_mutex);

#ifdef CONFIG_PROFILE_KSYM_TRACER

#define MAX_UL_INT 0xffffffff

void ksym_collect_stats(unsigned long hbp_hit_addr)
{
	struct hlist_node *node;
	struct trace_ksym *entry;

	rcu_read_lock();
	hlist_for_each_entry_rcu(entry, node, &ksym_filter_head, ksym_hlist) {
		if ((entry->ksym_addr == hbp_hit_addr) &&
		    (entry->counter <= MAX_UL_INT)) {
			entry->counter++;
			break;
		}
	}
	rcu_read_unlock();
}
#endif /* CONFIG_PROFILE_KSYM_TRACER */

void ksym_hbp_handler(struct perf_event *hbp, void *data)
{
	struct ring_buffer_event *event;
	struct ksym_trace_entry *entry;
	struct pt_regs *regs = data;
	struct ring_buffer *buffer;
	int pc;

	if (!ksym_tracing_enabled)
		return;

	buffer = ksym_trace_array->buffer;

	pc = preempt_count();

	event = trace_buffer_lock_reserve(buffer, TRACE_KSYM,
							sizeof(*entry), 0, pc);
	if (!event)
		return;

	entry		= ring_buffer_event_data(event);
	entry->ip	= instruction_pointer(regs);
	entry->type	= hw_breakpoint_type(hbp);
	entry->addr	= hw_breakpoint_addr(hbp);
	strlcpy(entry->cmd, current->comm, TASK_COMM_LEN);

#ifdef CONFIG_PROFILE_KSYM_TRACER
	ksym_collect_stats(hw_breakpoint_addr(hbp));
#endif /* CONFIG_PROFILE_KSYM_TRACER */

	trace_buffer_unlock_commit(buffer, event, 0, pc);
}

/* Valid access types are represented as
 *
 * rw- : Set Read/Write Access Breakpoint
 * -w- : Set Write Access Breakpoint
 * --- : Clear Breakpoints
 * --x : Set Execution Break points (Not available yet)
 *
 */
static int ksym_trace_get_access_type(char *str)
{
	int access = 0;

	if (str[0] == 'r')
		access |= HW_BREAKPOINT_R;

	if (str[1] == 'w')
		access |= HW_BREAKPOINT_W;

	if (str[2] == 'x')
		access |= HW_BREAKPOINT_X;

	switch (access) {
	case HW_BREAKPOINT_W:
	case HW_BREAKPOINT_W | HW_BREAKPOINT_R:
		return access;
	default:
		return -EINVAL;
	}
}

/*
 * There can be several possible malformed requests and we attempt to capture
 * all of them. We enumerate some of the rules
 * 1. We will not allow kernel symbols with ':' since it is used as a delimiter.
 *    i.e. multiple ':' symbols disallowed. Possible uses are of the form
 *    <module>:<ksym_name>:<op>.
 * 2. No delimiter symbol ':' in the input string
 * 3. Spurious operator symbols or symbols not in their respective positions
 * 4. <ksym_name>:--- i.e. clear breakpoint request when ksym_name not in file
 * 5. Kernel symbol not a part of /proc/kallsyms
 * 6. Duplicate requests
 */
static int parse_ksym_trace_str(char *input_string, char **ksymname,
							unsigned long *addr)
{
	int ret;

	*ksymname = strsep(&input_string, ":");
	*addr = kallsyms_lookup_name(*ksymname);

	/* Check for malformed request: (2), (1) and (5) */
	if ((!input_string) ||
	    (strlen(input_string) != KSYM_TRACER_OP_LEN) ||
	    (*addr == 0))
		return -EINVAL;;

	ret = ksym_trace_get_access_type(input_string);

	return ret;
}

int process_new_ksym_entry(char *ksymname, int op, unsigned long addr)
{
	struct trace_ksym *entry;
	int ret = -ENOMEM;

	if (ksym_filter_entry_count >= KSYM_TRACER_MAX) {
		printk(KERN_ERR "ksym_tracer: Maximum limit:(%d) reached. No"
		" new requests for tracing can be accepted now.\n",
			KSYM_TRACER_MAX);
		return -ENOSPC;
	}

	entry = kzalloc(sizeof(struct trace_ksym), GFP_KERNEL);
	if (!entry)
		return -ENOMEM;

	entry->type = op;
	entry->ksym_addr = addr;
	entry->len = HW_BREAKPOINT_LEN_4;

	ret = -EAGAIN;
	entry->ksym_hbp = register_wide_hw_breakpoint(entry->ksym_addr,
					entry->len, entry->type,
					ksym_hbp_handler, true);
	if (IS_ERR(entry->ksym_hbp)) {
		entry->ksym_hbp = NULL;
		ret = PTR_ERR(entry->ksym_hbp);
	}

	if (!entry->ksym_hbp) {
		printk(KERN_INFO "ksym_tracer request failed. Try again"
					" later!!\n");
		goto err;
	}

	hlist_add_head_rcu(&(entry->ksym_hlist), &ksym_filter_head);
	ksym_filter_entry_count++;

	return 0;

err:
	kfree(entry);

	return ret;
}

static ssize_t ksym_trace_filter_read(struct file *filp, char __user *ubuf,
						size_t count, loff_t *ppos)
{
	struct trace_ksym *entry;
	struct hlist_node *node;
	struct trace_seq *s;
	ssize_t cnt = 0;
	int ret;

	s = kmalloc(sizeof(*s), GFP_KERNEL);
	if (!s)
		return -ENOMEM;
	trace_seq_init(s);

	mutex_lock(&ksym_tracer_mutex);

	hlist_for_each_entry(entry, node, &ksym_filter_head, ksym_hlist) {
		ret = trace_seq_printf(s, "%pS:", (void *)entry->ksym_addr);
		if (entry->type == HW_BREAKPOINT_W)
			ret = trace_seq_puts(s, "-w-\n");
		else if (entry->type == (HW_BREAKPOINT_W | HW_BREAKPOINT_R))
			ret = trace_seq_puts(s, "rw-\n");
		WARN_ON_ONCE(!ret);
	}

	cnt = simple_read_from_buffer(ubuf, count, ppos, s->buffer, s->len);

	mutex_unlock(&ksym_tracer_mutex);

	kfree(s);

	return cnt;
}

static void __ksym_trace_reset(void)
{
	struct trace_ksym *entry;
	struct hlist_node *node, *node1;

	mutex_lock(&ksym_tracer_mutex);
	hlist_for_each_entry_safe(entry, node, node1, &ksym_filter_head,
								ksym_hlist) {
		unregister_wide_hw_breakpoint(entry->ksym_hbp);
		ksym_filter_entry_count--;
		hlist_del_rcu(&(entry->ksym_hlist));
		synchronize_rcu();
		kfree(entry);
	}
	mutex_unlock(&ksym_tracer_mutex);
}

static ssize_t ksym_trace_filter_write(struct file *file,
					const char __user *buffer,
						size_t count, loff_t *ppos)
{
	struct trace_ksym *entry;
	struct hlist_node *node;
	char *input_string, *ksymname = NULL;
	unsigned long ksym_addr = 0;
	int ret, op, changed = 0;

	input_string = kzalloc(count + 1, GFP_KERNEL);
	if (!input_string)
		return -ENOMEM;

	if (copy_from_user(input_string, buffer, count)) {
		kfree(input_string);
		return -EFAULT;
	}
	input_string[count] = '\0';

	strstrip(input_string);

	/*
	 * Clear all breakpoints if:
	 * 1: echo > ksym_trace_filter
	 * 2: echo 0 > ksym_trace_filter
	 * 3: echo "*:---" > ksym_trace_filter
	 */
	if (!input_string[0] || !strcmp(input_string, "0") ||
	    !strcmp(input_string, "*:---")) {
		__ksym_trace_reset();
		kfree(input_string);
		return count;
	}

	ret = op = parse_ksym_trace_str(input_string, &ksymname, &ksym_addr);
	if (ret < 0) {
		kfree(input_string);
		return ret;
	}

	mutex_lock(&ksym_tracer_mutex);

	ret = -EINVAL;
	hlist_for_each_entry(entry, node, &ksym_filter_head, ksym_hlist) {
		if (entry->ksym_addr == ksym_addr) {
			/* Check for malformed request: (6) */
			if (entry->type != op)
				changed = 1;
			else
				goto out;
			break;
		}
	}
	if (changed) {
		unregister_wide_hw_breakpoint(entry->ksym_hbp);
		entry->type = op;
		if (op > 0) {
			entry->ksym_hbp =
				register_wide_hw_breakpoint(entry->ksym_addr,
					entry->len, entry->type,
					ksym_hbp_handler, true);
			if (IS_ERR(entry->ksym_hbp))
				entry->ksym_hbp = NULL;
			if (!entry->ksym_hbp)
				goto out;
		}
		ksym_filter_entry_count--;
		hlist_del_rcu(&(entry->ksym_hlist));
		synchronize_rcu();
		kfree(entry);
		ret = 0;
		goto out;
	} else {
		/* Check for malformed request: (4) */
		if (op == 0)
			goto out;
		ret = process_new_ksym_entry(ksymname, op, ksym_addr);
	}
out:
	mutex_unlock(&ksym_tracer_mutex);

	kfree(input_string);

	if (!ret)
		ret = count;
	return ret;
}

static const struct file_operations ksym_tracing_fops = {
	.open		= tracing_open_generic,
	.read		= ksym_trace_filter_read,
	.write		= ksym_trace_filter_write,
};

static void ksym_trace_reset(struct trace_array *tr)
{
	ksym_tracing_enabled = 0;
	__ksym_trace_reset();
}

static int ksym_trace_init(struct trace_array *tr)
{
	int cpu, ret = 0;

	for_each_online_cpu(cpu)
		tracing_reset(tr, cpu);
	ksym_tracing_enabled = 1;
	ksym_trace_array = tr;

	return ret;
}

static void ksym_trace_print_header(struct seq_file *m)
{
	seq_puts(m,
		 "#       TASK-PID   CPU#      Symbol                    "
		 "Type    Function\n");
	seq_puts(m,
		 "#          |        |          |                       "
		 " |         |\n");
}

static enum print_line_t ksym_trace_output(struct trace_iterator *iter)
{
	struct trace_entry *entry = iter->ent;
	struct trace_seq *s = &iter->seq;
	struct ksym_trace_entry *field;
	char str[KSYM_SYMBOL_LEN];
	int ret;

	if (entry->type != TRACE_KSYM)
		return TRACE_TYPE_UNHANDLED;

	trace_assign_type(field, entry);

	ret = trace_seq_printf(s, "%11s-%-5d [%03d] %pS", field->cmd,
				entry->pid, iter->cpu, (char *)field->addr);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	switch (field->type) {
	case HW_BREAKPOINT_W:
		ret = trace_seq_printf(s, " W  ");
		break;
	case HW_BREAKPOINT_R | HW_BREAKPOINT_W:
		ret = trace_seq_printf(s, " RW ");
		break;
	default:
		return TRACE_TYPE_PARTIAL_LINE;
	}

	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	sprint_symbol(str, field->ip);
	ret = trace_seq_printf(s, "%s\n", str);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}

struct tracer ksym_tracer __read_mostly =
{
	.name		= "ksym_tracer",
	.init		= ksym_trace_init,
	.reset		= ksym_trace_reset,
#ifdef CONFIG_FTRACE_SELFTEST
	.selftest	= trace_selftest_startup_ksym,
#endif
	.print_header   = ksym_trace_print_header,
	.print_line	= ksym_trace_output
};

__init static int init_ksym_trace(void)
{
	struct dentry *d_tracer;
	struct dentry *entry;

	d_tracer = tracing_init_dentry();
	ksym_filter_entry_count = 0;

	entry = debugfs_create_file("ksym_trace_filter", 0644, d_tracer,
				    NULL, &ksym_tracing_fops);
	if (!entry)
		pr_warning("Could not create debugfs "
			   "'ksym_trace_filter' file\n");

	return register_tracer(&ksym_tracer);
}
device_initcall(init_ksym_trace);


#ifdef CONFIG_PROFILE_KSYM_TRACER
static int ksym_tracer_stat_headers(struct seq_file *m)
{
	seq_puts(m, "  Access Type ");
	seq_puts(m, "  Symbol                                       Counter\n");
	seq_puts(m, "  ----------- ");
	seq_puts(m, "  ------                                       -------\n");
	return 0;
}

static int ksym_tracer_stat_show(struct seq_file *m, void *v)
{
	struct hlist_node *stat = v;
	struct trace_ksym *entry;
	int access_type = 0;
	char fn_name[KSYM_NAME_LEN];

	entry = hlist_entry(stat, struct trace_ksym, ksym_hlist);

	access_type = entry->type;

	switch (access_type) {
	case HW_BREAKPOINT_W:
		seq_puts(m, "  W           ");
		break;
	case HW_BREAKPOINT_R | HW_BREAKPOINT_W:
		seq_puts(m, "  RW          ");
		break;
	default:
		seq_puts(m, "  NA          ");
	}

	if (lookup_symbol_name(entry->ksym_addr, fn_name) >= 0)
		seq_printf(m, "  %-36s", fn_name);
	else
		seq_printf(m, "  %-36s", "<NA>");
	seq_printf(m, " %15lu\n", entry->counter);

	return 0;
}

static void *ksym_tracer_stat_start(struct tracer_stat *trace)
{
	return ksym_filter_head.first;
}

static void *
ksym_tracer_stat_next(void *v, int idx)
{
	struct hlist_node *stat = v;

	return stat->next;
}

static struct tracer_stat ksym_tracer_stats = {
	.name = "ksym_tracer",
	.stat_start = ksym_tracer_stat_start,
	.stat_next = ksym_tracer_stat_next,
	.stat_headers = ksym_tracer_stat_headers,
	.stat_show = ksym_tracer_stat_show
};

__init static int ksym_tracer_stat_init(void)
{
	int ret;

	ret = register_stat_tracer(&ksym_tracer_stats);
	if (ret) {
		printk(KERN_WARNING "Warning: could not register "
				    "ksym tracer stats\n");
		return 1;
	}

	return 0;
}
fs_initcall(ksym_tracer_stat_init);
#endif /* CONFIG_PROFILE_KSYM_TRACER */
Commit	Line	Data
0722db01 P	1	/*
	2	* trace_ksym.c - Kernel Symbol Tracer
	3	*
	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.
	8	*
	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.
	13	*
	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.
	17	*
	18	* Copyright (C) IBM Corporation, 2009
	19	*/
	20
	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>
	26	#include <linux/fs.h>
	27
	28	#include "trace_output.h"
	29	#include "trace_stat.h"
	30	#include "trace.h"
	31
24f1e32c FW	32	#include <linux/hw_breakpoint.h>
	33	#include <asm/hw_breakpoint.h>
	34
	35	/*
	36	* For now, let us restrict the no. of symbols traced simultaneously to number
0722db01 P	37	* of available hardware breakpoint registers.
	38	*/
	39	#define KSYM_TRACER_MAX HBP_NUM
	40
	41	#define KSYM_TRACER_OP_LEN 3 /* rw- */
0722db01	42
db59504d	43	struct trace_ksym {
24f1e32c	44	struct perf_event **ksym_hbp;
db59504d	45	unsigned long ksym_addr;
24f1e32c FW	46	int type;
24f1e32c FW	47	int len;
db59504d LZ	48	#ifdef CONFIG_PROFILE_KSYM_TRACER
	49	unsigned long counter;
	50	#endif
	51	struct hlist_node ksym_hlist;
	52	};
	53
0722db01 P	54	static struct trace_array *ksym_trace_array;
	55
	56	static unsigned int ksym_filter_entry_count;
	57	static unsigned int ksym_tracing_enabled;
	58
	59	static HLIST_HEAD(ksym_filter_head);
	60
73874005 FW	61	static DEFINE_MUTEX(ksym_tracer_mutex);
73874005 FW	62
0722db01 P	63	#ifdef CONFIG_PROFILE_KSYM_TRACER
	64
	65	#define MAX_UL_INT 0xffffffff
	66
0722db01 P	67	void ksym_collect_stats(unsigned long hbp_hit_addr)
	68	{
	69	struct hlist_node *node;
	70	struct trace_ksym *entry;
	71
	72	rcu_read_lock();
	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)) {
	76	entry->counter++;
	77	break;
	78	}
	79	}
	80	rcu_read_unlock();
	81	}
	82	#endif /* CONFIG_PROFILE_KSYM_TRACER */
	83
24f1e32c	84	void ksym_hbp_handler(struct perf_event hbp, void data)
0722db01 P	85	{
0722db01 P	86	struct ring_buffer_event *event;
db59504d	87	struct ksym_trace_entry *entry;
24f1e32c	88	struct pt_regs *regs = data;
d6a65dff	89	struct ring_buffer *buffer;
0722db01 P	90	int pc;
	91
	92	if (!ksym_tracing_enabled)
	93	return;
	94
d6a65dff FW	95	buffer = ksym_trace_array->buffer;
d6a65dff FW	96
0722db01 P	97	pc = preempt_count();
0722db01 P	98
d6a65dff	99	event = trace_buffer_lock_reserve(buffer, TRACE_KSYM,
0722db01 P	100	sizeof(*entry), 0, pc);
	101	if (!event)
	102	return;
	103
db59504d LZ	104	entry = ring_buffer_event_data(event);
db59504d LZ	105	entry->ip = instruction_pointer(regs);
24f1e32c FW	106	entry->type = hw_breakpoint_type(hbp);
24f1e32c FW	107	entry->addr = hw_breakpoint_addr(hbp);
db59504d LZ	108	strlcpy(entry->cmd, current->comm, TASK_COMM_LEN);
db59504d LZ	109
0722db01	110	#ifdef CONFIG_PROFILE_KSYM_TRACER
24f1e32c	111	ksym_collect_stats(hw_breakpoint_addr(hbp));
0722db01 P	112	#endif /* CONFIG_PROFILE_KSYM_TRACER */
0722db01 P	113
d6a65dff	114	trace_buffer_unlock_commit(buffer, event, 0, pc);
0722db01 P	115	}
	116
	117	/* Valid access types are represented as
	118	*
	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)
	123	*
	124	*/
f088e547	125	static int ksym_trace_get_access_type(char *str)
0722db01	126	{
f088e547	127	int access = 0;
0722db01	128
f088e547	129	if (str[0] == 'r')
24f1e32c	130	access \|= HW_BREAKPOINT_R;
f088e547 LZ	131
f088e547 LZ	132	if (str[1] == 'w')
24f1e32c	133	access \|= HW_BREAKPOINT_W;
f088e547	134
24f1e32c FW	135	if (str[2] == 'x')
24f1e32c FW	136	access \|= HW_BREAKPOINT_X;
0722db01 P	137
0722db01 P	138	switch (access) {
24f1e32c FW	139	case HW_BREAKPOINT_W:
	140	case HW_BREAKPOINT_W \| HW_BREAKPOINT_R:
	141	return access;
	142	default:
	143	return -EINVAL;
0722db01	144	}
0722db01 P	145	}
	146
	147	/*
	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
	158	*/
	159	static int parse_ksym_trace_str(char input_string, char *ksymname,
	160	unsigned long *addr)
	161	{
0722db01 P	162	int ret;
0722db01 P	163
92cf9f8f	164	*ksymname = strsep(&input_string, ":");
0722db01 P	165	addr = kallsyms_lookup_name(ksymname);
	166
	167	/* Check for malformed request: (2), (1) and (5) */
	168	if ((!input_string) \|\|
92cf9f8f LZ	169	(strlen(input_string) != KSYM_TRACER_OP_LEN) \|\|
	170	(*addr == 0))
	171	return -EINVAL;;
	172
0722db01 P	173	ret = ksym_trace_get_access_type(input_string);
0722db01 P	174
0722db01 P	175	return ret;
	176	}
	177
	178	int process_new_ksym_entry(char *ksymname, int op, unsigned long addr)
	179	{
	180	struct trace_ksym *entry;
558df6c8	181	int ret = -ENOMEM;
0722db01 P	182
	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",
	186	KSYM_TRACER_MAX);
	187	return -ENOSPC;
	188	}
	189
	190	entry = kzalloc(sizeof(struct trace_ksym), GFP_KERNEL);
	191	if (!entry)
	192	return -ENOMEM;
	193
24f1e32c FW	194	entry->type = op;
	195	entry->ksym_addr = addr;
	196	entry->len = HW_BREAKPOINT_LEN_4;
	197
	198	ret = -EAGAIN;
	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);
	205	}
0722db01	206
24f1e32c	207	if (!entry->ksym_hbp) {
0722db01 P	208	printk(KERN_INFO "ksym_tracer request failed. Try again"
0722db01 P	209	" later!!\n");
558df6c8	210	goto err;
0722db01	211	}
24f1e32c	212
0722db01 P	213	hlist_add_head_rcu(&(entry->ksym_hlist), &ksym_filter_head);
0722db01 P	214	ksym_filter_entry_count++;
24f1e32c	215
0722db01	216	return 0;
24f1e32c	217
558df6c8	218	err:
558df6c8	219	kfree(entry);
24f1e32c	220
558df6c8	221	return ret;
0722db01 P	222	}
	223
	224	static ssize_t ksym_trace_filter_read(struct file filp, char __user ubuf,
	225	size_t count, loff_t *ppos)
	226	{
	227	struct trace_ksym *entry;
	228	struct hlist_node *node;
be9742e6 LZ	229	struct trace_seq *s;
	230	ssize_t cnt = 0;
	231	int ret;
	232
	233	s = kmalloc(sizeof(*s), GFP_KERNEL);
	234	if (!s)
	235	return -ENOMEM;
	236	trace_seq_init(s);
0722db01 P	237
	238	mutex_lock(&ksym_tracer_mutex);
	239
	240	hlist_for_each_entry(entry, node, &ksym_filter_head, ksym_hlist) {
24f1e32c FW	241	ret = trace_seq_printf(s, "%pS:", (void *)entry->ksym_addr);
24f1e32c FW	242	if (entry->type == HW_BREAKPOINT_W)
be9742e6	243	ret = trace_seq_puts(s, "-w-\n");
24f1e32c	244	else if (entry->type == (HW_BREAKPOINT_W \| HW_BREAKPOINT_R))
be9742e6 LZ	245	ret = trace_seq_puts(s, "rw-\n");
be9742e6 LZ	246	WARN_ON_ONCE(!ret);
0722db01	247	}
be9742e6 LZ	248
	249	cnt = simple_read_from_buffer(ubuf, count, ppos, s->buffer, s->len);
	250
0722db01 P	251	mutex_unlock(&ksym_tracer_mutex);
0722db01 P	252
be9742e6 LZ	253	kfree(s);
	254
	255	return cnt;
0722db01 P	256	}
0722db01 P	257
75e33751 XG	258	static void __ksym_trace_reset(void)
	259	{
	260	struct trace_ksym *entry;
	261	struct hlist_node node, node1;
	262
	263	mutex_lock(&ksym_tracer_mutex);
	264	hlist_for_each_entry_safe(entry, node, node1, &ksym_filter_head,
	265	ksym_hlist) {
24f1e32c	266	unregister_wide_hw_breakpoint(entry->ksym_hbp);
75e33751 XG	267	ksym_filter_entry_count--;
	268	hlist_del_rcu(&(entry->ksym_hlist));
	269	synchronize_rcu();
75e33751 XG	270	kfree(entry);
	271	}
	272	mutex_unlock(&ksym_tracer_mutex);
	273	}
	274
0722db01 P	275	static ssize_t ksym_trace_filter_write(struct file *file,
	276	const char __user *buffer,
	277	size_t count, loff_t *ppos)
	278	{
	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;
	284
011ed568	285	input_string = kzalloc(count + 1, GFP_KERNEL);
0722db01 P	286	if (!input_string)
	287	return -ENOMEM;
	288
	289	if (copy_from_user(input_string, buffer, count)) {
	290	kfree(input_string);
	291	return -EFAULT;
	292	}
011ed568	293	input_string[count] = '\0';
0722db01	294
75e33751 XG	295	strstrip(input_string);
	296
	297	/*
	298	* Clear all breakpoints if:
	299	* 1: echo > ksym_trace_filter
	300	* 2: echo 0 > ksym_trace_filter
	301	* 3: echo "*:---" > ksym_trace_filter
	302	*/
	303	if (!input_string[0] \|\| !strcmp(input_string, "0") \|\|
	304	!strcmp(input_string, "*:---")) {
	305	__ksym_trace_reset();
	306	kfree(input_string);
	307	return count;
	308	}
	309
0722db01 P	310	ret = op = parse_ksym_trace_str(input_string, &ksymname, &ksym_addr);
	311	if (ret < 0) {
	312	kfree(input_string);
	313	return ret;
	314	}
	315
	316	mutex_lock(&ksym_tracer_mutex);
	317
	318	ret = -EINVAL;
	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) */
24f1e32c	322	if (entry->type != op)
0722db01 P	323	changed = 1;
0722db01 P	324	else
558df6c8	325	goto out;
0722db01 P	326	break;
	327	}
	328	}
	329	if (changed) {
24f1e32c FW	330	unregister_wide_hw_breakpoint(entry->ksym_hbp);
24f1e32c FW	331	entry->type = op;
0722db01	332	if (op > 0) {
24f1e32c FW	333	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)
558df6c8 LZ	340	goto out;
558df6c8 LZ	341	}
0722db01 P	342	ksym_filter_entry_count--;
	343	hlist_del_rcu(&(entry->ksym_hlist));
	344	synchronize_rcu();
0722db01	345	kfree(entry);
8e068542	346	ret = 0;
558df6c8	347	goto out;
0722db01 P	348	} else {
	349	/* Check for malformed request: (4) */
	350	if (op == 0)
558df6c8	351	goto out;
0722db01	352	ret = process_new_ksym_entry(ksymname, op, ksym_addr);
0722db01	353	}
558df6c8 LZ	354	out:
558df6c8 LZ	355	mutex_unlock(&ksym_tracer_mutex);
0722db01	356
0722db01 P	357	kfree(input_string);
0722db01 P	358
558df6c8 LZ	359	if (!ret)
558df6c8 LZ	360	ret = count;
0722db01 P	361	return ret;
	362	}
	363
	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,
	368	};
	369
	370	static void ksym_trace_reset(struct trace_array *tr)
	371	{
0722db01	372	ksym_tracing_enabled = 0;
75e33751	373	__ksym_trace_reset();
0722db01 P	374	}
	375
	376	static int ksym_trace_init(struct trace_array *tr)
	377	{
	378	int cpu, ret = 0;
	379
	380	for_each_online_cpu(cpu)
	381	tracing_reset(tr, cpu);
	382	ksym_tracing_enabled = 1;
	383	ksym_trace_array = tr;
	384
	385	return ret;
	386	}
	387
	388	static void ksym_trace_print_header(struct seq_file *m)
	389	{
0722db01	390	seq_puts(m,
d857ace1 XG	391	"# TASK-PID CPU# Symbol "
d857ace1 XG	392	"Type Function\n");
0722db01	393	seq_puts(m,
d857ace1 XG	394	"# \| \| \| "
d857ace1 XG	395	" \| \|\n");
0722db01 P	396	}
	397
	398	static enum print_line_t ksym_trace_output(struct trace_iterator *iter)
	399	{
	400	struct trace_entry *entry = iter->ent;
	401	struct trace_seq *s = &iter->seq;
db59504d	402	struct ksym_trace_entry *field;
0722db01 P	403	char str[KSYM_SYMBOL_LEN];
	404	int ret;
	405
	406	if (entry->type != TRACE_KSYM)
	407	return TRACE_TYPE_UNHANDLED;
	408
	409	trace_assign_type(field, entry);
	410
24f1e32c FW	411	ret = trace_seq_printf(s, "%11s-%-5d [%03d] %pS", field->cmd,
24f1e32c FW	412	entry->pid, iter->cpu, (char *)field->addr);
0722db01 P	413	if (!ret)
	414	return TRACE_TYPE_PARTIAL_LINE;
	415
db59504d	416	switch (field->type) {
24f1e32c	417	case HW_BREAKPOINT_W:
0722db01 P	418	ret = trace_seq_printf(s, " W ");
0722db01 P	419	break;
24f1e32c	420	case HW_BREAKPOINT_R \| HW_BREAKPOINT_W:
0722db01 P	421	ret = trace_seq_printf(s, " RW ");
	422	break;
	423	default:
	424	return TRACE_TYPE_PARTIAL_LINE;
	425	}
	426
	427	if (!ret)
	428	return TRACE_TYPE_PARTIAL_LINE;
	429
	430	sprint_symbol(str, field->ip);
d857ace1	431	ret = trace_seq_printf(s, "%s\n", str);
0722db01 P	432	if (!ret)
	433	return TRACE_TYPE_PARTIAL_LINE;
	434
	435	return TRACE_TYPE_HANDLED;
	436	}
	437
	438	struct tracer ksym_tracer __read_mostly =
	439	{
	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,
	445	#endif
	446	.print_header = ksym_trace_print_header,
	447	.print_line = ksym_trace_output
	448	};
	449
	450	__init static int init_ksym_trace(void)
	451	{
	452	struct dentry *d_tracer;
	453	struct dentry *entry;
	454
	455	d_tracer = tracing_init_dentry();
	456	ksym_filter_entry_count = 0;
	457
	458	entry = debugfs_create_file("ksym_trace_filter", 0644, d_tracer,
	459	NULL, &ksym_tracing_fops);
	460	if (!entry)
	461	pr_warning("Could not create debugfs "
	462	"'ksym_trace_filter' file\n");
	463
	464	return register_tracer(&ksym_tracer);
	465	}
	466	device_initcall(init_ksym_trace);
	467
	468
	469	#ifdef CONFIG_PROFILE_KSYM_TRACER
	470	static int ksym_tracer_stat_headers(struct seq_file *m)
	471	{
9d7e9344 LZ	472	seq_puts(m, " Access Type ");
	473	seq_puts(m, " Symbol Counter\n");
	474	seq_puts(m, " ----------- ");
	475	seq_puts(m, " ------ -------\n");
0722db01 P	476	return 0;
	477	}
	478
	479	static int ksym_tracer_stat_show(struct seq_file m, void v)
	480	{
	481	struct hlist_node *stat = v;
	482	struct trace_ksym *entry;
	483	int access_type = 0;
	484	char fn_name[KSYM_NAME_LEN];
	485
	486	entry = hlist_entry(stat, struct trace_ksym, ksym_hlist);
	487
24f1e32c	488	access_type = entry->type;
0722db01 P	489
0722db01 P	490	switch (access_type) {
24f1e32c	491	case HW_BREAKPOINT_W:
9d7e9344	492	seq_puts(m, " W ");
0722db01	493	break;
24f1e32c	494	case HW_BREAKPOINT_R \| HW_BREAKPOINT_W:
9d7e9344	495	seq_puts(m, " RW ");
0722db01 P	496	break;
0722db01 P	497	default:
9d7e9344	498	seq_puts(m, " NA ");
0722db01 P	499	}
	500
	501	if (lookup_symbol_name(entry->ksym_addr, fn_name) >= 0)
9d7e9344	502	seq_printf(m, " %-36s", fn_name);
0722db01	503	else
9d7e9344 LZ	504	seq_printf(m, " %-36s", "<NA>");
9d7e9344 LZ	505	seq_printf(m, " %15lu\n", entry->counter);
0722db01	506
0722db01 P	507	return 0;
	508	}
	509
	510	static void ksym_tracer_stat_start(struct tracer_stat trace)
	511	{
9d7e9344	512	return ksym_filter_head.first;
0722db01 P	513	}
	514
	515	static void *
	516	ksym_tracer_stat_next(void *v, int idx)
	517	{
	518	struct hlist_node *stat = v;
	519
	520	return stat->next;
	521	}
	522
	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
	529	};
	530
	531	__init static int ksym_tracer_stat_init(void)
	532	{
	533	int ret;
	534
	535	ret = register_stat_tracer(&ksym_tracer_stats);
	536	if (ret) {
	537	printk(KERN_WARNING "Warning: could not register "
	538	"ksym tracer stats\n");
	539	return 1;
	540	}
	541
	542	return 0;
	543	}
	544	fs_initcall(ksym_tracer_stat_init);
	545	#endif /* CONFIG_PROFILE_KSYM_TRACER */