/* * uprobes-based tracing events * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * 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, 2010-2012 * Author:	Srikar Dronamraju <srikar@linux.vnet.ibm.com> */ #include <linux/module.h>#include <linux/uaccess.h>#include <linux/uprobes.h>#include <linux/namei.h>#include <linux/string.h> #include "trace_probe.h" #define UPROBE_EVENT_SYSTEM	"uprobes" struct uprobe_trace_entry_head {	struct trace_entry	ent;	unsigned long		vaddr[];}; #define SIZEOF_TRACE_ENTRY(is_return)			\	(sizeof(struct uprobe_trace_entry_head) +	\	 sizeof(unsigned long) * (is_return ? 2 : 1)) #define DATAOF_TRACE_ENTRY(entry, is_return)		\	((void*)(entry) + SIZEOF_TRACE_ENTRY(is_return)) struct trace_uprobe_filter {	rwlock_t		rwlock;	int			nr_systemwide;	struct list_head	perf_events;}; /* * uprobe event core functions */struct trace_uprobe {	struct list_head		list;	struct ftrace_event_class	class;	struct ftrace_event_call	call;	struct trace_uprobe_filter	filter;	struct uprobe_consumer		consumer;	struct inode			*inode;	char				*filename;	unsigned long			offset;	unsigned long			nhit;	unsigned int			flags;	/* For TP_FLAG_* */	ssize_t				size;	/* trace entry size */	unsigned int			nr_args;	struct probe_arg		args[];}; #define SIZEOF_TRACE_UPROBE(n)			\	(offsetof(struct trace_uprobe, args) +	\	(sizeof(struct probe_arg) * (n))) static int register_uprobe_event(struct trace_uprobe *tu);static int unregister_uprobe_event(struct trace_uprobe *tu); static DEFINE_MUTEX(uprobe_lock);static LIST_HEAD(uprobe_list); static int uprobe_dispatcher(struct uprobe_consumer *con, struct pt_regs *regs);static int uretprobe_dispatcher(struct uprobe_consumer *con,				unsigned long func, struct pt_regs *regs); static inline void init_trace_uprobe_filter(struct trace_uprobe_filter *filter){	rwlock_init(&filter->rwlock);	filter->nr_systemwide = 0;	INIT_LIST_HEAD(&filter->perf_events);} static inline bool uprobe_filter_is_empty(struct trace_uprobe_filter *filter){	return !filter->nr_systemwide && list_empty(&filter->perf_events);} static inline bool is_ret_probe(struct trace_uprobe *tu){	return tu->consumer.ret_handler != NULL;} /* * Allocate new trace_uprobe and initialize it (including uprobes). */static struct trace_uprobe *alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret){	struct trace_uprobe *tu; 	if (!event || !is_good_name(event))		return ERR_PTR(-EINVAL); 	if (!group || !is_good_name(group))		return ERR_PTR(-EINVAL); 	tu = kzalloc(SIZEOF_TRACE_UPROBE(nargs), GFP_KERNEL);	if (!tu)		return ERR_PTR(-ENOMEM); 	tu->call.class = &tu->class;	tu->call.name = kstrdup(event, GFP_KERNEL);	if (!tu->call.name)		goto error; 	tu->class.system = kstrdup(group, GFP_KERNEL);	if (!tu->class.system)		goto error; 	INIT_LIST_HEAD(&tu->list);	tu->consumer.handler = uprobe_dispatcher;	if (is_ret)		tu->consumer.ret_handler = uretprobe_dispatcher;	init_trace_uprobe_filter(&tu->filter);	tu->call.flags |= TRACE_EVENT_FL_USE_CALL_FILTER;	return tu; error:	kfree(tu->call.name);	kfree(tu); 	return ERR_PTR(-ENOMEM);} static void free_trace_uprobe(struct trace_uprobe *tu){	int i; 	for (i = 0; i < tu->nr_args; i++)		traceprobe_free_probe_arg(&tu->args[i]); 	iput(tu->inode);	kfree(tu->call.class->system);	kfree(tu->call.name);	kfree(tu->filename);	kfree(tu);} static struct trace_uprobe *find_probe_event(const char *event, const char *group){	struct trace_uprobe *tu; 	list_for_each_entry(tu, &uprobe_list, list)		if (strcmp(tu->call.name, event) == 0 &&		    strcmp(tu->call.class->system, group) == 0)			return tu; 	return NULL;} /* Unregister a trace_uprobe and probe_event: call with locking uprobe_lock */static int unregister_trace_uprobe(struct trace_uprobe *tu){	int ret; 	ret = unregister_uprobe_event(tu);	if (ret)		return ret; 	list_del(&tu->list);	free_trace_uprobe(tu);	return 0;} /* Register a trace_uprobe and probe_event */static int register_trace_uprobe(struct trace_uprobe *tu){	struct trace_uprobe *old_tp;	int ret; 	mutex_lock(&uprobe_lock); 	/* register as an event */	old_tp = find_probe_event(tu->call.name, tu->call.class->system);	if (old_tp) {		/* delete old event */		ret = unregister_trace_uprobe(old_tp);		if (ret)			goto end;	} 	ret = register_uprobe_event(tu);	if (ret) {		pr_warning("Failed to register probe event(%d)\n", ret);		goto end;	} 	list_add_tail(&tu->list, &uprobe_list); end:	mutex_unlock(&uprobe_lock); 	return ret;} /* * Argument syntax: *  - Add uprobe: p|r[:[GRP/]EVENT] PATH:SYMBOL [FETCHARGS] * *  - Remove uprobe: -:[GRP/]EVENT */static int create_trace_uprobe(int argc, char **argv){	struct trace_uprobe *tu;	struct inode *inode;	char *arg, *event, *group, *filename;	char buf[MAX_EVENT_NAME_LEN];	struct path path;	unsigned long offset;	bool is_delete, is_return;	int i, ret; 	inode = NULL;	ret = 0;	is_delete = false;	is_return = false;	event = NULL;	group = NULL; 	/* argc must be >= 1 */	if (argv[0][0] == '-')		is_delete = true;	else if (argv[0][0] == 'r')		is_return = true;	else if (argv[0][0] != 'p') {		pr_info("Probe definition must be started with 'p', 'r' or '-'.\n");		return -EINVAL;	} 	if (argv[0][1] == ':') {		event = &argv[0][2];		arg = strchr(event, '/'); 		if (arg) {			group = event;			event = arg + 1;			event[-1] = '\0'; 			if (strlen(group) == 0) {				pr_info("Group name is not specified\n");				return -EINVAL;			}		}		if (strlen(event) == 0) {			pr_info("Event name is not specified\n");			return -EINVAL;		}	}	if (!group)		group = UPROBE_EVENT_SYSTEM; 	if (is_delete) {		int ret; 		if (!event) {			pr_info("Delete command needs an event name.\n");			return -EINVAL;		}		mutex_lock(&uprobe_lock);		tu = find_probe_event(event, group); 		if (!tu) {			mutex_unlock(&uprobe_lock);			pr_info("Event %s/%s doesn't exist.\n", group, event);			return -ENOENT;		}		/* delete an event */		ret = unregister_trace_uprobe(tu);		mutex_unlock(&uprobe_lock);		return ret;	} 	if (argc < 2) {		pr_info("Probe point is not specified.\n");		return -EINVAL;	}	if (isdigit(argv[1][0])) {		pr_info("probe point must be have a filename.\n");		return -EINVAL;	}	arg = strchr(argv[1], ':');	if (!arg) {		ret = -EINVAL;		goto fail_address_parse;	} 	*arg++ = '\0';	filename = argv[1];	ret = kern_path(filename, LOOKUP_FOLLOW, &path);	if (ret)		goto fail_address_parse; 	inode = igrab(path.dentry->d_inode);	path_put(&path); 	if (!inode || !S_ISREG(inode->i_mode)) {		ret = -EINVAL;		goto fail_address_parse;	} 	ret = kstrtoul(arg, 0, &offset);	if (ret)		goto fail_address_parse; 	argc -= 2;	argv += 2; 	/* setup a probe */	if (!event) {		char *tail;		char *ptr; 		tail = kstrdup(kbasename(filename), GFP_KERNEL);		if (!tail) {			ret = -ENOMEM;			goto fail_address_parse;		} 		ptr = strpbrk(tail, ".-_");		if (ptr)			*ptr = '\0'; 		snprintf(buf, MAX_EVENT_NAME_LEN, "%c_%s_0x%lx", 'p', tail, offset);		event = buf;		kfree(tail);	} 	tu = alloc_trace_uprobe(group, event, argc, is_return);	if (IS_ERR(tu)) {		pr_info("Failed to allocate trace_uprobe.(%d)\n", (int)PTR_ERR(tu));		ret = PTR_ERR(tu);		goto fail_address_parse;	}	tu->offset = offset;	tu->inode = inode;	tu->filename = kstrdup(filename, GFP_KERNEL); 	if (!tu->filename) {		pr_info("Failed to allocate filename.\n");		ret = -ENOMEM;		goto error;	} 	/* parse arguments */	ret = 0;	for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) {		/* Increment count for freeing args in error case */		tu->nr_args++; 		/* Parse argument name */		arg = strchr(argv[i], '=');		if (arg) {			*arg++ = '\0';			tu->args[i].name = kstrdup(argv[i], GFP_KERNEL);		} else {			arg = argv[i];			/* If argument name is omitted, set "argN" */			snprintf(buf, MAX_EVENT_NAME_LEN, "arg%d", i + 1);			tu->args[i].name = kstrdup(buf, GFP_KERNEL);		} 		if (!tu->args[i].name) {			pr_info("Failed to allocate argument[%d] name.\n", i);			ret = -ENOMEM;			goto error;		} 		if (!is_good_name(tu->args[i].name)) {			pr_info("Invalid argument[%d] name: %s\n", i, tu->args[i].name);			ret = -EINVAL;			goto error;		} 		if (traceprobe_conflict_field_name(tu->args[i].name, tu->args, i)) {			pr_info("Argument[%d] name '%s' conflicts with "				"another field.\n", i, argv[i]);			ret = -EINVAL;			goto error;		} 		/* Parse fetch argument */		ret = traceprobe_parse_probe_arg(arg, &tu->size, &tu->args[i], false, false);		if (ret) {			pr_info("Parse error at argument[%d]. (%d)\n", i, ret);			goto error;		}	} 	ret = register_trace_uprobe(tu);	if (ret)		goto error;	return 0; error:	free_trace_uprobe(tu);	return ret; fail_address_parse:	if (inode)		iput(inode); 	pr_info("Failed to parse address or file.\n"); 	return ret;} static int cleanup_all_probes(void){	struct trace_uprobe *tu;	int ret = 0; 	mutex_lock(&uprobe_lock);	while (!list_empty(&uprobe_list)) {		tu = list_entry(uprobe_list.next, struct trace_uprobe, list);		ret = unregister_trace_uprobe(tu);		if (ret)			break;	}	mutex_unlock(&uprobe_lock);	return ret;} /* Probes listing interfaces */static void *probes_seq_start(struct seq_file *m, loff_t *pos){	mutex_lock(&uprobe_lock);	return seq_list_start(&uprobe_list, *pos);} static void *probes_seq_next(struct seq_file *m, void *v, loff_t *pos){	return seq_list_next(v, &uprobe_list, pos);} static void probes_seq_stop(struct seq_file *m, void *v){	mutex_unlock(&uprobe_lock);} static int probes_seq_show(struct seq_file *m, void *v){	struct trace_uprobe *tu = v;	char c = is_ret_probe(tu) ? 'r' : 'p';	int i; 	seq_printf(m, "%c:%s/%s", c, tu->call.class->system, tu->call.name);	seq_printf(m, " %s:0x%p", tu->filename, (void *)tu->offset); 	for (i = 0; i < tu->nr_args; i++)		seq_printf(m, " %s=%s", tu->args[i].name, tu->args[i].comm); 	seq_printf(m, "\n");	return 0;} static const struct seq_operations probes_seq_op = {	.start	= probes_seq_start,	.next	= probes_seq_next,	.stop	= probes_seq_stop,	.show	= probes_seq_show}; static int probes_open(struct inode *inode, struct file *file){	int ret; 	if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {		ret = cleanup_all_probes();		if (ret)			return ret;	} 	return seq_open(file, &probes_seq_op);} static ssize_t probes_write(struct file *file, const char __user *buffer,			    size_t count, loff_t *ppos){	return traceprobe_probes_write(file, buffer, count, ppos, create_trace_uprobe);} static const struct file_operations uprobe_events_ops = {	.owner		= THIS_MODULE,	.open		= probes_open,

Lines 1–500 of 1022. Load more