*
*/
-
#define _LGPL_SOURCE
-#include <algorithm>
-#include <inttypes.h>
-#include <stdio.h>
-#include <sys/stat.h>
-#include <urcu/list.h>
-#include <urcu/uatomic.h>
+#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/string-utils/string-utils.hpp>
#include <common/trace-chunk.hpp>
#include <common/utils.hpp>
+
#include <lttng/action/action-internal.hpp>
#include <lttng/action/action.h>
#include <lttng/channel-internal.hpp>
#include <lttng/trigger/trigger-internal.hpp>
#include <lttng/userspace-probe-internal.hpp>
-#include "agent-thread.hpp"
-#include "agent.hpp"
-#include "buffer-registry.hpp"
-#include "channel.hpp"
-#include "cmd.hpp"
-#include "consumer.hpp"
-#include "event-notifier-error-accounting.hpp"
-#include "event.hpp"
-#include "health-sessiond.hpp"
-#include "kernel-consumer.hpp"
-#include "kernel.hpp"
-#include "lttng-sessiond.hpp"
-#include "lttng-syscall.hpp"
-#include "notification-thread-commands.hpp"
-#include "notification-thread.hpp"
-#include "rotate.hpp"
-#include "rotation-thread.hpp"
-#include "session.hpp"
-#include "timer.hpp"
-#include "tracker.hpp"
-#include "utils.hpp"
+#include <algorithm>
+#include <inttypes.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <urcu/list.h>
+#include <urcu/uatomic.h>
/* Sleep for 100ms between each check for the shm path's deletion. */
#define SESSION_DESTROY_SHM_PATH_CHECK_DELAY_US 100000
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;
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 enum lttng_error_code 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;
* 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;
local_nb_events = (unsigned int) agent_event_count;
- cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) {
+ cds_lfht_for_each_entry (agt->events->ht, &iter.iter, event, node.node) {
struct lttng_event *tmp_event = lttng_event_create();
if (!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, NULL,
- event->filter_expression, 0, NULL, reply_payload);
+ 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;
* 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;
DBG3("Listing UST global %d events", *nb_events);
- cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
+ cds_lfht_for_each_entry (uchan->events->ht, &iter.iter, uevent, node.node) {
struct lttng_event *tmp_event = NULL;
if (uevent->internal) {
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 :
+ NULL,
+ uevent->filter_expression,
+ 0,
+ NULL,
+ reply_payload);
lttng_event_destroy(tmp_event);
if (ret) {
ret_code = LTTNG_ERR_FATAL;
* 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;
}
/* 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, NULL, event->filter_expression, 0, NULL, 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;
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;
rcu_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);
* 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;
}
/* 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;
*
* 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;
}
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) {
+ 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 : NULL,
+ 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) {
+ 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 : NULL,
+ 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:
}
/* 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) {
}
/* 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");
* 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;
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;
}
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 enum lttng_error_code 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)
{
enum lttng_error_code ret_code;
struct ltt_ust_session *usess = session->ust_session;
len = lttng_strnlen(attr->name, sizeof(attr->name));
/* Validate channel name */
- if (attr->name[0] == '.' ||
- memchr(attr->name, '/', len) != NULL) {
+ if (attr->name[0] == '.' || memchr(attr->name, '/', len) != NULL) {
ret_code = LTTNG_ERR_INVALID_CHANNEL_NAME;
goto end;
}
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;
{
struct ltt_kernel_channel *kchan;
- kchan = trace_kernel_get_channel_by_name(
- attr->name, session->kernel_session);
+ kchan = trace_kernel_get_channel_by_name(attr->name, session->kernel_session);
if (kchan == NULL) {
/*
* Don't try to create a channel if the session has been started at
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_code = 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;
}
* adhered to.
*/
if (domain->type == LTTNG_DOMAIN_JUL) {
- if (strncmp(attr->name, DEFAULT_JUL_CHANNEL_NAME,
- LTTNG_SYMBOL_NAME_LEN)) {
+ if (strncmp(attr->name, DEFAULT_JUL_CHANNEL_NAME, LTTNG_SYMBOL_NAME_LEN)) {
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)) {
+ if (strncmp(attr->name, DEFAULT_LOG4J_CHANNEL_NAME, LTTNG_SYMBOL_NAME_LEN)) {
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)) {
+ if (strncmp(attr->name,
+ DEFAULT_PYTHON_CHANNEL_NAME,
+ LTTNG_SYMBOL_NAME_LEN)) {
ret_code = LTTNG_ERR_INVALID_CHANNEL_NAME;
goto error;
}
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;
/* 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;
}
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, NULL, 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);
+ uchan = trace_ust_find_channel_by_name(usess->domain_global.channels, channel_name);
if (uchan == NULL) {
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:
* 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;
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)) {
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)) {
ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
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;
* 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);
+ 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);
+ attr = channel_new_default_attr(LTTNG_DOMAIN_KERNEL, LTTNG_BUFFER_GLOBAL);
if (attr == NULL) {
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);
+ kchan = trace_kernel_get_channel_by_name(channel_name, session->kernel_session);
if (kchan == NULL) {
/* This sould not happen... */
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;
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;
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;
}
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;
}
/* Get channel from global UST domain */
- 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);
if (uchan == NULL) {
/* Create default channel */
- attr = channel_new_default_attr(LTTNG_DOMAIN_UST,
- usess->buffer_type);
+ attr = channel_new_default_attr(LTTNG_DOMAIN_UST, usess->buffer_type);
if (attr == NULL) {
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;
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;
struct lttng_bytecode *filter_copy = NULL;
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 = zmalloc<lttng_bytecode>(filter_size);
if (!filter_copy) {
}
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,
+ NULL,
+ 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;
* 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);
+ &command_domain,
+ cmd_ctx->lsm.u.enable.channel_name,
+ event,
+ filter_expression,
+ bytecode,
+ exclusion,
+ wpipe,
+ false);
filter_expression = NULL;
bytecode = NULL;
exclusion = NULL;
* 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;
/* 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, NULL, NULL, 0, NULL, 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;
/* 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;
/* 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, NULL, NULL, 0, NULL, 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;
}
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, NULL, NULL, NULL);
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, NULL);
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, NULL, true, LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION);
if (ret != LTTNG_OK) {
goto error;
}
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");
} else {
session->active = 0;
/* 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;
ret = LTTNG_OK;
* 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;
}
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:
}
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,
+ NULL,
+ 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;
}
}
- 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;
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);
+ new_session->id,
+ new_session->name,
+ new_session->uid,
+ new_session->gid);
if (ret_code != LTTNG_OK) {
goto end;
}
/* Announce the session's destruction to the notification thread when it is destroyed. */
ret = session_add_destroy_notifier(
- new_session,
- [](const struct ltt_session *session,
- void *user_data __attribute__((unused))) {
- (void) notification_thread_command_remove_session(
- the_notification_thread_handle, session->id);
- },
- NULL);
+ new_session,
+ [](const struct ltt_session *session, void *user_data __attribute__((unused))) {
+ (void) notification_thread_command_remove_session(
+ the_notification_thread_handle, session->id);
+ },
+ NULL);
if (ret) {
PERROR("Failed to add notification thread command to session's destroy notifiers: session name = %s",
- new_session->name);
+ 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 : NULL, 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;
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;
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;
* Sets the descriptor's auto-generated properties (name, output) if
* needed.
*/
- ret_code = cmd_create_session_from_descriptor(session_descriptor,
- &cmd_ctx->creds,
- home_dir_view.size ? home_dir_view.data : NULL);
+ ret_code =
+ cmd_create_session_from_descriptor(session_descriptor,
+ &cmd_ctx->creds,
+ home_dir_view.size ? home_dir_view.data : NULL);
if (ret_code != LTTNG_OK) {
goto error;
}
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;
.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;
/* 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, NULL, 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, NULL, 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;
/*
* 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;
nb_dom++;
rcu_read_lock();
- cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter,
- agt, node.node) {
+ cds_lfht_for_each_entry (
+ session->ust_session->agents->ht, &iter.iter, agt, node.node) {
if (agt->being_used) {
nb_dom++;
}
index++;
rcu_read_lock();
- cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter,
- agt, node.node) {
+ 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;
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) {
+ 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 ltt_ust_channel *uchan;
rcu_read_lock();
- cds_lfht_for_each_entry(session->ust_session->domain_global.channels->ht,
- &iter.iter, uchan, node.node) {
+ 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;
goto end;
}
- extended = (struct lttng_channel_extended *)
- channel->attr.extended.ptr;
+ extended = (struct lttng_channel_extended *) channel->attr.extended.ptr;
- ret = get_ust_runtime_stats(session, uchan,
- &discarded_events, &lost_packets);
+ ret = get_ust_runtime_stats(
+ session, uchan, &discarded_events, &lost_packets);
if (ret < 0) {
lttng_channel_destroy(channel);
ret_code = LTTNG_ERR_UNK;
extended->discarded_events = discarded_events;
extended->lost_packets = lost_packets;
- ret = lttng_channel_serialize(
- channel, &payload->buffer);
+ ret = lttng_channel_serialize(channel, &payload->buffer);
if (ret) {
ERR("Failed to serialize lttng_channel: channel name = '%s'",
- channel->name);
+ channel->name);
lttng_channel_destroy(channel);
ret_code = LTTNG_ERR_UNK;
goto end;
/* 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);
+ 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);
+ ret_code =
+ list_lttng_ust_global_events(channel_name,
+ &session->ust_session->domain_global,
+ reply_payload,
+ &nb_events);
}
break;
struct agent *agt;
rcu_read_lock();
- cds_lfht_for_each_entry(session->ust_session->agents->ht,
- &iter.iter, agt, node.node) {
+ 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;
}
}
/* 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;
*
* 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;
}
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) {
* 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;
/* 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) {
+ 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))) {
+ 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))) {
+ 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));
+ 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));
+ list[idx].data_url,
+ sizeof(list[idx].data_url));
if (ret < 0) {
ret = -LTTNG_ERR_NOMEM;
goto error;
*
* 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;
}
}
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->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;
}
}
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;
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;
/* 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 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;
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;
- 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:
*
* 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;
* snapshot output.
*/
rcu_read_lock();
- cds_lfht_for_each_entry(output->socks->ht, &iter.iter,
- socket, node.node) {
+ 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,
- session->creation_time,
- session->name_contains_creation_time);
+ 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,
+ session->creation_time,
+ session->name_contains_creation_time);
pthread_mutex_unlock(socket->lock);
if (status != LTTNG_OK) {
rcu_read_unlock();
*
* 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];
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);
+ 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;
}
snapshot_trace_chunk = NULL;
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);
+ 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,
+ NULL)) {
/*
* 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;
}
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;
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,
+ NULL);
if (ret < 0) {
if (ret == -ENOMEM) {
cmd_ret = LTTNG_ERR_NOMEM;
struct lttng_ht_iter iter;
rcu_read_lock();
- cds_lfht_for_each_entry(session->snapshot.output_ht->ht,
- &iter.iter, sout, node.node) {
+ 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;
/*
* 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;
* 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, NULL, NULL, NULL);
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;
chunk_being_archived = NULL;
if (!quiet_rotation) {
ret = notification_thread_command_session_rotation_ongoing(
- the_notification_thread_handle, session->id,
- 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;
}
}
projects / lttng-tools.git / blobdiff