X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-relayd%2Fsessiond-trace-chunks.cpp;h=eba9a1989ab07fd2cf21c5865e089d6ca72099db;hb=8a00688e1d58cc5a2e77eba206ff23bd6105130c;hp=e0c46e34ad4a7436e344b178a1302bd9fd06c64b;hpb=ac497a37018f3c253d2e50397294f58d33f7f24f;p=lttng-tools.git diff --git a/src/bin/lttng-relayd/sessiond-trace-chunks.cpp b/src/bin/lttng-relayd/sessiond-trace-chunks.cpp index e0c46e34a..eba9a1989 100644 --- a/src/bin/lttng-relayd/sessiond-trace-chunks.cpp +++ b/src/bin/lttng-relayd/sessiond-trace-chunks.cpp @@ -5,17 +5,17 @@ * */ -#include "sessiond-trace-chunks.h" +#include "sessiond-trace-chunks.hpp" #include #include #include -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include #include #include @@ -56,6 +56,7 @@ struct sessiond_trace_chunk_registry { struct cds_lfht *ht; }; +namespace { struct trace_chunk_registry_ht_key { lttng_uuid sessiond_uuid; }; @@ -70,13 +71,14 @@ struct trace_chunk_registry_ht_element { struct lttng_trace_chunk_registry *trace_chunk_registry; struct sessiond_trace_chunk_registry *sessiond_trace_chunk_registry; }; +} /* namespace */ static unsigned long trace_chunk_registry_ht_key_hash( const struct trace_chunk_registry_ht_key *key) { - uint64_t uuid_h1 = ((uint64_t *) key->sessiond_uuid)[0]; - uint64_t uuid_h2 = ((uint64_t *) key->sessiond_uuid)[1]; + const uint64_t uuid_h1 = *reinterpret_cast(&key->sessiond_uuid[0]); + const uint64_t uuid_h2 = *reinterpret_cast(&key->sessiond_uuid[1]); return hash_key_u64(&uuid_h1, lttng_ht_seed) ^ hash_key_u64(&uuid_h2, lttng_ht_seed); @@ -91,16 +93,15 @@ int trace_chunk_registry_ht_key_match(struct cds_lfht_node *node, (struct trace_chunk_registry_ht_key *) _key; struct trace_chunk_registry_ht_element *registry; - registry = container_of(node, typeof(*registry), ht_node); - return lttng_uuid_is_equal(key->sessiond_uuid, - registry->key.sessiond_uuid); + registry = lttng::utils::container_of(node, &trace_chunk_registry_ht_element::ht_node); + return key->sessiond_uuid == registry->key.sessiond_uuid; } static void trace_chunk_registry_ht_element_free(struct rcu_head *node) { - struct trace_chunk_registry_ht_element *element = - container_of(node, typeof(*element), rcu_node); + struct trace_chunk_registry_ht_element *element = lttng::utils::container_of( + node, &trace_chunk_registry_ht_element::rcu_node); free(element); } @@ -109,7 +110,7 @@ static void trace_chunk_registry_ht_element_release(struct urcu_ref *ref) { struct trace_chunk_registry_ht_element *element = - container_of(ref, typeof(*element), ref); + lttng::utils::container_of(ref, &trace_chunk_registry_ht_element::ref); char uuid_str[LTTNG_UUID_STR_LEN]; lttng_uuid_to_str(element->key.sessiond_uuid, uuid_str); @@ -166,7 +167,8 @@ struct trace_chunk_registry_ht_element *trace_chunk_registry_ht_element_find( &iter); node = cds_lfht_iter_get_node(&iter); if (node) { - element = container_of(node, typeof(*element), ht_node); + element = lttng::utils::container_of( + node, &trace_chunk_registry_ht_element::ht_node); /* * Only consider the look-up as successful if a reference * could be acquired. @@ -197,7 +199,7 @@ int trace_chunk_registry_ht_element_create( goto end; } - new_element = (trace_chunk_registry_ht_element *) zmalloc(sizeof(*new_element)); + new_element = zmalloc(); if (!new_element) { ret = -1; goto end; @@ -235,8 +237,8 @@ int trace_chunk_registry_ht_element_create( * was already published and release the reference to the copy * we created if successful. */ - published_element = container_of(published_node, - typeof(*published_element), ht_node); + published_element = lttng::utils::container_of(published_node, + &trace_chunk_registry_ht_element::ht_node); if (trace_chunk_registry_ht_element_get(published_element)) { DBG("Acquired reference to trace chunk registry of sessiond {%s}", uuid_str); @@ -263,7 +265,7 @@ end: struct sessiond_trace_chunk_registry *sessiond_trace_chunk_registry_create(void) { struct sessiond_trace_chunk_registry *sessiond_registry = - (sessiond_trace_chunk_registry *) zmalloc(sizeof(*sessiond_registry)); + zmalloc(); if (!sessiond_registry) { goto end; @@ -293,13 +295,13 @@ void sessiond_trace_chunk_registry_destroy( int sessiond_trace_chunk_registry_session_created( struct sessiond_trace_chunk_registry *sessiond_registry, - const lttng_uuid sessiond_uuid) + const lttng_uuid& sessiond_uuid) { int ret = 0; struct trace_chunk_registry_ht_key key; struct trace_chunk_registry_ht_element *element; - lttng_uuid_copy(key.sessiond_uuid, sessiond_uuid); + key.sessiond_uuid = sessiond_uuid; element = trace_chunk_registry_ht_element_find(sessiond_registry, &key); if (element) { @@ -319,7 +321,7 @@ end: int sessiond_trace_chunk_registry_session_destroyed( struct sessiond_trace_chunk_registry *sessiond_registry, - const lttng_uuid sessiond_uuid) + const lttng_uuid& sessiond_uuid) { int ret = 0; struct trace_chunk_registry_ht_key key; @@ -327,7 +329,7 @@ int sessiond_trace_chunk_registry_session_destroyed( char uuid_str[LTTNG_UUID_STR_LEN]; lttng_uuid_to_str(sessiond_uuid, uuid_str); - lttng_uuid_copy(key.sessiond_uuid, sessiond_uuid); + key.sessiond_uuid = sessiond_uuid; element = trace_chunk_registry_ht_element_find(sessiond_registry, &key); if (element) { @@ -349,7 +351,7 @@ int sessiond_trace_chunk_registry_session_destroyed( struct lttng_trace_chunk *sessiond_trace_chunk_registry_publish_chunk( struct sessiond_trace_chunk_registry *sessiond_registry, - const lttng_uuid sessiond_uuid, uint64_t session_id, + const lttng_uuid& sessiond_uuid, uint64_t session_id, struct lttng_trace_chunk *new_chunk) { enum lttng_trace_chunk_status status; @@ -360,9 +362,10 @@ struct lttng_trace_chunk *sessiond_trace_chunk_registry_publish_chunk( char uuid_str[LTTNG_UUID_STR_LEN]; char chunk_id_str[MAX_INT_DEC_LEN(typeof(chunk_id))] = "-1"; struct lttng_trace_chunk *published_chunk = NULL; + bool trace_chunk_already_published; lttng_uuid_to_str(sessiond_uuid, uuid_str); - lttng_uuid_copy(key.sessiond_uuid, sessiond_uuid); + key.sessiond_uuid = sessiond_uuid; status = lttng_trace_chunk_get_id(new_chunk, &chunk_id); if (status == LTTNG_TRACE_CHUNK_STATUS_OK) { @@ -394,20 +397,29 @@ struct lttng_trace_chunk *sessiond_trace_chunk_registry_publish_chunk( } published_chunk = lttng_trace_chunk_registry_publish_chunk( - element->trace_chunk_registry, session_id, new_chunk); + element->trace_chunk_registry, session_id, new_chunk, + &trace_chunk_already_published); /* - * At this point, two references to the published chunks exist. One - * is taken by the registry while the other is being returned to the - * caller. In the use case of the relay daemon, the reference held - * by the registry itself is undesirable. + * When the trace chunk is first published, two references to the + * published chunks exist. One is taken by the registry while the other + * is being returned to the caller. In the use case of the relay daemon, + * the reference held by the registry itself is undesirable. * * We want the trace chunk to be removed from the registry as soon * as it is not being used by the relay daemon (through a session * or a stream). This differs from the behaviour of the consumer * daemon which relies on an explicit command from the session * daemon to release the registry's reference. + * + * In cases where the trace chunk had already been published, + * the reference belonging to the sessiond trace chunk + * registry instance has already been 'put'. We simply return + * the published trace chunk with a reference taken on behalf of the + * caller. */ - lttng_trace_chunk_put(published_chunk); + if (!trace_chunk_already_published) { + lttng_trace_chunk_put(published_chunk); + } end: trace_chunk_registry_ht_element_put(element); return published_chunk; @@ -416,7 +428,7 @@ end: struct lttng_trace_chunk * sessiond_trace_chunk_registry_get_anonymous_chunk( struct sessiond_trace_chunk_registry *sessiond_registry, - const lttng_uuid sessiond_uuid, + const lttng_uuid& sessiond_uuid, uint64_t session_id) { struct lttng_trace_chunk *chunk = NULL; @@ -426,7 +438,7 @@ sessiond_trace_chunk_registry_get_anonymous_chunk( lttng_uuid_to_str(sessiond_uuid, uuid_str); - lttng_uuid_copy(key.sessiond_uuid, sessiond_uuid); + key.sessiond_uuid = sessiond_uuid; element = trace_chunk_registry_ht_element_find(sessiond_registry, &key); if (!element) { ERR("Failed to find trace chunk registry of sessiond {%s}", @@ -445,7 +457,7 @@ end: struct lttng_trace_chunk * sessiond_trace_chunk_registry_get_chunk( struct sessiond_trace_chunk_registry *sessiond_registry, - const lttng_uuid sessiond_uuid, + const lttng_uuid& sessiond_uuid, uint64_t session_id, uint64_t chunk_id) { struct lttng_trace_chunk *chunk = NULL; @@ -455,7 +467,7 @@ sessiond_trace_chunk_registry_get_chunk( lttng_uuid_to_str(sessiond_uuid, uuid_str); - lttng_uuid_copy(key.sessiond_uuid, sessiond_uuid); + key.sessiond_uuid = sessiond_uuid; element = trace_chunk_registry_ht_element_find(sessiond_registry, &key); if (!element) { ERR("Failed to find trace chunk registry of sessiond {%s}", @@ -473,14 +485,14 @@ end: int sessiond_trace_chunk_registry_chunk_exists( struct sessiond_trace_chunk_registry *sessiond_registry, - const lttng_uuid sessiond_uuid, + const lttng_uuid& sessiond_uuid, uint64_t session_id, uint64_t chunk_id, bool *chunk_exists) { int ret; struct trace_chunk_registry_ht_element *element; struct trace_chunk_registry_ht_key key; - lttng_uuid_copy(key.sessiond_uuid, sessiond_uuid); + key.sessiond_uuid = sessiond_uuid; element = trace_chunk_registry_ht_element_find(sessiond_registry, &key); if (!element) { char uuid_str[LTTNG_UUID_STR_LEN];