tracing: Move print functions into event class
[deliverable/linux.git] / include / trace / ftrace.h
CommitLineData
f42c85e7
SR
1/*
2 * Stage 1 of the trace events.
3 *
4 * Override the macros in <trace/trace_events.h> to include the following:
5 *
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
ff038f5c 21/*
091ad365 22 * DECLARE_EVENT_CLASS can be used to add a generic function
ff038f5c
SR
23 * 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
091ad365 26 * will map the DECLARE_EVENT_CLASS to the tracepoint.
ff038f5c
SR
27 *
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) \
091ad365 32 DECLARE_EVENT_CLASS(name, \
ff038f5c
SR
33 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
7fcb7c47
LZ
41#undef __field
42#define __field(type, item) type item;
43
43b51ead
LZ
44#undef __field_ext
45#define __field_ext(type, item, filter_type) type item;
46
f42c85e7
SR
47#undef __array
48#define __array(type, item, len) type item[len];
49
7fcb7c47 50#undef __dynamic_array
7d536cb3 51#define __dynamic_array(type, item, len) u32 __data_loc_##item;
f42c85e7 52
9cbf1176 53#undef __string
7fcb7c47 54#define __string(item, src) __dynamic_array(char, item, -1)
9cbf1176 55
f42c85e7
SR
56#undef TP_STRUCT__entry
57#define TP_STRUCT__entry(args...) args
58
091ad365
IM
59#undef DECLARE_EVENT_CLASS
60#define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print) \
ff038f5c
SR
61 struct ftrace_raw_##name { \
62 struct trace_entry ent; \
63 tstruct \
64 char __data[0]; \
8f082018
SR
65 }; \
66 \
67 static struct ftrace_event_class event_class_##name;
68
ff038f5c
SR
69#undef DEFINE_EVENT
70#define DEFINE_EVENT(template, name, proto, args) \
86c38a31
JM
71 static struct ftrace_event_call \
72 __attribute__((__aligned__(4))) event_##name
f42c85e7 73
e5bc9721
SR
74#undef DEFINE_EVENT_PRINT
75#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
76 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
77
0dd7b747
FW
78#undef __cpparg
79#define __cpparg(arg...) arg
80
97419875
JS
81/* Callbacks are meaningless to ftrace. */
82#undef TRACE_EVENT_FN
0dd7b747
FW
83#define TRACE_EVENT_FN(name, proto, args, tstruct, \
84 assign, print, reg, unreg) \
85 TRACE_EVENT(name, __cpparg(proto), __cpparg(args), \
86 __cpparg(tstruct), __cpparg(assign), __cpparg(print)) \
97419875 87
f42c85e7
SR
88#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
89
9cbf1176 90
f42c85e7
SR
91/*
92 * Stage 2 of the trace events.
93 *
9cbf1176
FW
94 * Include the following:
95 *
7fcb7c47 96 * struct ftrace_data_offsets_<call> {
7d536cb3
LZ
97 * u32 <item1>;
98 * u32 <item2>;
9cbf1176
FW
99 * [...]
100 * };
101 *
7d536cb3 102 * The __dynamic_array() macro will create each u32 <item>, this is
7fcb7c47 103 * to keep the offset of each array from the beginning of the event.
7d536cb3 104 * The size of an array is also encoded, in the higher 16 bits of <item>.
9cbf1176
FW
105 */
106
7fcb7c47 107#undef __field
43b51ead
LZ
108#define __field(type, item)
109
110#undef __field_ext
111#define __field_ext(type, item, filter_type)
7fcb7c47 112
9cbf1176
FW
113#undef __array
114#define __array(type, item, len)
115
7fcb7c47 116#undef __dynamic_array
7d536cb3 117#define __dynamic_array(type, item, len) u32 item;
9cbf1176
FW
118
119#undef __string
7fcb7c47 120#define __string(item, src) __dynamic_array(char, item, -1)
9cbf1176 121
091ad365
IM
122#undef DECLARE_EVENT_CLASS
123#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
7fcb7c47 124 struct ftrace_data_offsets_##call { \
9cbf1176
FW
125 tstruct; \
126 };
127
ff038f5c
SR
128#undef DEFINE_EVENT
129#define DEFINE_EVENT(template, name, proto, args)
130
e5bc9721
SR
131#undef DEFINE_EVENT_PRINT
132#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
133 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
134
9cbf1176
FW
135#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
136
137/*
138 * Stage 3 of the trace events.
139 *
f42c85e7
SR
140 * Override the macros in <trace/trace_events.h> to include the following:
141 *
142 * enum print_line_t
143 * ftrace_raw_output_<call>(struct trace_iterator *iter, int flags)
144 * {
145 * struct trace_seq *s = &iter->seq;
146 * struct ftrace_raw_<call> *field; <-- defined in stage 1
147 * struct trace_entry *entry;
be74b73a 148 * struct trace_seq *p;
f42c85e7
SR
149 * int ret;
150 *
151 * entry = iter->ent;
152 *
153 * if (entry->type != event_<call>.id) {
154 * WARN_ON_ONCE(1);
155 * return TRACE_TYPE_UNHANDLED;
156 * }
157 *
158 * field = (typeof(field))entry;
159 *
50354a8a 160 * p = &get_cpu_var(ftrace_event_seq);
56d8bd3f 161 * trace_seq_init(p);
50354a8a
LZ
162 * ret = trace_seq_printf(s, "%s: ", <call>);
163 * if (ret)
164 * ret = trace_seq_printf(s, <TP_printk> "\n");
be74b73a 165 * put_cpu();
f42c85e7
SR
166 * if (!ret)
167 * return TRACE_TYPE_PARTIAL_LINE;
168 *
169 * return TRACE_TYPE_HANDLED;
170 * }
171 *
172 * This is the method used to print the raw event to the trace
173 * output format. Note, this is not needed if the data is read
174 * in binary.
175 */
176
177#undef __entry
178#define __entry field
179
180#undef TP_printk
181#define TP_printk(fmt, args...) fmt "\n", args
182
7fcb7c47
LZ
183#undef __get_dynamic_array
184#define __get_dynamic_array(field) \
7d536cb3 185 ((void *)__entry + (__entry->__data_loc_##field & 0xffff))
7fcb7c47 186
9cbf1176 187#undef __get_str
7fcb7c47 188#define __get_str(field) (char *)__get_dynamic_array(field)
9cbf1176 189
be74b73a
SR
190#undef __print_flags
191#define __print_flags(flag, delim, flag_array...) \
192 ({ \
a48f494e 193 static const struct trace_print_flags __flags[] = \
be74b73a 194 { flag_array, { -1, NULL }}; \
a48f494e 195 ftrace_print_flags_seq(p, delim, flag, __flags); \
be74b73a
SR
196 })
197
0f4fc29d
SR
198#undef __print_symbolic
199#define __print_symbolic(value, symbol_array...) \
200 ({ \
201 static const struct trace_print_flags symbols[] = \
202 { symbol_array, { -1, NULL }}; \
203 ftrace_print_symbols_seq(p, value, symbols); \
204 })
205
091ad365
IM
206#undef DECLARE_EVENT_CLASS
207#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
83f0d539 208static notrace enum print_line_t \
80decc70
SR
209ftrace_raw_output_##call(struct trace_iterator *iter, int flags, \
210 struct trace_event *trace_event) \
f42c85e7 211{ \
80decc70 212 struct ftrace_event_call *event; \
f42c85e7
SR
213 struct trace_seq *s = &iter->seq; \
214 struct ftrace_raw_##call *field; \
215 struct trace_entry *entry; \
be74b73a 216 struct trace_seq *p; \
f42c85e7
SR
217 int ret; \
218 \
80decc70
SR
219 event = container_of(trace_event, struct ftrace_event_call, \
220 event); \
221 \
f42c85e7
SR
222 entry = iter->ent; \
223 \
80decc70 224 if (entry->type != event->id) { \
f42c85e7
SR
225 WARN_ON_ONCE(1); \
226 return TRACE_TYPE_UNHANDLED; \
227 } \
228 \
229 field = (typeof(field))entry; \
230 \
be74b73a 231 p = &get_cpu_var(ftrace_event_seq); \
56d8bd3f 232 trace_seq_init(p); \
80decc70 233 ret = trace_seq_printf(s, "%s: ", event->name); \
ff038f5c
SR
234 if (ret) \
235 ret = trace_seq_printf(s, print); \
be74b73a 236 put_cpu(); \
f42c85e7
SR
237 if (!ret) \
238 return TRACE_TYPE_PARTIAL_LINE; \
239 \
240 return TRACE_TYPE_HANDLED; \
80decc70
SR
241} \
242static struct trace_event_functions ftrace_event_type_funcs_##call = { \
243 .trace = ftrace_raw_output_##call, \
244};
ff038f5c 245
e5bc9721
SR
246#undef DEFINE_EVENT_PRINT
247#define DEFINE_EVENT_PRINT(template, call, proto, args, print) \
83f0d539 248static notrace enum print_line_t \
a9a57763
SR
249ftrace_raw_output_##call(struct trace_iterator *iter, int flags, \
250 struct trace_event *event) \
e5bc9721
SR
251{ \
252 struct trace_seq *s = &iter->seq; \
253 struct ftrace_raw_##template *field; \
254 struct trace_entry *entry; \
255 struct trace_seq *p; \
f42c85e7
SR
256 int ret; \
257 \
258 entry = iter->ent; \
259 \
260 if (entry->type != event_##call.id) { \
261 WARN_ON_ONCE(1); \
262 return TRACE_TYPE_UNHANDLED; \
263 } \
264 \
265 field = (typeof(field))entry; \
266 \
be74b73a 267 p = &get_cpu_var(ftrace_event_seq); \
56d8bd3f 268 trace_seq_init(p); \
e5bc9721
SR
269 ret = trace_seq_printf(s, "%s: ", #call); \
270 if (ret) \
271 ret = trace_seq_printf(s, print); \
be74b73a 272 put_cpu(); \
f42c85e7
SR
273 if (!ret) \
274 return TRACE_TYPE_PARTIAL_LINE; \
275 \
276 return TRACE_TYPE_HANDLED; \
80decc70
SR
277} \
278static struct trace_event_functions ftrace_event_type_funcs_##call = { \
279 .trace = ftrace_raw_output_##call, \
280};
e5bc9721 281
f42c85e7
SR
282#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
283
43b51ead
LZ
284#undef __field_ext
285#define __field_ext(type, item, filter_type) \
f42c85e7
SR
286 ret = trace_define_field(event_call, #type, #item, \
287 offsetof(typeof(field), item), \
43b51ead
LZ
288 sizeof(field.item), \
289 is_signed_type(type), filter_type); \
f42c85e7
SR
290 if (ret) \
291 return ret;
292
43b51ead
LZ
293#undef __field
294#define __field(type, item) __field_ext(type, item, FILTER_OTHER)
295
f42c85e7
SR
296#undef __array
297#define __array(type, item, len) \
298 BUILD_BUG_ON(len > MAX_FILTER_STR_VAL); \
299 ret = trace_define_field(event_call, #type "[" #len "]", #item, \
300 offsetof(typeof(field), item), \
fb7ae981
LJ
301 sizeof(field.item), \
302 is_signed_type(type), FILTER_OTHER); \
f42c85e7
SR
303 if (ret) \
304 return ret;
305
7fcb7c47
LZ
306#undef __dynamic_array
307#define __dynamic_array(type, item, len) \
68fd60a8 308 ret = trace_define_field(event_call, "__data_loc " #type "[]", #item, \
43b51ead 309 offsetof(typeof(field), __data_loc_##item), \
fb7ae981
LJ
310 sizeof(field.__data_loc_##item), \
311 is_signed_type(type), FILTER_OTHER);
7fcb7c47 312
9cbf1176 313#undef __string
7fcb7c47 314#define __string(item, src) __dynamic_array(char, item, -1)
9cbf1176 315
091ad365
IM
316#undef DECLARE_EVENT_CLASS
317#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, func, print) \
83f0d539 318static int notrace \
14be96c9 319ftrace_define_fields_##call(struct ftrace_event_call *event_call) \
f42c85e7
SR
320{ \
321 struct ftrace_raw_##call field; \
f42c85e7
SR
322 int ret; \
323 \
f42c85e7
SR
324 tstruct; \
325 \
326 return ret; \
327}
328
ff038f5c
SR
329#undef DEFINE_EVENT
330#define DEFINE_EVENT(template, name, proto, args)
331
e5bc9721
SR
332#undef DEFINE_EVENT_PRINT
333#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
334 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
335
f42c85e7
SR
336#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
337
7fcb7c47
LZ
338/*
339 * remember the offset of each array from the beginning of the event.
340 */
341
342#undef __entry
343#define __entry entry
344
345#undef __field
346#define __field(type, item)
347
43b51ead
LZ
348#undef __field_ext
349#define __field_ext(type, item, filter_type)
350
7fcb7c47
LZ
351#undef __array
352#define __array(type, item, len)
353
354#undef __dynamic_array
355#define __dynamic_array(type, item, len) \
356 __data_offsets->item = __data_size + \
357 offsetof(typeof(*entry), __data); \
7d536cb3 358 __data_offsets->item |= (len * sizeof(type)) << 16; \
7fcb7c47
LZ
359 __data_size += (len) * sizeof(type);
360
361#undef __string
ff038f5c 362#define __string(item, src) __dynamic_array(char, item, strlen(src) + 1)
7fcb7c47 363
091ad365
IM
364#undef DECLARE_EVENT_CLASS
365#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
83f0d539 366static inline notrace int ftrace_get_offsets_##call( \
7fcb7c47
LZ
367 struct ftrace_data_offsets_##call *__data_offsets, proto) \
368{ \
369 int __data_size = 0; \
370 struct ftrace_raw_##call __maybe_unused *entry; \
371 \
372 tstruct; \
373 \
374 return __data_size; \
375}
376
ff038f5c
SR
377#undef DEFINE_EVENT
378#define DEFINE_EVENT(template, name, proto, args)
379
e5bc9721
SR
380#undef DEFINE_EVENT_PRINT
381#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
382 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
383
7fcb7c47
LZ
384#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
385
c32e827b 386/*
9cbf1176 387 * Stage 4 of the trace events.
c32e827b 388 *
ea20d929 389 * Override the macros in <trace/trace_events.h> to include the following:
c32e827b 390 *
157587d7 391 * For those macros defined with TRACE_EVENT:
c32e827b
SR
392 *
393 * static struct ftrace_event_call event_<call>;
394 *
2239291a 395 * static void ftrace_raw_event_<call>(void *__data, proto)
c32e827b 396 * {
2239291a 397 * struct ftrace_event_call *event_call = __data;
50354a8a 398 * struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;
ef18012b
SR
399 * struct ring_buffer_event *event;
400 * struct ftrace_raw_<call> *entry; <-- defined in stage 1
e77405ad 401 * struct ring_buffer *buffer;
ef18012b 402 * unsigned long irq_flags;
50354a8a 403 * int __data_size;
ef18012b
SR
404 * int pc;
405 *
406 * local_save_flags(irq_flags);
407 * pc = preempt_count();
408 *
50354a8a
LZ
409 * __data_size = ftrace_get_offsets_<call>(&__data_offsets, args);
410 *
e77405ad
SR
411 * event = trace_current_buffer_lock_reserve(&buffer,
412 * event_<call>.id,
50354a8a 413 * sizeof(*entry) + __data_size,
ef18012b
SR
414 * irq_flags, pc);
415 * if (!event)
416 * return;
417 * entry = ring_buffer_event_data(event);
418 *
50354a8a
LZ
419 * { <assign>; } <-- Here we assign the entries by the __field and
420 * __array macros.
c32e827b 421 *
50354a8a
LZ
422 * if (!filter_current_check_discard(buffer, event_call, entry, event))
423 * trace_current_buffer_unlock_commit(buffer,
424 * event, irq_flags, pc);
c32e827b
SR
425 * }
426 *
c32e827b 427 * static struct trace_event ftrace_event_type_<call> = {
ef18012b 428 * .trace = ftrace_raw_output_<call>, <-- stage 2
c32e827b
SR
429 * };
430 *
50354a8a
LZ
431 * static const char print_fmt_<call>[] = <TP_printk>;
432 *
8f082018
SR
433 * static struct ftrace_event_class __used event_class_<template> = {
434 * .system = "<system>",
2e33af02 435 * .define_fields = ftrace_define_fields_<call>,
0405ab80
SR
436 * .fields = LIST_HEAD_INIT(event_class_##call.fields),
437 * .raw_init = trace_event_raw_init,
438 * .probe = ftrace_raw_event_##call,
8f082018
SR
439 * };
440 *
c32e827b
SR
441 * static struct ftrace_event_call __used
442 * __attribute__((__aligned__(4)))
443 * __attribute__((section("_ftrace_events"))) event_<call> = {
ef18012b 444 * .name = "<call>",
8f082018 445 * .class = event_class_<template>,
2e33af02 446 * .event = &ftrace_event_type_<call>,
50354a8a 447 * .print_fmt = print_fmt_<call>,
8f082018 448 * };
c32e827b
SR
449 *
450 */
451
07b139c8 452#ifdef CONFIG_PERF_EVENTS
ac199db0 453
2239291a
SR
454#define _TRACE_PERF_PROTO(call, proto) \
455 static notrace void \
456 perf_trace_##call(void *__data, proto);
457
97d5a220 458#define _TRACE_PERF_INIT(call) \
2239291a 459 .perf_probe = perf_trace_##call,
ac199db0
PZ
460
461#else
2239291a 462#define _TRACE_PERF_PROTO(call, proto)
97d5a220 463#define _TRACE_PERF_INIT(call)
07b139c8 464#endif /* CONFIG_PERF_EVENTS */
ac199db0 465
da4d0302
SR
466#undef __entry
467#define __entry entry
d20e3b03 468
9cbf1176
FW
469#undef __field
470#define __field(type, item)
471
472#undef __array
473#define __array(type, item, len)
474
7fcb7c47
LZ
475#undef __dynamic_array
476#define __dynamic_array(type, item, len) \
477 __entry->__data_loc_##item = __data_offsets.item;
478
9cbf1176 479#undef __string
7fcb7c47 480#define __string(item, src) __dynamic_array(char, item, -1) \
9cbf1176
FW
481
482#undef __assign_str
483#define __assign_str(dst, src) \
9cbf1176
FW
484 strcpy(__get_str(dst), src);
485
0fa0edaf
LJ
486#undef TP_fast_assign
487#define TP_fast_assign(args...) args
488
489#undef TP_perf_assign
490#define TP_perf_assign(args...)
491
091ad365
IM
492#undef DECLARE_EVENT_CLASS
493#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
c32e827b 494 \
83f0d539 495static notrace void \
2239291a 496ftrace_raw_event_##call(void *__data, proto) \
c32e827b 497{ \
2239291a 498 struct ftrace_event_call *event_call = __data; \
7fcb7c47 499 struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
c32e827b
SR
500 struct ring_buffer_event *event; \
501 struct ftrace_raw_##call *entry; \
e77405ad 502 struct ring_buffer *buffer; \
c32e827b 503 unsigned long irq_flags; \
7fcb7c47 504 int __data_size; \
c32e827b
SR
505 int pc; \
506 \
507 local_save_flags(irq_flags); \
508 pc = preempt_count(); \
509 \
7fcb7c47 510 __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
9cbf1176 511 \
e77405ad 512 event = trace_current_buffer_lock_reserve(&buffer, \
ff038f5c 513 event_call->id, \
7fcb7c47 514 sizeof(*entry) + __data_size, \
9cbf1176 515 irq_flags, pc); \
c32e827b
SR
516 if (!event) \
517 return; \
518 entry = ring_buffer_event_data(event); \
519 \
7fcb7c47
LZ
520 tstruct \
521 \
a9c1c3ab 522 { assign; } \
c32e827b 523 \
e77405ad
SR
524 if (!filter_current_check_discard(buffer, event_call, entry, event)) \
525 trace_nowake_buffer_unlock_commit(buffer, \
526 event, irq_flags, pc); \
ff038f5c 527}
2239291a
SR
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 */
ff038f5c
SR
533
534#undef DEFINE_EVENT
535#define DEFINE_EVENT(template, call, proto, args) \
2239291a
SR
536static inline void ftrace_test_probe_##call(void) \
537{ \
538 check_trace_callback_type_##call(ftrace_raw_event_##template); \
539}
e5bc9721
SR
540
541#undef DEFINE_EVENT_PRINT
80decc70 542#define DEFINE_EVENT_PRINT(template, name, proto, args, print)
e5bc9721
SR
543
544#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
545
509e760c
LJ
546#undef __entry
547#define __entry REC
548
549#undef __print_flags
550#undef __print_symbolic
551#undef __get_dynamic_array
552#undef __get_str
553
554#undef TP_printk
555#define TP_printk(fmt, args...) "\"" fmt "\", " __stringify(args)
556
091ad365 557#undef DECLARE_EVENT_CLASS
509e760c 558#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
2239291a 559_TRACE_PERF_PROTO(call, PARAMS(proto)); \
8f082018
SR
560static const char print_fmt_##call[] = print; \
561static struct ftrace_event_class __used event_class_##call = { \
2239291a 562 .system = __stringify(TRACE_SYSTEM), \
2e33af02
SR
563 .define_fields = ftrace_define_fields_##call, \
564 .fields = LIST_HEAD_INIT(event_class_##call.fields),\
0405ab80 565 .raw_init = trace_event_raw_init, \
2239291a
SR
566 .probe = ftrace_raw_event_##call, \
567 _TRACE_PERF_INIT(call) \
8f082018 568};
e5bc9721
SR
569
570#undef DEFINE_EVENT
571#define DEFINE_EVENT(template, call, proto, args) \
c32e827b
SR
572 \
573static struct ftrace_event_call __used \
574__attribute__((__aligned__(4))) \
575__attribute__((section("_ftrace_events"))) event_##call = { \
ef18012b 576 .name = #call, \
8f082018 577 .class = &event_class_##template, \
80decc70 578 .event.funcs = &ftrace_event_type_funcs_##template, \
509e760c 579 .print_fmt = print_fmt_##template, \
8f082018 580};
ac199db0 581
e5bc9721
SR
582#undef DEFINE_EVENT_PRINT
583#define DEFINE_EVENT_PRINT(template, call, proto, args, print) \
c32e827b 584 \
509e760c
LJ
585static const char print_fmt_##call[] = print; \
586 \
c32e827b
SR
587static struct ftrace_event_call __used \
588__attribute__((__aligned__(4))) \
589__attribute__((section("_ftrace_events"))) event_##call = { \
ef18012b 590 .name = #call, \
8f082018 591 .class = &event_class_##template, \
80decc70 592 .event.funcs = &ftrace_event_type_funcs_##call, \
509e760c 593 .print_fmt = print_fmt_##call, \
c32e827b 594}
ac199db0 595
f42c85e7 596#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
ac199db0 597
f413cdb8 598/*
97d5a220 599 * Define the insertion callback to perf events
f413cdb8
FW
600 *
601 * The job is very similar to ftrace_raw_event_<call> except that we don't
602 * insert in the ring buffer but in a perf counter.
603 *
97d5a220 604 * static void ftrace_perf_<call>(proto)
f413cdb8
FW
605 * {
606 * struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;
607 * struct ftrace_event_call *event_call = &event_<call>;
cdd6c482 608 * extern void perf_tp_event(int, u64, u64, void *, int);
f413cdb8 609 * struct ftrace_raw_##call *entry;
444a2a3b 610 * struct perf_trace_buf *trace_buf;
f413cdb8
FW
611 * u64 __addr = 0, __count = 1;
612 * unsigned long irq_flags;
20ab4425 613 * struct trace_entry *ent;
f413cdb8
FW
614 * int __entry_size;
615 * int __data_size;
20ab4425 616 * int __cpu
f413cdb8
FW
617 * int pc;
618 *
f413cdb8
FW
619 * pc = preempt_count();
620 *
621 * __data_size = ftrace_get_offsets_<call>(&__data_offsets, args);
304703ab
FW
622 *
623 * // Below we want to get the aligned size by taking into account
624 * // the u32 field that will later store the buffer size
625 * __entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),
626 * sizeof(u64));
627 * __entry_size -= sizeof(u32);
f413cdb8 628 *
20ab4425
FW
629 * // Protect the non nmi buffer
630 * // This also protects the rcu read side
631 * local_irq_save(irq_flags);
632 * __cpu = smp_processor_id();
633 *
634 * if (in_nmi())
8d53dd54 635 * trace_buf = rcu_dereference_sched(perf_trace_buf_nmi);
20ab4425 636 * else
8d53dd54 637 * trace_buf = rcu_dereference_sched(perf_trace_buf);
20ab4425 638 *
444a2a3b 639 * if (!trace_buf)
20ab4425 640 * goto end;
f413cdb8 641 *
444a2a3b
FW
642 * trace_buf = per_cpu_ptr(trace_buf, __cpu);
643 *
644 * // Avoid recursion from perf that could mess up the buffer
645 * if (trace_buf->recursion++)
646 * goto end_recursion;
647 *
648 * raw_data = trace_buf->buf;
649 *
650 * // Make recursion update visible before entering perf_tp_event
651 * // so that we protect from perf recursions.
652 *
653 * barrier();
1853db0e 654 *
20ab4425
FW
655 * //zero dead bytes from alignment to avoid stack leak to userspace:
656 * *(u64 *)(&raw_data[__entry_size - sizeof(u64)]) = 0ULL;
657 * entry = (struct ftrace_raw_<call> *)raw_data;
658 * ent = &entry->ent;
659 * tracing_generic_entry_update(ent, irq_flags, pc);
660 * ent->type = event_call->id;
f413cdb8 661 *
20ab4425 662 * <tstruct> <- do some jobs with dynamic arrays
f413cdb8 663 *
20ab4425 664 * <assign> <- affect our values
f413cdb8 665 *
43c1266c 666 * perf_tp_event(event_call->id, __addr, __count, entry,
20ab4425 667 * __entry_size); <- submit them to perf counter
f413cdb8
FW
668 *
669 * }
670 */
671
07b139c8 672#ifdef CONFIG_PERF_EVENTS
f413cdb8 673
509e760c
LJ
674#undef __entry
675#define __entry entry
676
677#undef __get_dynamic_array
678#define __get_dynamic_array(field) \
679 ((void *)__entry + (__entry->__data_loc_##field & 0xffff))
680
681#undef __get_str
682#define __get_str(field) (char *)__get_dynamic_array(field)
683
f413cdb8
FW
684#undef __perf_addr
685#define __perf_addr(a) __addr = (a)
686
687#undef __perf_count
688#define __perf_count(c) __count = (c)
689
091ad365
IM
690#undef DECLARE_EVENT_CLASS
691#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
83f0d539 692static notrace void \
2239291a 693perf_trace_##call(void *__data, proto) \
f413cdb8 694{ \
2239291a 695 struct ftrace_event_call *event_call = __data; \
f413cdb8 696 struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
f413cdb8
FW
697 struct ftrace_raw_##call *entry; \
698 u64 __addr = 0, __count = 1; \
699 unsigned long irq_flags; \
c530665c 700 struct pt_regs *__regs; \
f413cdb8
FW
701 int __entry_size; \
702 int __data_size; \
4ed7c92d 703 int rctx; \
f413cdb8
FW
704 \
705 __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
a044560c
PZ
706 __entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),\
707 sizeof(u64)); \
304703ab 708 __entry_size -= sizeof(u32); \
f413cdb8 709 \
97d5a220 710 if (WARN_ONCE(__entry_size > PERF_MAX_TRACE_SIZE, \
20ab4425
FW
711 "profile buffer not large enough")) \
712 return; \
97d5a220 713 entry = (struct ftrace_raw_##call *)perf_trace_buf_prepare( \
430ad5a6
XG
714 __entry_size, event_call->id, &rctx, &irq_flags); \
715 if (!entry) \
716 return; \
20ab4425
FW
717 tstruct \
718 \
719 { assign; } \
720 \
c530665c
FW
721 __regs = &__get_cpu_var(perf_trace_regs); \
722 perf_fetch_caller_regs(__regs, 2); \
723 \
97d5a220 724 perf_trace_buf_submit(entry, __entry_size, rctx, __addr, \
c530665c 725 __count, irq_flags, __regs); \
f413cdb8
FW
726}
727
2239291a
SR
728/*
729 * This part is compiled out, it is only here as a build time check
730 * to make sure that if the tracepoint handling changes, the
731 * perf probe will fail to compile unless it too is updated.
732 */
ff038f5c 733#undef DEFINE_EVENT
2239291a
SR
734#define DEFINE_EVENT(template, call, proto, args) \
735static inline void perf_test_probe_##call(void) \
736{ \
737 check_trace_callback_type_##call(perf_trace_##template); \
738 \
ff038f5c
SR
739}
740
2239291a 741
e5bc9721
SR
742#undef DEFINE_EVENT_PRINT
743#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
744 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
745
f413cdb8 746#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
07b139c8 747#endif /* CONFIG_PERF_EVENTS */
f413cdb8 748
ac199db0
PZ
749#undef _TRACE_PROFILE_INIT
750
This page took 0.110612 seconds and 5 git commands to generate.