~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/trace/ftrace.h

Version: ~ [ linux-5.8-rc3 ] ~ [ linux-5.7.5 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.48 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.129 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.185 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.228 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.228 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 21 /*
 22  * DECLARE_EVENT_CLASS can be used to add a generic function
 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
 26  * will map the DECLARE_EVENT_CLASS to the tracepoint.
 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) \
 32         DECLARE_EVENT_CLASS(name,                              \
 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 
 41 #undef __field
 42 #define __field(type, item)             type    item;
 43 
 44 #undef __field_ext
 45 #define __field_ext(type, item, filter_type)    type    item;
 46 
 47 #undef __field_struct
 48 #define __field_struct(type, item)      type    item;
 49 
 50 #undef __field_struct_ext
 51 #define __field_struct_ext(type, item, filter_type)     type    item;
 52 
 53 #undef __array
 54 #define __array(type, item, len)        type    item[len];
 55 
 56 #undef __dynamic_array
 57 #define __dynamic_array(type, item, len) u32 __data_loc_##item;
 58 
 59 #undef __string
 60 #define __string(item, src) __dynamic_array(char, item, -1)
 61 
 62 #undef __bitmask
 63 #define __bitmask(item, nr_bits) __dynamic_array(char, item, -1)
 64 
 65 #undef TP_STRUCT__entry
 66 #define TP_STRUCT__entry(args...) args
 67 
 68 #undef DECLARE_EVENT_CLASS
 69 #define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print)  \
 70         struct ftrace_raw_##name {                                      \
 71                 struct trace_entry      ent;                            \
 72                 tstruct                                                 \
 73                 char                    __data[0];                      \
 74         };                                                              \
 75                                                                         \
 76         static struct ftrace_event_class event_class_##name;
 77 
 78 #undef DEFINE_EVENT
 79 #define DEFINE_EVENT(template, name, proto, args)       \
 80         static struct ftrace_event_call __used          \
 81         __attribute__((__aligned__(4))) event_##name
 82 
 83 #undef DEFINE_EVENT_FN
 84 #define DEFINE_EVENT_FN(template, name, proto, args, reg, unreg)        \
 85         DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
 86 
 87 #undef DEFINE_EVENT_PRINT
 88 #define DEFINE_EVENT_PRINT(template, name, proto, args, print)  \
 89         DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
 90 
 91 /* Callbacks are meaningless to ftrace. */
 92 #undef TRACE_EVENT_FN
 93 #define TRACE_EVENT_FN(name, proto, args, tstruct,                      \
 94                 assign, print, reg, unreg)                              \
 95         TRACE_EVENT(name, PARAMS(proto), PARAMS(args),                  \
 96                 PARAMS(tstruct), PARAMS(assign), PARAMS(print))         \
 97 
 98 #undef TRACE_EVENT_FLAGS
 99 #define TRACE_EVENT_FLAGS(name, value)                                  \
100         __TRACE_EVENT_FLAGS(name, value)
101 
102 #undef TRACE_EVENT_PERF_PERM
103 #define TRACE_EVENT_PERF_PERM(name, expr...)                            \
104         __TRACE_EVENT_PERF_PERM(name, expr)
105 
106 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
107 
108 
109 /*
110  * Stage 2 of the trace events.
111  *
112  * Include the following:
113  *
114  * struct ftrace_data_offsets_<call> {
115  *      u32                             <item1>;
116  *      u32                             <item2>;
117  *      [...]
118  * };
119  *
120  * The __dynamic_array() macro will create each u32 <item>, this is
121  * to keep the offset of each array from the beginning of the event.
122  * The size of an array is also encoded, in the higher 16 bits of <item>.
123  */
124 
125 #undef __field
126 #define __field(type, item)
127 
128 #undef __field_ext
129 #define __field_ext(type, item, filter_type)
130 
131 #undef __field_struct
132 #define __field_struct(type, item)
133 
134 #undef __field_struct_ext
135 #define __field_struct_ext(type, item, filter_type)
136 
137 #undef __array
138 #define __array(type, item, len)
139 
140 #undef __dynamic_array
141 #define __dynamic_array(type, item, len)        u32 item;
142 
143 #undef __string
144 #define __string(item, src) __dynamic_array(char, item, -1)
145 
146 #undef __bitmask
147 #define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, -1)
148 
149 #undef DECLARE_EVENT_CLASS
150 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
151         struct ftrace_data_offsets_##call {                             \
152                 tstruct;                                                \
153         };
154 
155 #undef DEFINE_EVENT
156 #define DEFINE_EVENT(template, name, proto, args)
157 
158 #undef DEFINE_EVENT_PRINT
159 #define DEFINE_EVENT_PRINT(template, name, proto, args, print)  \
160         DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
161 
162 #undef TRACE_EVENT_FLAGS
163 #define TRACE_EVENT_FLAGS(event, flag)
164 
165 #undef TRACE_EVENT_PERF_PERM
166 #define TRACE_EVENT_PERF_PERM(event, expr...)
167 
168 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
169 
170 /*
171  * Stage 3 of the trace events.
172  *
173  * Override the macros in <trace/trace_events.h> to include the following:
174  *
175  * enum print_line_t
176  * ftrace_raw_output_<call>(struct trace_iterator *iter, int flags)
177  * {
178  *      struct trace_seq *s = &iter->seq;
179  *      struct ftrace_raw_<call> *field; <-- defined in stage 1
180  *      struct trace_entry *entry;
181  *      struct trace_seq *p = &iter->tmp_seq;
182  *      int ret;
183  *
184  *      entry = iter->ent;
185  *
186  *      if (entry->type != event_<call>->event.type) {
187  *              WARN_ON_ONCE(1);
188  *              return TRACE_TYPE_UNHANDLED;
189  *      }
190  *
191  *      field = (typeof(field))entry;
192  *
193  *      trace_seq_init(p);
194  *      ret = trace_seq_printf(s, "%s: ", <call>);
195  *      if (ret)
196  *              ret = trace_seq_printf(s, <TP_printk> "\n");
197  *      if (!ret)
198  *              return TRACE_TYPE_PARTIAL_LINE;
199  *
200  *      return TRACE_TYPE_HANDLED;
201  * }
202  *
203  * This is the method used to print the raw event to the trace
204  * output format. Note, this is not needed if the data is read
205  * in binary.
206  */
207 
208 #undef __entry
209 #define __entry field
210 
211 #undef TP_printk
212 #define TP_printk(fmt, args...) fmt "\n", args
213 
214 #undef __get_dynamic_array
215 #define __get_dynamic_array(field)      \
216                 ((void *)__entry + (__entry->__data_loc_##field & 0xffff))
217 
218 #undef __get_dynamic_array_len
219 #define __get_dynamic_array_len(field)  \
220                 ((__entry->__data_loc_##field >> 16) & 0xffff)
221 
222 #undef __get_str
223 #define __get_str(field) (char *)__get_dynamic_array(field)
224 
225 #undef __get_bitmask
226 #define __get_bitmask(field)                                            \
227         ({                                                              \
228                 void *__bitmask = __get_dynamic_array(field);           \
229                 unsigned int __bitmask_size;                            \
230                 __bitmask_size = __get_dynamic_array_len(field);        \
231                 ftrace_print_bitmask_seq(p, __bitmask, __bitmask_size); \
232         })
233 
234 #undef __print_flags
235 #define __print_flags(flag, delim, flag_array...)                       \
236         ({                                                              \
237                 static const struct trace_print_flags __flags[] =       \
238                         { flag_array, { -1, NULL }};                    \
239                 ftrace_print_flags_seq(p, delim, flag, __flags);        \
240         })
241 
242 #undef __print_symbolic
243 #define __print_symbolic(value, symbol_array...)                        \
244         ({                                                              \
245                 static const struct trace_print_flags symbols[] =       \
246                         { symbol_array, { -1, NULL }};                  \
247                 ftrace_print_symbols_seq(p, value, symbols);            \
248         })
249 
250 #undef __print_symbolic_u64
251 #if BITS_PER_LONG == 32
252 #define __print_symbolic_u64(value, symbol_array...)                    \
253         ({                                                              \
254                 static const struct trace_print_flags_u64 symbols[] =   \
255                         { symbol_array, { -1, NULL } };                 \
256                 ftrace_print_symbols_seq_u64(p, value, symbols);        \
257         })
258 #else
259 #define __print_symbolic_u64(value, symbol_array...)                    \
260                         __print_symbolic(value, symbol_array)
261 #endif
262 
263 #undef __print_hex
264 #define __print_hex(buf, buf_len) ftrace_print_hex_seq(p, buf, buf_len)
265 
266 #undef DECLARE_EVENT_CLASS
267 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
268 static notrace enum print_line_t                                        \
269 ftrace_raw_output_##call(struct trace_iterator *iter, int flags,        \
270                          struct trace_event *trace_event)               \
271 {                                                                       \
272         struct trace_seq *s = &iter->seq;                               \
273         struct trace_seq __maybe_unused *p = &iter->tmp_seq;            \
274         struct ftrace_raw_##call *field;                                \
275         int ret;                                                        \
276                                                                         \
277         field = (typeof(field))iter->ent;                               \
278                                                                         \
279         ret = ftrace_raw_output_prep(iter, trace_event);                \
280         if (ret != TRACE_TYPE_HANDLED)                                  \
281                 return ret;                                             \
282                                                                         \
283         trace_seq_printf(s, print);                                     \
284                                                                         \
285         return trace_handle_return(s);                                  \
286 }                                                                       \
287 static struct trace_event_functions ftrace_event_type_funcs_##call = {  \
288         .trace                  = ftrace_raw_output_##call,             \
289 };
290 
291 #undef DEFINE_EVENT_PRINT
292 #define DEFINE_EVENT_PRINT(template, call, proto, args, print)          \
293 static notrace enum print_line_t                                        \
294 ftrace_raw_output_##call(struct trace_iterator *iter, int flags,        \
295                          struct trace_event *event)                     \
296 {                                                                       \
297         struct ftrace_raw_##template *field;                            \
298         struct trace_entry *entry;                                      \
299         struct trace_seq *p = &iter->tmp_seq;                           \
300                                                                         \
301         entry = iter->ent;                                              \
302                                                                         \
303         if (entry->type != event_##call.event.type) {                   \
304                 WARN_ON_ONCE(1);                                        \
305                 return TRACE_TYPE_UNHANDLED;                            \
306         }                                                               \
307                                                                         \
308         field = (typeof(field))entry;                                   \
309                                                                         \
310         trace_seq_init(p);                                              \
311         return ftrace_output_call(iter, #call, print);                  \
312 }                                                                       \
313 static struct trace_event_functions ftrace_event_type_funcs_##call = {  \
314         .trace                  = ftrace_raw_output_##call,             \
315 };
316 
317 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
318 
319 #undef __field_ext
320 #define __field_ext(type, item, filter_type)                            \
321         ret = trace_define_field(event_call, #type, #item,              \
322                                  offsetof(typeof(field), item),         \
323                                  sizeof(field.item),                    \
324                                  is_signed_type(type), filter_type);    \
325         if (ret)                                                        \
326                 return ret;
327 
328 #undef __field_struct_ext
329 #define __field_struct_ext(type, item, filter_type)                     \
330         ret = trace_define_field(event_call, #type, #item,              \
331                                  offsetof(typeof(field), item),         \
332                                  sizeof(field.item),                    \
333                                  0, filter_type);                       \
334         if (ret)                                                        \
335                 return ret;
336 
337 #undef __field
338 #define __field(type, item)     __field_ext(type, item, FILTER_OTHER)
339 
340 #undef __field_struct
341 #define __field_struct(type, item) __field_struct_ext(type, item, FILTER_OTHER)
342 
343 #undef __array
344 #define __array(type, item, len)                                        \
345         do {                                                            \
346                 char *type_str = #type"["__stringify(len)"]";           \
347                 BUILD_BUG_ON(len > MAX_FILTER_STR_VAL);                 \
348                 ret = trace_define_field(event_call, type_str, #item,   \
349                                  offsetof(typeof(field), item),         \
350                                  sizeof(field.item),                    \
351                                  is_signed_type(type), FILTER_OTHER);   \
352                 if (ret)                                                \
353                         return ret;                                     \
354         } while (0);
355 
356 #undef __dynamic_array
357 #define __dynamic_array(type, item, len)                                       \
358         ret = trace_define_field(event_call, "__data_loc " #type "[]", #item,  \
359                                  offsetof(typeof(field), __data_loc_##item),   \
360                                  sizeof(field.__data_loc_##item),              \
361                                  is_signed_type(type), FILTER_OTHER);
362 
363 #undef __string
364 #define __string(item, src) __dynamic_array(char, item, -1)
365 
366 #undef __bitmask
367 #define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, -1)
368 
369 #undef DECLARE_EVENT_CLASS
370 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, func, print)    \
371 static int notrace __init                                               \
372 ftrace_define_fields_##call(struct ftrace_event_call *event_call)       \
373 {                                                                       \
374         struct ftrace_raw_##call field;                                 \
375         int ret;                                                        \
376                                                                         \
377         tstruct;                                                        \
378                                                                         \
379         return ret;                                                     \
380 }
381 
382 #undef DEFINE_EVENT
383 #define DEFINE_EVENT(template, name, proto, args)
384 
385 #undef DEFINE_EVENT_PRINT
386 #define DEFINE_EVENT_PRINT(template, name, proto, args, print)  \
387         DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
388 
389 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
390 
391 /*
392  * remember the offset of each array from the beginning of the event.
393  */
394 
395 #undef __entry
396 #define __entry entry
397 
398 #undef __field
399 #define __field(type, item)
400 
401 #undef __field_ext
402 #define __field_ext(type, item, filter_type)
403 
404 #undef __field_struct
405 #define __field_struct(type, item)
406 
407 #undef __field_struct_ext
408 #define __field_struct_ext(type, item, filter_type)
409 
410 #undef __array
411 #define __array(type, item, len)
412 
413 #undef __dynamic_array
414 #define __dynamic_array(type, item, len)                                \
415         __item_length = (len) * sizeof(type);                           \
416         __data_offsets->item = __data_size +                            \
417                                offsetof(typeof(*entry), __data);        \
418         __data_offsets->item |= __item_length << 16;                    \
419         __data_size += __item_length;
420 
421 #undef __string
422 #define __string(item, src) __dynamic_array(char, item,                 \
423                     strlen((src) ? (const char *)(src) : "(null)") + 1)
424 
425 /*
426  * __bitmask_size_in_bytes_raw is the number of bytes needed to hold
427  * num_possible_cpus().
428  */
429 #define __bitmask_size_in_bytes_raw(nr_bits)    \
430         (((nr_bits) + 7) / 8)
431 
432 #define __bitmask_size_in_longs(nr_bits)                        \
433         ((__bitmask_size_in_bytes_raw(nr_bits) +                \
434           ((BITS_PER_LONG / 8) - 1)) / (BITS_PER_LONG / 8))
435 
436 /*
437  * __bitmask_size_in_bytes is the number of bytes needed to hold
438  * num_possible_cpus() padded out to the nearest long. This is what
439  * is saved in the buffer, just to be consistent.
440  */
441 #define __bitmask_size_in_bytes(nr_bits)                                \
442         (__bitmask_size_in_longs(nr_bits) * (BITS_PER_LONG / 8))
443 
444 #undef __bitmask
445 #define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item,   \
446                                          __bitmask_size_in_longs(nr_bits))
447 
448 #undef DECLARE_EVENT_CLASS
449 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
450 static inline notrace int ftrace_get_offsets_##call(                    \
451         struct ftrace_data_offsets_##call *__data_offsets, proto)       \
452 {                                                                       \
453         int __data_size = 0;                                            \
454         int __maybe_unused __item_length;                               \
455         struct ftrace_raw_##call __maybe_unused *entry;                 \
456                                                                         \
457         tstruct;                                                        \
458                                                                         \
459         return __data_size;                                             \
460 }
461 
462 #undef DEFINE_EVENT
463 #define DEFINE_EVENT(template, name, proto, args)
464 
465 #undef DEFINE_EVENT_PRINT
466 #define DEFINE_EVENT_PRINT(template, name, proto, args, print)  \
467         DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
468 
469 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
470 
471 /*
472  * Stage 4 of the trace events.
473  *
474  * Override the macros in <trace/trace_events.h> to include the following:
475  *
476  * For those macros defined with TRACE_EVENT:
477  *
478  * static struct ftrace_event_call event_<call>;
479  *
480  * static void ftrace_raw_event_<call>(void *__data, proto)
481  * {
482  *      struct ftrace_event_file *ftrace_file = __data;
483  *      struct ftrace_event_call *event_call = ftrace_file->event_call;
484  *      struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;
485  *      unsigned long eflags = ftrace_file->flags;
486  *      enum event_trigger_type __tt = ETT_NONE;
487  *      struct ring_buffer_event *event;
488  *      struct ftrace_raw_<call> *entry; <-- defined in stage 1
489  *      struct ring_buffer *buffer;
490  *      unsigned long irq_flags;
491  *      int __data_size;
492  *      int pc;
493  *
494  *      if (!(eflags & FTRACE_EVENT_FL_TRIGGER_COND)) {
495  *              if (eflags & FTRACE_EVENT_FL_TRIGGER_MODE)
496  *                      event_triggers_call(ftrace_file, NULL);
497  *              if (eflags & FTRACE_EVENT_FL_SOFT_DISABLED)
498  *                      return;
499  *      }
500  *
501  *      local_save_flags(irq_flags);
502  *      pc = preempt_count();
503  *
504  *      __data_size = ftrace_get_offsets_<call>(&__data_offsets, args);
505  *
506  *      event = trace_event_buffer_lock_reserve(&buffer, ftrace_file,
507  *                                event_<call>->event.type,
508  *                                sizeof(*entry) + __data_size,
509  *                                irq_flags, pc);
510  *      if (!event)
511  *              return;
512  *      entry   = ring_buffer_event_data(event);
513  *
514  *      { <assign>; }  <-- Here we assign the entries by the __field and
515  *                         __array macros.
516  *
517  *      if (eflags & FTRACE_EVENT_FL_TRIGGER_COND)
518  *              __tt = event_triggers_call(ftrace_file, entry);
519  *
520  *      if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT,
521  *                   &ftrace_file->flags))
522  *              ring_buffer_discard_commit(buffer, event);
523  *      else if (!filter_check_discard(ftrace_file, entry, buffer, event))
524  *              trace_buffer_unlock_commit(buffer, event, irq_flags, pc);
525  *
526  *      if (__tt)
527  *              event_triggers_post_call(ftrace_file, __tt);
528  * }
529  *
530  * static struct trace_event ftrace_event_type_<call> = {
531  *      .trace                  = ftrace_raw_output_<call>, <-- stage 2
532  * };
533  *
534  * static const char print_fmt_<call>[] = <TP_printk>;
535  *
536  * static struct ftrace_event_class __used event_class_<template> = {
537  *      .system                 = "<system>",
538  *      .define_fields          = ftrace_define_fields_<call>,
539  *      .fields                 = LIST_HEAD_INIT(event_class_##call.fields),
540  *      .raw_init               = trace_event_raw_init,
541  *      .probe                  = ftrace_raw_event_##call,
542  *      .reg                    = ftrace_event_reg,
543  * };
544  *
545  * static struct ftrace_event_call event_<call> = {
546  *      .class                  = event_class_<template>,
547  *      {
548  *              .tp                     = &__tracepoint_<call>,
549  *      },
550  *      .event                  = &ftrace_event_type_<call>,
551  *      .print_fmt              = print_fmt_<call>,
552  *      .flags                  = TRACE_EVENT_FL_TRACEPOINT,
553  * };
554  * // its only safe to use pointers when doing linker tricks to
555  * // create an array.
556  * static struct ftrace_event_call __used
557  * __attribute__((section("_ftrace_events"))) *__event_<call> = &event_<call>;
558  *
559  */
560 
561 #ifdef CONFIG_PERF_EVENTS
562 
563 #define _TRACE_PERF_PROTO(call, proto)                                  \
564         static notrace void                                             \
565         perf_trace_##call(void *__data, proto);
566 
567 #define _TRACE_PERF_INIT(call)                                          \
568         .perf_probe             = perf_trace_##call,
569 
570 #else
571 #define _TRACE_PERF_PROTO(call, proto)
572 #define _TRACE_PERF_INIT(call)
573 #endif /* CONFIG_PERF_EVENTS */
574 
575 #undef __entry
576 #define __entry entry
577 
578 #undef __field
579 #define __field(type, item)
580 
581 #undef __field_struct
582 #define __field_struct(type, item)
583 
584 #undef __array
585 #define __array(type, item, len)
586 
587 #undef __dynamic_array
588 #define __dynamic_array(type, item, len)                                \
589         __entry->__data_loc_##item = __data_offsets.item;
590 
591 #undef __string
592 #define __string(item, src) __dynamic_array(char, item, -1)
593 
594 #undef __assign_str
595 #define __assign_str(dst, src)                                          \
596         strcpy(__get_str(dst), (src) ? (const char *)(src) : "(null)");
597 
598 #undef __bitmask
599 #define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, -1)
600 
601 #undef __get_bitmask
602 #define __get_bitmask(field) (char *)__get_dynamic_array(field)
603 
604 #undef __assign_bitmask
605 #define __assign_bitmask(dst, src, nr_bits)                                     \
606         memcpy(__get_bitmask(dst), (src), __bitmask_size_in_bytes(nr_bits))
607 
608 #undef TP_fast_assign
609 #define TP_fast_assign(args...) args
610 
611 #undef __perf_addr
612 #define __perf_addr(a)  (a)
613 
614 #undef __perf_count
615 #define __perf_count(c) (c)
616 
617 #undef __perf_task
618 #define __perf_task(t)  (t)
619 
620 #undef DECLARE_EVENT_CLASS
621 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
622                                                                         \
623 static notrace void                                                     \
624 ftrace_raw_event_##call(void *__data, proto)                            \
625 {                                                                       \
626         struct ftrace_event_file *ftrace_file = __data;                 \
627         struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
628         struct ftrace_event_buffer fbuffer;                             \
629         struct ftrace_raw_##call *entry;                                \
630         int __data_size;                                                \
631                                                                         \
632         if (ftrace_trigger_soft_disabled(ftrace_file))                  \
633                 return;                                                 \
634                                                                         \
635         __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
636                                                                         \
637         entry = ftrace_event_buffer_reserve(&fbuffer, ftrace_file,      \
638                                  sizeof(*entry) + __data_size);         \
639                                                                         \
640         if (!entry)                                                     \
641                 return;                                                 \
642                                                                         \
643         tstruct                                                         \
644                                                                         \
645         { assign; }                                                     \
646                                                                         \
647         ftrace_event_buffer_commit(&fbuffer);                           \
648 }
649 /*
650  * The ftrace_test_probe is compiled out, it is only here as a build time check
651  * to make sure that if the tracepoint handling changes, the ftrace probe will
652  * fail to compile unless it too is updated.
653  */
654 
655 #undef DEFINE_EVENT
656 #define DEFINE_EVENT(template, call, proto, args)                       \
657 static inline void ftrace_test_probe_##call(void)                       \
658 {                                                                       \
659         check_trace_callback_type_##call(ftrace_raw_event_##template);  \
660 }
661 
662 #undef DEFINE_EVENT_PRINT
663 #define DEFINE_EVENT_PRINT(template, name, proto, args, print)
664 
665 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
666 
667 #undef __entry
668 #define __entry REC
669 
670 #undef __print_flags
671 #undef __print_symbolic
672 #undef __print_hex
673 #undef __get_dynamic_array
674 #undef __get_dynamic_array_len
675 #undef __get_str
676 #undef __get_bitmask
677 
678 #undef TP_printk
679 #define TP_printk(fmt, args...) "\"" fmt "\", "  __stringify(args)
680 
681 #undef DECLARE_EVENT_CLASS
682 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
683 _TRACE_PERF_PROTO(call, PARAMS(proto));                                 \
684 static const char print_fmt_##call[] = print;                           \
685 static struct ftrace_event_class __used __refdata event_class_##call = { \
686         .system                 = __stringify(TRACE_SYSTEM),            \
687         .define_fields          = ftrace_define_fields_##call,          \
688         .fields                 = LIST_HEAD_INIT(event_class_##call.fields),\
689         .raw_init               = trace_event_raw_init,                 \
690         .probe                  = ftrace_raw_event_##call,              \
691         .reg                    = ftrace_event_reg,                     \
692         _TRACE_PERF_INIT(call)                                          \
693 };
694 
695 #undef DEFINE_EVENT
696 #define DEFINE_EVENT(template, call, proto, args)                       \
697                                                                         \
698 static struct ftrace_event_call __used event_##call = {                 \
699         .class                  = &event_class_##template,              \
700         {                                                               \
701                 .tp                     = &__tracepoint_##call,         \
702         },                                                              \
703         .event.funcs            = &ftrace_event_type_funcs_##template,  \
704         .print_fmt              = print_fmt_##template,                 \
705         .flags                  = TRACE_EVENT_FL_TRACEPOINT,            \
706 };                                                                      \
707 static struct ftrace_event_call __used                                  \
708 __attribute__((section("_ftrace_events"))) *__event_##call = &event_##call
709 
710 #undef DEFINE_EVENT_PRINT
711 #define DEFINE_EVENT_PRINT(template, call, proto, args, print)          \
712                                                                         \
713 static const char print_fmt_##call[] = print;                           \
714                                                                         \
715 static struct ftrace_event_call __used event_##call = {                 \
716         .class                  = &event_class_##template,              \
717         {                                                               \
718                 .tp                     = &__tracepoint_##call,         \
719         },                                                              \
720         .event.funcs            = &ftrace_event_type_funcs_##call,      \
721         .print_fmt              = print_fmt_##call,                     \
722         .flags                  = TRACE_EVENT_FL_TRACEPOINT,            \
723 };                                                                      \
724 static struct ftrace_event_call __used                                  \
725 __attribute__((section("_ftrace_events"))) *__event_##call = &event_##call
726 
727 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
728 
729 
730 #ifdef CONFIG_PERF_EVENTS
731 
732 #undef __entry
733 #define __entry entry
734 
735 #undef __get_dynamic_array
736 #define __get_dynamic_array(field)      \
737                 ((void *)__entry + (__entry->__data_loc_##field & 0xffff))
738 
739 #undef __get_dynamic_array_len
740 #define __get_dynamic_array_len(field)  \
741                 ((__entry->__data_loc_##field >> 16) & 0xffff)
742 
743 #undef __get_str
744 #define __get_str(field) (char *)__get_dynamic_array(field)
745 
746 #undef __get_bitmask
747 #define __get_bitmask(field) (char *)__get_dynamic_array(field)
748 
749 #undef __perf_addr
750 #define __perf_addr(a)  (__addr = (a))
751 
752 #undef __perf_count
753 #define __perf_count(c) (__count = (c))
754 
755 #undef __perf_task
756 #define __perf_task(t)  (__task = (t))
757 
758 #undef DECLARE_EVENT_CLASS
759 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
760 static notrace void                                                     \
761 perf_trace_##call(void *__data, proto)                                  \
762 {                                                                       \
763         struct ftrace_event_call *event_call = __data;                  \
764         struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
765         struct ftrace_raw_##call *entry;                                \
766         struct pt_regs __regs;                                          \
767         u64 __addr = 0, __count = 1;                                    \
768         struct task_struct *__task = NULL;                              \
769         struct hlist_head *head;                                        \
770         int __entry_size;                                               \
771         int __data_size;                                                \
772         int rctx;                                                       \
773                                                                         \
774         __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
775                                                                         \
776         head = this_cpu_ptr(event_call->perf_events);                   \
777         if (__builtin_constant_p(!__task) && !__task &&                 \
778                                 hlist_empty(head))                      \
779                 return;                                                 \
780                                                                         \
781         __entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),\
782                              sizeof(u64));                              \
783         __entry_size -= sizeof(u32);                                    \
784                                                                         \
785         perf_fetch_caller_regs(&__regs);                                \
786         entry = perf_trace_buf_prepare(__entry_size,                    \
787                         event_call->event.type, &__regs, &rctx);        \
788         if (!entry)                                                     \
789                 return;                                                 \
790                                                                         \
791         tstruct                                                         \
792                                                                         \
793         { assign; }                                                     \
794                                                                         \
795         perf_trace_buf_submit(entry, __entry_size, rctx, __addr,        \
796                 __count, &__regs, head, __task);                        \
797 }
798 
799 /*
800  * This part is compiled out, it is only here as a build time check
801  * to make sure that if the tracepoint handling changes, the
802  * perf probe will fail to compile unless it too is updated.
803  */
804 #undef DEFINE_EVENT
805 #define DEFINE_EVENT(template, call, proto, args)                       \
806 static inline void perf_test_probe_##call(void)                         \
807 {                                                                       \
808         check_trace_callback_type_##call(perf_trace_##template);        \
809 }
810 
811 
812 #undef DEFINE_EVENT_PRINT
813 #define DEFINE_EVENT_PRINT(template, name, proto, args, print)  \
814         DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
815 
816 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
817 #endif /* CONFIG_PERF_EVENTS */
818 
819 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp