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.
#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;
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. */
#include "ust-app.hpp"
#include "agent.hpp"
+namespace lsu = lttng::sessiond::ust;
+
/*
* Match function for the events hash table lookup.
*
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;
* 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);
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);
pthread_mutex_lock(&session->_lock);
}
- return ust_registry_session::locked_ptr{session};
+ return lsu::registry_session::locked_ptr{session};
}
} /* namespace */
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;
* 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)
{
* 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;
*/
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;
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;
/* 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;
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();
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;
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) {
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) {
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) {
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) {
#include "trace-ust.hpp"
#include "ust-registry.hpp"
+#include "ust-registry-session.hpp"
#include "session.hpp"
#define UST_APP_EVENT_LIST_SIZE 32
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);
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)))
{
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;
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;
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);
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,
* Always returns a new field, throws on error.
*/
std::vector<lst::field::cuptr> 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)
{
} /* namespace */
std::vector<lst::field::cuptr> 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)
{
#include "field.hpp"
#include "ust-registry.hpp"
+#include "ust-registry-session.hpp"
#include <cstddef>
#include <vector>
namespace ust {
std::vector<trace::field::cuptr> 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);
*/
#include "ust-app.hpp"
-#include "ust-registry.hpp"
+#include "ust-registry-session-pid.hpp"
#include <common/exception.hpp>
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,
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},
_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<int64_t>("tracer_buffering_id", _vpid));
visitor.visit(lst::environment_field<int64_t>(
"tracer_patchlevel", _tracer_patch_level_version));
--- /dev/null
+/*
+ * Copyright (C) 2022 Jérémie Galarneau <jeremie.galarneau@efficios.com>
+ *
+ * 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 <cstdint>
+#include <ctime>
+#include <lttng/lttng.h>
+#include <string>
+#include <unistd.h>
+
+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 */
*
*/
-#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,
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<int64_t>("tracer_buffering_id", _tracing_uid));
}
--- /dev/null
+/*
+ * Copyright (C) 2022 Jérémie Galarneau <jeremie.galarneau@efficios.com>
+ *
+ * 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 <cstdint>
+#include <lttng/lttng.h>
+#include <unistd.h>
+
+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 */
}
} /* 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,
}
}
-ust_registry_session::~ust_registry_session()
+lsu::registry_session::~registry_session()
{
int ret;
struct lttng_ht_iter iter;
}
}
-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);
/*
* 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);
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;
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;
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);
}
}
-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);
* 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;
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;
_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;
}
}
-void ust_registry_session::_reset_metadata()
+void lsu::registry_session::_reset_metadata()
{
_metadata_len_sent = 0;
memset(_metadata, 0, _metadata_alloc_len);
}
}
-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);
--- /dev/null
+/*
+ * Copyright (C) 2022 Jérémie Galarneau <jeremie.galarneau@efficios.com>
+ *
+ * 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 <common/make-unique-wrapper.hpp>
+
+#include <cstdint>
+#include <ctime>
+#include <lttng/lttng.h>
+#include <string>
+#include <unistd.h>
+
+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<registry_session,
+ lttng::details::create_unique_class<registry_session,
+ details::locked_registry_session_release>::
+ 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 */
#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 <common/common.hpp>
* 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;
* 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;
*
* 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)
* 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;
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,
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());
}
}
-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,
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());
* 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;
}
#include "ust-clock-class.hpp"
#include "ust-registry-channel.hpp"
#include "ust-registry-event.hpp"
+#include "ust-registry-session.hpp"
#include <common/format.hpp>
#include <common/hashtable/hashtable.hpp>
#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<ust_registry_session,
- lttng::details::create_unique_class<ust_registry_session,
- lttng::sessiond::details::locked_ust_registry_session_release>::
- 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<const registry_enum, lttng::urcu::unique_read_lock>;
-
- 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 <class MappingIntegerType>
typename trace::typed_enumeration_type<MappingIntegerType>::mapping mapping_from_ust_ctl_entry(
const lttng_ust_ctl_enum_entry& entry)
}
} /* namespace details */
+class registry_enum {
+public:
+ using const_rcu_protected_reference = lttng::locked_reference<const registry_enum, lttng::urcu::unique_read_lock>;
+
+ 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 MappingIntegerType>
class registry_typed_enum : public registry_enum {
public:
*
* 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,
*
* 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,
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)),
}
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)),
static inline
void ust_registry_session_destroy(
- ust_registry_session *session __attribute__((unused)))
+ lttng::sessiond::ust::registry_session *session __attribute__((unused)))
{}
static inline
/* 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;
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)))
{
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)),
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)))
{
}
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)))
{}
projects / lttng-tools.git / commitdiff
