Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b7bc9e7d authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'trace-fixes-3.11-rc3' of... 

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

Pull tracing fixes from Steven Rostedt:
 "Oleg Nesterov has been working hard in closing all the holes that can
  lead to race conditions between deleting an event and accessing an
  event debugfs file.  This included a fix to the debugfs system (acked
  by Greg Kroah-Hartman).  We think that all the holes have been patched
  and hopefully we don't find more.  I haven't marked all of them for
  stable because I need to examine them more to figure out how far back
  some of the changes need to go.

  Along the way, some other fixes have been made.  Alexander Z Lam fixed
  some logic where the wrong buffer was being modifed.

  Andrew Vagin found a possible corruption for machines that actually
  allocate cpumask, as a reference to one was being zeroed out by
  mistake.

  Dhaval Giani found a bad prototype when tracing is not configured.

  And I not only had some changes to help Oleg, but also finally fixed a
  long standing bug that Dave Jones and others have been hitting, where
  a module unload and reload can cause the function tracing accounting
  to get screwed up"

* tag 'trace-fixes-3.11-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace:
  tracing: Fix reset of time stamps during trace_clock changes
  tracing: Make TRACE_ITER_STOP_ON_FREE stop the correct buffer
  tracing: Fix trace_dump_stack() proto when CONFIG_TRACING is not set
  tracing: Fix fields of struct trace_iterator that are zeroed by mistake
  tracing/uprobes: Fail to unregister if probe event files are in use
  tracing/kprobes: Fail to unregister if probe event files are in use
  tracing: Add comment to describe special break case in probe_remove_event_call()
  tracing: trace_remove_event_call() should fail if call/file is in use
  debugfs: debugfs_remove_recursive() must not rely on list_empty(d_subdirs)
  ftrace: Check module functions being traced on reload
  ftrace: Consolidate some duplicate code for updating ftrace ops
  tracing: Change remove_event_file_dir() to clear "d_subdirs"->i_private
  tracing: Introduce remove_event_file_dir()
  tracing: Change f_start() to take event_mutex and verify i_private != NULL
  tracing: Change event_filter_read/write to verify i_private != NULL
  tracing: Change event_enable/disable_read() to verify i_private != NULL
  tracing: Turn event/id->i_private into call->event.type
parents 8ef9c292 9457158b

fs/debugfs/inode.c

+22 −47
Original line number Diff line number Diff line
@@ -533,8 +533,7 @@ EXPORT_SYMBOL_GPL(debugfs_remove); 
 */

void debugfs_remove_recursive(struct dentry *dentry)

{

	struct dentry *child;

	struct dentry *parent;

	struct dentry *child, *next, *parent;



	if (IS_ERR_OR_NULL(dentry))

		return;
@@ -544,61 +543,37 @@ void debugfs_remove_recursive(struct dentry *dentry) 
		return;



	parent = dentry;

 down:

	mutex_lock(&parent->d_inode->i_mutex);

	list_for_each_entry_safe(child, next, &parent->d_subdirs, d_u.d_child) {

		if (!debugfs_positive(child))

			continue;



	while (1) {

		/*

		 * When all dentries under "parent" has been removed,

		 * walk up the tree until we reach our starting point.

		 */

		if (list_empty(&parent->d_subdirs)) {

			mutex_unlock(&parent->d_inode->i_mutex);

			if (parent == dentry)

				break;

			parent = parent->d_parent;

			mutex_lock(&parent->d_inode->i_mutex);

		}

		child = list_entry(parent->d_subdirs.next, struct dentry,

				d_u.d_child);

 next_sibling:



		/*

		 * If "child" isn't empty, walk down the tree and

		 * remove all its descendants first.

		 */

		/* perhaps simple_empty(child) makes more sense */

		if (!list_empty(&child->d_subdirs)) {

			mutex_unlock(&parent->d_inode->i_mutex);

			parent = child;

			mutex_lock(&parent->d_inode->i_mutex);

			continue;

			goto down;

		}

		__debugfs_remove(child, parent);

		if (parent->d_subdirs.next == &child->d_u.d_child) {

			/*

			 * Try the next sibling.

			 */

			if (child->d_u.d_child.next != &parent->d_subdirs) {

				child = list_entry(child->d_u.d_child.next,

						   struct dentry,

						   d_u.d_child);

				goto next_sibling;

 up:

		if (!__debugfs_remove(child, parent))

			simple_release_fs(&debugfs_mount, &debugfs_mount_count);

	}



			/*

			 * Avoid infinite loop if we fail to remove

			 * one dentry.

			 */

	mutex_unlock(&parent->d_inode->i_mutex);

			break;

		}

		simple_release_fs(&debugfs_mount, &debugfs_mount_count);

	child = parent;

	parent = parent->d_parent;

	mutex_lock(&parent->d_inode->i_mutex);



	if (child != dentry) {

		next = list_entry(child->d_u.d_child.next, struct dentry,

					d_u.d_child);

		goto up;

	}



	parent = dentry->d_parent;

	mutex_lock(&parent->d_inode->i_mutex);

	__debugfs_remove(dentry, parent);

	mutex_unlock(&parent->d_inode->i_mutex);

	if (!__debugfs_remove(child, parent))

		simple_release_fs(&debugfs_mount, &debugfs_mount_count);

	mutex_unlock(&parent->d_inode->i_mutex);

}

EXPORT_SYMBOL_GPL(debugfs_remove_recursive);

include/linux/ftrace_event.h

+7 −5
Original line number Diff line number Diff line
@@ -78,6 +78,11 @@ struct trace_iterator { 
	/* trace_seq for __print_flags() and __print_symbolic() etc. */

	struct trace_seq	tmp_seq;



	cpumask_var_t		started;



	/* it's true when current open file is snapshot */

	bool			snapshot;



	/* The below is zeroed out in pipe_read */

	struct trace_seq	seq;

	struct trace_entry	*ent;
@@ -90,10 +95,7 @@ struct trace_iterator { 
	loff_t			pos;

	long			idx;



	cpumask_var_t		started;



	/* it's true when current open file is snapshot */

	bool			snapshot;

	/* All new field here will be zeroed out in pipe_read */

};



enum trace_iter_flags {
@@ -332,7 +334,7 @@ extern int trace_define_field(struct ftrace_event_call *call, const char *type, 
			      const char *name, int offset, int size,

			      int is_signed, int filter_type);

extern int trace_add_event_call(struct ftrace_event_call *call);

extern void trace_remove_event_call(struct ftrace_event_call *call);

extern int trace_remove_event_call(struct ftrace_event_call *call);



#define is_signed_type(type)	(((type)(-1)) < (type)1)

include/linux/kernel.h

+1 −1
Original line number Diff line number Diff line
@@ -629,7 +629,7 @@ extern void ftrace_dump(enum ftrace_dump_mode oops_dump_mode); 
static inline void tracing_start(void) { }

static inline void tracing_stop(void) { }

static inline void ftrace_off_permanent(void) { }

static inline void trace_dump_stack(void) { }

static inline void trace_dump_stack(int skip) { }



static inline void tracing_on(void) { }

static inline void tracing_off(void) { }

kernel/trace/ftrace.c

+72 −15
Original line number Diff line number Diff line
@@ -2169,12 +2169,57 @@ static cycle_t ftrace_update_time; 
static unsigned long	ftrace_update_cnt;

unsigned long		ftrace_update_tot_cnt;



static int ops_traces_mod(struct ftrace_ops *ops)

static inline int ops_traces_mod(struct ftrace_ops *ops)

{

	struct ftrace_hash *hash;

	/*

	 * Filter_hash being empty will default to trace module.

	 * But notrace hash requires a test of individual module functions.

	 */

	return ftrace_hash_empty(ops->filter_hash) &&

		ftrace_hash_empty(ops->notrace_hash);

}



	hash = ops->filter_hash;

	return ftrace_hash_empty(hash);

/*

 * Check if the current ops references the record.

 *

 * If the ops traces all functions, then it was already accounted for.

 * If the ops does not trace the current record function, skip it.

 * If the ops ignores the function via notrace filter, skip it.

 */

static inline bool

ops_references_rec(struct ftrace_ops *ops, struct dyn_ftrace *rec)

{

	/* If ops isn't enabled, ignore it */

	if (!(ops->flags & FTRACE_OPS_FL_ENABLED))

		return 0;



	/* If ops traces all mods, we already accounted for it */

	if (ops_traces_mod(ops))

		return 0;



	/* The function must be in the filter */

	if (!ftrace_hash_empty(ops->filter_hash) &&

	    !ftrace_lookup_ip(ops->filter_hash, rec->ip))

		return 0;



	/* If in notrace hash, we ignore it too */

	if (ftrace_lookup_ip(ops->notrace_hash, rec->ip))

		return 0;



	return 1;

}



static int referenced_filters(struct dyn_ftrace *rec)

{

	struct ftrace_ops *ops;

	int cnt = 0;



	for (ops = ftrace_ops_list; ops != &ftrace_list_end; ops = ops->next) {

		if (ops_references_rec(ops, rec))

		    cnt++;

	}



	return cnt;

}



static int ftrace_update_code(struct module *mod)
@@ -2183,6 +2228,7 @@ static int ftrace_update_code(struct module *mod) 
	struct dyn_ftrace *p;

	cycle_t start, stop;

	unsigned long ref = 0;

	bool test = false;

	int i;



	/*
@@ -2196,9 +2242,12 @@ static int ftrace_update_code(struct module *mod) 


		for (ops = ftrace_ops_list;

		     ops != &ftrace_list_end; ops = ops->next) {

			if (ops->flags & FTRACE_OPS_FL_ENABLED &&

			    ops_traces_mod(ops))

			if (ops->flags & FTRACE_OPS_FL_ENABLED) {

				if (ops_traces_mod(ops))

					ref++;

				else

					test = true;

			}

		}

	}
@@ -2208,12 +2257,16 @@ static int ftrace_update_code(struct module *mod) 
	for (pg = ftrace_new_pgs; pg; pg = pg->next) {



		for (i = 0; i < pg->index; i++) {

			int cnt = ref;



			/* If something went wrong, bail without enabling anything */

			if (unlikely(ftrace_disabled))

				return -1;



			p = &pg->records[i];

			p->flags = ref;

			if (test)

				cnt += referenced_filters(p);

			p->flags = cnt;



			/*

			 * Do the initial record conversion from mcount jump
@@ -2233,7 +2286,7 @@ static int ftrace_update_code(struct module *mod) 
			 * conversion puts the module to the correct state, thus

			 * passing the ftrace_make_call check.

			 */

			if (ftrace_start_up && ref) {

			if (ftrace_start_up && cnt) {

				int failed = __ftrace_replace_code(p, 1);

				if (failed)

					ftrace_bug(failed, p->ip);
@@ -3384,6 +3437,12 @@ ftrace_match_addr(struct ftrace_hash *hash, unsigned long ip, int remove) 
	return add_hash_entry(hash, ip);

}



static void ftrace_ops_update_code(struct ftrace_ops *ops)

{

	if (ops->flags & FTRACE_OPS_FL_ENABLED && ftrace_enabled)

		ftrace_run_update_code(FTRACE_UPDATE_CALLS);

}



static int

ftrace_set_hash(struct ftrace_ops *ops, unsigned char *buf, int len,

		unsigned long ip, int remove, int reset, int enable)
@@ -3426,9 +3485,8 @@ ftrace_set_hash(struct ftrace_ops *ops, unsigned char *buf, int len, 


	mutex_lock(&ftrace_lock);

	ret = ftrace_hash_move(ops, enable, orig_hash, hash);

	if (!ret && ops->flags & FTRACE_OPS_FL_ENABLED

	    && ftrace_enabled)

		ftrace_run_update_code(FTRACE_UPDATE_CALLS);

	if (!ret)

		ftrace_ops_update_code(ops);



	mutex_unlock(&ftrace_lock);
@@ -3655,9 +3713,8 @@ int ftrace_regex_release(struct inode *inode, struct file *file) 
		mutex_lock(&ftrace_lock);

		ret = ftrace_hash_move(iter->ops, filter_hash,

				       orig_hash, iter->hash);

		if (!ret && (iter->ops->flags & FTRACE_OPS_FL_ENABLED)

		    && ftrace_enabled)

			ftrace_run_update_code(FTRACE_UPDATE_CALLS);

		if (!ret)

			ftrace_ops_update_code(iter->ops);



		mutex_unlock(&ftrace_lock);

	}

kernel/trace/trace.c

+14 −13
Original line number Diff line number Diff line
@@ -243,20 +243,25 @@ int filter_current_check_discard(struct ring_buffer *buffer, 
}

EXPORT_SYMBOL_GPL(filter_current_check_discard);



cycle_t ftrace_now(int cpu)

cycle_t buffer_ftrace_now(struct trace_buffer *buf, int cpu)

{

	u64 ts;



	/* Early boot up does not have a buffer yet */

	if (!global_trace.trace_buffer.buffer)

	if (!buf->buffer)

		return trace_clock_local();



	ts = ring_buffer_time_stamp(global_trace.trace_buffer.buffer, cpu);

	ring_buffer_normalize_time_stamp(global_trace.trace_buffer.buffer, cpu, &ts);

	ts = ring_buffer_time_stamp(buf->buffer, cpu);

	ring_buffer_normalize_time_stamp(buf->buffer, cpu, &ts);



	return ts;

}



cycle_t ftrace_now(int cpu)

{

	return buffer_ftrace_now(&global_trace.trace_buffer, cpu);

}



/**

 * tracing_is_enabled - Show if global_trace has been disabled

 *
@@ -1211,7 +1216,7 @@ void tracing_reset_online_cpus(struct trace_buffer *buf) 
	/* Make sure all commits have finished */

	synchronize_sched();



	buf->time_start = ftrace_now(buf->cpu);

	buf->time_start = buffer_ftrace_now(buf, buf->cpu);



	for_each_online_cpu(cpu)

		ring_buffer_reset_cpu(buffer, cpu);
@@ -1219,11 +1224,6 @@ void tracing_reset_online_cpus(struct trace_buffer *buf) 
	ring_buffer_record_enable(buffer);

}



void tracing_reset_current(int cpu)

{

	tracing_reset(&global_trace.trace_buffer, cpu);

}



/* Must have trace_types_lock held */

void tracing_reset_all_online_cpus(void)

{
@@ -4151,6 +4151,7 @@ waitagain: 
	memset(&iter->seq, 0,

	       sizeof(struct trace_iterator) -

	       offsetof(struct trace_iterator, seq));

	cpumask_clear(iter->started);

	iter->pos = -1;



	trace_event_read_lock();
@@ -4468,7 +4469,7 @@ tracing_free_buffer_release(struct inode *inode, struct file *filp) 


	/* disable tracing ? */

	if (trace_flags & TRACE_ITER_STOP_ON_FREE)

		tracing_off();

		tracer_tracing_off(tr);

	/* resize the ring buffer to 0 */

	tracing_resize_ring_buffer(tr, 0, RING_BUFFER_ALL_CPUS);
@@ -4633,12 +4634,12 @@ static ssize_t tracing_clock_write(struct file *filp, const char __user *ubuf, 
	 * New clock may not be consistent with the previous clock.

	 * Reset the buffer so that it doesn't have incomparable timestamps.

	 */

	tracing_reset_online_cpus(&global_trace.trace_buffer);

	tracing_reset_online_cpus(&tr->trace_buffer);



#ifdef CONFIG_TRACER_MAX_TRACE

	if (tr->flags & TRACE_ARRAY_FL_GLOBAL && tr->max_buffer.buffer)

		ring_buffer_set_clock(tr->max_buffer.buffer, trace_clocks[i].func);

	tracing_reset_online_cpus(&global_trace.max_buffer);

	tracing_reset_online_cpus(&tr->max_buffer);

#endif



	mutex_unlock(&trace_types_lock);