#include <urcu/list.h>
#include <urcu/uatomic.h>
-#include <common/buffer-view.h>
-#include <common/common.h>
-#include <common/compat/string.h>
-#include <common/defaults.h>
-#include <common/dynamic-buffer.h>
-#include <common/kernel-ctl/kernel-ctl.h>
-#include <common/relayd/relayd.h>
-#include <common/sessiond-comm/sessiond-comm.h>
-#include <common/string-utils/string-utils.h>
-#include <common/trace-chunk.h>
-#include <common/utils.h>
-
+#include <common/buffer-view.hpp>
+#include <common/common.hpp>
+#include <common/compat/string.hpp>
+#include <common/defaults.hpp>
+#include <common/dynamic-buffer.hpp>
+#include <common/kernel-ctl/kernel-ctl.hpp>
+#include <common/payload-view.hpp>
+#include <common/payload.hpp>
+#include <common/relayd/relayd.hpp>
+#include <common/sessiond-comm/sessiond-comm.hpp>
+#include <common/string-utils/string-utils.hpp>
+#include <common/trace-chunk.hpp>
+#include <common/utils.hpp>
+#include <lttng/action/action-internal.hpp>
#include <lttng/action/action.h>
-#include <lttng/action/action-internal.h>
-#include <lttng/channel-internal.h>
+#include <lttng/channel-internal.hpp>
#include <lttng/channel.h>
+#include <lttng/condition/condition-internal.hpp>
#include <lttng/condition/condition.h>
-#include <lttng/error-query-internal.h>
-#include <lttng/event-internal.h>
-#include <lttng/location-internal.h>
-#include <lttng/rotate-internal.h>
-#include <lttng/session-descriptor-internal.h>
-#include <lttng/session-internal.h>
-#include <lttng/trigger/trigger-internal.h>
-#include <lttng/userspace-probe-internal.h>
-
-#include "agent-thread.h"
-#include "agent.h"
-#include "buffer-registry.h"
-#include "channel.h"
-#include "cmd.h"
-#include "consumer.h"
-#include "event-notifier-error-accounting.h"
-#include "event.h"
-#include "health-sessiond.h"
-#include "kernel-consumer.h"
-#include "kernel.h"
-#include "lttng-sessiond.h"
-#include "lttng-syscall.h"
-#include "notification-thread-commands.h"
-#include "notification-thread.h"
-#include "rotate.h"
-#include "rotation-thread.h"
-#include "session.h"
-#include "timer.h"
-#include "tracker.h"
-#include "utils.h"
+#include <lttng/condition/event-rule-matches-internal.hpp>
+#include <lttng/condition/event-rule-matches.h>
+#include <lttng/error-query-internal.hpp>
+#include <lttng/event-internal.hpp>
+#include <lttng/event-rule/event-rule-internal.hpp>
+#include <lttng/event-rule/event-rule.h>
+#include <lttng/location-internal.hpp>
+#include <lttng/lttng-error.h>
+#include <lttng/rotate-internal.hpp>
+#include <lttng/session-descriptor-internal.hpp>
+#include <lttng/session-internal.hpp>
+#include <lttng/tracker.h>
+#include <lttng/trigger/trigger-internal.hpp>
+#include <lttng/userspace-probe-internal.hpp>
+
+#include "agent-thread.hpp"
+#include "agent.hpp"
+#include "buffer-registry.hpp"
+#include "channel.hpp"
+#include "cmd.hpp"
+#include "consumer.hpp"
+#include "event-notifier-error-accounting.hpp"
+#include "event.hpp"
+#include "health-sessiond.hpp"
+#include "kernel-consumer.hpp"
+#include "kernel.hpp"
+#include "lttng-sessiond.hpp"
+#include "lttng-syscall.hpp"
+#include "notification-thread-commands.hpp"
+#include "notification-thread.hpp"
+#include "rotate.hpp"
+#include "rotation-thread.hpp"
+#include "session.hpp"
+#include "timer.hpp"
+#include "tracker.hpp"
+#include "utils.hpp"
/* Sleep for 100ms between each check for the shm path's deletion. */
#define SESSION_DESTROY_SHM_PATH_CHECK_DELAY_US 100000
+namespace lsu = lttng::sessiond::ust;
+
+static enum lttng_error_code wait_on_path(void *path);
+
+namespace {
struct cmd_destroy_session_reply_context {
int reply_sock_fd;
bool implicit_rotation_on_destroy;
enum lttng_error_code destruction_status;
};
-static enum lttng_error_code wait_on_path(void *path);
-
/*
* Command completion handler that is used by the destroy command
* when a session that has a non-default shm_path is being destroyed.
*
* See comment in cmd_destroy_session() for the rationale.
*/
-static struct destroy_completion_handler {
+struct destroy_completion_handler {
struct cmd_completion_handler handler;
char shm_path[member_sizeof(struct ltt_session, shm_path)];
} destroy_completion_handler = {
.shm_path = { 0 },
};
-static struct cmd_completion_handler *current_completion_handler;
-
/*
* Used to keep a unique index for each relayd socket created where this value
* is associated with streams on the consumer so it can match the right relayd
* to send to. It must be accessed with the relayd_net_seq_idx_lock
* held.
*/
-static pthread_mutex_t relayd_net_seq_idx_lock = PTHREAD_MUTEX_INITIALIZER;
-static uint64_t relayd_net_seq_idx;
+pthread_mutex_t relayd_net_seq_idx_lock = PTHREAD_MUTEX_INITIALIZER;
+uint64_t relayd_net_seq_idx;
+} /* namespace */
+static struct cmd_completion_handler *current_completion_handler;
static int validate_ust_event_name(const char *);
static int cmd_enable_event_internal(struct ltt_session *session,
const struct lttng_domain *domain,
}
}
if (filter) {
- filter_a = (lttng_bytecode *) zmalloc(sizeof(*filter_a) + filter->len);
+ filter_a = zmalloc<lttng_bytecode>(sizeof(*filter_a) + filter->len);
if (!filter_a) {
free(filter_expression_a);
ret = LTTNG_ERR_FATAL;
struct lttng_bytecode)
+ filter->len;
- filter_copy = (lttng_bytecode *) zmalloc(filter_size);
+ filter_copy = zmalloc<lttng_bytecode>(filter_size);
if (!filter_copy) {
ret = LTTNG_ERR_NOMEM;
goto error;
goto end;
}
+ ret_code = notification_thread_command_add_session(the_notification_thread_handle,
+ new_session->id, new_session->name, new_session->uid, new_session->gid);
+ if (ret_code != LTTNG_OK) {
+ goto end;
+ }
+
+ /* Announce the session's destruction to the notification thread when it is destroyed. */
+ ret = session_add_destroy_notifier(
+ new_session,
+ [](const struct ltt_session *session,
+ void *user_data __attribute__((unused))) {
+ (void) notification_thread_command_remove_session(
+ the_notification_thread_handle, session->id);
+ },
+ NULL);
+ if (ret) {
+ PERROR("Failed to add notification thread command to session's destroy notifiers: session name = %s",
+ new_session->name);
+ ret = LTTNG_ERR_NOMEM;
+ goto end;
+ }
+
if (!session_name) {
ret = lttng_session_descriptor_set_session_name(descriptor,
new_session->name);
struct lttcomm_session_destroy_command_header cmd_header;
struct lttng_trace_archive_location *location = NULL;
struct lttcomm_lttng_msg llm = {
- .cmd_type = LTTNG_DESTROY_SESSION,
+ .cmd_type = LTTCOMM_SESSIOND_COMMAND_DESTROY_SESSION,
.ret_code = reply_context->destruction_status,
.pid = UINT32_MAX,
.cmd_header_size =
struct cmd_destroy_session_reply_context *reply_context = NULL;
if (sock_fd) {
- reply_context = (cmd_destroy_session_reply_context *) zmalloc(sizeof(*reply_context));
+ reply_context = zmalloc<cmd_destroy_session_reply_context>();
if (!reply_context) {
ret = LTTNG_ERR_NOMEM;
goto end;
}
+
reply_context->reply_sock_fd = *sock_fd;
}
goto error;
}
- socket->lock = (pthread_mutex_t *) zmalloc(sizeof(pthread_mutex_t));
+ socket->lock = zmalloc<pthread_mutex_t>();
if (socket->lock == NULL) {
PERROR("zmalloc pthread mutex");
ret = LTTNG_ERR_FATAL;
goto error;
}
+
pthread_mutex_init(socket->lock, NULL);
socket->registered = 1;
goto end;
}
- *domains = (lttng_domain *) zmalloc(nb_dom * sizeof(struct lttng_domain));
+ *domains = calloc<lttng_domain>(nb_dom);
if (*domains == NULL) {
ret = LTTNG_ERR_FATAL;
goto error;
goto end;
}
- list = (lttng_snapshot_output *) zmalloc(session->snapshot.nb_output * sizeof(*list));
+ list = calloc<lttng_snapshot_output>(session->snapshot.nb_output);
if (!list) {
ret = -LTTNG_ERR_NOMEM;
goto end;
return ret;
}
-static
-int clear_metadata_file(int fd)
-{
- int ret;
- off_t lseek_ret;
-
- lseek_ret = lseek(fd, 0, SEEK_SET);
- if (lseek_ret < 0) {
- PERROR("lseek");
- ret = -1;
- goto end;
- }
-
- ret = ftruncate(fd, 0);
- if (ret < 0) {
- PERROR("ftruncate");
- goto end;
- }
-
-end:
- return ret;
-}
-
-static
-int ust_regenerate_metadata(struct ltt_ust_session *usess)
-{
- int ret = 0;
- struct buffer_reg_uid *uid_reg = NULL;
- struct buffer_reg_session *session_reg = NULL;
-
- rcu_read_lock();
- cds_list_for_each_entry(uid_reg, &usess->buffer_reg_uid_list, lnode) {
- struct ust_registry_session *registry;
- struct ust_registry_channel *chan;
- struct lttng_ht_iter iter_chan;
-
- session_reg = uid_reg->registry;
- registry = session_reg->reg.ust;
-
- pthread_mutex_lock(®istry->lock);
- registry->metadata_len_sent = 0;
- memset(registry->metadata, 0, registry->metadata_alloc_len);
- registry->metadata_len = 0;
- registry->metadata_version++;
- if (registry->metadata_fd > 0) {
- /* Clear the metadata file's content. */
- ret = clear_metadata_file(registry->metadata_fd);
- if (ret) {
- pthread_mutex_unlock(®istry->lock);
- goto end;
- }
- }
-
- ret = ust_metadata_session_statedump(registry, NULL,
- registry->major, registry->minor);
- if (ret) {
- pthread_mutex_unlock(®istry->lock);
- ERR("Failed to generate session metadata (err = %d)",
- ret);
- goto end;
- }
- cds_lfht_for_each_entry(registry->channels->ht, &iter_chan.iter,
- chan, node.node) {
- struct ust_registry_event *event;
- struct lttng_ht_iter iter_event;
-
- ret = ust_metadata_channel_statedump(registry, chan);
- if (ret) {
- pthread_mutex_unlock(®istry->lock);
- ERR("Failed to generate channel metadata "
- "(err = %d)", ret);
- goto end;
- }
- cds_lfht_for_each_entry(chan->ht->ht, &iter_event.iter,
- event, node.node) {
- ret = ust_metadata_event_statedump(registry,
- chan, event);
- if (ret) {
- pthread_mutex_unlock(®istry->lock);
- ERR("Failed to generate event metadata "
- "(err = %d)", ret);
- goto end;
- }
- }
- }
- pthread_mutex_unlock(®istry->lock);
- }
-
-end:
- rcu_read_unlock();
- return ret;
-}
-
/*
* Command LTTNG_REGENERATE_METADATA from the lttng-ctl library.
*
}
if (session->ust_session) {
- ret = ust_regenerate_metadata(session->ust_session);
+ ret = trace_ust_regenerate_metadata(session->ust_session);
if (ret < 0) {
ERR("Failed to regenerate the UST metadata");
goto end;
chunk_being_archived = NULL;
if (!quiet_rotation) {
ret = notification_thread_command_session_rotation_ongoing(
- the_notification_thread_handle, session->name,
- session->uid, session->gid,
+ the_notification_thread_handle, session->id,
ongoing_rotation_chunk_id);
if (ret != LTTNG_OK) {
ERR("Failed to notify notification thread that a session rotation is ongoing for session %s",