[linux-2.6-block.git] / include / trace / ftrace.h

/*
 * Stage 1 of the trace events.
 *
 * Override the macros in <trace/trace_events.h> to include the following:
 *
 * struct ftrace_raw_<call> {
 *	struct trace_entry		ent;
 *	<type>				<item>;
 *	<type2>				<item2>[<len>];
 *	[...]
 * };
 *
 * The <type> <item> is created by the __field(type, item) macro or
 * the __array(type2, item2, len) macro.
 * We simply do "type item;", and that will create the fields
 * in the structure.
 */

#include <linux/ftrace_event.h>

#undef __field
#define __field(type, item)		type	item;

#undef __array
#define __array(type, item, len)	type	item[len];

#undef __dynamic_array
#define __dynamic_array(type, item, len) unsigned short __data_loc_##item;

#undef __string
#define __string(item, src) __dynamic_array(char, item, -1)

#undef TP_STRUCT__entry
#define TP_STRUCT__entry(args...) args

#undef TRACE_EVENT
#define TRACE_EVENT(name, proto, args, tstruct, assign, print)	\
	struct ftrace_raw_##name {				\
		struct trace_entry	ent;			\
		tstruct						\
		char			__data[0];		\
	};							\
	static struct ftrace_event_call event_##name

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)


/*
 * Stage 2 of the trace events.
 *
 * Include the following:
 *
 * struct ftrace_data_offsets_<call> {
 *	int				<item1>;
 *	int				<item2>;
 *	[...]
 * };
 *
 * The __dynamic_array() macro will create each int <item>, this is
 * to keep the offset of each array from the beginning of the event.
 */

#undef __field
#define __field(type, item);

#undef __array
#define __array(type, item, len)

#undef __dynamic_array
#define __dynamic_array(type, item, len)	int item;

#undef __string
#define __string(item, src) __dynamic_array(char, item, -1)

#undef TRACE_EVENT
#define TRACE_EVENT(call, proto, args, tstruct, assign, print)		\
	struct ftrace_data_offsets_##call {				\
		tstruct;						\
	};

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/*
 * Setup the showing format of trace point.
 *
 * int
 * ftrace_format_##call(struct trace_seq *s)
 * {
 *	struct ftrace_raw_##call field;
 *	int ret;
 *
 *	ret = trace_seq_printf(s, #type " " #item ";"
 *			       " offset:%u; size:%u;\n",
 *			       offsetof(struct ftrace_raw_##call, item),
 *			       sizeof(field.type));
 *
 * }
 */

#undef TP_STRUCT__entry
#define TP_STRUCT__entry(args...) args

#undef __field
#define __field(type, item)					\
	ret = trace_seq_printf(s, "\tfield:" #type " " #item ";\t"	\
			       "offset:%u;\tsize:%u;\n",		\
			       (unsigned int)offsetof(typeof(field), item), \
			       (unsigned int)sizeof(field.item));	\
	if (!ret)							\
		return 0;

#undef __array
#define __array(type, item, len)						\
	ret = trace_seq_printf(s, "\tfield:" #type " " #item "[" #len "];\t"	\
			       "offset:%u;\tsize:%u;\n",		\
			       (unsigned int)offsetof(typeof(field), item), \
			       (unsigned int)sizeof(field.item));	\
	if (!ret)							\
		return 0;

#undef __dynamic_array
#define __dynamic_array(type, item, len)				       \
	ret = trace_seq_printf(s, "\tfield:__data_loc " #item ";\t"	       \
			       "offset:%u;\tsize:%u;\n",		       \
			       (unsigned int)offsetof(typeof(field),	       \
					__data_loc_##item),		       \
			       (unsigned int)sizeof(field.__data_loc_##item)); \
	if (!ret)							       \
		return 0;

#undef __string
#define __string(item, src) __dynamic_array(char, item, -1)

#undef __entry
#define __entry REC

#undef __print_symbolic
#undef __get_dynamic_array
#undef __get_str

#undef TP_printk
#define TP_printk(fmt, args...) "%s, %s\n", #fmt, __stringify(args)

#undef TP_fast_assign
#define TP_fast_assign(args...) args

#undef TP_perf_assign
#define TP_perf_assign(args...)

#undef TRACE_EVENT
#define TRACE_EVENT(call, proto, args, tstruct, func, print)		\
static int								\
ftrace_format_##call(struct trace_seq *s)				\
{									\
	struct ftrace_raw_##call field __attribute__((unused));		\
	int ret = 0;							\
									\
	tstruct;							\
									\
	trace_seq_printf(s, "\nprint fmt: " print);			\
									\
	return ret;							\
}

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/*
 * Stage 3 of the trace events.
 *
 * Override the macros in <trace/trace_events.h> to include the following:
 *
 * enum print_line_t
 * ftrace_raw_output_<call>(struct trace_iterator *iter, int flags)
 * {
 *	struct trace_seq *s = &iter->seq;
 *	struct ftrace_raw_<call> *field; <-- defined in stage 1
 *	struct trace_entry *entry;
 *	struct trace_seq *p;
 *	int ret;
 *
 *	entry = iter->ent;
 *
 *	if (entry->type != event_<call>.id) {
 *		WARN_ON_ONCE(1);
 *		return TRACE_TYPE_UNHANDLED;
 *	}
 *
 *	field = (typeof(field))entry;
 *
 *	p = get_cpu_var(ftrace_event_seq);
 *	trace_seq_init(p);
 *	ret = trace_seq_printf(s, <TP_printk> "\n");
 *	put_cpu();
 *	if (!ret)
 *		return TRACE_TYPE_PARTIAL_LINE;
 *
 *	return TRACE_TYPE_HANDLED;
 * }
 *
 * This is the method used to print the raw event to the trace
 * output format. Note, this is not needed if the data is read
 * in binary.
 */

#undef __entry
#define __entry field

#undef TP_printk
#define TP_printk(fmt, args...) fmt "\n", args

#undef __get_dynamic_array
#define __get_dynamic_array(field)	\
		((void *)__entry + __entry->__data_loc_##field)

#undef __get_str
#define __get_str(field) (char *)__get_dynamic_array(field)

#undef __print_flags
#define __print_flags(flag, delim, flag_array...)			\
	({								\
		static const struct trace_print_flags flags[] =		\
			{ flag_array, { -1, NULL }};			\
		ftrace_print_flags_seq(p, delim, flag, flags);		\
	})

#undef __print_symbolic
#define __print_symbolic(value, symbol_array...)			\
	({								\
		static const struct trace_print_flags symbols[] =	\
			{ symbol_array, { -1, NULL }};			\
		ftrace_print_symbols_seq(p, value, symbols);		\
	})

#undef TRACE_EVENT
#define TRACE_EVENT(call, proto, args, tstruct, assign, print)		\
enum print_line_t							\
ftrace_raw_output_##call(struct trace_iterator *iter, int flags)	\
{									\
	struct trace_seq *s = &iter->seq;				\
	struct ftrace_raw_##call *field;				\
	struct trace_entry *entry;					\
	struct trace_seq *p;						\
	int ret;							\
									\
	entry = iter->ent;						\
									\
	if (entry->type != event_##call.id) {				\
		WARN_ON_ONCE(1);					\
		return TRACE_TYPE_UNHANDLED;				\
	}								\
									\
	field = (typeof(field))entry;					\
									\
	p = &get_cpu_var(ftrace_event_seq);				\
	trace_seq_init(p);						\
	ret = trace_seq_printf(s, #call ": " print);			\
	put_cpu();							\
	if (!ret)							\
		return TRACE_TYPE_PARTIAL_LINE;				\
									\
	return TRACE_TYPE_HANDLED;					\
}
	
#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

#undef __field
#define __field(type, item)						\
	ret = trace_define_field(event_call, #type, #item,		\
				 offsetof(typeof(field), item),		\
				 sizeof(field.item), is_signed_type(type));	\
	if (ret)							\
		return ret;

#undef __array
#define __array(type, item, len)					\
	BUILD_BUG_ON(len > MAX_FILTER_STR_VAL);				\
	ret = trace_define_field(event_call, #type "[" #len "]", #item,	\
				 offsetof(typeof(field), item),		\
				 sizeof(field.item), 0);		\
	if (ret)							\
		return ret;

#undef __dynamic_array
#define __dynamic_array(type, item, len)				       \
	ret = trace_define_field(event_call, "__data_loc" "[" #type "]", #item,\
				offsetof(typeof(field), __data_loc_##item),    \
				 sizeof(field.__data_loc_##item), 0);

#undef __string
#define __string(item, src) __dynamic_array(char, item, -1)

#undef TRACE_EVENT
#define TRACE_EVENT(call, proto, args, tstruct, func, print)		\
int									\
ftrace_define_fields_##call(void)					\
{									\
	struct ftrace_raw_##call field;					\
	struct ftrace_event_call *event_call = &event_##call;		\
	int ret;							\
									\
	__common_field(int, type, 1);					\
	__common_field(unsigned char, flags, 0);			\
	__common_field(unsigned char, preempt_count, 0);		\
	__common_field(int, pid, 1);					\
	__common_field(int, tgid, 1);					\
									\
	tstruct;							\
									\
	return ret;							\
}

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/*
 * remember the offset of each array from the beginning of the event.
 */

#undef __entry
#define __entry entry

#undef __field
#define __field(type, item)

#undef __array
#define __array(type, item, len)

#undef __dynamic_array
#define __dynamic_array(type, item, len)				\
	__data_offsets->item = __data_size +				\
			       offsetof(typeof(*entry), __data);	\
	__data_size += (len) * sizeof(type);

#undef __string
#define __string(item, src) __dynamic_array(char, item, strlen(src) + 1)       \

#undef TRACE_EVENT
#define TRACE_EVENT(call, proto, args, tstruct, assign, print)		\
static inline int ftrace_get_offsets_##call(				\
	struct ftrace_data_offsets_##call *__data_offsets, proto)       \
{									\
	int __data_size = 0;						\
	struct ftrace_raw_##call __maybe_unused *entry;			\
									\
	tstruct;							\
									\
	return __data_size;						\
}

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

#ifdef CONFIG_EVENT_PROFILE

/*
 * Generate the functions needed for tracepoint perf_counter support.
 *
 * NOTE: The insertion profile callback (ftrace_profile_<call>) is defined later
 *
 * static int ftrace_profile_enable_<call>(struct ftrace_event_call *event_call)
 * {
 * 	int ret = 0;
 *
 * 	if (!atomic_inc_return(&event_call->profile_count))
 * 		ret = register_trace_<call>(ftrace_profile_<call>);
 *
 * 	return ret;
 * }
 *
 * static void ftrace_profile_disable_<call>(struct ftrace_event_call *event_call)
 * {
 * 	if (atomic_add_negative(-1, &event->call->profile_count))
 * 		unregister_trace_<call>(ftrace_profile_<call>);
 * }
 *
 */

#undef TRACE_EVENT
#define TRACE_EVENT(call, proto, args, tstruct, assign, print)		\
									\
static void ftrace_profile_##call(proto);				\
									\
static int ftrace_profile_enable_##call(struct ftrace_event_call *event_call) \
{									\
	int ret = 0;							\
									\
	if (!atomic_inc_return(&event_call->profile_count))		\
		ret = register_trace_##call(ftrace_profile_##call);	\
									\
	return ret;							\
}									\
									\
static void ftrace_profile_disable_##call(struct ftrace_event_call *event_call)\
{									\
	if (atomic_add_negative(-1, &event_call->profile_count))	\
		unregister_trace_##call(ftrace_profile_##call);		\
}

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

#endif

/*
 * Stage 4 of the trace events.
 *
 * Override the macros in <trace/trace_events.h> to include the following:
 *
 * static void ftrace_event_<call>(proto)
 * {
 *	event_trace_printk(_RET_IP_, "<call>: " <fmt>);
 * }
 *
 * static int ftrace_reg_event_<call>(void)
 * {
 *	int ret;
 *
 *	ret = register_trace_<call>(ftrace_event_<call>);
 *	if (!ret)
 *		pr_info("event trace: Could not activate trace point "
 *			"probe to  <call>");
 *	return ret;
 * }
 *
 * static void ftrace_unreg_event_<call>(void)
 * {
 *	unregister_trace_<call>(ftrace_event_<call>);
 * }
 *
 *
 * For those macros defined with TRACE_EVENT:
 *
 * static struct ftrace_event_call event_<call>;
 *
 * static void ftrace_raw_event_<call>(proto)
 * {
 *	struct ring_buffer_event *event;
 *	struct ftrace_raw_<call> *entry; <-- defined in stage 1
 *	unsigned long irq_flags;
 *	int pc;
 *
 *	local_save_flags(irq_flags);
 *	pc = preempt_count();
 *
 *	event = trace_current_buffer_lock_reserve(event_<call>.id,
 *				  sizeof(struct ftrace_raw_<call>),
 *				  irq_flags, pc);
 *	if (!event)
 *		return;
 *	entry	= ring_buffer_event_data(event);
 *
 *	<assign>;  <-- Here we assign the entries by the __field and
 *			__array macros.
 *
 *	trace_current_buffer_unlock_commit(event, irq_flags, pc);
 * }
 *
 * static int ftrace_raw_reg_event_<call>(void)
 * {
 *	int ret;
 *
 *	ret = register_trace_<call>(ftrace_raw_event_<call>);
 *	if (!ret)
 *		pr_info("event trace: Could not activate trace point "
 *			"probe to <call>");
 *	return ret;
 * }
 *
 * static void ftrace_unreg_event_<call>(void)
 * {
 *	unregister_trace_<call>(ftrace_raw_event_<call>);
 * }
 *
 * static struct trace_event ftrace_event_type_<call> = {
 *	.trace			= ftrace_raw_output_<call>, <-- stage 2
 * };
 *
 * static int ftrace_raw_init_event_<call>(void)
 * {
 *	int id;
 *
 *	id = register_ftrace_event(&ftrace_event_type_<call>);
 *	if (!id)
 *		return -ENODEV;
 *	event_<call>.id = id;
 *	return 0;
 * }
 *
 * static struct ftrace_event_call __used
 * __attribute__((__aligned__(4)))
 * __attribute__((section("_ftrace_events"))) event_<call> = {
 *	.name			= "<call>",
 *	.system			= "<system>",
 *	.raw_init		= ftrace_raw_init_event_<call>,
 *	.regfunc		= ftrace_reg_event_<call>,
 *	.unregfunc		= ftrace_unreg_event_<call>,
 *	.show_format		= ftrace_format_<call>,
 * }
 *
 */

#undef TP_FMT
#define TP_FMT(fmt, args...)	fmt "\n", ##args

#ifdef CONFIG_EVENT_PROFILE

#define _TRACE_PROFILE_INIT(call)					\
	.profile_count = ATOMIC_INIT(-1),				\
	.profile_enable = ftrace_profile_enable_##call,			\
	.profile_disable = ftrace_profile_disable_##call,

#else
#define _TRACE_PROFILE_INIT(call)
#endif

#undef __entry
#define __entry entry

#undef __field
#define __field(type, item)

#undef __array
#define __array(type, item, len)

#undef __dynamic_array
#define __dynamic_array(type, item, len)				\
	__entry->__data_loc_##item = __data_offsets.item;

#undef __string
#define __string(item, src) __dynamic_array(char, item, -1)       	\

#undef __assign_str
#define __assign_str(dst, src)						\
	strcpy(__get_str(dst), src);

#undef TRACE_EVENT
#define TRACE_EVENT(call, proto, args, tstruct, assign, print)		\
									\
static struct ftrace_event_call event_##call;				\
									\
static void ftrace_raw_event_##call(proto)				\
{									\
	struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
	struct ftrace_event_call *event_call = &event_##call;		\
	struct ring_buffer_event *event;				\
	struct ftrace_raw_##call *entry;				\
	unsigned long irq_flags;					\
	int __data_size;						\
	int pc;								\
									\
	local_save_flags(irq_flags);					\
	pc = preempt_count();						\
									\
	__data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
									\
	event = trace_current_buffer_lock_reserve(event_##call.id,	\
				 sizeof(*entry) + __data_size,		\
				 irq_flags, pc);			\
	if (!event)							\
		return;							\
	entry	= ring_buffer_event_data(event);			\
									\
									\
	tstruct								\
									\
	{ assign; }							\
									\
	if (!filter_current_check_discard(event_call, entry, event))	\
		trace_nowake_buffer_unlock_commit(event, irq_flags, pc); \
}									\
									\
static int ftrace_raw_reg_event_##call(void)				\
{									\
	int ret;							\
									\
	ret = register_trace_##call(ftrace_raw_event_##call);		\
	if (ret)							\
		pr_info("event trace: Could not activate trace point "	\
			"probe to " #call "\n");			\
	return ret;							\
}									\
									\
static void ftrace_raw_unreg_event_##call(void)				\
{									\
	unregister_trace_##call(ftrace_raw_event_##call);		\
}									\
									\
static struct trace_event ftrace_event_type_##call = {			\
	.trace			= ftrace_raw_output_##call,		\
};									\
									\
static int ftrace_raw_init_event_##call(void)				\
{									\
	int id;								\
									\
	id = register_ftrace_event(&ftrace_event_type_##call);		\
	if (!id)							\
		return -ENODEV;						\
	event_##call.id = id;						\
	INIT_LIST_HEAD(&event_##call.fields);				\
	init_preds(&event_##call);					\
	return 0;							\
}									\
									\
static struct ftrace_event_call __used					\
__attribute__((__aligned__(4)))						\
__attribute__((section("_ftrace_events"))) event_##call = {		\
	.name			= #call,				\
	.system			= __stringify(TRACE_SYSTEM),		\
	.event			= &ftrace_event_type_##call,		\
	.raw_init		= ftrace_raw_init_event_##call,		\
	.regfunc		= ftrace_raw_reg_event_##call,		\
	.unregfunc		= ftrace_raw_unreg_event_##call,	\
	.show_format		= ftrace_format_##call,			\
	.define_fields		= ftrace_define_fields_##call,		\
	_TRACE_PROFILE_INIT(call)					\
}

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/*
 * Define the insertion callback to profile events
 *
 * The job is very similar to ftrace_raw_event_<call> except that we don't
 * insert in the ring buffer but in a perf counter.
 *
 * static void ftrace_profile_<call>(proto)
 * {
 *	struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;
 *	struct ftrace_event_call *event_call = &event_<call>;
 *	extern void perf_tpcounter_event(int, u64, u64, void *, int);
 *	struct ftrace_raw_##call *entry;
 *	u64 __addr = 0, __count = 1;
 *	unsigned long irq_flags;
 *	int __entry_size;
 *	int __data_size;
 *	int pc;
 *
 *	local_save_flags(irq_flags);
 *	pc = preempt_count();
 *
 *	__data_size = ftrace_get_offsets_<call>(&__data_offsets, args);
 *	__entry_size = __data_size + sizeof(*entry);
 *
 *	do {
 *		char raw_data[__entry_size]; <- allocate our sample in the stack
 *		struct trace_entry *ent;
 *
 *		entry = (struct ftrace_raw_<call> *)raw_data;
 *		ent = &entry->ent;
 *		tracing_generic_entry_update(ent, irq_flags, pc);
 *		ent->type = event_call->id;
 *
 *		<tstruct> <- do some jobs with dynamic arrays
 *
 *		<assign>  <- affect our values
 *
 *		perf_tpcounter_event(event_call->id, __addr, __count, entry,
 *			     __entry_size);  <- submit them to perf counter
 *	} while (0);
 *
 * }
 */

#ifdef CONFIG_EVENT_PROFILE

#undef __perf_addr
#define __perf_addr(a) __addr = (a)

#undef __perf_count
#define __perf_count(c) __count = (c)

#undef TRACE_EVENT
#define TRACE_EVENT(call, proto, args, tstruct, assign, print)		\
static void ftrace_profile_##call(proto)				\
{									\
	struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
	struct ftrace_event_call *event_call = &event_##call;		\
	extern void perf_tpcounter_event(int, u64, u64, void *, int);	\
	struct ftrace_raw_##call *entry;				\
	u64 __addr = 0, __count = 1;					\
	unsigned long irq_flags;					\
	int __entry_size;						\
	int __data_size;						\
	int pc;								\
									\
	local_save_flags(irq_flags);					\
	pc = preempt_count();						\
									\
	__data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
	__entry_size = ALIGN(__data_size + sizeof(*entry), sizeof(u64));\
									\
	do {								\
		char raw_data[__entry_size];				\
		struct trace_entry *ent;				\
									\
		entry = (struct ftrace_raw_##call *)raw_data;		\
		ent = &entry->ent;					\
		tracing_generic_entry_update(ent, irq_flags, pc);	\
		ent->type = event_call->id;				\
									\
		tstruct							\
									\
		{ assign; }						\
									\
		perf_tpcounter_event(event_call->id, __addr, __count, entry,\
			     __entry_size);				\
	} while (0);							\
									\
}

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
#endif /* CONFIG_EVENT_PROFILE */

#undef _TRACE_PROFILE_INIT
Commit	Line	Data
f42c85e7 SR	1	/*
	2	* Stage 1 of the trace events.
	3	*
	4	* Override the macros in <trace/trace_events.h> to include the following:
	5	*
	6	* struct ftrace_raw_<call> {
	7	* struct trace_entry ent;
	8	* <type> <item>;
	9	* <type2> <item2>[<len>];
	10	* [...]
	11	* };
	12	*
	13	* The <type> <item> is created by the __field(type, item) macro or
	14	* the __array(type2, item2, len) macro.
	15	* We simply do "type item;", and that will create the fields
	16	* in the structure.
	17	*/
	18
	19	#include <linux/ftrace_event.h>
	20
7fcb7c47 LZ	21	#undef __field
	22	#define __field(type, item) type item;
	23
f42c85e7 SR	24	#undef __array
	25	#define __array(type, item, len) type item[len];
	26
7fcb7c47 LZ	27	#undef __dynamic_array
7fcb7c47 LZ	28	#define __dynamic_array(type, item, len) unsigned short __data_loc_##item;
f42c85e7	29
9cbf1176	30	#undef __string
7fcb7c47	31	#define __string(item, src) __dynamic_array(char, item, -1)
9cbf1176	32
f42c85e7 SR	33	#undef TP_STRUCT__entry
	34	#define TP_STRUCT__entry(args...) args
	35
	36	#undef TRACE_EVENT
	37	#define TRACE_EVENT(name, proto, args, tstruct, assign, print) \
	38	struct ftrace_raw_##name { \
	39	struct trace_entry ent; \
	40	tstruct \
7fcb7c47	41	char __data[0]; \
f42c85e7 SR	42	}; \
	43	static struct ftrace_event_call event_##name
	44
	45	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	46
9cbf1176	47
f42c85e7 SR	48	/*
	49	* Stage 2 of the trace events.
	50	*
9cbf1176 FW	51	* Include the following:
9cbf1176 FW	52	*
7fcb7c47 LZ	53	* struct ftrace_data_offsets_<call> {
	54	* int <item1>;
	55	* int <item2>;
9cbf1176 FW	56	* [...]
	57	* };
	58	*
7fcb7c47 LZ	59	* The __dynamic_array() macro will create each int <item>, this is
7fcb7c47 LZ	60	* to keep the offset of each array from the beginning of the event.
9cbf1176 FW	61	*/
9cbf1176 FW	62
7fcb7c47 LZ	63	#undef __field
	64	#define __field(type, item);
	65
9cbf1176 FW	66	#undef __array
	67	#define __array(type, item, len)
	68
7fcb7c47 LZ	69	#undef __dynamic_array
7fcb7c47 LZ	70	#define __dynamic_array(type, item, len) int item;
9cbf1176 FW	71
9cbf1176 FW	72	#undef __string
7fcb7c47	73	#define __string(item, src) __dynamic_array(char, item, -1)
9cbf1176 FW	74
	75	#undef TRACE_EVENT
	76	#define TRACE_EVENT(call, proto, args, tstruct, assign, print) \
7fcb7c47	77	struct ftrace_data_offsets_##call { \
9cbf1176 FW	78	tstruct; \
	79	};
	80
	81	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	82
6ff9a64d SR	83	/*
	84	* Setup the showing format of trace point.
	85	*
	86	* int
	87	* ftrace_format_##call(struct trace_seq *s)
	88	* {
	89	* struct ftrace_raw_##call field;
	90	* int ret;
	91	*
	92	* ret = trace_seq_printf(s, #type " " #item ";"
	93	* " offset:%u; size:%u;\n",
	94	* offsetof(struct ftrace_raw_##call, item),
	95	* sizeof(field.type));
	96	*
	97	* }
	98	*/
	99
	100	#undef TP_STRUCT__entry
	101	#define TP_STRUCT__entry(args...) args
	102
	103	#undef __field
	104	#define __field(type, item) \
	105	ret = trace_seq_printf(s, "\tfield:" #type " " #item ";\t" \
	106	"offset:%u;\tsize:%u;\n", \
	107	(unsigned int)offsetof(typeof(field), item), \
	108	(unsigned int)sizeof(field.item)); \
	109	if (!ret) \
	110	return 0;
	111
	112	#undef __array
	113	#define __array(type, item, len) \
	114	ret = trace_seq_printf(s, "\tfield:" #type " " #item "[" #len "];\t" \
	115	"offset:%u;\tsize:%u;\n", \
	116	(unsigned int)offsetof(typeof(field), item), \
	117	(unsigned int)sizeof(field.item)); \
	118	if (!ret) \
	119	return 0;
	120
	121	#undef __dynamic_array
	122	#define __dynamic_array(type, item, len) \
	123	ret = trace_seq_printf(s, "\tfield:__data_loc " #item ";\t" \
	124	"offset:%u;\tsize:%u;\n", \
	125	(unsigned int)offsetof(typeof(field), \
	126	__data_loc_##item), \
	127	(unsigned int)sizeof(field.__data_loc_##item)); \
	128	if (!ret) \
	129	return 0;
	130
	131	#undef __string
	132	#define __string(item, src) __dynamic_array(char, item, -1)
	133
	134	#undef __entry
	135	#define __entry REC
	136
	137	#undef __print_symbolic
	138	#undef __get_dynamic_array
	139	#undef __get_str
	140
	141	#undef TP_printk
	142	#define TP_printk(fmt, args...) "%s, %s\n", #fmt, __stringify(args)
	143
	144	#undef TP_fast_assign
	145	#define TP_fast_assign(args...) args
	146
3a659305 PZ	147	#undef TP_perf_assign
	148	#define TP_perf_assign(args...)
	149
6ff9a64d SR	150	#undef TRACE_EVENT
	151	#define TRACE_EVENT(call, proto, args, tstruct, func, print) \
	152	static int \
	153	ftrace_format_##call(struct trace_seq *s) \
	154	{ \
	155	struct ftrace_raw_##call field __attribute__((unused)); \
	156	int ret = 0; \
	157	\
	158	tstruct; \
	159	\
	160	trace_seq_printf(s, "\nprint fmt: " print); \
	161	\
	162	return ret; \
	163	}
	164
	165	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	166
9cbf1176 FW	167	/*
	168	* Stage 3 of the trace events.
	169	*
f42c85e7 SR	170	* Override the macros in <trace/trace_events.h> to include the following:
	171	*
	172	* enum print_line_t
	173	* ftrace_raw_output_<call>(struct trace_iterator *iter, int flags)
	174	* {
	175	* struct trace_seq *s = &iter->seq;
	176	* struct ftrace_raw_<call> *field; <-- defined in stage 1
	177	* struct trace_entry *entry;
be74b73a	178	* struct trace_seq *p;
f42c85e7 SR	179	* int ret;
	180	*
	181	* entry = iter->ent;
	182	*
	183	* if (entry->type != event_<call>.id) {
	184	* WARN_ON_ONCE(1);
	185	* return TRACE_TYPE_UNHANDLED;
	186	* }
	187	*
	188	* field = (typeof(field))entry;
	189	*
be74b73a	190	* p = get_cpu_var(ftrace_event_seq);
56d8bd3f	191	* trace_seq_init(p);
f42c85e7	192	* ret = trace_seq_printf(s, <TP_printk> "\n");
be74b73a	193	* put_cpu();
f42c85e7 SR	194	* if (!ret)
	195	* return TRACE_TYPE_PARTIAL_LINE;
	196	*
	197	* return TRACE_TYPE_HANDLED;
	198	* }
	199	*
	200	* This is the method used to print the raw event to the trace
	201	* output format. Note, this is not needed if the data is read
	202	* in binary.
	203	*/
	204
	205	#undef __entry
	206	#define __entry field
	207
	208	#undef TP_printk
	209	#define TP_printk(fmt, args...) fmt "\n", args
	210
7fcb7c47 LZ	211	#undef __get_dynamic_array
	212	#define __get_dynamic_array(field) \
	213	((void *)__entry + __entry->__data_loc_##field)
	214
9cbf1176	215	#undef __get_str
7fcb7c47	216	#define __get_str(field) (char *)__get_dynamic_array(field)
9cbf1176	217
be74b73a SR	218	#undef __print_flags
	219	#define __print_flags(flag, delim, flag_array...) \
	220	({ \
	221	static const struct trace_print_flags flags[] = \
	222	{ flag_array, { -1, NULL }}; \
	223	ftrace_print_flags_seq(p, delim, flag, flags); \
	224	})
	225
0f4fc29d SR	226	#undef __print_symbolic
	227	#define __print_symbolic(value, symbol_array...) \
	228	({ \
	229	static const struct trace_print_flags symbols[] = \
	230	{ symbol_array, { -1, NULL }}; \
	231	ftrace_print_symbols_seq(p, value, symbols); \
	232	})
	233
f42c85e7 SR	234	#undef TRACE_EVENT
	235	#define TRACE_EVENT(call, proto, args, tstruct, assign, print) \
	236	enum print_line_t \
	237	ftrace_raw_output_##call(struct trace_iterator *iter, int flags) \
	238	{ \
	239	struct trace_seq *s = &iter->seq; \
	240	struct ftrace_raw_##call *field; \
	241	struct trace_entry *entry; \
be74b73a	242	struct trace_seq *p; \
f42c85e7 SR	243	int ret; \
	244	\
	245	entry = iter->ent; \
	246	\
	247	if (entry->type != event_##call.id) { \
	248	WARN_ON_ONCE(1); \
	249	return TRACE_TYPE_UNHANDLED; \
	250	} \
	251	\
	252	field = (typeof(field))entry; \
	253	\
be74b73a	254	p = &get_cpu_var(ftrace_event_seq); \
56d8bd3f	255	trace_seq_init(p); \
f42c85e7	256	ret = trace_seq_printf(s, #call ": " print); \
be74b73a	257	put_cpu(); \
f42c85e7 SR	258	if (!ret) \
	259	return TRACE_TYPE_PARTIAL_LINE; \
	260	\
	261	return TRACE_TYPE_HANDLED; \
	262	}
	263
	264	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	265
f42c85e7 SR	266	#undef __field
	267	#define __field(type, item) \
	268	ret = trace_define_field(event_call, #type, #item, \
	269	offsetof(typeof(field), item), \
a118e4d1	270	sizeof(field.item), is_signed_type(type)); \
f42c85e7 SR	271	if (ret) \
	272	return ret;
	273
	274	#undef __array
	275	#define __array(type, item, len) \
	276	BUILD_BUG_ON(len > MAX_FILTER_STR_VAL); \
	277	ret = trace_define_field(event_call, #type "[" #len "]", #item, \
	278	offsetof(typeof(field), item), \
a118e4d1	279	sizeof(field.item), 0); \
f42c85e7 SR	280	if (ret) \
	281	return ret;
	282
7fcb7c47 LZ	283	#undef __dynamic_array
	284	#define __dynamic_array(type, item, len) \
	285	ret = trace_define_field(event_call, "__data_loc" "[" #type "]", #item,\
	286	offsetof(typeof(field), __data_loc_##item), \
	287	sizeof(field.__data_loc_##item), 0);
	288
9cbf1176	289	#undef __string
7fcb7c47	290	#define __string(item, src) __dynamic_array(char, item, -1)
9cbf1176	291
f42c85e7 SR	292	#undef TRACE_EVENT
	293	#define TRACE_EVENT(call, proto, args, tstruct, func, print) \
	294	int \
	295	ftrace_define_fields_##call(void) \
	296	{ \
	297	struct ftrace_raw_##call field; \
	298	struct ftrace_event_call *event_call = &event_##call; \
	299	int ret; \
	300	\
a118e4d1 TZ	301	__common_field(int, type, 1); \
	302	__common_field(unsigned char, flags, 0); \
	303	__common_field(unsigned char, preempt_count, 0); \
	304	__common_field(int, pid, 1); \
	305	__common_field(int, tgid, 1); \
f42c85e7 SR	306	\
	307	tstruct; \
	308	\
	309	return ret; \
	310	}
	311
	312	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	313
7fcb7c47 LZ	314	/*
	315	* remember the offset of each array from the beginning of the event.
	316	*/
	317
	318	#undef __entry
	319	#define __entry entry
	320
	321	#undef __field
	322	#define __field(type, item)
	323
	324	#undef __array
	325	#define __array(type, item, len)
	326
	327	#undef __dynamic_array
	328	#define __dynamic_array(type, item, len) \
	329	__data_offsets->item = __data_size + \
	330	offsetof(typeof(*entry), __data); \
	331	__data_size += (len) * sizeof(type);
	332
	333	#undef __string
	334	#define __string(item, src) __dynamic_array(char, item, strlen(src) + 1) \
	335
	336	#undef TRACE_EVENT
	337	#define TRACE_EVENT(call, proto, args, tstruct, assign, print) \
	338	static inline int ftrace_get_offsets_##call( \
	339	struct ftrace_data_offsets_##call *__data_offsets, proto) \
	340	{ \
	341	int __data_size = 0; \
	342	struct ftrace_raw_##call __maybe_unused *entry; \
	343	\
	344	tstruct; \
	345	\
	346	return __data_size; \
	347	}
	348
	349	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	350
3a659305 PZ	351	#ifdef CONFIG_EVENT_PROFILE
	352
	353	/*
	354	* Generate the functions needed for tracepoint perf_counter support.
	355	*
f413cdb8	356	* NOTE: The insertion profile callback (ftrace_profile_<call>) is defined later
3a659305 PZ	357	*
	358	* static int ftrace_profile_enable_<call>(struct ftrace_event_call *event_call)
	359	* {
	360	* int ret = 0;
	361	*
	362	* if (!atomic_inc_return(&event_call->profile_count))
	363	* ret = register_trace_<call>(ftrace_profile_<call>);
	364	*
	365	* return ret;
	366	* }
	367	*
	368	* static void ftrace_profile_disable_<call>(struct ftrace_event_call *event_call)
	369	* {
	370	* if (atomic_add_negative(-1, &event->call->profile_count))
	371	* unregister_trace_<call>(ftrace_profile_<call>);
	372	* }
	373	*
	374	*/
	375
3a659305 PZ	376	#undef TRACE_EVENT
	377	#define TRACE_EVENT(call, proto, args, tstruct, assign, print) \
	378	\
f413cdb8	379	static void ftrace_profile_##call(proto); \
3a659305 PZ	380	\
	381	static int ftrace_profile_enable_##call(struct ftrace_event_call *event_call) \
	382	{ \
	383	int ret = 0; \
	384	\
	385	if (!atomic_inc_return(&event_call->profile_count)) \
	386	ret = register_trace_##call(ftrace_profile_##call); \
	387	\
	388	return ret; \
	389	} \
	390	\
	391	static void ftrace_profile_disable_##call(struct ftrace_event_call *event_call)\
	392	{ \
	393	if (atomic_add_negative(-1, &event_call->profile_count)) \
	394	unregister_trace_##call(ftrace_profile_##call); \
	395	}
	396
	397	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	398
3a659305 PZ	399	#endif
3a659305 PZ	400
c32e827b	401	/*
9cbf1176	402	* Stage 4 of the trace events.
c32e827b	403	*
ea20d929	404	* Override the macros in <trace/trace_events.h> to include the following:
c32e827b SR	405	*
	406	* static void ftrace_event_<call>(proto)
	407	* {
ef18012b	408	* event_trace_printk(_RET_IP_, "<call>: " <fmt>);
c32e827b SR	409	* }
	410	*
	411	* static int ftrace_reg_event_<call>(void)
	412	* {
ef18012b	413	* int ret;
c32e827b	414	*
ef18012b SR	415	* ret = register_trace_<call>(ftrace_event_<call>);
	416	* if (!ret)
	417	* pr_info("event trace: Could not activate trace point "
	418	* "probe to <call>");
	419	* return ret;
c32e827b SR	420	* }
	421	*
	422	* static void ftrace_unreg_event_<call>(void)
	423	* {
ef18012b	424	* unregister_trace_<call>(ftrace_event_<call>);
c32e827b SR	425	* }
c32e827b SR	426	*
c32e827b	427	*
157587d7	428	* For those macros defined with TRACE_EVENT:
c32e827b SR	429	*
	430	* static struct ftrace_event_call event_<call>;
	431	*
	432	* static void ftrace_raw_event_<call>(proto)
	433	* {
ef18012b SR	434	* struct ring_buffer_event *event;
	435	* struct ftrace_raw_<call> *entry; <-- defined in stage 1
	436	* unsigned long irq_flags;
	437	* int pc;
	438	*
	439	* local_save_flags(irq_flags);
	440	* pc = preempt_count();
	441	*
	442	* event = trace_current_buffer_lock_reserve(event_<call>.id,
	443	* sizeof(struct ftrace_raw_<call>),
	444	* irq_flags, pc);
	445	* if (!event)
	446	* return;
	447	* entry = ring_buffer_event_data(event);
	448	*
	449	* <assign>; <-- Here we assign the entries by the __field and
0e3d0f05	450	* __array macros.
c32e827b	451	*
ef18012b	452	* trace_current_buffer_unlock_commit(event, irq_flags, pc);
c32e827b SR	453	* }
	454	*
	455	* static int ftrace_raw_reg_event_<call>(void)
	456	* {
ef18012b	457	* int ret;
c32e827b	458	*
ef18012b SR	459	* ret = register_trace_<call>(ftrace_raw_event_<call>);
	460	* if (!ret)
	461	* pr_info("event trace: Could not activate trace point "
	462	* "probe to <call>");
	463	* return ret;
c32e827b SR	464	* }
	465	*
	466	* static void ftrace_unreg_event_<call>(void)
	467	* {
ef18012b	468	* unregister_trace_<call>(ftrace_raw_event_<call>);
c32e827b SR	469	* }
	470	*
	471	* static struct trace_event ftrace_event_type_<call> = {
ef18012b	472	* .trace = ftrace_raw_output_<call>, <-- stage 2
c32e827b SR	473	* };
	474	*
	475	* static int ftrace_raw_init_event_<call>(void)
	476	* {
ef18012b	477	* int id;
c32e827b	478	*
ef18012b SR	479	* id = register_ftrace_event(&ftrace_event_type_<call>);
	480	* if (!id)
	481	* return -ENODEV;
	482	* event_<call>.id = id;
	483	* return 0;
c32e827b SR	484	* }
	485	*
	486	* static struct ftrace_event_call __used
	487	* __attribute__((__aligned__(4)))
	488	* __attribute__((section("_ftrace_events"))) event_<call> = {
ef18012b	489	* .name = "<call>",
0e3d0f05	490	* .system = "<system>",
ef18012b SR	491	* .raw_init = ftrace_raw_init_event_<call>,
	492	* .regfunc = ftrace_reg_event_<call>,
	493	* .unregfunc = ftrace_unreg_event_<call>,
981d081e	494	* .show_format = ftrace_format_<call>,
c32e827b SR	495	* }
	496	*
	497	*/
	498
2939b046 SR	499	#undef TP_FMT
2939b046 SR	500	#define TP_FMT(fmt, args...) fmt "\n", ##args
c32e827b	501
ac199db0	502	#ifdef CONFIG_EVENT_PROFILE
ac199db0 PZ	503
	504	#define _TRACE_PROFILE_INIT(call) \
	505	.profile_count = ATOMIC_INIT(-1), \
	506	.profile_enable = ftrace_profile_enable_##call, \
	507	.profile_disable = ftrace_profile_disable_##call,
	508
	509	#else
ac199db0 PZ	510	#define _TRACE_PROFILE_INIT(call)
	511	#endif
	512
da4d0302 SR	513	#undef __entry
da4d0302 SR	514	#define __entry entry
d20e3b03	515
9cbf1176 FW	516	#undef __field
	517	#define __field(type, item)
	518
	519	#undef __array
	520	#define __array(type, item, len)
	521
7fcb7c47 LZ	522	#undef __dynamic_array
	523	#define __dynamic_array(type, item, len) \
	524	__entry->__data_loc_##item = __data_offsets.item;
	525
9cbf1176	526	#undef __string
7fcb7c47	527	#define __string(item, src) __dynamic_array(char, item, -1) \
9cbf1176 FW	528
	529	#undef __assign_str
	530	#define __assign_str(dst, src) \
9cbf1176 FW	531	strcpy(__get_str(dst), src);
9cbf1176 FW	532
da4d0302	533	#undef TRACE_EVENT
30a8fecc	534	#define TRACE_EVENT(call, proto, args, tstruct, assign, print) \
c32e827b SR	535	\
	536	static struct ftrace_event_call event_##call; \
	537	\
	538	static void ftrace_raw_event_##call(proto) \
	539	{ \
7fcb7c47	540	struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
f2aebaee	541	struct ftrace_event_call *event_call = &event_##call; \
c32e827b SR	542	struct ring_buffer_event *event; \
	543	struct ftrace_raw_##call *entry; \
	544	unsigned long irq_flags; \
7fcb7c47	545	int __data_size; \
c32e827b SR	546	int pc; \
	547	\
	548	local_save_flags(irq_flags); \
	549	pc = preempt_count(); \
	550	\
7fcb7c47	551	__data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
9cbf1176	552	\
c32e827b	553	event = trace_current_buffer_lock_reserve(event_##call.id, \
7fcb7c47	554	sizeof(*entry) + __data_size, \
9cbf1176	555	irq_flags, pc); \
c32e827b SR	556	if (!event) \
	557	return; \
	558	entry = ring_buffer_event_data(event); \
	559	\
7fcb7c47 LZ	560	\
	561	tstruct \
	562	\
a9c1c3ab	563	{ assign; } \
c32e827b	564	\
f2aebaee	565	if (!filter_current_check_discard(event_call, entry, event)) \
77d9f465	566	trace_nowake_buffer_unlock_commit(event, irq_flags, pc); \
c32e827b SR	567	} \
	568	\
	569	static int ftrace_raw_reg_event_##call(void) \
	570	{ \
	571	int ret; \
	572	\
	573	ret = register_trace_##call(ftrace_raw_event_##call); \
633ddaa7	574	if (ret) \
c32e827b	575	pr_info("event trace: Could not activate trace point " \
633ddaa7	576	"probe to " #call "\n"); \
c32e827b SR	577	return ret; \
	578	} \
	579	\
	580	static void ftrace_raw_unreg_event_##call(void) \
	581	{ \
	582	unregister_trace_##call(ftrace_raw_event_##call); \
	583	} \
	584	\
	585	static struct trace_event ftrace_event_type_##call = { \
	586	.trace = ftrace_raw_output_##call, \
	587	}; \
	588	\
	589	static int ftrace_raw_init_event_##call(void) \
	590	{ \
	591	int id; \
	592	\
	593	id = register_ftrace_event(&ftrace_event_type_##call); \
	594	if (!id) \
	595	return -ENODEV; \
	596	event_##call.id = id; \
cf027f64	597	INIT_LIST_HEAD(&event_##call.fields); \
0a19e53c	598	init_preds(&event_##call); \
c32e827b SR	599	return 0; \
	600	} \
	601	\
	602	static struct ftrace_event_call __used \
	603	__attribute__((__aligned__(4))) \
	604	__attribute__((section("_ftrace_events"))) event_##call = { \
ef18012b	605	.name = #call, \
9cc26a26	606	.system = __stringify(TRACE_SYSTEM), \
6d723736	607	.event = &ftrace_event_type_##call, \
c32e827b	608	.raw_init = ftrace_raw_init_event_##call, \
da4d0302 SR	609	.regfunc = ftrace_raw_reg_event_##call, \
da4d0302 SR	610	.unregfunc = ftrace_raw_unreg_event_##call, \
981d081e	611	.show_format = ftrace_format_##call, \
cf027f64	612	.define_fields = ftrace_define_fields_##call, \
ac199db0	613	_TRACE_PROFILE_INIT(call) \
c32e827b	614	}
ac199db0	615
f42c85e7	616	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
ac199db0	617
f413cdb8 FW	618	/*
	619	* Define the insertion callback to profile events
	620	*
	621	* The job is very similar to ftrace_raw_event_<call> except that we don't
	622	* insert in the ring buffer but in a perf counter.
	623	*
	624	* static void ftrace_profile_<call>(proto)
	625	* {
	626	* struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;
	627	* struct ftrace_event_call *event_call = &event_<call>;
	628	* extern void perf_tpcounter_event(int, u64, u64, void *, int);
	629	* struct ftrace_raw_##call *entry;
	630	* u64 __addr = 0, __count = 1;
	631	* unsigned long irq_flags;
	632	* int __entry_size;
	633	* int __data_size;
	634	* int pc;
	635	*
	636	* local_save_flags(irq_flags);
	637	* pc = preempt_count();
	638	*
	639	* __data_size = ftrace_get_offsets_<call>(&__data_offsets, args);
	640	* __entry_size = __data_size + sizeof(*entry);
	641	*
	642	* do {
	643	* char raw_data[__entry_size]; <- allocate our sample in the stack
	644	* struct trace_entry *ent;
	645	*
	646	* entry = (struct ftrace_raw_<call> *)raw_data;
	647	* ent = &entry->ent;
	648	* tracing_generic_entry_update(ent, irq_flags, pc);
	649	* ent->type = event_call->id;
	650	*
	651	* <tstruct> <- do some jobs with dynamic arrays
	652	*
	653	* <assign> <- affect our values
	654	*
	655	* perf_tpcounter_event(event_call->id, __addr, __count, entry,
	656	* __entry_size); <- submit them to perf counter
	657	* } while (0);
	658	*
	659	* }
	660	*/
	661
	662	#ifdef CONFIG_EVENT_PROFILE
	663
	664	#undef __perf_addr
	665	#define __perf_addr(a) __addr = (a)
	666
	667	#undef __perf_count
	668	#define __perf_count(c) __count = (c)
	669
	670	#undef TRACE_EVENT
	671	#define TRACE_EVENT(call, proto, args, tstruct, assign, print) \
	672	static void ftrace_profile_##call(proto) \
	673	{ \
	674	struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
	675	struct ftrace_event_call *event_call = &event_##call; \
	676	extern void perf_tpcounter_event(int, u64, u64, void *, int); \
	677	struct ftrace_raw_##call *entry; \
	678	u64 __addr = 0, __count = 1; \
	679	unsigned long irq_flags; \
	680	int __entry_size; \
	681	int __data_size; \
682	int pc; \
683	\
684	local_save_flags(irq_flags); \
685	pc = preempt_count(); \
686	\
687	__data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
688	__entry_size = ALIGN(__data_size + sizeof(*entry), sizeof(u64));\
689	\
690	do { \
691	char raw_data[__entry_size]; \
692	struct trace_entry *ent; \
693	\
694	entry = (struct ftrace_raw_##call *)raw_data; \
695	ent = &entry->ent; \
696	tracing_generic_entry_update(ent, irq_flags, pc); \
697	ent->type = event_call->id; \
698	\
699	tstruct \
700	\
701	{ assign; } \
702	\
703	perf_tpcounter_event(event_call->id, __addr, __count, entry,\
704	__entry_size); \
705	} while (0); \
706	\
707	}
708
709	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
710	#endif /* CONFIG_EVENT_PROFILE */
711
ac199db0 PZ	712	#undef _TRACE_PROFILE_INIT
ac199db0 PZ	713