From: Jérémie Galarneau Date: Wed, 8 Jun 2022 17:10:26 +0000 (-0400) Subject: Clean-up: sessiond: move ust_registry_session under lttng::sessiond::ust X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=commitdiff_plain;h=b0f2e8db59fcadc8f4b06a94175792be3c431004 Clean-up: sessiond: move ust_registry_session under lttng::sessiond::ust The ust_registry_session* class hierarchy is namespaced under lttng::sessiond::ust. The registry session classes are also moved to their own headers. Signed-off-by: Jérémie Galarneau Change-Id: I3be5aa3239bbff9b385ab942f749748b4d6cb352 --- diff --git a/src/bin/lttng-sessiond/Makefile.am b/src/bin/lttng-sessiond/Makefile.am index 86e356752..7f8ac379c 100644 --- a/src/bin/lttng-sessiond/Makefile.am +++ b/src/bin/lttng-sessiond/Makefile.am @@ -71,12 +71,12 @@ liblttng_sessiond_common_la_SOURCES += trace-ust.cpp ust-registry.cpp ust-app.cp agent-thread.cpp agent-thread.hpp \ ust-field-convert.cpp ust-field-convert.hpp \ ust-sigbus.cpp \ - ust-registry-session.cpp \ + ust-registry-session.cpp ust-registry-session.hpp \ ust-registry-event.cpp ust-registry-event.hpp \ ust-registry-channel.cpp ust-registry-channel.hpp \ - ust-registry-session-uid.cpp \ - ust-registry-session-pid.cpp \ - tsdl-trace-class-visitor.hpp tsdl-trace-class-visitor.cpp + ust-registry-session-uid.cpp ust-registry-session-uid.hpp \ + ust-registry-session-pid.cpp ust-registry-session-pid.hpp \ + tsdl-trace-class-visitor.cpp tsdl-trace-class-visitor.hpp endif # link on liblttngctl for check if sessiond is already alive. diff --git a/src/bin/lttng-sessiond/buffer-registry.hpp b/src/bin/lttng-sessiond/buffer-registry.hpp index e7d0dae1d..4641361f0 100644 --- a/src/bin/lttng-sessiond/buffer-registry.hpp +++ b/src/bin/lttng-sessiond/buffer-registry.hpp @@ -17,6 +17,7 @@ #include "consumer.hpp" #include "lttng-ust-ctl.hpp" #include "ust-registry.hpp" +#include "ust-registry-session.hpp" struct buffer_reg_stream { struct cds_list_head lnode; @@ -52,7 +53,7 @@ struct buffer_reg_channel { struct buffer_reg_session { /* Registry per domain. */ union { - ust_registry_session *ust; + lttng::sessiond::ust::registry_session *ust; } reg; /* Contains buffer registry channel indexed by tracing channel key. */ diff --git a/src/bin/lttng-sessiond/trace-ust.cpp b/src/bin/lttng-sessiond/trace-ust.cpp index 1a98d3ff7..6f423c9c6 100644 --- a/src/bin/lttng-sessiond/trace-ust.cpp +++ b/src/bin/lttng-sessiond/trace-ust.cpp @@ -24,6 +24,8 @@ #include "ust-app.hpp" #include "agent.hpp" +namespace lsu = lttng::sessiond::ust; + /* * Match function for the events hash table lookup. * @@ -1361,7 +1363,7 @@ int trace_ust_regenerate_metadata(struct ltt_ust_session *usess) rcu_read_lock(); cds_list_for_each_entry(uid_reg, &usess->buffer_reg_uid_list, lnode) { - ust_registry_session *registry; + lsu::registry_session *registry; session_reg = uid_reg->registry; registry = session_reg->reg.ust; diff --git a/src/bin/lttng-sessiond/ust-app.cpp b/src/bin/lttng-sessiond/ust-app.cpp index dd51d61f2..3ca4279a9 100644 --- a/src/bin/lttng-sessiond/ust-app.cpp +++ b/src/bin/lttng-sessiond/ust-app.cpp @@ -86,10 +86,10 @@ namespace { * A registry per UID object MUST exists before calling this function or else * it LTTNG_ASSERT() if not found. RCU read side lock must be acquired. */ -static ust_registry_session *get_session_registry( +static lsu::registry_session *get_session_registry( const struct ust_app_session *ua_sess) { - ust_registry_session *registry = NULL; + lsu::registry_session *registry = NULL; LTTNG_ASSERT(ua_sess); @@ -122,7 +122,7 @@ error: return registry; } -ust_registry_session::locked_ptr +lsu::registry_session::locked_ptr get_locked_session_registry(const struct ust_app_session *ua_sess) { auto session = get_session_registry(ua_sess); @@ -130,7 +130,7 @@ get_locked_session_registry(const struct ust_app_session *ua_sess) pthread_mutex_lock(&session->_lock); } - return ust_registry_session::locked_ptr{session}; + return lsu::registry_session::locked_ptr{session}; } } /* namespace */ @@ -562,7 +562,7 @@ end: static void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan, struct ust_app *app, - const ust_registry_session::locked_ptr& locked_registry) + const lsu::registry_session::locked_ptr& locked_registry) { int ret; struct lttng_ht_iter iter; @@ -685,7 +685,7 @@ int ust_app_release_object(struct ust_app *app, struct lttng_ust_abi_object_data * but it can be caused by recoverable errors (e.g. the application has * terminated concurrently). */ -ssize_t ust_app_push_metadata(const ust_registry_session::locked_ptr& locked_registry, +ssize_t ust_app_push_metadata(const lsu::registry_session::locked_ptr& locked_registry, struct consumer_socket *socket, int send_zero_data) { @@ -825,7 +825,7 @@ error_push: * but it can be caused by recoverable errors (e.g. the application has * terminated concurrently). */ -static int push_metadata(const ust_registry_session::locked_ptr& locked_registry, +static int push_metadata(const lsu::registry_session::locked_ptr& locked_registry, struct consumer_output *consumer) { int ret_val; @@ -2985,7 +2985,7 @@ error: */ static int do_consumer_create_channel(struct ltt_ust_session *usess, struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan, - int bitness, ust_registry_session *registry) + int bitness, lsu::registry_session *registry) { int ret; unsigned int nb_fd = 0; @@ -3504,7 +3504,7 @@ static int create_channel_per_pid(struct ust_app *app, struct ust_app_channel *ua_chan) { int ret; - ust_registry_session *registry; + lsu::registry_session *registry; enum lttng_error_code cmd_ret; struct ltt_session *session = NULL; uint64_t chan_reg_key; @@ -5414,7 +5414,7 @@ int ust_app_flush_session(struct ltt_ust_session *usess) /* Flush all per UID buffers associated to that session. */ cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) { - ust_registry_session *ust_session_reg; + lsu::registry_session *ust_session_reg; struct buffer_reg_channel *buf_reg_chan; struct consumer_socket *socket; @@ -6619,7 +6619,7 @@ static int add_enum_ust_registry(int sock, int sobjd, char *name, int ret = 0, ret_code; struct ust_app *app; struct ust_app_session *ua_sess; - ust_registry_session *registry; + lsu::registry_session *registry; uint64_t enum_id = -1ULL; rcu_read_lock(); @@ -7038,7 +7038,7 @@ enum lttng_error_code ust_app_snapshot_record( struct lttng_ht_iter chan_iter; struct ust_app_channel *ua_chan; struct ust_app_session *ua_sess; - ust_registry_session *registry; + lsu::registry_session *registry; char pathname[PATH_MAX]; size_t consumer_path_offset = 0; @@ -7433,7 +7433,7 @@ enum lttng_error_code ust_app_rotate_session(struct ltt_session *session) struct lttng_ht_iter chan_iter; struct ust_app_channel *ua_chan; struct ust_app_session *ua_sess; - ust_registry_session *registry; + lsu::registry_session *registry; ua_sess = lookup_session_by_app(usess, app); if (!ua_sess) { @@ -7563,7 +7563,7 @@ enum lttng_error_code ust_app_create_channel_subdirectories( cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) { struct ust_app_session *ua_sess; - ust_registry_session *registry; + lsu::registry_session *registry; ua_sess = lookup_session_by_app(usess, app); if (!ua_sess) { @@ -7685,7 +7685,7 @@ enum lttng_error_code ust_app_clear_session(struct ltt_session *session) struct lttng_ht_iter chan_iter; struct ust_app_channel *ua_chan; struct ust_app_session *ua_sess; - ust_registry_session *registry; + lsu::registry_session *registry; ua_sess = lookup_session_by_app(usess, app); if (!ua_sess) { @@ -7832,7 +7832,7 @@ enum lttng_error_code ust_app_open_packets(struct ltt_session *session) struct lttng_ht_iter chan_iter; struct ust_app_channel *ua_chan; struct ust_app_session *ua_sess; - ust_registry_session *registry; + lsu::registry_session *registry; ua_sess = lookup_session_by_app(usess, app); if (!ua_sess) { diff --git a/src/bin/lttng-sessiond/ust-app.hpp b/src/bin/lttng-sessiond/ust-app.hpp index f9238edc3..34376a63d 100644 --- a/src/bin/lttng-sessiond/ust-app.hpp +++ b/src/bin/lttng-sessiond/ust-app.hpp @@ -17,6 +17,7 @@ #include "trace-ust.hpp" #include "ust-registry.hpp" +#include "ust-registry-session.hpp" #include "session.hpp" #define UST_APP_EVENT_LIST_SIZE 32 @@ -376,7 +377,7 @@ int ust_app_recv_notify(int sock); void ust_app_add(struct ust_app *app); struct ust_app *ust_app_create(struct ust_register_msg *msg, int sock); void ust_app_notify_sock_unregister(int sock); -ssize_t ust_app_push_metadata(const ust_registry_session::locked_ptr& registry, +ssize_t ust_app_push_metadata(const lttng::sessiond::ust::registry_session::locked_ptr& registry, struct consumer_socket *socket, int send_zero_data); void ust_app_destroy(struct ust_app *app); @@ -626,7 +627,7 @@ void ust_app_notify_sock_unregister(int sock __attribute__((unused))) static inline ssize_t ust_app_push_metadata( - ust_registry_session *registry __attribute__((unused)), + lttng::sessiond::ust::registry_session *registry __attribute__((unused)), struct consumer_socket *socket __attribute__((unused)), int send_zero_data __attribute__((unused))) { diff --git a/src/bin/lttng-sessiond/ust-consumer.cpp b/src/bin/lttng-sessiond/ust-consumer.cpp index 9098f9cd3..df4689920 100644 --- a/src/bin/lttng-sessiond/ust-consumer.cpp +++ b/src/bin/lttng-sessiond/ust-consumer.cpp @@ -36,7 +36,7 @@ static int ask_channel_creation(struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan, struct consumer_output *consumer, struct consumer_socket *socket, - ust_registry_session *registry, + lsu::registry_session *registry, struct lttng_trace_chunk *trace_chunk) { int ret, output; @@ -201,7 +201,7 @@ int ust_consumer_ask_channel(struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan, struct consumer_output *consumer, struct consumer_socket *socket, - ust_registry_session *registry, + lsu::registry_session *registry, struct lttng_trace_chunk * trace_chunk) { int ret; @@ -450,7 +450,7 @@ int ust_consumer_metadata_request(struct consumer_socket *socket) ssize_t ret_push; struct lttcomm_metadata_request_msg request; struct buffer_reg_uid *reg_uid; - ust_registry_session *ust_reg; + lsu::registry_session *ust_reg; struct lttcomm_consumer_msg msg; LTTNG_ASSERT(socket); diff --git a/src/bin/lttng-sessiond/ust-consumer.hpp b/src/bin/lttng-sessiond/ust-consumer.hpp index 176c42310..f752131b6 100644 --- a/src/bin/lttng-sessiond/ust-consumer.hpp +++ b/src/bin/lttng-sessiond/ust-consumer.hpp @@ -17,7 +17,7 @@ int ust_consumer_ask_channel(struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan, struct consumer_output *consumer, struct consumer_socket *socket, - ust_registry_session *registry, + lttng::sessiond::ust::registry_session *registry, struct lttng_trace_chunk *trace_chunk); int ust_consumer_get_channel(struct consumer_socket *socket, diff --git a/src/bin/lttng-sessiond/ust-field-convert.cpp b/src/bin/lttng-sessiond/ust-field-convert.cpp index 06ade1e40..ae402ccb8 100644 --- a/src/bin/lttng-sessiond/ust-field-convert.cpp +++ b/src/bin/lttng-sessiond/ust-field-convert.cpp @@ -642,7 +642,7 @@ void create_field_from_ust_ctl_fields(const lttng_ust_ctl_field *current, * Always returns a new field, throws on error. */ std::vector create_fields_from_ust_ctl_fields( - const ust_registry_session& session, + const lsu::registry_session& session, const lttng_ust_ctl_field *current, const lttng_ust_ctl_field *end) { @@ -679,7 +679,7 @@ std::vector create_fields_from_ust_ctl_fields( } /* namespace */ std::vector lsu::create_trace_fields_from_ust_ctl_fields( - const ust_registry_session& session, + const lsu::registry_session& session, const lttng_ust_ctl_field *fields, std::size_t field_count) { diff --git a/src/bin/lttng-sessiond/ust-field-convert.hpp b/src/bin/lttng-sessiond/ust-field-convert.hpp index f570e65ed..0faf65db1 100644 --- a/src/bin/lttng-sessiond/ust-field-convert.hpp +++ b/src/bin/lttng-sessiond/ust-field-convert.hpp @@ -10,6 +10,7 @@ #include "field.hpp" #include "ust-registry.hpp" +#include "ust-registry-session.hpp" #include #include @@ -19,7 +20,7 @@ namespace sessiond { namespace ust { std::vector create_trace_fields_from_ust_ctl_fields( - const ust_registry_session& session, + const lttng::sessiond::ust::registry_session& session, const lttng_ust_ctl_field *fields, std::size_t field_count); diff --git a/src/bin/lttng-sessiond/ust-registry-session-pid.cpp b/src/bin/lttng-sessiond/ust-registry-session-pid.cpp index f8251106f..7e091fdac 100644 --- a/src/bin/lttng-sessiond/ust-registry-session-pid.cpp +++ b/src/bin/lttng-sessiond/ust-registry-session-pid.cpp @@ -6,13 +6,14 @@ */ #include "ust-app.hpp" -#include "ust-registry.hpp" +#include "ust-registry-session-pid.hpp" #include namespace lst = lttng::sessiond::trace; +namespace lsu = lttng::sessiond::ust; -ust_registry_session_per_pid::ust_registry_session_per_pid(const struct ust_app& app, +lsu::registry_session_per_pid::registry_session_per_pid(const struct ust_app& app, const struct lst::abi& in_abi, uint32_t major, uint32_t minor, @@ -21,7 +22,7 @@ ust_registry_session_per_pid::ust_registry_session_per_pid(const struct ust_app& uid_t euid, gid_t egid, uint64_t tracing_id) : - ust_registry_session{in_abi, major, minor, root_shm_path, shm_path, euid, egid, tracing_id}, + registry_session{in_abi, major, minor, root_shm_path, shm_path, euid, egid, tracing_id}, _tracer_patch_level_version{app.version.patchlevel}, _vpid{app.pid}, _procname{app.name}, @@ -31,14 +32,14 @@ ust_registry_session_per_pid::ust_registry_session_per_pid(const struct ust_app& _generate_metadata(); } -lttng_buffer_type ust_registry_session_per_pid::get_buffering_scheme() const noexcept +lttng_buffer_type lsu::registry_session_per_pid::get_buffering_scheme() const noexcept { return LTTNG_BUFFER_PER_PID; } -void ust_registry_session_per_pid::_visit_environment(lst::trace_class_visitor& visitor) const +void lsu::registry_session_per_pid::_visit_environment(lst::trace_class_visitor& visitor) const { - ust_registry_session::_visit_environment(visitor); + registry_session::_visit_environment(visitor); visitor.visit(lst::environment_field("tracer_buffering_id", _vpid)); visitor.visit(lst::environment_field( "tracer_patchlevel", _tracer_patch_level_version)); diff --git a/src/bin/lttng-sessiond/ust-registry-session-pid.hpp b/src/bin/lttng-sessiond/ust-registry-session-pid.hpp new file mode 100644 index 000000000..aa6cfb91b --- /dev/null +++ b/src/bin/lttng-sessiond/ust-registry-session-pid.hpp @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2022 Jérémie Galarneau + * + * SPDX-License-Identifier: GPL-2.0-only + * + */ + +#ifndef LTTNG_UST_REGISTRY_SESSION_PID_H +#define LTTNG_UST_REGISTRY_SESSION_PID_H + +#include "trace-class.hpp" +#include "ust-registry-session.hpp" + +#include +#include +#include +#include +#include + +namespace lttng { +namespace sessiond { +namespace ust { + +class registry_session_per_pid : public registry_session { +public: + registry_session_per_pid(const struct ust_app& app, + const struct lttng::sessiond::trace::abi& trace_abi, + 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); + + virtual lttng_buffer_type get_buffering_scheme() const noexcept override final; + +private: + virtual void _visit_environment( + lttng::sessiond::trace::trace_class_visitor& trace_class_visitor) + const override final; + + const unsigned int _tracer_patch_level_version; + const pid_t _vpid; + const std::string _procname; + const std::time_t _app_creation_time; +}; + +} /* namespace ust */ +} /* namespace sessiond */ +} /* namespace lttng */ + +#endif /* LTTNG_UST_REGISTRY_SESSION_PID_H */ diff --git a/src/bin/lttng-sessiond/ust-registry-session-uid.cpp b/src/bin/lttng-sessiond/ust-registry-session-uid.cpp index b7630b2a5..8aa79dd7b 100644 --- a/src/bin/lttng-sessiond/ust-registry-session-uid.cpp +++ b/src/bin/lttng-sessiond/ust-registry-session-uid.cpp @@ -5,11 +5,12 @@ * */ -#include "ust-registry.hpp" +#include "ust-registry-session-uid.hpp" namespace lst = lttng::sessiond::trace; +namespace lsu = lttng::sessiond::ust; -ust_registry_session_per_uid::ust_registry_session_per_uid( +lsu::registry_session_per_uid::registry_session_per_uid( const struct lst::abi& in_abi, uint32_t major, uint32_t minor, @@ -19,20 +20,20 @@ ust_registry_session_per_uid::ust_registry_session_per_uid( gid_t egid, uint64_t tracing_id, uid_t tracing_uid) : - ust_registry_session{in_abi, major, minor, root_shm_path, shm_path, euid, egid, tracing_id}, + registry_session{in_abi, major, minor, root_shm_path, shm_path, euid, egid, tracing_id}, _tracing_uid{tracing_uid} { lttng::pthread::lock_guard registry_lock(_lock); _generate_metadata(); } -lttng_buffer_type ust_registry_session_per_uid::get_buffering_scheme() const noexcept +lttng_buffer_type lsu::registry_session_per_uid::get_buffering_scheme() const noexcept { return LTTNG_BUFFER_PER_UID; } -void ust_registry_session_per_uid::_visit_environment(lst::trace_class_visitor& visitor) const +void lsu::registry_session_per_uid::_visit_environment(lst::trace_class_visitor& visitor) const { - ust_registry_session::_visit_environment(visitor); + registry_session::_visit_environment(visitor); visitor.visit(lst::environment_field("tracer_buffering_id", _tracing_uid)); } diff --git a/src/bin/lttng-sessiond/ust-registry-session-uid.hpp b/src/bin/lttng-sessiond/ust-registry-session-uid.hpp new file mode 100644 index 000000000..665bfa5d0 --- /dev/null +++ b/src/bin/lttng-sessiond/ust-registry-session-uid.hpp @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2022 Jérémie Galarneau + * + * SPDX-License-Identifier: GPL-2.0-only + * + */ + +#ifndef LTTNG_UST_REGISTRY_SESSION_UID_H +#define LTTNG_UST_REGISTRY_SESSION_UID_H + +#include "trace-class.hpp" +#include "ust-registry-session.hpp" + +#include +#include +#include + +namespace lttng { +namespace sessiond { +namespace ust { + +class registry_session_per_uid : public registry_session { +public: + registry_session_per_uid(const struct lttng::sessiond::trace::abi& trace_abi, + 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); + + virtual lttng_buffer_type get_buffering_scheme() const noexcept override final; + +private: + virtual void _visit_environment( + lttng::sessiond::trace::trace_class_visitor& trace_class_visitor) + const override final; + + const uid_t _tracing_uid; +}; + +} /* namespace ust */ +} /* namespace sessiond */ +} /* namespace lttng */ + +#endif /* LTTNG_UST_REGISTRY_SESSION_UID_H */ diff --git a/src/bin/lttng-sessiond/ust-registry-session.cpp b/src/bin/lttng-sessiond/ust-registry-session.cpp index 652a3fbc9..bb678fe4d 100644 --- a/src/bin/lttng-sessiond/ust-registry-session.cpp +++ b/src/bin/lttng-sessiond/ust-registry-session.cpp @@ -133,12 +133,12 @@ void destroy_channel(lsu::registry_channel *chan, bool notify) } } /* namespace */ -void ls::details::locked_ust_registry_session_release(ust_registry_session *session) +void lsu::details::locked_registry_session_release(lsu::registry_session *session) { pthread_mutex_unlock(&session->_lock); } -ust_registry_session::ust_registry_session(const struct lst::abi& in_abi, +lsu::registry_session::registry_session(const struct lst::abi& in_abi, uint32_t major, uint32_t minor, const char *root_shm_path, @@ -205,7 +205,7 @@ ust_registry_session::ust_registry_session(const struct lst::abi& in_abi, } } -ust_registry_session::~ust_registry_session() +lsu::registry_session::~registry_session() { int ret; struct lttng_ht_iter iter; @@ -265,7 +265,7 @@ ust_registry_session::~ust_registry_session() } } -ust_registry_session::locked_ptr ust_registry_session::lock() +lsu::registry_session::locked_ptr lsu::registry_session::lock() { pthread_mutex_lock(&_lock); return locked_ptr(this); @@ -274,7 +274,7 @@ ust_registry_session::locked_ptr ust_registry_session::lock() /* * Initialize registry with default values. */ -void ust_registry_session::add_channel(uint64_t key) +void lsu::registry_session::add_channel(uint64_t key) { lttng::pthread::lock_guard session_lock_guard(_lock); @@ -315,7 +315,7 @@ void ust_registry_session::add_channel(uint64_t key) lttng_ht_add_unique_u64(_channels.get(), &chan->_node); } -lttng::sessiond::ust::registry_channel& ust_registry_session::get_channel( +lttng::sessiond::ust::registry_channel& lsu::registry_session::get_channel( uint64_t channel_key) const { lttng::urcu::read_lock_guard read_lock_guard; @@ -338,7 +338,7 @@ lttng::sessiond::ust::registry_channel& ust_registry_session::get_channel( return *chan; } -void ust_registry_session::remove_channel(uint64_t channel_key, bool notify) +void lsu::registry_session::remove_channel(uint64_t channel_key, bool notify) { struct lttng_ht_iter iter; int ret; @@ -353,7 +353,7 @@ void ust_registry_session::remove_channel(uint64_t channel_key, bool notify) destroy_channel(&channel, notify); } -void ust_registry_session::_visit_environment( +void lsu::registry_session::_visit_environment( lttng::sessiond::trace::trace_class_visitor& visitor) const { ASSERT_LOCKED(_lock); @@ -383,13 +383,13 @@ void ust_registry_session::_visit_environment( } } -void ust_registry_session::_accept_on_clock_classes(lst::trace_class_visitor& visitor) const +void lsu::registry_session::_accept_on_clock_classes(lst::trace_class_visitor& visitor) const { ASSERT_LOCKED(_lock); _clock.accept(visitor); } -void ust_registry_session::_accept_on_stream_classes(lst::trace_class_visitor& visitor) const +void lsu::registry_session::_accept_on_stream_classes(lst::trace_class_visitor& visitor) const { ASSERT_LOCKED(_lock); @@ -428,7 +428,7 @@ void ust_registry_session::_accept_on_stream_classes(lst::trace_class_visitor& v * Return a unique channel ID. If max is reached, the used_channel_id counter * is returned. */ -uint32_t ust_registry_session::_get_next_channel_id() +uint32_t lsu::registry_session::_get_next_channel_id() { if (is_max_channel_id(_used_channel_id)) { return _used_channel_id; @@ -438,7 +438,7 @@ uint32_t ust_registry_session::_get_next_channel_id() return _next_channel_id++; } -void ust_registry_session::_increase_metadata_size(size_t reservation_length) +void lsu::registry_session::_increase_metadata_size(size_t reservation_length) { const auto new_len = _metadata_len + reservation_length; auto new_alloc_len = new_len; @@ -473,7 +473,7 @@ void ust_registry_session::_increase_metadata_size(size_t reservation_length) _metadata_len += reservation_length; } -void ust_registry_session::_append_metadata_fragment(const std::string& fragment) +void lsu::registry_session::_append_metadata_fragment(const std::string& fragment) { const auto offset = _metadata_len; @@ -491,7 +491,7 @@ void ust_registry_session::_append_metadata_fragment(const std::string& fragment } } -void ust_registry_session::_reset_metadata() +void lsu::registry_session::_reset_metadata() { _metadata_len_sent = 0; memset(_metadata, 0, _metadata_alloc_len); @@ -503,12 +503,12 @@ void ust_registry_session::_reset_metadata() } } -void ust_registry_session::_generate_metadata() +void lsu::registry_session::_generate_metadata() { accept(*_metadata_generating_visitor); } -void ust_registry_session::regenerate_metadata() +void lsu::registry_session::regenerate_metadata() { lttng::pthread::lock_guard registry_lock(_lock); diff --git a/src/bin/lttng-sessiond/ust-registry-session.hpp b/src/bin/lttng-sessiond/ust-registry-session.hpp new file mode 100644 index 000000000..c95097e4f --- /dev/null +++ b/src/bin/lttng-sessiond/ust-registry-session.hpp @@ -0,0 +1,179 @@ +/* + * Copyright (C) 2022 Jérémie Galarneau + * + * SPDX-License-Identifier: GPL-2.0-only + * + */ + +#ifndef LTTNG_UST_REGISTRY_SESSION_H +#define LTTNG_UST_REGISTRY_SESSION_H + +#include "clock-class.hpp" +#include "session.hpp" +#include "trace-class.hpp" +#include "ust-clock-class.hpp" +#include "ust-registry-channel.hpp" + +#include + +#include +#include +#include +#include +#include + +namespace lttng { +namespace sessiond { +namespace ust { + +class registry_session; + +namespace details { +void locked_registry_session_release(registry_session *session); +} /* namespace details */ + +class registry_session : public lttng::sessiond::trace::trace_class { +public: + using locked_ptr = std::unique_ptr:: + deleter>; + + virtual lttng_buffer_type get_buffering_scheme() const noexcept = 0; + locked_ptr lock(); + + void add_channel(uint64_t channel_key); + lttng::sessiond::ust::registry_channel& get_channel(uint64_t channel_key) const; + void remove_channel(uint64_t channel_key, bool notify); + + void regenerate_metadata(); + virtual ~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. + */ + mutable pthread_mutex_t _lock; + /* Next channel ID available for a newly registered channel. */ + uint32_t _next_channel_id = 0; + /* Once this value reaches UINT32_MAX, no more id can be allocated. */ + uint32_t _used_channel_id = 0; + /* Next enumeration ID available. */ + uint64_t _next_enum_id = 0; + + /* Generated metadata. */ + char *_metadata = nullptr; /* NOT null-terminated ! Use memcpy. */ + size_t _metadata_len = 0, _metadata_alloc_len = 0; + /* Length of bytes sent to the consumer. */ + size_t _metadata_len_sent = 0; + /* Current version of the metadata. */ + uint64_t _metadata_version = 0; + + /* + * 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] = {}; + /* File-backed metadata FD */ + int _metadata_fd = -1; + + /* + * Hash table containing channels sent by the UST tracer. MUST + * be accessed with a RCU read side lock acquired. + */ + lttng_ht::uptr _channels; + + /* + * Unique key to identify the metadata on the consumer side. + */ + uint64_t _metadata_key = 0; + /* + * 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. + */ + bool _metadata_closed = false; + + /* User and group owning the session. */ + uid_t _uid = -1; + gid_t _gid = -1; + + /* Enumerations table. */ + lttng_ht::uptr _enums; + + /* + * Copy of the tracer version when the first app is registered. + * It is used if we need to regenerate the metadata. + */ + uint32_t _app_tracer_version_major = 0; + uint32_t _app_tracer_version_minor = 0; + + /* The id of the parent session */ + ltt_session::id_t _tracing_id = -1ULL; + +protected: + /* Prevent instanciation of this base class. */ + registry_session(const struct lttng::sessiond::trace::abi& abi, + unsigned int app_tracer_version_major, + unsigned int app_tracer_version_minor, + const char *root_shm_path, + const char *shm_path, + uid_t euid, + gid_t egid, + uint64_t tracing_id); + virtual void _visit_environment( + lttng::sessiond::trace::trace_class_visitor& trace_class_visitor) + const override; + void _generate_metadata(); + +private: + uint32_t _get_next_channel_id(); + void _increase_metadata_size(size_t reservation_length); + void _append_metadata_fragment(const std::string& fragment); + void _reset_metadata(); + + virtual void _accept_on_clock_classes( + lttng::sessiond::trace::trace_class_visitor& trace_class_visitor) + const override final; + virtual void _accept_on_stream_classes( + lttng::sessiond::trace::trace_class_visitor& trace_class_visitor) + const override final; + + lttng::sessiond::ust::clock_class _clock; + const lttng::sessiond::trace::trace_class_visitor::cuptr _metadata_generating_visitor; +}; + +} /* namespace ust */ +} /* namespace sessiond */ +} /* namespace lttng */ + +#endif /* LTTNG_UST_REGISTRY_SESSION_H */ diff --git a/src/bin/lttng-sessiond/ust-registry.cpp b/src/bin/lttng-sessiond/ust-registry.cpp index 570f367a8..ce76e403f 100644 --- a/src/bin/lttng-sessiond/ust-registry.cpp +++ b/src/bin/lttng-sessiond/ust-registry.cpp @@ -11,6 +11,8 @@ #include "lttng-sessiond.hpp" #include "notification-thread-commands.hpp" #include "ust-app.hpp" +#include "ust-registry-session-pid.hpp" +#include "ust-registry-session-uid.hpp" #include "utils.hpp" #include @@ -157,7 +159,7 @@ static void destroy_enum_rcu(struct rcu_head *head) * Needs to be called from RCU read-side critical section. */ static lsu::registry_enum *ust_registry_lookup_enum( - ust_registry_session *session, + lsu::registry_session *session, const lsu::registry_enum *reg_enum_lookup) { lsu::registry_enum *reg_enum = NULL; @@ -187,7 +189,7 @@ end: * Lookup enumeration by enum ID. */ lsu::registry_enum::const_rcu_protected_reference -ust_registry_lookup_enum_by_id(const ust_registry_session *session, +ust_registry_lookup_enum_by_id(const lsu::registry_session *session, const char *enum_name, uint64_t enum_id) { lsu::registry_enum *reg_enum = NULL; @@ -231,7 +233,7 @@ ust_registry_lookup_enum_by_id(const ust_registry_session *session, * * We receive ownership of entries. */ -int ust_registry_create_or_find_enum(ust_registry_session *session, +int ust_registry_create_or_find_enum(lsu::registry_session *session, int session_objd, char *enum_name, struct lttng_ust_ctl_enum_entry *raw_entries, size_t nr_entries, uint64_t *enum_id) @@ -305,7 +307,7 @@ end: * the enumeration. * This MUST be called within a RCU read side lock section. */ -void ust_registry_destroy_enum(ust_registry_session *reg_session, +void ust_registry_destroy_enum(lsu::registry_session *reg_session, lsu::registry_enum *reg_enum) { int ret; @@ -322,7 +324,7 @@ void ust_registry_destroy_enum(ust_registry_session *reg_session, call_rcu(®_enum->rcu_head, destroy_enum_rcu); } -ust_registry_session *ust_registry_session_per_uid_create(const lttng::sessiond::trace::abi& abi, +lsu::registry_session *ust_registry_session_per_uid_create(const lttng::sessiond::trace::abi& abi, uint32_t major, uint32_t minor, const char *root_shm_path, @@ -333,7 +335,7 @@ ust_registry_session *ust_registry_session_per_uid_create(const lttng::sessiond: uid_t tracing_uid) { try { - return new ust_registry_session_per_uid(abi, major, minor, root_shm_path, shm_path, + return new lsu::registry_session_per_uid(abi, major, minor, root_shm_path, shm_path, euid, egid, tracing_id, tracing_uid); } catch (const std::exception& ex) { ERR("Failed to create per-uid registry session: %s", ex.what()); @@ -341,7 +343,7 @@ ust_registry_session *ust_registry_session_per_uid_create(const lttng::sessiond: } } -ust_registry_session *ust_registry_session_per_pid_create(struct ust_app *app, +lsu::registry_session *ust_registry_session_per_pid_create(struct ust_app *app, const lttng::sessiond::trace::abi& abi, uint32_t major, uint32_t minor, @@ -352,7 +354,7 @@ ust_registry_session *ust_registry_session_per_pid_create(struct ust_app *app, uint64_t tracing_id) { try { - return new ust_registry_session_per_pid(*app, abi, major, minor, root_shm_path, + return new lsu::registry_session_per_pid(*app, abi, major, minor, root_shm_path, shm_path, euid, egid, tracing_id); } catch (const std::exception& ex) { ERR("Failed to create per-pid registry session: %s", ex.what()); @@ -364,7 +366,7 @@ ust_registry_session *ust_registry_session_per_pid_create(struct ust_app *app, * Destroy session registry. This does NOT free the given pointer since it * might get passed as a reference. The registry lock should NOT be acquired. */ -void ust_registry_session_destroy(ust_registry_session *reg) +void ust_registry_session_destroy(lsu::registry_session *reg) { delete reg; } diff --git a/src/bin/lttng-sessiond/ust-registry.hpp b/src/bin/lttng-sessiond/ust-registry.hpp index acfc92404..627ae06c0 100644 --- a/src/bin/lttng-sessiond/ust-registry.hpp +++ b/src/bin/lttng-sessiond/ust-registry.hpp @@ -18,6 +18,7 @@ #include "ust-clock-class.hpp" #include "ust-registry-channel.hpp" #include "ust-registry-event.hpp" +#include "ust-registry-session.hpp" #include #include @@ -38,233 +39,12 @@ #define CTF_SPEC_MINOR 8 struct ust_app; -class ust_registry_session; - -namespace lttng { -namespace sessiond { -namespace details { -void locked_ust_registry_session_release(ust_registry_session *session); -} /* namespace details */ -} /* namespace sessiond */ -} /* namespace lttng */ - -class ust_registry_session : public lttng::sessiond::trace::trace_class { -public: - using locked_ptr = std::unique_ptr:: - deleter>; - - virtual lttng_buffer_type get_buffering_scheme() const noexcept = 0; - locked_ptr lock(); - - void add_channel(uint64_t channel_key); - lttng::sessiond::ust::registry_channel& get_channel(uint64_t channel_key) const; - void remove_channel(uint64_t channel_key, bool notify); - - void regenerate_metadata(); - virtual ~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. - */ - mutable pthread_mutex_t _lock; - /* Next channel ID available for a newly registered channel. */ - uint32_t _next_channel_id = 0; - /* Once this value reaches UINT32_MAX, no more id can be allocated. */ - uint32_t _used_channel_id = 0; - /* Next enumeration ID available. */ - uint64_t _next_enum_id = 0; - - /* Generated metadata. */ - char *_metadata = nullptr; /* NOT null-terminated ! Use memcpy. */ - size_t _metadata_len = 0, _metadata_alloc_len = 0; - /* Length of bytes sent to the consumer. */ - size_t _metadata_len_sent = 0; - /* Current version of the metadata. */ - uint64_t _metadata_version = 0; - - /* - * 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] = {}; - /* File-backed metadata FD */ - int _metadata_fd = -1; - - /* - * Hash table containing channels sent by the UST tracer. MUST - * be accessed with a RCU read side lock acquired. - */ - lttng_ht::uptr _channels; - - /* - * Unique key to identify the metadata on the consumer side. - */ - uint64_t _metadata_key = 0; - /* - * 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. - */ - bool _metadata_closed = false; - - /* User and group owning the session. */ - uid_t _uid = -1; - gid_t _gid = -1; - - /* Enumerations table. */ - lttng_ht::uptr _enums; - - /* - * Copy of the tracer version when the first app is registered. - * It is used if we need to regenerate the metadata. - */ - uint32_t _app_tracer_version_major = 0; - uint32_t _app_tracer_version_minor = 0; - - /* The id of the parent session */ - ltt_session::id_t _tracing_id = -1ULL; - -protected: - /* Prevent instanciation of this base class. */ - ust_registry_session(const struct lttng::sessiond::trace::abi& abi, - unsigned int app_tracer_version_major, - unsigned int app_tracer_version_minor, - const char *root_shm_path, - const char *shm_path, - uid_t euid, - gid_t egid, - uint64_t tracing_id); - virtual void _visit_environment( - lttng::sessiond::trace::trace_class_visitor& trace_class_visitor) - const override; - void _generate_metadata(); - -private: - uint32_t _get_next_channel_id(); - void _increase_metadata_size(size_t reservation_length); - void _append_metadata_fragment(const std::string& fragment); - void _reset_metadata(); - - virtual void _accept_on_clock_classes( - lttng::sessiond::trace::trace_class_visitor& trace_class_visitor) - const override final; - virtual void _accept_on_stream_classes( - lttng::sessiond::trace::trace_class_visitor& trace_class_visitor) - const override final; - - lttng::sessiond::ust::clock_class _clock; - const lttng::sessiond::trace::trace_class_visitor::cuptr _metadata_generating_visitor; -}; - -class ust_registry_session_per_uid : public ust_registry_session { -public: - ust_registry_session_per_uid(const struct lttng::sessiond::trace::abi& trace_abi, - 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); - - virtual lttng_buffer_type get_buffering_scheme() const noexcept override final; - -private: - virtual void _visit_environment( - lttng::sessiond::trace::trace_class_visitor& trace_class_visitor) - const override final; - - const uid_t _tracing_uid; -}; - -class ust_registry_session_per_pid : public ust_registry_session { -public: - ust_registry_session_per_pid(const struct ust_app& app, - const struct lttng::sessiond::trace::abi& - trace_abi, - 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); - - virtual lttng_buffer_type get_buffering_scheme() const noexcept override final; - -private: - virtual void _visit_environment( - lttng::sessiond::trace::trace_class_visitor& trace_class_visitor) - const override final; - - const unsigned int _tracer_patch_level_version; - const pid_t _vpid; - const std::string _procname; - const std::time_t _app_creation_time; -}; - namespace lttng { namespace sessiond { namespace ust { - -class registry_enum { -public: - using const_rcu_protected_reference = lttng::locked_reference; - - registry_enum(std::string name, enum lttng::sessiond::trace::integer_type::signedness signedness); - virtual ~registry_enum() = default; - - std::string name; - enum lttng::sessiond::trace::integer_type::signedness signedness; - /* enum id in session */ - uint64_t id = -1ULL; - /* Enumeration node in session hash table. */ - struct lttng_ht_node_str node; - /* For delayed reclaim. */ - struct rcu_head rcu_head; - - friend bool operator==(const registry_enum& lhs, const registry_enum& rhs) noexcept; -protected: - virtual bool _is_equal(const registry_enum& other) const noexcept = 0; -}; - -bool operator==(const registry_enum& lhs, const registry_enum& rhs) noexcept; - namespace details { + template typename trace::typed_enumeration_type::mapping mapping_from_ust_ctl_entry( const lttng_ust_ctl_enum_entry& entry) @@ -295,6 +75,29 @@ typename trace::typed_enumeration_type::mappings mappings_fr } } /* namespace details */ +class registry_enum { +public: + using const_rcu_protected_reference = lttng::locked_reference; + + registry_enum(std::string name, enum lttng::sessiond::trace::integer_type::signedness signedness); + virtual ~registry_enum() = default; + + std::string name; + enum lttng::sessiond::trace::integer_type::signedness signedness; + /* enum id in session */ + uint64_t id = -1ULL; + /* Enumeration node in session hash table. */ + struct lttng_ht_node_str node; + /* For delayed reclaim. */ + struct rcu_head rcu_head; + + friend bool operator==(const registry_enum& lhs, const registry_enum& rhs) noexcept; +protected: + virtual bool _is_equal(const registry_enum& other) const noexcept = 0; +}; + +bool operator==(const registry_enum& lhs, const registry_enum& rhs) noexcept; + template class registry_typed_enum : public registry_enum { public: @@ -340,7 +143,7 @@ using registry_unsigned_enum = registry_typed_enum; * * Return new instance on success, nullptr on error. */ -ust_registry_session *ust_registry_session_per_uid_create( +lttng::sessiond::ust::registry_session *ust_registry_session_per_uid_create( const lttng::sessiond::trace::abi& abi, uint32_t major, uint32_t minor, @@ -356,7 +159,7 @@ ust_registry_session *ust_registry_session_per_uid_create( * * Return new instance on success, nullptr on error. */ -ust_registry_session *ust_registry_session_per_pid_create(struct ust_app *app, +lttng::sessiond::ust::registry_session *ust_registry_session_per_pid_create(struct ust_app *app, const lttng::sessiond::trace::abi& abi, uint32_t major, uint32_t minor, @@ -365,24 +168,24 @@ ust_registry_session *ust_registry_session_per_pid_create(struct ust_app *app, uid_t euid, gid_t egid, uint64_t tracing_id); -void ust_registry_session_destroy(ust_registry_session *session); +void ust_registry_session_destroy(lttng::sessiond::ust::registry_session *session); void ust_registry_channel_destroy_event(lttng::sessiond::ust::registry_channel *chan, lttng::sessiond::ust::registry_event *event); -int ust_registry_create_or_find_enum(ust_registry_session *session, +int ust_registry_create_or_find_enum(lttng::sessiond::ust::registry_session *session, int session_objd, char *name, struct lttng_ust_ctl_enum_entry *entries, size_t nr_entries, uint64_t *enum_id); lttng::sessiond::ust::registry_enum::const_rcu_protected_reference -ust_registry_lookup_enum_by_id(const ust_registry_session *session, +ust_registry_lookup_enum_by_id(const lttng::sessiond::ust::registry_session *session, const char *name, uint64_t id); -void ust_registry_destroy_enum(ust_registry_session *reg_session, +void ust_registry_destroy_enum(lttng::sessiond::ust::registry_session *reg_session, lttng::sessiond::ust::registry_enum *reg_enum); #else /* HAVE_LIBLTTNG_UST_CTL */ static inline -ust_registry_session *ust_registry_session_per_uid_create( +lttng::sessiond::ust::registry_session *ust_registry_session_per_uid_create( uint32_t bits_per_long __attribute__((unused)), uint32_t uint8_t_alignment __attribute__((unused)), uint32_t uint16_t_alignment __attribute__((unused)), @@ -403,7 +206,7 @@ ust_registry_session *ust_registry_session_per_uid_create( } static inline -ust_registry_session *ust_registry_session_per_pid_create( +lttng::sessiond::ust::registry_session *ust_registry_session_per_pid_create( struct ust_app *app __attribute__((unused)), uint32_t bits_per_long __attribute__((unused)), uint32_t uint8_t_alignment __attribute__((unused)), @@ -425,7 +228,7 @@ ust_registry_session *ust_registry_session_per_pid_create( static inline void ust_registry_session_destroy( - ust_registry_session *session __attribute__((unused))) + lttng::sessiond::ust::registry_session *session __attribute__((unused))) {} static inline @@ -437,14 +240,14 @@ void ust_registry_destroy_event( /* The app object can be NULL for registry shared across applications. */ static inline int ust_metadata_session_statedump( - ust_registry_session *session __attribute__((unused))) + lttng::sessiond::ust::registry_session *session __attribute__((unused))) { return 0; } static inline int ust_metadata_channel_statedump( - ust_registry_session *session __attribute__((unused)), + lttng::sessiond::ust::registry_session *session __attribute__((unused)), lttng::sessiond::ust::registry_channel *chan __attribute__((unused))) { return 0; @@ -452,7 +255,7 @@ int ust_metadata_channel_statedump( static inline int ust_metadata_event_statedump( - ust_registry_session *session __attribute__((unused)), + lttng::sessiond::ust::registry_session *session __attribute__((unused)), lttng::sessiond::ust::registry_channel *chan __attribute__((unused)), lttng::sessiond::ust::registry_event *event __attribute__((unused))) { @@ -461,7 +264,7 @@ int ust_metadata_event_statedump( static inline int ust_registry_create_or_find_enum( - ust_registry_session *session __attribute__((unused)), + lttng::sessiond::ust::registry_session *session __attribute__((unused)), int session_objd __attribute__((unused)), char *name __attribute__((unused)), struct lttng_ust_ctl_enum_entry *entries __attribute__((unused)), @@ -474,7 +277,7 @@ int ust_registry_create_or_find_enum( static inline struct ust_registry_enum * ust_registry_lookup_enum_by_id( - const ust_registry_session *session __attribute__((unused)), + const lttng::sessiond::ust::registry_session *session __attribute__((unused)), const char *name __attribute__((unused)), uint64_t id __attribute__((unused))) { @@ -482,7 +285,7 @@ struct ust_registry_enum * } static inline -void ust_registry_destroy_enum(ust_registry_session *reg_session __attribute__((unused)), +void ust_registry_destroy_enum(lttng::sessiond::ust::registry_session *reg_session __attribute__((unused)), struct ust_registry_enum *reg_enum __attribute__((unused))) {}