/* * 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> /* * 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 __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 TP_STRUCT__entry#define TP_STRUCT__entry(args...) args #undef DECLARE_EVENT_CLASS#define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print)	\	struct ftrace_raw_##name {					\		struct trace_entry	ent;				\		tstruct							\		char			__data[0];			\	};								\									\	static struct ftrace_event_class event_class_##name; #undef DEFINE_EVENT#define DEFINE_EVENT(template, name, proto, args)	\	static struct ftrace_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 ftrace_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 __field#define __field(type, item) #undef __field_ext#define __field_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 DECLARE_EVENT_CLASS#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)	\	struct ftrace_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 * 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 = &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_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 __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 } };			\		ftrace_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) ftrace_print_hex_seq(p, buf, buf_len) #undef DECLARE_EVENT_CLASS#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)	\static notrace enum print_line_t					\ftrace_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 ftrace_raw_##call *field;				\	int ret;							\									\	field = (typeof(field))iter->ent;				\									\	ret = ftrace_raw_output_prep(iter, trace_event);		\	if (ret)							\		return ret;						\									\	ret = trace_seq_printf(s, print);				\	if (!ret)							\		return TRACE_TYPE_PARTIAL_LINE;				\									\	return TRACE_TYPE_HANDLED;					\}									\static struct trace_event_functions ftrace_event_type_funcs_##call = {	\	.trace			= ftrace_raw_output_##call,		\}; #undef DEFINE_EVENT_PRINT#define DEFINE_EVENT_PRINT(template, call, proto, args, print)		\static notrace enum print_line_t					\ftrace_raw_output_##call(struct trace_iterator *iter, int flags,	\			 struct trace_event *event)			\{									\	struct trace_seq *s = &iter->seq;				\	struct ftrace_raw_##template *field;				\	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, print);			\	if (!ret)							\		return TRACE_TYPE_PARTIAL_LINE;				\									\	return TRACE_TYPE_HANDLED;					\}									\static struct trace_event_functions ftrace_event_type_funcs_##call = {	\	.trace			= ftrace_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#define __field(type, item)	__field_ext(type, item, FILTER_OTHER) #undef __array#define __array(type, item, len)					\	do {								\		mutex_lock(&event_storage_mutex);			\		BUILD_BUG_ON(len > MAX_FILTER_STR_VAL);			\		snprintf(event_storage, sizeof(event_storage),		\			 "%s[%d]", #type, len);				\		ret = trace_define_field(event_call, event_storage, #item, \				 offsetof(typeof(field), item),		\				 sizeof(field.item),			\				 is_signed_type(type), FILTER_OTHER);	\		mutex_unlock(&event_storage_mutex);			\		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 DECLARE_EVENT_CLASS#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, func, print)	\static int notrace __init						\ftrace_define_fields_##call(struct ftrace_event_call *event_call)	\{									\	struct ftrace_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 __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_offsets->item |= (len * sizeof(type)) << 16;		\	__data_size += (len) * sizeof(type); #undef __string#define __string(item, src) __dynamic_array(char, item,			\		    strlen((src) ? (const char *)(src) : "(null)") + 1) #undef DECLARE_EVENT_CLASS#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)	\static inline notrace 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;						\} #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) /* * Stage 4 of the trace events. * * Override the macros in <trace/trace_events.h> to include the following: * * For those macros defined with TRACE_EVENT: * * static struct ftrace_event_call event_<call>; * * static void ftrace_raw_event_<call>(void *__data, proto) * { *	struct ftrace_event_file *ftrace_file = __data; *	struct ftrace_event_call *event_call = ftrace_file->event_call; *	struct ftrace_data_offsets_<call> __maybe_unused __data_offsets; *	struct ring_buffer_event *event; *	struct ftrace_raw_<call> *entry; <-- defined in stage 1 *	struct ring_buffer *buffer; *	unsigned long irq_flags; *	int __data_size; *	int pc; * *	if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, *		     &ftrace_file->flags)) *		return; * *	local_save_flags(irq_flags); *	pc = preempt_count(); * *	__data_size = ftrace_get_offsets_<call>(&__data_offsets, args); * *	event = trace_event_buffer_lock_reserve(&buffer, ftrace_file, *				  event_<call>->event.type, *				  sizeof(*entry) + __data_size, *				  irq_flags, pc); *	if (!event) *		return; *	entry	= ring_buffer_event_data(event); * *	{ <assign>; }  <-- Here we assign the entries by the __field and *			   __array macros. * *	if (!filter_check_discard(ftrace_file, entry, buffer, event)) *		trace_buffer_unlock_commit(buffer, event, irq_flags, pc); * } * * static struct trace_event ftrace_event_type_<call> = { *	.trace			= ftrace_raw_output_<call>, <-- stage 2 * }; * * static const char print_fmt_<call>[] = <TP_printk>; * * static struct ftrace_event_class __used event_class_<template> = { *	.system			= "<system>", *	.define_fields		= ftrace_define_fields_<call>, *	.fields			= LIST_HEAD_INIT(event_class_##call.fields), *	.raw_init		= trace_event_raw_init, *	.probe			= ftrace_raw_event_##call, *	.reg			= ftrace_event_reg, * }; * * static struct ftrace_event_call event_<call> = { *	.name			= "<call>", *	.class			= event_class_<template>, *	.event			= &ftrace_event_type_<call>, *	.print_fmt		= print_fmt_<call>, * }; * // its only safe to use pointers when doing linker tricks to * // create an array. * static struct ftrace_event_call __used * __attribute__((section("_ftrace_events"))) *__event_<call> = &event_<call>; * */ #ifdef CONFIG_PERF_EVENTS #define _TRACE_PERF_PROTO(call, proto)					\	static notrace void						\	perf_trace_##call(void *__data, proto); #define _TRACE_PERF_INIT(call)						\	.perf_probe		= perf_trace_##call, #else#define _TRACE_PERF_PROTO(call, proto)#define _TRACE_PERF_INIT(call)#endif /* CONFIG_PERF_EVENTS */ #undef __entry#define __entry entry #undef __field#define __field(type, item) #undef __array

Lines 1–500 of 720. Load more