Quelle  trace_custom_events.h   Sprache: unbekannt

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * This is similar to the trace_events.h file, but is to only
 * create custom trace events to be attached to existing tracepoints.
 * Where as the TRACE_EVENT() macro (from trace_events.h) will create
 * both the trace event and the tracepoint it will attach the event to,
 * TRACE_CUSTOM_EVENT() is to create only a custom version of an existing
 * trace event (created by TRACE_EVENT() or DEFINE_EVENT()), and will
 * be placed in the "custom" system.
 */

#include <linux/trace_events.h>

/* All custom events are placed in the custom group */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM custom

#ifndef TRACE_SYSTEM_VAR
#define TRACE_SYSTEM_VAR TRACE_SYSTEM
#endif

/* The init stage creates the system string and enum mappings */

#include "stages/init.h"

#undef TRACE_CUSTOM_EVENT
#define TRACE_CUSTOM_EVENT(name, proto, args, tstruct, assign, print) \
 DECLARE_CUSTOM_EVENT_CLASS(name,         \
        PARAMS(proto),         \
        PARAMS(args),         \
        PARAMS(tstruct),         \
        PARAMS(assign),         \
        PARAMS(print));         \
 DEFINE_CUSTOM_EVENT(name, name, PARAMS(proto), PARAMS(args));

/* Stage 1 creates the structure of the recorded event layout */

#include "stages/stage1_struct_define.h"

#undef DECLARE_CUSTOM_EVENT_CLASS
#define DECLARE_CUSTOM_EVENT_CLASS(name, proto, args, tstruct, assign, print) \
 struct trace_custom_event_raw_##name {    \
  struct trace_entry ent;    \
  tstruct       \
  char   __data[];   \
 };        \
         \
 static struct trace_event_class custom_event_class_##name;

#undef DEFINE_CUSTOM_EVENT
#define DEFINE_CUSTOM_EVENT(template, name, proto, args) \
 static struct trace_event_call __used   \
 __attribute__((__aligned__(4))) custom_event_##name

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/* Stage 2 creates the custom class */

#include "stages/stage2_data_offsets.h"

#undef DECLARE_CUSTOM_EVENT_CLASS
#define DECLARE_CUSTOM_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
 struct trace_custom_event_data_offsets_##call {   \
  tstruct;      \
 };

#undef DEFINE_CUSTOM_EVENT
#define DEFINE_CUSTOM_EVENT(template, name, proto, args)

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/* Stage 3 create the way to print the custom event */

#include "stages/stage3_trace_output.h"

#undef DECLARE_CUSTOM_EVENT_CLASS
#define DECLARE_CUSTOM_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
static notrace enum print_line_t     \
trace_custom_raw_output_##call(struct trace_iterator *iter, int flags, \
   struct trace_event *trace_event)  \
{         \
 struct trace_seq *s = &iter->seq;    \
 struct trace_seq __maybe_unused *p = &iter->tmp_seq;  \
 struct trace_custom_event_raw_##call *field;   \
 int ret;       \
         \
 field = (typeof(field))iter->ent;    \
         \
 ret = trace_raw_output_prep(iter, trace_event);   \
 if (ret != TRACE_TYPE_HANDLED)     \
  return ret;      \
         \
 trace_event_printf(iter, print);    \
         \
 return trace_handle_return(s);     \
}         \
static struct trace_event_functions trace_custom_event_type_funcs_##call = { \
 .trace   = trace_custom_raw_output_##call, \
};

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/* Stage 4 creates the offset layout for the fields */

#include "stages/stage4_event_fields.h"

#undef DECLARE_CUSTOM_EVENT_CLASS
#define DECLARE_CUSTOM_EVENT_CLASS(call, proto, args, tstruct, func, print) \
static struct trace_event_fields trace_custom_event_fields_##call[] = { \
 tstruct        \
 {} };

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/* Stage 5 creates the helper function for dynamic fields */

#include "stages/stage5_get_offsets.h"

#undef DECLARE_CUSTOM_EVENT_CLASS
#define DECLARE_CUSTOM_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
static inline notrace int trace_custom_event_get_offsets_##call( \
 struct trace_custom_event_data_offsets_##call *__data_offsets, proto) \
{         \
 int __data_size = 0;      \
 int __maybe_unused __item_length;    \
 struct trace_custom_event_raw_##call __maybe_unused *entry; \
         \
 tstruct;       \
         \
 return __data_size;      \
}

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/* Stage 6 creates the probe function that records the event */

#include "stages/stage6_event_callback.h"

#undef DECLARE_CUSTOM_EVENT_CLASS
#define DECLARE_CUSTOM_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
         \
static notrace void       \
trace_custom_event_raw_event_##call(void *__data, proto)  \
{         \
 struct trace_event_file *trace_file = __data;   \
 struct trace_custom_event_data_offsets_##call __maybe_unused __data_offsets; \
 struct trace_event_buffer fbuffer;    \
 struct trace_custom_event_raw_##call *entry;   \
 int __data_size;      \
         \
 if (trace_trigger_soft_disabled(trace_file))   \
  return;       \
         \
 __data_size = trace_custom_event_get_offsets_##call(&__data_offsets, args); \
         \
 entry = trace_event_buffer_reserve(&fbuffer, trace_file, \
     sizeof(*entry) + __data_size);  \
         \
 if (!entry)       \
  return;       \
         \
 tstruct        \
         \
 { assign; }       \
         \
 trace_event_buffer_commit(&fbuffer);    \
}
/*
 * The ftrace_test_custom_probe is compiled out, it is only here as a build time check
 * to make sure that if the tracepoint handling changes, the ftrace probe will
 * fail to compile unless it too is updated.
 */

#undef DEFINE_CUSTOM_EVENT
#define DEFINE_CUSTOM_EVENT(template, call, proto, args)  \
static inline void ftrace_test_custom_probe_##call(void)  \
{         \
 check_trace_callback_type_##call(trace_custom_event_raw_event_##template); \
}

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/* Stage 7 creates the actual class and event structure for the custom event */

#include "stages/stage7_class_define.h"

#undef DECLARE_CUSTOM_EVENT_CLASS
#define DECLARE_CUSTOM_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
static char custom_print_fmt_##call[] = print;     \
static struct trace_event_class __used __refdata custom_event_class_##call = { \
 .system   = TRACE_SYSTEM_STRING,   \
 .fields_array  = trace_custom_event_fields_##call,  \
 .fields   = LIST_HEAD_INIT(custom_event_class_##call.fields),\
 .raw_init  = trace_event_raw_init,   \
 .probe   = trace_custom_event_raw_event_##call, \
 .reg   = trace_event_reg,   \
};

#undef DEFINE_CUSTOM_EVENT
#define DEFINE_CUSTOM_EVENT(template, call, proto, args)  \
         \
static struct trace_event_call __used custom_event_##call = {  \
 .name   = #call,    \
 .class   = &custom_event_class_##template, \
 .event.funcs  = &trace_custom_event_type_funcs_##template, \
 .print_fmt  = custom_print_fmt_##template,  \
 .flags   = TRACE_EVENT_FL_CUSTOM,  \
};         \
static inline int trace_custom_event_##call##_update(struct tracepoint *tp) \
{         \
 if (tp->name && strcmp(tp->name, #call) == 0) {   \
  custom_event_##call.tp = tp;    \
  custom_event_##call.flags = TRACE_EVENT_FL_TRACEPOINT; \
  return 1;      \
 }        \
 return 0;       \
}         \
static struct trace_event_call __used     \
__section("_ftrace_events") *__custom_event_##call = &custom_event_##call

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)