[lttng-tools.git] / include / lttng / trigger / trigger-internal.h

/*
 * Copyright (C) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 */

#ifndef LTTNG_TRIGGER_INTERNAL_H
#define LTTNG_TRIGGER_INTERNAL_H

#include <common/credentials.h>
#include <common/dynamic-array.h>
#include <common/macros.h>
#include <common/optional.h>
#include <lttng/lttng.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdint.h>
#include <sys/types.h>
#include <urcu/ref.h>

struct lttng_payload;
struct lttng_payload_view;

struct lttng_trigger {
	/* Reference counting is only exposed to internal users. */
	struct urcu_ref ref;

	struct lttng_condition *condition;
	struct lttng_action *action;
	char *name;
	/* For now only the uid portion of the credentials is used. */
	struct lttng_credentials creds;
	/*
	 * Internal use only.
	 * The unique token passed to the tracer to identify an event-rule
	 * notification.
	 */
	LTTNG_OPTIONAL(uint64_t) tracer_token;

	/*
	 * Is the trigger registered?
	 *
	 * This is necessary since a reference holder might be interested in the
	 * overall state of the trigger from the point of view of its owner.
	 *
	 * The main user is the action executor since we want to prevent the
	 * execution of actions related to a trigger that is unregistered.
	 *
	 * Not considered for `is_equal`.
	 */
	bool registered;

	/*
	 * The lock is used to protect against concurrent trigger execution and
	 * trigger removal.
	 */
	pthread_mutex_t lock;
};

struct lttng_triggers {
	struct lttng_dynamic_pointer_array array;
};

struct lttng_trigger_comm {
	/*
	 * Credentials, only the uid portion is used for now.
	 * Used as an override when desired by the root user.
	 */
	uint64_t uid;
	/*
	 * Length of the variable length payload (name, condition, and
	 * an action).
	 */
	uint32_t length;
	/* Includes '\0' terminator. */
	uint32_t name_length;
	/* A null-terminated name, a condition, and an action follow. */
	char payload[];
} LTTNG_PACKED;

struct lttng_triggers_comm {
	uint32_t count;
	uint32_t length;
	/* Count * lttng_trigger_comm structure */
	char payload[];
};

LTTNG_HIDDEN
ssize_t lttng_trigger_create_from_payload(struct lttng_payload_view *view,
		struct lttng_trigger **trigger);

LTTNG_HIDDEN
int lttng_trigger_serialize(const struct lttng_trigger *trigger,
		struct lttng_payload *payload);

LTTNG_HIDDEN
bool lttng_trigger_validate(const struct lttng_trigger *trigger);

LTTNG_HIDDEN
int lttng_trigger_assign_name(
		struct lttng_trigger *dst, const struct lttng_trigger *src);

LTTNG_HIDDEN
void lttng_trigger_set_tracer_token(
		struct lttng_trigger *trigger, uint64_t token);

LTTNG_HIDDEN
uint64_t lttng_trigger_get_tracer_token(const struct lttng_trigger *trigger);

LTTNG_HIDDEN
int lttng_trigger_generate_name(struct lttng_trigger *trigger,
		uint64_t unique_id);

LTTNG_HIDDEN
bool lttng_trigger_is_equal(
		const struct lttng_trigger *a, const struct lttng_trigger *b);

LTTNG_HIDDEN
void lttng_trigger_get(struct lttng_trigger *trigger);

LTTNG_HIDDEN
void lttng_trigger_put(struct lttng_trigger *trigger);

/*
 * Allocate a new set of triggers.
 * The returned object must be freed via lttng_triggers_destroy.
 */
LTTNG_HIDDEN
struct lttng_triggers *lttng_triggers_create(void);

/*
 * Return the a pointer to a mutable element at index "index" of an
 * lttng_triggers set.
 *
 * This differs from the public `lttng_triggers_get_at_index` in that
 * the returned pointer to a mutable trigger.
 *
 * The ownership of the trigger set element is NOT transfered.
 * The returned object can NOT be freed via lttng_trigger_destroy.
 */
LTTNG_HIDDEN
struct lttng_trigger *lttng_triggers_borrow_mutable_at_index(
		const struct lttng_triggers *triggers, unsigned int index);

/*
 * Add a trigger to the triggers set.
 *
 * A reference to the added trigger is acquired on behalf of the trigger set
 * on success.
 */
LTTNG_HIDDEN
int lttng_triggers_add(
		struct lttng_triggers *triggers, struct lttng_trigger *trigger);

/*
 * Serialize a trigger set to an lttng_payload object.
 * Return LTTNG_OK on success, negative lttng error code on error.
 */
LTTNG_HIDDEN
int lttng_triggers_serialize(const struct lttng_triggers *triggers,
		struct lttng_payload *payload);

LTTNG_HIDDEN
ssize_t lttng_triggers_create_from_payload(struct lttng_payload_view *view,
		struct lttng_triggers **triggers);

LTTNG_HIDDEN
const struct lttng_credentials *lttng_trigger_get_credentials(
		const struct lttng_trigger *trigger);

LTTNG_HIDDEN
void lttng_trigger_set_credentials(struct lttng_trigger *trigger,
		const struct lttng_credentials *creds);

/*
 * Return the type of any underlying domain restriction. If no particular
 * requirement is present, returns LTTNG_DOMAIN_NONE.
 */
LTTNG_HIDDEN
enum lttng_domain_type lttng_trigger_get_underlying_domain_type_restriction(
		const struct lttng_trigger *trigger);

/*
 * Generate any bytecode related to the trigger.
 * On success LTTNG_OK. On error, returns lttng_error code.
 */
LTTNG_HIDDEN
enum lttng_error_code lttng_trigger_generate_bytecode(
		struct lttng_trigger *trigger,
		const struct lttng_credentials *creds);

LTTNG_HIDDEN
struct lttng_trigger *lttng_trigger_copy(const struct lttng_trigger *trigger);

/*
 * A given trigger needs a tracer notifier if
 *  it has an event-rule condition,
 *  AND
 *  it has one or more sessiond-execution action.
 */
LTTNG_HIDDEN
bool lttng_trigger_needs_tracer_notifier(const struct lttng_trigger *trigger);

LTTNG_HIDDEN
void lttng_trigger_set_as_registered(struct lttng_trigger *trigger);

LTTNG_HIDDEN
void lttng_trigger_set_as_unregistered(struct lttng_trigger *trigger);

/*
 * The trigger must be locked before calling lttng_trigger_is_registered.
 *
 * The lock is necessary since a trigger can be unregistered at any time.
 *
 * Manipulations requiring that the trigger be registered must always acquire
 * the trigger lock for the duration of the manipulation using
 * `lttng_trigger_lock` and `lttng_trigger_unlock`.
 */
LTTNG_HIDDEN
bool lttng_trigger_is_registered(struct lttng_trigger *trigger);

LTTNG_HIDDEN
void lttng_trigger_lock(struct lttng_trigger *trigger);

LTTNG_HIDDEN
void lttng_trigger_unlock(struct lttng_trigger *trigger);

LTTNG_HIDDEN
enum lttng_trigger_status lttng_trigger_add_error_results(
		const struct lttng_trigger *trigger,
		struct lttng_error_query_results *results);

LTTNG_HIDDEN
enum lttng_trigger_status lttng_trigger_add_action_error_query_results(
		struct lttng_trigger *trigger,
		struct lttng_error_query_results *results);

#endif /* LTTNG_TRIGGER_INTERNAL_H */
Commit	Line	Data
	1	/*
	2	* Copyright (C) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	3	*
	4	* SPDX-License-Identifier: LGPL-2.1-only
	5	*
	6	*/
	7
	8	#ifndef LTTNG_TRIGGER_INTERNAL_H
	9	#define LTTNG_TRIGGER_INTERNAL_H
	10
	11	#include <common/credentials.h>
	12	#include <common/dynamic-array.h>
	13	#include <common/macros.h>
	14	#include <common/optional.h>
	15	#include <lttng/lttng.h>
	16	#include <pthread.h>
	17	#include <stdbool.h>
	18	#include <stdint.h>
	19	#include <sys/types.h>
	20	#include <urcu/ref.h>
	21
	22	struct lttng_payload;
	23	struct lttng_payload_view;
	24
	25	struct lttng_trigger {
	26	/* Reference counting is only exposed to internal users. */
	27	struct urcu_ref ref;
	28
	29	struct lttng_condition *condition;
	30	struct lttng_action *action;
	31	char *name;
	32	/* For now only the uid portion of the credentials is used. */
	33	struct lttng_credentials creds;
	34	/*
	35	* Internal use only.
	36	* The unique token passed to the tracer to identify an event-rule
	37	* notification.
	38	*/
	39	LTTNG_OPTIONAL(uint64_t) tracer_token;
	40
	41	/*
	42	* Is the trigger registered?
	43	*
	44	* This is necessary since a reference holder might be interested in the
	45	* overall state of the trigger from the point of view of its owner.
	46	*
	47	* The main user is the action executor since we want to prevent the
	48	* execution of actions related to a trigger that is unregistered.
	49	*
	50	* Not considered for `is_equal`.
	51	*/
	52	bool registered;
	53
	54	/*
	55	* The lock is used to protect against concurrent trigger execution and
	56	* trigger removal.
	57	*/
	58	pthread_mutex_t lock;
	59	};
	60
	61	struct lttng_triggers {
	62	struct lttng_dynamic_pointer_array array;
	63	};
	64
	65	struct lttng_trigger_comm {
	66	/*
	67	* Credentials, only the uid portion is used for now.
	68	* Used as an override when desired by the root user.
	69	*/
	70	uint64_t uid;
	71	/*
	72	* Length of the variable length payload (name, condition, and
	73	* an action).
	74	*/
	75	uint32_t length;
	76	/* Includes '\0' terminator. */
	77	uint32_t name_length;
	78	/* A null-terminated name, a condition, and an action follow. */
	79	char payload[];
	80	} LTTNG_PACKED;
	81
	82	struct lttng_triggers_comm {
	83	uint32_t count;
	84	uint32_t length;
	85	/* Count * lttng_trigger_comm structure */
	86	char payload[];
	87	};
	88
	89	LTTNG_HIDDEN
	90	ssize_t lttng_trigger_create_from_payload(struct lttng_payload_view *view,
	91	struct lttng_trigger **trigger);
	92
	93	LTTNG_HIDDEN
	94	int lttng_trigger_serialize(const struct lttng_trigger *trigger,
	95	struct lttng_payload *payload);
	96
	97	LTTNG_HIDDEN
	98	bool lttng_trigger_validate(const struct lttng_trigger *trigger);
	99
	100	LTTNG_HIDDEN
	101	int lttng_trigger_assign_name(
	102	struct lttng_trigger dst, const struct lttng_trigger src);
	103
	104	LTTNG_HIDDEN
	105	void lttng_trigger_set_tracer_token(
	106	struct lttng_trigger *trigger, uint64_t token);
	107
	108	LTTNG_HIDDEN
	109	uint64_t lttng_trigger_get_tracer_token(const struct lttng_trigger *trigger);
	110
	111	LTTNG_HIDDEN
	112	int lttng_trigger_generate_name(struct lttng_trigger *trigger,
	113	uint64_t unique_id);
	114
	115	LTTNG_HIDDEN
	116	bool lttng_trigger_is_equal(
	117	const struct lttng_trigger a, const struct lttng_trigger b);
	118
	119	LTTNG_HIDDEN
	120	void lttng_trigger_get(struct lttng_trigger *trigger);
	121
	122	LTTNG_HIDDEN
	123	void lttng_trigger_put(struct lttng_trigger *trigger);
	124
	125	/*
	126	* Allocate a new set of triggers.
	127	* The returned object must be freed via lttng_triggers_destroy.
	128	*/
	129	LTTNG_HIDDEN
	130	struct lttng_triggers *lttng_triggers_create(void);
	131
	132	/*
	133	* Return the a pointer to a mutable element at index "index" of an
	134	* lttng_triggers set.
	135	*
	136	* This differs from the public `lttng_triggers_get_at_index` in that
	137	* the returned pointer to a mutable trigger.
	138	*
	139	* The ownership of the trigger set element is NOT transfered.
	140	* The returned object can NOT be freed via lttng_trigger_destroy.
	141	*/
	142	LTTNG_HIDDEN
	143	struct lttng_trigger *lttng_triggers_borrow_mutable_at_index(
	144	const struct lttng_triggers *triggers, unsigned int index);
	145
	146	/*
	147	* Add a trigger to the triggers set.
	148	*
	149	* A reference to the added trigger is acquired on behalf of the trigger set
	150	* on success.
	151	*/
	152	LTTNG_HIDDEN
	153	int lttng_triggers_add(
	154	struct lttng_triggers triggers, struct lttng_trigger trigger);
	155
	156	/*
	157	* Serialize a trigger set to an lttng_payload object.
	158	* Return LTTNG_OK on success, negative lttng error code on error.
	159	*/
	160	LTTNG_HIDDEN
	161	int lttng_triggers_serialize(const struct lttng_triggers *triggers,
	162	struct lttng_payload *payload);
	163
	164	LTTNG_HIDDEN
	165	ssize_t lttng_triggers_create_from_payload(struct lttng_payload_view *view,
	166	struct lttng_triggers **triggers);
	167
	168	LTTNG_HIDDEN
	169	const struct lttng_credentials *lttng_trigger_get_credentials(
	170	const struct lttng_trigger *trigger);
	171
	172	LTTNG_HIDDEN
	173	void lttng_trigger_set_credentials(struct lttng_trigger *trigger,
	174	const struct lttng_credentials *creds);
	175
	176	/*
	177	* Return the type of any underlying domain restriction. If no particular
	178	* requirement is present, returns LTTNG_DOMAIN_NONE.
	179	*/
	180	LTTNG_HIDDEN
	181	enum lttng_domain_type lttng_trigger_get_underlying_domain_type_restriction(
	182	const struct lttng_trigger *trigger);
	183
	184	/*
	185	* Generate any bytecode related to the trigger.
	186	* On success LTTNG_OK. On error, returns lttng_error code.
	187	*/
	188	LTTNG_HIDDEN
	189	enum lttng_error_code lttng_trigger_generate_bytecode(
	190	struct lttng_trigger *trigger,
	191	const struct lttng_credentials *creds);
	192
	193	LTTNG_HIDDEN
	194	struct lttng_trigger lttng_trigger_copy(const struct lttng_trigger trigger);
	195
	196	/*
	197	* A given trigger needs a tracer notifier if
	198	* it has an event-rule condition,
	199	* AND
	200	* it has one or more sessiond-execution action.
	201	*/
	202	LTTNG_HIDDEN
	203	bool lttng_trigger_needs_tracer_notifier(const struct lttng_trigger *trigger);
	204
	205	LTTNG_HIDDEN
	206	void lttng_trigger_set_as_registered(struct lttng_trigger *trigger);
	207
	208	LTTNG_HIDDEN
	209	void lttng_trigger_set_as_unregistered(struct lttng_trigger *trigger);
	210
	211	/*
	212	* The trigger must be locked before calling lttng_trigger_is_registered.
	213	*
	214	* The lock is necessary since a trigger can be unregistered at any time.
	215	*
	216	* Manipulations requiring that the trigger be registered must always acquire
	217	* the trigger lock for the duration of the manipulation using
	218	* `lttng_trigger_lock` and `lttng_trigger_unlock`.
	219	*/
	220	LTTNG_HIDDEN
	221	bool lttng_trigger_is_registered(struct lttng_trigger *trigger);
	222
	223	LTTNG_HIDDEN
	224	void lttng_trigger_lock(struct lttng_trigger *trigger);
	225
	226	LTTNG_HIDDEN
	227	void lttng_trigger_unlock(struct lttng_trigger *trigger);
	228
	229	LTTNG_HIDDEN
	230	enum lttng_trigger_status lttng_trigger_add_error_results(
	231	const struct lttng_trigger *trigger,
	232	struct lttng_error_query_results *results);
	233
	234	LTTNG_HIDDEN
	235	enum lttng_trigger_status lttng_trigger_add_action_error_query_results(
	236	struct lttng_trigger *trigger,
	237	struct lttng_error_query_results *results);
	238
	239	#endif /* LTTNG_TRIGGER_INTERNAL_H */