[lttng-tools.git] / src / bin / lttng-sessiond / notification-thread-commands.h

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

#ifndef NOTIFICATION_THREAD_COMMANDS_H
#define NOTIFICATION_THREAD_COMMANDS_H

#include <lttng/domain.h>
#include <lttng/lttng-error.h>
#include <urcu/rculfhash.h>
#include "notification-thread.h"
#include "notification-thread-internal.h"
#include "notification-thread-events.h"
#include <common/waiter.h>
#include <stdbool.h>

struct notification_thread_data;
struct lttng_trigger;

enum notification_thread_command_type {
	NOTIFICATION_COMMAND_TYPE_REGISTER_TRIGGER,
	NOTIFICATION_COMMAND_TYPE_UNREGISTER_TRIGGER,
	NOTIFICATION_COMMAND_TYPE_ADD_CHANNEL,
	NOTIFICATION_COMMAND_TYPE_REMOVE_CHANNEL,
	NOTIFICATION_COMMAND_TYPE_SESSION_ROTATION_ONGOING,
	NOTIFICATION_COMMAND_TYPE_SESSION_ROTATION_COMPLETED,
	NOTIFICATION_COMMAND_TYPE_ADD_APPLICATION,
	NOTIFICATION_COMMAND_TYPE_REMOVE_APPLICATION,
	NOTIFICATION_COMMAND_TYPE_GET_TOKENS,
	NOTIFICATION_COMMAND_TYPE_LIST_TRIGGERS,
	NOTIFICATION_COMMAND_TYPE_QUIT,
	NOTIFICATION_COMMAND_TYPE_CLIENT_COMMUNICATION_UPDATE,
};

struct notification_thread_command {
	struct cds_list_head cmd_list_node;

	enum notification_thread_command_type type;
	union {
		/* Register/Unregister trigger. */
		struct lttng_trigger *trigger;
		/* Add channel. */
		struct {
			struct {
				const char *name;
				uid_t uid;
				gid_t gid;
			} session;
			struct {
				const char *name;
				enum lttng_domain_type domain;
				uint64_t key;
				uint64_t capacity;
			} channel;
		} add_channel;
		/* Remove channel. */
		struct {
			uint64_t key;
			enum lttng_domain_type domain;
		} remove_channel;
		struct {
			const char *session_name;
			uid_t uid;
			gid_t gid;
			uint64_t trace_archive_chunk_id;
			struct lttng_trace_archive_location *location;
		} session_rotation;
		/* Add/Remove application */
		struct {
			int read_side_trigger_event_application_pipe;
			enum lttng_domain_type domain;
		} application;
		/* List triggers */
		struct {
			/* Credential */
			uid_t uid;
		} list_triggers;
		/* Client communication update. */
		struct {
			notification_client_id id;
			enum client_transmission_status status;
		} client_communication_update;

	} parameters;

	union {
		struct {
			struct lttng_triggers *triggers;
		} get_tokens;
		struct {
			struct lttng_triggers *triggers;
		} list_triggers;
	} reply;

	/* lttng_waiter on which to wait for command reply (optional). */
	struct lttng_waiter reply_waiter;
	enum lttng_error_code reply_code;
	bool is_async;
};

enum lttng_error_code notification_thread_command_register_trigger(
		struct notification_thread_handle *handle,
		struct lttng_trigger *trigger);

enum lttng_error_code notification_thread_command_unregister_trigger(
		struct notification_thread_handle *handle,
		struct lttng_trigger *trigger);

enum lttng_error_code notification_thread_command_add_channel(
		struct notification_thread_handle *handle,
		char *session_name, uid_t session_uid, gid_t session_gid,
		char *channel_name, uint64_t key,
		enum lttng_domain_type domain, uint64_t capacity);

enum lttng_error_code notification_thread_command_remove_channel(
		struct notification_thread_handle *handle,
		uint64_t key, enum lttng_domain_type domain);

enum lttng_error_code notification_thread_command_session_rotation_ongoing(
		struct notification_thread_handle *handle,
		const char *session_name, uid_t session_uid, gid_t session_gid,
		uint64_t trace_archive_chunk_id);

/* Ownership of location is transferred. */
enum lttng_error_code notification_thread_command_session_rotation_completed(
		struct notification_thread_handle *handle,
		const char *session_name, uid_t session_uid, gid_t session_gid,
		uint64_t trace_archive_chunk_id,
		struct lttng_trace_archive_location *location);

enum lttng_error_code notification_thread_command_add_application(
		struct notification_thread_handle *handle,
		int fd,
		enum lttng_domain_type domain
		);

enum lttng_error_code notification_thread_command_remove_application(
		struct notification_thread_handle *handle,
		int trigger_event_application_pipe);

/* Must hold the notification_trigger_tokens_ht_lock to protect against
 * insertion removal of triggers TODO: is it the case even with refcounting? */
/* todo find a better way....*/
enum lttng_error_code notification_thread_command_get_tokens(
		struct notification_thread_handle *handle,
		struct lttng_triggers **triggers);

enum lttng_error_code notification_thread_command_list_triggers(
		struct notification_thread_handle *handle,
		uid_t uid,
		struct lttng_triggers **triggers);

void notification_thread_command_quit(
		struct notification_thread_handle *handle);

#endif /* NOTIFICATION_THREAD_COMMANDS_H */
Commit	Line	Data
ab0ee2ca	1	/*
ab5be9fa	2	* Copyright (C) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
ab0ee2ca	3	*
ab5be9fa	4	* SPDX-License-Identifier: GPL-2.0-only
ab0ee2ca	5	*
ab0ee2ca JG	6	*/
	7
	8	#ifndef NOTIFICATION_THREAD_COMMANDS_H
	9	#define NOTIFICATION_THREAD_COMMANDS_H
	10
	11	#include <lttng/domain.h>
	12	#include <lttng/lttng-error.h>
	13	#include <urcu/rculfhash.h>
	14	#include "notification-thread.h"
8abe313a JG	15	#include "notification-thread-internal.h"
8abe313a JG	16	#include "notification-thread-events.h"
8ada111f	17	#include <common/waiter.h>
0ab399e0	18	#include <stdbool.h>
ab0ee2ca JG	19
	20	struct notification_thread_data;
	21	struct lttng_trigger;
	22
	23	enum notification_thread_command_type {
	24	NOTIFICATION_COMMAND_TYPE_REGISTER_TRIGGER,
	25	NOTIFICATION_COMMAND_TYPE_UNREGISTER_TRIGGER,
	26	NOTIFICATION_COMMAND_TYPE_ADD_CHANNEL,
	27	NOTIFICATION_COMMAND_TYPE_REMOVE_CHANNEL,
731c1b12 JG	28	NOTIFICATION_COMMAND_TYPE_SESSION_ROTATION_ONGOING,
731c1b12 JG	29	NOTIFICATION_COMMAND_TYPE_SESSION_ROTATION_COMPLETED,
2463b787 JR	30	NOTIFICATION_COMMAND_TYPE_ADD_APPLICATION,
	31	NOTIFICATION_COMMAND_TYPE_REMOVE_APPLICATION,
	32	NOTIFICATION_COMMAND_TYPE_GET_TOKENS,
	33	NOTIFICATION_COMMAND_TYPE_LIST_TRIGGERS,
ab0ee2ca	34	NOTIFICATION_COMMAND_TYPE_QUIT,
f2b3ef9f	35	NOTIFICATION_COMMAND_TYPE_CLIENT_COMMUNICATION_UPDATE,
ab0ee2ca JG	36	};
ab0ee2ca JG	37
ab0ee2ca JG	38	struct notification_thread_command {
	39	struct cds_list_head cmd_list_node;
	40
	41	enum notification_thread_command_type type;
	42	union {
	43	/* Register/Unregister trigger. */
	44	struct lttng_trigger *trigger;
	45	/* Add channel. */
8abe313a JG	46	struct {
	47	struct {
	48	const char *name;
	49	uid_t uid;
	50	gid_t gid;
	51	} session;
	52	struct {
	53	const char *name;
	54	enum lttng_domain_type domain;
	55	uint64_t key;
	56	uint64_t capacity;
	57	} channel;
	58	} add_channel;
ab0ee2ca JG	59	/* Remove channel. */
	60	struct {
	61	uint64_t key;
	62	enum lttng_domain_type domain;
	63	} remove_channel;
731c1b12 JG	64	struct {
	65	const char *session_name;
	66	uid_t uid;
	67	gid_t gid;
	68	uint64_t trace_archive_chunk_id;
	69	struct lttng_trace_archive_location *location;
	70	} session_rotation;
2463b787 JR	71	/* Add/Remove application */
	72	struct {
	73	int read_side_trigger_event_application_pipe;
	74	enum lttng_domain_type domain;
	75	} application;
	76	/* List triggers */
	77	struct {
	78	/* Credential */
	79	uid_t uid;
	80	} list_triggers;
f2b3ef9f JG	81	/* Client communication update. */
	82	struct {
	83	notification_client_id id;
	84	enum client_transmission_status status;
	85	} client_communication_update;
	86
ab0ee2ca JG	87	} parameters;
ab0ee2ca JG	88
2463b787 JR	89	union {
	90	struct {
	91	struct lttng_triggers *triggers;
	92	} get_tokens;
	93	struct {
	94	struct lttng_triggers *triggers;
	95	} list_triggers;
	96	} reply;
	97
8ada111f JG	98	/* lttng_waiter on which to wait for command reply (optional). */
8ada111f JG	99	struct lttng_waiter reply_waiter;
ab0ee2ca	100	enum lttng_error_code reply_code;
0ab399e0	101	bool is_async;
ab0ee2ca JG	102	};
	103
	104	enum lttng_error_code notification_thread_command_register_trigger(
	105	struct notification_thread_handle *handle,
	106	struct lttng_trigger *trigger);
	107
	108	enum lttng_error_code notification_thread_command_unregister_trigger(
	109	struct notification_thread_handle *handle,
	110	struct lttng_trigger *trigger);
	111
	112	enum lttng_error_code notification_thread_command_add_channel(
	113	struct notification_thread_handle *handle,
731c1b12	114	char *session_name, uid_t session_uid, gid_t session_gid,
ab0ee2ca JG	115	char *channel_name, uint64_t key,
	116	enum lttng_domain_type domain, uint64_t capacity);
	117
	118	enum lttng_error_code notification_thread_command_remove_channel(
	119	struct notification_thread_handle *handle,
	120	uint64_t key, enum lttng_domain_type domain);
	121
731c1b12 JG	122	enum lttng_error_code notification_thread_command_session_rotation_ongoing(
	123	struct notification_thread_handle *handle,
	124	const char *session_name, uid_t session_uid, gid_t session_gid,
	125	uint64_t trace_archive_chunk_id);
	126
	127	/* Ownership of location is transferred. */
	128	enum lttng_error_code notification_thread_command_session_rotation_completed(
	129	struct notification_thread_handle *handle,
	130	const char *session_name, uid_t session_uid, gid_t session_gid,
	131	uint64_t trace_archive_chunk_id,
	132	struct lttng_trace_archive_location *location);
	133
2463b787 JR	134	enum lttng_error_code notification_thread_command_add_application(
	135	struct notification_thread_handle *handle,
	136	int fd,
	137	enum lttng_domain_type domain
	138	);
	139
	140	enum lttng_error_code notification_thread_command_remove_application(
	141	struct notification_thread_handle *handle,
	142	int trigger_event_application_pipe);
	143
	144	/* Must hold the notification_trigger_tokens_ht_lock to protect against
	145	* insertion removal of triggers TODO: is it the case even with refcounting? */
	146	/* todo find a better way....*/
	147	enum lttng_error_code notification_thread_command_get_tokens(
	148	struct notification_thread_handle *handle,
	149	struct lttng_triggers **triggers);
	150
	151	enum lttng_error_code notification_thread_command_list_triggers(
	152	struct notification_thread_handle *handle,
	153	uid_t uid,
	154	struct lttng_triggers **triggers);
	155
ab0ee2ca JG	156	void notification_thread_command_quit(
	157	struct notification_thread_handle *handle);
	158
	159	#endif /* NOTIFICATION_THREAD_COMMANDS_H */