[lttng-tools.git] / src / bin / lttng-sessiond / ust-registry.h

/*
 * Copyright (C) 2013 David Goulet <dgoulet@efficios.com>
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 */

#ifndef LTTNG_UST_REGISTRY_H
#define LTTNG_UST_REGISTRY_H

#include <pthread.h>
#include <stdint.h>

#include <common/hashtable/hashtable.h>
#include <common/uuid.h>

#include "lttng-ust-ctl.h"

#define CTF_SPEC_MAJOR	1
#define CTF_SPEC_MINOR	8

struct ust_app;

struct ust_registry_session {
	/*
	 * With multiple writers and readers, use this lock to access
	 * the registry. Can nest within the ust app session lock.
	 * Also acts as a registry serialization lock. Used by registry
	 * readers to serialize the registry information sent from the
	 * sessiond to the consumerd.
	 * The consumer socket lock nests within this lock.
	 */
	pthread_mutex_t lock;
	/* Next channel ID available for a newly registered channel. */
	uint32_t next_channel_id;
	/* Once this value reaches UINT32_MAX, no more id can be allocated. */
	uint32_t used_channel_id;
	/* Next enumeration ID available. */
	uint64_t next_enum_id;
	/* Universal unique identifier used by the tracer. */
	unsigned char uuid[LTTNG_UUID_LEN];

	/* session ABI description */

	/* Size of long, in bits */
	unsigned int bits_per_long;
	/* Alignment, in bits */
	unsigned int uint8_t_alignment,
		uint16_t_alignment,
		uint32_t_alignment,
		uint64_t_alignment,
		long_alignment;
	/* endianness */
	int byte_order;	/* BIG_ENDIAN or LITTLE_ENDIAN */

	/* Generated metadata. */
	char *metadata;		/* NOT null-terminated ! Use memcpy. */
	size_t metadata_len, metadata_alloc_len;
	/* Length of bytes sent to the consumer. */
	size_t metadata_len_sent;
	/* Current version of the metadata. */
	uint64_t metadata_version;

	/*
	 * Those fields are only used when a session is created with
	 * the --shm-path option. In this case, the metadata is output
	 * twice: once to the consumer, as ususal, but a second time
	 * also in the shm path directly. This is done so that a copy
	 * of the metadata that is as fresh as possible is available
	 * on the event of a crash.
	 *
	 * root_shm_path contains the shm-path provided by the user, along with
	 * the session's name and timestamp:
	 *   e.g. /tmp/my_shm/my_session-20180612-135822
	 *
	 * shm_path contains the full path of the memory buffers:
	 *   e.g. /tmp/my_shm/my_session-20180612-135822/ust/uid/1000/64-bit
	 *
	 * metadata_path contains the full path to the metadata file that
	 * is kept for the "crash buffer" extraction:
	 *  e.g. /tmp/my_shm/my_session-20180612-135822/ust/uid/1000/64-bit/metadata
	 *
	 * Note that this is not the trace's final metadata file. It is
	 * only meant to be used to read the contents of the ring buffers
	 * in the event of a crash.
	 *
	 * metadata_fd is a file descriptor that points to the file at
	 * 'metadata_path'.
	 */
	char root_shm_path[PATH_MAX];
	char shm_path[PATH_MAX];
	char metadata_path[PATH_MAX];
	int metadata_fd;	/* file-backed metadata FD */

	/*
	 * Hash table containing channels sent by the UST tracer. MUST
	 * be accessed with a RCU read side lock acquired.
	 */
	struct lttng_ht *channels;
	/*
	 * Unique key to identify the metadata on the consumer side.
	 */
	uint64_t metadata_key;
	/*
	 * Indicates if the metadata is closed on the consumer side. This is to
	 * avoid double close of metadata when an application unregisters AND
	 * deletes its sessions.
	 */
	unsigned int metadata_closed;

	/* User and group owning the session. */
	uid_t uid;
	gid_t gid;

	/* Enumerations table. */
	struct lttng_ht *enums;

	/*
	 * Copy of the tracer version when the first app is registered.
	 * It is used if we need to regenerate the metadata.
	 */
	uint32_t major;
	uint32_t minor;

	/* The id of the parent session */
	uint64_t tracing_id;
	uid_t tracing_uid;
};

struct ust_registry_channel {
	uint64_t key;
	uint64_t consumer_key;
	/* Id set when replying to a register channel. */
	uint32_t chan_id;
	enum lttng_ust_ctl_channel_header header_type;

	/*
	 * Flag for this channel if the metadata was dumped once during
	 * registration. 0 means no, 1 yes.
	 */
	unsigned int metadata_dumped;
	/* Indicates if this channel registry has already been registered. */
	unsigned int register_done;

	/*
	 * Hash table containing events sent by the UST tracer. MUST be accessed
	 * with a RCU read side lock acquired.
	 */
	struct lttng_ht *ht;
	/* Next event ID available for a newly registered event. */
	uint32_t next_event_id;
	/* Once this value reaches UINT32_MAX, no more id can be allocated. */
	uint32_t used_event_id;
	/*
	 * Context fields of the registry. Context are per channel. Allocated by a
	 * register channel notification from the UST tracer.
	 */
	size_t nr_ctx_fields;
	struct lttng_ust_ctl_field *ctx_fields;
	struct lttng_ht_node_u64 node;
	/* For delayed reclaim */
	struct rcu_head rcu_head;
};

/*
 * Event registered from a UST tracer sent to the session daemon. This is
 * indexed and matched by <event_name/signature>.
 */
struct ust_registry_event {
	int id;
	/* Both objd are set by the tracer. */
	int session_objd;
	int channel_objd;
	/* Name of the event returned by the tracer. */
	char name[LTTNG_UST_ABI_SYM_NAME_LEN];
	char *signature;
	int loglevel_value;
	size_t nr_fields;
	struct lttng_ust_ctl_field *fields;
	char *model_emf_uri;
	/*
	 * Flag for this channel if the metadata was dumped once during
	 * registration. 0 means no, 1 yes.
	 */
	unsigned int metadata_dumped;
	/*
	 * Node in the ust-registry hash table. The event name is used to
	 * initialize the node and the event_name/signature for the match function.
	 */
	struct lttng_ht_node_u64 node;
};

struct ust_registry_enum {
	char name[LTTNG_UST_ABI_SYM_NAME_LEN];
	struct lttng_ust_ctl_enum_entry *entries;
	size_t nr_entries;
	uint64_t id;	/* enum id in session */
	/* Enumeration node in session hash table. */
	struct lttng_ht_node_str node;
	/* For delayed reclaim. */
	struct rcu_head rcu_head;
};

/*
 * Validate that the id has reached the maximum allowed or not.
 *
 * Return 0 if NOT else 1.
 */
static inline int ust_registry_is_max_id(uint32_t id)
{
	return (id == UINT32_MAX) ? 1 : 0;
}

/*
 * Return next available event id and increment the used counter. The
 * ust_registry_is_max_id function MUST be called before in order to validate
 * if the maximum number of IDs have been reached. If not, it is safe to call
 * this function.
 *
 * Return a unique channel ID. If max is reached, the used_event_id counter is
 * returned.
 */
static inline uint32_t ust_registry_get_next_event_id(
		struct ust_registry_channel *r)
{
	if (ust_registry_is_max_id(r->used_event_id)) {
		return r->used_event_id;
	}

	r->used_event_id++;
	return r->next_event_id++;
}

/*
 * Return next available channel id and increment the used counter. The
 * ust_registry_is_max_id function MUST be called before in order to validate
 * if the maximum number of IDs have been reached. If not, it is safe to call
 * this function.
 *
 * Return a unique channel ID. If max is reached, the used_channel_id counter
 * is returned.
 */
static inline uint32_t ust_registry_get_next_chan_id(
		struct ust_registry_session *r)
{
	if (ust_registry_is_max_id(r->used_channel_id)) {
		return r->used_channel_id;
	}

	r->used_channel_id++;
	return r->next_channel_id++;
}

/*
 * Return registry event count. This is read atomically.
 */
static inline uint32_t ust_registry_get_event_count(
		struct ust_registry_channel *r)
{
	return (uint32_t) uatomic_read(&r->used_event_id);
}

#ifdef HAVE_LIBLTTNG_UST_CTL

void ust_registry_channel_destroy(struct ust_registry_session *session,
		struct ust_registry_channel *chan);
struct ust_registry_channel *ust_registry_channel_find(
		struct ust_registry_session *session, uint64_t key);
int ust_registry_channel_add(struct ust_registry_session *session,
		uint64_t key);
void ust_registry_channel_del_free(struct ust_registry_session *session,
		uint64_t key, bool notif);

int ust_registry_session_init(struct ust_registry_session **sessionp,
		struct ust_app *app,
		uint32_t bits_per_long,
		uint32_t uint8_t_alignment,
		uint32_t uint16_t_alignment,
		uint32_t uint32_t_alignment,
		uint32_t uint64_t_alignment,
		uint32_t long_alignment,
		int byte_order,
		uint32_t major,
		uint32_t minor,
		const char *root_shm_path,
		const char *shm_path,
		uid_t euid,
		gid_t egid,
		uint64_t tracing_id,
		uid_t tracing_uid);
void ust_registry_session_destroy(struct ust_registry_session *session);

int ust_registry_create_event(struct ust_registry_session *session,
		uint64_t chan_key, int session_objd, int channel_objd, char *name,
		char *sig, size_t nr_fields, struct lttng_ust_ctl_field *fields,
		int loglevel_value, char *model_emf_uri, int buffer_type,
		uint32_t *event_id_p, struct ust_app *app);
struct ust_registry_event *ust_registry_find_event(
		struct ust_registry_channel *chan, char *name, char *sig);
void ust_registry_destroy_event(struct ust_registry_channel *chan,
		struct ust_registry_event *event);

/* app can be NULL for registry shared across applications. */
int ust_metadata_session_statedump(struct ust_registry_session *session,
		struct ust_app *app, uint32_t major, uint32_t minor);
int ust_metadata_channel_statedump(struct ust_registry_session *session,
		struct ust_registry_channel *chan);
int ust_metadata_event_statedump(struct ust_registry_session *session,
		struct ust_registry_channel *chan,
		struct ust_registry_event *event);
int ust_registry_create_or_find_enum(struct ust_registry_session *session,
		int session_objd, char *name,
		struct lttng_ust_ctl_enum_entry *entries, size_t nr_entries,
		uint64_t *enum_id);
struct ust_registry_enum *
	ust_registry_lookup_enum_by_id(struct ust_registry_session *session,
		const char *name, uint64_t id);

#else /* HAVE_LIBLTTNG_UST_CTL */

static inline
void ust_registry_channel_destroy(
		struct ust_registry_session *session __attribute__((unused)),
		struct ust_registry_channel *chan __attribute__((unused)))
{}

static inline
struct ust_registry_channel *ust_registry_channel_find(
		struct ust_registry_session *session __attribute__((unused)),
		uint64_t key __attribute__((unused)))
{
	return NULL;
}

static inline
int ust_registry_channel_add(
		struct ust_registry_session *session __attribute__((unused)),
		uint64_t key __attribute__((unused)))
{
	return 0;
}

static inline
void ust_registry_channel_del_free(
		struct ust_registry_session *session __attribute__((unused)),
		uint64_t key __attribute__((unused)),
		bool notif __attribute__((unused)))
{}

static inline
int ust_registry_session_init(
		struct ust_registry_session **sessionp __attribute__((unused)),
		struct ust_app *app __attribute__((unused)),
		uint32_t bits_per_long __attribute__((unused)),
		uint32_t uint8_t_alignment __attribute__((unused)),
		uint32_t uint16_t_alignment __attribute__((unused)),
		uint32_t uint32_t_alignment __attribute__((unused)),
		uint32_t uint64_t_alignment __attribute__((unused)),
		uint32_t long_alignment __attribute__((unused)),
		int byte_order __attribute__((unused)),
		uint32_t major __attribute__((unused)),
		uint32_t minor __attribute__((unused)),
		const char *root_shm_path __attribute__((unused)),
		const char *shm_path __attribute__((unused)),
		uid_t euid __attribute__((unused)),
		gid_t egid __attribute__((unused)),
		uint64_t tracing_id __attribute__((unused)),
		uid_t tracing_uid __attribute__((unused)))
{
	return 0;
}

static inline
void ust_registry_session_destroy(
		struct ust_registry_session *session __attribute__((unused)))
{}

static inline
int ust_registry_create_event(
		struct ust_registry_session *session __attribute__((unused)),
		uint64_t chan_key __attribute__((unused)),
		int session_objd __attribute__((unused)),
		int channel_objd __attribute__((unused)),
		char *name __attribute__((unused)),
		char *sig __attribute__((unused)),
		size_t nr_fields __attribute__((unused)),
		struct lttng_ust_ctl_field *fields __attribute__((unused)),
		int loglevel_value __attribute__((unused)),
		char *model_emf_uri __attribute__((unused)),
		int buffer_type __attribute__((unused)),
		uint32_t *event_id_p __attribute__((unused)))
{
	return 0;
}
static inline
struct ust_registry_event *ust_registry_find_event(
		struct ust_registry_channel *chan __attribute__((unused)),
		char *name __attribute__((unused)),
		char *sig __attribute__((unused)))
{
	return NULL;
}

static inline
void ust_registry_destroy_event(
		struct ust_registry_channel *chan __attribute__((unused)),
		struct ust_registry_event *event __attribute__((unused)))
{}

/* The app object can be NULL for registry shared across applications. */
static inline
int ust_metadata_session_statedump(
		struct ust_registry_session *session __attribute__((unused)),
		struct ust_app *app __attribute__((unused)),
		uint32_t major __attribute__((unused)),
		uint32_t minor __attribute__((unused)))
{
	return 0;
}

static inline
int ust_metadata_channel_statedump(
		struct ust_registry_session *session __attribute__((unused)),
		struct ust_registry_channel *chan __attribute__((unused)))
{
	return 0;
}

static inline
int ust_metadata_event_statedump(
		struct ust_registry_session *session __attribute__((unused)),
		struct ust_registry_channel *chan __attribute__((unused)),
		struct ust_registry_event *event __attribute__((unused)))
{
	return 0;
}

static inline
int ust_registry_create_or_find_enum(
		struct ust_registry_session *session __attribute__((unused)),
		int session_objd __attribute__((unused)),
		char *name __attribute__((unused)),
		struct lttng_ust_ctl_enum_entry *entries __attribute__((unused)),
		size_t nr_entries __attribute__((unused)),
		uint64_t *enum_id __attribute__((unused)))
{
	return 0;
}

static inline
struct ust_registry_enum *
	ust_registry_lookup_enum_by_id(
		struct ust_registry_session *session __attribute__((unused)),
		const char *name __attribute__((unused)),
		uint64_t id __attribute__((unused)))
{
	return NULL;
}

#endif /* HAVE_LIBLTTNG_UST_CTL */

#endif /* LTTNG_UST_REGISTRY_H */
Commit	Line	Data
d0b96690	1	/*
ab5be9fa	2	* Copyright (C) 2013 David Goulet <dgoulet@efficios.com>
d0b96690	3	*
ab5be9fa	4	* SPDX-License-Identifier: GPL-2.0-only
d0b96690	5	*
d0b96690 DG	6	*/
	7
	8	#ifndef LTTNG_UST_REGISTRY_H
	9	#define LTTNG_UST_REGISTRY_H
	10
	11	#include <pthread.h>
	12	#include <stdint.h>
d0b96690 DG	13
d0b96690 DG	14	#include <common/hashtable/hashtable.h>
c70636a7	15	#include <common/uuid.h>
d0b96690	16
75018ab6	17	#include "lttng-ust-ctl.h"
7972aab2	18
d0b96690 DG	19	#define CTF_SPEC_MAJOR 1
	20	#define CTF_SPEC_MINOR 8
	21
	22	struct ust_app;
	23
	24	struct ust_registry_session {
	25	/*
dc2bbdae MD	26	* With multiple writers and readers, use this lock to access
	27	* the registry. Can nest within the ust app session lock.
	28	* Also acts as a registry serialization lock. Used by registry
	29	* readers to serialize the registry information sent from the
	30	* sessiond to the consumerd.
	31	* The consumer socket lock nests within this lock.
d0b96690 DG	32	*/
	33	pthread_mutex_t lock;
	34	/* Next channel ID available for a newly registered channel. */
	35	uint32_t next_channel_id;
	36	/* Once this value reaches UINT32_MAX, no more id can be allocated. */
	37	uint32_t used_channel_id;
10b56aef MD	38	/* Next enumeration ID available. */
10b56aef MD	39	uint64_t next_enum_id;
d0b96690	40	/* Universal unique identifier used by the tracer. */
c70636a7	41	unsigned char uuid[LTTNG_UUID_LEN];
d0b96690 DG	42
	43	/* session ABI description */
	44
	45	/* Size of long, in bits */
	46	unsigned int bits_per_long;
	47	/* Alignment, in bits */
	48	unsigned int uint8_t_alignment,
	49	uint16_t_alignment,
	50	uint32_t_alignment,
	51	uint64_t_alignment,
	52	long_alignment;
	53	/* endianness */
	54	int byte_order; /* BIG_ENDIAN or LITTLE_ENDIAN */
	55
	56	/* Generated metadata. */
	57	char metadata; / NOT null-terminated ! Use memcpy. */
	58	size_t metadata_len, metadata_alloc_len;
d88aee68 DG	59	/* Length of bytes sent to the consumer. */
d88aee68 DG	60	size_t metadata_len_sent;
93ec662e JD	61	/* Current version of the metadata. */
93ec662e JD	62	uint64_t metadata_version;
d7ba1388	63
9aed4377 JG	64	/*
	65	* Those fields are only used when a session is created with
	66	* the --shm-path option. In this case, the metadata is output
	67	* twice: once to the consumer, as ususal, but a second time
	68	* also in the shm path directly. This is done so that a copy
	69	* of the metadata that is as fresh as possible is available
	70	* on the event of a crash.
	71	*
	72	* root_shm_path contains the shm-path provided by the user, along with
	73	* the session's name and timestamp:
	74	* e.g. /tmp/my_shm/my_session-20180612-135822
	75	*
	76	* shm_path contains the full path of the memory buffers:
	77	* e.g. /tmp/my_shm/my_session-20180612-135822/ust/uid/1000/64-bit
	78	*
	79	* metadata_path contains the full path to the metadata file that
	80	* is kept for the "crash buffer" extraction:
	81	* e.g. /tmp/my_shm/my_session-20180612-135822/ust/uid/1000/64-bit/metadata
	82	*
	83	* Note that this is not the trace's final metadata file. It is
	84	* only meant to be used to read the contents of the ring buffers
	85	* in the event of a crash.
	86	*
	87	* metadata_fd is a file descriptor that points to the file at
	88	* 'metadata_path'.
	89	*/
3d071855	90	char root_shm_path[PATH_MAX];
d7ba1388 MD	91	char shm_path[PATH_MAX];
	92	char metadata_path[PATH_MAX];
	93	int metadata_fd; /* file-backed metadata FD */
	94
45893984	95	/*
dc2bbdae MD	96	* Hash table containing channels sent by the UST tracer. MUST
dc2bbdae MD	97	* be accessed with a RCU read side lock acquired.
45893984 DG	98	*/
45893984 DG	99	struct lttng_ht *channels;
dc2bbdae MD	100	/*
	101	* Unique key to identify the metadata on the consumer side.
	102	*/
7972aab2 DG	103	uint64_t metadata_key;
	104	/*
	105	* Indicates if the metadata is closed on the consumer side. This is to
	106	* avoid double close of metadata when an application unregisters AND
	107	* deletes its sessions.
	108	*/
	109	unsigned int metadata_closed;
4628484a MD	110
	111	/* User and group owning the session. */
	112	uid_t uid;
	113	gid_t gid;
10b56aef MD	114
	115	/* Enumerations table. */
	116	struct lttng_ht *enums;
7062f070 JD	117
	118	/*
	119	* Copy of the tracer version when the first app is registered.
	120	* It is used if we need to regenerate the metadata.
	121	*/
	122	uint32_t major;
	123	uint32_t minor;
8de88061 JR	124
	125	/* The id of the parent session */
	126	uint64_t tracing_id;
	127	uid_t tracing_uid;
d0b96690 DG	128	};
	129
	130	struct ust_registry_channel {
45893984	131	uint64_t key;
e9404c27	132	uint64_t consumer_key;
d0b96690 DG	133	/* Id set when replying to a register channel. */
d0b96690 DG	134	uint32_t chan_id;
b623cb6a	135	enum lttng_ust_ctl_channel_header header_type;
d0b96690	136
7972aab2 DG	137	/*
	138	* Flag for this channel if the metadata was dumped once during
	139	* registration. 0 means no, 1 yes.
	140	*/
	141	unsigned int metadata_dumped;
	142	/* Indicates if this channel registry has already been registered. */
	143	unsigned int register_done;
	144
d0b96690 DG	145	/*
	146	* Hash table containing events sent by the UST tracer. MUST be accessed
	147	* with a RCU read side lock acquired.
	148	*/
	149	struct lttng_ht *ht;
	150	/* Next event ID available for a newly registered event. */
	151	uint32_t next_event_id;
	152	/* Once this value reaches UINT32_MAX, no more id can be allocated. */
	153	uint32_t used_event_id;
	154	/*
	155	* Context fields of the registry. Context are per channel. Allocated by a
	156	* register channel notification from the UST tracer.
	157	*/
	158	size_t nr_ctx_fields;
b623cb6a	159	struct lttng_ust_ctl_field *ctx_fields;
45893984	160	struct lttng_ht_node_u64 node;
36b588ed MD	161	/* For delayed reclaim */
36b588ed MD	162	struct rcu_head rcu_head;
d0b96690 DG	163	};
	164
	165	/*
	166	* Event registered from a UST tracer sent to the session daemon. This is
	167	* indexed and matched by <event_name/signature>.
	168	*/
	169	struct ust_registry_event {
	170	int id;
	171	/* Both objd are set by the tracer. */
	172	int session_objd;
	173	int channel_objd;
	174	/* Name of the event returned by the tracer. */
fc4b93fa	175	char name[LTTNG_UST_ABI_SYM_NAME_LEN];
d0b96690	176	char *signature;
2106efa0	177	int loglevel_value;
d0b96690	178	size_t nr_fields;
b623cb6a	179	struct lttng_ust_ctl_field *fields;
d0b96690	180	char *model_emf_uri;
7972aab2 DG	181	/*
	182	* Flag for this channel if the metadata was dumped once during
	183	* registration. 0 means no, 1 yes.
	184	*/
	185	unsigned int metadata_dumped;
d0b96690 DG	186	/*
	187	* Node in the ust-registry hash table. The event name is used to
	188	* initialize the node and the event_name/signature for the match function.
	189	*/
7972aab2	190	struct lttng_ht_node_u64 node;
d0b96690 DG	191	};
d0b96690 DG	192
10b56aef	193	struct ust_registry_enum {
fc4b93fa	194	char name[LTTNG_UST_ABI_SYM_NAME_LEN];
b623cb6a	195	struct lttng_ust_ctl_enum_entry *entries;
10b56aef MD	196	size_t nr_entries;
	197	uint64_t id; /* enum id in session */
	198	/* Enumeration node in session hash table. */
	199	struct lttng_ht_node_str node;
	200	/* For delayed reclaim. */
	201	struct rcu_head rcu_head;
	202	};
	203
d0b96690 DG	204	/*
	205	* Validate that the id has reached the maximum allowed or not.
	206	*
	207	* Return 0 if NOT else 1.
	208	*/
	209	static inline int ust_registry_is_max_id(uint32_t id)
	210	{
	211	return (id == UINT32_MAX) ? 1 : 0;
	212	}
	213
	214	/*
	215	* Return next available event id and increment the used counter. The
	216	* ust_registry_is_max_id function MUST be called before in order to validate
	217	* if the maximum number of IDs have been reached. If not, it is safe to call
	218	* this function.
	219	*
	220	* Return a unique channel ID. If max is reached, the used_event_id counter is
	221	* returned.
	222	*/
	223	static inline uint32_t ust_registry_get_next_event_id(
	224	struct ust_registry_channel *r)
	225	{
	226	if (ust_registry_is_max_id(r->used_event_id)) {
	227	return r->used_event_id;
	228	}
	229
	230	r->used_event_id++;
	231	return r->next_event_id++;
	232	}
	233
	234	/*
	235	* Return next available channel id and increment the used counter. The
	236	* ust_registry_is_max_id function MUST be called before in order to validate
	237	* if the maximum number of IDs have been reached. If not, it is safe to call
	238	* this function.
	239	*
	240	* Return a unique channel ID. If max is reached, the used_channel_id counter
	241	* is returned.
	242	*/
	243	static inline uint32_t ust_registry_get_next_chan_id(
	244	struct ust_registry_session *r)
	245	{
	246	if (ust_registry_is_max_id(r->used_channel_id)) {
	247	return r->used_channel_id;
	248	}
	249
	250	r->used_channel_id++;
	251	return r->next_channel_id++;
	252	}
	253
	254	/*
	255	* Return registry event count. This is read atomically.
	256	*/
	257	static inline uint32_t ust_registry_get_event_count(
	258	struct ust_registry_channel *r)
	259	{
	260	return (uint32_t) uatomic_read(&r->used_event_id);
	261	}
	262
7972aab2 DG	263	#ifdef HAVE_LIBLTTNG_UST_CTL
7972aab2 DG	264
d0b96690 DG	265	void ust_registry_channel_destroy(struct ust_registry_session *session,
d0b96690 DG	266	struct ust_registry_channel *chan);
45893984 DG	267	struct ust_registry_channel *ust_registry_channel_find(
	268	struct ust_registry_session *session, uint64_t key);
	269	int ust_registry_channel_add(struct ust_registry_session *session,
	270	uint64_t key);
	271	void ust_registry_channel_del_free(struct ust_registry_session *session,
e9404c27	272	uint64_t key, bool notif);
45893984 DG	273
45893984 DG	274	int ust_registry_session_init(struct ust_registry_session **sessionp,
d0b96690 DG	275	struct ust_app *app,
	276	uint32_t bits_per_long,
	277	uint32_t uint8_t_alignment,
	278	uint32_t uint16_t_alignment,
	279	uint32_t uint32_t_alignment,
	280	uint32_t uint64_t_alignment,
	281	uint32_t long_alignment,
af6142cf MD	282	int byte_order,
af6142cf MD	283	uint32_t major,
d7ba1388	284	uint32_t minor,
3d071855	285	const char *root_shm_path,
d7ba1388 MD	286	const char *shm_path,
d7ba1388 MD	287	uid_t euid,
8de88061 JR	288	gid_t egid,
	289	uint64_t tracing_id,
	290	uid_t tracing_uid);
d0b96690 DG	291	void ust_registry_session_destroy(struct ust_registry_session *session);
	292
	293	int ust_registry_create_event(struct ust_registry_session *session,
45893984	294	uint64_t chan_key, int session_objd, int channel_objd, char *name,
b623cb6a	295	char sig, size_t nr_fields, struct lttng_ust_ctl_field fields,
2106efa0 PP	296	int loglevel_value, char *model_emf_uri, int buffer_type,
2106efa0 PP	297	uint32_t event_id_p, struct ust_app app);
d0b96690 DG	298	struct ust_registry_event *ust_registry_find_event(
	299	struct ust_registry_channel chan, char name, char *sig);
	300	void ust_registry_destroy_event(struct ust_registry_channel *chan,
	301	struct ust_registry_event *event);
	302
	303	/* app can be NULL for registry shared across applications. */
	304	int ust_metadata_session_statedump(struct ust_registry_session *session,
af6142cf	305	struct ust_app *app, uint32_t major, uint32_t minor);
d0b96690 DG	306	int ust_metadata_channel_statedump(struct ust_registry_session *session,
	307	struct ust_registry_channel *chan);
	308	int ust_metadata_event_statedump(struct ust_registry_session *session,
	309	struct ust_registry_channel *chan,
	310	struct ust_registry_event *event);
10b56aef MD	311	int ust_registry_create_or_find_enum(struct ust_registry_session *session,
10b56aef MD	312	int session_objd, char *name,
b623cb6a	313	struct lttng_ust_ctl_enum_entry *entries, size_t nr_entries,
10b56aef MD	314	uint64_t *enum_id);
	315	struct ust_registry_enum *
	316	ust_registry_lookup_enum_by_id(struct ust_registry_session *session,
	317	const char *name, uint64_t id);
d0b96690	318
7972aab2 DG	319	#else /* HAVE_LIBLTTNG_UST_CTL */
	320
	321	static inline
f46376a1 MJ	322	void ust_registry_channel_destroy(
	323	struct ust_registry_session *session __attribute__((unused)),
	324	struct ust_registry_channel *chan __attribute__((unused)))
7972aab2	325	{}
f46376a1	326
7972aab2 DG	327	static inline
7972aab2 DG	328	struct ust_registry_channel *ust_registry_channel_find(
f46376a1 MJ	329	struct ust_registry_session *session __attribute__((unused)),
f46376a1 MJ	330	uint64_t key __attribute__((unused)))
7972aab2 DG	331	{
	332	return NULL;
	333	}
f46376a1	334
7972aab2	335	static inline
f46376a1 MJ	336	int ust_registry_channel_add(
	337	struct ust_registry_session *session __attribute__((unused)),
	338	uint64_t key __attribute__((unused)))
7972aab2 DG	339	{
	340	return 0;
	341	}
f46376a1	342
7972aab2	343	static inline
f46376a1 MJ	344	void ust_registry_channel_del_free(
	345	struct ust_registry_session *session __attribute__((unused)),
	346	uint64_t key __attribute__((unused)),
	347	bool notif __attribute__((unused)))
7972aab2	348	{}
f46376a1	349
7972aab2	350	static inline
f46376a1 MJ	351	int ust_registry_session_init(
	352	struct ust_registry_session **sessionp __attribute__((unused)),
	353	struct ust_app *app __attribute__((unused)),
	354	uint32_t bits_per_long __attribute__((unused)),
	355	uint32_t uint8_t_alignment __attribute__((unused)),
	356	uint32_t uint16_t_alignment __attribute__((unused)),
	357	uint32_t uint32_t_alignment __attribute__((unused)),
	358	uint32_t uint64_t_alignment __attribute__((unused)),
	359	uint32_t long_alignment __attribute__((unused)),
	360	int byte_order __attribute__((unused)),
	361	uint32_t major __attribute__((unused)),
	362	uint32_t minor __attribute__((unused)),
	363	const char *root_shm_path __attribute__((unused)),
	364	const char *shm_path __attribute__((unused)),
	365	uid_t euid __attribute__((unused)),
	366	gid_t egid __attribute__((unused)),
	367	uint64_t tracing_id __attribute__((unused)),
	368	uid_t tracing_uid __attribute__((unused)))
7972aab2 DG	369	{
	370	return 0;
	371	}
f46376a1	372
7972aab2	373	static inline
f46376a1 MJ	374	void ust_registry_session_destroy(
f46376a1 MJ	375	struct ust_registry_session *session __attribute__((unused)))
7972aab2	376	{}
f46376a1	377
7972aab2	378	static inline
f46376a1 MJ	379	int ust_registry_create_event(
	380	struct ust_registry_session *session __attribute__((unused)),
	381	uint64_t chan_key __attribute__((unused)),
	382	int session_objd __attribute__((unused)),
	383	int channel_objd __attribute__((unused)),
	384	char *name __attribute__((unused)),
	385	char *sig __attribute__((unused)),
	386	size_t nr_fields __attribute__((unused)),
	387	struct lttng_ust_ctl_field *fields __attribute__((unused)),
	388	int loglevel_value __attribute__((unused)),
	389	char *model_emf_uri __attribute__((unused)),
	390	int buffer_type __attribute__((unused)),
	391	uint32_t *event_id_p __attribute__((unused)))
7972aab2 DG	392	{
	393	return 0;
	394	}
	395	static inline
	396	struct ust_registry_event *ust_registry_find_event(
f46376a1 MJ	397	struct ust_registry_channel *chan __attribute__((unused)),
	398	char *name __attribute__((unused)),
	399	char *sig __attribute__((unused)))
7972aab2 DG	400	{
	401	return NULL;
	402	}
f46376a1	403
7972aab2	404	static inline
f46376a1 MJ	405	void ust_registry_destroy_event(
	406	struct ust_registry_channel *chan __attribute__((unused)),
	407	struct ust_registry_event *event __attribute__((unused)))
7972aab2 DG	408	{}
	409
	410	/* The app object can be NULL for registry shared across applications. */
	411	static inline
f46376a1 MJ	412	int ust_metadata_session_statedump(
	413	struct ust_registry_session *session __attribute__((unused)),
	414	struct ust_app *app __attribute__((unused)),
	415	uint32_t major __attribute__((unused)),
	416	uint32_t minor __attribute__((unused)))
7972aab2 DG	417	{
	418	return 0;
	419	}
f46376a1	420
7972aab2	421	static inline
f46376a1 MJ	422	int ust_metadata_channel_statedump(
	423	struct ust_registry_session *session __attribute__((unused)),
	424	struct ust_registry_channel *chan __attribute__((unused)))
7972aab2 DG	425	{
	426	return 0;
	427	}
f46376a1	428
7972aab2	429	static inline
f46376a1 MJ	430	int ust_metadata_event_statedump(
	431	struct ust_registry_session *session __attribute__((unused)),
	432	struct ust_registry_channel *chan __attribute__((unused)),
	433	struct ust_registry_event *event __attribute__((unused)))
7972aab2 DG	434	{
	435	return 0;
	436	}
f46376a1	437
10b56aef	438	static inline
f46376a1 MJ	439	int ust_registry_create_or_find_enum(
	440	struct ust_registry_session *session __attribute__((unused)),
	441	int session_objd __attribute__((unused)),
	442	char *name __attribute__((unused)),
	443	struct lttng_ust_ctl_enum_entry *entries __attribute__((unused)),
	444	size_t nr_entries __attribute__((unused)),
	445	uint64_t *enum_id __attribute__((unused)))
10b56aef MD	446	{
	447	return 0;
	448	}
f46376a1	449
10b56aef MD	450	static inline
10b56aef MD	451	struct ust_registry_enum *
f46376a1 MJ	452	ust_registry_lookup_enum_by_id(
	453	struct ust_registry_session *session __attribute__((unused)),
	454	const char *name __attribute__((unused)),
	455	uint64_t id __attribute__((unused)))
10b56aef MD	456	{
	457	return NULL;
	458	}
7972aab2 DG	459
	460	#endif /* HAVE_LIBLTTNG_UST_CTL */
	461
d0b96690	462	#endif /* LTTNG_UST_REGISTRY_H */