[deliverable/linux.git] / include / trace / trace_events.h

/*
 * Stage 1 of the trace events.
 *
 * Override the macros in <trace/trace_events.h> to include the following:
 *
 * struct trace_event_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/trace_events.h>

#ifndef TRACE_SYSTEM_VAR
#define TRACE_SYSTEM_VAR TRACE_SYSTEM
#endif

#define __app__(x, y) str__##x##y
#define __app(x, y) __app__(x, y)

#define TRACE_SYSTEM_STRING __app(TRACE_SYSTEM_VAR,__trace_system_name)

#define TRACE_MAKE_SYSTEM_STR()				\
	static const char TRACE_SYSTEM_STRING[] =	\
		__stringify(TRACE_SYSTEM)

TRACE_MAKE_SYSTEM_STR();

#undef TRACE_DEFINE_ENUM
#define TRACE_DEFINE_ENUM(a)				\
	static struct trace_enum_map __used __initdata	\
	__##TRACE_SYSTEM##_##a =			\
	{						\
		.system = TRACE_SYSTEM_STRING,		\
		.enum_string = #a,			\
		.enum_value = a				\
	};						\
	static struct trace_enum_map __used		\
	__attribute__((section("_ftrace_enum_map")))	\
	*TRACE_SYSTEM##_##a = &__##TRACE_SYSTEM##_##a

/*
 * DECLARE_EVENT_CLASS can be used to add a generic function
 * handlers for events. That is, if all events have the same
 * parameters and just have distinct trace points.
 * Each tracepoint can be defined with DEFINE_EVENT and that
 * will map the DECLARE_EVENT_CLASS to the tracepoint.
 *
 * TRACE_EVENT is a one to one mapping between tracepoint and template.
 */
#undef TRACE_EVENT
#define TRACE_EVENT(name, proto, args, tstruct, assign, print) \
	DECLARE_EVENT_CLASS(name,			       \
			     PARAMS(proto),		       \
			     PARAMS(args),		       \
			     PARAMS(tstruct),		       \
			     PARAMS(assign),		       \
			     PARAMS(print));		       \
	DEFINE_EVENT(name, name, PARAMS(proto), PARAMS(args));


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

#undef __field_ext
#define __field_ext(type, item, filter_type)	type	item;

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

#undef __field_struct_ext
#define __field_struct_ext(type, item, filter_type)	type	item;

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

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

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

#undef __bitmask
#define __bitmask(item, nr_bits) __dynamic_array(char, item, -1)

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

#undef DECLARE_EVENT_CLASS
#define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print)	\
	struct trace_event_raw_##name {					\
		struct trace_entry	ent;				\
		tstruct							\
		char			__data[0];			\
	};								\
									\
	static struct trace_event_class event_class_##name;

#undef DEFINE_EVENT
#define DEFINE_EVENT(template, name, proto, args)	\
	static struct trace_event_call	__used		\
	__attribute__((__aligned__(4))) event_##name

#undef DEFINE_EVENT_FN
#define DEFINE_EVENT_FN(template, name, proto, args, reg, unreg)	\
	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))

#undef DEFINE_EVENT_PRINT
#define DEFINE_EVENT_PRINT(template, name, proto, args, print)	\
	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))

/* Callbacks are meaningless to ftrace. */
#undef TRACE_EVENT_FN
#define TRACE_EVENT_FN(name, proto, args, tstruct,			\
		assign, print, reg, unreg)				\
	TRACE_EVENT(name, PARAMS(proto), PARAMS(args),			\
		PARAMS(tstruct), PARAMS(assign), PARAMS(print))		\

#undef TRACE_EVENT_FLAGS
#define TRACE_EVENT_FLAGS(name, value)					\
	__TRACE_EVENT_FLAGS(name, value)

#undef TRACE_EVENT_PERF_PERM
#define TRACE_EVENT_PERF_PERM(name, expr...)				\
	__TRACE_EVENT_PERF_PERM(name, expr)

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/*
 * Stage 2 of the trace events.
 *
 * Include the following:
 *
 * struct trace_event_data_offsets_<call> {
 *	u32				<item1>;
 *	u32				<item2>;
 *	[...]
 * };
 *
 * The __dynamic_array() macro will create each u32 <item>, this is
 * to keep the offset of each array from the beginning of the event.
 * The size of an array is also encoded, in the higher 16 bits of <item>.
 */

#undef TRACE_DEFINE_ENUM
#define TRACE_DEFINE_ENUM(a)

#undef __field
#define __field(type, item)

#undef __field_ext
#define __field_ext(type, item, filter_type)

#undef __field_struct
#define __field_struct(type, item)

#undef __field_struct_ext
#define __field_struct_ext(type, item, filter_type)

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

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

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

#undef __bitmask
#define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, -1)

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

#undef DEFINE_EVENT
#define DEFINE_EVENT(template, name, proto, args)

#undef DEFINE_EVENT_PRINT
#define DEFINE_EVENT_PRINT(template, name, proto, args, print)	\
	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))

#undef TRACE_EVENT_FLAGS
#define TRACE_EVENT_FLAGS(event, flag)

#undef TRACE_EVENT_PERF_PERM
#define TRACE_EVENT_PERF_PERM(event, expr...)

#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
 * trace_raw_output_<call>(struct trace_iterator *iter, int flags)
 * {
 *	struct trace_seq *s = &iter->seq;
 *	struct trace_event_raw_<call> *field; <-- defined in stage 1
 *	struct trace_entry *entry;
 *	struct trace_seq *p = &iter->tmp_seq;
 *	int ret;
 *
 *	entry = iter->ent;
 *
 *	if (entry->type != event_<call>->event.type) {
 *		WARN_ON_ONCE(1);
 *		return TRACE_TYPE_UNHANDLED;
 *	}
 *
 *	field = (typeof(field))entry;
 *
 *	trace_seq_init(p);
 *	ret = trace_seq_printf(s, "%s: ", <call>);
 *	if (ret)
 *		ret = trace_seq_printf(s, <TP_printk> "\n");
 *	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 & 0xffff))

#undef __get_dynamic_array_len
#define __get_dynamic_array_len(field)	\
		((__entry->__data_loc_##field >> 16) & 0xffff)

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

#undef __get_bitmask
#define __get_bitmask(field)						\
	({								\
		void *__bitmask = __get_dynamic_array(field);		\
		unsigned int __bitmask_size;				\
		__bitmask_size = __get_dynamic_array_len(field);	\
		trace_print_bitmask_seq(p, __bitmask, __bitmask_size);	\
	})

#undef __print_flags
#define __print_flags(flag, delim, flag_array...)			\
	({								\
		static const struct trace_print_flags __flags[] =	\
			{ flag_array, { -1, NULL }};			\
		trace_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 }};			\
		trace_print_symbols_seq(p, value, symbols);		\
	})

#undef __print_symbolic_u64
#if BITS_PER_LONG == 32
#define __print_symbolic_u64(value, symbol_array...)			\
	({								\
		static const struct trace_print_flags_u64 symbols[] =	\
			{ symbol_array, { -1, NULL } };			\
		trace_print_symbols_seq_u64(p, value, symbols);	\
	})
#else
#define __print_symbolic_u64(value, symbol_array...)			\
			__print_symbolic(value, symbol_array)
#endif

#undef __print_hex
#define __print_hex(buf, buf_len) trace_print_hex_seq(p, buf, buf_len)

#undef __print_array
#define __print_array(array, count, el_size)				\
	({								\
		BUILD_BUG_ON(el_size != 1 && el_size != 2 &&		\
			     el_size != 4 && el_size != 8);		\
		trace_print_array_seq(p, array, count, el_size);	\
	})

#undef DECLARE_EVENT_CLASS
#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)	\
static notrace enum print_line_t					\
trace_raw_output_##call(struct trace_iterator *iter, int flags,		\
			struct trace_event *trace_event)		\
{									\
	struct trace_seq *s = &iter->seq;				\
	struct trace_seq __maybe_unused *p = &iter->tmp_seq;		\
	struct trace_event_raw_##call *field;				\
	int ret;							\
									\
	field = (typeof(field))iter->ent;				\
									\
	ret = trace_raw_output_prep(iter, trace_event);			\
	if (ret != TRACE_TYPE_HANDLED)					\
		return ret;						\
									\
	trace_seq_printf(s, print);					\
									\
	return trace_handle_return(s);					\
}									\
static struct trace_event_functions trace_event_type_funcs_##call = {	\
	.trace			= trace_raw_output_##call,		\
};

#undef DEFINE_EVENT_PRINT
#define DEFINE_EVENT_PRINT(template, call, proto, args, print)		\
static notrace enum print_line_t					\
trace_raw_output_##call(struct trace_iterator *iter, int flags,		\
			 struct trace_event *event)			\
{									\
	struct trace_event_raw_##template *field;			\
	struct trace_entry *entry;					\
	struct trace_seq *p = &iter->tmp_seq;				\
									\
	entry = iter->ent;						\
									\
	if (entry->type != event_##call.event.type) {			\
		WARN_ON_ONCE(1);					\
		return TRACE_TYPE_UNHANDLED;				\
	}								\
									\
	field = (typeof(field))entry;					\
									\
	trace_seq_init(p);						\
	return trace_output_call(iter, #call, print);			\
}									\
static struct trace_event_functions trace_event_type_funcs_##call = {	\
	.trace			= trace_raw_output_##call,		\
};

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

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

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

#undef __field
#define __field(type, item)	__field_ext(type, item, FILTER_OTHER)

#undef __field_struct
#define __field_struct(type, item) __field_struct_ext(type, item, FILTER_OTHER)

#undef __array
#define __array(type, item, len)					\
	do {								\
		char *type_str = #type"["__stringify(len)"]";		\
		BUILD_BUG_ON(len > MAX_FILTER_STR_VAL);			\
		ret = trace_define_field(event_call, type_str, #item,	\
				 offsetof(typeof(field), item),		\
				 sizeof(field.item),			\
				 is_signed_type(type), FILTER_OTHER);	\
		if (ret)						\
			return ret;					\
	} while (0);

#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),	       \
				 is_signed_type(type), FILTER_OTHER);

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

#undef __bitmask
#define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, -1)

#undef DECLARE_EVENT_CLASS
#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, func, print)	\
static int notrace __init						\
trace_event_define_fields_##call(struct trace_event_call *event_call)	\
{									\
	struct trace_event_raw_##call field;				\
	int ret;							\
									\
	tstruct;							\
									\
	return ret;							\
}

#undef DEFINE_EVENT
#define DEFINE_EVENT(template, name, proto, args)

#undef DEFINE_EVENT_PRINT
#define DEFINE_EVENT_PRINT(template, name, proto, args, print)	\
	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))

#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 __field_ext
#define __field_ext(type, item, filter_type)

#undef __field_struct
#define __field_struct(type, item)

#undef __field_struct_ext
#define __field_struct_ext(type, item, filter_type)

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

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

#undef __string
#define __string(item, src) __dynamic_array(char, item,			\
		    strlen((src) ? (const char *)(src) : "(null)") + 1)

/*
 * __bitmask_size_in_bytes_raw is the number of bytes needed to hold
 * num_possible_cpus().
 */
#define __bitmask_size_in_bytes_raw(nr_bits)	\
	(((nr_bits) + 7) / 8)

#define __bitmask_size_in_longs(nr_bits)			\
	((__bitmask_size_in_bytes_raw(nr_bits) +		\
	  ((BITS_PER_LONG / 8) - 1)) / (BITS_PER_LONG / 8))

/*
 * __bitmask_size_in_bytes is the number of bytes needed to hold
 * num_possible_cpus() padded out to the nearest long. This is what
 * is saved in the buffer, just to be consistent.
 */
#define __bitmask_size_in_bytes(nr_bits)				\
	(__bitmask_size_in_longs(nr_bits) * (BITS_PER_LONG / 8))

#undef __bitmask
#define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item,	\
					 __bitmask_size_in_longs(nr_bits))

#undef DECLARE_EVENT_CLASS
#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)	\
static inline notrace int trace_event_get_offsets_##call(		\
	struct trace_event_data_offsets_##call *__data_offsets, proto)	\
{									\
	int __data_size = 0;						\
	int __maybe_unused __item_length;				\
	struct trace_event_raw_##call __maybe_unused *entry;		\
									\
	tstruct;							\
									\
	return __data_size;						\
}

#undef DEFINE_EVENT
#define DEFINE_EVENT(template, name, proto, args)

#undef DEFINE_EVENT_PRINT
#define DEFINE_EVENT_PRINT(template, name, proto, args, print)	\
	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
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	*
a7237765	6	* struct trace_event_raw_<call> {
f42c85e7 SR	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
af658dca	19	#include <linux/trace_events.h>
f42c85e7	20
acd388fd SRRH	21	#ifndef TRACE_SYSTEM_VAR
	22	#define TRACE_SYSTEM_VAR TRACE_SYSTEM
	23	#endif
	24
	25	#define __app__(x, y) str__##x##y
	26	#define __app(x, y) __app__(x, y)
	27
	28	#define TRACE_SYSTEM_STRING __app(TRACE_SYSTEM_VAR,__trace_system_name)
	29
	30	#define TRACE_MAKE_SYSTEM_STR() \
	31	static const char TRACE_SYSTEM_STRING[] = \
	32	__stringify(TRACE_SYSTEM)
	33
	34	TRACE_MAKE_SYSTEM_STR();
	35
0c564a53 SRRH	36	#undef TRACE_DEFINE_ENUM
	37	#define TRACE_DEFINE_ENUM(a) \
	38	static struct trace_enum_map __used __initdata \
	39	__##TRACE_SYSTEM##_##a = \
	40	{ \
	41	.system = TRACE_SYSTEM_STRING, \
	42	.enum_string = #a, \
	43	.enum_value = a \
	44	}; \
	45	static struct trace_enum_map __used \
	46	__attribute__((section("_ftrace_enum_map"))) \
	47	*TRACE_SYSTEM##_##a = &__##TRACE_SYSTEM##_##a
	48
ff038f5c	49	/*
091ad365	50	* DECLARE_EVENT_CLASS can be used to add a generic function
ff038f5c SR	51	* handlers for events. That is, if all events have the same
	52	* parameters and just have distinct trace points.
	53	* Each tracepoint can be defined with DEFINE_EVENT and that
091ad365	54	* will map the DECLARE_EVENT_CLASS to the tracepoint.
ff038f5c SR	55	*
	56	* TRACE_EVENT is a one to one mapping between tracepoint and template.
	57	*/
	58	#undef TRACE_EVENT
	59	#define TRACE_EVENT(name, proto, args, tstruct, assign, print) \
091ad365	60	DECLARE_EVENT_CLASS(name, \
ff038f5c SR	61	PARAMS(proto), \
	62	PARAMS(args), \
	63	PARAMS(tstruct), \
	64	PARAMS(assign), \
	65	PARAMS(print)); \
	66	DEFINE_EVENT(name, name, PARAMS(proto), PARAMS(args));
	67
	68
7fcb7c47 LZ	69	#undef __field
	70	#define __field(type, item) type item;
	71
43b51ead LZ	72	#undef __field_ext
	73	#define __field_ext(type, item, filter_type) type item;
	74
4d4c9cc8 SR	75	#undef __field_struct
	76	#define __field_struct(type, item) type item;
	77
	78	#undef __field_struct_ext
	79	#define __field_struct_ext(type, item, filter_type) type item;
	80
f42c85e7 SR	81	#undef __array
	82	#define __array(type, item, len) type item[len];
	83
7fcb7c47	84	#undef __dynamic_array
7d536cb3	85	#define __dynamic_array(type, item, len) u32 __data_loc_##item;
f42c85e7	86
9cbf1176	87	#undef __string
7fcb7c47	88	#define __string(item, src) __dynamic_array(char, item, -1)
9cbf1176	89
4449bf92 SRRH	90	#undef __bitmask
	91	#define __bitmask(item, nr_bits) __dynamic_array(char, item, -1)
	92
f42c85e7 SR	93	#undef TP_STRUCT__entry
	94	#define TP_STRUCT__entry(args...) args
	95
091ad365 IM	96	#undef DECLARE_EVENT_CLASS
091ad365 IM	97	#define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print) \
a7237765	98	struct trace_event_raw_##name { \
ff038f5c SR	99	struct trace_entry ent; \
	100	tstruct \
	101	char __data[0]; \
8f082018 SR	102	}; \
8f082018 SR	103	\
2425bcb9	104	static struct trace_event_class event_class_##name;
8f082018	105
ff038f5c SR	106	#undef DEFINE_EVENT
ff038f5c SR	107	#define DEFINE_EVENT(template, name, proto, args) \
2425bcb9	108	static struct trace_event_call __used \
86c38a31	109	__attribute__((__aligned__(4))) event_##name
f42c85e7	110
f5abaa1b SR	111	#undef DEFINE_EVENT_FN
	112	#define DEFINE_EVENT_FN(template, name, proto, args, reg, unreg) \
	113	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
	114
e5bc9721 SR	115	#undef DEFINE_EVENT_PRINT
	116	#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
	117	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
	118
97419875 JS	119	/* Callbacks are meaningless to ftrace. */
97419875 JS	120	#undef TRACE_EVENT_FN
0dd7b747 FW	121	#define TRACE_EVENT_FN(name, proto, args, tstruct, \
0dd7b747 FW	122	assign, print, reg, unreg) \
819ce45a FW	123	TRACE_EVENT(name, PARAMS(proto), PARAMS(args), \
819ce45a FW	124	PARAMS(tstruct), PARAMS(assign), PARAMS(print)) \
97419875	125
1ed0c597 FW	126	#undef TRACE_EVENT_FLAGS
1ed0c597 FW	127	#define TRACE_EVENT_FLAGS(name, value) \
53cf810b	128	__TRACE_EVENT_FLAGS(name, value)
1ed0c597	129
d5b5f391 PZ	130	#undef TRACE_EVENT_PERF_PERM
	131	#define TRACE_EVENT_PERF_PERM(name, expr...) \
	132	__TRACE_EVENT_PERF_PERM(name, expr)
	133
f42c85e7 SR	134	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	135
	136	/*
	137	* Stage 2 of the trace events.
	138	*
9cbf1176 FW	139	* Include the following:
9cbf1176 FW	140	*
62323a14	141	* struct trace_event_data_offsets_<call> {
7d536cb3 LZ	142	* u32 <item1>;
7d536cb3 LZ	143	* u32 <item2>;
9cbf1176 FW	144	* [...]
	145	* };
	146	*
7d536cb3	147	* The __dynamic_array() macro will create each u32 <item>, this is
7fcb7c47	148	* to keep the offset of each array from the beginning of the event.
7d536cb3	149	* The size of an array is also encoded, in the higher 16 bits of <item>.
9cbf1176 FW	150	*/
9cbf1176 FW	151
0c564a53 SRRH	152	#undef TRACE_DEFINE_ENUM
	153	#define TRACE_DEFINE_ENUM(a)
	154
7fcb7c47	155	#undef __field
43b51ead LZ	156	#define __field(type, item)
	157
	158	#undef __field_ext
	159	#define __field_ext(type, item, filter_type)
7fcb7c47	160
4d4c9cc8 SR	161	#undef __field_struct
	162	#define __field_struct(type, item)
	163
	164	#undef __field_struct_ext
	165	#define __field_struct_ext(type, item, filter_type)
	166
9cbf1176 FW	167	#undef __array
	168	#define __array(type, item, len)
	169
7fcb7c47	170	#undef __dynamic_array
7d536cb3	171	#define __dynamic_array(type, item, len) u32 item;
9cbf1176 FW	172
9cbf1176 FW	173	#undef __string
7fcb7c47	174	#define __string(item, src) __dynamic_array(char, item, -1)
9cbf1176	175
4449bf92 SRRH	176	#undef __bitmask
	177	#define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, -1)
	178
091ad365 IM	179	#undef DECLARE_EVENT_CLASS
091ad365 IM	180	#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
62323a14	181	struct trace_event_data_offsets_##call { \
9cbf1176 FW	182	tstruct; \
	183	};
	184
ff038f5c SR	185	#undef DEFINE_EVENT
	186	#define DEFINE_EVENT(template, name, proto, args)
	187
e5bc9721 SR	188	#undef DEFINE_EVENT_PRINT
	189	#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
	190	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
	191
1ed0c597 FW	192	#undef TRACE_EVENT_FLAGS
	193	#define TRACE_EVENT_FLAGS(event, flag)
	194
d5b5f391 PZ	195	#undef TRACE_EVENT_PERF_PERM
	196	#define TRACE_EVENT_PERF_PERM(event, expr...)
	197
9cbf1176 FW	198	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	199
	200	/*
	201	* Stage 3 of the trace events.
	202	*
f42c85e7 SR	203	* Override the macros in <trace/trace_events.h> to include the following:
	204	*
	205	* enum print_line_t
892c505a	206	* trace_raw_output_<call>(struct trace_iterator *iter, int flags)
f42c85e7 SR	207	* {
f42c85e7 SR	208	* struct trace_seq *s = &iter->seq;
a7237765	209	* struct trace_event_raw_<call> *field; <-- defined in stage 1
f42c85e7	210	* struct trace_entry *entry;
bc289ae9	211	* struct trace_seq *p = &iter->tmp_seq;
f42c85e7 SR	212	* int ret;
	213	*
	214	* entry = iter->ent;
	215	*
32c0edae	216	* if (entry->type != event_<call>->event.type) {
f42c85e7 SR	217	* WARN_ON_ONCE(1);
	218	* return TRACE_TYPE_UNHANDLED;
	219	* }
	220	*
	221	* field = (typeof(field))entry;
	222	*
56d8bd3f	223	* trace_seq_init(p);
50354a8a LZ	224	* ret = trace_seq_printf(s, "%s: ", <call>);
	225	* if (ret)
	226	* ret = trace_seq_printf(s, <TP_printk> "\n");
f42c85e7 SR	227	* if (!ret)
	228	* return TRACE_TYPE_PARTIAL_LINE;
	229	*
	230	* return TRACE_TYPE_HANDLED;
	231	* }
	232	*
	233	* This is the method used to print the raw event to the trace
	234	* output format. Note, this is not needed if the data is read
	235	* in binary.
	236	*/
	237
	238	#undef __entry
	239	#define __entry field
	240
	241	#undef TP_printk
	242	#define TP_printk(fmt, args...) fmt "\n", args
	243
7fcb7c47 LZ	244	#undef __get_dynamic_array
7fcb7c47 LZ	245	#define __get_dynamic_array(field) \
7d536cb3	246	((void *)__entry + (__entry->__data_loc_##field & 0xffff))
7fcb7c47	247
beba4bb0 SRRH	248	#undef __get_dynamic_array_len
	249	#define __get_dynamic_array_len(field) \
	250	((__entry->__data_loc_##field >> 16) & 0xffff)
	251
9cbf1176	252	#undef __get_str
7fcb7c47	253	#define __get_str(field) (char *)__get_dynamic_array(field)
9cbf1176	254
4449bf92 SRRH	255	#undef __get_bitmask
	256	#define __get_bitmask(field) \
	257	({ \
	258	void *__bitmask = __get_dynamic_array(field); \
	259	unsigned int __bitmask_size; \
beba4bb0	260	__bitmask_size = __get_dynamic_array_len(field); \
645df987	261	trace_print_bitmask_seq(p, __bitmask, __bitmask_size); \
4449bf92 SRRH	262	})
4449bf92 SRRH	263
be74b73a SR	264	#undef __print_flags
	265	#define __print_flags(flag, delim, flag_array...) \
	266	({ \
a48f494e	267	static const struct trace_print_flags __flags[] = \
be74b73a	268	{ flag_array, { -1, NULL }}; \
645df987	269	trace_print_flags_seq(p, delim, flag, __flags); \
be74b73a SR	270	})
be74b73a SR	271
0f4fc29d SR	272	#undef __print_symbolic
	273	#define __print_symbolic(value, symbol_array...) \
	274	({ \
	275	static const struct trace_print_flags symbols[] = \
	276	{ symbol_array, { -1, NULL }}; \
645df987	277	trace_print_symbols_seq(p, value, symbols); \
0f4fc29d SR	278	})
0f4fc29d SR	279
2fc1b6f0	280	#undef __print_symbolic_u64
	281	#if BITS_PER_LONG == 32
	282	#define __print_symbolic_u64(value, symbol_array...) \
	283	({ \
	284	static const struct trace_print_flags_u64 symbols[] = \
	285	{ symbol_array, { -1, NULL } }; \
645df987	286	trace_print_symbols_seq_u64(p, value, symbols); \
2fc1b6f0	287	})
	288	#else
	289	#define __print_symbolic_u64(value, symbol_array...) \
	290	__print_symbolic(value, symbol_array)
	291	#endif
	292
5a2e3995	293	#undef __print_hex
645df987	294	#define __print_hex(buf, buf_len) trace_print_hex_seq(p, buf, buf_len)
5a2e3995	295
6ea22486 DM	296	#undef __print_array
	297	#define __print_array(array, count, el_size) \
	298	({ \
	299	BUILD_BUG_ON(el_size != 1 && el_size != 2 && \
	300	el_size != 4 && el_size != 8); \
645df987	301	trace_print_array_seq(p, array, count, el_size); \
6ea22486 DM	302	})
6ea22486 DM	303
091ad365 IM	304	#undef DECLARE_EVENT_CLASS
091ad365 IM	305	#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
83f0d539	306	static notrace enum print_line_t \
892c505a SRRH	307	trace_raw_output_##call(struct trace_iterator *iter, int flags, \
892c505a SRRH	308	struct trace_event *trace_event) \
f42c85e7 SR	309	{ \
f42c85e7 SR	310	struct trace_seq *s = &iter->seq; \
f71130de	311	struct trace_seq __maybe_unused *p = &iter->tmp_seq; \
a7237765	312	struct trace_event_raw_##call *field; \
f42c85e7 SR	313	int ret; \
f42c85e7 SR	314	\
f71130de	315	field = (typeof(field))iter->ent; \
80decc70	316	\
892c505a	317	ret = trace_raw_output_prep(iter, trace_event); \
8e2e095c	318	if (ret != TRACE_TYPE_HANDLED) \
f71130de LZ	319	return ret; \
f71130de LZ	320	\
19a7fe20	321	trace_seq_printf(s, print); \
f42c85e7	322	\
19a7fe20	323	return trace_handle_return(s); \
80decc70	324	} \
3ad017ba	325	static struct trace_event_functions trace_event_type_funcs_##call = { \
892c505a	326	.trace = trace_raw_output_##call, \
80decc70	327	};
ff038f5c	328
e5bc9721 SR	329	#undef DEFINE_EVENT_PRINT
e5bc9721 SR	330	#define DEFINE_EVENT_PRINT(template, call, proto, args, print) \
83f0d539	331	static notrace enum print_line_t \
892c505a	332	trace_raw_output_##call(struct trace_iterator *iter, int flags, \
a9a57763	333	struct trace_event *event) \
e5bc9721	334	{ \
a7237765	335	struct trace_event_raw_##template *field; \
e5bc9721	336	struct trace_entry *entry; \
bc289ae9	337	struct trace_seq *p = &iter->tmp_seq; \
f42c85e7 SR	338	\
	339	entry = iter->ent; \
	340	\
32c0edae	341	if (entry->type != event_##call.event.type) { \
f42c85e7 SR	342	WARN_ON_ONCE(1); \
	343	return TRACE_TYPE_UNHANDLED; \
	344	} \
	345	\
	346	field = (typeof(field))entry; \
	347	\
56d8bd3f	348	trace_seq_init(p); \
892c505a	349	return trace_output_call(iter, #call, print); \
80decc70	350	} \
3ad017ba	351	static struct trace_event_functions trace_event_type_funcs_##call = { \
892c505a	352	.trace = trace_raw_output_##call, \
80decc70	353	};
e5bc9721	354
f42c85e7 SR	355	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
f42c85e7 SR	356
43b51ead LZ	357	#undef __field_ext
43b51ead LZ	358	#define __field_ext(type, item, filter_type) \
f42c85e7 SR	359	ret = trace_define_field(event_call, #type, #item, \
f42c85e7 SR	360	offsetof(typeof(field), item), \
43b51ead LZ	361	sizeof(field.item), \
43b51ead LZ	362	is_signed_type(type), filter_type); \
f42c85e7 SR	363	if (ret) \
	364	return ret;
	365
4d4c9cc8 SR	366	#undef __field_struct_ext
	367	#define __field_struct_ext(type, item, filter_type) \
	368	ret = trace_define_field(event_call, #type, #item, \
	369	offsetof(typeof(field), item), \
	370	sizeof(field.item), \
	371	0, filter_type); \
	372	if (ret) \
	373	return ret;
	374
43b51ead LZ	375	#undef __field
	376	#define __field(type, item) __field_ext(type, item, FILTER_OTHER)
	377
4d4c9cc8 SR	378	#undef __field_struct
	379	#define __field_struct(type, item) __field_struct_ext(type, item, FILTER_OTHER)
	380
f42c85e7 SR	381	#undef __array
f42c85e7 SR	382	#define __array(type, item, len) \
04295780	383	do { \
87291347	384	char *type_str = #type"["__stringify(len)"]"; \
04295780	385	BUILD_BUG_ON(len > MAX_FILTER_STR_VAL); \
87291347	386	ret = trace_define_field(event_call, type_str, #item, \
f42c85e7	387	offsetof(typeof(field), item), \
fb7ae981 LJ	388	sizeof(field.item), \
fb7ae981 LJ	389	is_signed_type(type), FILTER_OTHER); \
04295780 SR	390	if (ret) \
	391	return ret; \
	392	} while (0);
f42c85e7	393
7fcb7c47 LZ	394	#undef __dynamic_array
7fcb7c47 LZ	395	#define __dynamic_array(type, item, len) \
68fd60a8	396	ret = trace_define_field(event_call, "__data_loc " #type "[]", #item, \
43b51ead	397	offsetof(typeof(field), __data_loc_##item), \
fb7ae981 LJ	398	sizeof(field.__data_loc_##item), \
fb7ae981 LJ	399	is_signed_type(type), FILTER_OTHER);
7fcb7c47	400
9cbf1176	401	#undef __string
7fcb7c47	402	#define __string(item, src) __dynamic_array(char, item, -1)
9cbf1176	403
4449bf92 SRRH	404	#undef __bitmask
	405	#define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, -1)
	406
091ad365 IM	407	#undef DECLARE_EVENT_CLASS
091ad365 IM	408	#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, func, print) \
7e4f44b1	409	static int notrace __init \
33d0f35e	410	trace_event_define_fields_##call(struct trace_event_call *event_call) \
f42c85e7	411	{ \
a7237765	412	struct trace_event_raw_##call field; \
f42c85e7 SR	413	int ret; \
f42c85e7 SR	414	\
f42c85e7 SR	415	tstruct; \
	416	\
	417	return ret; \
	418	}
	419
ff038f5c SR	420	#undef DEFINE_EVENT
	421	#define DEFINE_EVENT(template, name, proto, args)
	422
e5bc9721 SR	423	#undef DEFINE_EVENT_PRINT
	424	#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
	425	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
	426
f42c85e7 SR	427	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
f42c85e7 SR	428
7fcb7c47 LZ	429	/*
	430	* remember the offset of each array from the beginning of the event.
	431	*/
	432
	433	#undef __entry
	434	#define __entry entry
	435
	436	#undef __field
	437	#define __field(type, item)
	438
43b51ead LZ	439	#undef __field_ext
	440	#define __field_ext(type, item, filter_type)
	441
4d4c9cc8 SR	442	#undef __field_struct
	443	#define __field_struct(type, item)
	444
	445	#undef __field_struct_ext
	446	#define __field_struct_ext(type, item, filter_type)
	447
7fcb7c47 LZ	448	#undef __array
	449	#define __array(type, item, len)
	450
	451	#undef __dynamic_array
	452	#define __dynamic_array(type, item, len) \
114e7b52	453	__item_length = (len) * sizeof(type); \
7fcb7c47 LZ	454	__data_offsets->item = __data_size + \
7fcb7c47 LZ	455	offsetof(typeof(*entry), __data); \
114e7b52 FB	456	__data_offsets->item \|= __item_length << 16; \
114e7b52 FB	457	__data_size += __item_length;
7fcb7c47 LZ	458
7fcb7c47 LZ	459	#undef __string
4e58e547 SRRH	460	#define __string(item, src) __dynamic_array(char, item, \
4e58e547 SRRH	461	strlen((src) ? (const char *)(src) : "(null)") + 1)
7fcb7c47	462
4449bf92 SRRH	463	/*
	464	* __bitmask_size_in_bytes_raw is the number of bytes needed to hold
	465	* num_possible_cpus().
	466	*/
	467	#define __bitmask_size_in_bytes_raw(nr_bits) \
	468	(((nr_bits) + 7) / 8)
	469
	470	#define __bitmask_size_in_longs(nr_bits) \
	471	((__bitmask_size_in_bytes_raw(nr_bits) + \
	472	((BITS_PER_LONG / 8) - 1)) / (BITS_PER_LONG / 8))
	473
	474	/*
	475	* __bitmask_size_in_bytes is the number of bytes needed to hold
	476	* num_possible_cpus() padded out to the nearest long. This is what
	477	* is saved in the buffer, just to be consistent.
	478	*/
	479	#define __bitmask_size_in_bytes(nr_bits) \
	480	(__bitmask_size_in_longs(nr_bits) * (BITS_PER_LONG / 8))
	481
	482	#undef __bitmask
	483	#define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, \
	484	__bitmask_size_in_longs(nr_bits))
	485
091ad365 IM	486	#undef DECLARE_EVENT_CLASS
091ad365 IM	487	#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
d0ee8f4a	488	static inline notrace int trace_event_get_offsets_##call( \
62323a14	489	struct trace_event_data_offsets_##call *__data_offsets, proto) \
7fcb7c47 LZ	490	{ \
7fcb7c47 LZ	491	int __data_size = 0; \
114e7b52	492	int __maybe_unused __item_length; \
a7237765	493	struct trace_event_raw_##call __maybe_unused *entry; \
7fcb7c47 LZ	494	\
	495	tstruct; \
	496	\
	497	return __data_size; \
	498	}
	499
ff038f5c SR	500	#undef DEFINE_EVENT
	501	#define DEFINE_EVENT(template, name, proto, args)
	502
e5bc9721 SR	503	#undef DEFINE_EVENT_PRINT
	504	#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
	505	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
	506
7fcb7c47 LZ	507	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
7fcb7c47 LZ	508