*
*/
-#include <lttng/trigger/trigger.h>
-#include <lttng/lttng-error.h>
-#include "notification-thread.hpp"
#include "notification-thread-commands.hpp"
+#include "notification-thread.hpp"
+
#include <common/error.hpp>
-#include <unistd.h>
-#include <stdint.h>
+
+#include <lttng/lttng-error.h>
+#include <lttng/trigger/trigger.h>
+
#include <inttypes.h>
+#include <stdint.h>
+#include <unistd.h>
-static
-void init_notification_thread_command(struct notification_thread_command *cmd)
+static void init_notification_thread_command(struct notification_thread_command *cmd)
{
CDS_INIT_LIST_HEAD(&cmd->cmd_list_node);
- lttng_waiter_init(&cmd->reply_waiter);
}
-static
-int run_command_wait(struct notification_thread_handle *handle,
- struct notification_thread_command *cmd)
+static int run_command_wait(struct notification_thread_handle *handle,
+ struct notification_thread_command *cmd)
{
int ret;
uint64_t notification_counter = 1;
+ lttng::synchro::waiter command_completion_waiter;
+ cmd->command_completed_waker.emplace(command_completion_waiter.get_waker());
+
pthread_mutex_lock(&handle->cmd_queue.lock);
/* Add to queue. */
- cds_list_add_tail(&cmd->cmd_list_node,
- &handle->cmd_queue.list);
+ cds_list_add_tail(&cmd->cmd_list_node, &handle->cmd_queue.list);
/* Wake-up thread. */
- ret = lttng_write(lttng_pipe_get_writefd(handle->cmd_queue.event_pipe),
- ¬ification_counter, sizeof(notification_counter));
+ ret = lttng_write(
+ handle->cmd_queue.event_fd, ¬ification_counter, sizeof(notification_counter));
if (ret != sizeof(notification_counter)) {
PERROR("write to notification thread's queue event fd");
/*
}
pthread_mutex_unlock(&handle->cmd_queue.lock);
- lttng_waiter_wait(&cmd->reply_waiter);
+ command_completion_waiter.wait();
+ ;
return 0;
error_unlock_queue:
pthread_mutex_unlock(&handle->cmd_queue.lock);
return -1;
}
-static
-struct notification_thread_command *notification_thread_command_copy(
- const struct notification_thread_command *original_cmd)
+static struct notification_thread_command *
+notification_thread_command_copy(const struct notification_thread_command *original_cmd)
{
struct notification_thread_command *new_cmd;
- new_cmd = (notification_thread_command *) zmalloc(sizeof(*new_cmd));
- if (!new_cmd) {
- goto end;
+ try {
+ new_cmd = new notification_thread_command;
+ } catch (const std::bad_alloc& e) {
+ ERR("Failed to allocate notification_thread_command: %s", e.what());
+ return nullptr;
}
*new_cmd = *original_cmd;
init_notification_thread_command(new_cmd);
-end:
return new_cmd;
}
-static
-int run_command_no_wait(struct notification_thread_handle *handle,
- const struct notification_thread_command *in_cmd)
+static int run_command_no_wait(struct notification_thread_handle *handle,
+ const struct notification_thread_command *in_cmd)
{
int ret;
uint64_t notification_counter = 1;
- struct notification_thread_command *new_cmd =
- notification_thread_command_copy(in_cmd);
+ struct notification_thread_command *new_cmd = notification_thread_command_copy(in_cmd);
if (!new_cmd) {
goto error;
pthread_mutex_lock(&handle->cmd_queue.lock);
/* Add to queue. */
- cds_list_add_tail(&new_cmd->cmd_list_node,
- &handle->cmd_queue.list);
+ cds_list_add_tail(&new_cmd->cmd_list_node, &handle->cmd_queue.list);
/* Wake-up thread. */
- ret = lttng_write(lttng_pipe_get_writefd(handle->cmd_queue.event_pipe),
- ¬ification_counter, sizeof(notification_counter));
+ ret = lttng_write(
+ handle->cmd_queue.event_fd, ¬ification_counter, sizeof(notification_counter));
if (ret != sizeof(notification_counter)) {
PERROR("write to notification thread's queue event fd");
/*
cds_list_del(&new_cmd->cmd_list_node);
goto error_unlock_queue;
}
+
pthread_mutex_unlock(&handle->cmd_queue.lock);
return 0;
error_unlock_queue:
- free(new_cmd);
+
+ delete new_cmd;
pthread_mutex_unlock(&handle->cmd_queue.lock);
error:
return -1;
}
-enum lttng_error_code notification_thread_command_register_trigger(
- struct notification_thread_handle *handle,
- struct lttng_trigger *trigger,
- bool is_trigger_anonymous)
+enum lttng_error_code
+notification_thread_command_register_trigger(struct notification_thread_handle *handle,
+ struct lttng_trigger *trigger,
+ bool is_trigger_anonymous)
{
int ret;
enum lttng_error_code ret_code;
- struct notification_thread_command cmd = {};
+ notification_thread_command cmd;
LTTNG_ASSERT(trigger);
init_notification_thread_command(&cmd);
cmd.type = NOTIFICATION_COMMAND_TYPE_REGISTER_TRIGGER;
lttng_trigger_get(trigger);
cmd.parameters.register_trigger.trigger = trigger;
- cmd.parameters.register_trigger.is_trigger_anonymous =
- is_trigger_anonymous;
+ cmd.parameters.register_trigger.is_trigger_anonymous = is_trigger_anonymous;
ret = run_command_wait(handle, &cmd);
if (ret) {
return ret_code;
}
-enum lttng_error_code notification_thread_command_unregister_trigger(
- struct notification_thread_handle *handle,
- const struct lttng_trigger *trigger)
+enum lttng_error_code
+notification_thread_command_unregister_trigger(struct notification_thread_handle *handle,
+ const struct lttng_trigger *trigger)
{
int ret;
enum lttng_error_code ret_code;
- struct notification_thread_command cmd = {};
+ notification_thread_command cmd;
init_notification_thread_command(&cmd);
return ret_code;
}
-enum lttng_error_code notification_thread_command_add_channel(
- struct notification_thread_handle *handle,
- char *session_name, uid_t uid, gid_t gid,
- char *channel_name, uint64_t key,
- enum lttng_domain_type domain, uint64_t capacity)
+enum lttng_error_code
+notification_thread_command_add_session(struct notification_thread_handle *handle,
+ uint64_t session_id,
+ const char *session_name,
+ uid_t session_uid,
+ gid_t session_gid)
+{
+ int ret;
+ enum lttng_error_code ret_code;
+ notification_thread_command cmd;
+
+ init_notification_thread_command(&cmd);
+
+ cmd.type = NOTIFICATION_COMMAND_TYPE_ADD_SESSION;
+ cmd.parameters.add_session.session_id = session_id;
+ cmd.parameters.add_session.session_name = session_name;
+ cmd.parameters.add_session.session_uid = session_uid;
+ cmd.parameters.add_session.session_gid = session_gid;
+
+ ret = run_command_wait(handle, &cmd);
+ if (ret) {
+ ret_code = LTTNG_ERR_UNK;
+ goto end;
+ }
+ ret_code = cmd.reply_code;
+end:
+ return ret_code;
+}
+
+enum lttng_error_code
+notification_thread_command_remove_session(struct notification_thread_handle *handle,
+ uint64_t session_id)
+{
+ int ret;
+ enum lttng_error_code ret_code;
+ notification_thread_command cmd;
+
+ init_notification_thread_command(&cmd);
+
+ cmd.type = NOTIFICATION_COMMAND_TYPE_REMOVE_SESSION;
+ cmd.parameters.remove_session.session_id = session_id;
+
+ ret = run_command_wait(handle, &cmd);
+ if (ret) {
+ ret_code = LTTNG_ERR_UNK;
+ goto end;
+ }
+ ret_code = cmd.reply_code;
+end:
+ return ret_code;
+}
+
+enum lttng_error_code
+notification_thread_command_add_channel(struct notification_thread_handle *handle,
+ uint64_t session_id,
+ char *channel_name,
+ uint64_t key,
+ enum lttng_domain_type domain,
+ uint64_t capacity)
{
int ret;
enum lttng_error_code ret_code;
- struct notification_thread_command cmd = {};
+ notification_thread_command cmd;
init_notification_thread_command(&cmd);
cmd.type = NOTIFICATION_COMMAND_TYPE_ADD_CHANNEL;
- cmd.parameters.add_channel.session.name = session_name;
- cmd.parameters.add_channel.session.uid = uid;
- cmd.parameters.add_channel.session.gid = gid;
+ cmd.parameters.add_channel.session.id = session_id;
cmd.parameters.add_channel.channel.name = channel_name;
cmd.parameters.add_channel.channel.key = key;
cmd.parameters.add_channel.channel.domain = domain;
}
enum lttng_error_code notification_thread_command_remove_channel(
- struct notification_thread_handle *handle,
- uint64_t key, enum lttng_domain_type domain)
+ struct notification_thread_handle *handle, uint64_t key, enum lttng_domain_type domain)
{
int ret;
enum lttng_error_code ret_code;
- struct notification_thread_command cmd = {};
+ notification_thread_command cmd;
init_notification_thread_command(&cmd);
return ret_code;
}
-enum lttng_error_code notification_thread_command_session_rotation_ongoing(
- struct notification_thread_handle *handle,
- const char *session_name, uid_t uid, gid_t gid,
- uint64_t trace_archive_chunk_id)
+enum lttng_error_code
+notification_thread_command_session_rotation_ongoing(struct notification_thread_handle *handle,
+ uint64_t session_id,
+ uint64_t trace_archive_chunk_id)
{
int ret;
enum lttng_error_code ret_code;
- struct notification_thread_command cmd = {};
+ notification_thread_command cmd;
init_notification_thread_command(&cmd);
cmd.type = NOTIFICATION_COMMAND_TYPE_SESSION_ROTATION_ONGOING;
- cmd.parameters.session_rotation.session_name = session_name;
- cmd.parameters.session_rotation.uid = uid;
- cmd.parameters.session_rotation.gid = gid;
- cmd.parameters.session_rotation.trace_archive_chunk_id =
- trace_archive_chunk_id;
+ cmd.parameters.session_rotation.session_id = session_id;
+ cmd.parameters.session_rotation.trace_archive_chunk_id = trace_archive_chunk_id;
ret = run_command_wait(handle, &cmd);
if (ret) {
}
enum lttng_error_code notification_thread_command_session_rotation_completed(
- struct notification_thread_handle *handle,
- const char *session_name, uid_t uid, gid_t gid,
- uint64_t trace_archive_chunk_id,
- struct lttng_trace_archive_location *location)
+ struct notification_thread_handle *handle,
+ uint64_t session_id,
+ uint64_t trace_archive_chunk_id,
+ struct lttng_trace_archive_location *location)
{
int ret;
enum lttng_error_code ret_code;
- struct notification_thread_command cmd = {};
+ notification_thread_command cmd;
init_notification_thread_command(&cmd);
cmd.type = NOTIFICATION_COMMAND_TYPE_SESSION_ROTATION_COMPLETED;
- cmd.parameters.session_rotation.session_name = session_name;
- cmd.parameters.session_rotation.uid = uid;
- cmd.parameters.session_rotation.gid = gid;
- cmd.parameters.session_rotation.trace_archive_chunk_id =
- trace_archive_chunk_id;
+ cmd.parameters.session_rotation.session_id = session_id;
+ cmd.parameters.session_rotation.trace_archive_chunk_id = trace_archive_chunk_id;
cmd.parameters.session_rotation.location = location;
ret = run_command_wait(handle, &cmd);
return ret_code;
}
-enum lttng_error_code notification_thread_command_add_tracer_event_source(
- struct notification_thread_handle *handle,
- int tracer_event_source_fd,
- enum lttng_domain_type domain)
+enum lttng_error_code
+notification_thread_command_add_tracer_event_source(struct notification_thread_handle *handle,
+ int tracer_event_source_fd,
+ enum lttng_domain_type domain)
{
int ret;
enum lttng_error_code ret_code;
- struct notification_thread_command cmd = {};
+ notification_thread_command cmd;
LTTNG_ASSERT(tracer_event_source_fd >= 0);
init_notification_thread_command(&cmd);
cmd.type = NOTIFICATION_COMMAND_TYPE_ADD_TRACER_EVENT_SOURCE;
- cmd.parameters.tracer_event_source.tracer_event_source_fd =
- tracer_event_source_fd;
+ cmd.parameters.tracer_event_source.tracer_event_source_fd = tracer_event_source_fd;
cmd.parameters.tracer_event_source.domain = domain;
ret = run_command_wait(handle, &cmd);
return ret_code;
}
-enum lttng_error_code notification_thread_command_remove_tracer_event_source(
- struct notification_thread_handle *handle,
- int tracer_event_source_fd)
+enum lttng_error_code
+notification_thread_command_remove_tracer_event_source(struct notification_thread_handle *handle,
+ int tracer_event_source_fd)
{
int ret;
enum lttng_error_code ret_code;
- struct notification_thread_command cmd = {};
+ notification_thread_command cmd;
init_notification_thread_command(&cmd);
cmd.type = NOTIFICATION_COMMAND_TYPE_REMOVE_TRACER_EVENT_SOURCE;
- cmd.parameters.tracer_event_source.tracer_event_source_fd =
- tracer_event_source_fd;
+ cmd.parameters.tracer_event_source.tracer_event_source_fd = tracer_event_source_fd;
ret = run_command_wait(handle, &cmd);
if (ret) {
}
enum lttng_error_code notification_thread_command_list_triggers(
- struct notification_thread_handle *handle,
- uid_t uid,
- struct lttng_triggers **triggers)
+ struct notification_thread_handle *handle, uid_t uid, struct lttng_triggers **triggers)
{
int ret;
enum lttng_error_code ret_code;
- struct notification_thread_command cmd = {};
+ notification_thread_command cmd;
LTTNG_ASSERT(handle);
LTTNG_ASSERT(triggers);
return ret_code;
}
-void notification_thread_command_quit(
- struct notification_thread_handle *handle)
+void notification_thread_command_quit(struct notification_thread_handle *handle)
{
int ret;
- struct notification_thread_command cmd = {};
+ notification_thread_command cmd;
init_notification_thread_command(&cmd);
}
int notification_thread_client_communication_update(
- struct notification_thread_handle *handle,
- notification_client_id id,
- enum client_transmission_status transmission_status)
+ struct notification_thread_handle *handle,
+ notification_client_id id,
+ enum client_transmission_status transmission_status)
{
- struct notification_thread_command cmd = {};
+ notification_thread_command cmd;
init_notification_thread_command(&cmd);
return run_command_no_wait(handle, &cmd);
}
-enum lttng_error_code notification_thread_command_get_trigger(
- struct notification_thread_handle *handle,
- const struct lttng_trigger *trigger,
- struct lttng_trigger **real_trigger)
+enum lttng_error_code
+notification_thread_command_get_trigger(struct notification_thread_handle *handle,
+ const struct lttng_trigger *trigger,
+ struct lttng_trigger **real_trigger)
{
int ret;
enum lttng_error_code ret_code;
- struct notification_thread_command cmd = {};
+ notification_thread_command cmd;
init_notification_thread_command(&cmd);
* Takes ownership of the payload if present.
*/
struct lttng_event_notifier_notification *lttng_event_notifier_notification_create(
- uint64_t tracer_token,
- enum lttng_domain_type domain,
- char *payload,
- size_t payload_size)
+ uint64_t tracer_token, enum lttng_domain_type domain, char *payload, size_t payload_size)
{
- struct lttng_event_notifier_notification *notification = NULL;
+ struct lttng_event_notifier_notification *notification = nullptr;
LTTNG_ASSERT(domain != LTTNG_DOMAIN_NONE);
LTTNG_ASSERT((payload && payload_size) || (!payload && !payload_size));
- notification = (lttng_event_notifier_notification *) zmalloc(sizeof(struct lttng_event_notifier_notification));
- if (notification == NULL) {
+ notification = zmalloc<lttng_event_notifier_notification>();
+ if (notification == nullptr) {
ERR("Error allocating notification");
goto end;
}
}
void lttng_event_notifier_notification_destroy(
- struct lttng_event_notifier_notification *notification)
+ struct lttng_event_notifier_notification *notification)
{
if (!notification) {
return;
projects / lttng-tools.git / blobdiff