Commit 26b840ae authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'trace-fixes-v3.10' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace 

Pull tracing/kprobes update from Steven Rostedt:
 "The majority of these changes are from Masami Hiramatsu bringing
  kprobes up to par with the latest changes to ftrace (multi buffering
  and the new function probes).

  He also discovered and fixed some bugs in doing so.  When pulling in
  his patches, I also found a few minor bugs as well and fixed them.

  This also includes a compile fix for some archs that select the ring
  buffer but not tracing.

  I based this off of the last patch you took from me that fixed the
  merge conflict error, as that was the commit that had all the changes
  I needed for this set of changes."

* tag 'trace-fixes-v3.10' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace:
  tracing/kprobes: Support soft-mode disabling
  tracing/kprobes: Support ftrace_event_file base multibuffer
  tracing/kprobes: Pass trace_probe directly from dispatcher
  tracing/kprobes: Increment probe hit-count even if it is used by perf
  tracing/kprobes: Use bool for retprobe checker
  ftrace: Fix function probe when more than one probe is added
  ftrace: Fix the output of enabled_functions debug file
  ftrace: Fix locking in register_ftrace_function_probe()
  tracing: Add helper function trace_create_new_event() to remove duplicate code
  tracing: Modify soft-mode only if there's no other referrer
  tracing: Indicate enabled soft-mode in enable file
  tracing/kprobes: Fix to increment return event probe hit-count
  ftrace: Cleanup regex_lock and ftrace_lock around hash updating
  ftrace, kprobes: Fix a deadlock on ftrace_regex_lock
  ftrace: Have ftrace_regex_write() return either read or error
  tracing: Return error if register_ftrace_function_probe() fails for event_enable_func()
  tracing: Don't succeed if event_enable_func did not register anything
  ring-buffer: Select IRQ_WORK
parents 607eeb0b b8820084

include/linux/ftrace.h

+4 −0
Original line number Diff line number Diff line
@@ -90,6 +90,8 @@ typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip, 
 *            not set this, then the ftrace infrastructure will add recursion

 *            protection for the caller.

 * STUB   - The ftrace_ops is just a place holder.

 * INITIALIZED - The ftrace_ops has already been initialized (first use time

 *            register_ftrace_function() is called, it will initialized the ops)

 */

enum {

	FTRACE_OPS_FL_ENABLED			= 1 << 0,
@@ -100,6 +102,7 @@ enum { 
	FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED	= 1 << 5,

	FTRACE_OPS_FL_RECURSION_SAFE		= 1 << 6,

	FTRACE_OPS_FL_STUB			= 1 << 7,

	FTRACE_OPS_FL_INITIALIZED		= 1 << 8,

};



struct ftrace_ops {
@@ -110,6 +113,7 @@ struct ftrace_ops { 
#ifdef CONFIG_DYNAMIC_FTRACE

	struct ftrace_hash		*notrace_hash;

	struct ftrace_hash		*filter_hash;

	struct mutex			regex_lock;

#endif

};

include/linux/ftrace_event.h

+1 −0
Original line number Diff line number Diff line
@@ -293,6 +293,7 @@ struct ftrace_event_file { 
	 * caching and such. Which is mostly OK ;-)

	 */

	unsigned long		flags;

	atomic_t		sm_ref;	/* soft-mode reference counter */

};



#define __TRACE_EVENT_FLAGS(name, value)				\

kernel/trace/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -71,6 +71,7 @@ config TRACE_CLOCK 
config RING_BUFFER

	bool

	select TRACE_CLOCK

	select IRQ_WORK



config FTRACE_NMI_ENTER

       bool
@@ -107,7 +108,6 @@ config TRACING 
	select BINARY_PRINTF

	select EVENT_TRACING

	select TRACE_CLOCK

	select IRQ_WORK



config GENERIC_TRACER

	bool

kernel/trace/ftrace.c

+84 −42
Original line number Diff line number Diff line
@@ -64,6 +64,13 @@ 


#define FL_GLOBAL_CONTROL_MASK (FTRACE_OPS_FL_GLOBAL | FTRACE_OPS_FL_CONTROL)



#ifdef CONFIG_DYNAMIC_FTRACE

#define INIT_REGEX_LOCK(opsname)	\

	.regex_lock	= __MUTEX_INITIALIZER(opsname.regex_lock),

#else

#define INIT_REGEX_LOCK(opsname)

#endif



static struct ftrace_ops ftrace_list_end __read_mostly = {

	.func		= ftrace_stub,

	.flags		= FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_STUB,
@@ -131,6 +138,16 @@ static void ftrace_ops_no_ops(unsigned long ip, unsigned long parent_ip); 
	while (likely(op = rcu_dereference_raw((op)->next)) &&	\

	       unlikely((op) != &ftrace_list_end))



static inline void ftrace_ops_init(struct ftrace_ops *ops)

{

#ifdef CONFIG_DYNAMIC_FTRACE

	if (!(ops->flags & FTRACE_OPS_FL_INITIALIZED)) {

		mutex_init(&ops->regex_lock);

		ops->flags |= FTRACE_OPS_FL_INITIALIZED;

	}

#endif

}



/**

 * ftrace_nr_registered_ops - return number of ops registered

 *
@@ -907,7 +924,8 @@ static void unregister_ftrace_profiler(void) 
#else

static struct ftrace_ops ftrace_profile_ops __read_mostly = {

	.func		= function_profile_call,

	.flags		= FTRACE_OPS_FL_RECURSION_SAFE,

	.flags		= FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_INITIALIZED,

	INIT_REGEX_LOCK(ftrace_profile_ops)

};



static int register_ftrace_profiler(void)
@@ -1103,11 +1121,10 @@ static struct ftrace_ops global_ops = { 
	.func			= ftrace_stub,

	.notrace_hash		= EMPTY_HASH,

	.filter_hash		= EMPTY_HASH,

	.flags			= FTRACE_OPS_FL_RECURSION_SAFE,

	.flags			= FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_INITIALIZED,

	INIT_REGEX_LOCK(global_ops)

};



static DEFINE_MUTEX(ftrace_regex_lock);



struct ftrace_page {

	struct ftrace_page	*next;

	struct dyn_ftrace	*records;
@@ -1247,6 +1264,7 @@ static void free_ftrace_hash_rcu(struct ftrace_hash *hash) 


void ftrace_free_filter(struct ftrace_ops *ops)

{

	ftrace_ops_init(ops);

	free_ftrace_hash(ops->filter_hash);

	free_ftrace_hash(ops->notrace_hash);

}
@@ -2441,7 +2459,7 @@ t_next(struct seq_file *m, void *v, loff_t *pos) 
		     !ftrace_lookup_ip(ops->notrace_hash, rec->ip)) ||



		    ((iter->flags & FTRACE_ITER_ENABLED) &&

		     !(rec->flags & ~FTRACE_FL_MASK))) {

		     !(rec->flags & FTRACE_FL_ENABLED))) {



			rec = NULL;

			goto retry;
@@ -2624,6 +2642,8 @@ ftrace_regex_open(struct ftrace_ops *ops, int flag, 
	struct ftrace_hash *hash;

	int ret = 0;



	ftrace_ops_init(ops);



	if (unlikely(ftrace_disabled))

		return -ENODEV;
@@ -2636,28 +2656,26 @@ ftrace_regex_open(struct ftrace_ops *ops, int flag, 
		return -ENOMEM;

	}



	iter->ops = ops;

	iter->flags = flag;



	mutex_lock(&ops->regex_lock);



	if (flag & FTRACE_ITER_NOTRACE)

		hash = ops->notrace_hash;

	else

		hash = ops->filter_hash;



	iter->ops = ops;

	iter->flags = flag;



	if (file->f_mode & FMODE_WRITE) {

		mutex_lock(&ftrace_lock);

		iter->hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, hash);

		mutex_unlock(&ftrace_lock);



		if (!iter->hash) {

			trace_parser_put(&iter->parser);

			kfree(iter);

			return -ENOMEM;

			ret = -ENOMEM;

			goto out_unlock;

		}

	}



	mutex_lock(&ftrace_regex_lock);



	if ((file->f_mode & FMODE_WRITE) &&

	    (file->f_flags & O_TRUNC))

		ftrace_filter_reset(iter->hash);
@@ -2677,7 +2695,9 @@ ftrace_regex_open(struct ftrace_ops *ops, int flag, 
		}

	} else

		file->private_data = iter;

	mutex_unlock(&ftrace_regex_lock);



 out_unlock:

	mutex_unlock(&ops->regex_lock);



	return ret;

}
@@ -2910,6 +2930,8 @@ static void function_trace_probe_call(unsigned long ip, unsigned long parent_ip, 
static struct ftrace_ops trace_probe_ops __read_mostly =

{

	.func		= function_trace_probe_call,

	.flags		= FTRACE_OPS_FL_INITIALIZED,

	INIT_REGEX_LOCK(trace_probe_ops)

};



static int ftrace_probe_registered;
@@ -2919,8 +2941,12 @@ static void __enable_ftrace_function_probe(void) 
	int ret;

	int i;



	if (ftrace_probe_registered)

	if (ftrace_probe_registered) {

		/* still need to update the function call sites */

		if (ftrace_enabled)

			ftrace_run_update_code(FTRACE_UPDATE_CALLS);

		return;

	}



	for (i = 0; i < FTRACE_FUNC_HASHSIZE; i++) {

		struct hlist_head *hhd = &ftrace_func_hash[i];
@@ -2990,19 +3016,21 @@ register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops, 
	if (WARN_ON(not))

		return -EINVAL;



	mutex_lock(&ftrace_lock);

	mutex_lock(&trace_probe_ops.regex_lock);



	hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, *orig_hash);

	if (!hash) {

		count = -ENOMEM;

		goto out_unlock;

		goto out;

	}



	if (unlikely(ftrace_disabled)) {

		count = -ENODEV;

		goto out_unlock;

		goto out;

	}



	mutex_lock(&ftrace_lock);



	do_for_each_ftrace_rec(pg, rec) {



		if (!ftrace_match_record(rec, NULL, search, len, type))
@@ -3056,6 +3084,8 @@ register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops, 


 out_unlock:

	mutex_unlock(&ftrace_lock);

 out:

	mutex_unlock(&trace_probe_ops.regex_lock);

	free_ftrace_hash(hash);



	return count;
@@ -3095,7 +3125,7 @@ __unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops, 
			return;

	}



	mutex_lock(&ftrace_lock);

	mutex_lock(&trace_probe_ops.regex_lock);



	hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, *orig_hash);

	if (!hash)
@@ -3133,6 +3163,7 @@ __unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops, 
			list_add(&entry->free_list, &free_list);

		}

	}

	mutex_lock(&ftrace_lock);

	__disable_ftrace_function_probe();

	/*

	 * Remove after the disable is called. Otherwise, if the last
@@ -3144,9 +3175,10 @@ __unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops, 
		list_del(&entry->free_list);

		ftrace_free_entry(entry);

	}

	mutex_unlock(&ftrace_lock);

		

 out_unlock:

	mutex_unlock(&ftrace_lock);

	mutex_unlock(&trace_probe_ops.regex_lock);

	free_ftrace_hash(hash);

}
@@ -3256,18 +3288,17 @@ ftrace_regex_write(struct file *file, const char __user *ubuf, 
	if (!cnt)

		return 0;



	mutex_lock(&ftrace_regex_lock);



	ret = -ENODEV;

	if (unlikely(ftrace_disabled))

		goto out_unlock;



	if (file->f_mode & FMODE_READ) {

		struct seq_file *m = file->private_data;

		iter = m->private;

	} else

		iter = file->private_data;



	if (unlikely(ftrace_disabled))

		return -ENODEV;



	/* iter->hash is a local copy, so we don't need regex_lock */



	parser = &iter->parser;

	read = trace_get_user(parser, ubuf, cnt, ppos);
@@ -3276,14 +3307,12 @@ ftrace_regex_write(struct file *file, const char __user *ubuf, 
		ret = ftrace_process_regex(iter->hash, parser->buffer,

					   parser->idx, enable);

		trace_parser_clear(parser);

		if (ret)

			goto out_unlock;

		if (ret < 0)

			goto out;

	}



	ret = read;

out_unlock:

	mutex_unlock(&ftrace_regex_lock);



 out:

	return ret;

}
@@ -3335,16 +3364,19 @@ ftrace_set_hash(struct ftrace_ops *ops, unsigned char *buf, int len, 
	if (unlikely(ftrace_disabled))

		return -ENODEV;



	mutex_lock(&ops->regex_lock);



	if (enable)

		orig_hash = &ops->filter_hash;

	else

		orig_hash = &ops->notrace_hash;



	hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, *orig_hash);

	if (!hash)

		return -ENOMEM;

	if (!hash) {

		ret = -ENOMEM;

		goto out_regex_unlock;

	}



	mutex_lock(&ftrace_regex_lock);

	if (reset)

		ftrace_filter_reset(hash);

	if (buf && !ftrace_match_records(hash, buf, len)) {
@@ -3366,7 +3398,7 @@ ftrace_set_hash(struct ftrace_ops *ops, unsigned char *buf, int len, 
	mutex_unlock(&ftrace_lock);



 out_regex_unlock:

	mutex_unlock(&ftrace_regex_lock);

	mutex_unlock(&ops->regex_lock);



	free_ftrace_hash(hash);

	return ret;
@@ -3392,6 +3424,7 @@ ftrace_set_addr(struct ftrace_ops *ops, unsigned long ip, int remove, 
int ftrace_set_filter_ip(struct ftrace_ops *ops, unsigned long ip,

			 int remove, int reset)

{

	ftrace_ops_init(ops);

	return ftrace_set_addr(ops, ip, remove, reset, 1);

}

EXPORT_SYMBOL_GPL(ftrace_set_filter_ip);
@@ -3416,6 +3449,7 @@ ftrace_set_regex(struct ftrace_ops *ops, unsigned char *buf, int len, 
int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,

		       int len, int reset)

{

	ftrace_ops_init(ops);

	return ftrace_set_regex(ops, buf, len, reset, 1);

}

EXPORT_SYMBOL_GPL(ftrace_set_filter);
@@ -3434,6 +3468,7 @@ EXPORT_SYMBOL_GPL(ftrace_set_filter); 
int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,

			int len, int reset)

{

	ftrace_ops_init(ops);

	return ftrace_set_regex(ops, buf, len, reset, 0);

}

EXPORT_SYMBOL_GPL(ftrace_set_notrace);
@@ -3524,6 +3559,8 @@ ftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable) 
{

	char *func;



	ftrace_ops_init(ops);



	while (buf) {

		func = strsep(&buf, ",");

		ftrace_set_regex(ops, func, strlen(func), 0, enable);
@@ -3551,10 +3588,8 @@ int ftrace_regex_release(struct inode *inode, struct file *file) 
	int filter_hash;

	int ret;



	mutex_lock(&ftrace_regex_lock);

	if (file->f_mode & FMODE_READ) {

		iter = m->private;



		seq_release(inode, file);

	} else

		iter = file->private_data;
@@ -3567,6 +3602,8 @@ int ftrace_regex_release(struct inode *inode, struct file *file) 


	trace_parser_put(parser);



	mutex_lock(&iter->ops->regex_lock);



	if (file->f_mode & FMODE_WRITE) {

		filter_hash = !!(iter->flags & FTRACE_ITER_FILTER);
@@ -3584,10 +3621,11 @@ int ftrace_regex_release(struct inode *inode, struct file *file) 


		mutex_unlock(&ftrace_lock);

	}



	mutex_unlock(&iter->ops->regex_lock);

	free_ftrace_hash(iter->hash);

	kfree(iter);



	mutex_unlock(&ftrace_regex_lock);

	return 0;

}
@@ -4126,7 +4164,8 @@ void __init ftrace_init(void) 


static struct ftrace_ops global_ops = {

	.func			= ftrace_stub,

	.flags			= FTRACE_OPS_FL_RECURSION_SAFE,

	.flags			= FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_INITIALIZED,

	INIT_REGEX_LOCK(global_ops)

};



static int __init ftrace_nodyn_init(void)
@@ -4181,7 +4220,8 @@ ftrace_ops_control_func(unsigned long ip, unsigned long parent_ip, 


static struct ftrace_ops control_ops = {

	.func	= ftrace_ops_control_func,

	.flags = FTRACE_OPS_FL_RECURSION_SAFE,

	.flags	= FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_INITIALIZED,

	INIT_REGEX_LOCK(control_ops)

};



static inline void
@@ -4539,6 +4579,8 @@ int register_ftrace_function(struct ftrace_ops *ops) 
{

	int ret = -1;



	ftrace_ops_init(ops);



	mutex_lock(&ftrace_lock);



	ret = __register_ftrace_function(ops);

kernel/trace/trace_events.c

+41 −13
Original line number Diff line number Diff line
@@ -251,7 +251,8 @@ static int __ftrace_event_enable_disable(struct ftrace_event_file *file, 
	switch (enable) {

	case 0:

		/*

		 * When soft_disable is set and enable is cleared, we want

		 * When soft_disable is set and enable is cleared, the sm_ref

		 * reference counter is decremented. If it reaches 0, we want

		 * to clear the SOFT_DISABLED flag but leave the event in the

		 * state that it was. That is, if the event was enabled and

		 * SOFT_DISABLED isn't set, then do nothing. But if SOFT_DISABLED
@@ -263,6 +264,8 @@ static int __ftrace_event_enable_disable(struct ftrace_event_file *file, 
		 * "soft enable"s (clearing the SOFT_DISABLED bit) wont work.

		 */

		if (soft_disable) {

			if (atomic_dec_return(&file->sm_ref) > 0)

				break;

			disable = file->flags & FTRACE_EVENT_FL_SOFT_DISABLED;

			clear_bit(FTRACE_EVENT_FL_SOFT_MODE_BIT, &file->flags);

		} else
@@ -291,8 +294,11 @@ static int __ftrace_event_enable_disable(struct ftrace_event_file *file, 
		 */

		if (!soft_disable)

			clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);

		else

		else {

			if (atomic_inc_return(&file->sm_ref) > 1)

				break;

			set_bit(FTRACE_EVENT_FL_SOFT_MODE_BIT, &file->flags);

		}



		if (!(file->flags & FTRACE_EVENT_FL_ENABLED)) {
@@ -623,6 +629,8 @@ event_enable_read(struct file *filp, char __user *ubuf, size_t cnt, 
	if (file->flags & FTRACE_EVENT_FL_ENABLED) {

		if (file->flags & FTRACE_EVENT_FL_SOFT_DISABLED)

			buf = "0*\n";

		else if (file->flags & FTRACE_EVENT_FL_SOFT_MODE)

			buf = "1*\n";

		else

			buf = "1\n";

	} else
@@ -1521,6 +1529,24 @@ __register_event(struct ftrace_event_call *call, struct module *mod) 
	return 0;

}



static struct ftrace_event_file *

trace_create_new_event(struct ftrace_event_call *call,

		       struct trace_array *tr)

{

	struct ftrace_event_file *file;



	file = kmem_cache_alloc(file_cachep, GFP_TRACE);

	if (!file)

		return NULL;



	file->event_call = call;

	file->tr = tr;

	atomic_set(&file->sm_ref, 0);

	list_add(&file->list, &tr->events);



	return file;

}



/* Add an event to a trace directory */

static int

__trace_add_new_event(struct ftrace_event_call *call,
@@ -1532,14 +1558,10 @@ __trace_add_new_event(struct ftrace_event_call *call, 
{

	struct ftrace_event_file *file;



	file = kmem_cache_alloc(file_cachep, GFP_TRACE);

	file = trace_create_new_event(call, tr);

	if (!file)

		return -ENOMEM;



	file->event_call = call;

	file->tr = tr;

	list_add(&file->list, &tr->events);



	return event_create_dir(tr->event_dir, file, id, enable, filter, format);

}
@@ -1554,14 +1576,10 @@ __trace_early_add_new_event(struct ftrace_event_call *call, 
{

	struct ftrace_event_file *file;



	file = kmem_cache_alloc(file_cachep, GFP_TRACE);

	file = trace_create_new_event(call, tr);

	if (!file)

		return -ENOMEM;



	file->event_call = call;

	file->tr = tr;

	list_add(&file->list, &tr->events);



	return 0;

}
@@ -2061,8 +2079,18 @@ event_enable_func(struct ftrace_hash *hash, 
	if (ret < 0)

		goto out_put;

	ret = register_ftrace_function_probe(glob, ops, data);

	if (!ret)

	/*

	 * The above returns on success the # of functions enabled,

	 * but if it didn't find any functions it returns zero.

	 * Consider no functions a failure too.

	 */

	if (!ret) {

		ret = -ENOENT;

		goto out_disable;

	} else if (ret < 0)

		goto out_disable;

	/* Just return zero, not the number of enabled functions */

	ret = 0;

 out:

	mutex_unlock(&event_mutex);

	return ret;

CRA Git | Maintained and supported by SUSTech CRA and CCSE