[lttng-modules.git] / include / lttng / events.h

/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
 *
 * lttng/events.h
 *
 * Holds LTTng per-session event registry.
 *
 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 */

#ifndef _LTTNG_EVENTS_H
#define _LTTNG_EVENTS_H

#include <lttng/kernel-version.h>
#include <linux/list.h>
#include <linux/kprobes.h>
#include <linux/kref.h>
#include <linux/uuid.h>
#include <linux/irq_work.h>
#include <wrapper/uprobes.h>
#include <lttng/cpuhotplug.h>
#include <lttng/tracer.h>
#include <lttng/abi.h>
#include <lttng/abi-old.h>
#include <lttng/endian.h>

#define lttng_is_signed_type(type)	(((type) -1) < (type) 1)

struct lttng_kernel_channel_buffer;
struct lttng_kernel_session;
struct lttng_kernel_ring_buffer_ctx;

/* Type description */

enum lttng_kernel_type {
	lttng_kernel_type_integer,
	lttng_kernel_type_string,
	lttng_kernel_type_enum,
	lttng_kernel_type_array,
	lttng_kernel_type_sequence,
	lttng_kernel_type_struct,
	lttng_kernel_type_variant,
	NR_LTTNG_KERNEL_TYPES,
};

enum lttng_kernel_string_encoding {
	lttng_kernel_string_encoding_none = 0,
	lttng_kernel_string_encoding_UTF8 = 1,
	lttng_kernel_string_encoding_ASCII = 2,
	NR_LTTNG_KERNEL_STRING_ENCODING,
};

struct lttng_kernel_enum_value {
	unsigned long long value;
	unsigned int signedness:1;
};

struct lttng_kernel_enum_entry {
	struct lttng_kernel_enum_value start, end;	/* start and end are inclusive */
	const char *string;
	struct {
		unsigned int is_auto:1;
	} options;
};

/*
 * struct lttng_kernel_type_common is fixed-size. Its children inherits
 * from it by embedding struct lttng_kernel_type_common as its first field.
 */
struct lttng_kernel_type_common {
	enum lttng_kernel_type type;
};

struct lttng_kernel_type_integer {
	struct lttng_kernel_type_common parent;
	unsigned int size;		/* in bits */
	unsigned short alignment;	/* in bits */
	unsigned int signedness:1,
		reverse_byte_order:1,
		user:1;			/* fetch from user-space */
	unsigned int base;		/* 2, 8, 10, 16, for pretty print */
};

struct lttng_kernel_type_string {
	struct lttng_kernel_type_common parent;
	enum lttng_kernel_string_encoding encoding;
	unsigned int user:1;		/* fetch from user-space */
};

struct lttng_kernel_type_enum {
	struct lttng_kernel_type_common parent;
	const struct lttng_kernel_enum_desc *desc;	/* Enumeration mapping */
	const struct lttng_kernel_type_common *container_type;
};

struct lttng_kernel_type_array {
	struct lttng_kernel_type_common parent;
	const struct lttng_kernel_type_common *elem_type;
	unsigned int length;			/* Num. elems. */
	unsigned int alignment;		/* Alignment in bytes before elements. */
	enum lttng_kernel_string_encoding encoding;
};

struct lttng_kernel_type_sequence {
	struct lttng_kernel_type_common parent;
	const char *length_name;	/* Length field name. If NULL, use previous field. */
	const struct lttng_kernel_type_common *elem_type;
	unsigned int alignment;		/* Alignment in bytes before elements. */
	enum lttng_kernel_string_encoding encoding;
};

struct lttng_kernel_type_struct {
	struct lttng_kernel_type_common parent;
	unsigned int nr_fields;
	const struct lttng_kernel_event_field * const *fields;	/* Array of pointers to fields. */
	unsigned int alignment;		/* Alignment in bits */
};

struct lttng_kernel_type_variant {
	struct lttng_kernel_type_common parent;
	const char *tag_name;		/* Tag field name. If NULL, use previous field. */
	const struct lttng_kernel_event_field * const *choices; /* Array of pointers to fields. */
	unsigned int nr_choices;
	unsigned int alignment;		/* Alignment in bytes */
};

struct lttng_kernel_enum_desc {
	const char *name;
	const struct lttng_kernel_enum_entry * const *entries;
	unsigned int nr_entries;
	const struct lttng_kernel_probe_desc *probe_desc;
};

/* Event field description */

struct lttng_kernel_event_field {
	const char *name;
	const struct lttng_kernel_type_common *type;
	unsigned int nowrite:1,		/* do not write into trace */
			nofilter:1;	/* do not consider for filter */
};

#ifndef PARAMS
#define PARAMS(args...)	args
#endif

#define _lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, _user, _base)	\
	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_integer, { \
		.parent = {										\
			.type = lttng_kernel_type_integer,							\
		},											\
		.size = (_size),									\
		.alignment = (_alignment),								\
		.signedness = (_signedness),								\
		.reverse_byte_order = (_byte_order) != __BYTE_ORDER,					\
		.user = (_user),									\
		.base = (_base),									\
	}))

#define lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, _base)		\
	_lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, 0, _base)

#define lttng_kernel_static_type_user_integer(_size, _alignment, _signedness, _byte_order, _base)	\
	_lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, 1, _base)

#define _lttng_kernel_static_type_integer_from_type(_type, _byte_order, _user, _base)			\
	_lttng_kernel_static_type_integer(sizeof(_type) * CHAR_BIT,					\
			lttng_alignof(_type) * CHAR_BIT,						\
			lttng_is_signed_type(_type),							\
			_byte_order, _user, _base)

#define lttng_kernel_static_type_integer_from_type(_type, _byte_order, _base)				\
	_lttng_kernel_static_type_integer_from_type(_type, _byte_order, 0, _base)

#define lttng_kernel_static_type_user_integer_from_type(_type, _byte_order, _base)			\
	_lttng_kernel_static_type_integer_from_type(_type, _byte_order, 1, _base)

#define lttng_kernel_static_type_enum(_desc, _container_type)						\
	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_enum, { \
		.parent = {										\
			.type = lttng_kernel_type_enum,							\
		},											\
		.desc = (_desc),									\
		.container_type = (_container_type),							\
	}))

#define lttng_kernel_static_type_array(_length, _elem_type, _alignment, _encoding)			\
	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_array, { \
		.parent = {										\
			.type = lttng_kernel_type_array,						\
		},											\
		.length = (_length),									\
		.alignment = (_alignment),								\
		.encoding = lttng_kernel_string_encoding_##_encoding,					\
		.elem_type = (_elem_type),								\
	}))

#define lttng_kernel_static_type_array_text(_length)							\
	lttng_kernel_static_type_array(_length,								\
		lttng_kernel_static_type_integer(sizeof(char) * CHAR_BIT,				\
				lttng_alignof(char) * CHAR_BIT, lttng_is_signed_type(char),		\
				__BYTE_ORDER, 10),							\
		0, UTF8)

#define lttng_kernel_static_type_sequence(_length_name, _elem_type, _alignment, _encoding)			\
	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_sequence, { \
		.parent = {										\
			.type = lttng_kernel_type_sequence,						\
		},											\
		.length_name = (_length_name),								\
		.alignment = (_alignment),								\
		.encoding = lttng_kernel_string_encoding_##_encoding,					\
		.elem_type = (_elem_type),								\
	}))

#define lttng_kernel_static_type_string(_encoding, _user)						\
	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_string, { \
		.parent = {										\
			.type = lttng_kernel_type_string,						\
		},											\
		.encoding = lttng_kernel_string_encoding_##_encoding,					\
		.user = (_user),									\
	}))

#define lttng_kernel_static_type_struct_init(_nr_fields, _fields, _alignment)				\
	{												\
		.parent = {										\
			.type = lttng_kernel_type_struct,						\
		},											\
		.nr_fields = (_nr_fields),								\
		.fields = _fields,									\
		.alignment = (_alignment),								\
	}

#define lttng_kernel_static_type_struct(_nr_fields, _fields, _alignment)				\
	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_struct, \
		lttng_kernel_static_type_struct_init(_nr_fields, PARAMS(_fields), _alignment)			\
	))

#define lttng_kernel_static_type_variant(_nr_choices, _choices, _tag_name, _alignment)			\
	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_variant, { \
		.parent = {										\
			.type = lttng_kernel_type_variant,						\
		},											\
		.tag_name = (_tag_name),								\
		.choices = _choices,									\
		.nr_choices = (_nr_choices),								\
		.alignment = (_alignment),								\
	}))

#define lttng_kernel_static_event_field(_name, _type, _nowrite, _nofilter)				\
	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_event_field, {				\
		.name = (_name),									\
		.type = (_type),									\
		.nowrite = (_nowrite),									\
		.nofilter = (_nofilter),								\
	})

#define lttng_kernel_static_event_field_array(_fields...)						\
	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_event_field *,				\
		_fields											\
	)

#define lttng_kernel_static_enum_entry_value(_string, _value)						\
	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, {				\
		.start = {										\
			.signedness = lttng_is_signed_type(__typeof__(_value)),				\
			.value = lttng_is_signed_type(__typeof__(_value)) ?				\
				(long long) (_value) : (_value),					\
		},											\
		.end = {										\
			.signedness = lttng_is_signed_type(__typeof__(_value)),				\
			.value = lttng_is_signed_type(__typeof__(_value)) ?				\
				(long long) (_value) : (_value),					\
		},											\
		.string = (_string),									\
	}),

#define lttng_kernel_static_enum_entry_range(_string, _range_start, _range_end)				\
	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, {				\
		.start = {										\
			.signedness = lttng_is_signed_type(__typeof__(_range_start)),			\
			.value = lttng_is_signed_type(__typeof__(_range_start)) ?			\
				(long long) (_range_start) : (_range_start),				\
		},											\
		.end = {										\
			.signedness = lttng_is_signed_type(__typeof__(_range_end)),			\
			.value = lttng_is_signed_type(__typeof__(_range_end)) ?				\
				(long long) (_range_end) : (_range_end),				\
		},											\
		.string = (_string),									\
	}),

#define lttng_kernel_static_enum_entry_auto(_string)							\
	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, {				\
		.start = {										\
			.signedness = -1,								\
			.value = -1,									\
		},											\
		.end = {										\
			.signedness = -1, 								\
			.value = -1,									\
		},											\
		.string = (_string),									\
		.options = {										\
			.is_auto = 1,									\
		}											\
	}),

struct lttng_kernel_probe_ctx {
	struct lttng_kernel_event_common *event;
	uint8_t interruptible;
};

struct lttng_kernel_tracepoint_class {
	void (*probe_callback)(void);
	const struct lttng_kernel_event_field * const *fields;	/* event payload */
	unsigned int nr_fields;
	const struct lttng_kernel_probe_desc *probe_desc;
};

struct lttng_kernel_event_desc {
	const char *event_name;		/* lttng-modules name */
	const char *event_kname;	/* Linux kernel name (tracepoints) */
	const struct lttng_kernel_probe_desc *probe_desc;
	const struct lttng_kernel_tracepoint_class *tp_class;
	struct module *owner;
};

struct lttng_kernel_probe_desc {
	const char *provider_name;
	const struct lttng_kernel_event_desc * const *event_desc;
	unsigned int nr_events;
	struct list_head head;			/* chain registered probes */
	struct list_head lazy_init_head;
	int lazy;				/* lazy registration */
};

/*
 * Result of the run_filter() callback.
 */
enum lttng_kernel_event_filter_result {
	LTTNG_KERNEL_EVENT_FILTER_ACCEPT = 0,
	LTTNG_KERNEL_EVENT_FILTER_REJECT = 1,
};

struct lttng_kernel_event_common_private;

enum lttng_kernel_event_type {
	LTTNG_KERNEL_EVENT_TYPE_RECORDER = 0,
	LTTNG_KERNEL_EVENT_TYPE_NOTIFIER = 1,
};

struct lttng_kernel_event_common {
	struct lttng_kernel_event_common_private *priv;	/* Private event interface */

	enum lttng_kernel_event_type type;
	/* Get child with container_of(). */

	int enabled;
	int eval_filter;				/* Need to evaluate filters */
	int (*run_filter)(const struct lttng_kernel_event_common *event,
		const char *stack_data,
		struct lttng_kernel_probe_ctx *probe_ctx,
		void *filter_ctx);
};

struct lttng_kernel_event_recorder_private;

struct lttng_kernel_event_recorder {
	struct lttng_kernel_event_common parent;
	struct lttng_kernel_event_recorder_private *priv;	/* Private event record interface */

	struct lttng_kernel_channel_buffer *chan;
};

struct lttng_kernel_notification_ctx {
	int eval_capture;					/* Capture evaluation available. */
};

struct lttng_kernel_event_notifier_private;

struct lttng_kernel_event_notifier {
	struct lttng_kernel_event_common parent;
	struct lttng_kernel_event_notifier_private *priv;	/* Private event notifier interface */

	int eval_capture;				/* Need to evaluate capture */
	void (*notification_send)(struct lttng_kernel_event_notifier *event_notifier,
		const char *stack_data,
		struct lttng_kernel_probe_ctx *probe_ctx,
		struct lttng_kernel_notification_ctx *notif_ctx);
};

struct lttng_kernel_channel_buffer_ops {
	struct lttng_kernel_channel_buffer_ops_private *priv;	/* Private channel buffer ops interface. */

	int (*event_reserve)(struct lttng_kernel_ring_buffer_ctx *ctx);
	void (*event_commit)(struct lttng_kernel_ring_buffer_ctx *ctx);
	void (*event_write)(struct lttng_kernel_ring_buffer_ctx *ctx, const void *src,
			    size_t len, size_t alignment);
	void (*event_write_from_user)(struct lttng_kernel_ring_buffer_ctx *ctx,
				      const void *src, size_t len, size_t alignment);
	void (*event_memset)(struct lttng_kernel_ring_buffer_ctx *ctx,
			     int c, size_t len);
	void (*event_strcpy)(struct lttng_kernel_ring_buffer_ctx *ctx, const char *src,
			     size_t len);
	void (*event_strcpy_from_user)(struct lttng_kernel_ring_buffer_ctx *ctx,
				       const char __user *src, size_t len);
	void (*event_pstrcpy_pad)(struct lttng_kernel_ring_buffer_ctx *ctx,
				  const char *src, size_t len);
	void (*event_pstrcpy_pad_from_user)(struct lttng_kernel_ring_buffer_ctx *ctx,
				  const char __user *src, size_t len);
	void (*lost_event_too_big)(struct lttng_kernel_channel_buffer *lttng_channel);
};

enum lttng_kernel_channel_type {
	LTTNG_KERNEL_CHANNEL_TYPE_BUFFER = 0,
};

struct lttng_kernel_channel_common_private;

/* Use container_of() to get child. */
struct lttng_kernel_channel_common {
	struct lttng_kernel_channel_common_private *priv;	/* Private channel interface. */

	enum lttng_kernel_channel_type type;

	int enabled;
	struct lttng_kernel_session *session;
};

struct lttng_kernel_channel_buffer_private;

struct lttng_kernel_channel_buffer {
	struct lttng_kernel_channel_common parent;
	struct lttng_kernel_channel_buffer_private *priv;

	struct lttng_kernel_channel_buffer_ops *ops;
};

#define LTTNG_DYNAMIC_LEN_STACK_SIZE	128

struct lttng_dynamic_len_stack {
	size_t stack[LTTNG_DYNAMIC_LEN_STACK_SIZE];
	size_t offset;
};

DECLARE_PER_CPU(struct lttng_dynamic_len_stack, lttng_dynamic_len_stack);

/*
 * struct lttng_kernel_id_tracker declared in header due to deferencing of *v
 * in RCU_INITIALIZER(v).
 */
#define LTTNG_ID_HASH_BITS	6
#define LTTNG_ID_TABLE_SIZE	(1 << LTTNG_ID_HASH_BITS)

struct lttng_kernel_id_tracker_rcu {
	struct hlist_head id_hash[LTTNG_ID_TABLE_SIZE];
};

struct lttng_kernel_id_tracker {
	struct lttng_kernel_id_tracker_private *priv;	/* Private API */

	struct lttng_kernel_id_tracker_rcu *p;	/* RCU dereferenced. */
};

struct lttng_kernel_session_private;

struct lttng_kernel_session {
	struct lttng_kernel_session_private *priv;	/* Private session interface */

	int active;			/* Is trace session active ? */

	struct lttng_kernel_id_tracker pid_tracker;
	struct lttng_kernel_id_tracker vpid_tracker;
	struct lttng_kernel_id_tracker uid_tracker;
	struct lttng_kernel_id_tracker vuid_tracker;
	struct lttng_kernel_id_tracker gid_tracker;
	struct lttng_kernel_id_tracker vgid_tracker;
};

int lttng_kernel_probe_register(struct lttng_kernel_probe_desc *desc);
void lttng_kernel_probe_unregister(struct lttng_kernel_probe_desc *desc);

bool lttng_id_tracker_lookup(struct lttng_kernel_id_tracker_rcu *p, int id);

#endif /* _LTTNG_EVENTS_H */
Commit	Line	Data
	1	/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
	2	*
	3	* lttng/events.h
	4	*
	5	* Holds LTTng per-session event registry.
	6	*
	7	* Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	8	*/
	9
	10	#ifndef _LTTNG_EVENTS_H
	11	#define _LTTNG_EVENTS_H
	12
	13	#include <lttng/kernel-version.h>
	14	#include <linux/list.h>
	15	#include <linux/kprobes.h>
	16	#include <linux/kref.h>
	17	#include <linux/uuid.h>
	18	#include <linux/irq_work.h>
	19	#include <wrapper/uprobes.h>
	20	#include <lttng/cpuhotplug.h>
	21	#include <lttng/tracer.h>
	22	#include <lttng/abi.h>
	23	#include <lttng/abi-old.h>
	24	#include <lttng/endian.h>
	25
	26	#define lttng_is_signed_type(type) (((type) -1) < (type) 1)
	27
	28	struct lttng_kernel_channel_buffer;
	29	struct lttng_kernel_session;
	30	struct lttng_kernel_ring_buffer_ctx;
	31
	32	/* Type description */
	33
	34	enum lttng_kernel_type {
	35	lttng_kernel_type_integer,
	36	lttng_kernel_type_string,
	37	lttng_kernel_type_enum,
	38	lttng_kernel_type_array,
	39	lttng_kernel_type_sequence,
	40	lttng_kernel_type_struct,
	41	lttng_kernel_type_variant,
	42	NR_LTTNG_KERNEL_TYPES,
	43	};
	44
	45	enum lttng_kernel_string_encoding {
	46	lttng_kernel_string_encoding_none = 0,
	47	lttng_kernel_string_encoding_UTF8 = 1,
	48	lttng_kernel_string_encoding_ASCII = 2,
	49	NR_LTTNG_KERNEL_STRING_ENCODING,
	50	};
	51
	52	struct lttng_kernel_enum_value {
	53	unsigned long long value;
	54	unsigned int signedness:1;
	55	};
	56
	57	struct lttng_kernel_enum_entry {
	58	struct lttng_kernel_enum_value start, end; /* start and end are inclusive */
	59	const char *string;
	60	struct {
	61	unsigned int is_auto:1;
	62	} options;
	63	};
	64
	65	/*
	66	* struct lttng_kernel_type_common is fixed-size. Its children inherits
	67	* from it by embedding struct lttng_kernel_type_common as its first field.
	68	*/
	69	struct lttng_kernel_type_common {
	70	enum lttng_kernel_type type;
	71	};
	72
	73	struct lttng_kernel_type_integer {
	74	struct lttng_kernel_type_common parent;
	75	unsigned int size; /* in bits */
	76	unsigned short alignment; /* in bits */
	77	unsigned int signedness:1,
	78	reverse_byte_order:1,
	79	user:1; /* fetch from user-space */
	80	unsigned int base; /* 2, 8, 10, 16, for pretty print */
	81	};
	82
	83	struct lttng_kernel_type_string {
	84	struct lttng_kernel_type_common parent;
	85	enum lttng_kernel_string_encoding encoding;
	86	unsigned int user:1; /* fetch from user-space */
	87	};
	88
	89	struct lttng_kernel_type_enum {
	90	struct lttng_kernel_type_common parent;
	91	const struct lttng_kernel_enum_desc desc; / Enumeration mapping */
	92	const struct lttng_kernel_type_common *container_type;
	93	};
	94
	95	struct lttng_kernel_type_array {
	96	struct lttng_kernel_type_common parent;
	97	const struct lttng_kernel_type_common *elem_type;
	98	unsigned int length; /* Num. elems. */
	99	unsigned int alignment; /* Alignment in bytes before elements. */
	100	enum lttng_kernel_string_encoding encoding;
	101	};
	102
	103	struct lttng_kernel_type_sequence {
	104	struct lttng_kernel_type_common parent;
	105	const char length_name; / Length field name. If NULL, use previous field. */
	106	const struct lttng_kernel_type_common *elem_type;
	107	unsigned int alignment; /* Alignment in bytes before elements. */
	108	enum lttng_kernel_string_encoding encoding;
	109	};
	110
	111	struct lttng_kernel_type_struct {
	112	struct lttng_kernel_type_common parent;
	113	unsigned int nr_fields;
	114	const struct lttng_kernel_event_field * const fields; / Array of pointers to fields. */
	115	unsigned int alignment; /* Alignment in bits */
	116	};
	117
	118	struct lttng_kernel_type_variant {
	119	struct lttng_kernel_type_common parent;
	120	const char tag_name; / Tag field name. If NULL, use previous field. */
	121	const struct lttng_kernel_event_field * const choices; / Array of pointers to fields. */
	122	unsigned int nr_choices;
	123	unsigned int alignment; /* Alignment in bytes */
	124	};
	125
	126	struct lttng_kernel_enum_desc {
	127	const char *name;
	128	const struct lttng_kernel_enum_entry * const *entries;
	129	unsigned int nr_entries;
	130	const struct lttng_kernel_probe_desc *probe_desc;
	131	};
	132
	133	/* Event field description */
	134
	135	struct lttng_kernel_event_field {
	136	const char *name;
	137	const struct lttng_kernel_type_common *type;
	138	unsigned int nowrite:1, /* do not write into trace */
	139	nofilter:1; /* do not consider for filter */
	140	};
	141
	142	#ifndef PARAMS
	143	#define PARAMS(args...) args
	144	#endif
	145
	146	#define _lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, _user, _base) \
	147	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_integer, { \
	148	.parent = { \
	149	.type = lttng_kernel_type_integer, \
	150	}, \
	151	.size = (_size), \
	152	.alignment = (_alignment), \
	153	.signedness = (_signedness), \
	154	.reverse_byte_order = (_byte_order) != __BYTE_ORDER, \
	155	.user = (_user), \
	156	.base = (_base), \
	157	}))
	158
	159	#define lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, _base) \
	160	_lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, 0, _base)
	161
	162	#define lttng_kernel_static_type_user_integer(_size, _alignment, _signedness, _byte_order, _base) \
	163	_lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, 1, _base)
	164
	165	#define _lttng_kernel_static_type_integer_from_type(_type, _byte_order, _user, _base) \
	166	_lttng_kernel_static_type_integer(sizeof(_type) * CHAR_BIT, \
	167	lttng_alignof(_type) * CHAR_BIT, \
	168	lttng_is_signed_type(_type), \
	169	_byte_order, _user, _base)
	170
	171	#define lttng_kernel_static_type_integer_from_type(_type, _byte_order, _base) \
	172	_lttng_kernel_static_type_integer_from_type(_type, _byte_order, 0, _base)
	173
	174	#define lttng_kernel_static_type_user_integer_from_type(_type, _byte_order, _base) \
	175	_lttng_kernel_static_type_integer_from_type(_type, _byte_order, 1, _base)
	176
	177	#define lttng_kernel_static_type_enum(_desc, _container_type) \
	178	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_enum, { \
	179	.parent = { \
	180	.type = lttng_kernel_type_enum, \
	181	}, \
	182	.desc = (_desc), \
	183	.container_type = (_container_type), \
	184	}))
	185
	186	#define lttng_kernel_static_type_array(_length, _elem_type, _alignment, _encoding) \
	187	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_array, { \
	188	.parent = { \
	189	.type = lttng_kernel_type_array, \
	190	}, \
	191	.length = (_length), \
	192	.alignment = (_alignment), \
	193	.encoding = lttng_kernel_string_encoding_##_encoding, \
	194	.elem_type = (_elem_type), \
	195	}))
	196
	197	#define lttng_kernel_static_type_array_text(_length) \
	198	lttng_kernel_static_type_array(_length, \
	199	lttng_kernel_static_type_integer(sizeof(char) * CHAR_BIT, \
	200	lttng_alignof(char) * CHAR_BIT, lttng_is_signed_type(char), \
	201	__BYTE_ORDER, 10), \
	202	0, UTF8)
	203
	204	#define lttng_kernel_static_type_sequence(_length_name, _elem_type, _alignment, _encoding) \
	205	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_sequence, { \
	206	.parent = { \
	207	.type = lttng_kernel_type_sequence, \
	208	}, \
	209	.length_name = (_length_name), \
	210	.alignment = (_alignment), \
	211	.encoding = lttng_kernel_string_encoding_##_encoding, \
	212	.elem_type = (_elem_type), \
	213	}))
	214
	215	#define lttng_kernel_static_type_string(_encoding, _user) \
	216	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_string, { \
	217	.parent = { \
	218	.type = lttng_kernel_type_string, \
	219	}, \
	220	.encoding = lttng_kernel_string_encoding_##_encoding, \
	221	.user = (_user), \
	222	}))
	223
	224	#define lttng_kernel_static_type_struct_init(_nr_fields, _fields, _alignment) \
	225	{ \
	226	.parent = { \
	227	.type = lttng_kernel_type_struct, \
	228	}, \
	229	.nr_fields = (_nr_fields), \
	230	.fields = _fields, \
	231	.alignment = (_alignment), \
	232	}
	233
	234	#define lttng_kernel_static_type_struct(_nr_fields, _fields, _alignment) \
	235	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_struct, \
	236	lttng_kernel_static_type_struct_init(_nr_fields, PARAMS(_fields), _alignment) \
	237	))
	238
	239	#define lttng_kernel_static_type_variant(_nr_choices, _choices, _tag_name, _alignment) \
	240	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_variant, { \
	241	.parent = { \
	242	.type = lttng_kernel_type_variant, \
	243	}, \
	244	.tag_name = (_tag_name), \
	245	.choices = _choices, \
	246	.nr_choices = (_nr_choices), \
	247	.alignment = (_alignment), \
	248	}))
	249
	250	#define lttng_kernel_static_event_field(_name, _type, _nowrite, _nofilter) \
	251	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_event_field, { \
	252	.name = (_name), \
	253	.type = (_type), \
	254	.nowrite = (_nowrite), \
	255	.nofilter = (_nofilter), \
	256	})
	257
	258	#define lttng_kernel_static_event_field_array(_fields...) \
	259	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_event_field *, \
	260	_fields \
	261	)
	262
	263	#define lttng_kernel_static_enum_entry_value(_string, _value) \
	264	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, { \
	265	.start = { \
	266	.signedness = lttng_is_signed_type(__typeof__(_value)), \
	267	.value = lttng_is_signed_type(__typeof__(_value)) ? \
	268	(long long) (_value) : (_value), \
	269	}, \
	270	.end = { \
	271	.signedness = lttng_is_signed_type(__typeof__(_value)), \
	272	.value = lttng_is_signed_type(__typeof__(_value)) ? \
	273	(long long) (_value) : (_value), \
	274	}, \
	275	.string = (_string), \
	276	}),
	277
	278	#define lttng_kernel_static_enum_entry_range(_string, _range_start, _range_end) \
	279	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, { \
	280	.start = { \
	281	.signedness = lttng_is_signed_type(__typeof__(_range_start)), \
	282	.value = lttng_is_signed_type(__typeof__(_range_start)) ? \
	283	(long long) (_range_start) : (_range_start), \
	284	}, \
	285	.end = { \
	286	.signedness = lttng_is_signed_type(__typeof__(_range_end)), \
	287	.value = lttng_is_signed_type(__typeof__(_range_end)) ? \
	288	(long long) (_range_end) : (_range_end), \
	289	}, \
	290	.string = (_string), \
	291	}),
	292
	293	#define lttng_kernel_static_enum_entry_auto(_string) \
	294	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, { \
	295	.start = { \
	296	.signedness = -1, \
	297	.value = -1, \
	298	}, \
	299	.end = { \
	300	.signedness = -1, \
	301	.value = -1, \
	302	}, \
	303	.string = (_string), \
	304	.options = { \
	305	.is_auto = 1, \
	306	} \
	307	}),
	308
	309	struct lttng_kernel_probe_ctx {
	310	struct lttng_kernel_event_common *event;
	311	uint8_t interruptible;
	312	};
	313
	314	struct lttng_kernel_tracepoint_class {
	315	void (*probe_callback)(void);
	316	const struct lttng_kernel_event_field * const fields; / event payload */
	317	unsigned int nr_fields;
	318	const struct lttng_kernel_probe_desc *probe_desc;
	319	};
	320
	321	struct lttng_kernel_event_desc {
	322	const char event_name; / lttng-modules name */
	323	const char event_kname; / Linux kernel name (tracepoints) */
	324	const struct lttng_kernel_probe_desc *probe_desc;
	325	const struct lttng_kernel_tracepoint_class *tp_class;
	326	struct module *owner;
	327	};
	328
	329	struct lttng_kernel_probe_desc {
	330	const char *provider_name;
	331	const struct lttng_kernel_event_desc * const *event_desc;
	332	unsigned int nr_events;
	333	struct list_head head; /* chain registered probes */
	334	struct list_head lazy_init_head;
	335	int lazy; /* lazy registration */
	336	};
	337
	338	/*
	339	* Result of the run_filter() callback.
	340	*/
	341	enum lttng_kernel_event_filter_result {
	342	LTTNG_KERNEL_EVENT_FILTER_ACCEPT = 0,
	343	LTTNG_KERNEL_EVENT_FILTER_REJECT = 1,
	344	};
	345
	346	struct lttng_kernel_event_common_private;
	347
	348	enum lttng_kernel_event_type {
	349	LTTNG_KERNEL_EVENT_TYPE_RECORDER = 0,
	350	LTTNG_KERNEL_EVENT_TYPE_NOTIFIER = 1,
	351	};
	352
	353	struct lttng_kernel_event_common {
	354	struct lttng_kernel_event_common_private priv; / Private event interface */
	355
	356	enum lttng_kernel_event_type type;
	357	/* Get child with container_of(). */
	358
	359	int enabled;
	360	int eval_filter; /* Need to evaluate filters */
	361	int (run_filter)(const struct lttng_kernel_event_common event,
	362	const char *stack_data,
	363	struct lttng_kernel_probe_ctx *probe_ctx,
	364	void *filter_ctx);
	365	};
	366
	367	struct lttng_kernel_event_recorder_private;
	368
	369	struct lttng_kernel_event_recorder {
	370	struct lttng_kernel_event_common parent;
	371	struct lttng_kernel_event_recorder_private priv; / Private event record interface */
	372
	373	struct lttng_kernel_channel_buffer *chan;
	374	};
	375
	376	struct lttng_kernel_notification_ctx {
	377	int eval_capture; /* Capture evaluation available. */
	378	};
	379
	380	struct lttng_kernel_event_notifier_private;
	381
	382	struct lttng_kernel_event_notifier {
	383	struct lttng_kernel_event_common parent;
	384	struct lttng_kernel_event_notifier_private priv; / Private event notifier interface */
	385
	386	int eval_capture; /* Need to evaluate capture */
	387	void (notification_send)(struct lttng_kernel_event_notifier event_notifier,
	388	const char *stack_data,
	389	struct lttng_kernel_probe_ctx *probe_ctx,
	390	struct lttng_kernel_notification_ctx *notif_ctx);
	391	};
	392
	393	struct lttng_kernel_channel_buffer_ops {
	394	struct lttng_kernel_channel_buffer_ops_private priv; / Private channel buffer ops interface. */
	395
	396	int (event_reserve)(struct lttng_kernel_ring_buffer_ctx ctx);
	397	void (event_commit)(struct lttng_kernel_ring_buffer_ctx ctx);
	398	void (event_write)(struct lttng_kernel_ring_buffer_ctx ctx, const void *src,
	399	size_t len, size_t alignment);
	400	void (event_write_from_user)(struct lttng_kernel_ring_buffer_ctx ctx,
	401	const void *src, size_t len, size_t alignment);
	402	void (event_memset)(struct lttng_kernel_ring_buffer_ctx ctx,
	403	int c, size_t len);
	404	void (event_strcpy)(struct lttng_kernel_ring_buffer_ctx ctx, const char *src,
	405	size_t len);
	406	void (event_strcpy_from_user)(struct lttng_kernel_ring_buffer_ctx ctx,
	407	const char __user *src, size_t len);
	408	void (event_pstrcpy_pad)(struct lttng_kernel_ring_buffer_ctx ctx,
	409	const char *src, size_t len);
	410	void (event_pstrcpy_pad_from_user)(struct lttng_kernel_ring_buffer_ctx ctx,
	411	const char __user *src, size_t len);
	412	void (lost_event_too_big)(struct lttng_kernel_channel_buffer lttng_channel);
	413	};
	414
	415	enum lttng_kernel_channel_type {
	416	LTTNG_KERNEL_CHANNEL_TYPE_BUFFER = 0,
	417	};
	418
	419	struct lttng_kernel_channel_common_private;
	420
	421	/* Use container_of() to get child. */
	422	struct lttng_kernel_channel_common {
	423	struct lttng_kernel_channel_common_private priv; / Private channel interface. */
	424
	425	enum lttng_kernel_channel_type type;
	426
	427	int enabled;
	428	struct lttng_kernel_session *session;
	429	};
	430
	431	struct lttng_kernel_channel_buffer_private;
	432
	433	struct lttng_kernel_channel_buffer {
	434	struct lttng_kernel_channel_common parent;
	435	struct lttng_kernel_channel_buffer_private *priv;
	436
	437	struct lttng_kernel_channel_buffer_ops *ops;
	438	};
	439
	440	#define LTTNG_DYNAMIC_LEN_STACK_SIZE 128
	441
	442	struct lttng_dynamic_len_stack {
	443	size_t stack[LTTNG_DYNAMIC_LEN_STACK_SIZE];
	444	size_t offset;
	445	};
	446
	447	DECLARE_PER_CPU(struct lttng_dynamic_len_stack, lttng_dynamic_len_stack);
	448
	449	/*
	450	* struct lttng_kernel_id_tracker declared in header due to deferencing of *v
	451	* in RCU_INITIALIZER(v).
	452	*/
	453	#define LTTNG_ID_HASH_BITS 6
	454	#define LTTNG_ID_TABLE_SIZE (1 << LTTNG_ID_HASH_BITS)
	455
	456	struct lttng_kernel_id_tracker_rcu {
	457	struct hlist_head id_hash[LTTNG_ID_TABLE_SIZE];
	458	};
	459
	460	struct lttng_kernel_id_tracker {
	461	struct lttng_kernel_id_tracker_private priv; / Private API */
	462
	463	struct lttng_kernel_id_tracker_rcu p; / RCU dereferenced. */
	464	};
	465
	466	struct lttng_kernel_session_private;
	467
	468	struct lttng_kernel_session {
	469	struct lttng_kernel_session_private priv; / Private session interface */
	470
	471	int active; /* Is trace session active ? */
	472
	473	struct lttng_kernel_id_tracker pid_tracker;
	474	struct lttng_kernel_id_tracker vpid_tracker;
	475	struct lttng_kernel_id_tracker uid_tracker;
	476	struct lttng_kernel_id_tracker vuid_tracker;
	477	struct lttng_kernel_id_tracker gid_tracker;
	478	struct lttng_kernel_id_tracker vgid_tracker;
	479	};
	480
	481	int lttng_kernel_probe_register(struct lttng_kernel_probe_desc *desc);
	482	void lttng_kernel_probe_unregister(struct lttng_kernel_probe_desc *desc);
	483
	484	bool lttng_id_tracker_lookup(struct lttng_kernel_id_tracker_rcu *p, int id);
	485
	486	#endif /* _LTTNG_EVENTS_H */