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

/*
 * Copyright (C) 2013 - David Goulet <dgoulet@efficios.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License, version 2 only, as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 51
 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef LTTNG_UST_REGISTRY_H
#define LTTNG_UST_REGISTRY_H

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

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

#include "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[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 ustctl_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 ustctl_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_SYM_NAME_LEN];
	char *signature;
	int loglevel_value;
	size_t nr_fields;
	struct ustctl_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_SYM_NAME_LEN];
	struct ustctl_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 ustctl_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 ustctl_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,
		struct ust_registry_channel *chan)
{}
static inline
struct ust_registry_channel *ust_registry_channel_find(
		struct ust_registry_session *session, uint64_t key)
{
	return NULL;
}
static inline
int ust_registry_channel_add(struct ust_registry_session *session,
		uint64_t key)
{
	return 0;
}
static inline
void ust_registry_channel_del_free(struct ust_registry_session *session,
		uint64_t key, bool notif)
{}
static inline
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);
{
	return 0;
}
static inline
void ust_registry_session_destroy(struct ust_registry_session *session)
{}
static inline
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 ustctl_field *fields,
		int loglevel_value, char *model_emf_uri, int buffer_type,
		uint32_t *event_id_p)
{
	return 0;
}
static inline
struct ust_registry_event *ust_registry_find_event(
		struct ust_registry_channel *chan, char *name, char *sig)
{
	return NULL;
}
static inline
void ust_registry_destroy_event(struct ust_registry_channel *chan,
		struct ust_registry_event *event)
{}

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

#endif /* HAVE_LIBLTTNG_UST_CTL */

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