Commit b3b1e6ed authored by Steven Rostedt (VMware)'s avatar Steven Rostedt (VMware)
Browse files

ftrace: Create set_ftrace_notrace_pid to not trace tasks 



There's currently a way to select a task that should only be traced by
functions, but there's no way to select a task not to be traced by the
function tracer. Add a set_ftrace_notrace_pid file that acts the same as
set_ftrace_pid (and is also affected by function-fork), but the task pids in
this file will not be traced even if they are listed in the set_ftrace_pid
file. This makes it easy for tools like trace-cmd to "hide" itself from the
function tracer when it is recording other tasks.

Signed-off-by: default avatarSteven Rostedt (VMware) <rostedt@goodmis.org>
parent 717e3f5e

kernel/trace/ftrace.c

+158 −23
Original line number Diff line number Diff line
@@ -102,7 +102,7 @@ static bool ftrace_pids_enabled(struct ftrace_ops *ops) 


	tr = ops->private;



	return tr->function_pids != NULL;

	return tr->function_pids != NULL || tr->function_no_pids != NULL;

}



static void ftrace_update_trampoline(struct ftrace_ops *ops);
@@ -6931,10 +6931,12 @@ ftrace_filter_pid_sched_switch_probe(void *data, bool preempt, 
{

	struct trace_array *tr = data;

	struct trace_pid_list *pid_list;

	struct trace_pid_list *no_pid_list;



	pid_list = rcu_dereference_sched(tr->function_pids);

	no_pid_list = rcu_dereference_sched(tr->function_no_pids);



	if (trace_ignore_this_task(pid_list, next))

	if (trace_ignore_this_task(pid_list, no_pid_list, next))

		this_cpu_write(tr->array_buffer.data->ftrace_ignore_pid,

			       FTRACE_PID_IGNORE);

	else
@@ -6952,6 +6954,9 @@ ftrace_pid_follow_sched_process_fork(void *data, 


	pid_list = rcu_dereference_sched(tr->function_pids);

	trace_filter_add_remove_task(pid_list, self, task);



	pid_list = rcu_dereference_sched(tr->function_no_pids);

	trace_filter_add_remove_task(pid_list, self, task);

}



static void
@@ -6962,6 +6967,9 @@ ftrace_pid_follow_sched_process_exit(void *data, struct task_struct *task) 


	pid_list = rcu_dereference_sched(tr->function_pids);

	trace_filter_add_remove_task(pid_list, NULL, task);



	pid_list = rcu_dereference_sched(tr->function_no_pids);

	trace_filter_add_remove_task(pid_list, NULL, task);

}



void ftrace_pid_follow_fork(struct trace_array *tr, bool enable)
@@ -6979,42 +6987,64 @@ void ftrace_pid_follow_fork(struct trace_array *tr, bool enable) 
	}

}



static void clear_ftrace_pids(struct trace_array *tr)

enum {

	TRACE_PIDS		= BIT(0),

	TRACE_NO_PIDS		= BIT(1),

};



static void clear_ftrace_pids(struct trace_array *tr, int type)

{

	struct trace_pid_list *pid_list;

	struct trace_pid_list *no_pid_list;

	int cpu;



	pid_list = rcu_dereference_protected(tr->function_pids,

					     lockdep_is_held(&ftrace_lock));

	if (!pid_list)

	no_pid_list = rcu_dereference_protected(tr->function_no_pids,

						lockdep_is_held(&ftrace_lock));



	/* Make sure there's something to do */

	if (!(((type & TRACE_PIDS) && pid_list) ||

	      ((type & TRACE_NO_PIDS) && no_pid_list)))

		return;



	/* See if the pids still need to be checked after this */

	if (!((!(type & TRACE_PIDS) && pid_list) ||

	      (!(type & TRACE_NO_PIDS) && no_pid_list))) {

		unregister_trace_sched_switch(ftrace_filter_pid_sched_switch_probe, tr);



		for_each_possible_cpu(cpu)

			per_cpu_ptr(tr->array_buffer.data, cpu)->ftrace_ignore_pid = FTRACE_PID_TRACE;

	}



	if (type & TRACE_PIDS)

		rcu_assign_pointer(tr->function_pids, NULL);



	if (type & TRACE_NO_PIDS)

		rcu_assign_pointer(tr->function_no_pids, NULL);



	/* Wait till all users are no longer using pid filtering */

	synchronize_rcu();



	if ((type & TRACE_PIDS) && pid_list)

		trace_free_pid_list(pid_list);



	if ((type & TRACE_NO_PIDS) && no_pid_list)

		trace_free_pid_list(no_pid_list);

}



void ftrace_clear_pids(struct trace_array *tr)

{

	mutex_lock(&ftrace_lock);



	clear_ftrace_pids(tr);

	clear_ftrace_pids(tr, TRACE_PIDS | TRACE_NO_PIDS);



	mutex_unlock(&ftrace_lock);

}



static void ftrace_pid_reset(struct trace_array *tr)

static void ftrace_pid_reset(struct trace_array *tr, int type)

{

	mutex_lock(&ftrace_lock);

	clear_ftrace_pids(tr);

	clear_ftrace_pids(tr, type);



	ftrace_update_pid_func();

	ftrace_startup_all(0);
@@ -7078,9 +7108,45 @@ static const struct seq_operations ftrace_pid_sops = { 
	.show = fpid_show,

};



static int

ftrace_pid_open(struct inode *inode, struct file *file)

static void *fnpid_start(struct seq_file *m, loff_t *pos)

	__acquires(RCU)

{

	struct trace_pid_list *pid_list;

	struct trace_array *tr = m->private;



	mutex_lock(&ftrace_lock);

	rcu_read_lock_sched();



	pid_list = rcu_dereference_sched(tr->function_no_pids);



	if (!pid_list)

		return !(*pos) ? FTRACE_NO_PIDS : NULL;



	return trace_pid_start(pid_list, pos);

}



static void *fnpid_next(struct seq_file *m, void *v, loff_t *pos)

{

	struct trace_array *tr = m->private;

	struct trace_pid_list *pid_list = rcu_dereference_sched(tr->function_no_pids);



	if (v == FTRACE_NO_PIDS) {

		(*pos)++;

		return NULL;

	}

	return trace_pid_next(pid_list, v, pos);

}



static const struct seq_operations ftrace_no_pid_sops = {

	.start = fnpid_start,

	.next = fnpid_next,

	.stop = fpid_stop,

	.show = fpid_show,

};



static int pid_open(struct inode *inode, struct file *file, int type)

{

	const struct seq_operations *seq_ops;

	struct trace_array *tr = inode->i_private;

	struct seq_file *m;

	int ret = 0;
@@ -7091,9 +7157,18 @@ ftrace_pid_open(struct inode *inode, struct file *file) 


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

	    (file->f_flags & O_TRUNC))

		ftrace_pid_reset(tr);

		ftrace_pid_reset(tr, type);



	switch (type) {

	case TRACE_PIDS:

		seq_ops = &ftrace_pid_sops;

		break;

	case TRACE_NO_PIDS:

		seq_ops = &ftrace_no_pid_sops;

		break;

	}



	ret = seq_open(file, &ftrace_pid_sops);

	ret = seq_open(file, seq_ops);

	if (ret < 0) {

		trace_array_put(tr);

	} else {
@@ -7105,10 +7180,23 @@ ftrace_pid_open(struct inode *inode, struct file *file) 
	return ret;

}



static int

ftrace_pid_open(struct inode *inode, struct file *file)

{

	return pid_open(inode, file, TRACE_PIDS);

}



static int

ftrace_no_pid_open(struct inode *inode, struct file *file)

{

	return pid_open(inode, file, TRACE_NO_PIDS);

}



static void ignore_task_cpu(void *data)

{

	struct trace_array *tr = data;

	struct trace_pid_list *pid_list;

	struct trace_pid_list *no_pid_list;



	/*

	 * This function is called by on_each_cpu() while the
@@ -7116,8 +7204,10 @@ static void ignore_task_cpu(void *data) 
	 */

	pid_list = rcu_dereference_protected(tr->function_pids,

					     mutex_is_locked(&ftrace_lock));

	no_pid_list = rcu_dereference_protected(tr->function_no_pids,

						mutex_is_locked(&ftrace_lock));



	if (trace_ignore_this_task(pid_list, current))

	if (trace_ignore_this_task(pid_list, no_pid_list, current))

		this_cpu_write(tr->array_buffer.data->ftrace_ignore_pid,

			       FTRACE_PID_IGNORE);

	else
@@ -7126,12 +7216,13 @@ static void ignore_task_cpu(void *data) 
}



static ssize_t

ftrace_pid_write(struct file *filp, const char __user *ubuf,

		   size_t cnt, loff_t *ppos)

pid_write(struct file *filp, const char __user *ubuf,

	  size_t cnt, loff_t *ppos, int type)

{

	struct seq_file *m = filp->private_data;

	struct trace_array *tr = m->private;

	struct trace_pid_list *filtered_pids = NULL;

	struct trace_pid_list *filtered_pids;

	struct trace_pid_list *other_pids;

	struct trace_pid_list *pid_list;

	ssize_t ret;
@@ -7140,19 +7231,39 @@ ftrace_pid_write(struct file *filp, const char __user *ubuf, 


	mutex_lock(&ftrace_lock);



	switch (type) {

	case TRACE_PIDS:

		filtered_pids = rcu_dereference_protected(tr->function_pids,

					     lockdep_is_held(&ftrace_lock));

		other_pids = rcu_dereference_protected(tr->function_no_pids,

					     lockdep_is_held(&ftrace_lock));

		break;

	case TRACE_NO_PIDS:

		filtered_pids = rcu_dereference_protected(tr->function_no_pids,

					     lockdep_is_held(&ftrace_lock));

		other_pids = rcu_dereference_protected(tr->function_pids,

					     lockdep_is_held(&ftrace_lock));

		break;

	}



	ret = trace_pid_write(filtered_pids, &pid_list, ubuf, cnt);

	if (ret < 0)

		goto out;



	switch (type) {

	case TRACE_PIDS:

		rcu_assign_pointer(tr->function_pids, pid_list);

		break;

	case TRACE_NO_PIDS:

		rcu_assign_pointer(tr->function_no_pids, pid_list);

		break;

	}





	if (filtered_pids) {

		synchronize_rcu();

		trace_free_pid_list(filtered_pids);

	} else if (pid_list) {

	} else if (pid_list && !other_pids) {

		/* Register a probe to set whether to ignore the tracing of a task */

		register_trace_sched_switch(ftrace_filter_pid_sched_switch_probe, tr);

	}
@@ -7175,6 +7286,20 @@ ftrace_pid_write(struct file *filp, const char __user *ubuf, 
	return ret;

}



static ssize_t

ftrace_pid_write(struct file *filp, const char __user *ubuf,

		 size_t cnt, loff_t *ppos)

{

	return pid_write(filp, ubuf, cnt, ppos, TRACE_PIDS);

}



static ssize_t

ftrace_no_pid_write(struct file *filp, const char __user *ubuf,

		    size_t cnt, loff_t *ppos)

{

	return pid_write(filp, ubuf, cnt, ppos, TRACE_NO_PIDS);

}



static int

ftrace_pid_release(struct inode *inode, struct file *file)

{
@@ -7193,10 +7318,20 @@ static const struct file_operations ftrace_pid_fops = { 
	.release	= ftrace_pid_release,

};



static const struct file_operations ftrace_no_pid_fops = {

	.open		= ftrace_no_pid_open,

	.write		= ftrace_no_pid_write,

	.read		= seq_read,

	.llseek		= tracing_lseek,

	.release	= ftrace_pid_release,

};



void ftrace_init_tracefs(struct trace_array *tr, struct dentry *d_tracer)

{

	trace_create_file("set_ftrace_pid", 0644, d_tracer,

			    tr, &ftrace_pid_fops);

	trace_create_file("set_ftrace_notrace_pid", 0644, d_tracer,

			    tr, &ftrace_no_pid_fops);

}



void __init ftrace_init_tracefs_toplevel(struct trace_array *tr,

kernel/trace/trace.c

+14 −6
Original line number Diff line number Diff line
@@ -386,16 +386,22 @@ trace_find_filtered_pid(struct trace_pid_list *filtered_pids, pid_t search_pid) 
 * Returns false if @task should be traced.

 */

bool

trace_ignore_this_task(struct trace_pid_list *filtered_pids, struct task_struct *task)

trace_ignore_this_task(struct trace_pid_list *filtered_pids,

		       struct trace_pid_list *filtered_no_pids,

		       struct task_struct *task)

{

	/*

	 * Return false, because if filtered_pids does not exist,

	 * all pids are good to trace.

	 * If filterd_no_pids is not empty, and the task's pid is listed

	 * in filtered_no_pids, then return true.

	 * Otherwise, if filtered_pids is empty, that means we can

	 * trace all tasks. If it has content, then only trace pids

	 * within filtered_pids.

	 */

	if (!filtered_pids)

		return false;



	return !trace_find_filtered_pid(filtered_pids, task->pid);

	return (filtered_pids &&

		!trace_find_filtered_pid(filtered_pids, task->pid)) ||

		(filtered_no_pids &&

		 trace_find_filtered_pid(filtered_no_pids, task->pid));

}



/**
@@ -5013,6 +5019,8 @@ static const char readme_msg[] = 
#ifdef CONFIG_FUNCTION_TRACER

	"  set_ftrace_pid\t- Write pid(s) to only function trace those pids\n"

	"\t\t    (function)\n"

	"  set_ftrace_notrace_pid\t- Write pid(s) to not function trace those pids\n"

	"\t\t    (function)\n"

#endif

#ifdef CONFIG_FUNCTION_GRAPH_TRACER

	"  set_graph_function\t- Trace the nested calls of a function (function_graph)\n"

kernel/trace/trace.h

+2 −0
Original line number Diff line number Diff line
@@ -331,6 +331,7 @@ struct trace_array { 
#ifdef CONFIG_FUNCTION_TRACER

	struct ftrace_ops	*ops;

	struct trace_pid_list	__rcu *function_pids;

	struct trace_pid_list	__rcu *function_no_pids;

#ifdef CONFIG_DYNAMIC_FTRACE

	/* All of these are protected by the ftrace_lock */

	struct list_head	func_probes;
@@ -782,6 +783,7 @@ extern int pid_max; 
bool trace_find_filtered_pid(struct trace_pid_list *filtered_pids,

			     pid_t search_pid);

bool trace_ignore_this_task(struct trace_pid_list *filtered_pids,

			    struct trace_pid_list *filtered_no_pids,

			    struct task_struct *task);

void trace_filter_add_remove_task(struct trace_pid_list *pid_list,

				  struct task_struct *self,

kernel/trace/trace_events.c

+6 −6
Original line number Diff line number Diff line
@@ -549,8 +549,8 @@ event_filter_pid_sched_switch_probe_pre(void *data, bool preempt, 
	pid_list = rcu_dereference_sched(tr->filtered_pids);



	this_cpu_write(tr->array_buffer.data->ignore_pid,

		       trace_ignore_this_task(pid_list, prev) &&

		       trace_ignore_this_task(pid_list, next));

		       trace_ignore_this_task(pid_list, NULL, prev) &&

		       trace_ignore_this_task(pid_list, NULL, next));

}



static void
@@ -563,7 +563,7 @@ event_filter_pid_sched_switch_probe_post(void *data, bool preempt, 
	pid_list = rcu_dereference_sched(tr->filtered_pids);



	this_cpu_write(tr->array_buffer.data->ignore_pid,

		       trace_ignore_this_task(pid_list, next));

		       trace_ignore_this_task(pid_list, NULL, next));

}



static void
@@ -579,7 +579,7 @@ event_filter_pid_sched_wakeup_probe_pre(void *data, struct task_struct *task) 
	pid_list = rcu_dereference_sched(tr->filtered_pids);



	this_cpu_write(tr->array_buffer.data->ignore_pid,

		       trace_ignore_this_task(pid_list, task));

		       trace_ignore_this_task(pid_list, NULL, task));

}



static void
@@ -596,7 +596,7 @@ event_filter_pid_sched_wakeup_probe_post(void *data, struct task_struct *task) 


	/* Set tracing if current is enabled */

	this_cpu_write(tr->array_buffer.data->ignore_pid,

		       trace_ignore_this_task(pid_list, current));

		       trace_ignore_this_task(pid_list, NULL, current));

}



static void __ftrace_clear_event_pids(struct trace_array *tr)
@@ -1597,7 +1597,7 @@ static void ignore_task_cpu(void *data) 
					     mutex_is_locked(&event_mutex));



	this_cpu_write(tr->array_buffer.data->ignore_pid,

		       trace_ignore_this_task(pid_list, current));

		       trace_ignore_this_task(pid_list, NULL, current));

}



static ssize_t

CRA Git | Maintained and supported by SUSTech CRA and CCSE