[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 <linux/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_channel_counter;
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,
	LTTNG_KERNEL_EVENT_TYPE_COUNTER = 2
};

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_event_counter_ctx {
	int args_available;
};

struct lttng_kernel_event_counter_private;

struct lttng_kernel_event_counter {
	struct lttng_kernel_event_common parent;
	struct lttng_kernel_event_counter_private *priv;	/* Private event counter interface */

	struct lttng_kernel_channel_counter *chan;

	int use_args;						/* Use input arguments. */
};

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,
	LTTNG_KERNEL_CHANNEL_TYPE_COUNTER = 1,
};

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

struct lttng_kernel_channel_counter;
struct lttng_kernel_channel_counter_ops_private;

struct lttng_kernel_channel_counter_ops {
	struct lttng_kernel_channel_counter_ops_private *priv;	/* Private channel counter ops interface */

	int (*counter_hit)(struct lttng_kernel_event_counter *event_counter,
		const char *stack_data,
		struct lttng_kernel_probe_ctx *probe_ctx,
		struct lttng_kernel_event_counter_ctx *event_counter_ctx);
};

struct lttng_kernel_channel_counter {
	struct lttng_kernel_channel_common parent;
	struct lttng_kernel_channel_counter_private *priv;	/* Private channel counter interface */

	struct lttng_kernel_channel_counter_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);

static inline
struct lttng_kernel_channel_common *lttng_kernel_get_chan_common_from_event_common(
		struct lttng_kernel_event_common *event)
{
	switch (event->type) {
	case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
	{
		struct lttng_kernel_event_recorder *event_recorder =
			container_of(event, struct lttng_kernel_event_recorder, parent);
		struct lttng_kernel_channel_buffer *chan_buf = event_recorder->chan;

		return &chan_buf->parent;
	}
	case LTTNG_KERNEL_EVENT_TYPE_COUNTER:
	{
		struct lttng_kernel_event_counter *event_counter =
			container_of(event, struct lttng_kernel_event_counter, parent);
		struct lttng_kernel_channel_counter *chan_counter = event_counter->chan;

		return &chan_counter->parent;
	}
	default:
		return NULL;
	}
}

#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>
853f5b15 MJ	19	#include <linux/uprobes.h>
853f5b15 MJ	20
2df37e95 MD	21	#include <lttng/cpuhotplug.h>
	22	#include <lttng/tracer.h>
	23	#include <lttng/abi.h>
	24	#include <lttng/abi-old.h>
	25	#include <lttng/endian.h>
4e3c1b9b	26
e97dc605	27	#define lttng_is_signed_type(type) (((type) -1) < (type) 1)
9e7e4892	28
f7d06400	29	struct lttng_kernel_channel_buffer;
1a2317f8	30	struct lttng_kernel_channel_counter;
8cdc1a81	31	struct lttng_kernel_session;
8a57ec02	32	struct lttng_kernel_ring_buffer_ctx;
4e3c1b9b	33
c0edae1d MD	34	/* Type description */
c0edae1d MD	35
12bb2edb MD	36	enum lttng_kernel_type {
	37	lttng_kernel_type_integer,
	38	lttng_kernel_type_string,
437d5aa5 MD	39	lttng_kernel_type_enum,
	40	lttng_kernel_type_array,
	41	lttng_kernel_type_sequence,
	42	lttng_kernel_type_struct,
	43	lttng_kernel_type_variant,
12bb2edb	44	NR_LTTNG_KERNEL_TYPES,
c0edae1d MD	45	};
c0edae1d MD	46
28cbcb59 MD	47	enum lttng_kernel_string_encoding {
	48	lttng_kernel_string_encoding_none = 0,
	49	lttng_kernel_string_encoding_UTF8 = 1,
	50	lttng_kernel_string_encoding_ASCII = 2,
	51	NR_LTTNG_KERNEL_STRING_ENCODING,
c0edae1d MD	52	};
c0edae1d MD	53
a28cc520	54	struct lttng_kernel_enum_value {
141ddf28 MD	55	unsigned long long value;
	56	unsigned int signedness:1;
	57	};
	58
a28cc520 MD	59	struct lttng_kernel_enum_entry {
a28cc520 MD	60	struct lttng_kernel_enum_value start, end; /* start and end are inclusive */
c0edae1d	61	const char *string;
08ad1061 PP	62	struct {
	63	unsigned int is_auto:1;
	64	} options;
c0edae1d MD	65	};
c0edae1d MD	66
437d5aa5 MD	67	/*
	68	* struct lttng_kernel_type_common is fixed-size. Its children inherits
	69	* from it by embedding struct lttng_kernel_type_common as its first field.
	70	*/
	71	struct lttng_kernel_type_common {
	72	enum lttng_kernel_type type;
	73	};
	74
	75	struct lttng_kernel_type_integer {
	76	struct lttng_kernel_type_common parent;
c099397a MD	77	unsigned int size; /* in bits */
c099397a MD	78	unsigned short alignment; /* in bits */
9cccf98a	79	unsigned int signedness:1,
4697aac7 MD	80	reverse_byte_order:1,
4697aac7 MD	81	user:1; /* fetch from user-space */
e0a7a7c4	82	unsigned int base; /* 2, 8, 10, 16, for pretty print */
437d5aa5 MD	83	};
	84
	85	struct lttng_kernel_type_string {
	86	struct lttng_kernel_type_common parent;
28cbcb59	87	enum lttng_kernel_string_encoding encoding;
4697aac7	88	unsigned int user:1; /* fetch from user-space */
c099397a MD	89	};
c099397a MD	90
437d5aa5 MD	91	struct lttng_kernel_type_enum {
	92	struct lttng_kernel_type_common parent;
	93	const struct lttng_kernel_enum_desc desc; / Enumeration mapping */
	94	const struct lttng_kernel_type_common *container_type;
	95	};
	96
	97	struct lttng_kernel_type_array {
	98	struct lttng_kernel_type_common parent;
	99	const struct lttng_kernel_type_common *elem_type;
	100	unsigned int length; /* Num. elems. */
c27937ce	101	unsigned int alignment; /* Alignment in bytes before elements. */
437d5aa5 MD	102	enum lttng_kernel_string_encoding encoding;
	103	};
	104
	105	struct lttng_kernel_type_sequence {
	106	struct lttng_kernel_type_common parent;
51ef4536	107	const char length_name; / Length field name. If NULL, use previous field. */
437d5aa5	108	const struct lttng_kernel_type_common *elem_type;
c27937ce	109	unsigned int alignment; /* Alignment in bytes before elements. */
437d5aa5 MD	110	enum lttng_kernel_string_encoding encoding;
	111	};
	112
	113	struct lttng_kernel_type_struct {
	114	struct lttng_kernel_type_common parent;
	115	unsigned int nr_fields;
4f1d1ee5	116	const struct lttng_kernel_event_field * const fields; / Array of pointers to fields. */
c27937ce	117	unsigned int alignment; /* Alignment in bits */
437d5aa5 MD	118	};
	119
	120	struct lttng_kernel_type_variant {
	121	struct lttng_kernel_type_common parent;
51ef4536	122	const char tag_name; / Tag field name. If NULL, use previous field. */
4f1d1ee5	123	const struct lttng_kernel_event_field * const choices; / Array of pointers to fields. */
437d5aa5	124	unsigned int nr_choices;
c27937ce	125	unsigned int alignment; /* Alignment in bytes */
c099397a MD	126	};
c099397a MD	127
d96a4a7a	128	struct lttng_kernel_enum_desc {
c099397a	129	const char *name;
4f1d1ee5	130	const struct lttng_kernel_enum_entry * const *entries;
141ddf28	131	unsigned int nr_entries;
6c8c025b	132	const struct lttng_kernel_probe_desc *probe_desc;
c099397a	133	};
c0edae1d MD	134
	135	/* Event field description */
	136
437d5aa5	137	struct lttng_kernel_event_field {
c0edae1d	138	const char *name;
437d5aa5	139	const struct lttng_kernel_type_common *type;
f127e61e	140	unsigned int nowrite:1, /* do not write into trace */
ceabb767	141	nofilter:1; /* do not consider for filter */
c0edae1d MD	142	};
c0edae1d MD	143
9857164a FD	144	#ifndef PARAMS
	145	#define PARAMS(args...) args
	146	#endif
	147
4697aac7	148	#define _lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, _user, _base) \
437d5aa5 MD	149	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_integer, { \
	150	.parent = { \
	151	.type = lttng_kernel_type_integer, \
	152	}, \
	153	.size = (_size), \
	154	.alignment = (_alignment), \
	155	.signedness = (_signedness), \
	156	.reverse_byte_order = (_byte_order) != __BYTE_ORDER, \
4697aac7	157	.user = (_user), \
437d5aa5 MD	158	.base = (_base), \
	159	}))
	160
4697aac7 MD	161	#define lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, _base) \
	162	_lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, 0, _base)
	163
	164	#define lttng_kernel_static_type_user_integer(_size, _alignment, _signedness, _byte_order, _base) \
	165	_lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, 1, _base)
	166
	167	#define _lttng_kernel_static_type_integer_from_type(_type, _byte_order, _user, _base) \
6f185e4f	168	_lttng_kernel_static_type_integer(sizeof(_type) * CHAR_BIT, \
437d5aa5 MD	169	lttng_alignof(_type) * CHAR_BIT, \
437d5aa5 MD	170	lttng_is_signed_type(_type), \
6f185e4f	171	_byte_order, _user, _base)
437d5aa5	172
4697aac7 MD	173	#define lttng_kernel_static_type_integer_from_type(_type, _byte_order, _base) \
	174	_lttng_kernel_static_type_integer_from_type(_type, _byte_order, 0, _base)
	175
	176	#define lttng_kernel_static_type_user_integer_from_type(_type, _byte_order, _base) \
	177	_lttng_kernel_static_type_integer_from_type(_type, _byte_order, 1, _base)
	178
437d5aa5 MD	179	#define lttng_kernel_static_type_enum(_desc, _container_type) \
	180	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_enum, { \
	181	.parent = { \
	182	.type = lttng_kernel_type_enum, \
	183	}, \
	184	.desc = (_desc), \
	185	.container_type = (_container_type), \
	186	}))
	187
	188	#define lttng_kernel_static_type_array(_length, _elem_type, _alignment, _encoding) \
	189	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_array, { \
	190	.parent = { \
	191	.type = lttng_kernel_type_array, \
	192	}, \
	193	.length = (_length), \
	194	.alignment = (_alignment), \
	195	.encoding = lttng_kernel_string_encoding_##_encoding, \
	196	.elem_type = (_elem_type), \
	197	}))
	198
	199	#define lttng_kernel_static_type_array_text(_length) \
	200	lttng_kernel_static_type_array(_length, \
	201	lttng_kernel_static_type_integer(sizeof(char) * CHAR_BIT, \
	202	lttng_alignof(char) * CHAR_BIT, lttng_is_signed_type(char), \
	203	__BYTE_ORDER, 10), \
	204	0, UTF8)
	205
	206	#define lttng_kernel_static_type_sequence(_length_name, _elem_type, _alignment, _encoding) \
	207	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_sequence, { \
	208	.parent = { \
	209	.type = lttng_kernel_type_sequence, \
	210	}, \
	211	.length_name = (_length_name), \
	212	.alignment = (_alignment), \
	213	.encoding = lttng_kernel_string_encoding_##_encoding, \
	214	.elem_type = (_elem_type), \
	215	}))
	216
4697aac7	217	#define lttng_kernel_static_type_string(_encoding, _user) \
437d5aa5 MD	218	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_string, { \
	219	.parent = { \
	220	.type = lttng_kernel_type_string, \
	221	}, \
	222	.encoding = lttng_kernel_string_encoding_##_encoding, \
4697aac7	223	.user = (_user), \
437d5aa5 MD	224	}))
437d5aa5 MD	225
9857164a FD	226	#define lttng_kernel_static_type_struct_init(_nr_fields, _fields, _alignment) \
9857164a FD	227	{ \
437d5aa5 MD	228	.parent = { \
	229	.type = lttng_kernel_type_struct, \
	230	}, \
	231	.nr_fields = (_nr_fields), \
	232	.fields = _fields, \
	233	.alignment = (_alignment), \
9857164a FD	234	}
	235
	236	#define lttng_kernel_static_type_struct(_nr_fields, _fields, _alignment) \
	237	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_struct, \
	238	lttng_kernel_static_type_struct_init(_nr_fields, PARAMS(_fields), _alignment) \
	239	))
437d5aa5 MD	240
	241	#define lttng_kernel_static_type_variant(_nr_choices, _choices, _tag_name, _alignment) \
	242	((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_variant, { \
	243	.parent = { \
	244	.type = lttng_kernel_type_variant, \
	245	}, \
	246	.tag_name = (_tag_name), \
	247	.choices = _choices, \
	248	.nr_choices = (_nr_choices), \
	249	.alignment = (_alignment), \
	250	}))
	251
4697aac7	252	#define lttng_kernel_static_event_field(_name, _type, _nowrite, _nofilter) \
437d5aa5 MD	253	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_event_field, { \
	254	.name = (_name), \
	255	.type = (_type), \
	256	.nowrite = (_nowrite), \
437d5aa5 MD	257	.nofilter = (_nofilter), \
	258	})
	259
	260	#define lttng_kernel_static_event_field_array(_fields...) \
	261	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_event_field *, \
	262	_fields \
	263	)
	264
437d5aa5 MD	265	#define lttng_kernel_static_enum_entry_value(_string, _value) \
	266	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, { \
	267	.start = { \
	268	.signedness = lttng_is_signed_type(__typeof__(_value)), \
	269	.value = lttng_is_signed_type(__typeof__(_value)) ? \
	270	(long long) (_value) : (_value), \
	271	}, \
	272	.end = { \
	273	.signedness = lttng_is_signed_type(__typeof__(_value)), \
	274	.value = lttng_is_signed_type(__typeof__(_value)) ? \
	275	(long long) (_value) : (_value), \
	276	}, \
	277	.string = (_string), \
	278	}),
	279
	280	#define lttng_kernel_static_enum_entry_range(_string, _range_start, _range_end) \
	281	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, { \
	282	.start = { \
	283	.signedness = lttng_is_signed_type(__typeof__(_range_start)), \
	284	.value = lttng_is_signed_type(__typeof__(_range_start)) ? \
	285	(long long) (_range_start) : (_range_start), \
	286	}, \
	287	.end = { \
	288	.signedness = lttng_is_signed_type(__typeof__(_range_end)), \
	289	.value = lttng_is_signed_type(__typeof__(_range_end)) ? \
	290	(long long) (_range_end) : (_range_end), \
	291	}, \
	292	.string = (_string), \
	293	}),
	294
	295	#define lttng_kernel_static_enum_entry_auto(_string) \
	296	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, { \
	297	.start = { \
	298	.signedness = -1, \
	299	.value = -1, \
	300	}, \
	301	.end = { \
	302	.signedness = -1, \
	303	.value = -1, \
	304	}, \
	305	.string = (_string), \
	306	.options = { \
	307	.is_auto = 1, \
	308	} \
	309	}),
	310
a92e844e	311	struct lttng_kernel_probe_ctx {
e2d5dbc7	312	struct lttng_kernel_event_common *event;
79150a49 JD	313	uint8_t interruptible;
	314	};
	315
6c8c025b MD	316	struct lttng_kernel_tracepoint_class {
6c8c025b MD	317	void (*probe_callback)(void);
4f1d1ee5	318	const struct lttng_kernel_event_field * const fields; / event payload */
6c8c025b MD	319	unsigned int nr_fields;
	320	const struct lttng_kernel_probe_desc *probe_desc;
	321	};
	322
437d5aa5 MD	323	struct lttng_kernel_event_desc {
	324	const char event_name; / lttng-modules name */
	325	const char event_kname; / Linux kernel name (tracepoints) */
	326	const struct lttng_kernel_probe_desc *probe_desc;
6c8c025b	327	const struct lttng_kernel_tracepoint_class *tp_class;
dc7f600a	328	struct module *owner;
c0edae1d MD	329	};
c0edae1d MD	330
437d5aa5 MD	331	struct lttng_kernel_probe_desc {
437d5aa5 MD	332	const char *provider_name;
4f1d1ee5	333	const struct lttng_kernel_event_desc * const *event_desc;
85a9ca7f MD	334	unsigned int nr_events;
85a9ca7f MD	335	struct list_head head; /* chain registered probes */
3c997079 MD	336	struct list_head lazy_init_head;
3c997079 MD	337	int lazy; /* lazy registration */
85a9ca7f MD	338	};
85a9ca7f MD	339
8a445457 MD	340	/*
	341	* Result of the run_filter() callback.
	342	*/
	343	enum lttng_kernel_event_filter_result {
	344	LTTNG_KERNEL_EVENT_FILTER_ACCEPT = 0,
	345	LTTNG_KERNEL_EVENT_FILTER_REJECT = 1,
	346	};
	347
a67ba386 MD	348	struct lttng_kernel_event_common_private;
	349
	350	enum lttng_kernel_event_type {
	351	LTTNG_KERNEL_EVENT_TYPE_RECORDER = 0,
	352	LTTNG_KERNEL_EVENT_TYPE_NOTIFIER = 1,
062a5f00	353	LTTNG_KERNEL_EVENT_TYPE_COUNTER = 2
a67ba386 MD	354	};
	355
	356	struct lttng_kernel_event_common {
	357	struct lttng_kernel_event_common_private priv; / Private event interface */
	358
	359	enum lttng_kernel_event_type type;
	360	/* Get child with container_of(). */
	361
e64957da	362	int enabled;
a67ba386	363	int eval_filter; /* Need to evaluate filters */
8a445457	364	int (run_filter)(const struct lttng_kernel_event_common event,
a67ba386	365	const char *stack_data,
a92e844e	366	struct lttng_kernel_probe_ctx *probe_ctx,
a67ba386	367	void *filter_ctx);
3c997079 MD	368	};
3c997079 MD	369
a67ba386 MD	370	struct lttng_kernel_event_recorder_private;
	371
	372	struct lttng_kernel_event_recorder {
	373	struct lttng_kernel_event_common parent;
	374	struct lttng_kernel_event_recorder_private priv; / Private event record interface */
	375
f7d06400	376	struct lttng_kernel_channel_buffer *chan;
c3eddb2e MD	377	};
c3eddb2e MD	378
d9a337ba MD	379	struct lttng_kernel_event_counter_ctx {
	380	int args_available;
	381	};
	382
1a2317f8 MD	383	struct lttng_kernel_event_counter_private;
	384
	385	struct lttng_kernel_event_counter {
	386	struct lttng_kernel_event_common parent;
	387	struct lttng_kernel_event_counter_private priv; / Private event counter interface */
	388
	389	struct lttng_kernel_channel_counter *chan;
d9a337ba MD	390
d9a337ba MD	391	int use_args; /* Use input arguments. */
1a2317f8 MD	392	};
1a2317f8 MD	393
a67ba386 MD	394	struct lttng_kernel_notification_ctx {
	395	int eval_capture; /* Capture evaluation available. */
	396	};
dffef45d	397
a67ba386	398	struct lttng_kernel_event_notifier_private;
8a8ac9a8	399
a67ba386 MD	400	struct lttng_kernel_event_notifier {
	401	struct lttng_kernel_event_common parent;
	402	struct lttng_kernel_event_notifier_private priv; / Private event notifier interface */
dffef45d	403
a67ba386 MD	404	int eval_capture; /* Need to evaluate capture */
a67ba386 MD	405	void (notification_send)(struct lttng_kernel_event_notifier event_notifier,
a67ba386	406	const char *stack_data,
a92e844e	407	struct lttng_kernel_probe_ctx *probe_ctx,
a67ba386	408	struct lttng_kernel_notification_ctx *notif_ctx);
dffef45d FD	409	};
dffef45d FD	410
4a399b76 MD	411	struct lttng_kernel_channel_buffer_ops {
	412	struct lttng_kernel_channel_buffer_ops_private priv; / Private channel buffer ops interface. */
	413
8a57ec02 MD	414	int (event_reserve)(struct lttng_kernel_ring_buffer_ctx ctx);
	415	void (event_commit)(struct lttng_kernel_ring_buffer_ctx ctx);
	416	void (event_write)(struct lttng_kernel_ring_buffer_ctx ctx, const void *src,
f5ffbd77	417	size_t len, size_t alignment);
8a57ec02	418	void (event_write_from_user)(struct lttng_kernel_ring_buffer_ctx ctx,
f5ffbd77	419	const void *src, size_t len, size_t alignment);
8a57ec02	420	void (event_memset)(struct lttng_kernel_ring_buffer_ctx ctx,
58aa5d24	421	int c, size_t len);
8a57ec02	422	void (event_strcpy)(struct lttng_kernel_ring_buffer_ctx ctx, const char *src,
16f78f3a	423	size_t len);
8a57ec02	424	void (event_strcpy_from_user)(struct lttng_kernel_ring_buffer_ctx ctx,
16f78f3a	425	const char __user *src, size_t len);
0d1080f4 MD	426	void (event_pstrcpy_pad)(struct lttng_kernel_ring_buffer_ctx ctx,
	427	const char *src, size_t len);
	428	void (event_pstrcpy_pad_from_user)(struct lttng_kernel_ring_buffer_ctx ctx,
	429	const char __user *src, size_t len);
f7d06400 MD	430	void (lost_event_too_big)(struct lttng_kernel_channel_buffer lttng_channel);
	431	};
	432
	433	enum lttng_kernel_channel_type {
	434	LTTNG_KERNEL_CHANNEL_TYPE_BUFFER = 0,
76ba9cee	435	LTTNG_KERNEL_CHANNEL_TYPE_COUNTER = 1,
85a9ca7f MD	436	};
85a9ca7f MD	437
f7d06400 MD	438	struct lttng_kernel_channel_common_private;
	439
	440	/* Use container_of() to get child. */
	441	struct lttng_kernel_channel_common {
	442	struct lttng_kernel_channel_common_private priv; / Private channel interface. */
	443
	444	enum lttng_kernel_channel_type type;
	445
e64957da	446	int enabled;
8cdc1a81	447	struct lttng_kernel_session *session;
f7d06400 MD	448	};
	449
	450	struct lttng_kernel_channel_buffer_private;
	451
	452	struct lttng_kernel_channel_buffer {
	453	struct lttng_kernel_channel_common parent;
	454	struct lttng_kernel_channel_buffer_private *priv;
	455
4a399b76	456	struct lttng_kernel_channel_buffer_ops *ops;
85a9ca7f MD	457	};
85a9ca7f MD	458
143a6f27 MD	459	struct lttng_kernel_channel_counter;
	460	struct lttng_kernel_channel_counter_ops_private;
	461
	462	struct lttng_kernel_channel_counter_ops {
	463	struct lttng_kernel_channel_counter_ops_private priv; / Private channel counter ops interface */
	464
d9a337ba MD	465	int (counter_hit)(struct lttng_kernel_event_counter event_counter,
	466	const char *stack_data,
	467	struct lttng_kernel_probe_ctx *probe_ctx,
	468	struct lttng_kernel_event_counter_ctx *event_counter_ctx);
143a6f27 MD	469	};
	470
	471	struct lttng_kernel_channel_counter {
	472	struct lttng_kernel_channel_common parent;
	473	struct lttng_kernel_channel_counter_private priv; / Private channel counter interface */
	474
	475	struct lttng_kernel_channel_counter_ops *ops;
	476	};
	477
114667d5 MD	478	#define LTTNG_DYNAMIC_LEN_STACK_SIZE 128
	479
	480	struct lttng_dynamic_len_stack {
	481	size_t stack[LTTNG_DYNAMIC_LEN_STACK_SIZE];
	482	size_t offset;
	483	};
	484
	485	DECLARE_PER_CPU(struct lttng_dynamic_len_stack, lttng_dynamic_len_stack);
e0130fab MD	486
e0130fab MD	487	/*
8c0393c3	488	* struct lttng_kernel_id_tracker declared in header due to deferencing of *v
e0130fab MD	489	* in RCU_INITIALIZER(v).
e0130fab MD	490	*/
d1f652f8 MD	491	#define LTTNG_ID_HASH_BITS 6
d1f652f8 MD	492	#define LTTNG_ID_TABLE_SIZE (1 << LTTNG_ID_HASH_BITS)
e0130fab	493
8c0393c3	494	struct lttng_kernel_id_tracker_rcu {
d1f652f8 MD	495	struct hlist_head id_hash[LTTNG_ID_TABLE_SIZE];
	496	};
	497
8c0393c3 MD	498	struct lttng_kernel_id_tracker {
	499	struct lttng_kernel_id_tracker_private priv; / Private API */
	500
	501	struct lttng_kernel_id_tracker_rcu p; / RCU dereferenced. */
e0130fab MD	502	};
e0130fab MD	503
8cdc1a81 MD	504	struct lttng_kernel_session_private;
	505
	506	struct lttng_kernel_session {
	507	struct lttng_kernel_session_private priv; / Private session interface */
	508
85a9ca7f	509	int active; /* Is trace session active ? */
8cdc1a81	510
8c0393c3 MD	511	struct lttng_kernel_id_tracker pid_tracker;
	512	struct lttng_kernel_id_tracker vpid_tracker;
	513	struct lttng_kernel_id_tracker uid_tracker;
	514	struct lttng_kernel_id_tracker vuid_tracker;
	515	struct lttng_kernel_id_tracker gid_tracker;
	516	struct lttng_kernel_id_tracker vgid_tracker;
85a9ca7f MD	517	};
85a9ca7f MD	518
d1769981 MD	519	int lttng_kernel_probe_register(struct lttng_kernel_probe_desc *desc);
d1769981 MD	520	void lttng_kernel_probe_unregister(struct lttng_kernel_probe_desc *desc);
d83004aa	521
8c0393c3	522	bool lttng_id_tracker_lookup(struct lttng_kernel_id_tracker_rcu *p, int id);
271b6681	523
062a5f00 MD	524	static inline
	525	struct lttng_kernel_channel_common *lttng_kernel_get_chan_common_from_event_common(
	526	struct lttng_kernel_event_common *event)
	527	{
	528	switch (event->type) {
	529	case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
	530	{
	531	struct lttng_kernel_event_recorder *event_recorder =
	532	container_of(event, struct lttng_kernel_event_recorder, parent);
	533	struct lttng_kernel_channel_buffer *chan_buf = event_recorder->chan;
	534
	535	return &chan_buf->parent;
	536	}
	537	case LTTNG_KERNEL_EVENT_TYPE_COUNTER:
	538	{
	539	struct lttng_kernel_event_counter *event_counter =
	540	container_of(event, struct lttng_kernel_event_counter, parent);
	541	struct lttng_kernel_channel_counter *chan_counter = event_counter->chan;
	542
	543	return &chan_counter->parent;
	544	}
	545	default:
	546	return NULL;
	547	}
	548	}
	549
a90917c3	550	#endif /* _LTTNG_EVENTS_H */