blob: a763888a36f961339d5a437190c1c944077f875f [file] [log] [blame]
Steven Rostedtf42c85e2009-04-13 12:25:37 -04001/*
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
Steven Rostedtff038f52009-11-18 20:27:27 -050021/*
Ingo Molnar091ad362009-11-26 09:04:55 +010022 * DECLARE_EVENT_CLASS can be used to add a generic function
Steven Rostedtff038f52009-11-18 20:27:27 -050023 * handlers for events. That is, if all events have the same
24 * parameters and just have distinct trace points.
25 * Each tracepoint can be defined with DEFINE_EVENT and that
Ingo Molnar091ad362009-11-26 09:04:55 +010026 * will map the DECLARE_EVENT_CLASS to the tracepoint.
Steven Rostedtff038f52009-11-18 20:27:27 -050027 *
28 * TRACE_EVENT is a one to one mapping between tracepoint and template.
29 */
30#undef TRACE_EVENT
31#define TRACE_EVENT(name, proto, args, tstruct, assign, print) \
Ingo Molnar091ad362009-11-26 09:04:55 +010032 DECLARE_EVENT_CLASS(name, \
Steven Rostedtff038f52009-11-18 20:27:27 -050033 PARAMS(proto), \
34 PARAMS(args), \
35 PARAMS(tstruct), \
36 PARAMS(assign), \
37 PARAMS(print)); \
38 DEFINE_EVENT(name, name, PARAMS(proto), PARAMS(args));
39
40
Steven Rostedtf42c85e2009-04-13 12:25:37 -040041#undef __field
42#define __field(type, item) type item;
43
Li Zefan43b51ea2009-08-07 10:33:22 +080044#undef __field_ext
45#define __field_ext(type, item, filter_type) type item;
46
Li Zefan7fcb7c42009-06-01 15:35:46 +080047#undef __array
48#define __array(type, item, len) type item[len];
49
50#undef __dynamic_array
Li Zefan7d536cb2009-07-16 10:54:02 +080051#define __dynamic_array(type, item, len) u32 __data_loc_##item;
Li Zefan7fcb7c42009-06-01 15:35:46 +080052
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +020053#undef __string
Li Zefan7fcb7c42009-06-01 15:35:46 +080054#define __string(item, src) __dynamic_array(char, item, -1)
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +020055
Steven Rostedtf42c85e2009-04-13 12:25:37 -040056#undef TP_STRUCT__entry
57#define TP_STRUCT__entry(args...) args
58
Ingo Molnar091ad362009-11-26 09:04:55 +010059#undef DECLARE_EVENT_CLASS
60#define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print) \
Steven Rostedtff038f52009-11-18 20:27:27 -050061 struct ftrace_raw_##name { \
62 struct trace_entry ent; \
63 tstruct \
64 char __data[0]; \
Steven Rostedt8f082012010-04-20 10:47:33 -040065 }; \
66 \
67 static struct ftrace_event_class event_class_##name;
68
Steven Rostedtff038f52009-11-18 20:27:27 -050069#undef DEFINE_EVENT
70#define DEFINE_EVENT(template, name, proto, args) \
Steven Rostedt49c17742010-05-25 06:19:35 -070071 static struct ftrace_event_call __used \
Jeff Mahoney86c38a32010-02-24 13:59:23 -050072 __attribute__((__aligned__(4))) event_##name
Steven Rostedtf42c85e2009-04-13 12:25:37 -040073
Steven Rostedte5bc9722009-11-18 20:36:26 -050074#undef DEFINE_EVENT_PRINT
75#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
76 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
77
Josh Stone97419872009-08-24 14:43:13 -070078/* Callbacks are meaningless to ftrace. */
79#undef TRACE_EVENT_FN
Frederic Weisbecker0dd7b742009-08-28 00:50:06 +020080#define TRACE_EVENT_FN(name, proto, args, tstruct, \
81 assign, print, reg, unreg) \
Frederic Weisbecker819ce452010-07-20 18:41:24 +020082 TRACE_EVENT(name, PARAMS(proto), PARAMS(args), \
83 PARAMS(tstruct), PARAMS(assign), PARAMS(print)) \
Josh Stone97419872009-08-24 14:43:13 -070084
Frederic Weisbecker1ed0c592010-11-18 01:46:57 +010085#undef TRACE_EVENT_FLAGS
86#define TRACE_EVENT_FLAGS(name, value) \
Frederic Weisbecker53cf810b2010-11-18 02:11:42 +010087 __TRACE_EVENT_FLAGS(name, value)
Frederic Weisbecker1ed0c592010-11-18 01:46:57 +010088
Steven Rostedtf42c85e2009-04-13 12:25:37 -040089#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
90
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +020091
Steven Rostedtf42c85e2009-04-13 12:25:37 -040092/*
93 * Stage 2 of the trace events.
94 *
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +020095 * Include the following:
96 *
Li Zefan7fcb7c42009-06-01 15:35:46 +080097 * struct ftrace_data_offsets_<call> {
Li Zefan7d536cb2009-07-16 10:54:02 +080098 * u32 <item1>;
99 * u32 <item2>;
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200100 * [...]
101 * };
102 *
Li Zefan7d536cb2009-07-16 10:54:02 +0800103 * The __dynamic_array() macro will create each u32 <item>, this is
Li Zefan7fcb7c42009-06-01 15:35:46 +0800104 * to keep the offset of each array from the beginning of the event.
Li Zefan7d536cb2009-07-16 10:54:02 +0800105 * The size of an array is also encoded, in the higher 16 bits of <item>.
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200106 */
107
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200108#undef __field
Li Zefan43b51ea2009-08-07 10:33:22 +0800109#define __field(type, item)
110
111#undef __field_ext
112#define __field_ext(type, item, filter_type)
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200113
Li Zefan7fcb7c42009-06-01 15:35:46 +0800114#undef __array
115#define __array(type, item, len)
116
117#undef __dynamic_array
Li Zefan7d536cb2009-07-16 10:54:02 +0800118#define __dynamic_array(type, item, len) u32 item;
Li Zefan7fcb7c42009-06-01 15:35:46 +0800119
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200120#undef __string
Li Zefan7fcb7c42009-06-01 15:35:46 +0800121#define __string(item, src) __dynamic_array(char, item, -1)
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200122
Ingo Molnar091ad362009-11-26 09:04:55 +0100123#undef DECLARE_EVENT_CLASS
124#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
Li Zefan7fcb7c42009-06-01 15:35:46 +0800125 struct ftrace_data_offsets_##call { \
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200126 tstruct; \
127 };
128
Steven Rostedtff038f52009-11-18 20:27:27 -0500129#undef DEFINE_EVENT
130#define DEFINE_EVENT(template, name, proto, args)
131
Steven Rostedte5bc9722009-11-18 20:36:26 -0500132#undef DEFINE_EVENT_PRINT
133#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
134 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
135
Frederic Weisbecker1ed0c592010-11-18 01:46:57 +0100136#undef TRACE_EVENT_FLAGS
137#define TRACE_EVENT_FLAGS(event, flag)
138
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200139#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
140
141/*
142 * Stage 3 of the trace events.
143 *
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400144 * Override the macros in <trace/trace_events.h> to include the following:
145 *
146 * enum print_line_t
147 * ftrace_raw_output_<call>(struct trace_iterator *iter, int flags)
148 * {
149 * struct trace_seq *s = &iter->seq;
150 * struct ftrace_raw_<call> *field; <-- defined in stage 1
151 * struct trace_entry *entry;
Lai Jiangshanbc289ae2010-06-03 18:26:24 +0800152 * struct trace_seq *p = &iter->tmp_seq;
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400153 * int ret;
154 *
155 * entry = iter->ent;
156 *
Steven Rostedt32c0eda2010-04-23 10:38:03 -0400157 * if (entry->type != event_<call>->event.type) {
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400158 * WARN_ON_ONCE(1);
159 * return TRACE_TYPE_UNHANDLED;
160 * }
161 *
162 * field = (typeof(field))entry;
163 *
Steven Whitehouse56d8bd32009-06-03 14:52:03 +0100164 * trace_seq_init(p);
Li Zefan50354a82010-03-24 10:58:24 +0800165 * ret = trace_seq_printf(s, "%s: ", <call>);
166 * if (ret)
167 * ret = trace_seq_printf(s, <TP_printk> "\n");
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400168 * if (!ret)
169 * return TRACE_TYPE_PARTIAL_LINE;
170 *
171 * return TRACE_TYPE_HANDLED;
172 * }
173 *
174 * This is the method used to print the raw event to the trace
175 * output format. Note, this is not needed if the data is read
176 * in binary.
177 */
178
179#undef __entry
180#define __entry field
181
182#undef TP_printk
183#define TP_printk(fmt, args...) fmt "\n", args
184
Li Zefan7fcb7c42009-06-01 15:35:46 +0800185#undef __get_dynamic_array
186#define __get_dynamic_array(field) \
Li Zefan7d536cb2009-07-16 10:54:02 +0800187 ((void *)__entry + (__entry->__data_loc_##field & 0xffff))
Li Zefan7fcb7c42009-06-01 15:35:46 +0800188
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200189#undef __get_str
Li Zefan7fcb7c42009-06-01 15:35:46 +0800190#define __get_str(field) (char *)__get_dynamic_array(field)
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200191
Steven Rostedtbe74b732009-05-26 20:25:22 +0200192#undef __print_flags
193#define __print_flags(flag, delim, flag_array...) \
194 ({ \
Steven Rostedta48f4942009-09-14 11:18:02 -0400195 static const struct trace_print_flags __flags[] = \
Steven Rostedtbe74b732009-05-26 20:25:22 +0200196 { flag_array, { -1, NULL }}; \
Steven Rostedta48f4942009-09-14 11:18:02 -0400197 ftrace_print_flags_seq(p, delim, flag, __flags); \
Steven Rostedtbe74b732009-05-26 20:25:22 +0200198 })
199
Steven Rostedt0f4fc292009-05-20 19:21:47 -0400200#undef __print_symbolic
201#define __print_symbolic(value, symbol_array...) \
202 ({ \
203 static const struct trace_print_flags symbols[] = \
204 { symbol_array, { -1, NULL }}; \
205 ftrace_print_symbols_seq(p, value, symbols); \
206 })
207
liubo2fc1b6f2011-04-19 09:35:28 +0800208#undef __print_symbolic_u64
209#if BITS_PER_LONG == 32
210#define __print_symbolic_u64(value, symbol_array...) \
211 ({ \
212 static const struct trace_print_flags_u64 symbols[] = \
213 { symbol_array, { -1, NULL } }; \
214 ftrace_print_symbols_seq_u64(p, value, symbols); \
215 })
216#else
217#define __print_symbolic_u64(value, symbol_array...) \
218 __print_symbolic(value, symbol_array)
219#endif
220
Kei Tokunaga5a2e3992010-04-01 20:40:58 +0900221#undef __print_hex
222#define __print_hex(buf, buf_len) ftrace_print_hex_seq(p, buf, buf_len)
223
Ingo Molnar091ad362009-11-26 09:04:55 +0100224#undef DECLARE_EVENT_CLASS
225#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
Steven Rostedt83f0d532010-02-16 10:38:47 -0500226static notrace enum print_line_t \
Steven Rostedt80decc72010-04-23 10:00:22 -0400227ftrace_raw_output_##call(struct trace_iterator *iter, int flags, \
228 struct trace_event *trace_event) \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400229{ \
Steven Rostedt80decc72010-04-23 10:00:22 -0400230 struct ftrace_event_call *event; \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400231 struct trace_seq *s = &iter->seq; \
232 struct ftrace_raw_##call *field; \
233 struct trace_entry *entry; \
Lai Jiangshanbc289ae2010-06-03 18:26:24 +0800234 struct trace_seq *p = &iter->tmp_seq; \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400235 int ret; \
236 \
Steven Rostedt80decc72010-04-23 10:00:22 -0400237 event = container_of(trace_event, struct ftrace_event_call, \
238 event); \
239 \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400240 entry = iter->ent; \
241 \
Steven Rostedt32c0eda2010-04-23 10:38:03 -0400242 if (entry->type != event->event.type) { \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400243 WARN_ON_ONCE(1); \
244 return TRACE_TYPE_UNHANDLED; \
245 } \
246 \
247 field = (typeof(field))entry; \
248 \
Steven Whitehouse56d8bd32009-06-03 14:52:03 +0100249 trace_seq_init(p); \
Steven Rostedt80decc72010-04-23 10:00:22 -0400250 ret = trace_seq_printf(s, "%s: ", event->name); \
Steven Rostedtff038f52009-11-18 20:27:27 -0500251 if (ret) \
252 ret = trace_seq_printf(s, print); \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400253 if (!ret) \
254 return TRACE_TYPE_PARTIAL_LINE; \
255 \
256 return TRACE_TYPE_HANDLED; \
Steven Rostedt80decc72010-04-23 10:00:22 -0400257} \
258static struct trace_event_functions ftrace_event_type_funcs_##call = { \
259 .trace = ftrace_raw_output_##call, \
260};
Steven Rostedtff038f52009-11-18 20:27:27 -0500261
Steven Rostedte5bc9722009-11-18 20:36:26 -0500262#undef DEFINE_EVENT_PRINT
263#define DEFINE_EVENT_PRINT(template, call, proto, args, print) \
Steven Rostedt83f0d532010-02-16 10:38:47 -0500264static notrace enum print_line_t \
Steven Rostedta9a57762010-04-22 18:46:14 -0400265ftrace_raw_output_##call(struct trace_iterator *iter, int flags, \
266 struct trace_event *event) \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400267{ \
268 struct trace_seq *s = &iter->seq; \
Steven Rostedte5bc9722009-11-18 20:36:26 -0500269 struct ftrace_raw_##template *field; \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400270 struct trace_entry *entry; \
Lai Jiangshanbc289ae2010-06-03 18:26:24 +0800271 struct trace_seq *p = &iter->tmp_seq; \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400272 int ret; \
273 \
274 entry = iter->ent; \
275 \
Steven Rostedt32c0eda2010-04-23 10:38:03 -0400276 if (entry->type != event_##call.event.type) { \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400277 WARN_ON_ONCE(1); \
278 return TRACE_TYPE_UNHANDLED; \
279 } \
280 \
281 field = (typeof(field))entry; \
282 \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400283 trace_seq_init(p); \
Steven Rostedte5bc9722009-11-18 20:36:26 -0500284 ret = trace_seq_printf(s, "%s: ", #call); \
285 if (ret) \
286 ret = trace_seq_printf(s, print); \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400287 if (!ret) \
288 return TRACE_TYPE_PARTIAL_LINE; \
289 \
290 return TRACE_TYPE_HANDLED; \
Steven Rostedt80decc72010-04-23 10:00:22 -0400291} \
292static struct trace_event_functions ftrace_event_type_funcs_##call = { \
293 .trace = ftrace_raw_output_##call, \
294};
Steven Rostedte5bc9722009-11-18 20:36:26 -0500295
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400296#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
297
Li Zefan43b51ea2009-08-07 10:33:22 +0800298#undef __field_ext
299#define __field_ext(type, item, filter_type) \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400300 ret = trace_define_field(event_call, #type, #item, \
301 offsetof(typeof(field), item), \
Li Zefan43b51ea2009-08-07 10:33:22 +0800302 sizeof(field.item), \
303 is_signed_type(type), filter_type); \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400304 if (ret) \
305 return ret;
306
Li Zefan43b51ea2009-08-07 10:33:22 +0800307#undef __field
308#define __field(type, item) __field_ext(type, item, FILTER_OTHER)
309
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400310#undef __array
311#define __array(type, item, len) \
Steven Rostedt04295782010-11-12 22:32:11 -0500312 do { \
313 mutex_lock(&event_storage_mutex); \
314 BUILD_BUG_ON(len > MAX_FILTER_STR_VAL); \
315 snprintf(event_storage, sizeof(event_storage), \
316 "%s[%d]", #type, len); \
317 ret = trace_define_field(event_call, event_storage, #item, \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400318 offsetof(typeof(field), item), \
Lai Jiangshanfb7ae982009-12-15 15:39:38 +0800319 sizeof(field.item), \
320 is_signed_type(type), FILTER_OTHER); \
Steven Rostedt04295782010-11-12 22:32:11 -0500321 mutex_unlock(&event_storage_mutex); \
322 if (ret) \
323 return ret; \
324 } while (0);
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400325
Li Zefan7fcb7c42009-06-01 15:35:46 +0800326#undef __dynamic_array
327#define __dynamic_array(type, item, len) \
Lai Jiangshan68fd60a2009-07-16 10:53:34 +0800328 ret = trace_define_field(event_call, "__data_loc " #type "[]", #item, \
Li Zefan43b51ea2009-08-07 10:33:22 +0800329 offsetof(typeof(field), __data_loc_##item), \
Lai Jiangshanfb7ae982009-12-15 15:39:38 +0800330 sizeof(field.__data_loc_##item), \
331 is_signed_type(type), FILTER_OTHER);
Li Zefan7fcb7c42009-06-01 15:35:46 +0800332
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200333#undef __string
Li Zefan7fcb7c42009-06-01 15:35:46 +0800334#define __string(item, src) __dynamic_array(char, item, -1)
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200335
Ingo Molnar091ad362009-11-26 09:04:55 +0100336#undef DECLARE_EVENT_CLASS
337#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, func, print) \
Steven Rostedt83f0d532010-02-16 10:38:47 -0500338static int notrace \
Li Zefan14be96c2009-08-19 15:53:52 +0800339ftrace_define_fields_##call(struct ftrace_event_call *event_call) \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400340{ \
341 struct ftrace_raw_##call field; \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400342 int ret; \
343 \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400344 tstruct; \
345 \
346 return ret; \
347}
348
Steven Rostedtff038f52009-11-18 20:27:27 -0500349#undef DEFINE_EVENT
350#define DEFINE_EVENT(template, name, proto, args)
351
Steven Rostedte5bc9722009-11-18 20:36:26 -0500352#undef DEFINE_EVENT_PRINT
353#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
354 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
355
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400356#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
357
358/*
Li Zefan7fcb7c42009-06-01 15:35:46 +0800359 * remember the offset of each array from the beginning of the event.
360 */
361
362#undef __entry
363#define __entry entry
364
365#undef __field
366#define __field(type, item)
367
Li Zefan43b51ea2009-08-07 10:33:22 +0800368#undef __field_ext
369#define __field_ext(type, item, filter_type)
370
Li Zefan7fcb7c42009-06-01 15:35:46 +0800371#undef __array
372#define __array(type, item, len)
373
374#undef __dynamic_array
375#define __dynamic_array(type, item, len) \
376 __data_offsets->item = __data_size + \
377 offsetof(typeof(*entry), __data); \
Li Zefan7d536cb2009-07-16 10:54:02 +0800378 __data_offsets->item |= (len * sizeof(type)) << 16; \
Li Zefan7fcb7c42009-06-01 15:35:46 +0800379 __data_size += (len) * sizeof(type);
380
381#undef __string
Steven Rostedtff038f52009-11-18 20:27:27 -0500382#define __string(item, src) __dynamic_array(char, item, strlen(src) + 1)
Li Zefan7fcb7c42009-06-01 15:35:46 +0800383
Ingo Molnar091ad362009-11-26 09:04:55 +0100384#undef DECLARE_EVENT_CLASS
385#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
Steven Rostedt83f0d532010-02-16 10:38:47 -0500386static inline notrace int ftrace_get_offsets_##call( \
Li Zefan7fcb7c42009-06-01 15:35:46 +0800387 struct ftrace_data_offsets_##call *__data_offsets, proto) \
388{ \
389 int __data_size = 0; \
390 struct ftrace_raw_##call __maybe_unused *entry; \
391 \
392 tstruct; \
393 \
394 return __data_size; \
395}
396
Steven Rostedtff038f52009-11-18 20:27:27 -0500397#undef DEFINE_EVENT
398#define DEFINE_EVENT(template, name, proto, args)
399
Steven Rostedte5bc9722009-11-18 20:36:26 -0500400#undef DEFINE_EVENT_PRINT
401#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
402 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
403
Li Zefan7fcb7c42009-06-01 15:35:46 +0800404#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
405
406/*
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200407 * Stage 4 of the trace events.
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400408 *
409 * Override the macros in <trace/trace_events.h> to include the following:
410 *
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400411 * For those macros defined with TRACE_EVENT:
412 *
413 * static struct ftrace_event_call event_<call>;
414 *
Steven Rostedt22392912010-04-21 12:27:06 -0400415 * static void ftrace_raw_event_<call>(void *__data, proto)
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400416 * {
Steven Rostedt22392912010-04-21 12:27:06 -0400417 * struct ftrace_event_call *event_call = __data;
Li Zefan50354a82010-03-24 10:58:24 +0800418 * struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400419 * struct ring_buffer_event *event;
420 * struct ftrace_raw_<call> *entry; <-- defined in stage 1
Steven Rostedte77405a2009-09-02 14:17:06 -0400421 * struct ring_buffer *buffer;
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400422 * unsigned long irq_flags;
Li Zefan50354a82010-03-24 10:58:24 +0800423 * int __data_size;
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400424 * int pc;
425 *
426 * local_save_flags(irq_flags);
427 * pc = preempt_count();
428 *
Li Zefan50354a82010-03-24 10:58:24 +0800429 * __data_size = ftrace_get_offsets_<call>(&__data_offsets, args);
430 *
Steven Rostedte77405a2009-09-02 14:17:06 -0400431 * event = trace_current_buffer_lock_reserve(&buffer,
Steven Rostedt32c0eda2010-04-23 10:38:03 -0400432 * event_<call>->event.type,
Li Zefan50354a82010-03-24 10:58:24 +0800433 * sizeof(*entry) + __data_size,
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400434 * irq_flags, pc);
435 * if (!event)
436 * return;
437 * entry = ring_buffer_event_data(event);
438 *
Li Zefan50354a82010-03-24 10:58:24 +0800439 * { <assign>; } <-- Here we assign the entries by the __field and
440 * __array macros.
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400441 *
Li Zefan50354a82010-03-24 10:58:24 +0800442 * if (!filter_current_check_discard(buffer, event_call, entry, event))
443 * trace_current_buffer_unlock_commit(buffer,
444 * event, irq_flags, pc);
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400445 * }
446 *
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400447 * static struct trace_event ftrace_event_type_<call> = {
448 * .trace = ftrace_raw_output_<call>, <-- stage 2
449 * };
450 *
Li Zefan50354a82010-03-24 10:58:24 +0800451 * static const char print_fmt_<call>[] = <TP_printk>;
452 *
Steven Rostedt8f082012010-04-20 10:47:33 -0400453 * static struct ftrace_event_class __used event_class_<template> = {
454 * .system = "<system>",
Steven Rostedt2e33af02010-04-22 10:35:55 -0400455 * .define_fields = ftrace_define_fields_<call>,
Steven Rostedt0405ab82010-04-22 11:46:44 -0400456 * .fields = LIST_HEAD_INIT(event_class_##call.fields),
457 * .raw_init = trace_event_raw_init,
458 * .probe = ftrace_raw_event_##call,
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400459 * .reg = ftrace_event_reg,
Steven Rostedt8f082012010-04-20 10:47:33 -0400460 * };
461 *
Steven Rostedte4a9ea52011-01-27 09:15:30 -0500462 * static struct ftrace_event_call event_<call> = {
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400463 * .name = "<call>",
Steven Rostedt8f082012010-04-20 10:47:33 -0400464 * .class = event_class_<template>,
Steven Rostedt2e33af02010-04-22 10:35:55 -0400465 * .event = &ftrace_event_type_<call>,
Li Zefan50354a82010-03-24 10:58:24 +0800466 * .print_fmt = print_fmt_<call>,
Steven Rostedt8f082012010-04-20 10:47:33 -0400467 * };
Steven Rostedte4a9ea52011-01-27 09:15:30 -0500468 * // its only safe to use pointers when doing linker tricks to
469 * // create an array.
470 * static struct ftrace_event_call __used
471 * __attribute__((section("_ftrace_events"))) *__event_<call> = &event_<call>;
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400472 *
473 */
474
Li Zefan07b139c2009-12-21 14:27:35 +0800475#ifdef CONFIG_PERF_EVENTS
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400476
Steven Rostedt22392912010-04-21 12:27:06 -0400477#define _TRACE_PERF_PROTO(call, proto) \
478 static notrace void \
479 perf_trace_##call(void *__data, proto);
480
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100481#define _TRACE_PERF_INIT(call) \
Steven Rostedt22392912010-04-21 12:27:06 -0400482 .perf_probe = perf_trace_##call,
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400483
484#else
Steven Rostedt22392912010-04-21 12:27:06 -0400485#define _TRACE_PERF_PROTO(call, proto)
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100486#define _TRACE_PERF_INIT(call)
Li Zefan07b139c2009-12-21 14:27:35 +0800487#endif /* CONFIG_PERF_EVENTS */
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400488
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400489#undef __entry
490#define __entry entry
491
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200492#undef __field
493#define __field(type, item)
494
495#undef __array
496#define __array(type, item, len)
497
Li Zefan7fcb7c42009-06-01 15:35:46 +0800498#undef __dynamic_array
499#define __dynamic_array(type, item, len) \
500 __entry->__data_loc_##item = __data_offsets.item;
501
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200502#undef __string
Li Zefan7fcb7c42009-06-01 15:35:46 +0800503#define __string(item, src) __dynamic_array(char, item, -1) \
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200504
505#undef __assign_str
506#define __assign_str(dst, src) \
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200507 strcpy(__get_str(dst), src);
508
Lai Jiangshan0fa0eda2009-12-15 15:39:57 +0800509#undef TP_fast_assign
510#define TP_fast_assign(args...) args
511
512#undef TP_perf_assign
513#define TP_perf_assign(args...)
514
Ingo Molnar091ad362009-11-26 09:04:55 +0100515#undef DECLARE_EVENT_CLASS
516#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400517 \
Steven Rostedt83f0d532010-02-16 10:38:47 -0500518static notrace void \
Steven Rostedt22392912010-04-21 12:27:06 -0400519ftrace_raw_event_##call(void *__data, proto) \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400520{ \
Steven Rostedt22392912010-04-21 12:27:06 -0400521 struct ftrace_event_call *event_call = __data; \
Li Zefan7fcb7c42009-06-01 15:35:46 +0800522 struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400523 struct ring_buffer_event *event; \
524 struct ftrace_raw_##call *entry; \
Steven Rostedte77405a2009-09-02 14:17:06 -0400525 struct ring_buffer *buffer; \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400526 unsigned long irq_flags; \
Li Zefan7fcb7c42009-06-01 15:35:46 +0800527 int __data_size; \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400528 int pc; \
529 \
530 local_save_flags(irq_flags); \
531 pc = preempt_count(); \
532 \
Li Zefan7fcb7c42009-06-01 15:35:46 +0800533 __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200534 \
Steven Rostedte77405a2009-09-02 14:17:06 -0400535 event = trace_current_buffer_lock_reserve(&buffer, \
Steven Rostedt32c0eda2010-04-23 10:38:03 -0400536 event_call->event.type, \
Li Zefan7fcb7c42009-06-01 15:35:46 +0800537 sizeof(*entry) + __data_size, \
Frederic Weisbecker9cbf1172009-04-19 04:51:29 +0200538 irq_flags, pc); \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400539 if (!event) \
540 return; \
541 entry = ring_buffer_event_data(event); \
542 \
Li Zefan7fcb7c42009-06-01 15:35:46 +0800543 tstruct \
544 \
Li Zefana9c1c3a2009-06-01 15:35:13 +0800545 { assign; } \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400546 \
Steven Rostedte77405a2009-09-02 14:17:06 -0400547 if (!filter_current_check_discard(buffer, event_call, entry, event)) \
548 trace_nowake_buffer_unlock_commit(buffer, \
549 event, irq_flags, pc); \
Steven Rostedtff038f52009-11-18 20:27:27 -0500550}
Steven Rostedt22392912010-04-21 12:27:06 -0400551/*
552 * The ftrace_test_probe is compiled out, it is only here as a build time check
553 * to make sure that if the tracepoint handling changes, the ftrace probe will
554 * fail to compile unless it too is updated.
555 */
Steven Rostedtff038f52009-11-18 20:27:27 -0500556
557#undef DEFINE_EVENT
558#define DEFINE_EVENT(template, call, proto, args) \
Steven Rostedt22392912010-04-21 12:27:06 -0400559static inline void ftrace_test_probe_##call(void) \
Steven Rostedtff038f52009-11-18 20:27:27 -0500560{ \
Steven Rostedt22392912010-04-21 12:27:06 -0400561 check_trace_callback_type_##call(ftrace_raw_event_##template); \
562}
Steven Rostedte5bc9722009-11-18 20:36:26 -0500563
564#undef DEFINE_EVENT_PRINT
Steven Rostedt80decc72010-04-23 10:00:22 -0400565#define DEFINE_EVENT_PRINT(template, name, proto, args, print)
Steven Rostedte5bc9722009-11-18 20:36:26 -0500566
567#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
568
Lai Jiangshan509e7602009-12-15 15:39:42 +0800569#undef __entry
570#define __entry REC
571
572#undef __print_flags
573#undef __print_symbolic
Namhyung Kimb102f1d2012-06-27 09:41:39 +0900574#undef __print_hex
Lai Jiangshan509e7602009-12-15 15:39:42 +0800575#undef __get_dynamic_array
576#undef __get_str
577
578#undef TP_printk
579#define TP_printk(fmt, args...) "\"" fmt "\", " __stringify(args)
580
Ingo Molnar091ad362009-11-26 09:04:55 +0100581#undef DECLARE_EVENT_CLASS
Lai Jiangshan509e7602009-12-15 15:39:42 +0800582#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
Steven Rostedt22392912010-04-21 12:27:06 -0400583_TRACE_PERF_PROTO(call, PARAMS(proto)); \
Steven Rostedt8f082012010-04-20 10:47:33 -0400584static const char print_fmt_##call[] = print; \
585static struct ftrace_event_class __used event_class_##call = { \
Steven Rostedt22392912010-04-21 12:27:06 -0400586 .system = __stringify(TRACE_SYSTEM), \
Steven Rostedt2e33af02010-04-22 10:35:55 -0400587 .define_fields = ftrace_define_fields_##call, \
588 .fields = LIST_HEAD_INIT(event_class_##call.fields),\
Steven Rostedt0405ab82010-04-22 11:46:44 -0400589 .raw_init = trace_event_raw_init, \
Steven Rostedt22392912010-04-21 12:27:06 -0400590 .probe = ftrace_raw_event_##call, \
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400591 .reg = ftrace_event_reg, \
Steven Rostedt22392912010-04-21 12:27:06 -0400592 _TRACE_PERF_INIT(call) \
Steven Rostedt8f082012010-04-20 10:47:33 -0400593};
Steven Rostedte5bc9722009-11-18 20:36:26 -0500594
595#undef DEFINE_EVENT
596#define DEFINE_EVENT(template, call, proto, args) \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400597 \
Steven Rostedte4a9ea52011-01-27 09:15:30 -0500598static struct ftrace_event_call __used event_##call = { \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400599 .name = #call, \
Steven Rostedt8f082012010-04-20 10:47:33 -0400600 .class = &event_class_##template, \
Steven Rostedt80decc72010-04-23 10:00:22 -0400601 .event.funcs = &ftrace_event_type_funcs_##template, \
Lai Jiangshan509e7602009-12-15 15:39:42 +0800602 .print_fmt = print_fmt_##template, \
Steven Rostedte4a9ea52011-01-27 09:15:30 -0500603}; \
604static struct ftrace_event_call __used \
605__attribute__((section("_ftrace_events"))) *__event_##call = &event_##call
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400606
Steven Rostedte5bc9722009-11-18 20:36:26 -0500607#undef DEFINE_EVENT_PRINT
608#define DEFINE_EVENT_PRINT(template, call, proto, args, print) \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400609 \
Lai Jiangshan509e7602009-12-15 15:39:42 +0800610static const char print_fmt_##call[] = print; \
611 \
Steven Rostedte4a9ea52011-01-27 09:15:30 -0500612static struct ftrace_event_call __used event_##call = { \
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400613 .name = #call, \
Steven Rostedt8f082012010-04-20 10:47:33 -0400614 .class = &event_class_##template, \
Steven Rostedt80decc72010-04-23 10:00:22 -0400615 .event.funcs = &ftrace_event_type_funcs_##call, \
Lai Jiangshan509e7602009-12-15 15:39:42 +0800616 .print_fmt = print_fmt_##call, \
Steven Rostedte4a9ea52011-01-27 09:15:30 -0500617}; \
618static struct ftrace_event_call __used \
619__attribute__((section("_ftrace_events"))) *__event_##call = &event_##call
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400620
621#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
622
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200623/*
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100624 * Define the insertion callback to perf events
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200625 *
626 * The job is very similar to ftrace_raw_event_<call> except that we don't
627 * insert in the ring buffer but in a perf counter.
628 *
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100629 * static void ftrace_perf_<call>(proto)
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200630 * {
631 * struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;
632 * struct ftrace_event_call *event_call = &event_<call>;
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200633 * extern void perf_tp_event(int, u64, u64, void *, int);
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200634 * struct ftrace_raw_##call *entry;
Frederic Weisbecker444a2a32009-11-06 04:13:05 +0100635 * struct perf_trace_buf *trace_buf;
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200636 * u64 __addr = 0, __count = 1;
637 * unsigned long irq_flags;
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200638 * struct trace_entry *ent;
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200639 * int __entry_size;
640 * int __data_size;
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200641 * int __cpu
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200642 * int pc;
643 *
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200644 * pc = preempt_count();
645 *
646 * __data_size = ftrace_get_offsets_<call>(&__data_offsets, args);
Frederic Weisbecker304703a2009-08-10 16:11:32 +0200647 *
648 * // Below we want to get the aligned size by taking into account
649 * // the u32 field that will later store the buffer size
650 * __entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),
651 * sizeof(u64));
652 * __entry_size -= sizeof(u32);
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200653 *
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200654 * // Protect the non nmi buffer
655 * // This also protects the rcu read side
656 * local_irq_save(irq_flags);
657 * __cpu = smp_processor_id();
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200658 *
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200659 * if (in_nmi())
Paul E. McKenney8d53dd52010-03-03 17:50:18 -0800660 * trace_buf = rcu_dereference_sched(perf_trace_buf_nmi);
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200661 * else
Paul E. McKenney8d53dd52010-03-03 17:50:18 -0800662 * trace_buf = rcu_dereference_sched(perf_trace_buf);
Frederic Weisbecker1853db02009-08-10 16:38:36 +0200663 *
Frederic Weisbecker444a2a32009-11-06 04:13:05 +0100664 * if (!trace_buf)
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200665 * goto end;
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200666 *
Frederic Weisbecker444a2a32009-11-06 04:13:05 +0100667 * trace_buf = per_cpu_ptr(trace_buf, __cpu);
668 *
669 * // Avoid recursion from perf that could mess up the buffer
670 * if (trace_buf->recursion++)
671 * goto end_recursion;
672 *
673 * raw_data = trace_buf->buf;
674 *
675 * // Make recursion update visible before entering perf_tp_event
676 * // so that we protect from perf recursions.
677 *
678 * barrier();
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200679 *
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200680 * //zero dead bytes from alignment to avoid stack leak to userspace:
681 * *(u64 *)(&raw_data[__entry_size - sizeof(u64)]) = 0ULL;
682 * entry = (struct ftrace_raw_<call> *)raw_data;
683 * ent = &entry->ent;
684 * tracing_generic_entry_update(ent, irq_flags, pc);
685 * ent->type = event_call->id;
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200686 *
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200687 * <tstruct> <- do some jobs with dynamic arrays
688 *
689 * <assign> <- affect our values
690 *
Linus Torvalds43c12662009-09-21 09:15:07 -0700691 * perf_tp_event(event_call->id, __addr, __count, entry,
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200692 * __entry_size); <- submit them to perf counter
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200693 *
694 * }
695 */
696
Li Zefan07b139c2009-12-21 14:27:35 +0800697#ifdef CONFIG_PERF_EVENTS
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200698
Lai Jiangshan509e7602009-12-15 15:39:42 +0800699#undef __entry
700#define __entry entry
701
702#undef __get_dynamic_array
703#define __get_dynamic_array(field) \
704 ((void *)__entry + (__entry->__data_loc_##field & 0xffff))
705
706#undef __get_str
707#define __get_str(field) (char *)__get_dynamic_array(field)
708
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200709#undef __perf_addr
710#define __perf_addr(a) __addr = (a)
711
712#undef __perf_count
713#define __perf_count(c) __count = (c)
714
Andrew Vagine6dab5f2012-07-11 18:14:58 +0400715#undef __perf_task
716#define __perf_task(t) __task = (t)
717
Andrew Vagin92e51932011-09-26 19:55:32 +0400718#undef TP_perf_assign
719#define TP_perf_assign(args...) args
720
Ingo Molnar091ad362009-11-26 09:04:55 +0100721#undef DECLARE_EVENT_CLASS
722#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
Steven Rostedt83f0d532010-02-16 10:38:47 -0500723static notrace void \
Steven Rostedt22392912010-04-21 12:27:06 -0400724perf_trace_##call(void *__data, proto) \
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200725{ \
Steven Rostedt22392912010-04-21 12:27:06 -0400726 struct ftrace_event_call *event_call = __data; \
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200727 struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200728 struct ftrace_raw_##call *entry; \
Steven Rostedtff5f1492010-05-21 11:49:57 -0400729 struct pt_regs __regs; \
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200730 u64 __addr = 0, __count = 1; \
Andrew Vagine6dab5f2012-07-11 18:14:58 +0400731 struct task_struct *__task = NULL; \
Peter Zijlstra1c024eca2010-05-19 14:02:22 +0200732 struct hlist_head *head; \
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200733 int __entry_size; \
734 int __data_size; \
Peter Zijlstra4ed7c922009-11-23 11:37:29 +0100735 int rctx; \
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200736 \
Frederic Weisbeckerb0f82b82010-05-20 07:47:21 +0200737 perf_fetch_caller_regs(&__regs); \
Steven Rostedtf0218b32010-05-17 22:26:53 -0400738 \
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200739 __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
Peter Zijlstraa0445602009-08-10 11:16:52 +0200740 __entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),\
741 sizeof(u64)); \
Frederic Weisbecker304703a2009-08-10 16:11:32 +0200742 __entry_size -= sizeof(u32); \
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200743 \
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100744 if (WARN_ONCE(__entry_size > PERF_MAX_TRACE_SIZE, \
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200745 "profile buffer not large enough")) \
746 return; \
Peter Zijlstrab7e2ece2010-05-19 10:52:27 +0200747 \
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100748 entry = (struct ftrace_raw_##call *)perf_trace_buf_prepare( \
Steven Rostedtff5f1492010-05-21 11:49:57 -0400749 __entry_size, event_call->event.type, &__regs, &rctx); \
Xiao Guangrong430ad5a2010-01-28 09:32:29 +0800750 if (!entry) \
751 return; \
Peter Zijlstrab7e2ece2010-05-19 10:52:27 +0200752 \
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200753 tstruct \
754 \
755 { assign; } \
756 \
Peter Zijlstra3771f072010-05-21 12:31:09 +0200757 head = this_cpu_ptr(event_call->perf_events); \
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100758 perf_trace_buf_submit(entry, __entry_size, rctx, __addr, \
Andrew Vagine6dab5f2012-07-11 18:14:58 +0400759 __count, &__regs, head, __task); \
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200760}
761
Steven Rostedt22392912010-04-21 12:27:06 -0400762/*
763 * This part is compiled out, it is only here as a build time check
764 * to make sure that if the tracepoint handling changes, the
765 * perf probe will fail to compile unless it too is updated.
766 */
Steven Rostedtff038f52009-11-18 20:27:27 -0500767#undef DEFINE_EVENT
Frederic Weisbecker6cc8a7c2010-03-19 01:23:53 +0100768#define DEFINE_EVENT(template, call, proto, args) \
Steven Rostedt22392912010-04-21 12:27:06 -0400769static inline void perf_test_probe_##call(void) \
Frederic Weisbecker6cc8a7c2010-03-19 01:23:53 +0100770{ \
Steven Rostedt22392912010-04-21 12:27:06 -0400771 check_trace_callback_type_##call(perf_trace_##template); \
Steven Rostedtff038f52009-11-18 20:27:27 -0500772}
773
Steven Rostedt22392912010-04-21 12:27:06 -0400774
Steven Rostedte5bc9722009-11-18 20:36:26 -0500775#undef DEFINE_EVENT_PRINT
776#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
777 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
778
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200779#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
Li Zefan07b139c2009-12-21 14:27:35 +0800780#endif /* CONFIG_PERF_EVENTS */
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200781
Steven Rostedtf42c85e2009-04-13 12:25:37 -0400782#undef _TRACE_PROFILE_INIT
783