[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_channel;
struct lttng_kernel_session;
struct lttng_metadata_cache;
struct lttng_kernel_ring_buffer_ctx;
struct perf_event;
struct perf_event_attr;
struct lib_ring_buffer_config;

/* 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,
};

enum channel_type {
	PER_CPU_CHANNEL,
	METADATA_CHANNEL,
};

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;
	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;
};

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;
	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 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 **fields;	/* Array of pointers to fields. */
	unsigned int alignment;
};

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 **choices; /* Array of pointers to fields. */
	unsigned int nr_choices;
	unsigned int alignment;
};

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

/* 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 */
			user:1,		/* fetch from user-space */
			nofilter:1;	/* do not consider for filter */
};

#define lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, _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,					\
		.base = (_base),									\
	}))

#define lttng_kernel_static_type_integer_from_type(_type, _byte_order, _base)				\
	lttng_kernel_static_type_integer(sizeof(_type) * CHAR_BIT,					\
			lttng_alignof(_type) * CHAR_BIT,						\
			lttng_is_signed_type(_type),							\
			_byte_order,									\
			_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)							\
	((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,					\
	}))

#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, { \
		.parent = {										\
			.type = lttng_kernel_type_struct,						\
		},											\
		.nr_fields = (_nr_fields),								\
		.fields = _fields,									\
		.alignment = (_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, _user, _nofilter)			\
	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_event_field, {				\
		.name = (_name),									\
		.type = (_type),									\
		.nowrite = (_nowrite),									\
		.user = (_user),									\
		.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_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;
	void (*probe_callback)(void);
	const struct lttng_kernel_event_field **fields;	/* event payload */
	unsigned int nr_fields;
	struct module *owner;
};

struct lttng_kernel_probe_desc {
	const char *provider_name;
	const struct lttng_kernel_event_desc **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_channel *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);
	void (*event_write_from_user)(struct lttng_kernel_ring_buffer_ctx *ctx,
				      const void *src, size_t len);
	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);
};

struct lttng_syscall_filter;

#define LTTNG_EVENT_HT_BITS		12
#define LTTNG_EVENT_HT_SIZE		(1U << LTTNG_EVENT_HT_BITS)

struct lttng_event_ht {
	struct hlist_head table[LTTNG_EVENT_HT_SIZE];
};

#define LTTNG_EVENT_NOTIFIER_HT_BITS		12
#define LTTNG_EVENT_NOTIFIER_HT_SIZE		(1U << LTTNG_EVENT_NOTIFIER_HT_BITS)

struct lttng_event_notifier_ht {
	struct hlist_head table[LTTNG_EVENT_NOTIFIER_HT_SIZE];
};

struct lttng_channel {
	unsigned int id;
	struct channel *chan;		/* Channel buffers */
	int enabled;
	struct lttng_kernel_ctx *ctx;
	/* Event ID management */
	struct lttng_kernel_session *session;
	struct file *file;		/* File associated to channel */
	unsigned int free_event_id;	/* Next event ID to allocate */
	struct list_head list;		/* Channel list */
	struct lttng_kernel_channel_buffer_ops *ops;
	struct lttng_transport *transport;
	struct hlist_head *sc_table;	/* for syscall tracing */
	struct hlist_head *compat_sc_table;
	struct hlist_head *sc_exit_table;	/* for syscall exit tracing */
	struct hlist_head *compat_sc_exit_table;
	struct hlist_head sc_unknown;	/* for unknown syscalls */
	struct hlist_head sc_compat_unknown;
	struct hlist_head sc_exit_unknown;
	struct hlist_head compat_sc_exit_unknown;
	struct lttng_syscall_filter *sc_filter;
	int header_type;		/* 0: unset, 1: compact, 2: large */
	enum channel_type channel_type;
	int syscall_all_entry;
	int syscall_all_exit;
	unsigned int metadata_dumped:1,
		sys_enter_registered:1,
		sys_exit_registered:1,
		tstate:1;		/* Transient enable state */
};

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