[lttng-tools.git] / src / bin / lttng-sessiond / buffer-registry.c

/*
 * 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.
 */

#define _GNU_SOURCE
#include <inttypes.h>

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

#include "buffer-registry.h"
#include "fd-limit.h"
#include "ust-consumer.h"
#include "ust-ctl.h"
#include "utils.h"

/*
 * Set in main.c during initialization process of the daemon. This contains
 * buffer_reg_uid object which are global registry for per UID buffer. Object
 * are indexed by session id and matched by the triplet
 * <session_id/bits_per_long/uid>.
 */
static struct lttng_ht *buffer_registry_uid;

/*
 * Initialized at the daemon start. This contains buffer_reg_pid object and
 * indexed by session id.
 */
static struct lttng_ht *buffer_registry_pid;

/*
 * Match function for the per UID registry hash table. It matches a registry
 * uid object with the triplet <session_id/abi/uid>.
 */
static int ht_match_reg_uid(struct cds_lfht_node *node, const void *_key)
{
	struct buffer_reg_uid *reg;
	const struct buffer_reg_uid *key;

	assert(node);
	assert(_key);

	reg = caa_container_of(node, struct buffer_reg_uid, node.node);
	assert(reg);
	key = _key;

	if (key->session_id != reg->session_id ||
			key->bits_per_long != reg->bits_per_long ||
			key->uid != reg->uid) {
		goto no_match;
	}

	/* Match */
	return 1;
no_match:
	return 0;
}

/*
 * Hash function for the per UID registry hash table. This XOR the triplet
 * together.
 */
static unsigned long ht_hash_reg_uid(void *_key, unsigned long seed)
{
	uint64_t xored_key;
	struct buffer_reg_uid *key = _key;

	assert(key);

	xored_key = (uint64_t)(key->session_id ^ key->bits_per_long ^ key->uid);
	return hash_key_u64(&xored_key, seed);
}

/*
 * Initialize global buffer per UID registry. Should only be called ONCE!.
 */
void buffer_reg_init_uid_registry(void)
{
	/* Should be called once. */
	assert(!buffer_registry_uid);
	buffer_registry_uid = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
	assert(buffer_registry_uid);
	buffer_registry_uid->match_fct = ht_match_reg_uid;
	buffer_registry_uid->hash_fct = ht_hash_reg_uid;

	DBG3("Global buffer per UID registry initialized");
}

/*
 * Allocate and initialize object. Set regp with the object pointer.
 *
 * Return 0 on success else a negative value and regp is untouched.
 */
int buffer_reg_uid_create(uint64_t session_id, uint32_t bits_per_long, uid_t uid,
		enum lttng_domain_type domain, struct buffer_reg_uid **regp)
{
	int ret = 0;
	struct buffer_reg_uid *reg = NULL;

	assert(regp);

	reg = zmalloc(sizeof(*reg));
	if (!reg) {
		PERROR("zmalloc buffer registry uid");
		ret = -ENOMEM;
		goto error;
	}

	reg->registry = zmalloc(sizeof(struct buffer_reg_session));
	if (!reg->registry) {
		PERROR("zmalloc buffer registry uid session");
		ret = -ENOMEM;
		goto error;
	}

	reg->session_id = session_id;
	reg->bits_per_long = bits_per_long;
	reg->uid = uid;
	reg->domain = domain;

	reg->registry->channels = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
	if (!reg->registry->channels) {
		ret = -ENOMEM;
		goto error_session;
	}

	cds_lfht_node_init(&reg->node.node);
	*regp = reg;

	DBG3("Buffer registry per UID created id: %" PRIu64 ", ABI: %u, uid: %d, domain: %d",
			session_id, bits_per_long, uid, domain);

	return 0;

error_session:
	free(reg->registry);
error:
	free(reg);
	return ret;
}

/*
 * Add a buffer registry per UID object to the global registry.
 */
void buffer_reg_uid_add(struct buffer_reg_uid *reg)
{
	struct cds_lfht_node *nodep;
	struct lttng_ht *ht = buffer_registry_uid;

	assert(reg);

	DBG3("Buffer registry per UID adding to global registry with id: %" PRIu64 ,
			reg->session_id);

	rcu_read_lock();
	nodep = cds_lfht_add_unique(ht->ht, ht->hash_fct(reg, lttng_ht_seed),
			ht->match_fct, reg, &reg->node.node);
	assert(nodep == &reg->node.node);
	rcu_read_unlock();
}

/*
 * Find a buffer registry per UID object with given params. RCU read side lock
 * MUST be acquired before calling this and hold on to protect the object.
 *
 * Return the object pointer or NULL on error.
 */
struct buffer_reg_uid *buffer_reg_uid_find(uint64_t session_id,
		uint32_t bits_per_long, uid_t uid)
{
	struct lttng_ht_node_u64 *node;
	struct lttng_ht_iter iter;
	struct buffer_reg_uid *reg = NULL, key;
	struct lttng_ht *ht = buffer_registry_uid;

	/* Setup key we are looking for. */
	key.session_id = session_id;
	key.bits_per_long = bits_per_long;
	key.uid = uid;

	DBG3("Buffer registry per UID find id: %" PRIu64 ", ABI: %u, uid: %d",
			session_id, bits_per_long, uid);

	/* Custom lookup function since it's a different key. */
	cds_lfht_lookup(ht->ht, ht->hash_fct(&key, lttng_ht_seed), ht->match_fct,
			&key, &iter.iter);
	node = lttng_ht_iter_get_node_u64(&iter);
	if (!node) {
		goto end;
	}
	reg = caa_container_of(node, struct buffer_reg_uid, node);

end:
	return reg;
}

/*
 * Initialize global buffer per PID registry. Should only be called ONCE!.
 */
void buffer_reg_init_pid_registry(void)
{
	/* Should be called once. */
	assert(!buffer_registry_pid);
	buffer_registry_pid = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
	assert(buffer_registry_pid);

	DBG3("Global buffer per PID registry initialized");
}

/*
 * Allocate and initialize object. Set regp with the object pointer.
 *
 * Return 0 on success else a negative value and regp is untouched.
 */
int buffer_reg_pid_create(uint64_t session_id, struct buffer_reg_pid **regp)
{
	int ret = 0;
	struct buffer_reg_pid *reg = NULL;

	assert(regp);

	reg = zmalloc(sizeof(*reg));
	if (!reg) {
		PERROR("zmalloc buffer registry pid");
		ret = -ENOMEM;
		goto error;
	}

	reg->registry = zmalloc(sizeof(struct buffer_reg_session));
	if (!reg->registry) {
		PERROR("zmalloc buffer registry pid session");
		ret = -ENOMEM;
		goto error;
	}

	/* A cast is done here so we can use the session ID as a u64 ht node. */
	reg->session_id = session_id;

	reg->registry->channels = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
	if (!reg->registry->channels) {
		ret = -ENOMEM;
		goto error_session;
	}

	lttng_ht_node_init_u64(&reg->node, reg->session_id);
	*regp = reg;

	DBG3("Buffer registry per PID created with session id: %" PRIu64,
			session_id);

	return 0;

error_session:
	free(reg->registry);
error:
	free(reg);
	return ret;
}

/*
 * Add a buffer registry per PID object to the global registry.
 */
void buffer_reg_pid_add(struct buffer_reg_pid *reg)
{
	assert(reg);

	DBG3("Buffer registry per PID adding to global registry with id: %" PRIu64,
			reg->session_id);

	rcu_read_lock();
	lttng_ht_add_unique_u64(buffer_registry_pid, &reg->node);
	rcu_read_unlock();
}

/*
 * Find a buffer registry per PID object with given params. RCU read side lock
 * MUST be acquired before calling this and hold on to protect the object.
 *
 * Return the object pointer or NULL on error.
 */
struct buffer_reg_pid *buffer_reg_pid_find(uint64_t session_id)
{
	struct lttng_ht_node_u64 *node;
	struct lttng_ht_iter iter;
	struct buffer_reg_pid *reg = NULL;
	struct lttng_ht *ht = buffer_registry_pid;

	DBG3("Buffer registry per PID find id: %" PRIu64, session_id);

	lttng_ht_lookup(ht, &session_id, &iter);
	node = lttng_ht_iter_get_node_u64(&iter);
	if (!node) {
		goto end;
	}
	reg = caa_container_of(node, struct buffer_reg_pid, node);

end:
	return reg;
}

/*
 * Allocate and initialize a buffer registry channel with the given key. Set
 * regp with the object pointer.
 *
 * Return 0 on success or else a negative value keeping regp untouched.
 */
int buffer_reg_channel_create(uint64_t key, struct buffer_reg_channel **regp)
{
	struct buffer_reg_channel *reg;

	assert(regp);

	DBG3("Buffer registry channel create with key: %" PRIu64, key);

	reg = zmalloc(sizeof(*reg));
	if (!reg) {
		PERROR("zmalloc buffer registry channel");
		return -ENOMEM;
	}

	reg->key = key;
	CDS_INIT_LIST_HEAD(&reg->streams);
	pthread_mutex_init(&reg->stream_list_lock, NULL);

	lttng_ht_node_init_u64(&reg->node, key);
	*regp = reg;

	return 0;
}

/*
 * Allocate and initialize a buffer registry stream. Set regp with the object
 * pointer.
 *
 * Return 0 on success or else a negative value keeping regp untouched.
 */
int buffer_reg_stream_create(struct buffer_reg_stream **regp)
{
	struct buffer_reg_stream *reg;

	assert(regp);

	DBG3("Buffer registry creating stream");

	reg = zmalloc(sizeof(*reg));
	if (!reg) {
		PERROR("zmalloc buffer registry stream");
		return -ENOMEM;
	}

	*regp = reg;

	return 0;
}

/*
 * Add stream to the list in the channel.
 */
void buffer_reg_stream_add(struct buffer_reg_stream *stream,
		struct buffer_reg_channel *channel)
{
	assert(stream);
	assert(channel);

	pthread_mutex_lock(&channel->stream_list_lock);
	cds_list_add_tail(&stream->lnode, &channel->streams);
	pthread_mutex_unlock(&channel->stream_list_lock);
}

/*
 * Add a buffer registry channel object to the given session.
 */
void buffer_reg_channel_add(struct buffer_reg_session *session,
		struct buffer_reg_channel *channel)
{
	assert(session);
	assert(channel);

	rcu_read_lock();
	lttng_ht_add_unique_u64(session->channels, &channel->node);
	rcu_read_unlock();
}

/*
 * Find a buffer registry channel object with the given key. RCU read side lock
 * MUST be acquired and hold on until the object reference is not needed
 * anymore.
 *
 * Return the object pointer or NULL on error.
 */
struct buffer_reg_channel *buffer_reg_channel_find(uint64_t key,
		struct buffer_reg_uid *reg)
{
	struct lttng_ht_node_u64 *node;
	struct lttng_ht_iter iter;
	struct buffer_reg_channel *chan = NULL;
	struct lttng_ht *ht;

	assert(reg);

	switch (reg->domain) {
	case LTTNG_DOMAIN_UST:
		ht = reg->registry->channels;
		break;
	default:
		assert(0);
		goto end;
	}

	lttng_ht_lookup(ht, &key, &iter);
	node = lttng_ht_iter_get_node_u64(&iter);
	if (!node) {
		goto end;
	}
	chan = caa_container_of(node, struct buffer_reg_channel, node);

end:
	return chan;
}

/*
 * Destroy a buffer registry stream with the given domain.
 */
void buffer_reg_stream_destroy(struct buffer_reg_stream *regp,
		enum lttng_domain_type domain)
{
	if (!regp) {
		return;
	}

	DBG3("Buffer registry stream destroy with handle %d",
			regp->obj.ust->handle);

	switch (domain) {
	case LTTNG_DOMAIN_UST:
	{
		int ret;

		ret = ust_ctl_release_object(-1, regp->obj.ust);
		if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
			ERR("Buffer reg stream release obj handle %d failed with ret %d",
					regp->obj.ust->handle, ret);
		}
		free(regp->obj.ust);
		lttng_fd_put(LTTNG_FD_APPS, 2);
		break;
	}
	default:
		assert(0);
	}

	free(regp);
	return;
}

/*
 * Remove buffer registry channel object from the session hash table. RCU read
 * side lock MUST be acquired before calling this.
 */
void buffer_reg_channel_remove(struct buffer_reg_session *session,
		struct buffer_reg_channel *regp)
{
	int ret;
	struct lttng_ht_iter iter;

	assert(session);
	assert(regp);

	iter.iter.node = &regp->node.node;
	ret = lttng_ht_del(session->channels, &iter);
	assert(!ret);
}

/*
 * Destroy a buffer registry channel with the given domain.
 */
void buffer_reg_channel_destroy(struct buffer_reg_channel *regp,
		enum lttng_domain_type domain)
{
	if (!regp) {
		return;
	}

	DBG3("Buffer registry channel destroy with key %" PRIu32, regp->key);

	switch (domain) {
	case LTTNG_DOMAIN_UST:
	{
		int ret;
		struct buffer_reg_stream *sreg, *stmp;
		/* Wipe stream */
		cds_list_for_each_entry_safe(sreg, stmp, &regp->streams, lnode) {
			cds_list_del(&sreg->lnode);
			buffer_reg_stream_destroy(sreg, domain);
		}

		if (regp->obj.ust) {
			ret = ust_ctl_release_object(-1, regp->obj.ust);
			if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
				ERR("Buffer reg channel release obj handle %d failed with ret %d",
						regp->obj.ust->handle, ret);
			}
			free(regp->obj.ust);
		}
		lttng_fd_put(LTTNG_FD_APPS, 1);
		break;
	}
	default:
		assert(0);
	}

	free(regp);
	return;
}

/*
 * Destroy a buffer registry session with the given domain.
 *
 * Should *NOT* be called with RCU read-side lock held.
 */
static void buffer_reg_session_destroy(struct buffer_reg_session *regp,
		enum lttng_domain_type domain)
{
	int ret;
	struct lttng_ht_iter iter;
	struct buffer_reg_channel *reg_chan;

	DBG3("Buffer registry session destroy");

	/* Destroy all channels. */
	rcu_read_lock();
	cds_lfht_for_each_entry(regp->channels->ht, &iter.iter, reg_chan,
			node.node) {
		ret = lttng_ht_del(regp->channels, &iter);
		assert(!ret);
		buffer_reg_channel_destroy(reg_chan, domain);
	}
	rcu_read_unlock();

	ht_cleanup_push(regp->channels);

	switch (domain) {
	case LTTNG_DOMAIN_UST:
		ust_registry_session_destroy(regp->reg.ust);
		free(regp->reg.ust);
		break;
	default:
		assert(0);
	}

	free(regp);
	return;
}

/*
 * Remove buffer registry UID object from the global hash table.
 */
void buffer_reg_uid_remove(struct buffer_reg_uid *regp)
{
	int ret;
	struct lttng_ht_iter iter;

	assert(regp);

	rcu_read_lock();
	iter.iter.node = &regp->node.node;
	ret = lttng_ht_del(buffer_registry_uid, &iter);
	assert(!ret);
	rcu_read_unlock();
}

static void rcu_free_buffer_reg_uid(struct rcu_head *head)
{
	struct lttng_ht_node_u64 *node =
		caa_container_of(head, struct lttng_ht_node_u64, head);
	struct buffer_reg_uid *reg =
		caa_container_of(node, struct buffer_reg_uid, node);

	buffer_reg_session_destroy(reg->registry, reg->domain);
	free(reg);
}

static void rcu_free_buffer_reg_pid(struct rcu_head *head)
{
	struct lttng_ht_node_u64 *node =
		caa_container_of(head, struct lttng_ht_node_u64, head);
	struct buffer_reg_pid *reg =
		caa_container_of(node, struct buffer_reg_pid, node);

	buffer_reg_session_destroy(reg->registry, LTTNG_DOMAIN_UST);
	free(reg);
}

/*
 * Destroy buffer registry per UID. The given pointer is NOT removed from any
 * list or hash table. Use buffer_reg_pid_remove() before calling this function
 * for the case that the object is in the global hash table.
 */
void buffer_reg_uid_destroy(struct buffer_reg_uid *regp,
		struct consumer_output *consumer)
{
	struct consumer_socket *socket;

	if (!regp) {
		return;
	}

	DBG3("Buffer registry per UID destroy with id: %" PRIu64 ", ABI: %u, uid: %d",
			regp->session_id, regp->bits_per_long, regp->uid);

	if (!consumer) {
		goto destroy;
	}

	rcu_read_lock();
	/* Get the right socket from the consumer object. */
	socket = consumer_find_socket_by_bitness(regp->bits_per_long,
			consumer);
	if (!socket) {
		goto unlock;
	}

	switch (regp->domain) {
	case LTTNG_DOMAIN_UST:
		if (regp->registry->reg.ust->metadata_key) {
			/* Return value does not matter. This call will print errors. */
			(void) consumer_close_metadata(socket,
					regp->registry->reg.ust->metadata_key);
		}
		break;
	default:
		assert(0);
		rcu_read_unlock();
		return;
	}

unlock:
	rcu_read_unlock();
destroy:
	call_rcu(&regp->node.head, rcu_free_buffer_reg_uid);
}

/*
 * Remove buffer registry UID object from the global hash table. RCU read side
 * lock MUST be acquired before calling this.
 */
void buffer_reg_pid_remove(struct buffer_reg_pid *regp)
{
	int ret;
	struct lttng_ht_iter iter;

	assert(regp);

	iter.iter.node = &regp->node.node;
	ret = lttng_ht_del(buffer_registry_pid, &iter);
	assert(!ret);
}

/*
 * Destroy buffer registry per PID. The pointer is NOT removed from the global
 * hash table. Call buffer_reg_pid_remove() before that if the object was
 * previously added to the global hash table.
 */
void buffer_reg_pid_destroy(struct buffer_reg_pid *regp)
{
	if (!regp) {
		return;
	}

	DBG3("Buffer registry per PID destroy with id: %" PRIu64,
			regp->session_id);

	/* This registry is only used by UST. */
	call_rcu(&regp->node.head, rcu_free_buffer_reg_pid);
}

/*
 * Destroy per PID and UID registry hash table.
 *
 * Should *NOT* be called with RCU read-side lock held.
 */
void buffer_reg_destroy_registries(void)
{
	DBG3("Buffer registry destroy all registry");
	ht_cleanup_push(buffer_registry_uid);
	ht_cleanup_push(buffer_registry_pid);
}
Commit	Line	Data
7972aab2 DG	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	#define _GNU_SOURCE
	19	#include <inttypes.h>
	20
	21	#include <common/common.h>
	22	#include <common/hashtable/utils.h>
	23
	24	#include "buffer-registry.h"
	25	#include "fd-limit.h"
	26	#include "ust-consumer.h"
	27	#include "ust-ctl.h"
0b2dc8df	28	#include "utils.h"
7972aab2 DG	29
	30	/*
	31	* Set in main.c during initialization process of the daemon. This contains
	32	* buffer_reg_uid object which are global registry for per UID buffer. Object
	33	* are indexed by session id and matched by the triplet
	34	* <session_id/bits_per_long/uid>.
	35	*/
	36	static struct lttng_ht *buffer_registry_uid;
	37
	38	/*
	39	* Initialized at the daemon start. This contains buffer_reg_pid object and
	40	* indexed by session id.
	41	*/
	42	static struct lttng_ht *buffer_registry_pid;
	43
	44	/*
	45	* Match function for the per UID registry hash table. It matches a registry
	46	* uid object with the triplet <session_id/abi/uid>.
	47	*/
	48	static int ht_match_reg_uid(struct cds_lfht_node node, const void _key)
	49	{
	50	struct buffer_reg_uid *reg;
	51	const struct buffer_reg_uid *key;
	52
	53	assert(node);
	54	assert(_key);
	55
	56	reg = caa_container_of(node, struct buffer_reg_uid, node.node);
	57	assert(reg);
	58	key = _key;
	59
	60	if (key->session_id != reg->session_id \|\|
	61	key->bits_per_long != reg->bits_per_long \|\|
	62	key->uid != reg->uid) {
	63	goto no_match;
	64	}
	65
	66	/* Match */
	67	return 1;
	68	no_match:
	69	return 0;
	70	}
	71
	72	/*
	73	* Hash function for the per UID registry hash table. This XOR the triplet
	74	* together.
	75	*/
	76	static unsigned long ht_hash_reg_uid(void *_key, unsigned long seed)
	77	{
	78	uint64_t xored_key;
	79	struct buffer_reg_uid *key = _key;
	80
	81	assert(key);
	82
	83	xored_key = (uint64_t)(key->session_id ^ key->bits_per_long ^ key->uid);
	84	return hash_key_u64(&xored_key, seed);
	85	}
	86
	87	/*
	88	* Initialize global buffer per UID registry. Should only be called ONCE!.
	89	*/
	90	void buffer_reg_init_uid_registry(void)
	91	{
	92	/* Should be called once. */
93	assert(!buffer_registry_uid);
94	buffer_registry_uid = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
95	assert(buffer_registry_uid);
96	buffer_registry_uid->match_fct = ht_match_reg_uid;
97	buffer_registry_uid->hash_fct = ht_hash_reg_uid;
98
99	DBG3("Global buffer per UID registry initialized");
100	}
101
102	/*
103	* Allocate and initialize object. Set regp with the object pointer.
104	*
105	* Return 0 on success else a negative value and regp is untouched.
106	*/
d9bf3ca4	107	int buffer_reg_uid_create(uint64_t session_id, uint32_t bits_per_long, uid_t uid,
7972aab2 DG	108	enum lttng_domain_type domain, struct buffer_reg_uid **regp)
	109	{
	110	int ret = 0;
	111	struct buffer_reg_uid *reg = NULL;
	112
	113	assert(regp);
	114
	115	reg = zmalloc(sizeof(*reg));
	116	if (!reg) {
	117	PERROR("zmalloc buffer registry uid");
	118	ret = -ENOMEM;
	119	goto error;
	120	}
	121
	122	reg->registry = zmalloc(sizeof(struct buffer_reg_session));
63c861bd	123	if (!reg->registry) {
7972aab2 DG	124	PERROR("zmalloc buffer registry uid session");
	125	ret = -ENOMEM;
	126	goto error;
	127	}
	128
	129	reg->session_id = session_id;
	130	reg->bits_per_long = bits_per_long;
	131	reg->uid = uid;
	132	reg->domain = domain;
	133
	134	reg->registry->channels = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
	135	if (!reg->registry->channels) {
	136	ret = -ENOMEM;
	137	goto error_session;
	138	}
	139
	140	cds_lfht_node_init(&reg->node.node);
	141	*regp = reg;
	142
d9bf3ca4	143	DBG3("Buffer registry per UID created id: %" PRIu64 ", ABI: %u, uid: %d, domain: %d",
7972aab2 DG	144	session_id, bits_per_long, uid, domain);
	145
	146	return 0;
	147
	148	error_session:
	149	free(reg->registry);
	150	error:
	151	free(reg);
	152	return ret;
	153	}
	154
	155	/*
	156	* Add a buffer registry per UID object to the global registry.
	157	*/
	158	void buffer_reg_uid_add(struct buffer_reg_uid *reg)
	159	{
	160	struct cds_lfht_node *nodep;
	161	struct lttng_ht *ht = buffer_registry_uid;
	162
	163	assert(reg);
	164
d9bf3ca4	165	DBG3("Buffer registry per UID adding to global registry with id: %" PRIu64 ,
7972aab2 DG	166	reg->session_id);
	167
	168	rcu_read_lock();
	169	nodep = cds_lfht_add_unique(ht->ht, ht->hash_fct(reg, lttng_ht_seed),
	170	ht->match_fct, reg, &reg->node.node);
	171	assert(nodep == &reg->node.node);
	172	rcu_read_unlock();
	173	}
	174
	175	/*
	176	* Find a buffer registry per UID object with given params. RCU read side lock
	177	* MUST be acquired before calling this and hold on to protect the object.
	178	*
	179	* Return the object pointer or NULL on error.
	180	*/
d9bf3ca4	181	struct buffer_reg_uid *buffer_reg_uid_find(uint64_t session_id,
7972aab2 DG	182	uint32_t bits_per_long, uid_t uid)
	183	{
	184	struct lttng_ht_node_u64 *node;
	185	struct lttng_ht_iter iter;
	186	struct buffer_reg_uid *reg = NULL, key;
	187	struct lttng_ht *ht = buffer_registry_uid;
	188
	189	/* Setup key we are looking for. */
	190	key.session_id = session_id;
	191	key.bits_per_long = bits_per_long;
	192	key.uid = uid;
	193
d9bf3ca4	194	DBG3("Buffer registry per UID find id: %" PRIu64 ", ABI: %u, uid: %d",
7972aab2 DG	195	session_id, bits_per_long, uid);
	196
	197	/* Custom lookup function since it's a different key. */
	198	cds_lfht_lookup(ht->ht, ht->hash_fct(&key, lttng_ht_seed), ht->match_fct,
	199	&key, &iter.iter);
	200	node = lttng_ht_iter_get_node_u64(&iter);
	201	if (!node) {
	202	goto end;
	203	}
	204	reg = caa_container_of(node, struct buffer_reg_uid, node);
	205
	206	end:
	207	return reg;
	208	}
	209
	210	/*
	211	* Initialize global buffer per PID registry. Should only be called ONCE!.
	212	*/
	213	void buffer_reg_init_pid_registry(void)
	214	{
	215	/* Should be called once. */
	216	assert(!buffer_registry_pid);
d9bf3ca4	217	buffer_registry_pid = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
7972aab2 DG	218	assert(buffer_registry_pid);
	219
	220	DBG3("Global buffer per PID registry initialized");
	221	}
	222
	223	/*
	224	* Allocate and initialize object. Set regp with the object pointer.
	225	*
	226	* Return 0 on success else a negative value and regp is untouched.
	227	*/
d9bf3ca4	228	int buffer_reg_pid_create(uint64_t session_id, struct buffer_reg_pid **regp)
7972aab2 DG	229	{
	230	int ret = 0;
	231	struct buffer_reg_pid *reg = NULL;
	232
	233	assert(regp);
	234
	235	reg = zmalloc(sizeof(*reg));
	236	if (!reg) {
	237	PERROR("zmalloc buffer registry pid");
	238	ret = -ENOMEM;
	239	goto error;
	240	}
	241
	242	reg->registry = zmalloc(sizeof(struct buffer_reg_session));
63c861bd	243	if (!reg->registry) {
7972aab2 DG	244	PERROR("zmalloc buffer registry pid session");
	245	ret = -ENOMEM;
	246	goto error;
	247	}
	248
	249	/* A cast is done here so we can use the session ID as a u64 ht node. */
	250	reg->session_id = session_id;
	251
	252	reg->registry->channels = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
	253	if (!reg->registry->channels) {
	254	ret = -ENOMEM;
	255	goto error_session;
	256	}
	257
d9bf3ca4	258	lttng_ht_node_init_u64(&reg->node, reg->session_id);
7972aab2 DG	259	*regp = reg;
7972aab2 DG	260
d9bf3ca4 MD	261	DBG3("Buffer registry per PID created with session id: %" PRIu64,
d9bf3ca4 MD	262	session_id);
7972aab2 DG	263
	264	return 0;
	265
	266	error_session:
	267	free(reg->registry);
	268	error:
	269	free(reg);
	270	return ret;
	271	}
	272
	273	/*
	274	* Add a buffer registry per PID object to the global registry.
	275	*/
	276	void buffer_reg_pid_add(struct buffer_reg_pid *reg)
	277	{
	278	assert(reg);
	279
d9bf3ca4	280	DBG3("Buffer registry per PID adding to global registry with id: %" PRIu64,
7972aab2 DG	281	reg->session_id);
	282
	283	rcu_read_lock();
d9bf3ca4	284	lttng_ht_add_unique_u64(buffer_registry_pid, &reg->node);
7972aab2 DG	285	rcu_read_unlock();
	286	}
	287
	288	/*
	289	* Find a buffer registry per PID object with given params. RCU read side lock
	290	* MUST be acquired before calling this and hold on to protect the object.
	291	*
	292	* Return the object pointer or NULL on error.
	293	*/
d9bf3ca4	294	struct buffer_reg_pid *buffer_reg_pid_find(uint64_t session_id)
7972aab2	295	{
d9bf3ca4	296	struct lttng_ht_node_u64 *node;
7972aab2 DG	297	struct lttng_ht_iter iter;
	298	struct buffer_reg_pid *reg = NULL;
	299	struct lttng_ht *ht = buffer_registry_pid;
	300
d9bf3ca4	301	DBG3("Buffer registry per PID find id: %" PRIu64, session_id);
7972aab2	302
d9bf3ca4 MD	303	lttng_ht_lookup(ht, &session_id, &iter);
d9bf3ca4 MD	304	node = lttng_ht_iter_get_node_u64(&iter);
7972aab2 DG	305	if (!node) {
	306	goto end;
	307	}
	308	reg = caa_container_of(node, struct buffer_reg_pid, node);
	309
	310	end:
	311	return reg;
	312	}
	313
	314	/*
	315	* Allocate and initialize a buffer registry channel with the given key. Set
	316	* regp with the object pointer.
	317	*
	318	* Return 0 on success or else a negative value keeping regp untouched.
	319	*/
	320	int buffer_reg_channel_create(uint64_t key, struct buffer_reg_channel **regp)
	321	{
	322	struct buffer_reg_channel *reg;
	323
	324	assert(regp);
	325
	326	DBG3("Buffer registry channel create with key: %" PRIu64, key);
	327
	328	reg = zmalloc(sizeof(*reg));
	329	if (!reg) {
	330	PERROR("zmalloc buffer registry channel");
	331	return -ENOMEM;
	332	}
	333
	334	reg->key = key;
	335	CDS_INIT_LIST_HEAD(&reg->streams);
	336	pthread_mutex_init(&reg->stream_list_lock, NULL);
	337
	338	lttng_ht_node_init_u64(&reg->node, key);
	339	*regp = reg;
	340
	341	return 0;
	342	}
	343
	344	/*
	345	* Allocate and initialize a buffer registry stream. Set regp with the object
	346	* pointer.
	347	*
	348	* Return 0 on success or else a negative value keeping regp untouched.
	349	*/
	350	int buffer_reg_stream_create(struct buffer_reg_stream **regp)
	351	{
	352	struct buffer_reg_stream *reg;
	353
	354	assert(regp);
	355
	356	DBG3("Buffer registry creating stream");
	357
	358	reg = zmalloc(sizeof(*reg));
	359	if (!reg) {
	360	PERROR("zmalloc buffer registry stream");
	361	return -ENOMEM;
	362	}
	363
	364	*regp = reg;
	365
	366	return 0;
	367	}
	368
369	/*
370	* Add stream to the list in the channel.
371	*/
372	void buffer_reg_stream_add(struct buffer_reg_stream *stream,
373	struct buffer_reg_channel *channel)
374	{
375	assert(stream);
376	assert(channel);
377
378	pthread_mutex_lock(&channel->stream_list_lock);
379	cds_list_add_tail(&stream->lnode, &channel->streams);
380	pthread_mutex_unlock(&channel->stream_list_lock);
381	}
382
383	/*
384	* Add a buffer registry channel object to the given session.
385	*/
386	void buffer_reg_channel_add(struct buffer_reg_session *session,
387	struct buffer_reg_channel *channel)
388	{
389	assert(session);
390	assert(channel);
391
392	rcu_read_lock();
393	lttng_ht_add_unique_u64(session->channels, &channel->node);
394	rcu_read_unlock();
395	}
396
397	/*
398	* Find a buffer registry channel object with the given key. RCU read side lock
399	* MUST be acquired and hold on until the object reference is not needed
400	* anymore.
401	*
402	* Return the object pointer or NULL on error.
403	*/
404	struct buffer_reg_channel *buffer_reg_channel_find(uint64_t key,
405	struct buffer_reg_uid *reg)
406	{
407	struct lttng_ht_node_u64 *node;
408	struct lttng_ht_iter iter;
409	struct buffer_reg_channel *chan = NULL;
410	struct lttng_ht *ht;
411
412	assert(reg);
413
414	switch (reg->domain) {
415	case LTTNG_DOMAIN_UST:
416	ht = reg->registry->channels;
417	break;
418	default:
419	assert(0);
420	goto end;
421	}
422
423	lttng_ht_lookup(ht, &key, &iter);
424	node = lttng_ht_iter_get_node_u64(&iter);
425	if (!node) {
426	goto end;
427	}
428	chan = caa_container_of(node, struct buffer_reg_channel, node);
429
430	end:
431	return chan;
432	}
433
434	/*
435	* Destroy a buffer registry stream with the given domain.
436	*/
437	void buffer_reg_stream_destroy(struct buffer_reg_stream *regp,
438	enum lttng_domain_type domain)
439	{
440	if (!regp) {
441	return;
442	}
443
444	DBG3("Buffer registry stream destroy with handle %d",
445	regp->obj.ust->handle);
446
447	switch (domain) {
448	case LTTNG_DOMAIN_UST:
449	{
450	int ret;
451
452	ret = ust_ctl_release_object(-1, regp->obj.ust);
453	if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
454	ERR("Buffer reg stream release obj handle %d failed with ret %d",
455	regp->obj.ust->handle, ret);
456	}
457	free(regp->obj.ust);
458	lttng_fd_put(LTTNG_FD_APPS, 2);
459	break;
460	}
461	default:
462	assert(0);
463	}
464
465	free(regp);
466	return;
467	}
468
469	/*
470	* Remove buffer registry channel object from the session hash table. RCU read
471	* side lock MUST be acquired before calling this.
472	*/
473	void buffer_reg_channel_remove(struct buffer_reg_session *session,
474	struct buffer_reg_channel *regp)
475	{
476	int ret;
477	struct lttng_ht_iter iter;
478
479	assert(session);
480	assert(regp);
481
482	iter.iter.node = &regp->node.node;
483	ret = lttng_ht_del(session->channels, &iter);
484	assert(!ret);
485	}
486
487	/*
488	* Destroy a buffer registry channel with the given domain.
489	*/
490	void buffer_reg_channel_destroy(struct buffer_reg_channel *regp,
491	enum lttng_domain_type domain)
492	{
493	if (!regp) {
494	return;
495	}
496
07d2ae95	497	DBG3("Buffer registry channel destroy with key %" PRIu32, regp->key);
7972aab2 DG	498
	499	switch (domain) {
	500	case LTTNG_DOMAIN_UST:
	501	{
	502	int ret;
	503	struct buffer_reg_stream sreg, stmp;
	504	/* Wipe stream */
	505	cds_list_for_each_entry_safe(sreg, stmp, &regp->streams, lnode) {
	506	cds_list_del(&sreg->lnode);
	507	buffer_reg_stream_destroy(sreg, domain);
	508	}
	509
55d7e860 MD	510	if (regp->obj.ust) {
	511	ret = ust_ctl_release_object(-1, regp->obj.ust);
	512	if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
	513	ERR("Buffer reg channel release obj handle %d failed with ret %d",
	514	regp->obj.ust->handle, ret);
	515	}
	516	free(regp->obj.ust);
7972aab2	517	}
7972aab2 DG	518	lttng_fd_put(LTTNG_FD_APPS, 1);
	519	break;
	520	}
	521	default:
	522	assert(0);
	523	}
	524
	525	free(regp);
	526	return;
	527	}
	528
	529	/*
	530	* Destroy a buffer registry session with the given domain.
36b588ed MD	531	*
36b588ed MD	532	* Should NOT be called with RCU read-side lock held.
7972aab2	533	*/
36b588ed	534	static void buffer_reg_session_destroy(struct buffer_reg_session *regp,
7972aab2 DG	535	enum lttng_domain_type domain)
	536	{
	537	int ret;
	538	struct lttng_ht_iter iter;
	539	struct buffer_reg_channel *reg_chan;
	540
	541	DBG3("Buffer registry session destroy");
	542
	543	/* Destroy all channels. */
	544	rcu_read_lock();
	545	cds_lfht_for_each_entry(regp->channels->ht, &iter.iter, reg_chan,
	546	node.node) {
	547	ret = lttng_ht_del(regp->channels, &iter);
	548	assert(!ret);
	549	buffer_reg_channel_destroy(reg_chan, domain);
	550	}
7972aab2 DG	551	rcu_read_unlock();
7972aab2 DG	552
0b2dc8df	553	ht_cleanup_push(regp->channels);
36b588ed	554
7972aab2 DG	555	switch (domain) {
	556	case LTTNG_DOMAIN_UST:
	557	ust_registry_session_destroy(regp->reg.ust);
	558	free(regp->reg.ust);
	559	break;
	560	default:
	561	assert(0);
	562	}
	563
	564	free(regp);
	565	return;
	566	}
	567
	568	/*
36b588ed	569	* Remove buffer registry UID object from the global hash table.
7972aab2 DG	570	*/
	571	void buffer_reg_uid_remove(struct buffer_reg_uid *regp)
	572	{
	573	int ret;
	574	struct lttng_ht_iter iter;
	575
	576	assert(regp);
	577
36b588ed	578	rcu_read_lock();
7972aab2 DG	579	iter.iter.node = &regp->node.node;
	580	ret = lttng_ht_del(buffer_registry_uid, &iter);
	581	assert(!ret);
36b588ed	582	rcu_read_unlock();
7972aab2 DG	583	}
	584
	585	static void rcu_free_buffer_reg_uid(struct rcu_head *head)
	586	{
	587	struct lttng_ht_node_u64 *node =
	588	caa_container_of(head, struct lttng_ht_node_u64, head);
	589	struct buffer_reg_uid *reg =
	590	caa_container_of(node, struct buffer_reg_uid, node);
	591
	592	buffer_reg_session_destroy(reg->registry, reg->domain);
	593	free(reg);
	594	}
	595
	596	static void rcu_free_buffer_reg_pid(struct rcu_head *head)
	597	{
d9bf3ca4 MD	598	struct lttng_ht_node_u64 *node =
d9bf3ca4 MD	599	caa_container_of(head, struct lttng_ht_node_u64, head);
7972aab2 DG	600	struct buffer_reg_pid *reg =
	601	caa_container_of(node, struct buffer_reg_pid, node);
	602
	603	buffer_reg_session_destroy(reg->registry, LTTNG_DOMAIN_UST);
	604	free(reg);
	605	}
	606
	607	/*
	608	* Destroy buffer registry per UID. The given pointer is NOT removed from any
	609	* list or hash table. Use buffer_reg_pid_remove() before calling this function
	610	* for the case that the object is in the global hash table.
	611	*/
	612	void buffer_reg_uid_destroy(struct buffer_reg_uid *regp,
	613	struct consumer_output *consumer)
	614	{
	615	struct consumer_socket *socket;
	616
	617	if (!regp) {
	618	return;
	619	}
	620
d9bf3ca4	621	DBG3("Buffer registry per UID destroy with id: %" PRIu64 ", ABI: %u, uid: %d",
7972aab2 DG	622	regp->session_id, regp->bits_per_long, regp->uid);
	623
	624	if (!consumer) {
	625	goto destroy;
	626	}
	627
36b588ed	628	rcu_read_lock();
7972aab2 DG	629	/* Get the right socket from the consumer object. */
	630	socket = consumer_find_socket_by_bitness(regp->bits_per_long,
	631	consumer);
	632	if (!socket) {
36b588ed	633	goto unlock;
7972aab2 DG	634	}
	635
	636	switch (regp->domain) {
	637	case LTTNG_DOMAIN_UST:
	638	if (regp->registry->reg.ust->metadata_key) {
	639	/* Return value does not matter. This call will print errors. */
	640	(void) consumer_close_metadata(socket,
	641	regp->registry->reg.ust->metadata_key);
	642	}
	643	break;
	644	default:
	645	assert(0);
36b588ed	646	rcu_read_unlock();
7972aab2 DG	647	return;
	648	}
	649
36b588ed MD	650	unlock:
36b588ed MD	651	rcu_read_unlock();
7972aab2 DG	652	destroy:
	653	call_rcu(&regp->node.head, rcu_free_buffer_reg_uid);
	654	}
	655
	656	/*
	657	* Remove buffer registry UID object from the global hash table. RCU read side
	658	* lock MUST be acquired before calling this.
	659	*/
	660	void buffer_reg_pid_remove(struct buffer_reg_pid *regp)
	661	{
	662	int ret;
	663	struct lttng_ht_iter iter;
	664
	665	assert(regp);
	666
	667	iter.iter.node = &regp->node.node;
	668	ret = lttng_ht_del(buffer_registry_pid, &iter);
	669	assert(!ret);
	670	}
	671
	672	/*
	673	* Destroy buffer registry per PID. The pointer is NOT removed from the global
	674	* hash table. Call buffer_reg_pid_remove() before that if the object was
	675	* previously added to the global hash table.
	676	*/
	677	void buffer_reg_pid_destroy(struct buffer_reg_pid *regp)
	678	{
	679	if (!regp) {
	680	return;
	681	}
	682
d9bf3ca4 MD	683	DBG3("Buffer registry per PID destroy with id: %" PRIu64,
d9bf3ca4 MD	684	regp->session_id);
7972aab2 DG	685
	686	/* This registry is only used by UST. */
	687	call_rcu(&regp->node.head, rcu_free_buffer_reg_pid);
	688	}
	689
	690	/*
	691	* Destroy per PID and UID registry hash table.
36b588ed MD	692	*
36b588ed MD	693	* Should NOT be called with RCU read-side lock held.
7972aab2 DG	694	*/
	695	void buffer_reg_destroy_registries(void)
	696	{
	697	DBG3("Buffer registry destroy all registry");
0b2dc8df MD	698	ht_cleanup_push(buffer_registry_uid);
0b2dc8df MD	699	ht_cleanup_push(buffer_registry_pid);
7972aab2	700	}