Commit 2f294c35 authored by Steven Rostedt's avatar Steven Rostedt Committed by Steven Rostedt (Google)
Browse files

Merge branch 'topic/func-profiler-offset' of... 

Merge branch 'topic/func-profiler-offset' of git://git.kernel.org/pub/scm/linux/kernel/git/mhiramat/linux

 into trace/trace/core

Updates to the function profiler adds new options to tracefs. The options
are currently defined by an enum as flags. The added options brings the
number of options over 32, which means they can no longer be held in a 32
bit enum. The TRACE_ITER_* flags are converted to a macro TRACE_ITER(*) to
allow the creation of options to still be done by macros.

This change is intrusive, as it affects all TRACE_ITER* options throughout
the trace code. Merge the branch that added these options and converted
the TRACE_ITER_* enum into a TRACE_ITER(*) macro, to allow the topic
branches to still be developed without conflict.

Signed-off-by: default avatarSteven Rostedt (Google) <rostedt@goodmis.org>
parents 25bd47a5 1149fcf7

kernel/trace/blktrace.c

+3 −3
Original line number Diff line number Diff line
@@ -1452,7 +1452,7 @@ static enum print_line_t print_one_line(struct trace_iterator *iter, 


	t	   = te_blk_io_trace(iter->ent);

	what	   = (t->action & ((1 << BLK_TC_SHIFT) - 1)) & ~__BLK_TA_CGROUP;

	long_act   = !!(tr->trace_flags & TRACE_ITER_VERBOSE);

	long_act   = !!(tr->trace_flags & TRACE_ITER(VERBOSE));

	log_action = classic ? &blk_log_action_classic : &blk_log_action;

	has_cg	   = t->action & __BLK_TA_CGROUP;
@@ -1517,9 +1517,9 @@ blk_tracer_set_flag(struct trace_array *tr, u32 old_flags, u32 bit, int set) 
	/* don't output context-info for blk_classic output */

	if (bit == TRACE_BLK_OPT_CLASSIC) {

		if (set)

			tr->trace_flags &= ~TRACE_ITER_CONTEXT_INFO;

			tr->trace_flags &= ~TRACE_ITER(CONTEXT_INFO);

		else

			tr->trace_flags |= TRACE_ITER_CONTEXT_INFO;

			tr->trace_flags |= TRACE_ITER(CONTEXT_INFO);

	}

	return 0;

}

kernel/trace/ftrace.c

+25 −1
Original line number Diff line number Diff line
@@ -534,7 +534,9 @@ static int function_stat_headers(struct seq_file *m) 


static int function_stat_show(struct seq_file *m, void *v)

{

	struct trace_array *tr = trace_get_global_array();

	struct ftrace_profile *rec = v;

	const char *refsymbol = NULL;

	char str[KSYM_SYMBOL_LEN];

#ifdef CONFIG_FUNCTION_GRAPH_TRACER

	static struct trace_seq s;
@@ -554,7 +556,29 @@ static int function_stat_show(struct seq_file *m, void *v) 
		return 0;

#endif



	if (tr->trace_flags & TRACE_ITER(PROF_TEXT_OFFSET)) {

		unsigned long offset;



		if (core_kernel_text(rec->ip)) {

			refsymbol = "_text";

			offset = rec->ip - (unsigned long)_text;

		} else {

			struct module *mod;



			guard(rcu)();

			mod = __module_text_address(rec->ip);

			if (mod) {

				refsymbol = mod->name;

				/* Calculate offset from module's text entry address. */

				offset = rec->ip - (unsigned long)mod->mem[MOD_TEXT].base;

			}

		}

		if (refsymbol)

			snprintf(str, sizeof(str), "  %s+%#lx", refsymbol, offset);

	}

	if (!refsymbol)

		kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);



	seq_printf(m, "  %-30.30s  %10lu", str, rec->counter);



#ifdef CONFIG_FUNCTION_GRAPH_TRACER

kernel/trace/trace.c

+78 −76
Original line number Diff line number Diff line
@@ -514,21 +514,22 @@ EXPORT_SYMBOL_GPL(unregister_ftrace_export); 
/* trace_flags holds trace_options default values */

#define TRACE_DEFAULT_FLAGS						\

	(FUNCTION_DEFAULT_FLAGS |					\

	 TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |			\

	 TRACE_ITER_ANNOTATE | TRACE_ITER_CONTEXT_INFO |		\

	 TRACE_ITER_RECORD_CMD | TRACE_ITER_OVERWRITE |			\

	 TRACE_ITER_IRQ_INFO | TRACE_ITER_MARKERS |			\

	 TRACE_ITER_HASH_PTR | TRACE_ITER_TRACE_PRINTK |		\

	 TRACE_ITER_COPY_MARKER)

	 TRACE_ITER(PRINT_PARENT) | TRACE_ITER(PRINTK) |			\

	 TRACE_ITER(ANNOTATE) | TRACE_ITER(CONTEXT_INFO) |		\

	 TRACE_ITER(RECORD_CMD) | TRACE_ITER(OVERWRITE) |			\

	 TRACE_ITER(IRQ_INFO) | TRACE_ITER(MARKERS) |			\

	 TRACE_ITER(HASH_PTR) | TRACE_ITER(TRACE_PRINTK) |		\

	 TRACE_ITER(COPY_MARKER))



/* trace_options that are only supported by global_trace */

#define TOP_LEVEL_TRACE_FLAGS (TRACE_ITER_PRINTK |			\

	       TRACE_ITER_PRINTK_MSGONLY | TRACE_ITER_RECORD_CMD)

#define TOP_LEVEL_TRACE_FLAGS (TRACE_ITER(PRINTK) |			\

	       TRACE_ITER(PRINTK_MSGONLY) | TRACE_ITER(RECORD_CMD) |	\

	       TRACE_ITER(PROF_TEXT_OFFSET))



/* trace_flags that are default zero for instances */

#define ZEROED_TRACE_FLAGS \

	(TRACE_ITER_EVENT_FORK | TRACE_ITER_FUNC_FORK | TRACE_ITER_TRACE_PRINTK | \

	 TRACE_ITER_COPY_MARKER)

	(TRACE_ITER(EVENT_FORK) | TRACE_ITER(FUNC_FORK) | TRACE_ITER(TRACE_PRINTK) | \

	 TRACE_ITER(COPY_MARKER))



/*

 * The global_trace is the descriptor that holds the top-level tracing
@@ -559,9 +560,9 @@ static void update_printk_trace(struct trace_array *tr) 
	if (printk_trace == tr)

		return;



	printk_trace->trace_flags &= ~TRACE_ITER_TRACE_PRINTK;

	printk_trace->trace_flags &= ~TRACE_ITER(TRACE_PRINTK);

	printk_trace = tr;

	tr->trace_flags |= TRACE_ITER_TRACE_PRINTK;

	tr->trace_flags |= TRACE_ITER(TRACE_PRINTK);

}



/* Returns true if the status of tr changed */
@@ -574,7 +575,7 @@ static bool update_marker_trace(struct trace_array *tr, int enabled) 
			return false;



		list_add_rcu(&tr->marker_list, &marker_copies);

		tr->trace_flags |= TRACE_ITER_COPY_MARKER;

		tr->trace_flags |= TRACE_ITER(COPY_MARKER);

		return true;

	}
@@ -582,7 +583,7 @@ static bool update_marker_trace(struct trace_array *tr, int enabled) 
		return false;



	list_del_init(&tr->marker_list);

	tr->trace_flags &= ~TRACE_ITER_COPY_MARKER;

	tr->trace_flags &= ~TRACE_ITER(COPY_MARKER);

	return true;

}
@@ -1140,7 +1141,7 @@ int __trace_array_puts(struct trace_array *tr, unsigned long ip, 
	unsigned int trace_ctx;

	int alloc;



	if (!(tr->trace_flags & TRACE_ITER_PRINTK))

	if (!(tr->trace_flags & TRACE_ITER(PRINTK)))

		return 0;



	if (unlikely(tracing_selftest_running && tr == &global_trace))
@@ -1206,7 +1207,7 @@ int __trace_bputs(unsigned long ip, const char *str) 
	if (!printk_binsafe(tr))

		return __trace_puts(ip, str, strlen(str));



	if (!(tr->trace_flags & TRACE_ITER_PRINTK))

	if (!(tr->trace_flags & TRACE_ITER(PRINTK)))

		return 0;



	if (unlikely(tracing_selftest_running || tracing_disabled))
@@ -3079,7 +3080,7 @@ static inline void ftrace_trace_stack(struct trace_array *tr, 
				      unsigned int trace_ctx,

				      int skip, struct pt_regs *regs)

{

	if (!(tr->trace_flags & TRACE_ITER_STACKTRACE))

	if (!(tr->trace_flags & TRACE_ITER(STACKTRACE)))

		return;



	__ftrace_trace_stack(tr, buffer, trace_ctx, skip, regs);
@@ -3140,7 +3141,7 @@ ftrace_trace_userstack(struct trace_array *tr, 
	struct ring_buffer_event *event;

	struct userstack_entry *entry;



	if (!(tr->trace_flags & TRACE_ITER_USERSTACKTRACE))

	if (!(tr->trace_flags & TRACE_ITER(USERSTACKTRACE)))

		return;



	/*
@@ -3485,7 +3486,7 @@ int trace_array_printk(struct trace_array *tr, 
	if (tr == &global_trace)

		return 0;



	if (!(tr->trace_flags & TRACE_ITER_PRINTK))

	if (!(tr->trace_flags & TRACE_ITER(PRINTK)))

		return 0;



	va_start(ap, fmt);
@@ -3522,7 +3523,7 @@ int trace_array_printk_buf(struct trace_buffer *buffer, 
	int ret;

	va_list ap;



	if (!(printk_trace->trace_flags & TRACE_ITER_PRINTK))

	if (!(printk_trace->trace_flags & TRACE_ITER(PRINTK)))

		return 0;



	va_start(ap, fmt);
@@ -3792,7 +3793,7 @@ const char *trace_event_format(struct trace_iterator *iter, const char *fmt) 
	if (WARN_ON_ONCE(!fmt))

		return fmt;



	if (!iter->tr || iter->tr->trace_flags & TRACE_ITER_HASH_PTR)

	if (!iter->tr || iter->tr->trace_flags & TRACE_ITER(HASH_PTR))

		return fmt;



	p = fmt;
@@ -4114,7 +4115,7 @@ static void print_event_info(struct array_buffer *buf, struct seq_file *m) 
static void print_func_help_header(struct array_buffer *buf, struct seq_file *m,

				   unsigned int flags)

{

	bool tgid = flags & TRACE_ITER_RECORD_TGID;

	bool tgid = flags & TRACE_ITER(RECORD_TGID);



	print_event_info(buf, m);
@@ -4125,7 +4126,7 @@ static void print_func_help_header(struct array_buffer *buf, struct seq_file *m, 
static void print_func_help_header_irq(struct array_buffer *buf, struct seq_file *m,

				       unsigned int flags)

{

	bool tgid = flags & TRACE_ITER_RECORD_TGID;

	bool tgid = flags & TRACE_ITER(RECORD_TGID);

	static const char space[] = "            ";

	int prec = tgid ? 12 : 2;
@@ -4198,7 +4199,7 @@ static void test_cpu_buff_start(struct trace_iterator *iter) 
	struct trace_seq *s = &iter->seq;

	struct trace_array *tr = iter->tr;



	if (!(tr->trace_flags & TRACE_ITER_ANNOTATE))

	if (!(tr->trace_flags & TRACE_ITER(ANNOTATE)))

		return;



	if (!(iter->iter_flags & TRACE_FILE_ANNOTATE))
@@ -4250,7 +4251,7 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter) 


	event = ftrace_find_event(entry->type);



	if (tr->trace_flags & TRACE_ITER_CONTEXT_INFO) {

	if (tr->trace_flags & TRACE_ITER(CONTEXT_INFO)) {

		if (iter->iter_flags & TRACE_FILE_LAT_FMT)

			trace_print_lat_context(iter);

		else
@@ -4261,7 +4262,7 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter) 
		return TRACE_TYPE_PARTIAL_LINE;



	if (event) {

		if (tr->trace_flags & TRACE_ITER_FIELDS)

		if (tr->trace_flags & TRACE_ITER(FIELDS))

			return print_event_fields(iter, event);

		/*

		 * For TRACE_EVENT() events, the print_fmt is not
@@ -4291,7 +4292,7 @@ static enum print_line_t print_raw_fmt(struct trace_iterator *iter) 


	entry = iter->ent;



	if (tr->trace_flags & TRACE_ITER_CONTEXT_INFO)

	if (tr->trace_flags & TRACE_ITER(CONTEXT_INFO))

		trace_seq_printf(s, "%d %d %llu ",

				 entry->pid, iter->cpu, iter->ts);
@@ -4317,7 +4318,7 @@ static enum print_line_t print_hex_fmt(struct trace_iterator *iter) 


	entry = iter->ent;



	if (tr->trace_flags & TRACE_ITER_CONTEXT_INFO) {

	if (tr->trace_flags & TRACE_ITER(CONTEXT_INFO)) {

		SEQ_PUT_HEX_FIELD(s, entry->pid);

		SEQ_PUT_HEX_FIELD(s, iter->cpu);

		SEQ_PUT_HEX_FIELD(s, iter->ts);
@@ -4346,7 +4347,7 @@ static enum print_line_t print_bin_fmt(struct trace_iterator *iter) 


	entry = iter->ent;



	if (tr->trace_flags & TRACE_ITER_CONTEXT_INFO) {

	if (tr->trace_flags & TRACE_ITER(CONTEXT_INFO)) {

		SEQ_PUT_FIELD(s, entry->pid);

		SEQ_PUT_FIELD(s, iter->cpu);

		SEQ_PUT_FIELD(s, iter->ts);
@@ -4417,27 +4418,27 @@ enum print_line_t print_trace_line(struct trace_iterator *iter) 
	}



	if (iter->ent->type == TRACE_BPUTS &&

			trace_flags & TRACE_ITER_PRINTK &&

			trace_flags & TRACE_ITER_PRINTK_MSGONLY)

			trace_flags & TRACE_ITER(PRINTK) &&

			trace_flags & TRACE_ITER(PRINTK_MSGONLY))

		return trace_print_bputs_msg_only(iter);



	if (iter->ent->type == TRACE_BPRINT &&

			trace_flags & TRACE_ITER_PRINTK &&

			trace_flags & TRACE_ITER_PRINTK_MSGONLY)

			trace_flags & TRACE_ITER(PRINTK) &&

			trace_flags & TRACE_ITER(PRINTK_MSGONLY))

		return trace_print_bprintk_msg_only(iter);



	if (iter->ent->type == TRACE_PRINT &&

			trace_flags & TRACE_ITER_PRINTK &&

			trace_flags & TRACE_ITER_PRINTK_MSGONLY)

			trace_flags & TRACE_ITER(PRINTK) &&

			trace_flags & TRACE_ITER(PRINTK_MSGONLY))

		return trace_print_printk_msg_only(iter);



	if (trace_flags & TRACE_ITER_BIN)

	if (trace_flags & TRACE_ITER(BIN))

		return print_bin_fmt(iter);



	if (trace_flags & TRACE_ITER_HEX)

	if (trace_flags & TRACE_ITER(HEX))

		return print_hex_fmt(iter);



	if (trace_flags & TRACE_ITER_RAW)

	if (trace_flags & TRACE_ITER(RAW))

		return print_raw_fmt(iter);



	return print_trace_fmt(iter);
@@ -4455,7 +4456,7 @@ void trace_latency_header(struct seq_file *m) 
	if (iter->iter_flags & TRACE_FILE_LAT_FMT)

		print_trace_header(m, iter);



	if (!(tr->trace_flags & TRACE_ITER_VERBOSE))

	if (!(tr->trace_flags & TRACE_ITER(VERBOSE)))

		print_lat_help_header(m);

}
@@ -4465,7 +4466,7 @@ void trace_default_header(struct seq_file *m) 
	struct trace_array *tr = iter->tr;

	unsigned long trace_flags = tr->trace_flags;



	if (!(trace_flags & TRACE_ITER_CONTEXT_INFO))

	if (!(trace_flags & TRACE_ITER(CONTEXT_INFO)))

		return;



	if (iter->iter_flags & TRACE_FILE_LAT_FMT) {
@@ -4473,11 +4474,11 @@ void trace_default_header(struct seq_file *m) 
		if (trace_empty(iter))

			return;

		print_trace_header(m, iter);

		if (!(trace_flags & TRACE_ITER_VERBOSE))

		if (!(trace_flags & TRACE_ITER(VERBOSE)))

			print_lat_help_header(m);

	} else {

		if (!(trace_flags & TRACE_ITER_VERBOSE)) {

			if (trace_flags & TRACE_ITER_IRQ_INFO)

		if (!(trace_flags & TRACE_ITER(VERBOSE))) {

			if (trace_flags & TRACE_ITER(IRQ_INFO))

				print_func_help_header_irq(iter->array_buffer,

							   m, trace_flags);

			else
@@ -4701,7 +4702,7 @@ __tracing_open(struct inode *inode, struct file *file, bool snapshot) 
	 * If pause-on-trace is enabled, then stop the trace while

	 * dumping, unless this is the "snapshot" file

	 */

	if (!iter->snapshot && (tr->trace_flags & TRACE_ITER_PAUSE_ON_TRACE))

	if (!iter->snapshot && (tr->trace_flags & TRACE_ITER(PAUSE_ON_TRACE)))

		tracing_stop_tr(tr);



	if (iter->cpu_file == RING_BUFFER_ALL_CPUS) {
@@ -4895,7 +4896,7 @@ static int tracing_open(struct inode *inode, struct file *file) 
		iter = __tracing_open(inode, file, false);

		if (IS_ERR(iter))

			ret = PTR_ERR(iter);

		else if (tr->trace_flags & TRACE_ITER_LATENCY_FMT)

		else if (tr->trace_flags & TRACE_ITER(LATENCY_FMT))

			iter->iter_flags |= TRACE_FILE_LAT_FMT;

	}
@@ -5167,7 +5168,7 @@ static int tracing_trace_options_show(struct seq_file *m, void *v) 
	trace_opts = tr->current_trace->flags->opts;



	for (i = 0; trace_options[i]; i++) {

		if (tr->trace_flags & (1 << i))

		if (tr->trace_flags & (1ULL << i))

			seq_printf(m, "%s\n", trace_options[i]);

		else

			seq_printf(m, "no%s\n", trace_options[i]);
@@ -5220,20 +5221,20 @@ static int set_tracer_option(struct trace_array *tr, char *cmp, int neg) 
}



/* Some tracers require overwrite to stay enabled */

int trace_keep_overwrite(struct tracer *tracer, u32 mask, int set)

int trace_keep_overwrite(struct tracer *tracer, u64 mask, int set)

{

	if (tracer->enabled && (mask & TRACE_ITER_OVERWRITE) && !set)

	if (tracer->enabled && (mask & TRACE_ITER(OVERWRITE)) && !set)

		return -1;



	return 0;

}



int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled)

int set_tracer_flag(struct trace_array *tr, u64 mask, int enabled)

{

	if ((mask == TRACE_ITER_RECORD_TGID) ||

	    (mask == TRACE_ITER_RECORD_CMD) ||

	    (mask == TRACE_ITER_TRACE_PRINTK) ||

	    (mask == TRACE_ITER_COPY_MARKER))

	if ((mask == TRACE_ITER(RECORD_TGID)) ||

	    (mask == TRACE_ITER(RECORD_CMD)) ||

	    (mask == TRACE_ITER(TRACE_PRINTK)) ||

	    (mask == TRACE_ITER(COPY_MARKER)))

		lockdep_assert_held(&event_mutex);



	/* do nothing if flag is already set */
@@ -5245,7 +5246,7 @@ int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled) 
		if (tr->current_trace->flag_changed(tr, mask, !!enabled))

			return -EINVAL;



	if (mask == TRACE_ITER_TRACE_PRINTK) {

	if (mask == TRACE_ITER(TRACE_PRINTK)) {

		if (enabled) {

			update_printk_trace(tr);

		} else {
@@ -5264,7 +5265,7 @@ int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled) 
		}

	}



	if (mask == TRACE_ITER_COPY_MARKER)

	if (mask == TRACE_ITER(COPY_MARKER))

		update_marker_trace(tr, enabled);



	if (enabled)
@@ -5272,33 +5273,33 @@ int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled) 
	else

		tr->trace_flags &= ~mask;



	if (mask == TRACE_ITER_RECORD_CMD)

	if (mask == TRACE_ITER(RECORD_CMD))

		trace_event_enable_cmd_record(enabled);



	if (mask == TRACE_ITER_RECORD_TGID) {

	if (mask == TRACE_ITER(RECORD_TGID)) {



		if (trace_alloc_tgid_map() < 0) {

			tr->trace_flags &= ~TRACE_ITER_RECORD_TGID;

			tr->trace_flags &= ~TRACE_ITER(RECORD_TGID);

			return -ENOMEM;

		}



		trace_event_enable_tgid_record(enabled);

	}



	if (mask == TRACE_ITER_EVENT_FORK)

	if (mask == TRACE_ITER(EVENT_FORK))

		trace_event_follow_fork(tr, enabled);



	if (mask == TRACE_ITER_FUNC_FORK)

	if (mask == TRACE_ITER(FUNC_FORK))

		ftrace_pid_follow_fork(tr, enabled);



	if (mask == TRACE_ITER_OVERWRITE) {

	if (mask == TRACE_ITER(OVERWRITE)) {

		ring_buffer_change_overwrite(tr->array_buffer.buffer, enabled);

#ifdef CONFIG_TRACER_MAX_TRACE

		ring_buffer_change_overwrite(tr->max_buffer.buffer, enabled);

#endif

	}



	if (mask == TRACE_ITER_PRINTK) {

	if (mask == TRACE_ITER(PRINTK)) {

		trace_printk_start_stop_comm(enabled);

		trace_printk_control(enabled);

	}
@@ -5330,7 +5331,7 @@ int trace_set_options(struct trace_array *tr, char *option) 
	if (ret < 0)

		ret = set_tracer_option(tr, cmp, neg);

	else

		ret = set_tracer_flag(tr, 1 << ret, !neg);

		ret = set_tracer_flag(tr, 1ULL << ret, !neg);



	mutex_unlock(&trace_types_lock);

	mutex_unlock(&event_mutex);
@@ -6551,7 +6552,7 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp) 
	/* trace pipe does not show start of buffer */

	cpumask_setall(iter->started);



	if (tr->trace_flags & TRACE_ITER_LATENCY_FMT)

	if (tr->trace_flags & TRACE_ITER(LATENCY_FMT))

		iter->iter_flags |= TRACE_FILE_LAT_FMT;



	/* Output in nanoseconds only if we are using a clock in nanoseconds. */
@@ -6612,7 +6613,7 @@ trace_poll(struct trace_iterator *iter, struct file *filp, poll_table *poll_tabl 
	if (trace_buffer_iter(iter, iter->cpu_file))

		return EPOLLIN | EPOLLRDNORM;



	if (tr->trace_flags & TRACE_ITER_BLOCK)

	if (tr->trace_flags & TRACE_ITER(BLOCK))

		/*

		 * Always select as readable when in blocking mode

		 */
@@ -7201,7 +7202,7 @@ tracing_free_buffer_release(struct inode *inode, struct file *filp) 
	struct trace_array *tr = inode->i_private;



	/* disable tracing ? */

	if (tr->trace_flags & TRACE_ITER_STOP_ON_FREE)

	if (tr->trace_flags & TRACE_ITER(STOP_ON_FREE))

		tracer_tracing_off(tr);

	/* resize the ring buffer to 0 */

	tracing_resize_ring_buffer(tr, 0, RING_BUFFER_ALL_CPUS);
@@ -7575,7 +7576,7 @@ tracing_mark_write(struct file *filp, const char __user *ubuf, 
	if (tracing_disabled)

		return -EINVAL;



	if (!(tr->trace_flags & TRACE_ITER_MARKERS))

	if (!(tr->trace_flags & TRACE_ITER(MARKERS)))

		return -EINVAL;



	if ((ssize_t)cnt < 0)
@@ -7655,7 +7656,7 @@ tracing_mark_raw_write(struct file *filp, const char __user *ubuf, 
	if (tracing_disabled)

		return -EINVAL;



	if (!(tr->trace_flags & TRACE_ITER_MARKERS))

	if (!(tr->trace_flags & TRACE_ITER(MARKERS)))

		return -EINVAL;



	/* The marker must at least have a tag id */
@@ -9495,7 +9496,7 @@ trace_options_core_read(struct file *filp, char __user *ubuf, size_t cnt, 


	get_tr_index(tr_index, &tr, &index);



	if (tr->trace_flags & (1 << index))

	if (tr->trace_flags & (1ULL << index))

		buf = "1\n";

	else

		buf = "0\n";
@@ -9524,7 +9525,7 @@ trace_options_core_write(struct file *filp, const char __user *ubuf, size_t cnt, 


	mutex_lock(&event_mutex);

	mutex_lock(&trace_types_lock);

	ret = set_tracer_flag(tr, 1 << index, val);

	ret = set_tracer_flag(tr, 1ULL << index, val);

	mutex_unlock(&trace_types_lock);

	mutex_unlock(&event_mutex);
@@ -9688,10 +9689,11 @@ static void create_trace_options_dir(struct trace_array *tr) 


	for (i = 0; trace_options[i]; i++) {

		if (top_level ||

		    !((1 << i) & TOP_LEVEL_TRACE_FLAGS))

		    !((1ULL << i) & TOP_LEVEL_TRACE_FLAGS)) {

			create_trace_option_core_file(tr, trace_options[i], i);

		}

	}

}



static ssize_t

rb_simple_read(struct file *filp, char __user *ubuf,
@@ -10010,7 +10012,7 @@ allocate_trace_buffer(struct trace_array *tr, struct array_buffer *buf, int size 
	struct trace_scratch *tscratch;

	unsigned int scratch_size = 0;



	rb_flags = tr->trace_flags & TRACE_ITER_OVERWRITE ? RB_FL_OVERWRITE : 0;

	rb_flags = tr->trace_flags & TRACE_ITER(OVERWRITE) ? RB_FL_OVERWRITE : 0;



	buf->tr = tr;
@@ -10375,7 +10377,7 @@ static int __remove_instance(struct trace_array *tr) 
	/* Disable all the flags that were enabled coming in */

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

		if ((1 << i) & ZEROED_TRACE_FLAGS)

			set_tracer_flag(tr, 1 << i, 0);

			set_tracer_flag(tr, 1ULL << i, 0);

	}



	if (printk_trace == tr)
@@ -10968,10 +10970,10 @@ static void ftrace_dump_one(struct trace_array *tr, enum ftrace_dump_mode dump_m 
	/* While dumping, do not allow the buffer to be enable */

	tracer_tracing_disable(tr);



	old_userobj = tr->trace_flags & TRACE_ITER_SYM_USEROBJ;

	old_userobj = tr->trace_flags & TRACE_ITER(SYM_USEROBJ);



	/* don't look at user memory in panic mode */

	tr->trace_flags &= ~TRACE_ITER_SYM_USEROBJ;

	tr->trace_flags &= ~TRACE_ITER(SYM_USEROBJ);



	if (dump_mode == DUMP_ORIG)

		iter.cpu_file = raw_smp_processor_id();
@@ -11487,7 +11489,7 @@ __init static int tracer_alloc_buffers(void) 


#ifdef CONFIG_FUNCTION_TRACER

/* Used to set module cached ftrace filtering at boot up */

__init struct trace_array *trace_get_global_array(void)

struct trace_array *trace_get_global_array(void)

{

	return &global_trace;

}

kernel/trace/trace.h

+23 −17
Original line number Diff line number Diff line
@@ -218,7 +218,7 @@ struct array_buffer { 
	int				cpu;

};



#define TRACE_FLAGS_MAX_SIZE		32

#define TRACE_FLAGS_MAX_SIZE		64



struct trace_options {

	struct tracer			*tracer;
@@ -392,7 +392,7 @@ struct trace_array { 
	int			buffer_percent;

	unsigned int		n_err_log_entries;

	struct tracer		*current_trace;

	unsigned int		trace_flags;

	u64			trace_flags;

	unsigned char		trace_flags_index[TRACE_FLAGS_MAX_SIZE];

	unsigned int		flags;

	raw_spinlock_t		start_lock;
@@ -634,7 +634,7 @@ struct tracer { 
					    u32 old_flags, u32 bit, int set);

	/* Return 0 if OK with change, else return non-zero */

	int			(*flag_changed)(struct trace_array *tr,

						u32 mask, int set);

						u64 mask, int set);

	struct tracer		*next;

	struct tracer_flags	*flags;

	int			enabled;
@@ -1348,11 +1348,11 @@ extern int trace_get_user(struct trace_parser *parser, const char __user *ubuf, 
# define FUNCTION_FLAGS						\

		C(FUNCTION,		"function-trace"),	\

		C(FUNC_FORK,		"function-fork"),

# define FUNCTION_DEFAULT_FLAGS		TRACE_ITER_FUNCTION

# define FUNCTION_DEFAULT_FLAGS		TRACE_ITER(FUNCTION)

#else

# define FUNCTION_FLAGS

# define FUNCTION_DEFAULT_FLAGS		0UL

# define TRACE_ITER_FUNC_FORK		0UL

# define TRACE_ITER_FUNC_FORK_BIT	-1

#endif



#ifdef CONFIG_STACKTRACE
@@ -1362,6 +1362,14 @@ extern int trace_get_user(struct trace_parser *parser, const char __user *ubuf, 
# define STACK_FLAGS

#endif



#ifdef CONFIG_FUNCTION_PROFILER

# define PROFILER_FLAGS					\

		C(PROF_TEXT_OFFSET,	"prof-text-offset"),

#else

# define PROFILER_FLAGS

# define TRACE_ITER_PROF_TEXT_OFFSET_BIT	-1

#endif



/*

 * trace_iterator_flags is an enumeration that defines bit

 * positions into trace_flags that controls the output.
@@ -1400,7 +1408,8 @@ extern int trace_get_user(struct trace_parser *parser, const char __user *ubuf, 
		FUNCTION_FLAGS					\

		FGRAPH_FLAGS					\

		STACK_FLAGS					\

		BRANCH_FLAGS

		BRANCH_FLAGS					\

		PROFILER_FLAGS



/*

 * By defining C, we can make TRACE_FLAGS a list of bit names
@@ -1416,20 +1425,17 @@ enum trace_iterator_bits { 
};



/*

 * By redefining C, we can make TRACE_FLAGS a list of masks that

 * use the bits as defined above.

 * And use TRACE_ITER(flag) to define the bit masks.

 */

#undef C

#define C(a, b) TRACE_ITER_##a = (1 << TRACE_ITER_##a##_BIT)



enum trace_iterator_flags { TRACE_FLAGS };

#define TRACE_ITER(flag)		\

	(TRACE_ITER_##flag##_BIT < 0 ? 0 : 1ULL << (TRACE_ITER_##flag##_BIT))



/*

 * TRACE_ITER_SYM_MASK masks the options in trace_flags that

 * control the output of kernel symbols.

 */

#define TRACE_ITER_SYM_MASK \

	(TRACE_ITER_PRINT_PARENT|TRACE_ITER_SYM_OFFSET|TRACE_ITER_SYM_ADDR)

	(TRACE_ITER(PRINT_PARENT)|TRACE_ITER(SYM_OFFSET)|TRACE_ITER(SYM_ADDR))



extern struct tracer nop_trace;
@@ -1438,7 +1444,7 @@ extern int enable_branch_tracing(struct trace_array *tr); 
extern void disable_branch_tracing(void);

static inline int trace_branch_enable(struct trace_array *tr)

{

	if (tr->trace_flags & TRACE_ITER_BRANCH)

	if (tr->trace_flags & TRACE_ITER(BRANCH))

		return enable_branch_tracing(tr);

	return 0;

}
@@ -2084,8 +2090,8 @@ extern const char *__stop___tracepoint_str[]; 


void trace_printk_control(bool enabled);

void trace_printk_start_comm(void);

int trace_keep_overwrite(struct tracer *tracer, u32 mask, int set);

int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled);

int trace_keep_overwrite(struct tracer *tracer, u64 mask, int set);

int set_tracer_flag(struct trace_array *tr, u64 mask, int enabled);



/* Used from boot time tracer */

extern int trace_set_options(struct trace_array *tr, char *option);

kernel/trace/trace_events.c

+2 −2
Original line number Diff line number Diff line
@@ -845,13 +845,13 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file, 
			if (soft_disable)

				set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);



			if (tr->trace_flags & TRACE_ITER_RECORD_CMD) {

			if (tr->trace_flags & TRACE_ITER(RECORD_CMD)) {

				cmd = true;

				tracing_start_cmdline_record();

				set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);

			}



			if (tr->trace_flags & TRACE_ITER_RECORD_TGID) {

			if (tr->trace_flags & TRACE_ITER(RECORD_TGID)) {

				tgid = true;

				tracing_start_tgid_record();

				set_bit(EVENT_FILE_FL_RECORDED_TGID_BIT, &file->flags);