*
*/
-#include "sessiond-trace-chunks.h"
+#include "sessiond-trace-chunks.hpp"
#include <urcu.h>
#include <urcu/rculfhash.h>
#include <urcu/ref.h>
-#include <common/macros.h>
-#include <common/hashtable/hashtable.h>
-#include <common/hashtable/utils.h>
-#include <common/trace-chunk-registry.h>
-#include <common/defaults.h>
-#include <common/error.h>
-#include <common/string-utils/format.h>
+#include <common/macros.hpp>
+#include <common/hashtable/hashtable.hpp>
+#include <common/hashtable/utils.hpp>
+#include <common/trace-chunk-registry.hpp>
+#include <common/defaults.hpp>
+#include <common/error.hpp>
+#include <common/string-utils/format.hpp>
#include <stdio.h>
#include <inttypes.h>
struct cds_lfht *ht;
};
+namespace {
struct trace_chunk_registry_ht_key {
lttng_uuid sessiond_uuid;
};
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<const uint64_t *>(&key->sessiond_uuid[0]);
+ const uint64_t uuid_h2 = *reinterpret_cast<const uint64_t *>(&key->sessiond_uuid[1]);
return hash_key_u64(&uuid_h1, lttng_ht_seed) ^
hash_key_u64(&uuid_h2, lttng_ht_seed);
(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);
}
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);
&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.
goto end;
}
- new_element = (trace_chunk_registry_ht_element *) zmalloc(sizeof(*new_element));
+ new_element = zmalloc<trace_chunk_registry_ht_element>();
if (!new_element) {
ret = -1;
goto end;
* 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);
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<sessiond_trace_chunk_registry>();
if (!sessiond_registry) {
goto end;
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) {
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;
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) {
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;
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) {
}
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;
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;
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}",
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;
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}",
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];
projects / lttng-tools.git / blobdiff