1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3 * Stage 1 of the trace events.
4 *
5 * Override the macros in the event tracepoint header <trace/events/XXX.h>
6 * to include the following:
7 *
8 * struct trace_event_raw_<call> {
9 * struct trace_entry ent;
10 * <type> <item>;
11 * <type2> <item2>[<len>];
12 * [...]
13 * };
14 *
15 * The <type> <item> is created by the __field(type, item) macro or
16 * the __array(type2, item2, len) macro.
17 * We simply do "type item;", and that will create the fields
18 * in the structure.
19 */
20
21 #include <linux/trace_events.h>
22
23 #ifndef TRACE_SYSTEM_VAR
24 #define TRACE_SYSTEM_VAR TRACE_SYSTEM
25 #endif
26
27 #include "stages/init.h"
28
29 /*
30 * DECLARE_EVENT_CLASS can be used to add a generic function
31 * handlers for events. That is, if all events have the same
32 * parameters and just have distinct trace points.
33 * Each tracepoint can be defined with DEFINE_EVENT and that
34 * will map the DECLARE_EVENT_CLASS to the tracepoint.
35 *
36 * TRACE_EVENT is a one to one mapping between tracepoint and template.
37 */
38 #undef TRACE_EVENT
39 #define TRACE_EVENT(name, proto, args, tstruct, assign, print) \
40 DECLARE_EVENT_CLASS(name, \
41 PARAMS(proto), \
42 PARAMS(args), \
43 PARAMS(tstruct), \
44 PARAMS(assign), \
45 PARAMS(print)); \
46 DEFINE_EVENT(name, name, PARAMS(proto), PARAMS(args));
47
48 #include "stages/stage1_struct_define.h"
49
50 #undef DECLARE_EVENT_CLASS
51 #define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print) \
52 struct trace_event_raw_##name { \
53 struct trace_entry ent; \
54 tstruct \
55 char __data[]; \
56 }; \
57 \
58 static struct trace_event_class event_class_##name;
59
60 #undef DEFINE_EVENT
61 #define DEFINE_EVENT(template, name, proto, args) \
62 static struct trace_event_call __used \
63 __attribute__((__aligned__(4))) event_##name
64
65 #undef DEFINE_EVENT_FN
66 #define DEFINE_EVENT_FN(template, name, proto, args, reg, unreg) \
67 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
68
69 #undef DEFINE_EVENT_PRINT
70 #define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
71 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
72
73 /* Callbacks are meaningless to ftrace. */
74 #undef TRACE_EVENT_FN
75 #define TRACE_EVENT_FN(name, proto, args, tstruct, \
76 assign, print, reg, unreg) \
77 TRACE_EVENT(name, PARAMS(proto), PARAMS(args), \
78 PARAMS(tstruct), PARAMS(assign), PARAMS(print)) \
79
80 #undef TRACE_EVENT_FN_COND
81 #define TRACE_EVENT_FN_COND(name, proto, args, cond, tstruct, \
82 assign, print, reg, unreg) \
83 TRACE_EVENT_CONDITION(name, PARAMS(proto), PARAMS(args), PARAMS(cond), \
84 PARAMS(tstruct), PARAMS(assign), PARAMS(print)) \
85
86 #undef TRACE_EVENT_FLAGS
87 #define TRACE_EVENT_FLAGS(name, value) \
88 __TRACE_EVENT_FLAGS(name, value)
89
90 #undef TRACE_EVENT_PERF_PERM
91 #define TRACE_EVENT_PERF_PERM(name, expr...) \
92 __TRACE_EVENT_PERF_PERM(name, expr)
93
94 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
95
96 /*
97 * Stage 2 of the trace events.
98 *
99 * Include the following:
100 *
101 * struct trace_event_data_offsets_<call> {
102 * u32 <item1>;
103 * u32 <item2>;
104 * [...]
105 * };
106 *
107 * The __dynamic_array() macro will create each u32 <item>, this is
108 * to keep the offset of each array from the beginning of the event.
109 * The size of an array is also encoded, in the higher 16 bits of <item>.
110 */
111
112 #include "stages/stage2_data_offsets.h"
113
114 #undef DECLARE_EVENT_CLASS
115 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
116 struct trace_event_data_offsets_##call { \
117 tstruct; \
118 };
119
120 #undef DEFINE_EVENT
121 #define DEFINE_EVENT(template, name, proto, args)
122
123 #undef DEFINE_EVENT_PRINT
124 #define DEFINE_EVENT_PRINT(template, name, proto, args, print)
125
126 #undef TRACE_EVENT_FLAGS
127 #define TRACE_EVENT_FLAGS(event, flag)
128
129 #undef TRACE_EVENT_PERF_PERM
130 #define TRACE_EVENT_PERF_PERM(event, expr...)
131
132 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
133
134 /*
135 * Stage 3 of the trace events.
136 *
137 * Override the macros in the event tracepoint header <trace/events/XXX.h>
138 * to include the following:
139 *
140 * enum print_line_t
141 * trace_raw_output_<call>(struct trace_iterator *iter, int flags)
142 * {
143 * struct trace_seq *s = &iter->seq;
144 * struct trace_event_raw_<call> *field; <-- defined in stage 1
145 * struct trace_seq *p = &iter->tmp_seq;
146 *
147 * -------(for event)-------
148 *
149 * struct trace_entry *entry;
150 *
151 * entry = iter->ent;
152 *
153 * if (entry->type != event_<call>->event.type) {
154 * WARN_ON_ONCE(1);
155 * return TRACE_TYPE_UNHANDLED;
156 * }
157 *
158 * field = (typeof(field))entry;
159 *
160 * trace_seq_init(p);
161 * return trace_output_call(iter, <call>, <TP_printk> "\n");
162 *
163 * ------(or, for event class)------
164 *
165 * int ret;
166 *
167 * field = (typeof(field))iter->ent;
168 *
169 * ret = trace_raw_output_prep(iter, trace_event);
170 * if (ret != TRACE_TYPE_HANDLED)
171 * return ret;
172 *
173 * trace_event_printf(iter, <TP_printk> "\n");
174 *
175 * return trace_handle_return(s);
176 * -------
177 * }
178 *
179 * This is the method used to print the raw event to the trace
180 * output format. Note, this is not needed if the data is read
181 * in binary.
182 */
183
184 #include "stages/stage3_trace_output.h"
185
186 #undef DECLARE_EVENT_CLASS
187 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
188 static notrace enum print_line_t \
189 trace_raw_output_##call(struct trace_iterator *iter, int flags, \
190 struct trace_event *trace_event) \
191 { \
192 struct trace_seq *s = &iter->seq; \
193 struct trace_seq __maybe_unused *p = &iter->tmp_seq; \
194 struct trace_event_raw_##call *field; \
195 int ret; \
196 \
197 field = (typeof(field))iter->ent; \
198 \
199 ret = trace_raw_output_prep(iter, trace_event); \
200 if (ret != TRACE_TYPE_HANDLED) \
201 return ret; \
202 \
203 trace_event_printf(iter, print); \
204 \
205 return trace_handle_return(s); \
206 } \
207 static struct trace_event_functions trace_event_type_funcs_##call = { \
208 .trace = trace_raw_output_##call, \
209 };
210
211 #undef DEFINE_EVENT_PRINT
212 #define DEFINE_EVENT_PRINT(template, call, proto, args, print) \
213 static notrace enum print_line_t \
214 trace_raw_output_##call(struct trace_iterator *iter, int flags, \
215 struct trace_event *event) \
216 { \
217 struct trace_event_raw_##template *field; \
218 struct trace_entry *entry; \
219 struct trace_seq *p = &iter->tmp_seq; \
220 \
221 entry = iter->ent; \
222 \
223 if (entry->type != event_##call.event.type) { \
224 WARN_ON_ONCE(1); \
225 return TRACE_TYPE_UNHANDLED; \
226 } \
227 \
228 field = (typeof(field))entry; \
229 \
230 trace_seq_init(p); \
231 return trace_output_call(iter, #call, print); \
232 } \
233 static struct trace_event_functions trace_event_type_funcs_##call = { \
234 .trace = trace_raw_output_##call, \
235 };
236
237 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
238
239 #include "stages/stage4_event_fields.h"
240
241 #undef DECLARE_EVENT_CLASS
242 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, func, print) \
243 static struct trace_event_fields trace_event_fields_##call[] = { \
244 tstruct \
245 {} };
246
247 #undef DEFINE_EVENT_PRINT
248 #define DEFINE_EVENT_PRINT(template, name, proto, args, print)
249
250 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
251
252 #include "stages/stage5_get_offsets.h"
253
254 #undef DECLARE_EVENT_CLASS
255 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
256 static inline notrace int trace_event_get_offsets_##call( \
257 struct trace_event_data_offsets_##call *__data_offsets, proto) \
258 { \
259 int __data_size = 0; \
260 int __maybe_unused __item_length; \
261 struct trace_event_raw_##call __maybe_unused *entry; \
262 \
263 tstruct; \
264 \
265 return __data_size; \
266 }
267
268 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
269
270 /*
271 * Stage 4 of the trace events.
272 *
273 * Override the macros in the event tracepoint header <trace/events/XXX.h>
274 * to include the following:
275 *
276 * For those macros defined with TRACE_EVENT:
277 *
278 * static struct trace_event_call event_<call>;
279 *
280 * static void trace_event_raw_event_<call>(void *__data, proto)
281 * {
282 * struct trace_event_file *trace_file = __data;
283 * struct trace_event_call *event_call = trace_file->event_call;
284 * struct trace_event_data_offsets_<call> __maybe_unused __data_offsets;
285 * unsigned long eflags = trace_file->flags;
286 * enum event_trigger_type __tt = ETT_NONE;
287 * struct ring_buffer_event *event;
288 * struct trace_event_raw_<call> *entry; <-- defined in stage 1
289 * struct trace_buffer *buffer;
290 * unsigned long irq_flags;
291 * int __data_size;
292 * int pc;
293 *
294 * if (!(eflags & EVENT_FILE_FL_TRIGGER_COND)) {
295 * if (eflags & EVENT_FILE_FL_TRIGGER_MODE)
296 * event_triggers_call(trace_file, NULL);
297 * if (eflags & EVENT_FILE_FL_SOFT_DISABLED)
298 * return;
299 * }
300 *
301 * local_save_flags(irq_flags);
302 * pc = preempt_count();
303 *
304 * __data_size = trace_event_get_offsets_<call>(&__data_offsets, args);
305 *
306 * event = trace_event_buffer_lock_reserve(&buffer, trace_file,
307 * event_<call>->event.type,
308 * sizeof(*entry) + __data_size,
309 * irq_flags, pc);
310 * if (!event)
311 * return;
312 * entry = ring_buffer_event_data(event);
313 *
314 * { <assign>; } <-- Here we assign the entries by the __field and
315 * __array macros.
316 *
317 * if (eflags & EVENT_FILE_FL_TRIGGER_COND)
318 * __tt = event_triggers_call(trace_file, entry);
319 *
320 * if (test_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT,
321 * &trace_file->flags))
322 * ring_buffer_discard_commit(buffer, event);
323 * else if (!filter_check_discard(trace_file, entry, buffer, event))
324 * trace_buffer_unlock_commit(buffer, event, irq_flags, pc);
325 *
326 * if (__tt)
327 * event_triggers_post_call(trace_file, __tt);
328 * }
329 *
330 * static struct trace_event ftrace_event_type_<call> = {
331 * .trace = trace_raw_output_<call>, <-- stage 2
332 * };
333 *
334 * static char print_fmt_<call>[] = <TP_printk>;
335 *
336 * static struct trace_event_class __used event_class_<template> = {
337 * .system = "<system>",
338 * .fields_array = trace_event_fields_<call>,
339 * .fields = LIST_HEAD_INIT(event_class_##call.fields),
340 * .raw_init = trace_event_raw_init,
341 * .probe = trace_event_raw_event_##call,
342 * .reg = trace_event_reg,
343 * };
344 *
345 * static struct trace_event_call event_<call> = {
346 * .class = event_class_<template>,
347 * {
348 * .tp = &__tracepoint_<call>,
349 * },
350 * .event = &ftrace_event_type_<call>,
351 * .print_fmt = print_fmt_<call>,
352 * .flags = TRACE_EVENT_FL_TRACEPOINT,
353 * };
354 * // its only safe to use pointers when doing linker tricks to
355 * // create an array.
356 * static struct trace_event_call __used
357 * __section("_ftrace_events") *__event_<call> = &event_<call>;
358 *
359 */
360
361 #ifdef CONFIG_PERF_EVENTS
362
363 #define _TRACE_PERF_PROTO(call, proto) \
364 static notrace void \
365 perf_trace_##call(void *__data, proto);
366
367 #define _TRACE_PERF_INIT(call) \
368 .perf_probe = perf_trace_##call,
369
370 #else
371 #define _TRACE_PERF_PROTO(call, proto)
372 #define _TRACE_PERF_INIT(call)
373 #endif /* CONFIG_PERF_EVENTS */
374
375 #include "stages/stage6_event_callback.h"
376
377 #undef DECLARE_EVENT_CLASS
378 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
379 \
380 static notrace void \
381 trace_event_raw_event_##call(void *__data, proto) \
382 { \
383 struct trace_event_file *trace_file = __data; \
384 struct trace_event_data_offsets_##call __maybe_unused __data_offsets;\
385 struct trace_event_buffer fbuffer; \
386 struct trace_event_raw_##call *entry; \
387 int __data_size; \
388 \
389 if (trace_trigger_soft_disabled(trace_file)) \
390 return; \
391 \
392 __data_size = trace_event_get_offsets_##call(&__data_offsets, args); \
393 \
394 entry = trace_event_buffer_reserve(&fbuffer, trace_file, \
395 sizeof(*entry) + __data_size); \
396 \
397 if (!entry) \
398 return; \
399 \
400 tstruct \
401 \
402 { assign; } \
403 \
404 trace_event_buffer_commit(&fbuffer); \
405 }
406 /*
407 * The ftrace_test_probe is compiled out, it is only here as a build time check
408 * to make sure that if the tracepoint handling changes, the ftrace probe will
409 * fail to compile unless it too is updated.
410 */
411
412 #undef DEFINE_EVENT
413 #define DEFINE_EVENT(template, call, proto, args) \
414 static inline void ftrace_test_probe_##call(void) \
415 { \
416 check_trace_callback_type_##call(trace_event_raw_event_##template); \
417 }
418
419 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
420
421 #include "stages/stage7_class_define.h"
422
423 #undef DECLARE_EVENT_CLASS
424 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
425 _TRACE_PERF_PROTO(call, PARAMS(proto)); \
426 static char print_fmt_##call[] = print; \
427 static struct trace_event_class __used __refdata event_class_##call = { \
428 .system = TRACE_SYSTEM_STRING, \
429 .fields_array = trace_event_fields_##call, \
430 .fields = LIST_HEAD_INIT(event_class_##call.fields),\
431 .raw_init = trace_event_raw_init, \
432 .probe = trace_event_raw_event_##call, \
433 .reg = trace_event_reg, \
434 _TRACE_PERF_INIT(call) \
435 };
436
437 #undef DEFINE_EVENT
438 #define DEFINE_EVENT(template, call, proto, args) \
439 \
440 static struct trace_event_call __used event_##call = { \
441 .class = &event_class_##template, \
442 { \
443 .tp = &__tracepoint_##call, \
444 }, \
445 .event.funcs = &trace_event_type_funcs_##template, \
446 .print_fmt = print_fmt_##template, \
447 .flags = TRACE_EVENT_FL_TRACEPOINT, \
448 }; \
449 static struct trace_event_call __used \
450 __section("_ftrace_events") *__event_##call = &event_##call
451
452 #undef DEFINE_EVENT_PRINT
453 #define DEFINE_EVENT_PRINT(template, call, proto, args, print) \
454 \
455 static char print_fmt_##call[] = print; \
456 \
457 static struct trace_event_call __used event_##call = { \
458 .class = &event_class_##template, \
459 { \
460 .tp = &__tracepoint_##call, \
461 }, \
462 .event.funcs = &trace_event_type_funcs_##call, \
463 .print_fmt = print_fmt_##call, \
464 .flags = TRACE_EVENT_FL_TRACEPOINT, \
465 }; \
466 static struct trace_event_call __used \
467 __section("_ftrace_events") *__event_##call = &event_##call
468
469 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
470
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.