cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

trace_events.h (13877B)


      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)	\
    188static notrace enum print_line_t					\
    189trace_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}									\
    207static 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)		\
    213static notrace enum print_line_t					\
    214trace_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}									\
    233static 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)	\
    243static 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)	\
    256static 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									\
    380static notrace void							\
    381trace_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)			\
    414static 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));					\
    426static char print_fmt_##call[] = print;					\
    427static 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									\
    440static 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};									\
    449static 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									\
    455static char print_fmt_##call[] = print;					\
    456									\
    457static 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};									\
    466static struct trace_event_call __used					\
    467__section("_ftrace_events") *__event_##call = &event_##call
    468
    469#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)