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

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

#ifndef _LTTNG_EVENTS_INTERNAL_H
#define _LTTNG_EVENTS_INTERNAL_H

#include <lttng/events.h>

struct lttng_kernel_event_common_private {
	struct lttng_kernel_event_common *pub;		/* Public event interface */

	const struct lttng_kernel_event_desc *desc;
	/* Backward references: list of lttng_enabler_ref (ref to enablers) */
	struct 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_bytecode_runtime, sorted by seqnum */
	struct list_head filter_bytecode_runtime_head;
	enum lttng_kernel_abi_instrumentation instrumentation;
	/* Selected by instrumentation */
	union {
		struct lttng_kprobe kprobe;
		struct lttng_uprobe uprobe;
		struct {
			struct lttng_krp *lttng_krp;
			char *symbol_name;
		} kretprobe;
		struct {
			enum lttng_syscall_entryexit entryexit;
			enum lttng_syscall_abi abi;
			struct hlist_node node;			/* chain registered syscall event_notifier */
			unsigned int syscall_id;
		} syscall;
	} u;
};

struct lttng_kernel_event_recorder_private {
	struct lttng_kernel_event_common_private parent;

	struct lttng_kernel_event_recorder *pub;	/* Public event interface */
	struct list_head node;				/* Event recorder list */
	struct hlist_node hlist;			/* Hash table of event recorders */
	struct lttng_kernel_ctx *ctx;
	unsigned int id;
	unsigned int metadata_dumped:1;
};

struct lttng_kernel_event_notifier_private {
	struct lttng_kernel_event_common_private parent;

	struct lttng_kernel_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 list_head node;				/* Event notifier list */
	struct hlist_node hlist;			/* Hash table of event notifiers */
	struct list_head capture_bytecode_runtime_head;

};

enum lttng_kernel_bytecode_interpreter_ret {
	LTTNG_KERNEL_BYTECODE_INTERPRETER_ERROR = -1,
	LTTNG_KERNEL_BYTECODE_INTERPRETER_OK = 0,
};

enum lttng_kernel_bytecode_filter_result {
	LTTNG_KERNEL_BYTECODE_FILTER_ACCEPT = 0,
	LTTNG_KERNEL_BYTECODE_FILTER_REJECT = 1,
};

struct lttng_kernel_bytecode_filter_ctx {
	enum lttng_kernel_bytecode_filter_result result;
};

/*
 * 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_bytecode_node */
	struct list_head filter_bytecode_head;

	struct lttng_kernel_abi_event event_param;
	unsigned int enabled:1;

	uint64_t user_token;		/* User-provided token. */
};

struct lttng_event_enabler {
	struct lttng_enabler base;
	struct list_head node;	/* per-session list of enablers */
	struct lttng_channel *chan;
};

struct lttng_event_notifier_enabler {
	struct lttng_enabler base;
	uint64_t error_counter_index;
	struct list_head node;	/* List of event_notifier enablers */
	struct lttng_event_notifier_group *group;

	/* head list of struct lttng_bytecode_node */
	struct list_head capture_bytecode_head;
	uint64_t num_captures;
};

static inline
const struct lttng_kernel_type_integer *lttng_kernel_get_type_integer(const struct lttng_kernel_type_common *type)
{
	if (type->type != lttng_kernel_type_integer)
		return NULL;
	return container_of(type, const struct lttng_kernel_type_integer, parent);
}

static inline
const struct lttng_kernel_type_string *lttng_kernel_get_type_string(const struct lttng_kernel_type_common *type)
{
	if (type->type != lttng_kernel_type_string)
		return NULL;
	return container_of(type, const struct lttng_kernel_type_string, parent);
}

static inline
const struct lttng_kernel_type_enum *lttng_kernel_get_type_enum(const struct lttng_kernel_type_common *type)
{
	if (type->type != lttng_kernel_type_enum)
		return NULL;
	return container_of(type, const struct lttng_kernel_type_enum, parent);
}

static inline
const struct lttng_kernel_type_array *lttng_kernel_get_type_array(const struct lttng_kernel_type_common *type)
{
	if (type->type != lttng_kernel_type_array)
		return NULL;
	return container_of(type, const struct lttng_kernel_type_array, parent);
}

static inline
const struct lttng_kernel_type_sequence *lttng_kernel_get_type_sequence(const struct lttng_kernel_type_common *type)
{
	if (type->type != lttng_kernel_type_sequence)
		return NULL;
	return container_of(type, const struct lttng_kernel_type_sequence, parent);
}

static inline
const struct lttng_kernel_type_struct *lttng_kernel_get_type_struct(const struct lttng_kernel_type_common *type)
{
	if (type->type != lttng_kernel_type_struct)
		return NULL;
	return container_of(type, const struct lttng_kernel_type_struct, parent);
}

static inline
const struct lttng_kernel_type_variant *lttng_kernel_get_type_variant(const struct lttng_kernel_type_common *type)
{
	if (type->type != lttng_kernel_type_variant)
		return NULL;
	return container_of(type, const struct lttng_kernel_type_variant, parent);
}

static inline bool lttng_kernel_type_is_bytewise_integer(const struct lttng_kernel_type_common *type)
{
	const struct lttng_kernel_type_integer *type_integer = lttng_kernel_get_type_integer(type);

	if (!type_integer)
		return false;
	switch (type_integer->size) {
	case 8:		/* Fall-through. */
	case 16:	/* Fall-through. */
	case 32:	/* Fall-through. */
	case 64:
		break;
	default:
		return false;
	}
	return true;
}

int lttng_kernel_interpret_event_filter(const struct lttng_kernel_event_common *event,
		const char *interpreter_stack_data,
		struct lttng_probe_ctx *probe_ctx,
		void *event_filter_ctx);

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

#endif /* _LTTNG_EVENTS_INTERNAL_H */
Commit	Line	Data
92bc1e23 MD	1	/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
	2	*
	3	* lttng/events-internal.h
	4	*
	5	* Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	6	*/
	7
	8	#ifndef _LTTNG_EVENTS_INTERNAL_H
	9	#define _LTTNG_EVENTS_INTERNAL_H
	10
437d5aa5 MD	11	#include <lttng/events.h>
437d5aa5 MD	12
a67ba386 MD	13	struct lttng_kernel_event_common_private {
	14	struct lttng_kernel_event_common pub; / Public event interface */
	15
	16	const struct lttng_kernel_event_desc *desc;
	17	/* Backward references: list of lttng_enabler_ref (ref to enablers) */
	18	struct list_head enablers_ref_head;
	19	int registered; /* has reg'd tracepoint probe */
	20	uint64_t user_token;
	21
	22	int has_enablers_without_filter_bytecode;
8a445457	23	/* list of struct lttng_bytecode_runtime, sorted by seqnum */
a67ba386 MD	24	struct list_head filter_bytecode_runtime_head;
	25	enum lttng_kernel_abi_instrumentation instrumentation;
	26	/* Selected by instrumentation */
	27	union {
	28	struct lttng_kprobe kprobe;
	29	struct lttng_uprobe uprobe;
	30	struct {
	31	struct lttng_krp *lttng_krp;
	32	char *symbol_name;
	33	} kretprobe;
	34	struct {
	35	enum lttng_syscall_entryexit entryexit;
	36	enum lttng_syscall_abi abi;
	37	struct hlist_node node; /* chain registered syscall event_notifier */
	38	unsigned int syscall_id;
	39	} syscall;
	40	} u;
	41	};
	42
	43	struct lttng_kernel_event_recorder_private {
	44	struct lttng_kernel_event_common_private parent;
	45
	46	struct lttng_kernel_event_recorder pub; / Public event interface */
	47	struct list_head node; /* Event recorder list */
	48	struct hlist_node hlist; /* Hash table of event recorders */
	49	struct lttng_kernel_ctx *ctx;
	50	unsigned int id;
	51	unsigned int metadata_dumped:1;
	52	};
	53
	54	struct lttng_kernel_event_notifier_private {
	55	struct lttng_kernel_event_common_private parent;
	56
	57	struct lttng_kernel_event_notifier pub; / Public event notifier interface */
	58	struct lttng_event_notifier_group group; / weak ref */
	59	size_t num_captures; /* Needed to allocate the msgpack array. */
	60	uint64_t error_counter_index;
	61	struct list_head node; /* Event notifier list */
	62	struct hlist_node hlist; /* Hash table of event notifiers */
	63	struct list_head capture_bytecode_runtime_head;
	64
	65	};
	66
8a445457 MD	67	enum lttng_kernel_bytecode_interpreter_ret {
	68	LTTNG_KERNEL_BYTECODE_INTERPRETER_ERROR = -1,
	69	LTTNG_KERNEL_BYTECODE_INTERPRETER_OK = 0,
	70	};
	71
	72	enum lttng_kernel_bytecode_filter_result {
	73	LTTNG_KERNEL_BYTECODE_FILTER_ACCEPT = 0,
	74	LTTNG_KERNEL_BYTECODE_FILTER_REJECT = 1,
	75	};
	76
	77	struct lttng_kernel_bytecode_filter_ctx {
	78	enum lttng_kernel_bytecode_filter_result result;
	79	};
	80
5e08a34f MD	81	/*
	82	* Enabler field, within whatever object is enabling an event. Target of
	83	* backward reference.
	84	*/
	85	struct lttng_enabler {
	86	enum lttng_enabler_format_type format_type;
	87
	88	/* head list of struct lttng_bytecode_node */
	89	struct list_head filter_bytecode_head;
	90
	91	struct lttng_kernel_abi_event event_param;
	92	unsigned int enabled:1;
	93
	94	uint64_t user_token; /* User-provided token. */
	95	};
	96
	97	struct lttng_event_enabler {
	98	struct lttng_enabler base;
	99	struct list_head node; /* per-session list of enablers */
	100	struct lttng_channel *chan;
	101	};
	102
	103	struct lttng_event_notifier_enabler {
	104	struct lttng_enabler base;
	105	uint64_t error_counter_index;
	106	struct list_head node; /* List of event_notifier enablers */
	107	struct lttng_event_notifier_group *group;
	108
	109	/* head list of struct lttng_bytecode_node */
	110	struct list_head capture_bytecode_head;
	111	uint64_t num_captures;
	112	};
	113
437d5aa5 MD	114	static inline
	115	const struct lttng_kernel_type_integer lttng_kernel_get_type_integer(const struct lttng_kernel_type_common type)
	116	{
	117	if (type->type != lttng_kernel_type_integer)
	118	return NULL;
	119	return container_of(type, const struct lttng_kernel_type_integer, parent);
	120	}
	121
	122	static inline
	123	const struct lttng_kernel_type_string lttng_kernel_get_type_string(const struct lttng_kernel_type_common type)
	124	{
	125	if (type->type != lttng_kernel_type_string)
	126	return NULL;
	127	return container_of(type, const struct lttng_kernel_type_string, parent);
	128	}
	129
	130	static inline
	131	const struct lttng_kernel_type_enum lttng_kernel_get_type_enum(const struct lttng_kernel_type_common type)
	132	{
	133	if (type->type != lttng_kernel_type_enum)
	134	return NULL;
	135	return container_of(type, const struct lttng_kernel_type_enum, parent);
	136	}
	137
	138	static inline
	139	const struct lttng_kernel_type_array lttng_kernel_get_type_array(const struct lttng_kernel_type_common type)
	140	{
	141	if (type->type != lttng_kernel_type_array)
	142	return NULL;
	143	return container_of(type, const struct lttng_kernel_type_array, parent);
	144	}
	145
	146	static inline
	147	const struct lttng_kernel_type_sequence lttng_kernel_get_type_sequence(const struct lttng_kernel_type_common type)
	148	{
	149	if (type->type != lttng_kernel_type_sequence)
	150	return NULL;
	151	return container_of(type, const struct lttng_kernel_type_sequence, parent);
	152	}
	153
	154	static inline
	155	const struct lttng_kernel_type_struct lttng_kernel_get_type_struct(const struct lttng_kernel_type_common type)
	156	{
	157	if (type->type != lttng_kernel_type_struct)
	158	return NULL;
	159	return container_of(type, const struct lttng_kernel_type_struct, parent);
	160	}
	161
	162	static inline
	163	const struct lttng_kernel_type_variant lttng_kernel_get_type_variant(const struct lttng_kernel_type_common type)
	164	{
	165	if (type->type != lttng_kernel_type_variant)
	166	return NULL;
	167	return container_of(type, const struct lttng_kernel_type_variant, parent);
	168	}
	169
	170	static inline bool lttng_kernel_type_is_bytewise_integer(const struct lttng_kernel_type_common *type)
	171	{
	172	const struct lttng_kernel_type_integer *type_integer = lttng_kernel_get_type_integer(type);
	173
	174	if (!type_integer)
	175	return false;
	176	switch (type_integer->size) {
	177	case 8: /* Fall-through. */
178	case 16: /* Fall-through. */
179	case 32: /* Fall-through. */
180	case 64:
181	break;
182	default:
183	return false;
184	}
185	return true;
186	}
187
8a445457 MD	188	int lttng_kernel_interpret_event_filter(const struct lttng_kernel_event_common *event,
	189	const char *interpreter_stack_data,
	190	struct lttng_probe_ctx *probe_ctx,
	191	void *event_filter_ctx);
	192
5e08a34f MD	193	static inline
	194	struct lttng_enabler *lttng_event_enabler_as_enabler(
	195	struct lttng_event_enabler *event_enabler)
	196	{
	197	return &event_enabler->base;
	198	}
	199
	200	static inline
	201	struct lttng_enabler *lttng_event_notifier_enabler_as_enabler(
	202	struct lttng_event_notifier_enabler *event_notifier_enabler)
	203	{
	204	return &event_notifier_enabler->base;
	205	}
	206
92bc1e23	207	#endif /* _LTTNG_EVENTS_INTERNAL_H */