X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fbuffer-registry.c;h=3390f870ae24537149b7c8396eac24902cf5e7c0;hp=5751b8d587f8a1a12a64a1b2fc207aaba22b0534;hb=3a5f70173aa04d11ccb22694d5d31a702cad33ab;hpb=55d7e8605242476e653997d4d4ac2ee999b225f0 diff --git a/src/bin/lttng-sessiond/buffer-registry.c b/src/bin/lttng-sessiond/buffer-registry.c index 5751b8d58..3390f870a 100644 --- a/src/bin/lttng-sessiond/buffer-registry.c +++ b/src/bin/lttng-sessiond/buffer-registry.c @@ -1,21 +1,11 @@ /* - * Copyright (C) 2013 - David Goulet + * Copyright (C) 2013 David Goulet * - * 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. + * SPDX-License-Identifier: GPL-2.0-only * - * 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 +#define _LGPL_SOURCE #include #include @@ -24,7 +14,9 @@ #include "buffer-registry.h" #include "fd-limit.h" #include "ust-consumer.h" -#include "ust-ctl.h" +#include "lttng-ust-ctl.h" +#include "lttng-ust-error.h" +#include "utils.h" /* * Set in main.c during initialization process of the daemon. This contains @@ -49,11 +41,11 @@ 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); + LTTNG_ASSERT(node); + LTTNG_ASSERT(_key); reg = caa_container_of(node, struct buffer_reg_uid, node.node); - assert(reg); + LTTNG_ASSERT(reg); key = _key; if (key->session_id != reg->session_id || @@ -72,12 +64,12 @@ no_match: * 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) +static unsigned long ht_hash_reg_uid(const void *_key, unsigned long seed) { uint64_t xored_key; - struct buffer_reg_uid *key = _key; + const struct buffer_reg_uid *key = _key; - assert(key); + LTTNG_ASSERT(key); xored_key = (uint64_t)(key->session_id ^ key->bits_per_long ^ key->uid); return hash_key_u64(&xored_key, seed); @@ -89,9 +81,9 @@ static unsigned long ht_hash_reg_uid(void *_key, unsigned long seed) void buffer_reg_init_uid_registry(void) { /* Should be called once. */ - assert(!buffer_registry_uid); + LTTNG_ASSERT(!buffer_registry_uid); buffer_registry_uid = lttng_ht_new(0, LTTNG_HT_TYPE_U64); - assert(buffer_registry_uid); + LTTNG_ASSERT(buffer_registry_uid); buffer_registry_uid->match_fct = ht_match_reg_uid; buffer_registry_uid->hash_fct = ht_hash_reg_uid; @@ -103,13 +95,14 @@ void buffer_reg_init_uid_registry(void) * * Return 0 on success else a negative value and regp is untouched. */ -int buffer_reg_uid_create(int session_id, uint32_t bits_per_long, uid_t uid, - enum lttng_domain_type domain, struct buffer_reg_uid **regp) +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, + const char *root_shm_path, const char *shm_path) { int ret = 0; struct buffer_reg_uid *reg = NULL; - assert(regp); + LTTNG_ASSERT(regp); reg = zmalloc(sizeof(*reg)); if (!reg) { @@ -119,7 +112,7 @@ int buffer_reg_uid_create(int session_id, uint32_t bits_per_long, uid_t uid, } reg->registry = zmalloc(sizeof(struct buffer_reg_session)); - if (!reg) { + if (!reg->registry) { PERROR("zmalloc buffer registry uid session"); ret = -ENOMEM; goto error; @@ -129,7 +122,14 @@ int buffer_reg_uid_create(int session_id, uint32_t bits_per_long, uid_t uid, reg->bits_per_long = bits_per_long; reg->uid = uid; reg->domain = domain; - + if (shm_path[0]) { + strncpy(reg->root_shm_path, root_shm_path, sizeof(reg->root_shm_path)); + reg->root_shm_path[sizeof(reg->root_shm_path) - 1] = '\0'; + strncpy(reg->shm_path, shm_path, sizeof(reg->shm_path)); + reg->shm_path[sizeof(reg->shm_path) - 1] = '\0'; + DBG3("shm path '%s' is assigned to uid buffer registry for session id %" PRIu64, + reg->shm_path, session_id); + } reg->registry->channels = lttng_ht_new(0, LTTNG_HT_TYPE_U64); if (!reg->registry->channels) { ret = -ENOMEM; @@ -139,7 +139,7 @@ int buffer_reg_uid_create(int session_id, uint32_t bits_per_long, uid_t uid, cds_lfht_node_init(®->node.node); *regp = reg; - DBG3("Buffer registry per UID created id: %d, ABI: %u, uid: %d, domain: %d", + DBG3("Buffer registry per UID created id: %" PRIu64 ", ABI: %u, uid: %d, domain: %d", session_id, bits_per_long, uid, domain); return 0; @@ -159,15 +159,15 @@ void buffer_reg_uid_add(struct buffer_reg_uid *reg) struct cds_lfht_node *nodep; struct lttng_ht *ht = buffer_registry_uid; - assert(reg); + LTTNG_ASSERT(reg); - DBG3("Buffer registry per UID adding to global registry with id: %d", + 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, ®->node.node); - assert(nodep == ®->node.node); + LTTNG_ASSERT(nodep == ®->node.node); rcu_read_unlock(); } @@ -177,7 +177,7 @@ void buffer_reg_uid_add(struct buffer_reg_uid *reg) * * Return the object pointer or NULL on error. */ -struct buffer_reg_uid *buffer_reg_uid_find(int session_id, +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; @@ -190,7 +190,7 @@ struct buffer_reg_uid *buffer_reg_uid_find(int session_id, key.bits_per_long = bits_per_long; key.uid = uid; - DBG3("Buffer registry per UID find id: %d, ABI: %u, uid: %d", + 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. */ @@ -212,9 +212,9 @@ end: 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_ULONG); - assert(buffer_registry_pid); + LTTNG_ASSERT(!buffer_registry_pid); + buffer_registry_pid = lttng_ht_new(0, LTTNG_HT_TYPE_U64); + LTTNG_ASSERT(buffer_registry_pid); DBG3("Global buffer per PID registry initialized"); } @@ -224,12 +224,13 @@ void buffer_reg_init_pid_registry(void) * * Return 0 on success else a negative value and regp is untouched. */ -int buffer_reg_pid_create(int session_id, struct buffer_reg_pid **regp) +int buffer_reg_pid_create(uint64_t session_id, struct buffer_reg_pid **regp, + const char *root_shm_path, const char *shm_path) { int ret = 0; struct buffer_reg_pid *reg = NULL; - assert(regp); + LTTNG_ASSERT(regp); reg = zmalloc(sizeof(*reg)); if (!reg) { @@ -239,7 +240,7 @@ int buffer_reg_pid_create(int session_id, struct buffer_reg_pid **regp) } reg->registry = zmalloc(sizeof(struct buffer_reg_session)); - if (!reg) { + if (!reg->registry) { PERROR("zmalloc buffer registry pid session"); ret = -ENOMEM; goto error; @@ -247,17 +248,25 @@ int buffer_reg_pid_create(int session_id, struct buffer_reg_pid **regp) /* A cast is done here so we can use the session ID as a u64 ht node. */ reg->session_id = session_id; - + if (shm_path[0]) { + strncpy(reg->root_shm_path, root_shm_path, sizeof(reg->root_shm_path)); + reg->root_shm_path[sizeof(reg->root_shm_path) - 1] = '\0'; + strncpy(reg->shm_path, shm_path, sizeof(reg->shm_path)); + reg->shm_path[sizeof(reg->shm_path) - 1] = '\0'; + DBG3("shm path '%s' is assigned to pid buffer registry for session id %" PRIu64, + reg->shm_path, 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_ulong(®->node, reg->session_id); + lttng_ht_node_init_u64(®->node, reg->session_id); *regp = reg; - DBG3("Buffer registry per PID created with session id: %d", session_id); + DBG3("Buffer registry per PID created with session id: %" PRIu64, + session_id); return 0; @@ -273,13 +282,13 @@ error: */ void buffer_reg_pid_add(struct buffer_reg_pid *reg) { - assert(reg); + LTTNG_ASSERT(reg); - DBG3("Buffer registry per PID adding to global registry with id: %d", + DBG3("Buffer registry per PID adding to global registry with id: %" PRIu64, reg->session_id); rcu_read_lock(); - lttng_ht_add_unique_ulong(buffer_registry_pid, ®->node); + lttng_ht_add_unique_u64(buffer_registry_pid, ®->node); rcu_read_unlock(); } @@ -289,17 +298,17 @@ void buffer_reg_pid_add(struct buffer_reg_pid *reg) * * Return the object pointer or NULL on error. */ -struct buffer_reg_pid *buffer_reg_pid_find(int session_id) +struct buffer_reg_pid *buffer_reg_pid_find(uint64_t session_id) { - struct lttng_ht_node_ulong *node; + 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: %d", session_id); + DBG3("Buffer registry per PID find id: %" PRIu64, session_id); - lttng_ht_lookup(ht, (void *)((unsigned long) session_id), &iter); - node = lttng_ht_iter_get_node_ulong(&iter); + lttng_ht_lookup(ht, &session_id, &iter); + node = lttng_ht_iter_get_node_u64(&iter); if (!node) { goto end; } @@ -309,6 +318,43 @@ end: return reg; } +/* + * Find the consumer channel key from a UST session per-uid channel key. + * + * Return the matching key or -1 if not found. + */ +int buffer_reg_uid_consumer_channel_key( + struct cds_list_head *buffer_reg_uid_list, + uint64_t chan_key, uint64_t *consumer_chan_key) +{ + struct lttng_ht_iter iter; + struct buffer_reg_uid *uid_reg = NULL; + struct buffer_reg_session *session_reg = NULL; + struct buffer_reg_channel *reg_chan; + int ret = -1; + + rcu_read_lock(); + /* + * For the per-uid registry, we have to iterate since we don't have the + * uid and bitness key. + */ + cds_list_for_each_entry(uid_reg, buffer_reg_uid_list, lnode) { + session_reg = uid_reg->registry; + cds_lfht_for_each_entry(session_reg->channels->ht, + &iter.iter, reg_chan, node.node) { + if (reg_chan->key == chan_key) { + *consumer_chan_key = reg_chan->consumer_key; + ret = 0; + goto end; + } + } + } + +end: + rcu_read_unlock(); + return ret; +} + /* * Allocate and initialize a buffer registry channel with the given key. Set * regp with the object pointer. @@ -319,7 +365,7 @@ int buffer_reg_channel_create(uint64_t key, struct buffer_reg_channel **regp) { struct buffer_reg_channel *reg; - assert(regp); + LTTNG_ASSERT(regp); DBG3("Buffer registry channel create with key: %" PRIu64, key); @@ -349,7 +395,7 @@ int buffer_reg_stream_create(struct buffer_reg_stream **regp) { struct buffer_reg_stream *reg; - assert(regp); + LTTNG_ASSERT(regp); DBG3("Buffer registry creating stream"); @@ -370,11 +416,12 @@ int buffer_reg_stream_create(struct buffer_reg_stream **regp) void buffer_reg_stream_add(struct buffer_reg_stream *stream, struct buffer_reg_channel *channel) { - assert(stream); - assert(channel); + LTTNG_ASSERT(stream); + LTTNG_ASSERT(channel); pthread_mutex_lock(&channel->stream_list_lock); cds_list_add_tail(&stream->lnode, &channel->streams); + channel->stream_count++; pthread_mutex_unlock(&channel->stream_list_lock); } @@ -384,8 +431,8 @@ void buffer_reg_stream_add(struct buffer_reg_stream *stream, void buffer_reg_channel_add(struct buffer_reg_session *session, struct buffer_reg_channel *channel) { - assert(session); - assert(channel); + LTTNG_ASSERT(session); + LTTNG_ASSERT(channel); rcu_read_lock(); lttng_ht_add_unique_u64(session->channels, &channel->node); @@ -407,14 +454,14 @@ struct buffer_reg_channel *buffer_reg_channel_find(uint64_t key, struct buffer_reg_channel *chan = NULL; struct lttng_ht *ht; - assert(reg); + LTTNG_ASSERT(reg); switch (reg->domain) { case LTTNG_DOMAIN_UST: ht = reg->registry->channels; break; default: - assert(0); + abort(); goto end; } @@ -447,7 +494,7 @@ void buffer_reg_stream_destroy(struct buffer_reg_stream *regp, { int ret; - ret = ust_ctl_release_object(-1, regp->obj.ust); + ret = ust_app_release_object(NULL, 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); @@ -457,7 +504,7 @@ void buffer_reg_stream_destroy(struct buffer_reg_stream *regp, break; } default: - assert(0); + abort(); } free(regp); @@ -474,12 +521,12 @@ void buffer_reg_channel_remove(struct buffer_reg_session *session, int ret; struct lttng_ht_iter iter; - assert(session); - assert(regp); + LTTNG_ASSERT(session); + LTTNG_ASSERT(regp); iter.iter.node = ®p->node.node; ret = lttng_ht_del(session->channels, &iter); - assert(!ret); + LTTNG_ASSERT(!ret); } /* @@ -492,8 +539,7 @@ void buffer_reg_channel_destroy(struct buffer_reg_channel *regp, return; } - DBG3("Buffer registry channel destroy with key %" PRIu32 " and handle %d", - regp->key, regp->obj.ust->handle); + DBG3("Buffer registry channel destroy with key %" PRIu32, regp->key); switch (domain) { case LTTNG_DOMAIN_UST: @@ -503,11 +549,12 @@ void buffer_reg_channel_destroy(struct buffer_reg_channel *regp, /* Wipe stream */ cds_list_for_each_entry_safe(sreg, stmp, ®p->streams, lnode) { cds_list_del(&sreg->lnode); + regp->stream_count--; buffer_reg_stream_destroy(sreg, domain); } if (regp->obj.ust) { - ret = ust_ctl_release_object(-1, regp->obj.ust); + ret = ust_app_release_object(NULL, 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); @@ -518,7 +565,7 @@ void buffer_reg_channel_destroy(struct buffer_reg_channel *regp, break; } default: - assert(0); + abort(); } free(regp); @@ -527,8 +574,10 @@ void buffer_reg_channel_destroy(struct buffer_reg_channel *regp, /* * Destroy a buffer registry session with the given domain. + * + * Should *NOT* be called with RCU read-side lock held. */ -void buffer_reg_session_destroy(struct buffer_reg_session *regp, +static void buffer_reg_session_destroy(struct buffer_reg_session *regp, enum lttng_domain_type domain) { int ret; @@ -542,19 +591,20 @@ void buffer_reg_session_destroy(struct buffer_reg_session *regp, cds_lfht_for_each_entry(regp->channels->ht, &iter.iter, reg_chan, node.node) { ret = lttng_ht_del(regp->channels, &iter); - assert(!ret); + LTTNG_ASSERT(!ret); buffer_reg_channel_destroy(reg_chan, domain); } - lttng_ht_destroy(regp->channels); 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); + abort(); } free(regp); @@ -562,19 +612,20 @@ void buffer_reg_session_destroy(struct buffer_reg_session *regp, } /* - * Remove buffer registry UID object from the global hash table. RCU read side - * lock MUST be acquired before calling this. + * 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); + LTTNG_ASSERT(regp); + rcu_read_lock(); iter.iter.node = ®p->node.node; ret = lttng_ht_del(buffer_registry_uid, &iter); - assert(!ret); + LTTNG_ASSERT(!ret); + rcu_read_unlock(); } static void rcu_free_buffer_reg_uid(struct rcu_head *head) @@ -590,8 +641,8 @@ static void rcu_free_buffer_reg_uid(struct rcu_head *head) static void rcu_free_buffer_reg_pid(struct rcu_head *head) { - struct lttng_ht_node_ulong *node = - caa_container_of(head, struct lttng_ht_node_ulong, 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); @@ -613,18 +664,19 @@ void buffer_reg_uid_destroy(struct buffer_reg_uid *regp, return; } - DBG3("Buffer registry per UID destroy with id: %d, ABI: %u, uid: %d", + 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 destroy; + goto unlock; } switch (regp->domain) { @@ -636,10 +688,13 @@ void buffer_reg_uid_destroy(struct buffer_reg_uid *regp, } break; default: - assert(0); + abort(); + rcu_read_unlock(); return; } +unlock: + rcu_read_unlock(); destroy: call_rcu(®p->node.head, rcu_free_buffer_reg_uid); } @@ -653,11 +708,11 @@ void buffer_reg_pid_remove(struct buffer_reg_pid *regp) int ret; struct lttng_ht_iter iter; - assert(regp); + LTTNG_ASSERT(regp); iter.iter.node = ®p->node.node; ret = lttng_ht_del(buffer_registry_pid, &iter); - assert(!ret); + LTTNG_ASSERT(!ret); } /* @@ -671,7 +726,8 @@ void buffer_reg_pid_destroy(struct buffer_reg_pid *regp) return; } - DBG3("Buffer registry per PID destroy with id: %d", regp->session_id); + DBG3("Buffer registry per PID destroy with id: %" PRIu64, + regp->session_id); /* This registry is only used by UST. */ call_rcu(®p->node.head, rcu_free_buffer_reg_pid); @@ -679,10 +735,12 @@ void buffer_reg_pid_destroy(struct buffer_reg_pid *regp) /* * 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"); - lttng_ht_destroy(buffer_registry_uid); - lttng_ht_destroy(buffer_registry_pid); + ht_cleanup_push(buffer_registry_uid); + ht_cleanup_push(buffer_registry_pid); }