*
*/
-
#define _LGPL_SOURCE
+#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"
+
+#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/urcu.hpp>
+#include <common/utils.hpp>
+
+#include <lttng/action/action-internal.hpp>
+#include <lttng/action/action.h>
+#include <lttng/channel-internal.hpp>
+#include <lttng/channel.h>
+#include <lttng/condition/condition-internal.hpp>
+#include <lttng/condition/condition.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 <algorithm>
#include <inttypes.h>
#include <stdio.h>
#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 <lttng/action/action.h>
-#include <lttng/action/action-internal.h>
-#include <lttng/channel-internal.h>
-#include <lttng/channel.h>
-#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"
-
/* 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 = {
- .handler = {
- .run = wait_on_path,
- .data = destroy_completion_handler.shm_path
- },
+ .handler = { .run = wait_on_path, .data = destroy_completion_handler.shm_path },
.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,
- char *channel_name, struct lttng_event *event,
- char *filter_expression,
- struct lttng_bytecode *filter,
- struct lttng_event_exclusion *exclusion,
- int wpipe);
-static int cmd_enable_channel_internal(struct ltt_session *session,
- const struct lttng_domain *domain,
- const struct lttng_channel *_attr,
- int wpipe);
+ const struct lttng_domain *domain,
+ char *channel_name,
+ struct lttng_event *event,
+ char *filter_expression,
+ struct lttng_bytecode *filter,
+ struct lttng_event_exclusion *exclusion,
+ int wpipe);
+static enum lttng_error_code cmd_enable_channel_internal(struct ltt_session *session,
+ const struct lttng_domain *domain,
+ const struct lttng_channel *_attr,
+ int wpipe);
/*
* Create a session path used by list_lttng_sessions for the case that the
* session consumer is on the network.
*/
-static int build_network_session_path(char *dst, size_t size,
- struct ltt_session *session)
+static int build_network_session_path(char *dst, size_t size, struct ltt_session *session)
{
int ret, kdata_port, udata_port;
- struct lttng_uri *kuri = NULL, *uuri = NULL, *uri = NULL;
+ struct lttng_uri *kuri = nullptr, *uuri = nullptr, *uri = nullptr;
char tmp_uurl[PATH_MAX], tmp_urls[PATH_MAX];
LTTNG_ASSERT(session);
udata_port = session->ust_session->consumer->dst.net.data.port;
}
- if (uuri == NULL && kuri == NULL) {
+ if (uuri == nullptr && kuri == nullptr) {
uri = &session->consumer->dst.net.control;
kdata_port = session->consumer->dst.net.data.port;
} else if (kuri && uuri) {
} else {
uri = kuri;
}
- } else if (kuri && uuri == NULL) {
+ } else if (kuri && uuri == nullptr) {
uri = kuri;
- } else if (uuri && kuri == NULL) {
+ } else if (uuri && kuri == nullptr) {
uri = uuri;
}
* to print.
*/
if (*tmp_uurl != '\0') {
- ret = snprintf(dst, size, "[K]: %s [data: %d] -- [U]: %s [data: %d]",
- tmp_urls, kdata_port, tmp_uurl, udata_port);
+ ret = snprintf(dst,
+ size,
+ "[K]: %s [data: %d] -- [U]: %s [data: %d]",
+ tmp_urls,
+ kdata_port,
+ tmp_uurl,
+ udata_port);
} else {
int dport;
if (kuri || (!kuri && !uuri)) {
* lost packets).
*/
static int get_kernel_runtime_stats(struct ltt_session *session,
- struct ltt_kernel_channel *kchan, uint64_t *discarded_events,
- uint64_t *lost_packets)
+ struct ltt_kernel_channel *kchan,
+ uint64_t *discarded_events,
+ uint64_t *lost_packets)
{
int ret;
goto end;
}
- ret = consumer_get_discarded_events(session->id, kchan->key,
- session->kernel_session->consumer,
- discarded_events);
+ ret = consumer_get_discarded_events(
+ session->id, kchan->key, session->kernel_session->consumer, discarded_events);
if (ret < 0) {
goto end;
}
- ret = consumer_get_lost_packets(session->id, kchan->key,
- session->kernel_session->consumer,
- lost_packets);
+ ret = consumer_get_lost_packets(
+ session->id, kchan->key, session->kernel_session->consumer, lost_packets);
if (ret < 0) {
goto end;
}
* lost packets).
*/
static int get_ust_runtime_stats(struct ltt_session *session,
- struct ltt_ust_channel *uchan, uint64_t *discarded_events,
- uint64_t *lost_packets)
+ struct ltt_ust_channel *uchan,
+ uint64_t *discarded_events,
+ uint64_t *lost_packets)
{
int ret;
struct ltt_ust_session *usess;
if (usess->buffer_type == LTTNG_BUFFER_PER_UID) {
ret = ust_app_uid_get_channel_runtime_stats(usess->id,
- &usess->buffer_reg_uid_list,
- usess->consumer, uchan->id,
- uchan->attr.overwrite,
- discarded_events,
- lost_packets);
+ &usess->buffer_reg_uid_list,
+ usess->consumer,
+ uchan->id,
+ uchan->attr.overwrite,
+ discarded_events,
+ lost_packets);
} else if (usess->buffer_type == LTTNG_BUFFER_PER_PID) {
ret = ust_app_pid_get_channel_runtime_stats(usess,
- uchan, usess->consumer,
- uchan->attr.overwrite,
- discarded_events,
- lost_packets);
+ uchan,
+ usess->consumer,
+ uchan->attr.overwrite,
+ discarded_events,
+ lost_packets);
if (ret < 0) {
goto end;
}
*
* Return number of events in list on success or else a negative value.
*/
-static enum lttng_error_code list_lttng_agent_events(
- struct agent *agt, struct lttng_payload *reply_payload,
- unsigned int *nb_events)
+static enum lttng_error_code list_lttng_agent_events(struct agent *agt,
+ struct lttng_payload *reply_payload,
+ unsigned int *nb_events)
{
enum lttng_error_code ret_code;
int ret = 0;
DBG3("Listing agent events");
- rcu_read_lock();
agent_event_count = lttng_ht_get_count(agt->events);
if (agent_event_count == 0) {
/* Early exit. */
local_nb_events = (unsigned int) agent_event_count;
- cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) {
- struct lttng_event *tmp_event = lttng_event_create();
+ {
+ lttng::urcu::read_lock_guard read_lock;
- if (!tmp_event) {
- ret_code = LTTNG_ERR_NOMEM;
- goto error;
- }
+ cds_lfht_for_each_entry (agt->events->ht, &iter.iter, event, node.node) {
+ struct lttng_event *tmp_event = lttng_event_create();
- if (lttng_strncpy(tmp_event->name, event->name, sizeof(tmp_event->name))) {
- lttng_event_destroy(tmp_event);
- ret_code = LTTNG_ERR_FATAL;
- goto error;
- }
-
- tmp_event->name[sizeof(tmp_event->name) - 1] = '\0';
- tmp_event->enabled = !!event->enabled_count;
- tmp_event->loglevel = event->loglevel_value;
- tmp_event->loglevel_type = event->loglevel_type;
+ if (!tmp_event) {
+ ret_code = LTTNG_ERR_NOMEM;
+ goto error;
+ }
- ret = lttng_event_serialize(tmp_event, 0, NULL,
- event->filter_expression, 0, NULL, reply_payload);
- lttng_event_destroy(tmp_event);
- if (ret) {
- ret_code = LTTNG_ERR_FATAL;
- goto error;
+ if (lttng_strncpy(tmp_event->name, event->name, sizeof(tmp_event->name))) {
+ lttng_event_destroy(tmp_event);
+ ret_code = LTTNG_ERR_FATAL;
+ goto error;
+ }
+
+ tmp_event->name[sizeof(tmp_event->name) - 1] = '\0';
+ tmp_event->enabled = !!event->enabled_count;
+ tmp_event->loglevel = event->loglevel_value;
+ tmp_event->loglevel_type = event->loglevel_type;
+
+ ret = lttng_event_serialize(tmp_event,
+ 0,
+ nullptr,
+ event->filter_expression,
+ 0,
+ nullptr,
+ reply_payload);
+ lttng_event_destroy(tmp_event);
+ if (ret) {
+ ret_code = LTTNG_ERR_FATAL;
+ goto error;
+ }
}
}
-
end:
ret_code = LTTNG_OK;
*nb_events = local_nb_events;
error:
- rcu_read_unlock();
return ret_code;
}
* Create a list of ust global domain events.
*/
static enum lttng_error_code list_lttng_ust_global_events(char *channel_name,
- struct ltt_ust_domain_global *ust_global,
- struct lttng_payload *reply_payload,
- unsigned int *nb_events)
+ struct ltt_ust_domain_global *ust_global,
+ struct lttng_payload *reply_payload,
+ unsigned int *nb_events)
{
enum lttng_error_code ret_code;
int ret;
DBG("Listing UST global events for channel %s", channel_name);
- rcu_read_lock();
+ lttng::urcu::read_lock_guard read_lock;
lttng_ht_lookup(ust_global->channels, (void *) channel_name, &iter);
node = lttng_ht_iter_get_node_str(&iter);
- if (node == NULL) {
+ if (node == nullptr) {
ret_code = LTTNG_ERR_UST_CHAN_NOT_FOUND;
goto error;
}
DBG3("Listing UST global %d events", *nb_events);
- cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
- struct lttng_event *tmp_event = NULL;
+ cds_lfht_for_each_entry (uchan->events->ht, &iter.iter, uevent, node.node) {
+ struct lttng_event *tmp_event = nullptr;
if (uevent->internal) {
/* This event should remain hidden from clients */
goto error;
}
- if (lttng_strncpy(tmp_event->name, uevent->attr.name,
- LTTNG_SYMBOL_NAME_LEN)) {
+ if (lttng_strncpy(tmp_event->name, uevent->attr.name, LTTNG_SYMBOL_NAME_LEN)) {
ret_code = LTTNG_ERR_FATAL;
lttng_event_destroy(tmp_event);
goto error;
* We do not care about the filter bytecode and the fd from the
* userspace_probe_location.
*/
- ret = lttng_event_serialize(tmp_event, uevent->exclusion ? uevent->exclusion->count : 0,
- uevent->exclusion ? (char **) uevent->exclusion ->names : NULL,
- uevent->filter_expression, 0, NULL, reply_payload);
+ ret = lttng_event_serialize(tmp_event,
+ uevent->exclusion ? uevent->exclusion->count : 0,
+ uevent->exclusion ? (char **) uevent->exclusion->names :
+ nullptr,
+ uevent->filter_expression,
+ 0,
+ nullptr,
+ reply_payload);
lttng_event_destroy(tmp_event);
if (ret) {
ret_code = LTTNG_ERR_FATAL;
ret_code = LTTNG_OK;
*nb_events = local_nb_events;
error:
- rcu_read_unlock();
return ret_code;
}
* Fill lttng_event array of all kernel events in the channel.
*/
static enum lttng_error_code list_lttng_kernel_events(char *channel_name,
- struct ltt_kernel_session *kernel_session,
- struct lttng_payload *reply_payload,
- unsigned int *nb_events)
+ struct ltt_kernel_session *kernel_session,
+ struct lttng_payload *reply_payload,
+ unsigned int *nb_events)
{
enum lttng_error_code ret_code;
int ret;
assert(reply_payload);
kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session);
- if (kchan == NULL) {
+ if (kchan == nullptr) {
ret_code = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
goto end;
}
}
/* Kernel channels */
- cds_list_for_each_entry(event, &kchan->events_list.head , list) {
+ cds_list_for_each_entry (event, &kchan->events_list.head, list) {
struct lttng_event *tmp_event = lttng_event_create();
if (!tmp_event) {
lttng_event_destroy(tmp_event);
ret_code = LTTNG_ERR_FATAL;
goto end;
-
}
tmp_event->name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
break;
case LTTNG_KERNEL_ABI_KRETPROBE:
tmp_event->type = LTTNG_EVENT_FUNCTION;
- memcpy(&tmp_event->attr.probe, &event->event->u.kprobe,
- sizeof(struct lttng_kernel_abi_kprobe));
+ memcpy(&tmp_event->attr.probe,
+ &event->event->u.kprobe,
+ sizeof(struct lttng_kernel_abi_kprobe));
break;
case LTTNG_KERNEL_ABI_KPROBE:
tmp_event->type = LTTNG_EVENT_PROBE;
- memcpy(&tmp_event->attr.probe, &event->event->u.kprobe,
- sizeof(struct lttng_kernel_abi_kprobe));
+ memcpy(&tmp_event->attr.probe,
+ &event->event->u.kprobe,
+ sizeof(struct lttng_kernel_abi_kprobe));
break;
case LTTNG_KERNEL_ABI_UPROBE:
tmp_event->type = LTTNG_EVENT_USERSPACE_PROBE;
break;
case LTTNG_KERNEL_ABI_FUNCTION:
tmp_event->type = LTTNG_EVENT_FUNCTION;
- memcpy(&(tmp_event->attr.ftrace), &event->event->u.ftrace,
- sizeof(struct lttng_kernel_abi_function));
+ memcpy(&(tmp_event->attr.ftrace),
+ &event->event->u.ftrace,
+ sizeof(struct lttng_kernel_abi_function));
break;
case LTTNG_KERNEL_ABI_NOOP:
tmp_event->type = LTTNG_EVENT_NOOP;
if (event->userspace_probe_location) {
struct lttng_userspace_probe_location *location_copy =
- lttng_userspace_probe_location_copy(
- event->userspace_probe_location);
+ lttng_userspace_probe_location_copy(
+ event->userspace_probe_location);
if (!location_copy) {
lttng_event_destroy(tmp_event);
goto end;
}
- ret = lttng_event_set_userspace_probe_location(
- tmp_event, location_copy);
+ ret = lttng_event_set_userspace_probe_location(tmp_event, location_copy);
if (ret) {
lttng_event_destroy(tmp_event);
- lttng_userspace_probe_location_destroy(
- location_copy);
+ lttng_userspace_probe_location_destroy(location_copy);
ret_code = LTTNG_ERR_INVALID;
goto end;
}
}
- ret = lttng_event_serialize(tmp_event, 0, NULL,
- event->filter_expression, 0, NULL, reply_payload);
+ ret = lttng_event_serialize(
+ tmp_event, 0, nullptr, event->filter_expression, 0, nullptr, reply_payload);
lttng_event_destroy(tmp_event);
if (ret) {
ret_code = LTTNG_ERR_FATAL;
* Add URI so the consumer output object. Set the correct path depending on the
* domain adding the default trace directory.
*/
-static enum lttng_error_code add_uri_to_consumer(
- const struct ltt_session *session,
- struct consumer_output *consumer,
- struct lttng_uri *uri, enum lttng_domain_type domain)
+static enum lttng_error_code add_uri_to_consumer(const struct ltt_session *session,
+ struct consumer_output *consumer,
+ struct lttng_uri *uri,
+ enum lttng_domain_type domain)
{
int ret;
enum lttng_error_code ret_code = LTTNG_OK;
LTTNG_ASSERT(uri);
- if (consumer == NULL) {
+ if (consumer == nullptr) {
DBG("No consumer detected. Don't add URI. Stopping.");
ret_code = LTTNG_ERR_NO_CONSUMER;
goto error;
switch (domain) {
case LTTNG_DOMAIN_KERNEL:
ret = lttng_strncpy(consumer->domain_subdir,
- DEFAULT_KERNEL_TRACE_DIR,
- sizeof(consumer->domain_subdir));
+ DEFAULT_KERNEL_TRACE_DIR,
+ sizeof(consumer->domain_subdir));
break;
case LTTNG_DOMAIN_UST:
ret = lttng_strncpy(consumer->domain_subdir,
- DEFAULT_UST_TRACE_DIR,
- sizeof(consumer->domain_subdir));
+ DEFAULT_UST_TRACE_DIR,
+ sizeof(consumer->domain_subdir));
break;
default:
/*
* tracing session consumer object which in this case there is
* no subdir.
*/
- memset(consumer->domain_subdir, 0,
- sizeof(consumer->domain_subdir));
+ memset(consumer->domain_subdir, 0, sizeof(consumer->domain_subdir));
ret = 0;
}
if (ret) {
if (consumer->type == CONSUMER_DST_NET) {
if ((uri->stype == LTTNG_STREAM_CONTROL &&
- consumer->dst.net.control_isset) ||
- (uri->stype == LTTNG_STREAM_DATA &&
- consumer->dst.net.data_isset)) {
+ consumer->dst.net.control_isset) ||
+ (uri->stype == LTTNG_STREAM_DATA && consumer->dst.net.data_isset)) {
ret_code = LTTNG_ERR_URL_EXIST;
goto error;
}
ret_code = LTTNG_ERR_INVALID;
goto error;
}
- DBG2("Setting trace directory path from URI to %s",
- uri->dst.path);
+ DBG2("Setting trace directory path from URI to %s", uri->dst.path);
memset(&consumer->dst, 0, sizeof(consumer->dst));
ret = lttng_strncpy(consumer->dst.session_root_path,
- uri->dst.path,
- sizeof(consumer->dst.session_root_path));
+ uri->dst.path,
+ sizeof(consumer->dst.session_root_path));
if (ret) {
ret_code = LTTNG_ERR_FATAL;
goto error;
LTTNG_ASSERT(session);
- rcu_read_lock();
+ if (session->consumer_fds_sent == 0 && session->consumer != nullptr) {
+ lttng::urcu::read_lock_guard read_lock;
- if (session->consumer_fds_sent == 0 && session->consumer != NULL) {
- cds_lfht_for_each_entry(session->consumer->socks->ht, &iter.iter,
- socket, node.node) {
+ cds_lfht_for_each_entry (
+ session->consumer->socks->ht, &iter.iter, socket, node.node) {
pthread_mutex_lock(socket->lock);
ret = kernel_consumer_send_session(socket, session);
pthread_mutex_unlock(socket->lock);
}
error:
- rcu_read_unlock();
return ret;
}
* Else, it remains untouched and an LTTng error code is returned.
*/
static enum lttng_error_code create_connect_relayd(struct lttng_uri *uri,
- struct lttcomm_relayd_sock **relayd_sock,
- struct consumer_output *consumer)
+ struct lttcomm_relayd_sock **relayd_sock,
+ struct consumer_output *consumer)
{
int ret;
enum lttng_error_code status = LTTNG_OK;
struct lttcomm_relayd_sock *rsock;
- rsock = lttcomm_alloc_relayd_sock(uri, RELAYD_VERSION_COMM_MAJOR,
- RELAYD_VERSION_COMM_MINOR);
+ rsock = lttcomm_alloc_relayd_sock(
+ uri, RELAYD_VERSION_COMM_MAJOR, RELAYD_VERSION_COMM_MINOR);
if (!rsock) {
status = LTTNG_ERR_FATAL;
goto error;
}
consumer->relay_major_version = rsock->major;
consumer->relay_minor_version = rsock->minor;
- ret = relayd_get_configuration(rsock, 0,
- &result_flags);
+ ret = relayd_get_configuration(rsock, 0, &result_flags);
if (ret < 0) {
ERR("Unable to get relayd configuration");
status = LTTNG_ERR_RELAYD_CONNECT_FAIL;
*
* Returns LTTNG_OK on success or an LTTng error code on failure.
*/
-static enum lttng_error_code send_consumer_relayd_socket(
- unsigned int session_id,
- struct lttng_uri *relayd_uri,
- struct consumer_output *consumer,
- struct consumer_socket *consumer_sock,
- const char *session_name, const char *hostname,
- const char *base_path, int session_live_timer,
- const uint64_t *current_chunk_id,
- time_t session_creation_time,
- bool session_name_contains_creation_time)
+static enum lttng_error_code send_consumer_relayd_socket(unsigned int session_id,
+ struct lttng_uri *relayd_uri,
+ struct consumer_output *consumer,
+ struct consumer_socket *consumer_sock,
+ const char *session_name,
+ const char *hostname,
+ const char *base_path,
+ int session_live_timer,
+ const uint64_t *current_chunk_id,
+ time_t session_creation_time,
+ bool session_name_contains_creation_time)
{
int ret;
- struct lttcomm_relayd_sock *rsock = NULL;
+ struct lttcomm_relayd_sock *rsock = nullptr;
enum lttng_error_code status;
/* Connect to relayd and make version check if uri is the control. */
}
/* Send relayd socket to consumer. */
- ret = consumer_send_relayd_socket(consumer_sock, rsock, consumer,
- relayd_uri->stype, session_id,
- session_name, hostname, base_path,
- session_live_timer, current_chunk_id,
- session_creation_time, session_name_contains_creation_time);
+ ret = consumer_send_relayd_socket(consumer_sock,
+ rsock,
+ consumer,
+ relayd_uri->stype,
+ session_id,
+ session_name,
+ hostname,
+ base_path,
+ session_live_timer,
+ current_chunk_id,
+ session_creation_time,
+ session_name_contains_creation_time);
if (ret < 0) {
status = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
goto close_sock;
* since the relayd connection failed thus making any tracing or/and
* streaming not usable.
*/
- consumer->enabled = 0;
+ consumer->enabled = false;
}
(void) relayd_close(rsock);
free(rsock);
*
* Returns LTTNG_OK, or an LTTng error code on failure.
*/
-static enum lttng_error_code send_consumer_relayd_sockets(
- unsigned int session_id, struct consumer_output *consumer,
- struct consumer_socket *sock, const char *session_name,
- const char *hostname, const char *base_path, int session_live_timer,
- const uint64_t *current_chunk_id, time_t session_creation_time,
- bool session_name_contains_creation_time)
+static enum lttng_error_code send_consumer_relayd_sockets(unsigned int session_id,
+ struct consumer_output *consumer,
+ struct consumer_socket *sock,
+ const char *session_name,
+ const char *hostname,
+ const char *base_path,
+ int session_live_timer,
+ const uint64_t *current_chunk_id,
+ time_t session_creation_time,
+ bool session_name_contains_creation_time)
{
enum lttng_error_code status = LTTNG_OK;
/* Sending control relayd socket. */
if (!sock->control_sock_sent) {
status = send_consumer_relayd_socket(session_id,
- &consumer->dst.net.control, consumer, sock,
- session_name, hostname, base_path, session_live_timer,
- current_chunk_id, session_creation_time,
- session_name_contains_creation_time);
+ &consumer->dst.net.control,
+ consumer,
+ sock,
+ session_name,
+ hostname,
+ base_path,
+ session_live_timer,
+ current_chunk_id,
+ session_creation_time,
+ session_name_contains_creation_time);
if (status != LTTNG_OK) {
goto error;
}
/* Sending data relayd socket. */
if (!sock->data_sock_sent) {
status = send_consumer_relayd_socket(session_id,
- &consumer->dst.net.data, consumer, sock,
- session_name, hostname, base_path, session_live_timer,
- current_chunk_id, session_creation_time,
- session_name_contains_creation_time);
+ &consumer->dst.net.data,
+ consumer,
+ sock,
+ session_name,
+ hostname,
+ base_path,
+ session_live_timer,
+ current_chunk_id,
+ session_creation_time,
+ session_name_contains_creation_time);
if (status != LTTNG_OK) {
goto error;
}
DBG("Setting relayd for session %s", session->name);
- rcu_read_lock();
if (session->current_trace_chunk) {
enum lttng_trace_chunk_status status = lttng_trace_chunk_get_id(
- session->current_trace_chunk, ¤t_chunk_id.value);
+ session->current_trace_chunk, ¤t_chunk_id.value);
if (status == LTTNG_TRACE_CHUNK_STATUS_OK) {
current_chunk_id.is_set = true;
}
}
- if (usess && usess->consumer && usess->consumer->type == CONSUMER_DST_NET
- && usess->consumer->enabled) {
+ if (usess && usess->consumer && usess->consumer->type == CONSUMER_DST_NET &&
+ usess->consumer->enabled) {
/* For each consumer socket, send relayd sockets */
- cds_lfht_for_each_entry(usess->consumer->socks->ht, &iter.iter,
- socket, node.node) {
+ lttng::urcu::read_lock_guard read_lock;
+
+ cds_lfht_for_each_entry (
+ usess->consumer->socks->ht, &iter.iter, socket, node.node) {
pthread_mutex_lock(socket->lock);
- ret = send_consumer_relayd_sockets(session->id,
- usess->consumer, socket,
- session->name, session->hostname,
- session->base_path,
- session->live_timer,
- current_chunk_id.is_set ? ¤t_chunk_id.value : NULL,
- session->creation_time,
- session->name_contains_creation_time);
+ ret = send_consumer_relayd_sockets(
+ session->id,
+ usess->consumer,
+ socket,
+ session->name,
+ session->hostname,
+ session->base_path,
+ session->live_timer,
+ current_chunk_id.is_set ? ¤t_chunk_id.value : nullptr,
+ session->creation_time,
+ session->name_contains_creation_time);
pthread_mutex_unlock(socket->lock);
if (ret != LTTNG_OK) {
goto error;
/* Session is now ready for network streaming. */
session->net_handle = 1;
}
- session->consumer->relay_major_version =
- usess->consumer->relay_major_version;
- session->consumer->relay_minor_version =
- usess->consumer->relay_minor_version;
- session->consumer->relay_allows_clear =
- usess->consumer->relay_allows_clear;
+
+ session->consumer->relay_major_version = usess->consumer->relay_major_version;
+ session->consumer->relay_minor_version = usess->consumer->relay_minor_version;
+ session->consumer->relay_allows_clear = usess->consumer->relay_allows_clear;
}
- if (ksess && ksess->consumer && ksess->consumer->type == CONSUMER_DST_NET
- && ksess->consumer->enabled) {
- cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
- socket, node.node) {
+ if (ksess && ksess->consumer && ksess->consumer->type == CONSUMER_DST_NET &&
+ ksess->consumer->enabled) {
+ lttng::urcu::read_lock_guard read_lock;
+
+ cds_lfht_for_each_entry (
+ ksess->consumer->socks->ht, &iter.iter, socket, node.node) {
pthread_mutex_lock(socket->lock);
- ret = send_consumer_relayd_sockets(session->id,
- ksess->consumer, socket,
- session->name, session->hostname,
- session->base_path,
- session->live_timer,
- current_chunk_id.is_set ? ¤t_chunk_id.value : NULL,
- session->creation_time,
- session->name_contains_creation_time);
+ ret = send_consumer_relayd_sockets(
+ session->id,
+ ksess->consumer,
+ socket,
+ session->name,
+ session->hostname,
+ session->base_path,
+ session->live_timer,
+ current_chunk_id.is_set ? ¤t_chunk_id.value : nullptr,
+ session->creation_time,
+ session->name_contains_creation_time);
pthread_mutex_unlock(socket->lock);
if (ret != LTTNG_OK) {
goto error;
/* Session is now ready for network streaming. */
session->net_handle = 1;
}
- session->consumer->relay_major_version =
- ksess->consumer->relay_major_version;
- session->consumer->relay_minor_version =
- ksess->consumer->relay_minor_version;
- session->consumer->relay_allows_clear =
- ksess->consumer->relay_allows_clear;
+
+ session->consumer->relay_major_version = ksess->consumer->relay_major_version;
+ session->consumer->relay_minor_version = ksess->consumer->relay_minor_version;
+ session->consumer->relay_allows_clear = ksess->consumer->relay_allows_clear;
}
error:
- rcu_read_unlock();
return ret;
}
struct ltt_kernel_channel *kchan;
/* Open kernel metadata */
- if (ksess->metadata == NULL && ksess->output_traces) {
+ if (ksess->metadata == nullptr && ksess->output_traces) {
ret = kernel_open_metadata(ksess);
if (ret < 0) {
ret = LTTNG_ERR_KERN_META_FAIL;
}
/* For each channel */
- cds_list_for_each_entry(kchan, &ksess->channel_list.head, list) {
+ cds_list_for_each_entry (kchan, &ksess->channel_list.head, list) {
if (kchan->stream_count == 0) {
ret = kernel_open_channel_stream(kchan);
if (ret < 0) {
/* Quiescent wait after starting trace */
kernel_wait_quiescent();
- ksess->active = 1;
+ ksess->active = true;
ret = LTTNG_OK;
}
/* Flush all buffers after stopping */
- cds_list_for_each_entry(kchan, &ksess->channel_list.head, list) {
+ cds_list_for_each_entry (kchan, &ksess->channel_list.head, list) {
ret = kernel_flush_buffer(kchan);
if (ret < 0) {
ERR("Kernel flush buffer error");
}
}
- ksess->active = 0;
+ ksess->active = false;
if (error_occurred) {
ret = LTTNG_ERR_UNK;
} else {
* Command LTTNG_DISABLE_CHANNEL processed by the client thread.
*/
int cmd_disable_channel(struct ltt_session *session,
- enum lttng_domain_type domain, char *channel_name)
+ enum lttng_domain_type domain,
+ char *channel_name)
{
int ret;
struct ltt_ust_session *usess;
usess = session->ust_session;
- rcu_read_lock();
+ lttng::urcu::read_lock_guard read_lock;
switch (domain) {
case LTTNG_DOMAIN_KERNEL:
{
- ret = channel_kernel_disable(session->kernel_session,
- channel_name);
+ ret = channel_kernel_disable(session->kernel_session, channel_name);
if (ret != LTTNG_OK) {
goto error;
}
chan_ht = usess->domain_global.channels;
uchan = trace_ust_find_channel_by_name(chan_ht, channel_name);
- if (uchan == NULL) {
+ if (uchan == nullptr) {
ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
goto error;
}
ret = LTTNG_OK;
error:
- rcu_read_unlock();
return ret;
}
int ret;
size_t channel_len;
ssize_t sock_recv_len;
- struct lttng_channel *channel = NULL;
+ struct lttng_channel *channel = nullptr;
struct lttng_buffer_view view;
struct lttng_dynamic_buffer channel_buffer;
const struct lttng_domain command_domain = cmd_ctx->lsm.domain;
goto end;
}
- sock_recv_len = lttcomm_recv_unix_sock(sock, channel_buffer.data,
- channel_len);
+ sock_recv_len = lttcomm_recv_unix_sock(sock, channel_buffer.data, channel_len);
if (sock_recv_len < 0 || sock_recv_len != channel_len) {
ERR("Failed to receive \"enable channel\" command payload");
ret = LTTNG_ERR_INVALID;
goto end;
}
- ret = cmd_enable_channel_internal(
- cmd_ctx->session, &command_domain, channel, wpipe);
+ ret = cmd_enable_channel_internal(cmd_ctx->session, &command_domain, channel, wpipe);
end:
lttng_dynamic_buffer_reset(&channel_buffer);
return ret;
}
-static int cmd_enable_channel_internal(struct ltt_session *session,
- const struct lttng_domain *domain,
- const struct lttng_channel *_attr,
- int wpipe)
+static enum lttng_error_code cmd_enable_channel_internal(struct ltt_session *session,
+ const struct lttng_domain *domain,
+ const struct lttng_channel *_attr,
+ int wpipe)
{
- int ret;
+ enum lttng_error_code ret_code;
struct ltt_ust_session *usess = session->ust_session;
struct lttng_ht *chan_ht;
size_t len;
- struct lttng_channel *attr = NULL;
+ struct lttng_channel *attr = nullptr;
LTTNG_ASSERT(session);
LTTNG_ASSERT(_attr);
LTTNG_ASSERT(domain);
+ lttng::urcu::read_lock_guard read_lock;
+
attr = lttng_channel_copy(_attr);
if (!attr) {
- ret = LTTNG_ERR_NOMEM;
+ ret_code = LTTNG_ERR_NOMEM;
goto end;
}
len = lttng_strnlen(attr->name, sizeof(attr->name));
/* Validate channel name */
- if (attr->name[0] == '.' ||
- memchr(attr->name, '/', len) != NULL) {
- ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
+ if (attr->name[0] == '.' || memchr(attr->name, '/', len) != nullptr) {
+ ret_code = LTTNG_ERR_INVALID_CHANNEL_NAME;
goto end;
}
DBG("Enabling channel %s for session %s", attr->name, session->name);
- rcu_read_lock();
-
/*
* If the session is a live session, remove the switch timer, the
* live timer does the same thing but sends also synchronisation
if (kernel_supports_ring_buffer_snapshot_sample_positions() != 1) {
/* Sampling position of buffer is not supported */
WARN("Kernel tracer does not support buffer monitoring. "
- "Setting the monitor interval timer to 0 "
- "(disabled) for channel '%s' of session '%s'",
- attr->name, session->name);
+ "Setting the monitor interval timer to 0 "
+ "(disabled) for channel '%s' of session '%s'",
+ attr->name,
+ session->name);
lttng_channel_set_monitor_timer_interval(attr, 0);
}
break;
case LTTNG_DOMAIN_PYTHON:
if (!agent_tracing_is_enabled()) {
DBG("Attempted to enable a channel in an agent domain but the agent thread is not running");
- ret = LTTNG_ERR_AGENT_TRACING_DISABLED;
+ ret_code = LTTNG_ERR_AGENT_TRACING_DISABLED;
goto error;
}
break;
default:
- ret = LTTNG_ERR_UNKNOWN_DOMAIN;
+ ret_code = LTTNG_ERR_UNKNOWN_DOMAIN;
goto error;
}
{
struct ltt_kernel_channel *kchan;
- kchan = trace_kernel_get_channel_by_name(
- attr->name, session->kernel_session);
- if (kchan == NULL) {
+ kchan = trace_kernel_get_channel_by_name(attr->name, session->kernel_session);
+ if (kchan == nullptr) {
/*
* Don't try to create a channel if the session has been started at
* some point in time before. The tracer does not allow it.
*/
if (session->has_been_started) {
- ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
+ ret_code = LTTNG_ERR_TRACE_ALREADY_STARTED;
goto error;
}
- if (session->snapshot.nb_output > 0 ||
- session->snapshot_mode) {
+ if (session->snapshot.nb_output > 0 || session->snapshot_mode) {
/* Enforce mmap output for snapshot sessions. */
attr->attr.output = LTTNG_EVENT_MMAP;
}
- ret = channel_kernel_create(
- session->kernel_session, attr, wpipe);
+ ret_code = channel_kernel_create(session->kernel_session, attr, wpipe);
if (attr->name[0] != '\0') {
session->kernel_session->has_non_default_channel = 1;
}
} else {
- ret = channel_kernel_enable(session->kernel_session, kchan);
+ ret_code = channel_kernel_enable(session->kernel_session, kchan);
}
- if (ret != LTTNG_OK) {
+ if (ret_code != LTTNG_OK) {
goto error;
}
* adhered to.
*/
if (domain->type == LTTNG_DOMAIN_JUL) {
- if (strncmp(attr->name, DEFAULT_JUL_CHANNEL_NAME,
- LTTNG_SYMBOL_NAME_LEN)) {
- ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
+ if (strncmp(attr->name,
+ DEFAULT_JUL_CHANNEL_NAME,
+ LTTNG_SYMBOL_NAME_LEN - 1) != 0) {
+ ret_code = LTTNG_ERR_INVALID_CHANNEL_NAME;
goto error;
}
} else if (domain->type == LTTNG_DOMAIN_LOG4J) {
- if (strncmp(attr->name, DEFAULT_LOG4J_CHANNEL_NAME,
- LTTNG_SYMBOL_NAME_LEN)) {
- ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
+ if (strncmp(attr->name,
+ DEFAULT_LOG4J_CHANNEL_NAME,
+ LTTNG_SYMBOL_NAME_LEN - 1) != 0) {
+ ret_code = LTTNG_ERR_INVALID_CHANNEL_NAME;
goto error;
}
} else if (domain->type == LTTNG_DOMAIN_PYTHON) {
- if (strncmp(attr->name, DEFAULT_PYTHON_CHANNEL_NAME,
- LTTNG_SYMBOL_NAME_LEN)) {
- ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
+ if (strncmp(attr->name,
+ DEFAULT_PYTHON_CHANNEL_NAME,
+ LTTNG_SYMBOL_NAME_LEN - 1) != 0) {
+ ret_code = LTTNG_ERR_INVALID_CHANNEL_NAME;
goto error;
}
}
chan_ht = usess->domain_global.channels;
uchan = trace_ust_find_channel_by_name(chan_ht, attr->name);
- if (uchan == NULL) {
+ if (uchan == nullptr) {
/*
* Don't try to create a channel if the session has been started at
* some point in time before. The tracer does not allow it.
*/
if (session->has_been_started) {
- ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
+ ret_code = LTTNG_ERR_TRACE_ALREADY_STARTED;
goto error;
}
- ret = channel_ust_create(usess, attr, domain->buf_type);
+ ret_code = channel_ust_create(usess, attr, domain->buf_type);
if (attr->name[0] != '\0') {
usess->has_non_default_channel = 1;
}
} else {
- ret = channel_ust_enable(usess, uchan);
+ ret_code = channel_ust_enable(usess, uchan);
}
break;
}
default:
- ret = LTTNG_ERR_UNKNOWN_DOMAIN;
+ ret_code = LTTNG_ERR_UNKNOWN_DOMAIN;
goto error;
}
- if (ret == LTTNG_OK && attr->attr.output != LTTNG_EVENT_MMAP) {
+ if (ret_code == LTTNG_OK && attr->attr.output != LTTNG_EVENT_MMAP) {
session->has_non_mmap_channel = true;
}
error:
- rcu_read_unlock();
end:
lttng_channel_destroy(attr);
- return ret;
+ return ret_code;
}
-enum lttng_error_code cmd_process_attr_tracker_get_tracking_policy(
- struct ltt_session *session,
- enum lttng_domain_type domain,
- enum lttng_process_attr process_attr,
- enum lttng_tracking_policy *policy)
+enum lttng_error_code
+cmd_process_attr_tracker_get_tracking_policy(struct ltt_session *session,
+ enum lttng_domain_type domain,
+ enum lttng_process_attr process_attr,
+ enum lttng_tracking_policy *policy)
{
enum lttng_error_code ret_code = LTTNG_OK;
const struct process_attr_tracker *tracker;
ret_code = LTTNG_ERR_INVALID;
goto end;
}
- tracker = kernel_get_process_attr_tracker(
- session->kernel_session, process_attr);
+ tracker = kernel_get_process_attr_tracker(session->kernel_session, process_attr);
break;
case LTTNG_DOMAIN_UST:
if (!session->ust_session) {
ret_code = LTTNG_ERR_INVALID;
goto end;
}
- tracker = trace_ust_get_process_attr_tracker(
- session->ust_session, process_attr);
+ tracker = trace_ust_get_process_attr_tracker(session->ust_session, process_attr);
break;
default:
ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
return ret_code;
}
-enum lttng_error_code cmd_process_attr_tracker_set_tracking_policy(
- struct ltt_session *session,
- enum lttng_domain_type domain,
- enum lttng_process_attr process_attr,
- enum lttng_tracking_policy policy)
+enum lttng_error_code
+cmd_process_attr_tracker_set_tracking_policy(struct ltt_session *session,
+ enum lttng_domain_type domain,
+ enum lttng_process_attr process_attr,
+ enum lttng_tracking_policy policy)
{
enum lttng_error_code ret_code = LTTNG_OK;
goto end;
}
ret_code = kernel_process_attr_tracker_set_tracking_policy(
- session->kernel_session, process_attr, policy);
+ session->kernel_session, process_attr, policy);
break;
case LTTNG_DOMAIN_UST:
if (!session->ust_session) {
goto end;
}
ret_code = trace_ust_process_attr_tracker_set_tracking_policy(
- session->ust_session, process_attr, policy);
+ session->ust_session, process_attr, policy);
break;
default:
ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
return ret_code;
}
-enum lttng_error_code cmd_process_attr_tracker_inclusion_set_add_value(
- struct ltt_session *session,
- enum lttng_domain_type domain,
- enum lttng_process_attr process_attr,
- const struct process_attr_value *value)
+enum lttng_error_code
+cmd_process_attr_tracker_inclusion_set_add_value(struct ltt_session *session,
+ enum lttng_domain_type domain,
+ enum lttng_process_attr process_attr,
+ const struct process_attr_value *value)
{
enum lttng_error_code ret_code = LTTNG_OK;
goto end;
}
ret_code = kernel_process_attr_tracker_inclusion_set_add_value(
- session->kernel_session, process_attr, value);
+ session->kernel_session, process_attr, value);
break;
case LTTNG_DOMAIN_UST:
if (!session->ust_session) {
goto end;
}
ret_code = trace_ust_process_attr_tracker_inclusion_set_add_value(
- session->ust_session, process_attr, value);
+ session->ust_session, process_attr, value);
break;
default:
ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
return ret_code;
}
-enum lttng_error_code cmd_process_attr_tracker_inclusion_set_remove_value(
- struct ltt_session *session,
- enum lttng_domain_type domain,
- enum lttng_process_attr process_attr,
- const struct process_attr_value *value)
+enum lttng_error_code
+cmd_process_attr_tracker_inclusion_set_remove_value(struct ltt_session *session,
+ enum lttng_domain_type domain,
+ enum lttng_process_attr process_attr,
+ const struct process_attr_value *value)
{
enum lttng_error_code ret_code = LTTNG_OK;
goto end;
}
ret_code = kernel_process_attr_tracker_inclusion_set_remove_value(
- session->kernel_session, process_attr, value);
+ session->kernel_session, process_attr, value);
break;
case LTTNG_DOMAIN_UST:
if (!session->ust_session) {
goto end;
}
ret_code = trace_ust_process_attr_tracker_inclusion_set_remove_value(
- session->ust_session, process_attr, value);
+ session->ust_session, process_attr, value);
break;
default:
ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
return ret_code;
}
-enum lttng_error_code cmd_process_attr_tracker_get_inclusion_set(
- struct ltt_session *session,
- enum lttng_domain_type domain,
- enum lttng_process_attr process_attr,
- struct lttng_process_attr_values **values)
+enum lttng_error_code
+cmd_process_attr_tracker_get_inclusion_set(struct ltt_session *session,
+ enum lttng_domain_type domain,
+ enum lttng_process_attr process_attr,
+ struct lttng_process_attr_values **values)
{
enum lttng_error_code ret_code = LTTNG_OK;
const struct process_attr_tracker *tracker;
ret_code = LTTNG_ERR_INVALID;
goto end;
}
- tracker = kernel_get_process_attr_tracker(
- session->kernel_session, process_attr);
+ tracker = kernel_get_process_attr_tracker(session->kernel_session, process_attr);
break;
case LTTNG_DOMAIN_UST:
if (!session->ust_session) {
ret_code = LTTNG_ERR_INVALID;
goto end;
}
- tracker = trace_ust_get_process_attr_tracker(
- session->ust_session, process_attr);
+ tracker = trace_ust_get_process_attr_tracker(session->ust_session, process_attr);
break;
default:
ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
* Command LTTNG_DISABLE_EVENT processed by the client thread.
*/
int cmd_disable_event(struct command_ctx *cmd_ctx,
- struct lttng_event *event,
- char *filter_expression,
- struct lttng_bytecode *bytecode,
- struct lttng_event_exclusion *exclusion)
+ struct lttng_event *event,
+ char *filter_expression,
+ struct lttng_bytecode *bytecode,
+ struct lttng_event_exclusion *exclusion)
{
int ret;
const char *event_name;
event_name = event->name;
+ lttng::urcu::read_lock_guard read_lock;
+
/* Error out on unhandled search criteria */
- if (event->loglevel_type || event->loglevel != -1 || event->enabled
- || event->pid || event->filter || event->exclusion) {
+ if (event->loglevel_type || event->loglevel != -1 || event->enabled || event->pid ||
+ event->filter || event->exclusion) {
ret = LTTNG_ERR_UNK;
goto error;
}
- rcu_read_lock();
-
switch (domain) {
case LTTNG_DOMAIN_KERNEL:
{
}
kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
- if (kchan == NULL) {
+ if (kchan == nullptr) {
ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
goto error_unlock;
}
case LTTNG_EVENT_SYSCALL:
case LTTNG_EVENT_PROBE:
case LTTNG_EVENT_FUNCTION:
- case LTTNG_EVENT_FUNCTION_ENTRY:/* fall-through */
+ case LTTNG_EVENT_FUNCTION_ENTRY: /* fall-through */
if (event_name[0] == '\0') {
- ret = event_kernel_disable_event(kchan,
- NULL, event->type);
+ ret = event_kernel_disable_event(kchan, nullptr, event->type);
} else {
- ret = event_kernel_disable_event(kchan,
- event_name, event->type);
+ ret = event_kernel_disable_event(kchan, event_name, event->type);
}
if (ret != LTTNG_OK) {
goto error_unlock;
goto error_unlock;
}
- uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
- channel_name);
- if (uchan == NULL) {
+ uchan = trace_ust_find_channel_by_name(usess->domain_global.channels, channel_name);
+ if (uchan == nullptr) {
ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
goto error_unlock;
}
if (event->name[0] == '\0') {
ret = event_ust_disable_all_tracepoints(usess, uchan);
} else {
- ret = event_ust_disable_tracepoint(usess, uchan,
- event_name);
+ ret = event_ust_disable_tracepoint(usess, uchan, event_name);
}
if (ret != LTTNG_OK) {
goto error_unlock;
goto error_unlock;
}
- DBG3("Disable UST event %s in channel %s completed", event_name,
- channel_name);
+ DBG3("Disable UST event %s in channel %s completed", event_name, channel_name);
break;
}
case LTTNG_DOMAIN_LOG4J:
ret = LTTNG_OK;
error_unlock:
- rcu_read_unlock();
error:
free(exclusion);
free(bytecode);
* Command LTTNG_ADD_CONTEXT processed by the client thread.
*/
int cmd_add_context(struct command_ctx *cmd_ctx,
- const struct lttng_event_context *event_context, int kwpipe)
+ const struct lttng_event_context *event_context,
+ int kwpipe)
{
int ret, chan_kern_created = 0, chan_ust_created = 0;
const enum lttng_domain_type domain = cmd_ctx->lsm.domain.type;
if (session->kernel_session->channel_count == 0) {
/* Create default channel */
- ret = channel_kernel_create(session->kernel_session, NULL, kwpipe);
+ ret = channel_kernel_create(session->kernel_session, nullptr, kwpipe);
if (ret != LTTNG_OK) {
goto error;
}
chan_kern_created = 1;
}
/* Add kernel context to kernel tracer */
- ret = context_kernel_add(session->kernel_session,
- event_context, channel_name);
+ ret = context_kernel_add(session->kernel_session, event_context, channel_name);
if (ret != LTTNG_OK) {
goto error;
}
* name, return an error.
*/
if (domain == LTTNG_DOMAIN_JUL && *channel_name &&
- strcmp(channel_name,
- DEFAULT_JUL_CHANNEL_NAME)) {
+ strcmp(channel_name, DEFAULT_JUL_CHANNEL_NAME) != 0) {
ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
goto error;
} else if (domain == LTTNG_DOMAIN_LOG4J && *channel_name &&
- strcmp(channel_name,
- DEFAULT_LOG4J_CHANNEL_NAME)) {
+ strcmp(channel_name, DEFAULT_LOG4J_CHANNEL_NAME) != 0) {
ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
goto error;
}
struct lttng_channel *attr;
/* Create default channel */
attr = channel_new_default_attr(domain, usess->buffer_type);
- if (attr == NULL) {
+ if (attr == nullptr) {
ret = LTTNG_ERR_FATAL;
goto error;
}
chan_ust_created = 1;
}
- ret = context_ust_add(usess, domain, event_context,
- channel_name);
+ ret = context_ust_add(usess, domain, event_context, channel_name);
if (ret != LTTNG_OK) {
goto error;
}
error:
if (chan_kern_created) {
- struct ltt_kernel_channel *kchan =
- trace_kernel_get_channel_by_name(DEFAULT_CHANNEL_NAME,
- session->kernel_session);
+ struct ltt_kernel_channel *kchan = trace_kernel_get_channel_by_name(
+ DEFAULT_CHANNEL_NAME, session->kernel_session);
/* Created previously, this should NOT fail. */
LTTNG_ASSERT(kchan);
kernel_destroy_channel(kchan);
}
if (chan_ust_created) {
- struct ltt_ust_channel *uchan =
- trace_ust_find_channel_by_name(
- session->ust_session->domain_global.channels,
- DEFAULT_CHANNEL_NAME);
+ struct ltt_ust_channel *uchan = trace_ust_find_channel_by_name(
+ session->ust_session->domain_global.channels, DEFAULT_CHANNEL_NAME);
/* Created previously, this should NOT fail. */
LTTNG_ASSERT(uchan);
/* Remove from the channel list of the session. */
- trace_ust_delete_channel(session->ust_session->domain_global.channels,
- uchan);
+ trace_ust_delete_channel(session->ust_session->domain_global.channels, uchan);
trace_ust_destroy_channel(uchan);
}
end:
* by the agents.
*/
if (name_starts_with(name, DEFAULT_JUL_EVENT_COMPONENT) ||
- name_starts_with(name, DEFAULT_LOG4J_EVENT_COMPONENT) ||
- name_starts_with(name, DEFAULT_PYTHON_EVENT_COMPONENT)) {
+ name_starts_with(name, DEFAULT_LOG4J_EVENT_COMPONENT) ||
+ name_starts_with(name, DEFAULT_PYTHON_EVENT_COMPONENT)) {
ret = -1;
}
* enable the events through which all "agent" events are funeled.
*/
static int _cmd_enable_event(struct ltt_session *session,
- const struct lttng_domain *domain,
- char *channel_name, struct lttng_event *event,
- char *filter_expression,
- struct lttng_bytecode *filter,
- struct lttng_event_exclusion *exclusion,
- int wpipe, bool internal_event)
+ const struct lttng_domain *domain,
+ char *channel_name,
+ struct lttng_event *event,
+ char *filter_expression,
+ struct lttng_bytecode *filter,
+ struct lttng_event_exclusion *exclusion,
+ int wpipe,
+ bool internal_event)
{
int ret = 0, channel_created = 0;
- struct lttng_channel *attr = NULL;
+ struct lttng_channel *attr = nullptr;
LTTNG_ASSERT(session);
LTTNG_ASSERT(event);
DBG("Enable event command for event \'%s\'", event->name);
- rcu_read_lock();
+ lttng::urcu::read_lock_guard read_lock;
switch (domain->type) {
case LTTNG_DOMAIN_KERNEL:
* session, explicitely require that -c chan_name needs
* to be provided.
*/
- if (session->kernel_session->has_non_default_channel
- && channel_name[0] == '\0') {
+ if (session->kernel_session->has_non_default_channel && channel_name[0] == '\0') {
ret = LTTNG_ERR_NEED_CHANNEL_NAME;
goto error;
}
- kchan = trace_kernel_get_channel_by_name(channel_name,
- session->kernel_session);
- if (kchan == NULL) {
- attr = channel_new_default_attr(LTTNG_DOMAIN_KERNEL,
- LTTNG_BUFFER_GLOBAL);
- if (attr == NULL) {
+ kchan = trace_kernel_get_channel_by_name(channel_name, session->kernel_session);
+ if (kchan == nullptr) {
+ attr = channel_new_default_attr(LTTNG_DOMAIN_KERNEL, LTTNG_BUFFER_GLOBAL);
+ if (attr == nullptr) {
ret = LTTNG_ERR_FATAL;
goto error;
}
- if (lttng_strncpy(attr->name, channel_name,
- sizeof(attr->name))) {
+ if (lttng_strncpy(attr->name, channel_name, sizeof(attr->name))) {
ret = LTTNG_ERR_INVALID;
goto error;
}
- ret = cmd_enable_channel_internal(
- session, domain, attr, wpipe);
+ ret = cmd_enable_channel_internal(session, domain, attr, wpipe);
if (ret != LTTNG_OK) {
goto error;
}
}
/* Get the newly created kernel channel pointer */
- kchan = trace_kernel_get_channel_by_name(channel_name,
- session->kernel_session);
- if (kchan == NULL) {
+ kchan = trace_kernel_get_channel_by_name(channel_name, session->kernel_session);
+ if (kchan == nullptr) {
/* This sould not happen... */
ret = LTTNG_ERR_FATAL;
goto error;
switch (event->type) {
case LTTNG_EVENT_ALL:
{
- char *filter_expression_a = NULL;
- struct lttng_bytecode *filter_a = NULL;
+ char *filter_expression_a = nullptr;
+ struct lttng_bytecode *filter_a = nullptr;
/*
* We need to duplicate filter_expression and filter,
}
}
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;
}
memcpy(filter_a, filter, sizeof(*filter_a) + filter->len);
}
- event->type = LTTNG_EVENT_TRACEPOINT; /* Hack */
- ret = event_kernel_enable_event(kchan, event,
- filter_expression, filter);
+ event->type = LTTNG_EVENT_TRACEPOINT; /* Hack */
+ ret = event_kernel_enable_event(kchan, event, filter_expression, filter);
/* We have passed ownership */
- filter_expression = NULL;
- filter = NULL;
+ filter_expression = nullptr;
+ filter = nullptr;
if (ret != LTTNG_OK) {
if (channel_created) {
/* Let's not leak a useless channel. */
free(filter_a);
goto error;
}
- event->type = LTTNG_EVENT_SYSCALL; /* Hack */
- ret = event_kernel_enable_event(kchan, event,
- filter_expression_a, filter_a);
+ event->type = LTTNG_EVENT_SYSCALL; /* Hack */
+ ret = event_kernel_enable_event(
+ kchan, event, filter_expression_a, filter_a);
/* We have passed ownership */
- filter_expression_a = NULL;
- filter_a = NULL;
+ filter_expression_a = nullptr;
+ filter_a = nullptr;
if (ret != LTTNG_OK) {
goto error;
}
case LTTNG_EVENT_FUNCTION:
case LTTNG_EVENT_FUNCTION_ENTRY:
case LTTNG_EVENT_TRACEPOINT:
- ret = event_kernel_enable_event(kchan, event,
- filter_expression, filter);
+ ret = event_kernel_enable_event(kchan, event, filter_expression, filter);
/* We have passed ownership */
- filter_expression = NULL;
- filter = NULL;
+ filter_expression = nullptr;
+ filter = nullptr;
if (ret != LTTNG_OK) {
if (channel_created) {
/* Let's not leak a useless channel. */
}
break;
case LTTNG_EVENT_SYSCALL:
- ret = event_kernel_enable_event(kchan, event,
- filter_expression, filter);
+ ret = event_kernel_enable_event(kchan, event, filter_expression, filter);
/* We have passed ownership */
- filter_expression = NULL;
- filter = NULL;
+ filter_expression = nullptr;
+ filter = nullptr;
if (ret != LTTNG_OK) {
goto error;
}
}
/* Get channel from global UST domain */
- uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
- channel_name);
- if (uchan == NULL) {
+ uchan = trace_ust_find_channel_by_name(usess->domain_global.channels, channel_name);
+ if (uchan == nullptr) {
/* Create default channel */
- attr = channel_new_default_attr(LTTNG_DOMAIN_UST,
- usess->buffer_type);
- if (attr == NULL) {
+ attr = channel_new_default_attr(LTTNG_DOMAIN_UST, usess->buffer_type);
+ if (attr == nullptr) {
ret = LTTNG_ERR_FATAL;
goto error;
}
- if (lttng_strncpy(attr->name, channel_name,
- sizeof(attr->name))) {
+ if (lttng_strncpy(attr->name, channel_name, sizeof(attr->name))) {
ret = LTTNG_ERR_INVALID;
goto error;
}
- ret = cmd_enable_channel_internal(
- session, domain, attr, wpipe);
+ ret = cmd_enable_channel_internal(session, domain, attr, wpipe);
if (ret != LTTNG_OK) {
goto error;
}
/* Get the newly created channel reference back */
- uchan = trace_ust_find_channel_by_name(
- usess->domain_global.channels, channel_name);
+ uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
+ channel_name);
LTTNG_ASSERT(uchan);
}
*/
ret = validate_ust_event_name(event->name);
if (ret) {
- WARN("Userspace event name %s failed validation.",
- event->name);
+ WARN("Userspace event name %s failed validation.", event->name);
ret = LTTNG_ERR_INVALID_EVENT_NAME;
goto error;
}
}
/* At this point, the session and channel exist on the tracer */
- ret = event_ust_enable_tracepoint(usess, uchan, event,
- filter_expression, filter, exclusion,
- internal_event);
+ ret = event_ust_enable_tracepoint(
+ usess, uchan, event, filter_expression, filter, exclusion, internal_event);
/* We have passed ownership */
- filter_expression = NULL;
- filter = NULL;
- exclusion = NULL;
+ filter_expression = nullptr;
+ filter = nullptr;
+ exclusion = nullptr;
if (ret == LTTNG_ERR_UST_EVENT_ENABLED) {
goto already_enabled;
} else if (ret != LTTNG_OK) {
memset(&uevent, 0, sizeof(uevent));
uevent.type = LTTNG_EVENT_TRACEPOINT;
uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
- default_event_name = event_get_default_agent_ust_name(
- domain->type);
+ default_event_name = event_get_default_agent_ust_name(domain->type);
if (!default_event_name) {
ret = LTTNG_ERR_FATAL;
goto error;
}
{
- char *filter_expression_copy = NULL;
- struct lttng_bytecode *filter_copy = NULL;
+ char *filter_expression_copy = nullptr;
+ struct lttng_bytecode *filter_copy = nullptr;
if (filter) {
- const size_t filter_size = sizeof(
- struct lttng_bytecode)
- + filter->len;
+ const size_t filter_size =
+ sizeof(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;
}
memcpy(filter_copy, filter, filter_size);
- filter_expression_copy =
- strdup(filter_expression);
+ filter_expression_copy = strdup(filter_expression);
if (!filter_expression) {
ret = LTTNG_ERR_NOMEM;
}
}
}
- ret = cmd_enable_event_internal(session, &tmp_dom,
- (char *) default_chan_name,
- &uevent, filter_expression_copy,
- filter_copy, NULL, wpipe);
+ ret = cmd_enable_event_internal(session,
+ &tmp_dom,
+ (char *) default_chan_name,
+ &uevent,
+ filter_expression_copy,
+ filter_copy,
+ nullptr,
+ wpipe);
}
if (ret == LTTNG_ERR_UST_EVENT_ENABLED) {
/* The wild card * means that everything should be enabled. */
if (strncmp(event->name, "*", 1) == 0 && strlen(event->name) == 1) {
- ret = event_agent_enable_all(usess, agt, event, filter,
- filter_expression);
+ ret = event_agent_enable_all(usess, agt, event, filter, filter_expression);
} else {
- ret = event_agent_enable(usess, agt, event, filter,
- filter_expression);
+ ret = event_agent_enable(usess, agt, event, filter, filter_expression);
}
- filter = NULL;
- filter_expression = NULL;
+ filter = nullptr;
+ filter_expression = nullptr;
if (ret != LTTNG_OK) {
goto error;
}
free(filter);
free(exclusion);
channel_attr_destroy(attr);
- rcu_read_unlock();
return ret;
}
* We own filter, exclusion, and filter_expression.
*/
int cmd_enable_event(struct command_ctx *cmd_ctx,
- struct lttng_event *event,
- char *filter_expression,
- struct lttng_event_exclusion *exclusion,
- struct lttng_bytecode *bytecode,
- int wpipe)
+ struct lttng_event *event,
+ char *filter_expression,
+ struct lttng_event_exclusion *exclusion,
+ struct lttng_bytecode *bytecode,
+ int wpipe)
{
int ret;
/*
* - exclusion
*/
ret = _cmd_enable_event(cmd_ctx->session,
- &command_domain,
- cmd_ctx->lsm.u.enable.channel_name, event,
- filter_expression, bytecode, exclusion, wpipe, false);
- filter_expression = NULL;
- bytecode = NULL;
- exclusion = NULL;
+ &command_domain,
+ cmd_ctx->lsm.u.enable.channel_name,
+ event,
+ filter_expression,
+ bytecode,
+ exclusion,
+ wpipe,
+ false);
+ filter_expression = nullptr;
+ bytecode = nullptr;
+ exclusion = nullptr;
return ret;
}
* reserved names.
*/
static int cmd_enable_event_internal(struct ltt_session *session,
- const struct lttng_domain *domain,
- char *channel_name, struct lttng_event *event,
- char *filter_expression,
- struct lttng_bytecode *filter,
- struct lttng_event_exclusion *exclusion,
- int wpipe)
+ const struct lttng_domain *domain,
+ char *channel_name,
+ struct lttng_event *event,
+ char *filter_expression,
+ struct lttng_bytecode *filter,
+ struct lttng_event_exclusion *exclusion,
+ int wpipe)
{
- return _cmd_enable_event(session, domain, channel_name, event,
- filter_expression, filter, exclusion, wpipe, true);
+ return _cmd_enable_event(session,
+ domain,
+ channel_name,
+ event,
+ filter_expression,
+ filter,
+ exclusion,
+ wpipe,
+ true);
}
/*
* Command LTTNG_LIST_TRACEPOINTS processed by the client thread.
*/
enum lttng_error_code cmd_list_tracepoints(enum lttng_domain_type domain,
- struct lttng_payload *reply_payload)
+ struct lttng_payload *reply_payload)
{
enum lttng_error_code ret_code;
int ret;
ssize_t i, nb_events = 0;
- struct lttng_event *events = NULL;
+ struct lttng_event *events = nullptr;
struct lttcomm_list_command_header reply_command_header = {};
size_t reply_command_header_offset;
/* Reserve space for command reply header. */
reply_command_header_offset = reply_payload->buffer.size;
ret = lttng_dynamic_buffer_set_size(&reply_payload->buffer,
- reply_command_header_offset +
- sizeof(struct lttcomm_list_command_header));
+ reply_command_header_offset +
+ sizeof(struct lttcomm_list_command_header));
if (ret) {
ret_code = LTTNG_ERR_NOMEM;
goto error;
}
for (i = 0; i < nb_events; i++) {
- ret = lttng_event_serialize(&events[i], 0, NULL, NULL, 0, NULL,
- reply_payload);
+ ret = lttng_event_serialize(
+ &events[i], 0, nullptr, nullptr, 0, nullptr, reply_payload);
if (ret) {
ret_code = LTTNG_ERR_NOMEM;
goto error;
/* Update command reply header. */
reply_command_header.count = (uint32_t) nb_events;
- memcpy(reply_payload->buffer.data + reply_command_header_offset, &reply_command_header,
- sizeof(reply_command_header));
+ memcpy(reply_payload->buffer.data + reply_command_header_offset,
+ &reply_command_header,
+ sizeof(reply_command_header));
ret_code = LTTNG_OK;
error:
* Command LTTNG_LIST_TRACEPOINT_FIELDS processed by the client thread.
*/
enum lttng_error_code cmd_list_tracepoint_fields(enum lttng_domain_type domain,
- struct lttng_payload *reply)
+ struct lttng_payload *reply)
{
enum lttng_error_code ret_code;
int ret;
unsigned int i, nb_fields;
- struct lttng_event_field *fields = NULL;
+ struct lttng_event_field *fields = nullptr;
struct lttcomm_list_command_header reply_command_header = {};
size_t reply_command_header_offset;
/* Reserve space for command reply header. */
reply_command_header_offset = reply->buffer.size;
ret = lttng_dynamic_buffer_set_size(&reply->buffer,
- reply_command_header_offset +
- sizeof(struct lttcomm_list_command_header));
+ reply_command_header_offset +
+ sizeof(struct lttcomm_list_command_header));
if (ret) {
ret_code = LTTNG_ERR_NOMEM;
goto error;
break;
case LTTNG_DOMAIN_KERNEL:
- default: /* fall-through */
+ default: /* fall-through */
ret_code = LTTNG_ERR_UND;
goto error;
}
/* Update command reply header. */
reply_command_header.count = (uint32_t) nb_fields;
- memcpy(reply->buffer.data + reply_command_header_offset, &reply_command_header,
- sizeof(reply_command_header));
+ memcpy(reply->buffer.data + reply_command_header_offset,
+ &reply_command_header,
+ sizeof(reply_command_header));
ret_code = LTTNG_OK;
return ret_code;
}
-enum lttng_error_code cmd_list_syscalls(
- struct lttng_payload *reply_payload)
+enum lttng_error_code cmd_list_syscalls(struct lttng_payload *reply_payload)
{
enum lttng_error_code ret_code;
ssize_t nb_events, i;
int ret;
- struct lttng_event *events = NULL;
+ struct lttng_event *events = nullptr;
struct lttcomm_list_command_header reply_command_header = {};
size_t reply_command_header_offset;
/* Reserve space for command reply header. */
reply_command_header_offset = reply_payload->buffer.size;
ret = lttng_dynamic_buffer_set_size(&reply_payload->buffer,
- reply_command_header_offset +
- sizeof(struct lttcomm_list_command_header));
+ reply_command_header_offset +
+ sizeof(struct lttcomm_list_command_header));
if (ret) {
ret_code = LTTNG_ERR_NOMEM;
goto end;
nb_events = syscall_table_list(&events);
if (nb_events < 0) {
- ret_code = (enum lttng_error_code) -nb_events;
+ ret_code = (enum lttng_error_code) - nb_events;
goto end;
}
for (i = 0; i < nb_events; i++) {
- ret = lttng_event_serialize(&events[i], 0, NULL, NULL, 0, NULL,
- reply_payload);
+ ret = lttng_event_serialize(
+ &events[i], 0, nullptr, nullptr, 0, nullptr, reply_payload);
if (ret) {
ret_code = LTTNG_ERR_NOMEM;
goto end;
/* Update command reply header. */
reply_command_header.count = (uint32_t) nb_events;
- memcpy(reply_payload->buffer.data + reply_command_header_offset, &reply_command_header,
- sizeof(reply_command_header));
+ memcpy(reply_payload->buffer.data + reply_command_header_offset,
+ &reply_command_header,
+ sizeof(reply_command_header));
ret_code = LTTNG_OK;
end:
unsigned long nb_chan = 0;
struct ltt_kernel_session *ksession;
struct ltt_ust_session *usess;
- const bool session_rotated_after_last_stop =
- session->rotated_after_last_stop;
- const bool session_cleared_after_last_stop =
- session->cleared_after_last_stop;
+ const bool session_rotated_after_last_stop = session->rotated_after_last_stop;
+ const bool session_cleared_after_last_stop = session->cleared_after_last_stop;
LTTNG_ASSERT(session);
}
if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING &&
- !session->current_trace_chunk) {
+ !session->current_trace_chunk) {
/*
* A rotation was launched while the session was stopped and
* it has not been completed yet. It is not possible to start
* supported.
*/
WARN("Refusing to start session \"%s\" as a rotation launched after the last \"stop\" is still ongoing",
- session->name);
+ session->name);
ret = LTTNG_ERR_ROTATION_PENDING;
goto error;
}
goto error;
}
- session->active = 1;
+ session->active = true;
session->rotated_after_last_stop = false;
session->cleared_after_last_stop = false;
if (session->output_traces && !session->current_trace_chunk) {
if (!session->has_been_started) {
struct lttng_trace_chunk *trace_chunk;
- DBG("Creating initial trace chunk of session \"%s\"",
- session->name);
- trace_chunk = session_create_new_trace_chunk(
- session, NULL, NULL, NULL);
+ DBG("Creating initial trace chunk of session \"%s\"", session->name);
+ trace_chunk =
+ session_create_new_trace_chunk(session, nullptr, nullptr, nullptr);
if (!trace_chunk) {
ret = LTTNG_ERR_CREATE_DIR_FAIL;
goto error;
}
LTTNG_ASSERT(!session->current_trace_chunk);
- ret = (lttng_error_code) session_set_trace_chunk(session, trace_chunk,
- NULL);
+ ret = (lttng_error_code) session_set_trace_chunk(
+ session, trace_chunk, nullptr);
lttng_trace_chunk_put(trace_chunk);
if (ret) {
ret = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER;
}
} else {
DBG("Rotating session \"%s\" from its current \"NULL\" trace chunk to a new chunk",
- session->name);
+ session->name);
/*
* Rotate existing streams into the new chunk.
* This is a "quiet" rotation has no client has
* was produced as the session was stopped, so the
* rotation should happen on reception of the command.
*/
- ret = (lttng_error_code) cmd_rotate_session(session, NULL, true,
- LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION);
+ ret = (lttng_error_code) cmd_rotate_session(
+ session, nullptr, true, LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION);
if (ret != LTTNG_OK) {
goto error;
}
}
/* Kernel tracing */
- if (ksession != NULL) {
+ if (ksession != nullptr) {
DBG("Start kernel tracing session %s", session->name);
ret = (lttng_error_code) start_kernel_session(ksession);
if (ret != LTTNG_OK) {
if (session->rotate_timer_period && !session->rotation_schedule_timer_enabled) {
int int_ret = timer_session_rotation_schedule_timer_start(
- session, session->rotate_timer_period);
+ session, session->rotate_timer_period);
if (int_ret < 0) {
ERR("Failed to enable rotate timer");
error:
if (ret == LTTNG_OK) {
/* Flag this after a successful start. */
- session->has_been_started |= 1;
+ session->has_been_started = true;
} else {
- session->active = 0;
+ session->active = false;
/* Restore initial state on error. */
- session->rotated_after_last_stop =
- session_rotated_after_last_stop;
- session->cleared_after_last_stop =
- session_cleared_after_last_stop;
+ session->rotated_after_last_stop = session_rotated_after_last_stop;
+ session->cleared_after_last_stop = session_cleared_after_last_stop;
}
end:
return ret;
}
}
- DBG("Completed stop session \"%s\" (id %" PRIu64 ")", session->name,
- session->id);
+ DBG("Completed stop session \"%s\" (id %" PRIu64 ")", session->name, session->id);
/* Flag inactive after a successful stop. */
- session->active = 0;
+ session->active = false;
ret = LTTNG_OK;
error:
* Set the base_path of the session only if subdir of a control uris is set.
* Return LTTNG_OK on success, otherwise LTTNG_ERR_*.
*/
-static int set_session_base_path_from_uris(struct ltt_session *session,
- size_t nb_uri,
- struct lttng_uri *uris)
+static int
+set_session_base_path_from_uris(struct ltt_session *session, size_t nb_uri, struct lttng_uri *uris)
{
int ret;
size_t i;
for (i = 0; i < nb_uri; i++) {
- if (uris[i].stype != LTTNG_STREAM_CONTROL ||
- uris[i].subdir[0] == '\0') {
+ if (uris[i].stype != LTTNG_STREAM_CONTROL || uris[i].subdir[0] == '\0') {
/* Not interested in these URIs */
continue;
}
- if (session->base_path != NULL) {
+ if (session->base_path != nullptr) {
free(session->base_path);
- session->base_path = NULL;
+ session->base_path = nullptr;
}
/* Set session base_path */
session->base_path = strdup(uris[i].subdir);
if (!session->base_path) {
PERROR("Failed to copy base path \"%s\" to session \"%s\"",
- uris[i].subdir, session->name);
+ uris[i].subdir,
+ session->name);
ret = LTTNG_ERR_NOMEM;
goto error;
}
DBG2("Setting base path \"%s\" for session \"%s\"",
- session->base_path, session->name);
+ session->base_path,
+ session->name);
}
ret = LTTNG_OK;
error:
/*
* Command LTTNG_SET_CONSUMER_URI processed by the client thread.
*/
-int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri,
- struct lttng_uri *uris)
+int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri, struct lttng_uri *uris)
{
int ret, i;
struct ltt_kernel_session *ksess = session->kernel_session;
/* Set the "global" consumer URIs */
for (i = 0; i < nb_uri; i++) {
- ret = add_uri_to_consumer(session, session->consumer, &uris[i],
- LTTNG_DOMAIN_NONE);
+ ret = add_uri_to_consumer(session, session->consumer, &uris[i], LTTNG_DOMAIN_NONE);
if (ret != LTTNG_OK) {
goto error;
}
if (session->ust_session) {
for (i = 0; i < nb_uri; i++) {
ret = add_uri_to_consumer(session,
- session->ust_session->consumer,
- &uris[i], LTTNG_DOMAIN_UST);
+ session->ust_session->consumer,
+ &uris[i],
+ LTTNG_DOMAIN_UST);
if (ret != LTTNG_OK) {
goto error;
}
if (session->kernel_session) {
for (i = 0; i < nb_uri; i++) {
ret = add_uri_to_consumer(session,
- session->kernel_session->consumer,
- &uris[i], LTTNG_DOMAIN_KERNEL);
+ session->kernel_session->consumer,
+ &uris[i],
+ LTTNG_DOMAIN_KERNEL);
if (ret != LTTNG_OK) {
goto error;
}
return ret;
}
-static
-enum lttng_error_code set_session_output_from_descriptor(
- struct ltt_session *session,
- const struct lttng_session_descriptor *descriptor)
+static enum lttng_error_code
+set_session_output_from_descriptor(struct ltt_session *session,
+ const struct lttng_session_descriptor *descriptor)
{
int ret;
enum lttng_error_code ret_code = LTTNG_OK;
enum lttng_session_descriptor_type session_type =
- lttng_session_descriptor_get_type(descriptor);
+ lttng_session_descriptor_get_type(descriptor);
enum lttng_session_descriptor_output_type output_type =
- lttng_session_descriptor_get_output_type(descriptor);
+ lttng_session_descriptor_get_output_type(descriptor);
struct lttng_uri uris[2] = {};
size_t uri_count = 0;
case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE:
goto end;
case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL:
- lttng_session_descriptor_get_local_output_uri(descriptor,
- &uris[0]);
+ lttng_session_descriptor_get_local_output_uri(descriptor, &uris[0]);
uri_count = 1;
break;
case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK:
- lttng_session_descriptor_get_network_output_uris(descriptor,
- &uris[0], &uris[1]);
+ lttng_session_descriptor_get_network_output_uris(descriptor, &uris[0], &uris[1]);
uri_count = 2;
break;
default:
switch (session_type) {
case LTTNG_SESSION_DESCRIPTOR_TYPE_SNAPSHOT:
{
- struct snapshot_output *new_output = NULL;
+ struct snapshot_output *new_output = nullptr;
new_output = snapshot_output_alloc();
if (!new_output) {
}
ret = snapshot_output_init_with_uri(session,
- DEFAULT_SNAPSHOT_MAX_SIZE,
- NULL, uris, uri_count, session->consumer,
- new_output, &session->snapshot);
+ DEFAULT_SNAPSHOT_MAX_SIZE,
+ nullptr,
+ uris,
+ uri_count,
+ session->consumer,
+ new_output,
+ &session->snapshot);
if (ret < 0) {
- ret_code = (ret == -ENOMEM) ?
- LTTNG_ERR_NOMEM : LTTNG_ERR_INVALID;
+ ret_code = (ret == -ENOMEM) ? LTTNG_ERR_NOMEM : LTTNG_ERR_INVALID;
snapshot_output_destroy(new_output);
goto end;
}
return ret_code;
}
-static
-enum lttng_error_code cmd_create_session_from_descriptor(
- struct lttng_session_descriptor *descriptor,
- const lttng_sock_cred *creds,
- const char *home_path)
+static enum lttng_error_code
+cmd_create_session_from_descriptor(struct lttng_session_descriptor *descriptor,
+ const lttng_sock_cred *creds,
+ const char *home_path)
{
int ret;
enum lttng_error_code ret_code;
const char *session_name;
- struct ltt_session *new_session = NULL;
+ struct ltt_session *new_session = nullptr;
enum lttng_session_descriptor_status descriptor_status;
session_lock_list();
}
}
- descriptor_status = lttng_session_descriptor_get_session_name(
- descriptor, &session_name);
+ descriptor_status = lttng_session_descriptor_get_session_name(descriptor, &session_name);
switch (descriptor_status) {
case LTTNG_SESSION_DESCRIPTOR_STATUS_OK:
break;
case LTTNG_SESSION_DESCRIPTOR_STATUS_UNSET:
- session_name = NULL;
+ session_name = nullptr;
break;
default:
ret_code = LTTNG_ERR_INVALID;
goto end;
}
- ret_code = session_create(session_name, creds->uid, creds->gid,
- &new_session);
+ ret_code = session_create(session_name, creds->uid, creds->gid, &new_session);
+ if (ret_code != LTTNG_OK) {
+ 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);
+ },
+ nullptr);
+ 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);
+ ret = lttng_session_descriptor_set_session_name(descriptor, new_session->name);
if (ret) {
ret_code = LTTNG_ERR_SESSION_FAIL;
goto end;
}
}
- if (!lttng_session_descriptor_is_output_destination_initialized(
- descriptor)) {
+ if (!lttng_session_descriptor_is_output_destination_initialized(descriptor)) {
/*
* Only include the session's creation time in the output
* destination if the name of the session itself was
* not auto-generated.
*/
ret_code = lttng_session_descriptor_set_default_output(
- descriptor,
- session_name ? &new_session->creation_time : NULL,
- home_path);
+ descriptor,
+ session_name ? &new_session->creation_time : nullptr,
+ home_path);
if (ret_code != LTTNG_OK) {
goto end;
}
} else {
new_session->has_user_specified_directory =
- lttng_session_descriptor_has_output_directory(
- descriptor);
+ lttng_session_descriptor_has_output_directory(descriptor);
}
switch (lttng_session_descriptor_get_type(descriptor)) {
break;
case LTTNG_SESSION_DESCRIPTOR_TYPE_LIVE:
new_session->live_timer =
- lttng_session_descriptor_live_get_timer_interval(
- descriptor);
+ lttng_session_descriptor_live_get_timer_interval(descriptor);
break;
default:
break;
if (ret_code != LTTNG_OK) {
goto end;
}
- new_session->consumer->enabled = 1;
+ new_session->consumer->enabled = true;
ret_code = LTTNG_OK;
end:
/* Release reference provided by the session_create function. */
return ret_code;
}
-enum lttng_error_code cmd_create_session(struct command_ctx *cmd_ctx, int sock,
- struct lttng_session_descriptor **return_descriptor)
+enum lttng_error_code cmd_create_session(struct command_ctx *cmd_ctx,
+ int sock,
+ struct lttng_session_descriptor **return_descriptor)
{
int ret;
size_t payload_size;
struct lttng_dynamic_buffer payload;
struct lttng_buffer_view home_dir_view;
struct lttng_buffer_view session_descriptor_view;
- struct lttng_session_descriptor *session_descriptor = NULL;
+ struct lttng_session_descriptor *session_descriptor = nullptr;
enum lttng_error_code ret_code;
lttng_dynamic_buffer_init(&payload);
- if (cmd_ctx->lsm.u.create_session.home_dir_size >=
- LTTNG_PATH_MAX) {
+ if (cmd_ctx->lsm.u.create_session.home_dir_size >= LTTNG_PATH_MAX) {
ret_code = LTTNG_ERR_INVALID;
goto error;
}
if (cmd_ctx->lsm.u.create_session.session_descriptor_size >
- LTTNG_SESSION_DESCRIPTOR_MAX_LEN) {
+ LTTNG_SESSION_DESCRIPTOR_MAX_LEN) {
ret_code = LTTNG_ERR_INVALID;
goto error;
}
payload_size = cmd_ctx->lsm.u.create_session.home_dir_size +
- cmd_ctx->lsm.u.create_session.session_descriptor_size;
+ cmd_ctx->lsm.u.create_session.session_descriptor_size;
ret = lttng_dynamic_buffer_set_size(&payload, payload_size);
if (ret) {
ret_code = LTTNG_ERR_NOMEM;
}
home_dir_view = lttng_buffer_view_from_dynamic_buffer(
- &payload,
- 0,
- cmd_ctx->lsm.u.create_session.home_dir_size);
+ &payload, 0, cmd_ctx->lsm.u.create_session.home_dir_size);
if (cmd_ctx->lsm.u.create_session.home_dir_size > 0 &&
- !lttng_buffer_view_is_valid(&home_dir_view)) {
+ !lttng_buffer_view_is_valid(&home_dir_view)) {
ERR("Invalid payload in \"create session\" command: buffer too short to contain home directory");
ret_code = LTTNG_ERR_INVALID_PROTOCOL;
goto error;
}
session_descriptor_view = lttng_buffer_view_from_dynamic_buffer(
- &payload,
- cmd_ctx->lsm.u.create_session.home_dir_size,
- cmd_ctx->lsm.u.create_session.session_descriptor_size);
+ &payload,
+ cmd_ctx->lsm.u.create_session.home_dir_size,
+ cmd_ctx->lsm.u.create_session.session_descriptor_size);
if (!lttng_buffer_view_is_valid(&session_descriptor_view)) {
ERR("Invalid payload in \"create session\" command: buffer too short to contain session descriptor");
ret_code = LTTNG_ERR_INVALID_PROTOCOL;
goto error;
}
- ret = lttng_session_descriptor_create_from_buffer(
- &session_descriptor_view, &session_descriptor);
+ ret = lttng_session_descriptor_create_from_buffer(&session_descriptor_view,
+ &session_descriptor);
if (ret < 0) {
ERR("Failed to create session descriptor from payload of \"create session\" command");
ret_code = LTTNG_ERR_INVALID;
* needed.
*/
ret_code = cmd_create_session_from_descriptor(session_descriptor,
- &cmd_ctx->creds,
- home_dir_view.size ? home_dir_view.data : NULL);
+ &cmd_ctx->creds,
+ home_dir_view.size ? home_dir_view.data :
+ nullptr);
if (ret_code != LTTNG_OK) {
goto error;
}
ret_code = LTTNG_OK;
*return_descriptor = session_descriptor;
- session_descriptor = NULL;
+ session_descriptor = nullptr;
error:
lttng_dynamic_buffer_reset(&payload);
lttng_session_descriptor_destroy(session_descriptor);
return ret_code;
}
-static
-void cmd_destroy_session_reply(const struct ltt_session *session,
- void *_reply_context)
+static void cmd_destroy_session_reply(const struct ltt_session *session, void *_reply_context)
{
int ret;
ssize_t comm_ret;
const struct cmd_destroy_session_reply_context *reply_context =
- (cmd_destroy_session_reply_context *) _reply_context;
+ (cmd_destroy_session_reply_context *) _reply_context;
struct lttng_dynamic_buffer payload;
struct lttcomm_session_destroy_command_header cmd_header;
- struct lttng_trace_archive_location *location = NULL;
+ struct lttng_trace_archive_location *location = nullptr;
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 =
- sizeof(struct lttcomm_session_destroy_command_header),
+ .cmd_header_size = sizeof(struct lttcomm_session_destroy_command_header),
.data_size = 0,
.fd_count = 0,
};
goto error;
}
- cmd_header.rotation_state =
- (int32_t) (reply_context->implicit_rotation_on_destroy ?
- session->rotation_state :
- LTTNG_ROTATION_STATE_NO_ROTATION);
- ret = lttng_dynamic_buffer_append(&payload, &cmd_header,
- sizeof(cmd_header));
+ cmd_header.rotation_state = (int32_t) (reply_context->implicit_rotation_on_destroy ?
+ session->rotation_state :
+ LTTNG_ROTATION_STATE_NO_ROTATION);
+ ret = lttng_dynamic_buffer_append(&payload, &cmd_header, sizeof(cmd_header));
if (ret) {
ERR("Failed to append session destruction command header");
goto error;
if (!reply_context->implicit_rotation_on_destroy) {
DBG("No implicit rotation performed during the destruction of session \"%s\", sending reply",
- session->name);
+ session->name);
goto send_reply;
}
if (session->rotation_state != LTTNG_ROTATION_STATE_COMPLETED) {
DBG("Rotation state of session \"%s\" is not \"completed\", sending session destruction reply",
- session->name);
+ session->name);
goto send_reply;
}
location = session_get_trace_archive_location(session);
if (!location) {
ERR("Failed to get the location of the trace archive produced during the destruction of session \"%s\"",
- session->name);
+ session->name);
goto error;
}
payload_size_before_location = payload.size;
- comm_ret = lttng_trace_archive_location_serialize(location,
- &payload);
+ comm_ret = lttng_trace_archive_location_serialize(location, &payload);
lttng_trace_archive_location_put(location);
if (comm_ret < 0) {
ERR("Failed to serialize the location of the trace archive produced during the destruction of session \"%s\"",
- session->name);
+ session->name);
goto error;
}
/* Update the message to indicate the location's length. */
((struct lttcomm_lttng_msg *) payload.data)->data_size =
- payload.size - payload_size_before_location;
+ payload.size - payload_size_before_location;
send_reply:
- comm_ret = lttcomm_send_unix_sock(reply_context->reply_sock_fd,
- payload.data, payload.size);
+ comm_ret = lttcomm_send_unix_sock(reply_context->reply_sock_fd, payload.data, payload.size);
if (comm_ret != (ssize_t) payload.size) {
ERR("Failed to send result of the destruction of session \"%s\" to client",
- session->name);
+ session->name);
}
error:
ret = close(reply_context->reply_sock_fd);
* Called with session lock held.
*/
int cmd_destroy_session(struct ltt_session *session,
- struct notification_thread_handle *notification_thread_handle,
- int *sock_fd)
+ struct notification_thread_handle *notification_thread_handle,
+ int *sock_fd)
{
int ret;
enum lttng_error_code destruction_last_error = LTTNG_OK;
- struct cmd_destroy_session_reply_context *reply_context = NULL;
+ struct cmd_destroy_session_reply_context *reply_context = nullptr;
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;
}
/* Safety net */
LTTNG_ASSERT(session);
- DBG("Begin destroy session %s (id %" PRIu64 ")", session->name,
- session->id);
+ DBG("Begin destroy session %s (id %" PRIu64 ")", session->name, session->id);
if (session->active) {
DBG("Session \"%s\" is active, attempting to stop it before destroying it",
- session->name);
+ session->name);
ret = cmd_stop_trace(session);
if (ret != LTTNG_OK && ret != LTTNG_ERR_TRACE_ALREADY_STOPPED) {
/* Carry on with the destruction of the session. */
ERR("Failed to stop session \"%s\" as part of its destruction: %s",
- session->name, lttng_strerror(-ret));
+ session->name,
+ lttng_strerror(-ret));
destruction_last_error = (lttng_error_code) ret;
}
}
if (session->rotation_schedule_timer_enabled) {
- if (timer_session_rotation_schedule_timer_stop(
- session)) {
+ if (timer_session_rotation_schedule_timer_stop(session)) {
ERR("Failed to stop the \"rotation schedule\" timer of session %s",
- session->name);
+ session->name);
destruction_last_error = LTTNG_ERR_TIMER_STOP_ERROR;
}
}
* Perform a last rotation on destruction if rotations have
* occurred during the session's lifetime.
*/
- ret = cmd_rotate_session(session, NULL, false,
- LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED);
+ ret = cmd_rotate_session(
+ session, nullptr, false, LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED);
if (ret != LTTNG_OK) {
ERR("Failed to perform an implicit rotation as part of the destruction of session \"%s\": %s",
- session->name, lttng_strerror(-ret));
+ session->name,
+ lttng_strerror(-ret));
destruction_last_error = (lttng_error_code) -ret;
}
if (reply_context) {
* emitted and no renaming of the current trace chunk takes
* place.
*/
- ret = cmd_rotate_session(session, NULL, true,
- LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION);
+ ret = cmd_rotate_session(
+ session, nullptr, true, LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION);
/*
* Rotation operations may not be supported by the kernel
* tracer. Hence, do not consider this implicit rotation as
* the session and waited for pending data; there is nothing
* left to do but complete the destruction of the session.
*/
- if (ret != LTTNG_OK &&
- ret != -LTTNG_ERR_ROTATION_NOT_AVAILABLE_KERNEL) {
+ if (ret != LTTNG_OK && ret != -LTTNG_ERR_ROTATION_NOT_AVAILABLE_KERNEL) {
ERR("Failed to perform a quiet rotation as part of the destruction of session \"%s\": %s",
- session->name, lttng_strerror(ret));
+ session->name,
+ lttng_strerror(ret));
destruction_last_error = (lttng_error_code) -ret;
}
}
*/
current_completion_handler = &destroy_completion_handler.handler;
ret = lttng_strncpy(destroy_completion_handler.shm_path,
- session->shm_path,
- sizeof(destroy_completion_handler.shm_path));
+ session->shm_path,
+ sizeof(destroy_completion_handler.shm_path));
LTTNG_ASSERT(!ret);
}
session_destroy(session);
if (reply_context) {
reply_context->destruction_status = destruction_last_error;
- ret = session_add_destroy_notifier(session,
- cmd_destroy_session_reply,
- (void *) reply_context);
+ ret = session_add_destroy_notifier(
+ session, cmd_destroy_session_reply, (void *) reply_context);
if (ret) {
ret = LTTNG_ERR_FATAL;
goto end;
* Command LTTNG_REGISTER_CONSUMER processed by the client thread.
*/
int cmd_register_consumer(struct ltt_session *session,
- enum lttng_domain_type domain, const char *sock_path,
- struct consumer_data *cdata)
+ enum lttng_domain_type domain,
+ const char *sock_path,
+ struct consumer_data *cdata)
{
int ret, sock;
- struct consumer_socket *socket = NULL;
+ struct consumer_socket *socket = nullptr;
LTTNG_ASSERT(session);
LTTNG_ASSERT(cdata);
cdata->cmd_sock = sock;
socket = consumer_allocate_socket(&cdata->cmd_sock);
- if (socket == NULL) {
+ if (socket == nullptr) {
ret = close(sock);
if (ret < 0) {
PERROR("close register consumer");
goto error;
}
- socket->lock = (pthread_mutex_t *) zmalloc(sizeof(pthread_mutex_t));
- if (socket->lock == NULL) {
+ socket->lock = zmalloc<pthread_mutex_t>();
+ if (socket->lock == nullptr) {
PERROR("zmalloc pthread mutex");
ret = LTTNG_ERR_FATAL;
goto error;
}
- pthread_mutex_init(socket->lock, NULL);
+
+ pthread_mutex_init(socket->lock, nullptr);
socket->registered = 1;
- rcu_read_lock();
+ lttng::urcu::read_lock_guard read_lock;
consumer_add_socket(socket, ksess->consumer);
- rcu_read_unlock();
pthread_mutex_lock(&cdata->pid_mutex);
cdata->pid = -1;
/*
* Command LTTNG_LIST_DOMAINS processed by the client thread.
*/
-ssize_t cmd_list_domains(struct ltt_session *session,
- struct lttng_domain **domains)
+ssize_t cmd_list_domains(struct ltt_session *session, struct lttng_domain **domains)
{
int ret, index = 0;
ssize_t nb_dom = 0;
struct agent *agt;
struct lttng_ht_iter iter;
- if (session->kernel_session != NULL) {
+ if (session->kernel_session != nullptr) {
DBG3("Listing domains found kernel domain");
nb_dom++;
}
- if (session->ust_session != NULL) {
+ if (session->ust_session != nullptr) {
DBG3("Listing domains found UST global domain");
nb_dom++;
- rcu_read_lock();
- cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter,
- agt, node.node) {
+ lttng::urcu::read_lock_guard read_lock;
+
+ cds_lfht_for_each_entry (
+ session->ust_session->agents->ht, &iter.iter, agt, node.node) {
if (agt->being_used) {
nb_dom++;
}
}
- rcu_read_unlock();
}
if (!nb_dom) {
goto end;
}
- *domains = (lttng_domain *) zmalloc(nb_dom * sizeof(struct lttng_domain));
- if (*domains == NULL) {
+ *domains = calloc<lttng_domain>(nb_dom);
+ if (*domains == nullptr) {
ret = LTTNG_ERR_FATAL;
goto error;
}
- if (session->kernel_session != NULL) {
+ if (session->kernel_session != nullptr) {
(*domains)[index].type = LTTNG_DOMAIN_KERNEL;
/* Kernel session buffer type is always GLOBAL */
index++;
}
- if (session->ust_session != NULL) {
+ if (session->ust_session != nullptr) {
(*domains)[index].type = LTTNG_DOMAIN_UST;
(*domains)[index].buf_type = session->ust_session->buffer_type;
index++;
- rcu_read_lock();
- cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter,
- agt, node.node) {
- if (agt->being_used) {
- (*domains)[index].type = agt->domain;
- (*domains)[index].buf_type = session->ust_session->buffer_type;
- index++;
+ {
+ lttng::urcu::read_lock_guard read_lock;
+
+ cds_lfht_for_each_entry (
+ session->ust_session->agents->ht, &iter.iter, agt, node.node) {
+ if (agt->being_used) {
+ (*domains)[index].type = agt->domain;
+ (*domains)[index].buf_type =
+ session->ust_session->buffer_type;
+ index++;
+ }
}
}
- rcu_read_unlock();
}
end:
return nb_dom;
return -ret;
}
-
/*
* Command LTTNG_LIST_CHANNELS processed by the client thread.
*/
enum lttng_error_code cmd_list_channels(enum lttng_domain_type domain,
- struct ltt_session *session,
- struct lttng_payload *payload)
+ struct ltt_session *session,
+ struct lttng_payload *payload)
{
int ret = 0;
unsigned int i = 0;
/* Reserve space for command reply header. */
ret = lttng_dynamic_buffer_set_size(&payload->buffer,
- cmd_header_offset + sizeof(cmd_header));
+ cmd_header_offset + sizeof(cmd_header));
if (ret) {
ret_code = LTTNG_ERR_NOMEM;
goto end;
{
/* Kernel channels */
struct ltt_kernel_channel *kchan;
- if (session->kernel_session != NULL) {
- cds_list_for_each_entry(kchan,
- &session->kernel_session->channel_list.head, list) {
+ if (session->kernel_session != nullptr) {
+ cds_list_for_each_entry (
+ kchan, &session->kernel_session->channel_list.head, list) {
uint64_t discarded_events, lost_packets;
struct lttng_channel_extended *extended;
extended = (struct lttng_channel_extended *)
- kchan->channel->attr.extended.ptr;
+ kchan->channel->attr.extended.ptr;
- ret = get_kernel_runtime_stats(session, kchan,
- &discarded_events, &lost_packets);
+ ret = get_kernel_runtime_stats(
+ session, kchan, &discarded_events, &lost_packets);
if (ret < 0) {
ret_code = LTTNG_ERR_UNK;
goto end;
extended->discarded_events = discarded_events;
extended->lost_packets = lost_packets;
- ret = lttng_channel_serialize(
- kchan->channel, &payload->buffer);
+ ret = lttng_channel_serialize(kchan->channel, &payload->buffer);
if (ret) {
ERR("Failed to serialize lttng_channel: channel name = '%s'",
- kchan->channel->name);
+ kchan->channel->name);
ret_code = LTTNG_ERR_UNK;
goto end;
}
struct lttng_ht_iter iter;
struct ltt_ust_channel *uchan;
- rcu_read_lock();
- cds_lfht_for_each_entry(session->ust_session->domain_global.channels->ht,
- &iter.iter, uchan, node.node) {
- uint64_t discarded_events = 0, lost_packets = 0;
- struct lttng_channel *channel = NULL;
- struct lttng_channel_extended *extended;
+ {
+ lttng::urcu::read_lock_guard read_lock;
+
+ cds_lfht_for_each_entry (session->ust_session->domain_global.channels->ht,
+ &iter.iter,
+ uchan,
+ node.node) {
+ uint64_t discarded_events = 0, lost_packets = 0;
+ struct lttng_channel *channel = nullptr;
+ struct lttng_channel_extended *extended;
- channel = trace_ust_channel_to_lttng_channel(uchan);
- if (!channel) {
- ret_code = LTTNG_ERR_NOMEM;
- goto end;
- }
+ channel = trace_ust_channel_to_lttng_channel(uchan);
+ if (!channel) {
+ ret_code = LTTNG_ERR_NOMEM;
+ goto end;
+ }
- extended = (struct lttng_channel_extended *)
+ extended = (struct lttng_channel_extended *)
channel->attr.extended.ptr;
- ret = get_ust_runtime_stats(session, uchan,
- &discarded_events, &lost_packets);
- if (ret < 0) {
- lttng_channel_destroy(channel);
- ret_code = LTTNG_ERR_UNK;
- goto end;
- }
+ ret = get_ust_runtime_stats(
+ session, uchan, &discarded_events, &lost_packets);
+ if (ret < 0) {
+ lttng_channel_destroy(channel);
+ ret_code = LTTNG_ERR_UNK;
+ goto end;
+ }
- extended->discarded_events = discarded_events;
- extended->lost_packets = lost_packets;
+ extended->discarded_events = discarded_events;
+ extended->lost_packets = lost_packets;
+
+ ret = lttng_channel_serialize(channel, &payload->buffer);
+ if (ret) {
+ ERR("Failed to serialize lttng_channel: channel name = '%s'",
+ channel->name);
+ lttng_channel_destroy(channel);
+ ret_code = LTTNG_ERR_UNK;
+ goto end;
+ }
- ret = lttng_channel_serialize(
- channel, &payload->buffer);
- if (ret) {
- ERR("Failed to serialize lttng_channel: channel name = '%s'",
- channel->name);
lttng_channel_destroy(channel);
- ret_code = LTTNG_ERR_UNK;
- goto end;
+ i++;
}
-
- lttng_channel_destroy(channel);
- i++;
}
- rcu_read_unlock();
+
break;
}
default:
/* Update command reply header. */
cmd_header.count = (uint32_t) i;
- memcpy(payload->buffer.data + cmd_header_offset, &cmd_header,
- sizeof(cmd_header));
+ memcpy(payload->buffer.data + cmd_header_offset, &cmd_header, sizeof(cmd_header));
ret_code = LTTNG_OK;
end:
* Command LTTNG_LIST_EVENTS processed by the client thread.
*/
enum lttng_error_code cmd_list_events(enum lttng_domain_type domain,
- struct ltt_session *session,
- char *channel_name,
- struct lttng_payload *reply_payload)
+ struct ltt_session *session,
+ char *channel_name,
+ struct lttng_payload *reply_payload)
{
int buffer_resize_ret;
enum lttng_error_code ret_code = LTTNG_OK;
/* Reserve space for command reply header. */
reply_command_header_offset = reply_payload->buffer.size;
- buffer_resize_ret = lttng_dynamic_buffer_set_size(&reply_payload->buffer,
- reply_command_header_offset +
- sizeof(struct lttcomm_list_command_header));
+ buffer_resize_ret = lttng_dynamic_buffer_set_size(
+ &reply_payload->buffer,
+ reply_command_header_offset + sizeof(struct lttcomm_list_command_header));
if (buffer_resize_ret) {
ret_code = LTTNG_ERR_NOMEM;
goto end;
switch (domain) {
case LTTNG_DOMAIN_KERNEL:
- if (session->kernel_session != NULL) {
- ret_code = list_lttng_kernel_events(channel_name,
- session->kernel_session, reply_payload, &nb_events);
+ if (session->kernel_session != nullptr) {
+ ret_code = list_lttng_kernel_events(
+ channel_name, session->kernel_session, reply_payload, &nb_events);
}
break;
case LTTNG_DOMAIN_UST:
{
- if (session->ust_session != NULL) {
- ret_code = list_lttng_ust_global_events(channel_name,
- &session->ust_session->domain_global,
- reply_payload, &nb_events);
+ if (session->ust_session != nullptr) {
+ ret_code =
+ list_lttng_ust_global_events(channel_name,
+ &session->ust_session->domain_global,
+ reply_payload,
+ &nb_events);
}
break;
struct lttng_ht_iter iter;
struct agent *agt;
- rcu_read_lock();
- cds_lfht_for_each_entry(session->ust_session->agents->ht,
- &iter.iter, agt, node.node) {
+ lttng::urcu::read_lock_guard read_lock;
+
+ cds_lfht_for_each_entry (
+ session->ust_session->agents->ht, &iter.iter, agt, node.node) {
if (agt->domain == domain) {
ret_code = list_lttng_agent_events(
- agt, reply_payload, &nb_events);
+ agt, reply_payload, &nb_events);
break;
}
}
-
- rcu_read_unlock();
}
break;
default:
/* Update command reply header. */
reply_command_header.count = (uint32_t) nb_events;
- memcpy(reply_payload->buffer.data + reply_command_header_offset, &reply_command_header,
- sizeof(reply_command_header));
+ memcpy(reply_payload->buffer.data + reply_command_header_offset,
+ &reply_command_header,
+ sizeof(reply_command_header));
end:
return ret_code;
* session_lock_list() and session_unlock_list().
*/
void cmd_list_lttng_sessions(struct lttng_session *sessions,
- size_t session_count, uid_t uid, gid_t gid)
+ size_t session_count,
+ uid_t uid,
+ gid_t gid)
{
int ret;
unsigned int i = 0;
struct ltt_session *session;
struct ltt_session_list *list = session_get_list();
- struct lttng_session_extended *extended =
- (typeof(extended)) (&sessions[session_count]);
+ struct lttng_session_extended *extended = (typeof(extended)) (&sessions[session_count]);
- DBG("Getting all available session for UID %d GID %d",
- uid, gid);
+ DBG("Getting all available session for UID %d GID %d", uid, gid);
/*
* Iterate over session list and append data after the control struct in
* the buffer.
*/
- cds_list_for_each_entry(session, &list->head, list) {
+ cds_list_for_each_entry (session, &list->head, list) {
if (!session_get(session)) {
continue;
}
/*
* Only list the sessions the user can control.
*/
- if (!session_access_ok(session, uid) ||
- session->destroyed) {
+ if (!session_access_ok(session, uid) || session->destroyed) {
session_put(session);
continue;
}
struct ltt_ust_session *usess = session->ust_session;
if (session->consumer->type == CONSUMER_DST_NET ||
- (ksess && ksess->consumer->type == CONSUMER_DST_NET) ||
- (usess && usess->consumer->type == CONSUMER_DST_NET)) {
- ret = build_network_session_path(sessions[i].path,
- sizeof(sessions[i].path), session);
+ (ksess && ksess->consumer->type == CONSUMER_DST_NET) ||
+ (usess && usess->consumer->type == CONSUMER_DST_NET)) {
+ ret = build_network_session_path(
+ sessions[i].path, sizeof(sessions[i].path), session);
} else {
- ret = snprintf(sessions[i].path, sizeof(sessions[i].path), "%s",
- session->consumer->dst.session_root_path);
+ ret = snprintf(sessions[i].path,
+ sizeof(sessions[i].path),
+ "%s",
+ session->consumer->dst.session_root_path);
}
if (ret < 0) {
PERROR("snprintf session path");
* Return LTTNG_OK on success or else a LTTNG_ERR code.
*/
int cmd_snapshot_add_output(struct ltt_session *session,
- const struct lttng_snapshot_output *output, uint32_t *id)
+ const struct lttng_snapshot_output *output,
+ uint32_t *id)
{
int ret;
struct snapshot_output *new_output;
goto error;
}
- ret = snapshot_output_init(session, output->max_size, output->name,
- output->ctrl_url, output->data_url, session->consumer, new_output,
- &session->snapshot);
+ ret = snapshot_output_init(session,
+ output->max_size,
+ output->name,
+ output->ctrl_url,
+ output->data_url,
+ session->consumer,
+ new_output,
+ &session->snapshot);
if (ret < 0) {
if (ret == -ENOMEM) {
ret = LTTNG_ERR_NOMEM;
goto free_error;
}
- rcu_read_lock();
snapshot_add_output(&session->snapshot, new_output);
if (id) {
*id = new_output->id;
}
- rcu_read_unlock();
return LTTNG_OK;
*
* Return LTTNG_OK on success or else a LTTNG_ERR code.
*/
-int cmd_snapshot_del_output(struct ltt_session *session,
- const struct lttng_snapshot_output *output)
+int cmd_snapshot_del_output(struct ltt_session *session, const struct lttng_snapshot_output *output)
{
int ret;
- struct snapshot_output *sout = NULL;
+ struct snapshot_output *sout = nullptr;
LTTNG_ASSERT(session);
LTTNG_ASSERT(output);
- rcu_read_lock();
+ lttng::urcu::read_lock_guard read_lock;
/*
* Permission denied to create an output if the session is not
}
if (output->id) {
- DBG("Cmd snapshot del output id %" PRIu32 " for session %s", output->id,
- session->name);
+ DBG("Cmd snapshot del output id %" PRIu32 " for session %s",
+ output->id,
+ session->name);
sout = snapshot_find_output_by_id(output->id, &session->snapshot);
} else if (*output->name != '\0') {
- DBG("Cmd snapshot del output name %s for session %s", output->name,
- session->name);
+ DBG("Cmd snapshot del output name %s for session %s", output->name, session->name);
sout = snapshot_find_output_by_name(output->name, &session->snapshot);
}
if (!sout) {
ret = LTTNG_OK;
error:
- rcu_read_unlock();
return ret;
}
* Return the size of the newly allocated outputs or a negative LTTNG_ERR code.
*/
ssize_t cmd_snapshot_list_outputs(struct ltt_session *session,
- struct lttng_snapshot_output **outputs)
+ struct lttng_snapshot_output **outputs)
{
int ret, idx = 0;
- struct lttng_snapshot_output *list = NULL;
+ struct lttng_snapshot_output *list = nullptr;
struct lttng_ht_iter iter;
struct snapshot_output *output;
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;
}
/* Copy list from session to the new list object. */
- rcu_read_lock();
- cds_lfht_for_each_entry(session->snapshot.output_ht->ht, &iter.iter,
- output, node.node) {
- LTTNG_ASSERT(output->consumer);
- list[idx].id = output->id;
- list[idx].max_size = output->max_size;
- if (lttng_strncpy(list[idx].name, output->name,
- sizeof(list[idx].name))) {
- ret = -LTTNG_ERR_INVALID;
- goto error;
- }
- if (output->consumer->type == CONSUMER_DST_LOCAL) {
- if (lttng_strncpy(list[idx].ctrl_url,
- output->consumer->dst.session_root_path,
- sizeof(list[idx].ctrl_url))) {
+ {
+ lttng::urcu::read_lock_guard read_lock;
+
+ cds_lfht_for_each_entry (
+ session->snapshot.output_ht->ht, &iter.iter, output, node.node) {
+ LTTNG_ASSERT(output->consumer);
+ list[idx].id = output->id;
+ list[idx].max_size = output->max_size;
+ if (lttng_strncpy(list[idx].name, output->name, sizeof(list[idx].name))) {
ret = -LTTNG_ERR_INVALID;
goto error;
}
- } else {
- /* Control URI. */
- ret = uri_to_str_url(&output->consumer->dst.net.control,
- list[idx].ctrl_url, sizeof(list[idx].ctrl_url));
- if (ret < 0) {
- ret = -LTTNG_ERR_NOMEM;
- goto error;
- }
- /* Data URI. */
- ret = uri_to_str_url(&output->consumer->dst.net.data,
- list[idx].data_url, sizeof(list[idx].data_url));
- if (ret < 0) {
- ret = -LTTNG_ERR_NOMEM;
- goto error;
+ if (output->consumer->type == CONSUMER_DST_LOCAL) {
+ if (lttng_strncpy(list[idx].ctrl_url,
+ output->consumer->dst.session_root_path,
+ sizeof(list[idx].ctrl_url))) {
+ ret = -LTTNG_ERR_INVALID;
+ goto error;
+ }
+ } else {
+ /* Control URI. */
+ ret = uri_to_str_url(&output->consumer->dst.net.control,
+ list[idx].ctrl_url,
+ sizeof(list[idx].ctrl_url));
+ if (ret < 0) {
+ ret = -LTTNG_ERR_NOMEM;
+ goto error;
+ }
+
+ /* Data URI. */
+ ret = uri_to_str_url(&output->consumer->dst.net.data,
+ list[idx].data_url,
+ sizeof(list[idx].data_url));
+ if (ret < 0) {
+ ret = -LTTNG_ERR_NOMEM;
+ goto error;
+ }
}
+
+ idx++;
}
- idx++;
}
*outputs = list;
- list = NULL;
+ list = nullptr;
ret = session->snapshot.nb_output;
error:
- rcu_read_unlock();
free(list);
end:
return ret;
*
* Return 0 if the metadata can be generated, a LTTNG_ERR code otherwise.
*/
-static
-int check_regenerate_metadata_support(struct ltt_session *session)
+static int check_regenerate_metadata_support(struct ltt_session *session)
{
int ret;
}
}
if (session->consumer->type == CONSUMER_DST_NET &&
- session->consumer->relay_minor_version < 8) {
+ session->consumer->relay_minor_version < 8) {
ret = LTTNG_ERR_RELAYD_VERSION_FAIL;
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->kernel_session) {
- ret = kernctl_session_regenerate_metadata(
- session->kernel_session->fd);
+ ret = kernctl_session_regenerate_metadata(session->kernel_session->fd);
if (ret < 0) {
ERR("Failed to regenerate the kernel metadata");
goto end;
}
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;
}
if (session->kernel_session) {
- ret = kernctl_session_regenerate_statedump(
- session->kernel_session->fd);
+ ret = kernctl_session_regenerate_statedump(session->kernel_session->fd);
/*
* Currently, the statedump in kernel can only fail if out
* of memory.
return ret;
}
-static
-enum lttng_error_code synchronize_tracer_notifier_register(
- struct notification_thread_handle *notification_thread,
- struct lttng_trigger *trigger, const struct lttng_credentials *cmd_creds)
+static enum lttng_error_code
+synchronize_tracer_notifier_register(struct notification_thread_handle *notification_thread,
+ struct lttng_trigger *trigger,
+ const struct lttng_credentials *cmd_creds)
{
enum lttng_error_code ret_code;
- const struct lttng_condition *condition =
- lttng_trigger_get_const_condition(trigger);
+ const struct lttng_condition *condition = lttng_trigger_get_const_condition(trigger);
const char *trigger_name;
uid_t trigger_owner;
enum lttng_trigger_status trigger_status;
const enum lttng_domain_type trigger_domain =
- lttng_trigger_get_underlying_domain_type_restriction(
- trigger);
+ lttng_trigger_get_underlying_domain_type_restriction(trigger);
trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_owner);
LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
LTTNG_ASSERT(condition);
LTTNG_ASSERT(lttng_condition_get_type(condition) ==
- LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
+ LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
- trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
- trigger_name : "(anonymous)";
+ trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? trigger_name : "(anonymous)";
session_lock_list();
switch (trigger_domain) {
enum lttng_error_code notif_thread_unregister_ret;
notif_thread_unregister_ret =
- notification_thread_command_unregister_trigger(
- notification_thread, trigger);
+ notification_thread_command_unregister_trigger(notification_thread,
+ trigger);
if (notif_thread_unregister_ret != LTTNG_OK) {
/* Return the original error code. */
ERR("Failed to unregister trigger from notification thread during error recovery: trigger name = '%s', trigger owner uid = %d, error code = %d",
- trigger_name,
- (int) trigger_owner,
- ret_code);
+ trigger_name,
+ (int) trigger_owner,
+ ret_code);
}
}
break;
case LTTNG_DOMAIN_PYTHON:
{
/* Agent domains. */
- struct agent *agt = agent_find_by_event_notifier_domain(
- trigger_domain);
+ struct agent *agt = agent_find_by_event_notifier_domain(trigger_domain);
if (!agt) {
agt = agent_create(trigger_domain);
}
enum lttng_error_code cmd_register_trigger(const struct lttng_credentials *cmd_creds,
- struct lttng_trigger *trigger,
- bool is_trigger_anonymous,
- struct notification_thread_handle *notification_thread,
- struct lttng_trigger **return_trigger)
+ struct lttng_trigger *trigger,
+ bool is_trigger_anonymous,
+ struct notification_thread_handle *notification_thread,
+ struct lttng_trigger **return_trigger)
{
enum lttng_error_code ret_code;
const char *trigger_name;
enum lttng_trigger_status trigger_status;
trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
- trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
- trigger_name : "(anonymous)";
+ trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? trigger_name : "(anonymous)";
- trigger_status = lttng_trigger_get_owner_uid(
- trigger, &trigger_owner);
+ trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_owner);
LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
DBG("Running register trigger command: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
- trigger_name, (int) trigger_owner,
- (int) lttng_credentials_get_uid(cmd_creds));
+ trigger_name,
+ (int) trigger_owner,
+ (int) lttng_credentials_get_uid(cmd_creds));
/*
* Validate the trigger credentials against the command credentials.
* Only the root user can register a trigger with non-matching
* credentials.
*/
- if (!lttng_credentials_is_equal_uid(
- lttng_trigger_get_credentials(trigger),
- cmd_creds)) {
+ if (!lttng_credentials_is_equal_uid(lttng_trigger_get_credentials(trigger), cmd_creds)) {
if (lttng_credentials_get_uid(cmd_creds) != 0) {
ERR("Trigger credentials do not match the command credentials: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
- trigger_name, (int) trigger_owner,
- (int) lttng_credentials_get_uid(cmd_creds));
+ trigger_name,
+ (int) trigger_owner,
+ (int) lttng_credentials_get_uid(cmd_creds));
ret_code = LTTNG_ERR_INVALID_TRIGGER;
goto end;
}
ret_code = lttng_trigger_generate_bytecode(trigger, cmd_creds);
if (ret_code != LTTNG_OK) {
ERR("Failed to generate bytecode of trigger: trigger name = '%s', trigger owner uid = %d, error code = %d",
- trigger_name, (int) trigger_owner, ret_code);
+ trigger_name,
+ (int) trigger_owner,
+ ret_code);
goto end;
}
* immutable.
*/
ret_code = notification_thread_command_register_trigger(
- notification_thread, trigger, is_trigger_anonymous);
+ notification_thread, trigger, is_trigger_anonymous);
if (ret_code != LTTNG_OK) {
DBG("Failed to register trigger to notification thread: trigger name = '%s', trigger owner uid = %d, error code = %d",
- trigger_name, (int) trigger_owner, ret_code);
+ trigger_name,
+ (int) trigger_owner,
+ ret_code);
goto end;
}
trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
- trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
- trigger_name : "(anonymous)";
+ trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? trigger_name : "(anonymous)";
/*
* Synchronize tracers if the trigger adds an event notifier.
*/
if (lttng_trigger_needs_tracer_notifier(trigger)) {
- ret_code = synchronize_tracer_notifier_register(notification_thread,
- trigger, cmd_creds);
+ ret_code = synchronize_tracer_notifier_register(
+ notification_thread, trigger, cmd_creds);
if (ret_code != LTTNG_OK) {
- ERR("Error registering tracer notifier: %s",
- lttng_strerror(-ret_code));
+ ERR("Error registering tracer notifier: %s", lttng_strerror(-ret_code));
goto end;
}
}
lttng_trigger_get(trigger);
*return_trigger = trigger;
/* Ownership of trigger was transferred to caller. */
- trigger = NULL;
+ trigger = nullptr;
}
end:
return ret_code;
}
-static
-enum lttng_error_code synchronize_tracer_notifier_unregister(
- const struct lttng_trigger *trigger)
+static enum lttng_error_code
+synchronize_tracer_notifier_unregister(const struct lttng_trigger *trigger)
{
enum lttng_error_code ret_code;
- const struct lttng_condition *condition =
- lttng_trigger_get_const_condition(trigger);
+ const struct lttng_condition *condition = lttng_trigger_get_const_condition(trigger);
const enum lttng_domain_type trigger_domain =
- lttng_trigger_get_underlying_domain_type_restriction(
- trigger);
+ lttng_trigger_get_underlying_domain_type_restriction(trigger);
LTTNG_ASSERT(condition);
LTTNG_ASSERT(lttng_condition_get_type(condition) ==
- LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
+ LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
session_lock_list();
switch (trigger_domain) {
case LTTNG_DOMAIN_PYTHON:
{
/* Agent domains. */
- struct agent *agt = agent_find_by_event_notifier_domain(
- trigger_domain);
+ struct agent *agt = agent_find_by_event_notifier_domain(trigger_domain);
/*
* This trigger was never registered in the first place. Calling
}
enum lttng_error_code cmd_unregister_trigger(const struct lttng_credentials *cmd_creds,
- const struct lttng_trigger *trigger,
- struct notification_thread_handle *notification_thread)
+ const struct lttng_trigger *trigger,
+ struct notification_thread_handle *notification_thread)
{
enum lttng_error_code ret_code;
const char *trigger_name;
uid_t trigger_owner;
enum lttng_trigger_status trigger_status;
- struct lttng_trigger *sessiond_trigger = NULL;
+ struct lttng_trigger *sessiond_trigger = nullptr;
trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? trigger_name : "(anonymous)";
LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
DBG("Running unregister trigger command: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
- trigger_name, (int) trigger_owner,
- (int) lttng_credentials_get_uid(cmd_creds));
+ trigger_name,
+ (int) trigger_owner,
+ (int) lttng_credentials_get_uid(cmd_creds));
/*
* Validate the trigger credentials against the command credentials.
* Only the root user can unregister a trigger with non-matching
* credentials.
*/
- if (!lttng_credentials_is_equal_uid(
- lttng_trigger_get_credentials(trigger),
- cmd_creds)) {
+ if (!lttng_credentials_is_equal_uid(lttng_trigger_get_credentials(trigger), cmd_creds)) {
if (lttng_credentials_get_uid(cmd_creds) != 0) {
ERR("Trigger credentials do not match the command credentials: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
- trigger_name, (int) trigger_owner,
- (int) lttng_credentials_get_uid(cmd_creds));
+ trigger_name,
+ (int) trigger_owner,
+ (int) lttng_credentials_get_uid(cmd_creds));
ret_code = LTTNG_ERR_INVALID_TRIGGER;
goto end;
}
/* Fetch the sessiond side trigger object. */
ret_code = notification_thread_command_get_trigger(
- notification_thread, trigger, &sessiond_trigger);
+ notification_thread, trigger, &sessiond_trigger);
if (ret_code != LTTNG_OK) {
DBG("Failed to get trigger from notification thread during unregister: trigger name = '%s', trigger owner uid = %d, error code = %d",
- trigger_name, (int) trigger_owner, ret_code);
+ trigger_name,
+ (int) trigger_owner,
+ ret_code);
goto end;
}
*/
lttng_trigger_set_as_unregistered(sessiond_trigger);
- ret_code = notification_thread_command_unregister_trigger(notification_thread,
- trigger);
+ ret_code = notification_thread_command_unregister_trigger(notification_thread, trigger);
if (ret_code != LTTNG_OK) {
DBG("Failed to unregister trigger from notification thread: trigger name = '%s', trigger owner uid = %d, error code = %d",
- trigger_name, (int) trigger_owner, ret_code);
+ trigger_name,
+ (int) trigger_owner,
+ ret_code);
goto end;
}
ERR("Error unregistering trigger to tracer.");
goto end;
}
-
}
end:
}
enum lttng_error_code cmd_list_triggers(struct command_ctx *cmd_ctx,
- struct notification_thread_handle *notification_thread,
- struct lttng_triggers **return_triggers)
+ struct notification_thread_handle *notification_thread,
+ struct lttng_triggers **return_triggers)
{
int ret;
enum lttng_error_code ret_code;
- struct lttng_triggers *triggers = NULL;
+ struct lttng_triggers *triggers = nullptr;
/* Get the set of triggers from the notification thread. */
ret_code = notification_thread_command_list_triggers(
- notification_thread, cmd_ctx->creds.uid, &triggers);
+ notification_thread, cmd_ctx->creds.uid, &triggers);
if (ret_code != LTTNG_OK) {
goto end;
}
}
*return_triggers = triggers;
- triggers = NULL;
+ triggers = nullptr;
ret_code = LTTNG_OK;
end:
lttng_triggers_destroy(triggers);
return ret_code;
}
-enum lttng_error_code cmd_execute_error_query(const struct lttng_credentials *cmd_creds,
- const struct lttng_error_query *query,
- struct lttng_error_query_results **_results,
- struct notification_thread_handle *notification_thread)
+enum lttng_error_code
+cmd_execute_error_query(const struct lttng_credentials *cmd_creds,
+ const struct lttng_error_query *query,
+ struct lttng_error_query_results **_results,
+ struct notification_thread_handle *notification_thread)
{
enum lttng_error_code ret_code;
const struct lttng_trigger *query_target_trigger;
- const struct lttng_action *query_target_action = NULL;
- struct lttng_trigger *matching_trigger = NULL;
+ const struct lttng_action *query_target_action = nullptr;
+ struct lttng_trigger *matching_trigger = nullptr;
const char *trigger_name;
uid_t trigger_owner;
enum lttng_trigger_status trigger_status;
- struct lttng_error_query_results *results = NULL;
+ struct lttng_error_query_results *results = nullptr;
switch (lttng_error_query_get_target_type(query)) {
case LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER:
query_target_trigger = lttng_error_query_trigger_borrow_target(query);
break;
case LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION:
- query_target_trigger =
- lttng_error_query_condition_borrow_target(query);
+ query_target_trigger = lttng_error_query_condition_borrow_target(query);
break;
case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION:
- query_target_trigger = lttng_error_query_action_borrow_trigger_target(
- query);
+ query_target_trigger = lttng_error_query_action_borrow_trigger_target(query);
break;
default:
abort();
LTTNG_ASSERT(query_target_trigger);
- ret_code = notification_thread_command_get_trigger(notification_thread,
- query_target_trigger, &matching_trigger);
+ ret_code = notification_thread_command_get_trigger(
+ notification_thread, query_target_trigger, &matching_trigger);
if (ret_code != LTTNG_OK) {
goto end;
}
/* No longer needed. */
- query_target_trigger = NULL;
+ query_target_trigger = nullptr;
- if (lttng_error_query_get_target_type(query) ==
- LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION) {
+ if (lttng_error_query_get_target_type(query) == LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION) {
/* Get the sessiond-side version of the target action. */
query_target_action =
- lttng_error_query_action_borrow_action_target(
- query, matching_trigger);
+ lttng_error_query_action_borrow_action_target(query, matching_trigger);
}
trigger_status = lttng_trigger_get_name(matching_trigger, &trigger_name);
- trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
- trigger_name : "(anonymous)";
- trigger_status = lttng_trigger_get_owner_uid(matching_trigger,
- &trigger_owner);
+ trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? trigger_name : "(anonymous)";
+ trigger_status = lttng_trigger_get_owner_uid(matching_trigger, &trigger_owner);
LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
results = lttng_error_query_results_create();
}
DBG("Running \"execute error query\" command: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
- trigger_name, (int) trigger_owner,
- (int) lttng_credentials_get_uid(cmd_creds));
+ trigger_name,
+ (int) trigger_owner,
+ (int) lttng_credentials_get_uid(cmd_creds));
/*
* Validate the trigger credentials against the command credentials.
* Only the root user can target a trigger with non-matching
* credentials.
*/
- if (!lttng_credentials_is_equal_uid(
- lttng_trigger_get_credentials(matching_trigger),
- cmd_creds)) {
+ if (!lttng_credentials_is_equal_uid(lttng_trigger_get_credentials(matching_trigger),
+ cmd_creds)) {
if (lttng_credentials_get_uid(cmd_creds) != 0) {
ERR("Trigger credentials do not match the command credentials: trigger name = '%s', trigger owner uid = %d, command creds uid = %d",
- trigger_name, (int) trigger_owner,
- (int) lttng_credentials_get_uid(cmd_creds));
+ trigger_name,
+ (int) trigger_owner,
+ (int) lttng_credentials_get_uid(cmd_creds));
ret_code = LTTNG_ERR_INVALID_TRIGGER;
goto end;
}
switch (lttng_error_query_get_target_type(query)) {
case LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER:
- trigger_status = lttng_trigger_add_error_results(
- matching_trigger, results);
+ trigger_status = lttng_trigger_add_error_results(matching_trigger, results);
switch (trigger_status) {
case LTTNG_TRIGGER_STATUS_OK:
break;
case LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION:
{
- trigger_status = lttng_trigger_condition_add_error_results(
- matching_trigger, results);
+ trigger_status =
+ lttng_trigger_condition_add_error_results(matching_trigger, results);
switch (trigger_status) {
case LTTNG_TRIGGER_STATUS_OK:
case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION:
{
const enum lttng_action_status action_status =
- lttng_action_add_error_query_results(
- query_target_action, results);
+ lttng_action_add_error_query_results(query_target_action, results);
switch (action_status) {
case LTTNG_ACTION_STATUS_OK:
}
*_results = results;
- results = NULL;
+ results = nullptr;
ret_code = LTTNG_OK;
end:
lttng_trigger_put(matching_trigger);
*
* Return LTTNG_OK on success or a LTTNG_ERR code.
*/
-static enum lttng_error_code set_relayd_for_snapshot(
- struct consumer_output *output,
- const struct ltt_session *session)
+static enum lttng_error_code set_relayd_for_snapshot(struct consumer_output *output,
+ const struct ltt_session *session)
{
enum lttng_error_code status = LTTNG_OK;
struct lttng_ht_iter iter;
DBG2("Set relayd object from snapshot output");
if (session->current_trace_chunk) {
- enum lttng_trace_chunk_status chunk_status =
- lttng_trace_chunk_get_id(
- session->current_trace_chunk,
- ¤t_chunk_id.value);
+ enum lttng_trace_chunk_status chunk_status = lttng_trace_chunk_get_id(
+ session->current_trace_chunk, ¤t_chunk_id.value);
if (chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK) {
current_chunk_id.is_set = true;
* For each consumer socket, create and send the relayd object of the
* snapshot output.
*/
- rcu_read_lock();
- cds_lfht_for_each_entry(output->socks->ht, &iter.iter,
- socket, node.node) {
- pthread_mutex_lock(socket->lock);
- status = send_consumer_relayd_sockets(session->id,
- output, socket,
- session->name, session->hostname,
+ {
+ lttng::urcu::read_lock_guard read_lock;
+
+ cds_lfht_for_each_entry (output->socks->ht, &iter.iter, socket, node.node) {
+ pthread_mutex_lock(socket->lock);
+ status = send_consumer_relayd_sockets(
+ session->id,
+ output,
+ socket,
+ session->name,
+ session->hostname,
base_path,
session->live_timer,
- current_chunk_id.is_set ? ¤t_chunk_id.value : NULL,
+ current_chunk_id.is_set ? ¤t_chunk_id.value : nullptr,
session->creation_time,
session->name_contains_creation_time);
- pthread_mutex_unlock(socket->lock);
- if (status != LTTNG_OK) {
- rcu_read_unlock();
- goto error;
+ pthread_mutex_unlock(socket->lock);
+ if (status != LTTNG_OK) {
+ goto error;
+ }
}
}
- rcu_read_unlock();
error:
return status;
*
* Return LTTNG_OK on success or a LTTNG_ERR code.
*/
-static enum lttng_error_code record_kernel_snapshot(
- struct ltt_kernel_session *ksess,
- const struct consumer_output *output,
- const struct ltt_session *session,
- uint64_t nb_packets_per_stream)
+static enum lttng_error_code record_kernel_snapshot(struct ltt_kernel_session *ksess,
+ const struct consumer_output *output,
+ const struct ltt_session *session,
+ uint64_t nb_packets_per_stream)
{
enum lttng_error_code status;
LTTNG_ASSERT(output);
LTTNG_ASSERT(session);
- status = kernel_snapshot_record(
- ksess, output, nb_packets_per_stream);
+ status = kernel_snapshot_record(ksess, output, nb_packets_per_stream);
return status;
}
* Returns LTTNG_OK on success or a LTTNG_ERR error code.
*/
static enum lttng_error_code record_ust_snapshot(struct ltt_ust_session *usess,
- const struct consumer_output *output,
- const struct ltt_session *session,
- uint64_t nb_packets_per_stream)
+ const struct consumer_output *output,
+ const struct ltt_session *session,
+ uint64_t nb_packets_per_stream)
{
enum lttng_error_code status;
LTTNG_ASSERT(output);
LTTNG_ASSERT(session);
- status = ust_app_snapshot_record(
- usess, output, nb_packets_per_stream);
+ status = ust_app_snapshot_record(usess, output, nb_packets_per_stream);
return status;
}
-static
-uint64_t get_session_size_one_more_packet_per_stream(
- const struct ltt_session *session, uint64_t cur_nr_packets)
+static uint64_t get_session_size_one_more_packet_per_stream(const struct ltt_session *session,
+ uint64_t cur_nr_packets)
{
uint64_t tot_size = 0;
if (session->kernel_session) {
struct ltt_kernel_channel *chan;
- const struct ltt_kernel_session *ksess =
- session->kernel_session;
+ const struct ltt_kernel_session *ksess = session->kernel_session;
- cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
+ cds_list_for_each_entry (chan, &ksess->channel_list.head, list) {
if (cur_nr_packets >= chan->channel->attr.num_subbuf) {
/*
* Don't take channel into account if we
*/
continue;
}
- tot_size += chan->channel->attr.subbuf_size
- * chan->stream_count;
+ tot_size += chan->channel->attr.subbuf_size * chan->stream_count;
}
}
if (session->ust_session) {
const struct ltt_ust_session *usess = session->ust_session;
- tot_size += ust_app_get_size_one_more_packet_per_stream(usess,
- cur_nr_packets);
+ tot_size += ust_app_get_size_one_more_packet_per_stream(usess, cur_nr_packets);
}
return tot_size;
* an approximation: for instance, applications could appear/disappear
* in between this call and actually grabbing data.
*/
-static
-int64_t get_session_nb_packets_per_stream(const struct ltt_session *session,
- uint64_t max_size)
+static int64_t get_session_nb_packets_per_stream(const struct ltt_session *session,
+ uint64_t max_size)
{
int64_t size_left;
uint64_t cur_nb_packets = 0;
if (!max_size) {
- return 0; /* Infinite */
+ return 0; /* Infinite */
}
size_left = max_size;
for (;;) {
uint64_t one_more_packet_tot_size;
- one_more_packet_tot_size = get_session_size_one_more_packet_per_stream(
- session, cur_nb_packets);
+ one_more_packet_tot_size =
+ get_session_size_one_more_packet_per_stream(session, cur_nb_packets);
if (!one_more_packet_tot_size) {
/* We are already grabbing all packets. */
break;
return cur_nb_packets;
}
-static
-enum lttng_error_code snapshot_record(struct ltt_session *session,
- const struct snapshot_output *snapshot_output)
+static enum lttng_error_code snapshot_record(struct ltt_session *session,
+ const struct snapshot_output *snapshot_output)
{
int64_t nb_packets_per_stream;
char snapshot_chunk_name[LTTNG_NAME_MAX];
int ret;
enum lttng_error_code ret_code = LTTNG_OK;
struct lttng_trace_chunk *snapshot_trace_chunk;
- struct consumer_output *original_ust_consumer_output = NULL;
- struct consumer_output *original_kernel_consumer_output = NULL;
- struct consumer_output *snapshot_ust_consumer_output = NULL;
- struct consumer_output *snapshot_kernel_consumer_output = NULL;
-
- ret = snprintf(snapshot_chunk_name, sizeof(snapshot_chunk_name),
- "%s-%s-%" PRIu64,
- snapshot_output->name,
- snapshot_output->datetime,
- snapshot_output->nb_snapshot);
+ struct consumer_output *original_ust_consumer_output = nullptr;
+ struct consumer_output *original_kernel_consumer_output = nullptr;
+ struct consumer_output *snapshot_ust_consumer_output = nullptr;
+ struct consumer_output *snapshot_kernel_consumer_output = nullptr;
+
+ ret = snprintf(snapshot_chunk_name,
+ sizeof(snapshot_chunk_name),
+ "%s-%s-%" PRIu64,
+ snapshot_output->name,
+ snapshot_output->datetime,
+ snapshot_output->nb_snapshot);
if (ret < 0 || ret >= sizeof(snapshot_chunk_name)) {
ERR("Failed to format snapshot name");
ret_code = LTTNG_ERR_INVALID;
goto error;
}
DBG("Recording snapshot \"%s\" for session \"%s\" with chunk name \"%s\"",
- snapshot_output->name, session->name,
- snapshot_chunk_name);
+ snapshot_output->name,
+ session->name,
+ snapshot_chunk_name);
if (!session->kernel_session && !session->ust_session) {
ERR("Failed to record snapshot as no channels exist");
ret_code = LTTNG_ERR_NO_CHANNEL;
}
if (session->kernel_session) {
- original_kernel_consumer_output =
- session->kernel_session->consumer;
- snapshot_kernel_consumer_output =
- consumer_copy_output(snapshot_output->consumer);
- strcpy(snapshot_kernel_consumer_output->chunk_path,
- snapshot_chunk_name);
+ original_kernel_consumer_output = session->kernel_session->consumer;
+ snapshot_kernel_consumer_output = consumer_copy_output(snapshot_output->consumer);
+ strcpy(snapshot_kernel_consumer_output->chunk_path, snapshot_chunk_name);
/* Copy the original domain subdir. */
strcpy(snapshot_kernel_consumer_output->domain_subdir,
- original_kernel_consumer_output->domain_subdir);
+ original_kernel_consumer_output->domain_subdir);
ret = consumer_copy_sockets(snapshot_kernel_consumer_output,
- original_kernel_consumer_output);
+ original_kernel_consumer_output);
if (ret < 0) {
ERR("Failed to copy consumer sockets from snapshot output configuration");
ret_code = LTTNG_ERR_NOMEM;
goto error;
}
- ret_code = set_relayd_for_snapshot(
- snapshot_kernel_consumer_output, session);
+ ret_code = set_relayd_for_snapshot(snapshot_kernel_consumer_output, session);
if (ret_code != LTTNG_OK) {
ERR("Failed to setup relay daemon for kernel tracer snapshot");
goto error;
}
- session->kernel_session->consumer =
- snapshot_kernel_consumer_output;
+ session->kernel_session->consumer = snapshot_kernel_consumer_output;
}
if (session->ust_session) {
original_ust_consumer_output = session->ust_session->consumer;
- snapshot_ust_consumer_output =
- consumer_copy_output(snapshot_output->consumer);
- strcpy(snapshot_ust_consumer_output->chunk_path,
- snapshot_chunk_name);
+ snapshot_ust_consumer_output = consumer_copy_output(snapshot_output->consumer);
+ strcpy(snapshot_ust_consumer_output->chunk_path, snapshot_chunk_name);
/* Copy the original domain subdir. */
strcpy(snapshot_ust_consumer_output->domain_subdir,
- original_ust_consumer_output->domain_subdir);
+ original_ust_consumer_output->domain_subdir);
ret = consumer_copy_sockets(snapshot_ust_consumer_output,
- original_ust_consumer_output);
+ original_ust_consumer_output);
if (ret < 0) {
ERR("Failed to copy consumer sockets from snapshot output configuration");
ret_code = LTTNG_ERR_NOMEM;
goto error;
}
- ret_code = set_relayd_for_snapshot(
- snapshot_ust_consumer_output, session);
+ ret_code = set_relayd_for_snapshot(snapshot_ust_consumer_output, session);
if (ret_code != LTTNG_OK) {
ERR("Failed to setup relay daemon for userspace tracer snapshot");
goto error;
}
- session->ust_session->consumer =
- snapshot_ust_consumer_output;
+ session->ust_session->consumer = snapshot_ust_consumer_output;
}
- snapshot_trace_chunk = session_create_new_trace_chunk(session,
- snapshot_kernel_consumer_output ?:
- snapshot_ust_consumer_output,
- consumer_output_get_base_path(
- snapshot_output->consumer),
- snapshot_chunk_name);
+ snapshot_trace_chunk = session_create_new_trace_chunk(
+ session,
+ snapshot_kernel_consumer_output ?: snapshot_ust_consumer_output,
+ consumer_output_get_base_path(snapshot_output->consumer),
+ snapshot_chunk_name);
if (!snapshot_trace_chunk) {
ERR("Failed to create temporary trace chunk to record a snapshot of session \"%s\"",
- session->name);
+ session->name);
ret_code = LTTNG_ERR_CREATE_DIR_FAIL;
goto error;
}
LTTNG_ASSERT(!session->current_trace_chunk);
- ret = session_set_trace_chunk(session, snapshot_trace_chunk, NULL);
+ ret = session_set_trace_chunk(session, snapshot_trace_chunk, nullptr);
lttng_trace_chunk_put(snapshot_trace_chunk);
- snapshot_trace_chunk = NULL;
+ snapshot_trace_chunk = nullptr;
if (ret) {
ERR("Failed to set temporary trace chunk to record a snapshot of session \"%s\"",
- session->name);
+ session->name);
ret_code = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER;
goto error;
}
- nb_packets_per_stream = get_session_nb_packets_per_stream(session,
- snapshot_output->max_size);
+ nb_packets_per_stream =
+ get_session_nb_packets_per_stream(session, snapshot_output->max_size);
if (nb_packets_per_stream < 0) {
ret_code = LTTNG_ERR_MAX_SIZE_INVALID;
goto error_close_trace_chunk;
if (session->kernel_session) {
ret_code = record_kernel_snapshot(session->kernel_session,
- snapshot_kernel_consumer_output, session,
- nb_packets_per_stream);
+ snapshot_kernel_consumer_output,
+ session,
+ nb_packets_per_stream);
if (ret_code != LTTNG_OK) {
goto error_close_trace_chunk;
}
if (session->ust_session) {
ret_code = record_ust_snapshot(session->ust_session,
- snapshot_ust_consumer_output, session,
- nb_packets_per_stream);
+ snapshot_ust_consumer_output,
+ session,
+ nb_packets_per_stream);
if (ret_code != LTTNG_OK) {
goto error_close_trace_chunk;
}
}
error_close_trace_chunk:
- if (session_set_trace_chunk(session, NULL, &snapshot_trace_chunk)) {
- ERR("Failed to release the current trace chunk of session \"%s\"",
- session->name);
+ if (session_set_trace_chunk(session, nullptr, &snapshot_trace_chunk)) {
+ ERR("Failed to release the current trace chunk of session \"%s\"", session->name);
ret_code = LTTNG_ERR_UNK;
}
- if (session_close_trace_chunk(session, snapshot_trace_chunk,
- LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION, NULL)) {
+ if (session_close_trace_chunk(session,
+ snapshot_trace_chunk,
+ LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION,
+ nullptr)) {
/*
* Don't goto end; make sure the chunk is closed for the session
* to allow future snapshots.
*/
- ERR("Failed to close snapshot trace chunk of session \"%s\"",
- session->name);
+ ERR("Failed to close snapshot trace chunk of session \"%s\"", session->name);
ret_code = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER;
}
lttng_trace_chunk_put(snapshot_trace_chunk);
- snapshot_trace_chunk = NULL;
+ snapshot_trace_chunk = nullptr;
error:
if (original_ust_consumer_output) {
session->ust_session->consumer = original_ust_consumer_output;
}
if (original_kernel_consumer_output) {
- session->kernel_session->consumer =
- original_kernel_consumer_output;
+ session->kernel_session->consumer = original_kernel_consumer_output;
}
consumer_output_put(snapshot_ust_consumer_output);
consumer_output_put(snapshot_kernel_consumer_output);
* Return LTTNG_OK on success or else a LTTNG_ERR code.
*/
int cmd_snapshot_record(struct ltt_session *session,
- const struct lttng_snapshot_output *output,
- int wait __attribute__((unused)))
+ const struct lttng_snapshot_output *output,
+ int wait __attribute__((unused)))
{
enum lttng_error_code cmd_ret = LTTNG_OK;
int ret;
unsigned int snapshot_success = 0;
char datetime[16];
- struct snapshot_output *tmp_output = NULL;
+ struct snapshot_output *tmp_output = nullptr;
LTTNG_ASSERT(session);
LTTNG_ASSERT(output);
DBG("Cmd snapshot record for session %s", session->name);
/* Get the datetime for the snapshot output directory. */
- ret = utils_get_current_time_str("%Y%m%d-%H%M%S", datetime,
- sizeof(datetime));
+ ret = utils_get_current_time_str("%Y%m%d-%H%M%S", datetime, sizeof(datetime));
if (!ret) {
cmd_ret = LTTNG_ERR_INVALID;
goto error;
goto error;
}
- ret = snapshot_output_init(session, output->max_size,
- output->name,
- output->ctrl_url, output->data_url,
- session->consumer,
- tmp_output, NULL);
+ ret = snapshot_output_init(session,
+ output->max_size,
+ output->name,
+ output->ctrl_url,
+ output->data_url,
+ session->consumer,
+ tmp_output,
+ nullptr);
if (ret < 0) {
if (ret == -ENOMEM) {
cmd_ret = LTTNG_ERR_NOMEM;
struct snapshot_output *sout;
struct lttng_ht_iter iter;
- rcu_read_lock();
- cds_lfht_for_each_entry(session->snapshot.output_ht->ht,
- &iter.iter, sout, node.node) {
+ lttng::urcu::read_lock_guard read_lock;
+
+ cds_lfht_for_each_entry (
+ session->snapshot.output_ht->ht, &iter.iter, sout, node.node) {
struct snapshot_output output_copy;
/*
}
output_copy.nb_snapshot = session->snapshot.nb_snapshot;
- memcpy(output_copy.datetime, datetime,
- sizeof(datetime));
+ memcpy(output_copy.datetime, datetime, sizeof(datetime));
/* Use temporary name. */
if (*output->name != '\0') {
if (lttng_strncpy(output_copy.name,
- output->name,
- sizeof(output_copy.name))) {
+ output->name,
+ sizeof(output_copy.name))) {
cmd_ret = LTTNG_ERR_INVALID;
- rcu_read_unlock();
goto error;
}
}
cmd_ret = snapshot_record(session, &output_copy);
if (cmd_ret != LTTNG_OK) {
- rcu_read_unlock();
goto error;
}
+
snapshot_success = 1;
}
- rcu_read_unlock();
}
if (snapshot_success) {
if (tmp_output) {
snapshot_output_destroy(tmp_output);
}
+
return cmd_ret;
}
/*
* Command LTTNG_SET_SESSION_SHM_PATH processed by the client thread.
*/
-int cmd_set_session_shm_path(struct ltt_session *session,
- const char *shm_path)
+int cmd_set_session_shm_path(struct ltt_session *session, const char *shm_path)
{
/* Safety net */
LTTNG_ASSERT(session);
return LTTNG_ERR_SESSION_STARTED;
}
- strncpy(session->shm_path, shm_path,
- sizeof(session->shm_path));
+ strncpy(session->shm_path, shm_path, sizeof(session->shm_path));
session->shm_path[sizeof(session->shm_path) - 1] = '\0';
return LTTNG_OK;
* Returns LTTNG_OK on success or else a negative LTTng error code.
*/
int cmd_rotate_session(struct ltt_session *session,
- struct lttng_rotate_session_return *rotate_return,
- bool quiet_rotation,
- enum lttng_trace_chunk_command_type command)
+ struct lttng_rotate_session_return *rotate_return,
+ bool quiet_rotation,
+ enum lttng_trace_chunk_command_type command)
{
int ret;
uint64_t ongoing_rotation_chunk_id;
enum lttng_error_code cmd_ret = LTTNG_OK;
- struct lttng_trace_chunk *chunk_being_archived = NULL;
- struct lttng_trace_chunk *new_trace_chunk = NULL;
+ struct lttng_trace_chunk *chunk_being_archived = nullptr;
+ struct lttng_trace_chunk *new_trace_chunk = nullptr;
enum lttng_trace_chunk_status chunk_status;
bool failed_to_rotate = false;
enum lttng_error_code rotation_fail_code = LTTNG_OK;
* destroy.
* Rotation is not supported for snapshot traces (no output).
*/
- if ((!quiet_rotation && session->live_timer) ||
- !session->output_traces) {
+ if ((!quiet_rotation && session->live_timer) || !session->output_traces) {
cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE;
goto end;
}
/* Unsupported feature in lttng-relayd before 2.11. */
if (!quiet_rotation && session->consumer->type == CONSUMER_DST_NET &&
- (session->consumer->relay_major_version == 2 &&
- session->consumer->relay_minor_version < 11)) {
+ (session->consumer->relay_major_version == 2 &&
+ session->consumer->relay_minor_version < 11)) {
cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE_RELAY;
goto end;
}
if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING) {
DBG("Refusing to launch a rotation; a rotation is already in progress for session %s",
- session->name);
+ session->name);
cmd_ret = LTTNG_ERR_ROTATION_PENDING;
goto end;
}
*/
if (session->rotated_after_last_stop) {
DBG("Session \"%s\" was already rotated after stop, refusing rotation",
- session->name);
+ session->name);
cmd_ret = LTTNG_ERR_ROTATION_MULTIPLE_AFTER_STOP;
goto end;
}
*/
if (session->cleared_after_last_stop) {
DBG("Session \"%s\" was already cleared after stop, refusing rotation",
- session->name);
+ session->name);
cmd_ret = LTTNG_ERR_ROTATION_AFTER_STOP_CLEAR;
goto end;
}
if (session->active) {
- new_trace_chunk = session_create_new_trace_chunk(session, NULL,
- NULL, NULL);
+ new_trace_chunk =
+ session_create_new_trace_chunk(session, nullptr, nullptr, nullptr);
if (!new_trace_chunk) {
cmd_ret = LTTNG_ERR_CREATE_DIR_FAIL;
goto error;
* be closed on the consumer(s), otherwise it will never be
* cleaned-up, which will result in a leak.
*/
- ret = session_set_trace_chunk(session, new_trace_chunk,
- &chunk_being_archived);
+ ret = session_set_trace_chunk(session, new_trace_chunk, &chunk_being_archived);
if (ret) {
cmd_ret = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER;
goto error;
if (!chunk_being_archived) {
DBG("Rotating session \"%s\" from a \"NULL\" trace chunk to a new trace chunk, skipping completion check",
- session->name);
+ session->name);
if (failed_to_rotate) {
cmd_ret = rotation_fail_code;
goto error;
}
session->rotation_state = LTTNG_ROTATION_STATE_ONGOING;
- chunk_status = lttng_trace_chunk_get_id(chunk_being_archived,
- &ongoing_rotation_chunk_id);
+ chunk_status = lttng_trace_chunk_get_id(chunk_being_archived, &ongoing_rotation_chunk_id);
LTTNG_ASSERT(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
- ret = session_close_trace_chunk(session, chunk_being_archived,
- command, session->last_chunk_path);
+ ret = session_close_trace_chunk(
+ session, chunk_being_archived, command, session->last_chunk_path);
if (ret) {
cmd_ret = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER;
goto error;
}
session->quiet_rotation = quiet_rotation;
- ret = timer_session_rotation_pending_check_start(session,
- DEFAULT_ROTATE_PENDING_TIMER);
+ ret = timer_session_rotation_pending_check_start(session, DEFAULT_ROTATE_PENDING_TIMER);
if (ret) {
cmd_ret = LTTNG_ERR_UNK;
goto error;
}
session->chunk_being_archived = chunk_being_archived;
- chunk_being_archived = NULL;
+ chunk_being_archived = nullptr;
if (!quiet_rotation) {
ret = notification_thread_command_session_rotation_ongoing(
- the_notification_thread_handle, session->name,
- session->uid, session->gid,
- ongoing_rotation_chunk_id);
+ 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",
- session->name);
+ session->name);
cmd_ret = (lttng_error_code) ret;
}
}
DBG("Cmd rotate session %s, archive_id %" PRIu64 " sent",
- session->name, ongoing_rotation_chunk_id);
+ session->name,
+ ongoing_rotation_chunk_id);
end:
lttng_trace_chunk_put(new_trace_chunk);
lttng_trace_chunk_put(chunk_being_archived);
ret = (cmd_ret == LTTNG_OK) ? cmd_ret : -((int) cmd_ret);
return ret;
error:
- if (session_reset_rotation_state(session,
- LTTNG_ROTATION_STATE_ERROR)) {
- ERR("Failed to reset rotation state of session \"%s\"",
- session->name);
+ if (session_reset_rotation_state(session, LTTNG_ROTATION_STATE_ERROR)) {
+ ERR("Failed to reset rotation state of session \"%s\"", session->name);
}
goto end;
}
* Return LTTNG_OK on success or else an LTTNG_ERR code.
*/
int cmd_rotate_get_info(struct ltt_session *session,
- struct lttng_rotation_get_info_return *info_return,
- uint64_t rotation_id)
+ struct lttng_rotation_get_info_return *info_return,
+ uint64_t rotation_id)
{
enum lttng_error_code cmd_ret = LTTNG_OK;
enum lttng_rotation_state rotation_state;
- DBG("Cmd rotate_get_info session %s, rotation id %" PRIu64, session->name,
- session->most_recent_chunk_id.value);
+ DBG("Cmd rotate_get_info session %s, rotation id %" PRIu64,
+ session->name,
+ session->most_recent_chunk_id.value);
if (session->chunk_being_archived) {
enum lttng_trace_chunk_status chunk_status;
uint64_t chunk_id;
- chunk_status = lttng_trace_chunk_get_id(
- session->chunk_being_archived,
- &chunk_id);
+ chunk_status = lttng_trace_chunk_get_id(session->chunk_being_archived, &chunk_id);
LTTNG_ASSERT(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
- rotation_state = rotation_id == chunk_id ?
- LTTNG_ROTATION_STATE_ONGOING :
- LTTNG_ROTATION_STATE_EXPIRED;
+ rotation_state = rotation_id == chunk_id ? LTTNG_ROTATION_STATE_ONGOING :
+ LTTNG_ROTATION_STATE_EXPIRED;
} else {
if (session->last_archived_chunk_id.is_set &&
- rotation_id != session->last_archived_chunk_id.value) {
+ rotation_id != session->last_archived_chunk_id.value) {
rotation_state = LTTNG_ROTATION_STATE_EXPIRED;
} else {
rotation_state = session->rotation_state;
switch (rotation_state) {
case LTTNG_ROTATION_STATE_NO_ROTATION:
DBG("Reporting that no rotation has occurred within the lifetime of session \"%s\"",
- session->name);
+ session->name);
goto end;
case LTTNG_ROTATION_STATE_EXPIRED:
- DBG("Reporting that the rotation state of rotation id %" PRIu64 " of session \"%s\" has expired",
- rotation_id, session->name);
+ DBG("Reporting that the rotation state of rotation id %" PRIu64
+ " of session \"%s\" has expired",
+ rotation_id,
+ session->name);
break;
case LTTNG_ROTATION_STATE_ONGOING:
DBG("Reporting that rotation id %" PRIu64 " of session \"%s\" is still pending",
- rotation_id, session->name);
+ rotation_id,
+ session->name);
break;
case LTTNG_ROTATION_STATE_COMPLETED:
{
size_t current_tracing_path_reply_len;
DBG("Reporting that rotation id %" PRIu64 " of session \"%s\" is completed",
- rotation_id, session->name);
+ rotation_id,
+ session->name);
switch (session_get_consumer_destination_type(session)) {
case CONSUMER_DST_LOCAL:
- current_tracing_path_reply =
- info_return->location.local.absolute_path;
+ current_tracing_path_reply = info_return->location.local.absolute_path;
current_tracing_path_reply_len =
- sizeof(info_return->location.local.absolute_path);
+ sizeof(info_return->location.local.absolute_path);
info_return->location_type =
- (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL;
+ (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL;
fmt_ret = asprintf(&chunk_path,
- "%s/" DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY "/%s",
- session_get_base_path(session),
- session->last_archived_chunk_name);
+ "%s/" DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY "/%s",
+ session_get_base_path(session),
+ session->last_archived_chunk_name);
if (fmt_ret == -1) {
PERROR("Failed to format the path of the last archived trace chunk");
info_return->status = LTTNG_ROTATION_STATUS_ERROR;
{
uint16_t ctrl_port, data_port;
- current_tracing_path_reply =
- info_return->location.relay.relative_path;
+ current_tracing_path_reply = info_return->location.relay.relative_path;
current_tracing_path_reply_len =
- sizeof(info_return->location.relay.relative_path);
+ sizeof(info_return->location.relay.relative_path);
/* Currently the only supported relay protocol. */
info_return->location.relay.protocol =
- (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_RELAY_PROTOCOL_TYPE_TCP;
+ (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_RELAY_PROTOCOL_TYPE_TCP;
fmt_ret = lttng_strncpy(info_return->location.relay.host,
- session_get_net_consumer_hostname(session),
- sizeof(info_return->location.relay.host));
+ session_get_net_consumer_hostname(session),
+ sizeof(info_return->location.relay.host));
if (fmt_ret) {
ERR("Failed to copy host name to rotate_get_info reply");
info_return->status = LTTNG_ROTATION_STATUS_ERROR;
info_return->location.relay.ports.control = ctrl_port;
info_return->location.relay.ports.data = data_port;
info_return->location_type =
- (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY;
+ (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY;
chunk_path = strdup(session->last_chunk_path);
if (!chunk_path) {
ERR("Failed to allocate the path of the last archived trace chunk");
abort();
}
- fmt_ret = lttng_strncpy(current_tracing_path_reply,
- chunk_path, current_tracing_path_reply_len);
+ fmt_ret = lttng_strncpy(
+ current_tracing_path_reply, chunk_path, current_tracing_path_reply_len);
free(chunk_path);
if (fmt_ret) {
ERR("Failed to copy path of the last archived trace chunk to rotate_get_info reply");
break;
}
case LTTNG_ROTATION_STATE_ERROR:
- DBG("Reporting that an error occurred during rotation %" PRIu64 " of session \"%s\"",
- rotation_id, session->name);
+ DBG("Reporting that an error occurred during rotation %" PRIu64
+ " of session \"%s\"",
+ rotation_id,
+ session->name);
break;
default:
abort();
* Return LTTNG_OK on success or else a positive LTTNG_ERR code.
*/
int cmd_rotation_set_schedule(struct ltt_session *session,
- bool activate, enum lttng_rotation_schedule_type schedule_type,
- uint64_t new_value,
- struct notification_thread_handle *notification_thread_handle)
+ bool activate,
+ enum lttng_rotation_schedule_type schedule_type,
+ uint64_t new_value,
+ struct notification_thread_handle *notification_thread_handle)
{
int ret;
uint64_t *parameter_value;
case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC:
parameter_value = &session->rotate_timer_period;
if (new_value >= UINT_MAX) {
- DBG("Failing ROTATION_SET_SCHEDULE command as the value requested for a periodic rotation schedule is invalid: %" PRIu64 " > %u (UINT_MAX)",
- new_value, UINT_MAX);
+ DBG("Failing ROTATION_SET_SCHEDULE command as the value requested for a periodic rotation schedule is invalid: %" PRIu64
+ " > %u (UINT_MAX)",
+ new_value,
+ UINT_MAX);
ret = LTTNG_ERR_INVALID;
goto end;
}
* Only start the timer if the session is active,
* otherwise it will be started when the session starts.
*/
- ret = timer_session_rotation_schedule_timer_start(
- session, new_value);
+ ret = timer_session_rotation_schedule_timer_start(session, new_value);
if (ret) {
ERR("Failed to enable session rotation timer in ROTATION_SET_SCHEDULE command");
ret = LTTNG_ERR_UNK;
goto end;
}
} else {
- ret = timer_session_rotation_schedule_timer_stop(
- session);
+ ret = timer_session_rotation_schedule_timer_stop(session);
if (ret) {
ERR("Failed to disable session rotation timer in ROTATION_SET_SCHEDULE command");
ret = LTTNG_ERR_UNK;
break;
case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD:
if (activate) {
- ret = subscribe_session_consumed_size_rotation(session,
- new_value, notification_thread_handle);
+ ret = subscribe_session_consumed_size_rotation(
+ session, new_value, notification_thread_handle);
if (ret) {
ERR("Failed to enable consumed-size notification in ROTATION_SET_SCHEDULE command");
ret = LTTNG_ERR_UNK;
goto end;
}
} else {
- ret = unsubscribe_session_consumed_size_rotation(session,
- notification_thread_handle);
+ ret = unsubscribe_session_consumed_size_rotation(
+ session, notification_thread_handle);
if (ret) {
ERR("Failed to disable consumed-size notification in ROTATION_SET_SCHEDULE command");
ret = LTTNG_ERR_UNK;
goto end;
}
-
}
break;
default:
const char *shm_path = (const char *) path_data;
DBG("Waiting for the shm path at %s to be removed before completing session destruction",
- shm_path);
+ shm_path);
while (true) {
int ret;
struct stat st;
} else {
if (!S_ISDIR(st.st_mode)) {
ERR("The type of shm path %s returned by stat() is not a directory; aborting the wait for shm path removal",
- shm_path);
+ shm_path);
break;
}
}
* Returns a pointer to a handler to run on completion of a command.
* Returns NULL if no handler has to be run for the last command executed.
*/
-const struct cmd_completion_handler *cmd_pop_completion_handler(void)
+const struct cmd_completion_handler *cmd_pop_completion_handler()
{
struct cmd_completion_handler *handler = current_completion_handler;
- current_completion_handler = NULL;
+ current_completion_handler = nullptr;
return handler;
}
/*
* Init command subsystem.
*/
-void cmd_init(void)
+void cmd_init()
{
/*
* Set network sequence index to 1 for streams to match a relayd