1 files changed, 86 insertions, 153 deletions
diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
index 4eb2148f1321..0152b8673bd7 100644
--- a/include/trace/ftrace.h
+++ b/include/trace/ftrace.h
@@ -62,7 +62,10 @@
                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                 \
@@ -147,7 +150,7 @@
 *
 *      entry = iter->ent;
 *
- *      if (entry->type != event_<call>.id) {
+ *      if (entry->type != event_<call>->event.type) {
 *              WARN_ON_ONCE(1);
 *              return TRACE_TYPE_UNHANDLED;
 *      }
@@ -203,18 +206,22 @@
 #undef DECLARE_EVENT_CLASS
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
 static notrace enum print_line_t                                        \
-ftrace_raw_output_id_##call(int event_id, const char *name,             \
+ftrace_raw_output_##call(struct trace_iterator *iter, int flags,        \
-                            struct trace_iterator *iter, int flags)     \
+                         struct trace_event *trace_event)               \
 {                                                                       \
+        struct ftrace_event_call *event;                                \
        struct trace_seq *s = &iter->seq;                               \
        struct ftrace_raw_##call *field;                                \
        struct trace_entry *entry;                                      \
        struct trace_seq *p;                                            \
        int ret;                                                        \
                                                                        \
+        event = container_of(trace_event, struct ftrace_event_call,     \
+                             event);                                    \
+                                                                        \
        entry = iter->ent;                                              \
                                                                        \
-        if (entry->type != event_id) {                                  \
+        if (entry->type != event->event.type) {                         \
                WARN_ON_ONCE(1);                                        \
                return TRACE_TYPE_UNHANDLED;                            \
        }                                                               \
@@ -223,7 +230,7 @@ ftrace_raw_output_id_##call(int event_id, const char *name,		\
                                                                        \
        p = &get_cpu_var(ftrace_event_seq);                             \
        trace_seq_init(p);                                              \
-        ret = trace_seq_printf(s, "%s: ", name);                        \
+        ret = trace_seq_printf(s, "%s: ", event->name);                 \
        if (ret)                                                        \
                ret = trace_seq_printf(s, print);                       \
        put_cpu();                                                      \
@@ -231,21 +238,16 @@ ftrace_raw_output_id_##call(int event_id, const char *name,		\
                return TRACE_TYPE_PARTIAL_LINE;                         \
                                                                        \
        return TRACE_TYPE_HANDLED;                                      \
-}
+}                                                                       \
+static struct trace_event_functions ftrace_event_type_funcs_##call = {  \
-#undef DEFINE_EVENT
+        .trace                  = ftrace_raw_output_##call,             \
-#define DEFINE_EVENT(template, name, proto, args)                       \
+};
-static notrace enum print_line_t                                        \
-ftrace_raw_output_##name(struct trace_iterator *iter, int flags)        \
-{                                                                       \
-        return ftrace_raw_output_id_##template(event_##name.id,         \
-                                               #name, iter, flags);     \
-}
 #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)        \
+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;                            \
@@ -255,7 +257,7 @@ ftrace_raw_output_##call(struct trace_iterator *iter, int flags)	\
                                                                        \
        entry = iter->ent;                                              \
                                                                        \
-        if (entry->type != event_##call.id) {                           \
+        if (entry->type != event_##call.event.type) {                   \
                WARN_ON_ONCE(1);                                        \
                return TRACE_TYPE_UNHANDLED;                            \
        }                                                               \
@@ -272,7 +274,10 @@ ftrace_raw_output_##call(struct trace_iterator *iter, int flags)	\
                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)
@@ -378,80 +383,18 @@ static inline notrace int ftrace_get_offsets_##call(			\
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
-#ifdef CONFIG_PERF_EVENTS
-/*
- * Generate the functions needed for tracepoint perf_event support.
- *
- * NOTE: The insertion profile callback (ftrace_profile_<call>) is defined later
- *
- * static int ftrace_profile_enable_<call>(void)
- * {
- *      return register_trace_<call>(ftrace_profile_<call>);
- * }
- *
- * static void ftrace_profile_disable_<call>(void)
- * {
- *      unregister_trace_<call>(ftrace_profile_<call>);
- * }
- *
- */
-#undef DECLARE_EVENT_CLASS
-#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)
-#undef DEFINE_EVENT
-#define DEFINE_EVENT(template, name, proto, args)                       \
-                                                                        \
-static void perf_trace_##name(proto);                                   \
-                                                                        \
-static notrace int                                                      \
-perf_trace_enable_##name(struct ftrace_event_call *unused)              \
-{                                                                       \
-        return register_trace_##name(perf_trace_##name);                \
-}                                                                       \
-                                                                        \
-static notrace void                                                     \
-perf_trace_disable_##name(struct ftrace_event_call *unused)             \
-{                                                                       \
-        unregister_trace_##name(perf_trace_##name);                     \
-}
-#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)
-#endif /* CONFIG_PERF_EVENTS */
 /*
 * 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>(struct ftrace_event_call *unused)
- * {
- *      return register_trace_<call>(ftrace_event_<call>);
- * }
- *
- * static void ftrace_unreg_event_<call>(struct ftrace_event_call *unused)
- * {
- *      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)
+ * static void ftrace_raw_event_<call>(void *__data, proto)
 * {
+ *      struct ftrace_event_call *event_call = __data;
 *      struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;
 *      struct ring_buffer_event *event;
 *      struct ftrace_raw_<call> *entry; <-- defined in stage 1
@@ -466,7 +409,7 @@ perf_trace_disable_##name(struct ftrace_event_call *unused)		\
 *      __data_size = ftrace_get_offsets_<call>(&__data_offsets, args);
 *
 *      event = trace_current_buffer_lock_reserve(&buffer,
- *                                event_<call>.id,
+ *                                event_<call>->event.type,
 *                                sizeof(*entry) + __data_size,
 *                                irq_flags, pc);
 *      if (!event)
@@ -481,43 +424,42 @@ perf_trace_disable_##name(struct ftrace_event_call *unused)		\
 *                                                 event, irq_flags, pc);
 * }
 *
- * static int ftrace_raw_reg_event_<call>(struct ftrace_event_call *unused)
- * {
- *      return register_trace_<call>(ftrace_raw_event_<call>);
- * }
- *
- * static void ftrace_unreg_event_<call>(struct ftrace_event_call *unused)
- * {
- *      unregister_trace_<call>(ftrace_raw_event_<call>);
- * }
- *
 * 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,
+ * };
+ *
 * static struct ftrace_event_call __used
 * __attribute__((__aligned__(4)))
 * __attribute__((section("_ftrace_events"))) event_<call> = {
 *      .name                   = "<call>",
- *      .system                 = "<system>",
+ *      .class                  = event_class_<template>,
- *      .raw_init               = trace_event_raw_init,
+ *      .event                  = &ftrace_event_type_<call>,
- *      .regfunc                = ftrace_reg_event_<call>,
- *      .unregfunc              = ftrace_unreg_event_<call>,
 *      .print_fmt              = print_fmt_<call>,
- *      .define_fields          = ftrace_define_fields_<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_event_enable = perf_trace_enable_##call,                  \
+        .perf_probe             = perf_trace_##call,
-        .perf_event_disable = perf_trace_disable_##call,
 #else
+#define _TRACE_PERF_PROTO(call, proto)
 #define _TRACE_PERF_INIT(call)
 #endif /* CONFIG_PERF_EVENTS */
@@ -551,9 +493,9 @@ perf_trace_disable_##name(struct ftrace_event_call *unused)		\
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
                                                                        \
 static notrace void                                                     \
-ftrace_raw_event_id_##call(struct ftrace_event_call *event_call,        \
+ftrace_raw_event_##call(void *__data, proto)                            \
-                                       proto)                           \
 {                                                                       \
+        struct ftrace_event_call *event_call = __data;                  \
        struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
        struct ring_buffer_event *event;                                \
        struct ftrace_raw_##call *entry;                                \
@@ -568,7 +510,7 @@ ftrace_raw_event_id_##call(struct ftrace_event_call *event_call,	\
        __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
                                                                        \
        event = trace_current_buffer_lock_reserve(&buffer,              \
-                                 event_call->id,                        \
+                                 event_call->event.type,                \
                                 sizeof(*entry) + __data_size,          \
                                 irq_flags, pc);                        \
        if (!event)                                                     \
@@ -583,34 +525,21 @@ ftrace_raw_event_id_##call(struct ftrace_event_call *event_call,	\
                trace_nowake_buffer_unlock_commit(buffer,               \
                                                  event, irq_flags, pc); \
 }
+/*
+ * The ftrace_test_probe is compiled out, it is only here as a build time check
+ * to make sure that if the tracepoint handling changes, the ftrace probe will
+ * fail to compile unless it too is updated.
+ */
 #undef DEFINE_EVENT
 #define DEFINE_EVENT(template, call, proto, args)                       \
-                                                                        \
+static inline void ftrace_test_probe_##call(void)                       \
-static notrace void ftrace_raw_event_##call(proto)                      \
-{                                                                       \
-        ftrace_raw_event_id_##template(&event_##call, args);            \
-}                                                                       \
-                                                                        \
-static notrace int                                                      \
-ftrace_raw_reg_event_##call(struct ftrace_event_call *unused)           \
-{                                                                       \
-        return register_trace_##call(ftrace_raw_event_##call);          \
-}                                                                       \
-                                                                        \
-static notrace void                                                     \
-ftrace_raw_unreg_event_##call(struct ftrace_event_call *unused)         \
 {                                                                       \
-        unregister_trace_##call(ftrace_raw_event_##call);               \
+        check_trace_callback_type_##call(ftrace_raw_event_##template);  \
-}                                                                       \
+}
-                                                                        \
-static struct trace_event ftrace_event_type_##call = {                  \
-        .trace                  = ftrace_raw_output_##call,             \
-};
 #undef DEFINE_EVENT_PRINT
-#define DEFINE_EVENT_PRINT(template, name, proto, args, print)  \
+#define DEFINE_EVENT_PRINT(template, name, proto, args, print)
-        DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
@@ -627,7 +556,16 @@ static struct trace_event ftrace_event_type_##call = {			\
 #undef DECLARE_EVENT_CLASS
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
-static const char print_fmt_##call[] = print;
+_TRACE_PERF_PROTO(call, PARAMS(proto));                                 \
+static const char print_fmt_##call[] = print;                           \
+static struct ftrace_event_class __used event_class_##call = {          \
+        .system                 = __stringify(TRACE_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,              \
+        _TRACE_PERF_INIT(call)                                          \
+};
 #undef DEFINE_EVENT
 #define DEFINE_EVENT(template, call, proto, args)                       \
@@ -636,15 +574,10 @@ static struct ftrace_event_call __used					\
 __attribute__((__aligned__(4)))                                         \
 __attribute__((section("_ftrace_events"))) event_##call = {             \
        .name                   = #call,                                \
-        .system                 = __stringify(TRACE_SYSTEM),            \
+        .class                  = &event_class_##template,              \
-        .event                  = &ftrace_event_type_##call,            \
+        .event.funcs            = &ftrace_event_type_funcs_##template,  \
-        .raw_init               = trace_event_raw_init,                 \
-        .regfunc                = ftrace_raw_reg_event_##call,          \
-        .unregfunc              = ftrace_raw_unreg_event_##call,        \
        .print_fmt              = print_fmt_##template,                 \
-        .define_fields          = ftrace_define_fields_##template,      \
+};
-        _TRACE_PERF_INIT(call)                                  \
-}
 #undef DEFINE_EVENT_PRINT
 #define DEFINE_EVENT_PRINT(template, call, proto, args, print)          \
@@ -655,14 +588,9 @@ static struct ftrace_event_call __used					\
 __attribute__((__aligned__(4)))                                         \
 __attribute__((section("_ftrace_events"))) event_##call = {             \
        .name                   = #call,                                \
-        .system                 = __stringify(TRACE_SYSTEM),            \
+        .class                  = &event_class_##template,              \
-        .event                  = &ftrace_event_type_##call,            \
+        .event.funcs            = &ftrace_event_type_funcs_##call,      \
-        .raw_init               = trace_event_raw_init,                 \
-        .regfunc                = ftrace_raw_reg_event_##call,          \
-        .unregfunc              = ftrace_raw_unreg_event_##call,        \
        .print_fmt              = print_fmt_##call,                     \
-        .define_fields          = ftrace_define_fields_##template,      \
-        _TRACE_PERF_INIT(call)                                  \
 }
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
@@ -762,17 +690,20 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
 #undef DECLARE_EVENT_CLASS
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
 static notrace void                                                     \
-perf_trace_templ_##call(struct ftrace_event_call *event_call,           \
+perf_trace_##call(void *__data, proto)                                  \
-                        struct pt_regs *__regs, proto)                  \
 {                                                                       \
+        struct ftrace_event_call *event_call = __data;                  \
        struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
        struct ftrace_raw_##call *entry;                                \
+        struct pt_regs __regs;                                          \
        u64 __addr = 0, __count = 1;                                    \
        struct hlist_head *head;                                        \
        int __entry_size;                                               \
        int __data_size;                                                \
        int rctx;                                                       \
                                                                        \
+        perf_fetch_caller_regs(&__regs, 1);                             \
+                                                                        \
        __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
        __entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),\
                             sizeof(u64));                              \
@@ -783,7 +714,7 @@ perf_trace_templ_##call(struct ftrace_event_call *event_call,		\
                return;                                                 \
                                                                        \
        entry = (struct ftrace_raw_##call *)perf_trace_buf_prepare(     \
-                __entry_size, event_call->id, __regs, &rctx);           \
+                __entry_size, event_call->event.type, &__regs, &rctx);  \
        if (!entry)                                                     \
                return;                                                 \
                                                                        \
@@ -793,20 +724,22 @@ perf_trace_templ_##call(struct ftrace_event_call *event_call,		\
                                                                        \
        head = per_cpu_ptr(event_call->perf_events, smp_processor_id());\
        perf_trace_buf_submit(entry, __entry_size, rctx, __addr,        \
-                __count, __regs, head);                                 \
+                __count, &__regs, head);                                \
 }
+/*
+ * This part is compiled out, it is only here as a build time check
+ * to make sure that if the tracepoint handling changes, the
+ * perf probe will fail to compile unless it too is updated.
+ */
 #undef DEFINE_EVENT
 #define DEFINE_EVENT(template, call, proto, args)                       \
-static notrace void perf_trace_##call(proto)                            \
+static inline void perf_test_probe_##call(void)                         \
 {                                                                       \
-        struct ftrace_event_call *event_call = &event_##call;           \
+        check_trace_callback_type_##call(perf_trace_##template);        \
-        struct pt_regs __regs;                                          \
-                                                                        \
-        perf_fetch_caller_regs(&__regs, 1);                             \
-        perf_trace_templ_##template(event_call, &__regs, args);         \
 }
 #undef DEFINE_EVENT_PRINT
 #define DEFINE_EVENT_PRINT(template, name, proto, args, print)  \
        DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))

diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h index 4eb2148f1321..0152b8673bd7 100644 --- a/include/trace/ftrace.h +++ b/include/trace/ftrace.h
@@ -62,7 +62,10 @@
62	struct trace_entry ent; \	62	struct trace_entry ent; \
63	tstruct \	63	tstruct \
64	char __data[0]; \	64	char __data[0]; \
65	};	65	}; \
		66	\
		67	static struct ftrace_event_class event_class_##name;
		68
66	#undef DEFINE_EVENT	69	#undef DEFINE_EVENT
67	#define DEFINE_EVENT(template, name, proto, args) \	70	#define DEFINE_EVENT(template, name, proto, args) \
68	static struct ftrace_event_call \	71	static struct ftrace_event_call \
@@ -147,7 +150,7 @@
147	*	150	*
148	* entry = iter->ent;	151	* entry = iter->ent;
149	*	152	*
150	* if (entry->type != event_<call>.id) {	153	* if (entry->type != event_<call>->event.type) {
151	* WARN_ON_ONCE(1);	154	* WARN_ON_ONCE(1);
152	* return TRACE_TYPE_UNHANDLED;	155	* return TRACE_TYPE_UNHANDLED;
153	* }	156	* }
@@ -203,18 +206,22 @@
203	#undef DECLARE_EVENT_CLASS	206	#undef DECLARE_EVENT_CLASS
204	#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \	207	#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
205	static notrace enum print_line_t \	208	static notrace enum print_line_t \
206	ftrace_raw_output_id_##call(int event_id, const char *name, \	209	ftrace_raw_output_##call(struct trace_iterator *iter, int flags, \
207	struct trace_iterator *iter, int flags) \	210	struct trace_event *trace_event) \
208	{ \	211	{ \
		212	struct ftrace_event_call *event; \
209	struct trace_seq *s = &iter->seq; \	213	struct trace_seq *s = &iter->seq; \
210	struct ftrace_raw_##call *field; \	214	struct ftrace_raw_##call *field; \
211	struct trace_entry *entry; \	215	struct trace_entry *entry; \
212	struct trace_seq *p; \	216	struct trace_seq *p; \
213	int ret; \	217	int ret; \
214	\	218	\
		219	event = container_of(trace_event, struct ftrace_event_call, \
		220	event); \
		221	\
215	entry = iter->ent; \	222	entry = iter->ent; \
216	\	223	\
217	if (entry->type != event_id) { \	224	if (entry->type != event->event.type) { \
218	WARN_ON_ONCE(1); \	225	WARN_ON_ONCE(1); \
219	return TRACE_TYPE_UNHANDLED; \	226	return TRACE_TYPE_UNHANDLED; \
220	} \	227	} \
@@ -223,7 +230,7 @@ ftrace_raw_output_id_##call(int event_id, const char *name, \
223	\	230	\
224	p = &get_cpu_var(ftrace_event_seq); \	231	p = &get_cpu_var(ftrace_event_seq); \
225	trace_seq_init(p); \	232	trace_seq_init(p); \
226	ret = trace_seq_printf(s, "%s: ", name); \	233	ret = trace_seq_printf(s, "%s: ", event->name); \
227	if (ret) \	234	if (ret) \
228	ret = trace_seq_printf(s, print); \	235	ret = trace_seq_printf(s, print); \
229	put_cpu(); \	236	put_cpu(); \
@@ -231,21 +238,16 @@ ftrace_raw_output_id_##call(int event_id, const char *name, \
231	return TRACE_TYPE_PARTIAL_LINE; \	238	return TRACE_TYPE_PARTIAL_LINE; \
232	\	239	\
233	return TRACE_TYPE_HANDLED; \	240	return TRACE_TYPE_HANDLED; \
234	}	241	} \
235		242	static struct trace_event_functions ftrace_event_type_funcs_##call = { \
236	#undef DEFINE_EVENT	243	.trace = ftrace_raw_output_##call, \
237	#define DEFINE_EVENT(template, name, proto, args) \	244	};
238	static notrace enum print_line_t \
239	ftrace_raw_output_##name(struct trace_iterator *iter, int flags) \
240	{ \
241	return ftrace_raw_output_id_##template(event_##name.id, \
242	#name, iter, flags); \
243	}
244		245
245	#undef DEFINE_EVENT_PRINT	246	#undef DEFINE_EVENT_PRINT
246	#define DEFINE_EVENT_PRINT(template, call, proto, args, print) \	247	#define DEFINE_EVENT_PRINT(template, call, proto, args, print) \
247	static notrace enum print_line_t \	248	static notrace enum print_line_t \
248	ftrace_raw_output_##call(struct trace_iterator *iter, int flags) \	249	ftrace_raw_output_##call(struct trace_iterator *iter, int flags, \
		250	struct trace_event *event) \
249	{ \	251	{ \
250	struct trace_seq *s = &iter->seq; \	252	struct trace_seq *s = &iter->seq; \
251	struct ftrace_raw_##template *field; \	253	struct ftrace_raw_##template *field; \
@@ -255,7 +257,7 @@ ftrace_raw_output_##call(struct trace_iterator *iter, int flags) \
255	\	257	\
256	entry = iter->ent; \	258	entry = iter->ent; \
257	\	259	\
258	if (entry->type != event_##call.id) { \	260	if (entry->type != event_##call.event.type) { \
259	WARN_ON_ONCE(1); \	261	WARN_ON_ONCE(1); \
260	return TRACE_TYPE_UNHANDLED; \	262	return TRACE_TYPE_UNHANDLED; \
261	} \	263	} \
@@ -272,7 +274,10 @@ ftrace_raw_output_##call(struct trace_iterator *iter, int flags) \
272	return TRACE_TYPE_PARTIAL_LINE; \	274	return TRACE_TYPE_PARTIAL_LINE; \
273	\	275	\
274	return TRACE_TYPE_HANDLED; \	276	return TRACE_TYPE_HANDLED; \
275	}	277	} \
		278	static struct trace_event_functions ftrace_event_type_funcs_##call = { \
		279	.trace = ftrace_raw_output_##call, \
		280	};
276		281
277	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)	282	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
278		283
@@ -378,80 +383,18 @@ static inline notrace int ftrace_get_offsets_##call( \
378		383
379	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)	384	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
380		385
381	#ifdef CONFIG_PERF_EVENTS
382
383	/*
384	* Generate the functions needed for tracepoint perf_event support.
385	*
386	* NOTE: The insertion profile callback (ftrace_profile_<call>) is defined later
387	*
388	* static int ftrace_profile_enable_<call>(void)
389	* {
390	* return register_trace_<call>(ftrace_profile_<call>);
391	* }
392	*
393	* static void ftrace_profile_disable_<call>(void)
394	* {
395	* unregister_trace_<call>(ftrace_profile_<call>);
396	* }
397	*
398	*/
399
400	#undef DECLARE_EVENT_CLASS
401	#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)
402
403	#undef DEFINE_EVENT
404	#define DEFINE_EVENT(template, name, proto, args) \
405	\
406	static void perf_trace_##name(proto); \
407	\
408	static notrace int \
409	perf_trace_enable_##name(struct ftrace_event_call *unused) \
410	{ \
411	return register_trace_##name(perf_trace_##name); \
412	} \
413	\
414	static notrace void \
415	perf_trace_disable_##name(struct ftrace_event_call *unused) \
416	{ \
417	unregister_trace_##name(perf_trace_##name); \
418	}
419
420	#undef DEFINE_EVENT_PRINT
421	#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
422	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
423
424	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
425
426	#endif /* CONFIG_PERF_EVENTS */
427
428	/*	386	/*
429	* Stage 4 of the trace events.	387	* Stage 4 of the trace events.
430	*	388	*
431	* Override the macros in <trace/trace_events.h> to include the following:	389	* Override the macros in <trace/trace_events.h> to include the following:
432	*	390	*
433	* static void ftrace_event_<call>(proto)
434	* {
435	* event_trace_printk(_RET_IP_, "<call>: " <fmt>);
436	* }
437	*
438	* static int ftrace_reg_event_<call>(struct ftrace_event_call *unused)
439	* {
440	* return register_trace_<call>(ftrace_event_<call>);
441	* }
442	*
443	* static void ftrace_unreg_event_<call>(struct ftrace_event_call *unused)
444	* {
445	* unregister_trace_<call>(ftrace_event_<call>);
446	* }
447	*
448	*
449	* For those macros defined with TRACE_EVENT:	391	* For those macros defined with TRACE_EVENT:
450	*	392	*
451	* static struct ftrace_event_call event_<call>;	393	* static struct ftrace_event_call event_<call>;
452	*	394	*
453	* static void ftrace_raw_event_<call>(proto)	395	* static void ftrace_raw_event_<call>(void *__data, proto)
454	* {	396	* {
		397	* struct ftrace_event_call *event_call = __data;
455	* struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;	398	* struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;
456	* struct ring_buffer_event *event;	399	* struct ring_buffer_event *event;
457	* struct ftrace_raw_<call> *entry; <-- defined in stage 1	400	* struct ftrace_raw_<call> *entry; <-- defined in stage 1
@@ -466,7 +409,7 @@ perf_trace_disable_##name(struct ftrace_event_call *unused) \
466	* __data_size = ftrace_get_offsets_<call>(&__data_offsets, args);	409	* __data_size = ftrace_get_offsets_<call>(&__data_offsets, args);
467	*	410	*
468	* event = trace_current_buffer_lock_reserve(&buffer,	411	* event = trace_current_buffer_lock_reserve(&buffer,
469	* event_<call>.id,	412	* event_<call>->event.type,
470	* sizeof(*entry) + __data_size,	413	* sizeof(*entry) + __data_size,
471	* irq_flags, pc);	414	* irq_flags, pc);
472	* if (!event)	415	* if (!event)
@@ -481,43 +424,42 @@ perf_trace_disable_##name(struct ftrace_event_call *unused) \
481	* event, irq_flags, pc);	424	* event, irq_flags, pc);
482	* }	425	* }
483	*	426	*
484	* static int ftrace_raw_reg_event_<call>(struct ftrace_event_call *unused)
485	* {
486	* return register_trace_<call>(ftrace_raw_event_<call>);
487	* }
488	*
489	* static void ftrace_unreg_event_<call>(struct ftrace_event_call *unused)
490	* {
491	* unregister_trace_<call>(ftrace_raw_event_<call>);
492	* }
493	*
494	* static struct trace_event ftrace_event_type_<call> = {	427	* static struct trace_event ftrace_event_type_<call> = {
495	* .trace = ftrace_raw_output_<call>, <-- stage 2	428	* .trace = ftrace_raw_output_<call>, <-- stage 2
496	* };	429	* };
497	*	430	*
498	* static const char print_fmt_<call>[] = <TP_printk>;	431	* static const char print_fmt_<call>[] = <TP_printk>;
499	*	432	*
		433	* static struct ftrace_event_class __used event_class_<template> = {
		434	* .system = "<system>",
		435	* .define_fields = ftrace_define_fields_<call>,
		436	* .fields = LIST_HEAD_INIT(event_class_##call.fields),
		437	* .raw_init = trace_event_raw_init,
		438	* .probe = ftrace_raw_event_##call,
		439	* };
		440	*
500	* static struct ftrace_event_call __used	441	* static struct ftrace_event_call __used
501	* __attribute__((__aligned__(4)))	442	* __attribute__((__aligned__(4)))
502	* __attribute__((section("_ftrace_events"))) event_<call> = {	443	* __attribute__((section("_ftrace_events"))) event_<call> = {
503	* .name = "<call>",	444	* .name = "<call>",
504	* .system = "<system>",	445	* .class = event_class_<template>,
505	* .raw_init = trace_event_raw_init,	446	* .event = &ftrace_event_type_<call>,
506	* .regfunc = ftrace_reg_event_<call>,
507	* .unregfunc = ftrace_unreg_event_<call>,
508	* .print_fmt = print_fmt_<call>,	447	* .print_fmt = print_fmt_<call>,
509	* .define_fields = ftrace_define_fields_<call>,	448	* };
510	* }
511	*	449	*
512	*/	450	*/
513		451
514	#ifdef CONFIG_PERF_EVENTS	452	#ifdef CONFIG_PERF_EVENTS
515		453
		454	#define _TRACE_PERF_PROTO(call, proto) \
		455	static notrace void \
		456	perf_trace_##call(void *__data, proto);
		457
516	#define _TRACE_PERF_INIT(call) \	458	#define _TRACE_PERF_INIT(call) \
517	.perf_event_enable = perf_trace_enable_##call, \	459	.perf_probe = perf_trace_##call,
518	.perf_event_disable = perf_trace_disable_##call,
519		460
520	#else	461	#else
		462	#define _TRACE_PERF_PROTO(call, proto)
521	#define _TRACE_PERF_INIT(call)	463	#define _TRACE_PERF_INIT(call)
522	#endif /* CONFIG_PERF_EVENTS */	464	#endif /* CONFIG_PERF_EVENTS */
523		465
@@ -551,9 +493,9 @@ perf_trace_disable_##name(struct ftrace_event_call *unused) \
551	#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \	493	#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
552	\	494	\
553	static notrace void \	495	static notrace void \
554	ftrace_raw_event_id_##call(struct ftrace_event_call *event_call, \	496	ftrace_raw_event_##call(void *__data, proto) \
555	proto) \
556	{ \	497	{ \
		498	struct ftrace_event_call *event_call = __data; \
557	struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\	499	struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
558	struct ring_buffer_event *event; \	500	struct ring_buffer_event *event; \
559	struct ftrace_raw_##call *entry; \	501	struct ftrace_raw_##call *entry; \
@@ -568,7 +510,7 @@ ftrace_raw_event_id_##call(struct ftrace_event_call *event_call, \
568	__data_size = ftrace_get_offsets_##call(&__data_offsets, args); \	510	__data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
569	\	511	\
570	event = trace_current_buffer_lock_reserve(&buffer, \	512	event = trace_current_buffer_lock_reserve(&buffer, \
571	event_call->id, \	513	event_call->event.type, \
572	sizeof(*entry) + __data_size, \	514	sizeof(*entry) + __data_size, \
573	irq_flags, pc); \	515	irq_flags, pc); \
574	if (!event) \	516	if (!event) \
@@ -583,34 +525,21 @@ ftrace_raw_event_id_##call(struct ftrace_event_call *event_call, \
583	trace_nowake_buffer_unlock_commit(buffer, \	525	trace_nowake_buffer_unlock_commit(buffer, \
584	event, irq_flags, pc); \	526	event, irq_flags, pc); \
585	}	527	}
		528	/*
		529	* The ftrace_test_probe is compiled out, it is only here as a build time check
		530	* to make sure that if the tracepoint handling changes, the ftrace probe will
		531	* fail to compile unless it too is updated.
		532	*/
586		533
587	#undef DEFINE_EVENT	534	#undef DEFINE_EVENT
588	#define DEFINE_EVENT(template, call, proto, args) \	535	#define DEFINE_EVENT(template, call, proto, args) \
589	\	536	static inline void ftrace_test_probe_##call(void) \
590	static notrace void ftrace_raw_event_##call(proto) \
591	{ \
592	ftrace_raw_event_id_##template(&event_##call, args); \
593	} \
594	\
595	static notrace int \
596	ftrace_raw_reg_event_##call(struct ftrace_event_call *unused) \
597	{ \
598	return register_trace_##call(ftrace_raw_event_##call); \
599	} \
600	\
601	static notrace void \
602	ftrace_raw_unreg_event_##call(struct ftrace_event_call *unused) \
603	{ \	537	{ \
604	unregister_trace_##call(ftrace_raw_event_##call); \	538	check_trace_callback_type_##call(ftrace_raw_event_##template); \
605	} \	539	}
606	\
607	static struct trace_event ftrace_event_type_##call = { \
608	.trace = ftrace_raw_output_##call, \
609	};
610		540
611	#undef DEFINE_EVENT_PRINT	541	#undef DEFINE_EVENT_PRINT
612	#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \	542	#define DEFINE_EVENT_PRINT(template, name, proto, args, print)
613	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
614		543
615	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)	544	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
616		545
@@ -627,7 +556,16 @@ static struct trace_event ftrace_event_type_##call = { \
627		556
628	#undef DECLARE_EVENT_CLASS	557	#undef DECLARE_EVENT_CLASS
629	#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \	558	#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
630	static const char print_fmt_##call[] = print;	559	_TRACE_PERF_PROTO(call, PARAMS(proto)); \
		560	static const char print_fmt_##call[] = print; \
		561	static struct ftrace_event_class __used event_class_##call = { \
		562	.system = __stringify(TRACE_SYSTEM), \
		563	.define_fields = ftrace_define_fields_##call, \
		564	.fields = LIST_HEAD_INIT(event_class_##call.fields),\
		565	.raw_init = trace_event_raw_init, \
		566	.probe = ftrace_raw_event_##call, \
		567	_TRACE_PERF_INIT(call) \
		568	};
631		569
632	#undef DEFINE_EVENT	570	#undef DEFINE_EVENT
633	#define DEFINE_EVENT(template, call, proto, args) \	571	#define DEFINE_EVENT(template, call, proto, args) \
@@ -636,15 +574,10 @@ static struct ftrace_event_call __used \
636	__attribute__((__aligned__(4))) \	574	__attribute__((__aligned__(4))) \
637	__attribute__((section("_ftrace_events"))) event_##call = { \	575	__attribute__((section("_ftrace_events"))) event_##call = { \
638	.name = #call, \	576	.name = #call, \
639	.system = __stringify(TRACE_SYSTEM), \	577	.class = &event_class_##template, \
640	.event = &ftrace_event_type_##call, \	578	.event.funcs = &ftrace_event_type_funcs_##template, \
641	.raw_init = trace_event_raw_init, \
642	.regfunc = ftrace_raw_reg_event_##call, \
643	.unregfunc = ftrace_raw_unreg_event_##call, \
644	.print_fmt = print_fmt_##template, \	579	.print_fmt = print_fmt_##template, \
645	.define_fields = ftrace_define_fields_##template, \	580	};
646	_TRACE_PERF_INIT(call) \
647	}
648		581
649	#undef DEFINE_EVENT_PRINT	582	#undef DEFINE_EVENT_PRINT
650	#define DEFINE_EVENT_PRINT(template, call, proto, args, print) \	583	#define DEFINE_EVENT_PRINT(template, call, proto, args, print) \
@@ -655,14 +588,9 @@ static struct ftrace_event_call __used \
655	__attribute__((__aligned__(4))) \	588	__attribute__((__aligned__(4))) \
656	__attribute__((section("_ftrace_events"))) event_##call = { \	589	__attribute__((section("_ftrace_events"))) event_##call = { \
657	.name = #call, \	590	.name = #call, \
658	.system = __stringify(TRACE_SYSTEM), \	591	.class = &event_class_##template, \
659	.event = &ftrace_event_type_##call, \	592	.event.funcs = &ftrace_event_type_funcs_##call, \
660	.raw_init = trace_event_raw_init, \
661	.regfunc = ftrace_raw_reg_event_##call, \
662	.unregfunc = ftrace_raw_unreg_event_##call, \
663	.print_fmt = print_fmt_##call, \	593	.print_fmt = print_fmt_##call, \
664	.define_fields = ftrace_define_fields_##template, \
665	_TRACE_PERF_INIT(call) \
666	}	594	}
667		595
668	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)	596	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
@@ -762,17 +690,20 @@ __attribute__((section("_ftrace_events"))) event_##call = { \
762	#undef DECLARE_EVENT_CLASS	690	#undef DECLARE_EVENT_CLASS
763	#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \	691	#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
764	static notrace void \	692	static notrace void \
765	perf_trace_templ_##call(struct ftrace_event_call *event_call, \	693	perf_trace_##call(void *__data, proto) \
766	struct pt_regs *__regs, proto) \
767	{ \	694	{ \
		695	struct ftrace_event_call *event_call = __data; \
768	struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\	696	struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
769	struct ftrace_raw_##call *entry; \	697	struct ftrace_raw_##call *entry; \
		698	struct pt_regs __regs; \
770	u64 __addr = 0, __count = 1; \	699	u64 __addr = 0, __count = 1; \
771	struct hlist_head *head; \	700	struct hlist_head *head; \
772	int __entry_size; \	701	int __entry_size; \
773	int __data_size; \	702	int __data_size; \
774	int rctx; \	703	int rctx; \
775	\	704	\
		705	perf_fetch_caller_regs(&__regs, 1); \
		706	\
776	__data_size = ftrace_get_offsets_##call(&__data_offsets, args); \	707	__data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
777	__entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),\	708	__entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),\
778	sizeof(u64)); \	709	sizeof(u64)); \
@@ -783,7 +714,7 @@ perf_trace_templ_##call(struct ftrace_event_call *event_call, \
783	return; \	714	return; \
784	\	715	\
785	entry = (struct ftrace_raw_##call *)perf_trace_buf_prepare( \	716	entry = (struct ftrace_raw_##call *)perf_trace_buf_prepare( \
786	__entry_size, event_call->id, __regs, &rctx); \	717	__entry_size, event_call->event.type, &__regs, &rctx); \
787	if (!entry) \	718	if (!entry) \
788	return; \	719	return; \
789	\	720	\
@@ -793,20 +724,22 @@ perf_trace_templ_##call(struct ftrace_event_call *event_call, \
793	\	724	\
794	head = per_cpu_ptr(event_call->perf_events, smp_processor_id());\	725	head = per_cpu_ptr(event_call->perf_events, smp_processor_id());\
795	perf_trace_buf_submit(entry, __entry_size, rctx, __addr, \	726	perf_trace_buf_submit(entry, __entry_size, rctx, __addr, \
796	__count, __regs, head); \	727	__count, &__regs, head); \
797	}	728	}
798		729
		730	/*
		731	* This part is compiled out, it is only here as a build time check
		732	* to make sure that if the tracepoint handling changes, the
		733	* perf probe will fail to compile unless it too is updated.
		734	*/
799	#undef DEFINE_EVENT	735	#undef DEFINE_EVENT
800	#define DEFINE_EVENT(template, call, proto, args) \	736	#define DEFINE_EVENT(template, call, proto, args) \
801	static notrace void perf_trace_##call(proto) \	737	static inline void perf_test_probe_##call(void) \
802	{ \	738	{ \
803	struct ftrace_event_call *event_call = &event_##call; \	739	check_trace_callback_type_##call(perf_trace_##template); \
804	struct pt_regs __regs; \
805	\
806	perf_fetch_caller_regs(&__regs, 1); \
807	perf_trace_templ_##template(event_call, &__regs, args); \
808	}	740	}
809		741
		742
810	#undef DEFINE_EVENT_PRINT	743	#undef DEFINE_EVENT_PRINT
811	#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \	744	#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
812	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))	745	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))