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

Commit 5d6ad960 authored by Steven Rostedt (Red Hat)'s avatar Steven Rostedt (Red Hat) Committed by Steven Rostedt
Browse files

tracing: Rename FTRACE_EVENT_FL_* flags to EVENT_FILE_FL_* 



The name "ftrace" really refers to the function hook infrastructure. It
is not about the trace_events. The FTRACE_EVENT_FL_* flags are flags to
do with the trace_event files in the tracefs directory. They are not related
to function tracing. Rename them to a more descriptive name.

Signed-off-by: default avatarSteven Rostedt <rostedt@goodmis.org>
parent 7967b3e0

include/linux/trace_events.h

+25 −25
Original line number Diff line number Diff line
@@ -250,11 +250,11 @@ enum { 
 *  FILTERED	  - The event has a filter attached

 *  CAP_ANY	  - Any user can enable for perf

 *  NO_SET_FILTER - Set when filter has error and is to be ignored

 *  IGNORE_ENABLE - For ftrace internal events, do not enable with debugfs file

 *  IGNORE_ENABLE - For trace internal events, do not enable with debugfs file

 *  WAS_ENABLED   - Set and stays set when an event was ever enabled

 *                    (used for module unloading, if a module event is enabled,

 *                     it is best to clear the buffers that used it).

 *  USE_CALL_FILTER - For ftrace internal events, don't use file filter

 *  USE_CALL_FILTER - For trace internal events, don't use file filter

 *  TRACEPOINT    - Event is a tracepoint

 *  KPROBE        - Event is a kprobe

 */
@@ -286,7 +286,7 @@ struct trace_event_call { 
	 *   bit 0:		filter_active

	 *   bit 1:		allow trace by non root (cap any)

	 *   bit 2:		failed to apply filter

	 *   bit 3:		ftrace internal event (do not enable)

	 *   bit 3:		trace internal event (do not enable)

	 *   bit 4:		Event was enabled by module

	 *   bit 5:		use call filter rather than file filter

	 *   bit 6:		Event is a tracepoint
@@ -316,18 +316,18 @@ struct trace_array; 
struct trace_subsystem_dir;



enum {

	FTRACE_EVENT_FL_ENABLED_BIT,

	FTRACE_EVENT_FL_RECORDED_CMD_BIT,

	FTRACE_EVENT_FL_FILTERED_BIT,

	FTRACE_EVENT_FL_NO_SET_FILTER_BIT,

	FTRACE_EVENT_FL_SOFT_MODE_BIT,

	FTRACE_EVENT_FL_SOFT_DISABLED_BIT,

	FTRACE_EVENT_FL_TRIGGER_MODE_BIT,

	FTRACE_EVENT_FL_TRIGGER_COND_BIT,

	EVENT_FILE_FL_ENABLED_BIT,

	EVENT_FILE_FL_RECORDED_CMD_BIT,

	EVENT_FILE_FL_FILTERED_BIT,

	EVENT_FILE_FL_NO_SET_FILTER_BIT,

	EVENT_FILE_FL_SOFT_MODE_BIT,

	EVENT_FILE_FL_SOFT_DISABLED_BIT,

	EVENT_FILE_FL_TRIGGER_MODE_BIT,

	EVENT_FILE_FL_TRIGGER_COND_BIT,

};



/*

 * Ftrace event file flags:

 * Event file flags:

 *  ENABLED	  - The event is enabled

 *  RECORDED_CMD  - The comms should be recorded at sched_switch

 *  FILTERED	  - The event has a filter attached
@@ -339,14 +339,14 @@ enum { 
 *  TRIGGER_COND  - When set, one or more triggers has an associated filter

 */

enum {

	FTRACE_EVENT_FL_ENABLED		= (1 << FTRACE_EVENT_FL_ENABLED_BIT),

	FTRACE_EVENT_FL_RECORDED_CMD	= (1 << FTRACE_EVENT_FL_RECORDED_CMD_BIT),

	FTRACE_EVENT_FL_FILTERED	= (1 << FTRACE_EVENT_FL_FILTERED_BIT),

	FTRACE_EVENT_FL_NO_SET_FILTER	= (1 << FTRACE_EVENT_FL_NO_SET_FILTER_BIT),

	FTRACE_EVENT_FL_SOFT_MODE	= (1 << FTRACE_EVENT_FL_SOFT_MODE_BIT),

	FTRACE_EVENT_FL_SOFT_DISABLED	= (1 << FTRACE_EVENT_FL_SOFT_DISABLED_BIT),

	FTRACE_EVENT_FL_TRIGGER_MODE	= (1 << FTRACE_EVENT_FL_TRIGGER_MODE_BIT),

	FTRACE_EVENT_FL_TRIGGER_COND	= (1 << FTRACE_EVENT_FL_TRIGGER_COND_BIT),

	EVENT_FILE_FL_ENABLED		= (1 << EVENT_FILE_FL_ENABLED_BIT),

	EVENT_FILE_FL_RECORDED_CMD	= (1 << EVENT_FILE_FL_RECORDED_CMD_BIT),

	EVENT_FILE_FL_FILTERED		= (1 << EVENT_FILE_FL_FILTERED_BIT),

	EVENT_FILE_FL_NO_SET_FILTER	= (1 << EVENT_FILE_FL_NO_SET_FILTER_BIT),

	EVENT_FILE_FL_SOFT_MODE		= (1 << EVENT_FILE_FL_SOFT_MODE_BIT),

	EVENT_FILE_FL_SOFT_DISABLED	= (1 << EVENT_FILE_FL_SOFT_DISABLED_BIT),

	EVENT_FILE_FL_TRIGGER_MODE	= (1 << EVENT_FILE_FL_TRIGGER_MODE_BIT),

	EVENT_FILE_FL_TRIGGER_COND	= (1 << EVENT_FILE_FL_TRIGGER_COND_BIT),

};



struct trace_event_file {
@@ -439,10 +439,10 @@ ftrace_trigger_soft_disabled(struct trace_event_file *file) 
{

	unsigned long eflags = file->flags;



	if (!(eflags & FTRACE_EVENT_FL_TRIGGER_COND)) {

		if (eflags & FTRACE_EVENT_FL_TRIGGER_MODE)

	if (!(eflags & EVENT_FILE_FL_TRIGGER_COND)) {

		if (eflags & EVENT_FILE_FL_TRIGGER_MODE)

			event_triggers_call(file, NULL);

		if (eflags & FTRACE_EVENT_FL_SOFT_DISABLED)

		if (eflags & EVENT_FILE_FL_SOFT_DISABLED)

			return true;

	}

	return false;
@@ -470,10 +470,10 @@ __event_trigger_test_discard(struct trace_event_file *file, 
{

	unsigned long eflags = file->flags;



	if (eflags & FTRACE_EVENT_FL_TRIGGER_COND)

	if (eflags & EVENT_FILE_FL_TRIGGER_COND)

		*tt = event_triggers_call(file, entry);



	if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags))

	if (test_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags))

		ring_buffer_discard_commit(buffer, event);

	else if (!filter_check_discard(file, entry, buffer, event))

		return false;

include/trace/perf.h

+5 −5
Original line number Diff line number Diff line
@@ -21,10 +21,10 @@ 
 *	int __data_size;

 *	int pc;

 *

 *	if (!(eflags & FTRACE_EVENT_FL_TRIGGER_COND)) {

 *		if (eflags & FTRACE_EVENT_FL_TRIGGER_MODE)

 *	if (!(eflags & EVENT_FILE_FL_TRIGGER_COND)) {

 *		if (eflags & EVENT_FILE_FL_TRIGGER_MODE)

 *			event_triggers_call(trace_file, NULL);

 *		if (eflags & FTRACE_EVENT_FL_SOFT_DISABLED)

 *		if (eflags & EVENT_FILE_FL_SOFT_DISABLED)

 *			return;

 *	}

 *
@@ -44,10 +44,10 @@ 
 *	{ <assign>; }  <-- Here we assign the entries by the __field and

 *			   __array macros.

 *

 *	if (eflags & FTRACE_EVENT_FL_TRIGGER_COND)

 *	if (eflags & EVENT_FILE_FL_TRIGGER_COND)

 *		__tt = event_triggers_call(trace_file, entry);

 *

 *	if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT,

 *	if (test_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT,

 *		     &trace_file->flags))

 *		ring_buffer_discard_commit(buffer, event);

 *	else if (!filter_check_discard(trace_file, entry, buffer, event))

kernel/trace/trace.c

+2 −2
Original line number Diff line number Diff line
@@ -301,7 +301,7 @@ int filter_check_discard(struct trace_event_file *file, void *rec, 
			 struct ring_buffer *buffer,

			 struct ring_buffer_event *event)

{

	if (unlikely(file->flags & FTRACE_EVENT_FL_FILTERED) &&

	if (unlikely(file->flags & EVENT_FILE_FL_FILTERED) &&

	    !filter_match_preds(file->filter, rec)) {

		ring_buffer_discard_commit(buffer, event);

		return 1;
@@ -1709,7 +1709,7 @@ trace_event_buffer_lock_reserve(struct ring_buffer **current_rb, 
	 * to store the trace event for the tigger to use. It's recusive

	 * safe and will not be recorded anywhere.

	 */

	if (!entry && trace_file->flags & FTRACE_EVENT_FL_TRIGGER_COND) {

	if (!entry && trace_file->flags & EVENT_FILE_FL_TRIGGER_COND) {

		*current_rb = temp_buffer;

		entry = trace_buffer_lock_reserve(*current_rb,

						  type, len, flags, pc);

kernel/trace/trace_events.c

+31 −31
Original line number Diff line number Diff line
@@ -298,15 +298,15 @@ void trace_event_enable_cmd_record(bool enable) 
	mutex_lock(&event_mutex);

	do_for_each_event_file(tr, file) {



		if (!(file->flags & FTRACE_EVENT_FL_ENABLED))

		if (!(file->flags & EVENT_FILE_FL_ENABLED))

			continue;



		if (enable) {

			tracing_start_cmdline_record();

			set_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);

			set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);

		} else {

			tracing_stop_cmdline_record();

			clear_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);

			clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);

		}

	} while_for_each_event_file();

	mutex_unlock(&event_mutex);
@@ -337,24 +337,24 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file, 
		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);

			disable = file->flags & EVENT_FILE_FL_SOFT_DISABLED;

			clear_bit(EVENT_FILE_FL_SOFT_MODE_BIT, &file->flags);

		} else

			disable = !(file->flags & FTRACE_EVENT_FL_SOFT_MODE);

			disable = !(file->flags & EVENT_FILE_FL_SOFT_MODE);



		if (disable && (file->flags & FTRACE_EVENT_FL_ENABLED)) {

			clear_bit(FTRACE_EVENT_FL_ENABLED_BIT, &file->flags);

			if (file->flags & FTRACE_EVENT_FL_RECORDED_CMD) {

		if (disable && (file->flags & EVENT_FILE_FL_ENABLED)) {

			clear_bit(EVENT_FILE_FL_ENABLED_BIT, &file->flags);

			if (file->flags & EVENT_FILE_FL_RECORDED_CMD) {

				tracing_stop_cmdline_record();

				clear_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);

				clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);

			}

			call->class->reg(call, TRACE_REG_UNREGISTER, file);

		}

		/* If in SOFT_MODE, just set the SOFT_DISABLE_BIT, else clear it */

		if (file->flags & FTRACE_EVENT_FL_SOFT_MODE)

			set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);

		if (file->flags & EVENT_FILE_FL_SOFT_MODE)

			set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);

		else

			clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);

			clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);

		break;

	case 1:

		/*
@@ -366,22 +366,22 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file, 
		 * it still seems to be disabled.

		 */

		if (!soft_disable)

			clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);

			clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);

		else {

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

				break;

			set_bit(FTRACE_EVENT_FL_SOFT_MODE_BIT, &file->flags);

			set_bit(EVENT_FILE_FL_SOFT_MODE_BIT, &file->flags);

		}



		if (!(file->flags & FTRACE_EVENT_FL_ENABLED)) {

		if (!(file->flags & EVENT_FILE_FL_ENABLED)) {



			/* Keep the event disabled, when going to SOFT_MODE. */

			if (soft_disable)

				set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);

				set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);



			if (trace_flags & TRACE_ITER_RECORD_CMD) {

				tracing_start_cmdline_record();

				set_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);

				set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);

			}

			ret = call->class->reg(call, TRACE_REG_REGISTER, file);

			if (ret) {
@@ -390,7 +390,7 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file, 
					"%s\n", trace_event_name(call));

				break;

			}

			set_bit(FTRACE_EVENT_FL_ENABLED_BIT, &file->flags);

			set_bit(EVENT_FILE_FL_ENABLED_BIT, &file->flags);



			/* WAS_ENABLED gets set but never cleared. */

			call->flags |= TRACE_EVENT_FL_WAS_ENABLED;
@@ -716,7 +716,7 @@ s_next(struct seq_file *m, void *v, loff_t *pos) 
	(*pos)++;



	list_for_each_entry_continue(file, &tr->events, list) {

		if (file->flags & FTRACE_EVENT_FL_ENABLED)

		if (file->flags & EVENT_FILE_FL_ENABLED)

			return file;

	}
@@ -774,12 +774,12 @@ event_enable_read(struct file *filp, char __user *ubuf, size_t cnt, 
	if (!file)

		return -ENODEV;



	if (flags & FTRACE_EVENT_FL_ENABLED &&

	    !(flags & FTRACE_EVENT_FL_SOFT_DISABLED))

	if (flags & EVENT_FILE_FL_ENABLED &&

	    !(flags & EVENT_FILE_FL_SOFT_DISABLED))

		strcpy(buf, "1");



	if (flags & FTRACE_EVENT_FL_SOFT_DISABLED ||

	    flags & FTRACE_EVENT_FL_SOFT_MODE)

	if (flags & EVENT_FILE_FL_SOFT_DISABLED ||

	    flags & EVENT_FILE_FL_SOFT_MODE)

		strcat(buf, "*");



	strcat(buf, "\n");
@@ -851,7 +851,7 @@ system_enable_read(struct file *filp, char __user *ubuf, size_t cnt, 
		 * or if all events or cleared, or if we have

		 * a mixture.

		 */

		set |= (1 << !!(file->flags & FTRACE_EVENT_FL_ENABLED));

		set |= (1 << !!(file->flags & EVENT_FILE_FL_ENABLED));



		/*

		 * If we have a mixture, no need to look further.
@@ -1932,10 +1932,10 @@ static int probe_remove_event_call(struct trace_event_call *call) 
			continue;

		/*

		 * We can't rely on ftrace_event_enable_disable(enable => 0)

		 * we are going to do, FTRACE_EVENT_FL_SOFT_MODE can suppress

		 * we are going to do, EVENT_FILE_FL_SOFT_MODE can suppress

		 * TRACE_REG_UNREGISTER.

		 */

		if (file->flags & FTRACE_EVENT_FL_ENABLED)

		if (file->flags & EVENT_FILE_FL_ENABLED)

			return -EBUSY;

		/*

		 * The do_for_each_event_file_safe() is
@@ -2114,9 +2114,9 @@ event_enable_probe(unsigned long ip, unsigned long parent_ip, void **_data) 
		return;



	if (data->enable)

		clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &data->file->flags);

		clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &data->file->flags);

	else

		set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &data->file->flags);

		set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &data->file->flags);

}



static void
@@ -2132,7 +2132,7 @@ event_enable_count_probe(unsigned long ip, unsigned long parent_ip, void **_data 
		return;



	/* Skip if the event is in a state we want to switch to */

	if (data->enable == !(data->file->flags & FTRACE_EVENT_FL_SOFT_DISABLED))

	if (data->enable == !(data->file->flags & EVENT_FILE_FL_SOFT_DISABLED))

		return;



	if (data->count != -1)
@@ -2793,7 +2793,7 @@ static __init void event_trace_self_tests(void) 
		 * If an event is already enabled, someone is using

		 * it and the self test should not be on.

		 */

		if (file->flags & FTRACE_EVENT_FL_ENABLED) {

		if (file->flags & EVENT_FILE_FL_ENABLED) {

			pr_warn("Enabled event during self test!\n");

			WARN_ON_ONCE(1);

			continue;

kernel/trace/trace_events_filter.c

+5 −5
Original line number Diff line number Diff line
@@ -787,7 +787,7 @@ static void filter_disable(struct trace_event_file *file) 
	if (call->flags & TRACE_EVENT_FL_USE_CALL_FILTER)

		call->flags &= ~TRACE_EVENT_FL_FILTERED;

	else

		file->flags &= ~FTRACE_EVENT_FL_FILTERED;

		file->flags &= ~EVENT_FILE_FL_FILTERED;

}



static void __free_filter(struct event_filter *filter)
@@ -1669,7 +1669,7 @@ static inline void event_set_filtered_flag(struct trace_event_file *file) 
	if (call->flags & TRACE_EVENT_FL_USE_CALL_FILTER)

		call->flags |= TRACE_EVENT_FL_FILTERED;

	else

		file->flags |= FTRACE_EVENT_FL_FILTERED;

		file->flags |= EVENT_FILE_FL_FILTERED;

}



static inline void event_set_filter(struct trace_event_file *file,
@@ -1701,7 +1701,7 @@ event_set_no_set_filter_flag(struct trace_event_file *file) 
	if (call->flags & TRACE_EVENT_FL_USE_CALL_FILTER)

		call->flags |= TRACE_EVENT_FL_NO_SET_FILTER;

	else

		file->flags |= FTRACE_EVENT_FL_NO_SET_FILTER;

		file->flags |= EVENT_FILE_FL_NO_SET_FILTER;

}



static inline void
@@ -1712,7 +1712,7 @@ event_clear_no_set_filter_flag(struct trace_event_file *file) 
	if (call->flags & TRACE_EVENT_FL_USE_CALL_FILTER)

		call->flags &= ~TRACE_EVENT_FL_NO_SET_FILTER;

	else

		file->flags &= ~FTRACE_EVENT_FL_NO_SET_FILTER;

		file->flags &= ~EVENT_FILE_FL_NO_SET_FILTER;

}



static inline bool
@@ -1720,7 +1720,7 @@ event_no_set_filter_flag(struct trace_event_file *file) 
{

	struct trace_event_call *call = file->event_call;



	if (file->flags & FTRACE_EVENT_FL_NO_SET_FILTER)

	if (file->flags & EVENT_FILE_FL_NO_SET_FILTER)

		return true;



	if ((call->flags & TRACE_EVENT_FL_USE_CALL_FILTER) &&