[lttng-ust.git] / src / common / events.h

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright 2019 (c) Francis Deslauriers <francis.deslauriers@efficios.com>
 */

#ifndef _UST_COMMON_UST_EVENTS_H
#define _UST_COMMON_UST_EVENTS_H

#include <limits.h>
#include <stdint.h>

#include <urcu/list.h>
#include <urcu/hlist.h>

#include <lttng/ust-events.h>

#include "common/macros.h"
#include "common/ust-context-provider.h"

struct lttng_ust_abi_obj;
struct lttng_event_notifier_group;

union lttng_ust_abi_args {
	struct {
		void *chan_data;
		int wakeup_fd;
	} channel;
	struct {
		int shm_fd;
		int wakeup_fd;
	} stream;
	struct {
		struct lttng_ust_abi_field_iter entry;
	} field_list;
	struct {
		char *ctxname;
	} app_context;
	struct {
		int event_notifier_notif_fd;
	} event_notifier_handle;
	struct {
		void *counter_data;
	} counter;
	struct {
		int shm_fd;
	} counter_shm;
};

struct lttng_ust_abi_objd_ops {
	long (*cmd)(int objd, unsigned int cmd, unsigned long arg,
		union lttng_ust_abi_args *args, void *owner);
	int (*release)(int objd);
};

enum lttng_enabler_format_type {
	LTTNG_ENABLER_FORMAT_STAR_GLOB,
	LTTNG_ENABLER_FORMAT_EVENT,
};

/*
 * Enabler field, within whatever object is enabling an event. Target of
 * backward reference.
 */
struct lttng_enabler {
	enum lttng_enabler_format_type format_type;

	/* head list of struct lttng_ust_filter_bytecode_node */
	struct cds_list_head filter_bytecode_head;
	/* head list of struct lttng_ust_excluder_node */
	struct cds_list_head excluder_head;

	struct lttng_ust_abi_event event_param;
	unsigned int enabled:1;
};

struct lttng_event_enabler {
	struct lttng_enabler base;
	struct cds_list_head node;	/* per-session list of enablers */
	struct lttng_ust_channel_buffer *chan;
	/*
	 * Unused, but kept around to make it explicit that the tracer can do
	 * it.
	 */
	struct lttng_ust_ctx *ctx;
};

struct lttng_event_notifier_enabler {
	struct lttng_enabler base;
	uint64_t error_counter_index;
	struct cds_list_head node;	/* per-app list of event_notifier enablers */
	struct cds_list_head capture_bytecode_head;
	struct lttng_event_notifier_group *group; /* weak ref */
	uint64_t user_token;		/* User-provided token */
	uint64_t num_captures;
};

enum lttng_ust_bytecode_type {
	LTTNG_UST_BYTECODE_TYPE_FILTER,
	LTTNG_UST_BYTECODE_TYPE_CAPTURE,
};

struct lttng_ust_bytecode_node {
	enum lttng_ust_bytecode_type type;
	struct cds_list_head node;
	struct lttng_enabler *enabler;
	struct  {
		uint32_t len;
		uint32_t reloc_offset;
		uint64_t seqnum;
		char data[];
	} bc;
};

/*
 * Bytecode interpreter return value.
 */
enum lttng_ust_bytecode_interpreter_ret {
	LTTNG_UST_BYTECODE_INTERPRETER_ERROR = -1,
	LTTNG_UST_BYTECODE_INTERPRETER_OK = 0,
};

struct lttng_interpreter_output;
struct lttng_ust_bytecode_runtime_private;

enum lttng_ust_bytecode_filter_result {
	LTTNG_UST_BYTECODE_FILTER_ACCEPT = 0,
	LTTNG_UST_BYTECODE_FILTER_REJECT = 1,
};

struct lttng_ust_bytecode_filter_ctx {
	enum lttng_ust_bytecode_filter_result result;
};

struct lttng_ust_excluder_node {
	struct cds_list_head node;
	struct lttng_enabler *enabler;
	/*
	 * struct lttng_ust_event_exclusion had variable sized array,
	 * must be last field.
	 */
	struct lttng_ust_abi_event_exclusion excluder;
};

/* Data structures used by the tracer. */

struct tp_list_entry {
	struct lttng_ust_abi_tracepoint_iter tp;
	struct cds_list_head head;
};

struct lttng_ust_tracepoint_list {
	struct tp_list_entry *iter;
	struct cds_list_head head;
};

struct tp_field_list_entry {
	struct lttng_ust_abi_field_iter field;
	struct cds_list_head head;
};

struct lttng_ust_field_list {
	struct tp_field_list_entry *iter;
	struct cds_list_head head;
};

/*
 * Objects in a linked-list of enablers, owned by an event or event_notifier.
 * This is used because an event (or a event_notifier) can be enabled by more
 * than one enabler and we want a quick way to iterate over all enablers of an
 * object.
 *
 * For example, event rules "my_app:a*" and "my_app:ab*" will both match the
 * event with the name "my_app:abc".
 */
struct lttng_enabler_ref {
	struct cds_list_head node;		/* enabler ref list */
	struct lttng_enabler *ref;		/* backward ref */
};

#define LTTNG_COUNTER_DIMENSION_MAX	8
struct lttng_counter_dimension {
	uint64_t size;
	uint64_t underflow_index;
	uint64_t overflow_index;
	uint8_t has_underflow;
	uint8_t has_overflow;
};

struct lttng_counter_ops {
	struct lib_counter *(*counter_create)(size_t nr_dimensions,
			const struct lttng_counter_dimension *dimensions,
			int64_t global_sum_step,
			int global_counter_fd,
			int nr_counter_cpu_fds,
			const int *counter_cpu_fds,
			bool is_daemon);
	void (*counter_destroy)(struct lib_counter *counter);
	int (*counter_add)(struct lib_counter *counter,
			const size_t *dimension_indexes, int64_t v);
	int (*counter_read)(struct lib_counter *counter,
			const size_t *dimension_indexes, int cpu,
			int64_t *value, bool *overflow, bool *underflow);
	int (*counter_aggregate)(struct lib_counter *counter,
			const size_t *dimension_indexes, int64_t *value,
			bool *overflow, bool *underflow);
	int (*counter_clear)(struct lib_counter *counter, const size_t *dimension_indexes);
};

struct lttng_counter {
	int objd;
	struct lttng_event_notifier_group *event_notifier_group;    /* owner */
	struct lttng_counter_transport *transport;
	struct lib_counter *counter;
	struct lttng_counter_ops *ops;
};

#define LTTNG_UST_EVENT_HT_BITS		12
#define LTTNG_UST_EVENT_HT_SIZE		(1U << LTTNG_UST_EVENT_HT_BITS)

struct lttng_ust_event_ht {
	struct cds_hlist_head table[LTTNG_UST_EVENT_HT_SIZE];
};

#define LTTNG_UST_EVENT_NOTIFIER_HT_BITS		12
#define LTTNG_UST_EVENT_NOTIFIER_HT_SIZE		(1U << LTTNG_UST_EVENT_NOTIFIER_HT_BITS)
struct lttng_ust_event_notifier_ht {
	struct cds_hlist_head table[LTTNG_UST_EVENT_NOTIFIER_HT_SIZE];
};

#define LTTNG_UST_ENUM_HT_BITS		12
#define LTTNG_UST_ENUM_HT_SIZE		(1U << LTTNG_UST_ENUM_HT_BITS)

struct lttng_ust_enum_ht {
	struct cds_hlist_head table[LTTNG_UST_ENUM_HT_SIZE];
};

struct lttng_event_notifier_group {
	int objd;
	void *owner;
	int notification_fd;
	struct cds_list_head node;		/* Event notifier group handle list */
	struct cds_list_head enablers_head;
	struct cds_list_head event_notifiers_head; /* list of event_notifiers */
	struct lttng_ust_event_notifier_ht event_notifiers_ht; /* hashtable of event_notifiers */
	struct lttng_ust_ctx *ctx;		/* contexts for filters. */

	struct lttng_counter *error_counter;
	size_t error_counter_len;
};

struct lttng_transport {
	const char *name;
	struct cds_list_head node;
	struct lttng_ust_channel_buffer_ops ops;
	const struct lttng_ust_ring_buffer_config *client_config;
};

struct lttng_counter_transport {
	const char *name;
	struct cds_list_head node;
	struct lttng_counter_ops ops;
	const struct lib_counter_config *client_config;
};

struct lttng_ust_event_common_private {
	struct lttng_ust_event_common *pub;	/* Public event interface */

	const struct lttng_ust_event_desc *desc;
	/* Backward references: list of lttng_enabler_ref (ref to enablers) */
	struct cds_list_head enablers_ref_head;
	int registered;				/* has reg'd tracepoint probe */
	uint64_t user_token;

	int has_enablers_without_filter_bytecode;
	/* list of struct lttng_ust_bytecode_runtime, sorted by seqnum */
	struct cds_list_head filter_bytecode_runtime_head;
};

struct lttng_ust_event_recorder_private {
	struct lttng_ust_event_common_private parent;

	struct lttng_ust_event_recorder *pub;	/* Public event interface */
	struct cds_list_head node;		/* Event recorder list */
	struct cds_hlist_node hlist;		/* Hash table of event recorders */
	struct lttng_ust_ctx *ctx;
	unsigned int id;
};

struct lttng_ust_event_notifier_private {
	struct lttng_ust_event_common_private parent;

	struct lttng_ust_event_notifier *pub;	/* Public event notifier interface */
	struct lttng_event_notifier_group *group; /* weak ref */
	size_t num_captures;			/* Needed to allocate the msgpack array. */
	uint64_t error_counter_index;
	struct cds_list_head node;		/* Event notifier list */
	struct cds_hlist_node hlist;		/* Hash table of event notifiers */
	struct cds_list_head capture_bytecode_runtime_head;
};

struct lttng_ust_bytecode_runtime {
	enum lttng_ust_bytecode_type type;
	struct lttng_ust_bytecode_node *bc;
	int link_failed;
	int (*interpreter_func)(struct lttng_ust_bytecode_runtime *bytecode_runtime,
			const char *interpreter_stack_data,
			struct lttng_ust_probe_ctx *probe_ctx,
			void *ctx);
	struct cds_list_head node;		/* list of bytecode runtime in event */
	/*
	 * Pointer to a URCU-protected pointer owned by an `struct
	 * lttng_session`or `struct lttng_event_notifier_group`.
	 */
	struct lttng_ust_ctx **pctx;
};

struct lttng_ust_session_private {
	struct lttng_ust_session *pub;		/* Public session interface */

	int been_active;			/* Been active ? */
	int objd;				/* Object associated */
	struct cds_list_head chan_head;		/* Channel list head */
	struct cds_list_head events_head;	/* list of events */
	struct cds_list_head node;		/* Session list */

	/* List of enablers */
	struct cds_list_head enablers_head;
	struct lttng_ust_event_ht events_ht;	/* ht of events */
	void *owner;				/* object owner */
	int tstate:1;				/* Transient enable state */

	int statedump_pending:1;

	struct lttng_ust_enum_ht enums_ht;	/* ht of enumerations */
	struct cds_list_head enums_head;
	struct lttng_ust_ctx *ctx;		/* contexts for filters. */

	unsigned char uuid[LTTNG_UST_UUID_LEN];	/* Trace session unique ID */
	bool uuid_set;				/* Is uuid set ? */
};

struct lttng_enum {
	const struct lttng_ust_enum_desc *desc;
	struct lttng_ust_session *session;
	struct cds_list_head node;		/* Enum list in session */
	struct cds_hlist_node hlist;		/* Session ht of enums */
	uint64_t id;				/* Enumeration ID in sessiond */
};

struct lttng_ust_shm_handle;

struct lttng_ust_channel_buffer_ops_private {
	struct lttng_ust_channel_buffer_ops *pub;	/* Public channel buffer ops interface */

	struct lttng_ust_channel_buffer *(*channel_create)(const char *name,
			void *buf_addr,
			size_t subbuf_size, size_t num_subbuf,
			unsigned int switch_timer_interval,
			unsigned int read_timer_interval,
			unsigned char *uuid,
			uint32_t chan_id,
			const int *stream_fds, int nr_stream_fds,
			int64_t blocking_timeout);
	void (*channel_destroy)(struct lttng_ust_channel_buffer *chan);
	/*
	 * packet_avail_size returns the available size in the current
	 * packet. Note that the size returned is only a hint, since it
	 * may change due to concurrent writes.
	 */
	size_t (*packet_avail_size)(struct lttng_ust_channel_buffer *chan);
	int (*is_finalized)(struct lttng_ust_channel_buffer *chan);
	int (*is_disabled)(struct lttng_ust_channel_buffer *chan);
	int (*flush_buffer)(struct lttng_ust_channel_buffer *chan);
};

struct lttng_ust_channel_common_private {
	struct lttng_ust_channel_common *pub;	/* Public channel interface */

	int objd;				/* Object associated with channel. */
	int tstate:1;				/* Transient enable state */
};

struct lttng_ust_channel_buffer_private {
	struct lttng_ust_channel_common_private parent;

	struct lttng_ust_channel_buffer *pub;	/* Public channel buffer interface */
	struct cds_list_head node;		/* Channel list in session */
	int header_type;			/* 0: unset, 1: compact, 2: large */
	unsigned int id;			/* Channel ID */
	enum lttng_ust_abi_chan_type type;
	struct lttng_ust_ctx *ctx;
	struct lttng_ust_ring_buffer_channel *rb_chan;	/* Ring buffer channel */
	unsigned char uuid[LTTNG_UST_UUID_LEN];	/* Trace session unique ID */
};

/*
 * IMPORTANT: this structure is part of the ABI between the consumer
 * daemon and the UST library within traced applications. Changing it
 * breaks the UST communication protocol.
 *
 * TODO: remove unused fields on next UST communication protocol
 * breaking update.
 */
struct lttng_ust_abi_channel_config {
	void *unused1;
	int unused2;
	void *unused3;
	void *unused4;
	int unused5;
	struct cds_list_head unused6;
	void *unused7;
	int unused8;
	void *unused9;

	/* Channel ID */
	unsigned int id;
	enum lttng_ust_abi_chan_type unused10;
	unsigned char uuid[LTTNG_UST_UUID_LEN]; /* Trace session unique ID */
	int unused11:1;
};

/* Global (filter), event and channel contexts. */
struct lttng_ust_ctx {
	struct lttng_ust_ctx_field *fields;
	unsigned int nr_fields;
	unsigned int allocated_fields;
	unsigned int largest_align;
};

struct lttng_ust_registered_probe {
	const struct lttng_ust_probe_desc *desc;

	struct cds_list_head head;		/* chain registered probes */
	struct cds_list_head lazy_init_head;
	int lazy;				/* lazy registration */
};

/*
 * Context field
 */

struct lttng_ust_ctx_field {
	const struct lttng_ust_event_field *event_field;
	size_t (*get_size)(void *priv, struct lttng_ust_probe_ctx *probe_ctx,
			size_t offset);
	void (*record)(void *priv, struct lttng_ust_probe_ctx *probe_ctx,
			struct lttng_ust_ring_buffer_ctx *ctx,
			struct lttng_ust_channel_buffer *chan);
	void (*get_value)(void *priv, struct lttng_ust_probe_ctx *probe_ctx,
			struct lttng_ust_ctx_value *value);
	void (*destroy)(void *priv);
	void *priv;
};

static inline
const struct lttng_ust_type_integer *lttng_ust_get_type_integer(const struct lttng_ust_type_common *type)
{
	if (type->type != lttng_ust_type_integer)
		return NULL;
	return caa_container_of(type, const struct lttng_ust_type_integer, parent);
}

static inline
const struct lttng_ust_type_float *lttng_ust_get_type_float(const struct lttng_ust_type_common *type)
{
	if (type->type != lttng_ust_type_float)
		return NULL;
	return caa_container_of(type, const struct lttng_ust_type_float, parent);
}

static inline
const struct lttng_ust_type_string *lttng_ust_get_type_string(const struct lttng_ust_type_common *type)
{
	if (type->type != lttng_ust_type_string)
		return NULL;
	return caa_container_of(type, const struct lttng_ust_type_string, parent);
}

static inline
const struct lttng_ust_type_enum *lttng_ust_get_type_enum(const struct lttng_ust_type_common *type)
{
	if (type->type != lttng_ust_type_enum)
		return NULL;
	return caa_container_of(type, const struct lttng_ust_type_enum, parent);
}

static inline
const struct lttng_ust_type_array *lttng_ust_get_type_array(const struct lttng_ust_type_common *type)
{
	if (type->type != lttng_ust_type_array)
		return NULL;
	return caa_container_of(type, const struct lttng_ust_type_array, parent);
}

static inline
const struct lttng_ust_type_sequence *lttng_ust_get_type_sequence(const struct lttng_ust_type_common *type)
{
	if (type->type != lttng_ust_type_sequence)
		return NULL;
	return caa_container_of(type, const struct lttng_ust_type_sequence, parent);
}

static inline
const struct lttng_ust_type_struct *lttng_ust_get_type_struct(const struct lttng_ust_type_common *type)
{
	if (type->type != lttng_ust_type_struct)
		return NULL;
	return caa_container_of(type, const struct lttng_ust_type_struct, parent);
}

#define lttng_ust_static_type_integer(_size, _alignment, _signedness, _byte_order, _base)		\
	((const struct lttng_ust_type_common *) LTTNG_UST_COMPOUND_LITERAL(const struct lttng_ust_type_integer, { \
		.parent = {										\
			.type = lttng_ust_type_integer,							\
		},											\
		.struct_size = sizeof(struct lttng_ust_type_integer),					\
		.size = (_size),									\
		.alignment = (_alignment),								\
		.signedness = (_signedness),								\
		.reverse_byte_order = (_byte_order) != LTTNG_UST_BYTE_ORDER,					\
		.base = (_base),									\
	}))

#define lttng_ust_static_type_array_text(_length)							\
	((const struct lttng_ust_type_common *) LTTNG_UST_COMPOUND_LITERAL(const struct lttng_ust_type_array, { \
		.parent = {										\
			.type = lttng_ust_type_array,							\
		},											\
		.struct_size = sizeof(struct lttng_ust_type_array),					\
		.length = (_length),									\
		.alignment = 0,										\
		.encoding = lttng_ust_string_encoding_UTF8,						\
		.elem_type = lttng_ust_static_type_integer(sizeof(char) * CHAR_BIT,			\
				lttng_ust_rb_alignof(char) * CHAR_BIT, lttng_ust_is_signed_type(char),	\
				LTTNG_UST_BYTE_ORDER, 10),							\
	}))

#define lttng_ust_static_event_field(_name, _type, _nowrite, _nofilter)					\
	LTTNG_UST_COMPOUND_LITERAL(const struct lttng_ust_event_field, {				\
		.struct_size = sizeof(struct lttng_ust_event_field),					\
		.name = (_name),									\
		.type = (_type),									\
		.nowrite = (_nowrite),									\
		.nofilter = (_nofilter),								\
	})

#define lttng_ust_static_ctx_field(_event_field, _get_size, _record, _get_value, _destroy, _priv)	\
	LTTNG_UST_COMPOUND_LITERAL(const struct lttng_ust_ctx_field, {				\
		.event_field = (_event_field),								\
		.get_size = (_get_size),								\
		.record = (_record),									\
		.get_value = (_get_value),								\
		.destroy = (_destroy),									\
		.priv = (_priv),									\
	})

static inline
struct lttng_enabler *lttng_event_enabler_as_enabler(
		struct lttng_event_enabler *event_enabler)
{
	return &event_enabler->base;
}

static inline
struct lttng_enabler *lttng_event_notifier_enabler_as_enabler(
		struct lttng_event_notifier_enabler *event_notifier_enabler)
{
	return &event_notifier_enabler->base;
}


/* This is ABI between liblttng-ust and liblttng-ust-dl */
void lttng_ust_dl_update(void *ip);

struct lttng_enum *lttng_ust_enum_get_from_desc(struct lttng_ust_session *session,
		const struct lttng_ust_enum_desc *enum_desc)
	__attribute__((visibility("hidden")));


#endif /* _UST_COMMON_UST_EVENTS_H */
Commit	Line	Data
d871c65b	1	/*
c0c0989a	2	* SPDX-License-Identifier: MIT
d871c65b	3	*
c0c0989a	4	* Copyright 2019 (c) Francis Deslauriers <francis.deslauriers@efficios.com>
d871c65b FD	5	*/
d871c65b FD	6
36c52fff MJ	7	#ifndef _UST_COMMON_UST_EVENTS_H
36c52fff MJ	8	#define _UST_COMMON_UST_EVENTS_H
c0c0989a	9
9af5d97a	10	#include <limits.h>
d871c65b FD	11	#include <stdint.h>
	12
	13	#include <urcu/list.h>
	14	#include <urcu/hlist.h>
	15
d871c65b FD	16	#include <lttng/ust-events.h>
d871c65b FD	17
9d315d6d MJ	18	#include "common/macros.h"
9d315d6d MJ	19	#include "common/ust-context-provider.h"
fd17d7ce MD	20
fd17d7ce MD	21	struct lttng_ust_abi_obj;
06cd86a0	22	struct lttng_event_notifier_group;
fd17d7ce MD	23
	24	union lttng_ust_abi_args {
	25	struct {
	26	void *chan_data;
	27	int wakeup_fd;
	28	} channel;
	29	struct {
	30	int shm_fd;
	31	int wakeup_fd;
	32	} stream;
	33	struct {
	34	struct lttng_ust_abi_field_iter entry;
	35	} field_list;
	36	struct {
	37	char *ctxname;
	38	} app_context;
	39	struct {
	40	int event_notifier_notif_fd;
	41	} event_notifier_handle;
	42	struct {
	43	void *counter_data;
	44	} counter;
	45	struct {
	46	int shm_fd;
	47	} counter_shm;
	48	};
	49
	50	struct lttng_ust_abi_objd_ops {
	51	long (*cmd)(int objd, unsigned int cmd, unsigned long arg,
	52	union lttng_ust_abi_args args, void owner);
	53	int (*release)(int objd);
	54	};
	55
8665f6a4 MJ	56	enum lttng_enabler_format_type {
	57	LTTNG_ENABLER_FORMAT_STAR_GLOB,
	58	LTTNG_ENABLER_FORMAT_EVENT,
	59	};
	60
	61	/*
	62	* Enabler field, within whatever object is enabling an event. Target of
	63	* backward reference.
	64	*/
	65	struct lttng_enabler {
	66	enum lttng_enabler_format_type format_type;
	67
	68	/* head list of struct lttng_ust_filter_bytecode_node */
	69	struct cds_list_head filter_bytecode_head;
	70	/* head list of struct lttng_ust_excluder_node */
	71	struct cds_list_head excluder_head;
	72
fd17d7ce	73	struct lttng_ust_abi_event event_param;
8665f6a4 MJ	74	unsigned int enabled:1;
	75	};
	76
d871c65b FD	77	struct lttng_event_enabler {
	78	struct lttng_enabler base;
	79	struct cds_list_head node; /* per-session list of enablers */
e7bc0ef6	80	struct lttng_ust_channel_buffer *chan;
d871c65b FD	81	/*
	82	* Unused, but kept around to make it explicit that the tracer can do
	83	* it.
	84	*/
daacdbfc	85	struct lttng_ust_ctx *ctx;
d871c65b FD	86	};
d871c65b FD	87
d8d2416d FD	88	struct lttng_event_notifier_enabler {
d8d2416d FD	89	struct lttng_enabler base;
6566528b	90	uint64_t error_counter_index;
d37ecb3f FD	91	struct cds_list_head node; /* per-app list of event_notifier enablers */
d37ecb3f FD	92	struct cds_list_head capture_bytecode_head;
d8d2416d FD	93	struct lttng_event_notifier_group group; / weak ref */
d8d2416d FD	94	uint64_t user_token; /* User-provided token */
d37ecb3f	95	uint64_t num_captures;
d8d2416d FD	96	};
d8d2416d FD	97
22c30e27 MD	98	enum lttng_ust_bytecode_type {
	99	LTTNG_UST_BYTECODE_TYPE_FILTER,
	100	LTTNG_UST_BYTECODE_TYPE_CAPTURE,
ab249ecf FD	101	};
	102
	103	struct lttng_ust_bytecode_node {
22c30e27	104	enum lttng_ust_bytecode_type type;
92495593 FD	105	struct cds_list_head node;
92495593 FD	106	struct lttng_enabler *enabler;
ab249ecf FD	107	struct {
	108	uint32_t len;
	109	uint32_t reloc_offset;
	110	uint64_t seqnum;
	111	char data[];
	112	} bc;
92495593 FD	113	};
92495593 FD	114
a2e4d05e MD	115	/*
	116	* Bytecode interpreter return value.
	117	*/
	118	enum lttng_ust_bytecode_interpreter_ret {
	119	LTTNG_UST_BYTECODE_INTERPRETER_ERROR = -1,
	120	LTTNG_UST_BYTECODE_INTERPRETER_OK = 0,
	121	};
	122
	123	struct lttng_interpreter_output;
	124	struct lttng_ust_bytecode_runtime_private;
	125
	126	enum lttng_ust_bytecode_filter_result {
	127	LTTNG_UST_BYTECODE_FILTER_ACCEPT = 0,
	128	LTTNG_UST_BYTECODE_FILTER_REJECT = 1,
	129	};
	130
	131	struct lttng_ust_bytecode_filter_ctx {
	132	enum lttng_ust_bytecode_filter_result result;
	133	};
	134
92495593 FD	135	struct lttng_ust_excluder_node {
	136	struct cds_list_head node;
	137	struct lttng_enabler *enabler;
	138	/*
	139	* struct lttng_ust_event_exclusion had variable sized array,
	140	* must be last field.
	141	*/
fd17d7ce	142	struct lttng_ust_abi_event_exclusion excluder;
92495593 FD	143	};
92495593 FD	144
bb7ad29d MJ	145	/* Data structures used by the tracer. */
	146
	147	struct tp_list_entry {
fd17d7ce	148	struct lttng_ust_abi_tracepoint_iter tp;
bb7ad29d MJ	149	struct cds_list_head head;
	150	};
	151
	152	struct lttng_ust_tracepoint_list {
	153	struct tp_list_entry *iter;
	154	struct cds_list_head head;
	155	};
	156
	157	struct tp_field_list_entry {
fd17d7ce	158	struct lttng_ust_abi_field_iter field;
bb7ad29d MJ	159	struct cds_list_head head;
	160	};
	161
	162	struct lttng_ust_field_list {
	163	struct tp_field_list_entry *iter;
	164	struct cds_list_head head;
	165	};
	166
	167	/*
	168	* Objects in a linked-list of enablers, owned by an event or event_notifier.
	169	* This is used because an event (or a event_notifier) can be enabled by more
	170	* than one enabler and we want a quick way to iterate over all enablers of an
	171	* object.
	172	*
	173	* For example, event rules "my_app:a" and "my_app:ab" will both match the
	174	* event with the name "my_app:abc".
	175	*/
	176	struct lttng_enabler_ref {
	177	struct cds_list_head node; /* enabler ref list */
	178	struct lttng_enabler ref; / backward ref */
	179	};
	180
	181	#define LTTNG_COUNTER_DIMENSION_MAX 8
	182	struct lttng_counter_dimension {
	183	uint64_t size;
	184	uint64_t underflow_index;
	185	uint64_t overflow_index;
	186	uint8_t has_underflow;
	187	uint8_t has_overflow;
	188	};
	189
b5863ea7 MD	190	struct lttng_counter_ops {
	191	struct lib_counter (counter_create)(size_t nr_dimensions,
	192	const struct lttng_counter_dimension *dimensions,
	193	int64_t global_sum_step,
	194	int global_counter_fd,
	195	int nr_counter_cpu_fds,
	196	const int *counter_cpu_fds,
	197	bool is_daemon);
	198	void (counter_destroy)(struct lib_counter counter);
	199	int (counter_add)(struct lib_counter counter,
	200	const size_t *dimension_indexes, int64_t v);
	201	int (counter_read)(struct lib_counter counter,
	202	const size_t *dimension_indexes, int cpu,
	203	int64_t value, bool overflow, bool *underflow);
	204	int (counter_aggregate)(struct lib_counter counter,
	205	const size_t dimension_indexes, int64_t value,
	206	bool overflow, bool underflow);
	207	int (counter_clear)(struct lib_counter counter, const size_t *dimension_indexes);
	208	};
	209
bb7ad29d MJ	210	struct lttng_counter {
	211	int objd;
	212	struct lttng_event_notifier_group event_notifier_group; / owner */
	213	struct lttng_counter_transport *transport;
	214	struct lib_counter *counter;
	215	struct lttng_counter_ops *ops;
	216	};
	217
681f6001 MD	218	#define LTTNG_UST_EVENT_HT_BITS 12
	219	#define LTTNG_UST_EVENT_HT_SIZE (1U << LTTNG_UST_EVENT_HT_BITS)
	220
	221	struct lttng_ust_event_ht {
	222	struct cds_hlist_head table[LTTNG_UST_EVENT_HT_SIZE];
	223	};
	224
	225	#define LTTNG_UST_EVENT_NOTIFIER_HT_BITS 12
	226	#define LTTNG_UST_EVENT_NOTIFIER_HT_SIZE (1U << LTTNG_UST_EVENT_NOTIFIER_HT_BITS)
	227	struct lttng_ust_event_notifier_ht {
	228	struct cds_hlist_head table[LTTNG_UST_EVENT_NOTIFIER_HT_SIZE];
	229	};
	230
	231	#define LTTNG_UST_ENUM_HT_BITS 12
	232	#define LTTNG_UST_ENUM_HT_SIZE (1U << LTTNG_UST_ENUM_HT_BITS)
	233
	234	struct lttng_ust_enum_ht {
	235	struct cds_hlist_head table[LTTNG_UST_ENUM_HT_SIZE];
	236	};
	237
bb7ad29d MJ	238	struct lttng_event_notifier_group {
	239	int objd;
	240	void *owner;
	241	int notification_fd;
	242	struct cds_list_head node; /* Event notifier group handle list */
	243	struct cds_list_head enablers_head;
0c1264b0	244	struct cds_list_head event_notifiers_head; /* list of event_notifiers */
bb7ad29d	245	struct lttng_ust_event_notifier_ht event_notifiers_ht; /* hashtable of event_notifiers */
0c1264b0	246	struct lttng_ust_ctx ctx; / contexts for filters. */
bb7ad29d MJ	247
	248	struct lttng_counter *error_counter;
	249	size_t error_counter_len;
	250	};
	251
	252	struct lttng_transport {
74c3f8e2	253	const char *name;
bb7ad29d	254	struct cds_list_head node;
14b6f891	255	struct lttng_ust_channel_buffer_ops ops;
b5457df5	256	const struct lttng_ust_ring_buffer_config *client_config;
bb7ad29d MJ	257	};
	258
	259	struct lttng_counter_transport {
74c3f8e2	260	const char *name;
bb7ad29d MJ	261	struct cds_list_head node;
	262	struct lttng_counter_ops ops;
	263	const struct lib_counter_config *client_config;
	264	};
	265
80333dfa	266	struct lttng_ust_event_common_private {
7ee76145	267	struct lttng_ust_event_common pub; / Public event interface */
68bb7559	268
4e48b5d2	269	const struct lttng_ust_event_desc *desc;
68bb7559 MD	270	/* Backward references: list of lttng_enabler_ref (ref to enablers) */
68bb7559 MD	271	struct cds_list_head enablers_ref_head;
0c1264b0	272	int registered; /* has reg'd tracepoint probe */
115db533	273	uint64_t user_token;
a2e4d05e MD	274
	275	int has_enablers_without_filter_bytecode;
	276	/* list of struct lttng_ust_bytecode_runtime, sorted by seqnum */
	277	struct cds_list_head filter_bytecode_runtime_head;
68bb7559 MD	278	};
68bb7559 MD	279
2e70391c	280	struct lttng_ust_event_recorder_private {
80333dfa MD	281	struct lttng_ust_event_common_private parent;
80333dfa MD	282
2e70391c	283	struct lttng_ust_event_recorder pub; / Public event interface */
ba99fbe2 MD	284	struct cds_list_head node; /* Event recorder list */
ba99fbe2 MD	285	struct cds_hlist_node hlist; /* Hash table of event recorders */
a40b5b8c	286	struct lttng_ust_ctx *ctx;
8936b6c0	287	unsigned int id;
80333dfa MD	288	};
80333dfa MD	289
115db533 MD	290	struct lttng_ust_event_notifier_private {
	291	struct lttng_ust_event_common_private parent;
	292
d7d45c0d	293	struct lttng_ust_event_notifier pub; / Public event notifier interface */
115db533 MD	294	struct lttng_event_notifier_group group; / weak ref */
	295	size_t num_captures; /* Needed to allocate the msgpack array. */
	296	uint64_t error_counter_index;
ba99fbe2 MD	297	struct cds_list_head node; /* Event notifier list */
ba99fbe2 MD	298	struct cds_hlist_node hlist; /* Hash table of event notifiers */
a2e4d05e	299	struct cds_list_head capture_bytecode_runtime_head;
a2e4d05e	300	};
362a65de	301
a2e4d05e	302	struct lttng_ust_bytecode_runtime {
22c30e27	303	enum lttng_ust_bytecode_type type;
362a65de MD	304	struct lttng_ust_bytecode_node *bc;
362a65de MD	305	int link_failed;
a2e4d05e MD	306	int (interpreter_func)(struct lttng_ust_bytecode_runtime bytecode_runtime,
a2e4d05e MD	307	const char *interpreter_stack_data,
b2e37d27	308	struct lttng_ust_probe_ctx *probe_ctx,
a2e4d05e	309	void *ctx);
0c1264b0	310	struct cds_list_head node; /* list of bytecode runtime in event */
362a65de MD	311	/*
	312	* Pointer to a URCU-protected pointer owned by an `struct
	313	* lttng_session`or `struct lttng_event_notifier_group`.
	314	*/
daacdbfc	315	struct lttng_ust_ctx **pctx;
362a65de MD	316	};
362a65de MD	317
bdb12629	318	struct lttng_ust_session_private {
f69fe5fb	319	struct lttng_ust_session pub; / Public session interface */
bdb12629 MD	320
	321	int been_active; /* Been active ? */
	322	int objd; /* Object associated */
	323	struct cds_list_head chan_head; /* Channel list head */
	324	struct cds_list_head events_head; /* list of events */
	325	struct cds_list_head node; /* Session list */
	326
bdb12629 MD	327	/* List of enablers */
	328	struct cds_list_head enablers_head;
	329	struct lttng_ust_event_ht events_ht; /* ht of events */
	330	void owner; / object owner */
	331	int tstate:1; /* Transient enable state */
	332
bdb12629 MD	333	int statedump_pending:1;
bdb12629 MD	334
bdb12629 MD	335	struct lttng_ust_enum_ht enums_ht; /* ht of enumerations */
bdb12629 MD	336	struct cds_list_head enums_head;
0c1264b0	337	struct lttng_ust_ctx ctx; / contexts for filters. */
9daacd1a MD	338
	339	unsigned char uuid[LTTNG_UST_UUID_LEN]; /* Trace session unique ID */
	340	bool uuid_set; /* Is uuid set ? */
bdb12629 MD	341	};
bdb12629 MD	342
036d17fb	343	struct lttng_enum {
4e48b5d2	344	const struct lttng_ust_enum_desc *desc;
f69fe5fb	345	struct lttng_ust_session *session;
0c1264b0 MD	346	struct cds_list_head node; /* Enum list in session */
	347	struct cds_hlist_node hlist; /* Session ht of enums */
	348	uint64_t id; /* Enumeration ID in sessiond */
036d17fb MD	349	};
036d17fb MD	350
e7bc0ef6 MD	351	struct lttng_ust_shm_handle;
e7bc0ef6 MD	352
14b6f891 MD	353	struct lttng_ust_channel_buffer_ops_private {
14b6f891 MD	354	struct lttng_ust_channel_buffer_ops pub; / Public channel buffer ops interface */
a880bae5	355
e7bc0ef6	356	struct lttng_ust_channel_buffer (channel_create)(const char *name,
a880bae5 MD	357	void *buf_addr,
	358	size_t subbuf_size, size_t num_subbuf,
	359	unsigned int switch_timer_interval,
	360	unsigned int read_timer_interval,
	361	unsigned char *uuid,
	362	uint32_t chan_id,
	363	const int *stream_fds, int nr_stream_fds,
	364	int64_t blocking_timeout);
e7bc0ef6	365	void (channel_destroy)(struct lttng_ust_channel_buffer chan);
a880bae5 MD	366	/*
	367	* packet_avail_size returns the available size in the current
	368	* packet. Note that the size returned is only a hint, since it
	369	* may change due to concurrent writes.
	370	*/
07539b34 MD	371	size_t (packet_avail_size)(struct lttng_ust_channel_buffer chan);
	372	int (is_finalized)(struct lttng_ust_channel_buffer chan);
	373	int (is_disabled)(struct lttng_ust_channel_buffer chan);
	374	int (flush_buffer)(struct lttng_ust_channel_buffer chan);
a880bae5 MD	375	};
a880bae5 MD	376
e7bc0ef6 MD	377	struct lttng_ust_channel_common_private {
	378	struct lttng_ust_channel_common pub; / Public channel interface */
	379
0c1264b0 MD	380	int objd; /* Object associated with channel. */
0c1264b0 MD	381	int tstate:1; /* Transient enable state */
e7bc0ef6 MD	382	};
	383
	384	struct lttng_ust_channel_buffer_private {
	385	struct lttng_ust_channel_common_private parent;
	386
	387	struct lttng_ust_channel_buffer pub; / Public channel buffer interface */
0c1264b0 MD	388	struct cds_list_head node; /* Channel list in session */
	389	int header_type; /* 0: unset, 1: compact, 2: large */
	390	unsigned int id; /* Channel ID */
e7bc0ef6	391	enum lttng_ust_abi_chan_type type;
0950190a	392	struct lttng_ust_ctx *ctx;
b5457df5	393	struct lttng_ust_ring_buffer_channel rb_chan; / Ring buffer channel */
e7bc0ef6 MD	394	unsigned char uuid[LTTNG_UST_UUID_LEN]; /* Trace session unique ID */
	395	};
	396
f0fde1c3 MD	397	/*
	398	* IMPORTANT: this structure is part of the ABI between the consumer
	399	* daemon and the UST library within traced applications. Changing it
	400	* breaks the UST communication protocol.
	401	*
	402	* TODO: remove unused fields on next UST communication protocol
	403	* breaking update.
	404	*/
	405	struct lttng_ust_abi_channel_config {
	406	void *unused1;
	407	int unused2;
	408	void *unused3;
	409	void *unused4;
	410	int unused5;
	411	struct cds_list_head unused6;
	412	void *unused7;
	413	int unused8;
	414	void *unused9;
	415
	416	/* Channel ID */
	417	unsigned int id;
	418	enum lttng_ust_abi_chan_type unused10;
	419	unsigned char uuid[LTTNG_UST_UUID_LEN]; /* Trace session unique ID */
	420	int unused11:1;
	421	};
	422
4e48b5d2 MD	423	/* Global (filter), event and channel contexts. */
	424	struct lttng_ust_ctx {
	425	struct lttng_ust_ctx_field *fields;
	426	unsigned int nr_fields;
	427	unsigned int allocated_fields;
	428	unsigned int largest_align;
	429	};
	430
	431	struct lttng_ust_registered_probe {
	432	const struct lttng_ust_probe_desc *desc;
	433
	434	struct cds_list_head head; /* chain registered probes */
	435	struct cds_list_head lazy_init_head;
	436	int lazy; /* lazy registration */
	437	};
	438
	439	/*
	440	* Context field
	441	*/
	442
	443	struct lttng_ust_ctx_field {
	444	const struct lttng_ust_event_field *event_field;
b2e37d27 MD	445	size_t (get_size)(void priv, struct lttng_ust_probe_ctx *probe_ctx,
	446	size_t offset);
	447	void (record)(void priv, struct lttng_ust_probe_ctx *probe_ctx,
	448	struct lttng_ust_ring_buffer_ctx *ctx,
	449	struct lttng_ust_channel_buffer *chan);
	450	void (get_value)(void priv, struct lttng_ust_probe_ctx *probe_ctx,
	451	struct lttng_ust_ctx_value *value);
4e48b5d2 MD	452	void (destroy)(void priv);
	453	void *priv;
	454	};
	455
a084756d	456	static inline
4e48b5d2	457	const struct lttng_ust_type_integer lttng_ust_get_type_integer(const struct lttng_ust_type_common type)
a084756d MD	458	{
	459	if (type->type != lttng_ust_type_integer)
	460	return NULL;
4e48b5d2	461	return caa_container_of(type, const struct lttng_ust_type_integer, parent);
a084756d MD	462	}
	463
	464	static inline
4e48b5d2	465	const struct lttng_ust_type_float lttng_ust_get_type_float(const struct lttng_ust_type_common type)
a084756d MD	466	{
	467	if (type->type != lttng_ust_type_float)
	468	return NULL;
4e48b5d2	469	return caa_container_of(type, const struct lttng_ust_type_float, parent);
a084756d MD	470	}
	471
	472	static inline
4e48b5d2	473	const struct lttng_ust_type_string lttng_ust_get_type_string(const struct lttng_ust_type_common type)
a084756d MD	474	{
	475	if (type->type != lttng_ust_type_string)
	476	return NULL;
4e48b5d2	477	return caa_container_of(type, const struct lttng_ust_type_string, parent);
a084756d MD	478	}
	479
	480	static inline
4e48b5d2	481	const struct lttng_ust_type_enum lttng_ust_get_type_enum(const struct lttng_ust_type_common type)
a084756d MD	482	{
	483	if (type->type != lttng_ust_type_enum)
	484	return NULL;
4e48b5d2	485	return caa_container_of(type, const struct lttng_ust_type_enum, parent);
a084756d MD	486	}
	487
	488	static inline
4e48b5d2	489	const struct lttng_ust_type_array lttng_ust_get_type_array(const struct lttng_ust_type_common type)
a084756d MD	490	{
	491	if (type->type != lttng_ust_type_array)
	492	return NULL;
4e48b5d2	493	return caa_container_of(type, const struct lttng_ust_type_array, parent);
a084756d MD	494	}
	495
	496	static inline
4e48b5d2	497	const struct lttng_ust_type_sequence lttng_ust_get_type_sequence(const struct lttng_ust_type_common type)
a084756d MD	498	{
	499	if (type->type != lttng_ust_type_sequence)
	500	return NULL;
4e48b5d2	501	return caa_container_of(type, const struct lttng_ust_type_sequence, parent);
a084756d MD	502	}
	503
	504	static inline
4e48b5d2	505	const struct lttng_ust_type_struct lttng_ust_get_type_struct(const struct lttng_ust_type_common type)
a084756d MD	506	{
	507	if (type->type != lttng_ust_type_struct)
	508	return NULL;
4e48b5d2	509	return caa_container_of(type, const struct lttng_ust_type_struct, parent);
a084756d MD	510	}
a084756d MD	511
4e48b5d2	512	#define lttng_ust_static_type_integer(_size, _alignment, _signedness, _byte_order, _base) \
5defa774	513	((const struct lttng_ust_type_common *) LTTNG_UST_COMPOUND_LITERAL(const struct lttng_ust_type_integer, { \
4e48b5d2 MD	514	.parent = { \
	515	.type = lttng_ust_type_integer, \
	516	}, \
	517	.struct_size = sizeof(struct lttng_ust_type_integer), \
	518	.size = (_size), \
	519	.alignment = (_alignment), \
	520	.signedness = (_signedness), \
baa8acf3	521	.reverse_byte_order = (_byte_order) != LTTNG_UST_BYTE_ORDER, \
4e48b5d2 MD	522	.base = (_base), \
	523	}))
	524
	525	#define lttng_ust_static_type_array_text(_length) \
5defa774	526	((const struct lttng_ust_type_common *) LTTNG_UST_COMPOUND_LITERAL(const struct lttng_ust_type_array, { \
4e48b5d2 MD	527	.parent = { \
	528	.type = lttng_ust_type_array, \
	529	}, \
	530	.struct_size = sizeof(struct lttng_ust_type_array), \
	531	.length = (_length), \
	532	.alignment = 0, \
	533	.encoding = lttng_ust_string_encoding_UTF8, \
	534	.elem_type = lttng_ust_static_type_integer(sizeof(char) * CHAR_BIT, \
	535	lttng_ust_rb_alignof(char) * CHAR_BIT, lttng_ust_is_signed_type(char), \
baa8acf3	536	LTTNG_UST_BYTE_ORDER, 10), \
4e48b5d2 MD	537	}))
	538
	539	#define lttng_ust_static_event_field(_name, _type, _nowrite, _nofilter) \
5defa774	540	LTTNG_UST_COMPOUND_LITERAL(const struct lttng_ust_event_field, { \
4e48b5d2 MD	541	.struct_size = sizeof(struct lttng_ust_event_field), \
	542	.name = (_name), \
	543	.type = (_type), \
	544	.nowrite = (_nowrite), \
	545	.nofilter = (_nofilter), \
	546	})
	547
	548	#define lttng_ust_static_ctx_field(_event_field, _get_size, _record, _get_value, _destroy, _priv) \
5defa774	549	LTTNG_UST_COMPOUND_LITERAL(const struct lttng_ust_ctx_field, { \
4e48b5d2 MD	550	.event_field = (_event_field), \
	551	.get_size = (_get_size), \
	552	.record = (_record), \
	553	.get_value = (_get_value), \
	554	.destroy = (_destroy), \
	555	.priv = (_priv), \
	556	})
a084756d	557
d871c65b FD	558	static inline
	559	struct lttng_enabler *lttng_event_enabler_as_enabler(
	560	struct lttng_event_enabler *event_enabler)
	561	{
	562	return &event_enabler->base;
	563	}
	564
d8d2416d FD	565	static inline
	566	struct lttng_enabler *lttng_event_notifier_enabler_as_enabler(
	567	struct lttng_event_notifier_enabler *event_notifier_enabler)
	568	{
	569	return &event_notifier_enabler->base;
	570	}
d871c65b	571
d8d2416d	572
7753d283	573
cbba5e04 MJ	574	/* This is ABI between liblttng-ust and liblttng-ust-dl */
	575	void lttng_ust_dl_update(void *ip);
	576
f69fe5fb	577	struct lttng_enum lttng_ust_enum_get_from_desc(struct lttng_ust_session session,
4e48b5d2	578	const struct lttng_ust_enum_desc *enum_desc)
1d18d519	579	__attribute__((visibility("hidden")));
7753d283	580
4e48b5d2	581
36c52fff	582	#endif /* _UST_COMMON_UST_EVENTS_H */