X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.cpp;fp=src%2Fbin%2Flttng-sessiond%2Fcmd.cpp;h=30e771e1cc21f14c61e60fa3e9c4bf0d4ccdb7c5;hp=5001d94e05dabf96907aea9aacc7d62408649ca5;hb=28ab034a2c3582d07d3423d2d746731f87d3969f;hpb=52e345b9ac912d033c2a2c25a170a01cf209839d diff --git a/src/bin/lttng-sessiond/cmd.cpp b/src/bin/lttng-sessiond/cmd.cpp index 5001d94e0..30e771e1c 100644 --- a/src/bin/lttng-sessiond/cmd.cpp +++ b/src/bin/lttng-sessiond/cmd.cpp @@ -6,14 +6,28 @@ * */ - #define _LGPL_SOURCE -#include -#include -#include -#include -#include -#include +#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 #include @@ -28,6 +42,7 @@ #include #include #include + #include #include #include @@ -49,27 +64,12 @@ #include #include -#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 +#include +#include +#include +#include +#include /* Sleep for 100ms between each check for the shm path's deletion. */ #define SESSION_DESTROY_SHM_PATH_CHECK_DELAY_US 100000 @@ -99,10 +99,7 @@ struct destroy_completion_handler { struct cmd_completion_handler handler; char shm_path[member_sizeof(struct ltt_session, shm_path)]; } destroy_completion_handler = { - .handler = { - .run = wait_on_path, - .data = destroy_completion_handler.shm_path - }, + .handler = { .run = wait_on_path, .data = destroy_completion_handler.shm_path }, .shm_path = { 0 }, }; @@ -119,24 +116,23 @@ uint64_t relayd_net_seq_idx; 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; @@ -192,8 +188,13 @@ static int build_network_session_path(char *dst, size_t size, * 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)) { @@ -214,8 +215,9 @@ error: * 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; @@ -226,16 +228,14 @@ static int get_kernel_runtime_stats(struct ltt_session *session, 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; } @@ -249,8 +249,9 @@ 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; @@ -273,17 +274,19 @@ static int get_ust_runtime_stats(struct ltt_session *session, 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; } @@ -305,9 +308,9 @@ 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; @@ -335,7 +338,7 @@ static enum lttng_error_code list_lttng_agent_events( 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) { @@ -348,14 +351,14 @@ static enum lttng_error_code list_lttng_agent_events( 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; @@ -375,9 +378,9 @@ error: * 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; @@ -420,7 +423,7 @@ static enum lttng_error_code list_lttng_ust_global_events(char *channel_name, 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) { @@ -435,8 +438,7 @@ static enum lttng_error_code list_lttng_ust_global_events(char *channel_name, 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; @@ -480,9 +482,14 @@ static enum lttng_error_code list_lttng_ust_global_events(char *channel_name, * 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; @@ -503,9 +510,9 @@ error: * 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; @@ -530,7 +537,7 @@ static enum lttng_error_code list_lttng_kernel_events(char *channel_name, } /* 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) { @@ -542,7 +549,6 @@ static enum lttng_error_code list_lttng_kernel_events(char *channel_name, lttng_event_destroy(tmp_event); ret_code = LTTNG_ERR_FATAL; goto end; - } tmp_event->name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; @@ -555,21 +561,24 @@ static enum lttng_error_code list_lttng_kernel_events(char *channel_name, 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; @@ -586,8 +595,8 @@ static enum lttng_error_code list_lttng_kernel_events(char *channel_name, 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); @@ -595,19 +604,17 @@ static enum lttng_error_code list_lttng_kernel_events(char *channel_name, 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; @@ -624,10 +631,10 @@ end: * 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; @@ -643,13 +650,13 @@ static enum lttng_error_code add_uri_to_consumer( 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: /* @@ -657,8 +664,7 @@ static enum lttng_error_code add_uri_to_consumer( * 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) { @@ -674,9 +680,8 @@ static enum lttng_error_code add_uri_to_consumer( 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; } @@ -703,13 +708,12 @@ static enum lttng_error_code add_uri_to_consumer( 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; @@ -737,8 +741,8 @@ static int init_kernel_tracing(struct ltt_kernel_session *session) 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); @@ -761,15 +765,15 @@ error: * 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; @@ -807,8 +811,7 @@ static enum lttng_error_code create_connect_relayd(struct lttng_uri *uri, } 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; @@ -846,16 +849,17 @@ error: * * 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; @@ -881,11 +885,18 @@ static enum lttng_error_code send_consumer_relayd_socket( } /* 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; @@ -928,12 +939,16 @@ relayd_comm_error: * * 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; @@ -943,10 +958,16 @@ static enum lttng_error_code send_consumer_relayd_sockets( /* 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; } @@ -955,10 +976,16 @@ static enum lttng_error_code send_consumer_relayd_sockets( /* 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; } @@ -992,7 +1019,7 @@ int cmd_setup_relayd(struct ltt_session *session) 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; @@ -1003,20 +1030,23 @@ int cmd_setup_relayd(struct ltt_session *session) } } - 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; @@ -1024,27 +1054,27 @@ int cmd_setup_relayd(struct ltt_session *session) /* 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; @@ -1052,12 +1082,9 @@ int cmd_setup_relayd(struct ltt_session *session) /* 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: @@ -1093,7 +1120,7 @@ int start_kernel_session(struct ltt_kernel_session *ksess) } /* 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) { @@ -1159,7 +1186,7 @@ int stop_kernel_session(struct ltt_kernel_session *ksess) } /* 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"); @@ -1181,7 +1208,8 @@ 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; @@ -1193,8 +1221,7 @@ int cmd_disable_channel(struct ltt_session *session, 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; } @@ -1256,8 +1283,7 @@ int cmd_enable_channel(struct command_ctx *cmd_ctx, int sock, int wpipe) 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; @@ -1276,8 +1302,7 @@ int cmd_enable_channel(struct command_ctx *cmd_ctx, int sock, int wpipe) 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); @@ -1285,11 +1310,10 @@ end: 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; @@ -1310,8 +1334,7 @@ static enum lttng_error_code cmd_enable_channel_internal( 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; } @@ -1337,9 +1360,10 @@ static enum lttng_error_code cmd_enable_channel_internal( 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; @@ -1365,8 +1389,7 @@ static enum lttng_error_code cmd_enable_channel_internal( { 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 @@ -1377,13 +1400,11 @@ static enum lttng_error_code cmd_enable_channel_internal( 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; } @@ -1414,20 +1435,19 @@ static enum lttng_error_code cmd_enable_channel_internal( * 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; } @@ -1470,11 +1490,11 @@ end: 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; @@ -1485,16 +1505,14 @@ enum lttng_error_code cmd_process_attr_tracker_get_tracking_policy( 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; @@ -1509,11 +1527,11 @@ end: 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; @@ -1534,7 +1552,7 @@ enum lttng_error_code cmd_process_attr_tracker_set_tracking_policy( 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) { @@ -1542,7 +1560,7 @@ enum lttng_error_code cmd_process_attr_tracker_set_tracking_policy( 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; @@ -1552,11 +1570,11 @@ end: 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; @@ -1567,7 +1585,7 @@ enum lttng_error_code cmd_process_attr_tracker_inclusion_set_add_value( 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) { @@ -1575,7 +1593,7 @@ enum lttng_error_code cmd_process_attr_tracker_inclusion_set_add_value( 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; @@ -1585,11 +1603,11 @@ end: 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; @@ -1600,7 +1618,7 @@ enum lttng_error_code cmd_process_attr_tracker_inclusion_set_remove_value( 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) { @@ -1608,7 +1626,7 @@ enum lttng_error_code cmd_process_attr_tracker_inclusion_set_remove_value( 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; @@ -1618,11 +1636,11 @@ end: 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; @@ -1634,16 +1652,14 @@ enum lttng_error_code cmd_process_attr_tracker_get_inclusion_set( 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; @@ -1679,10 +1695,10 @@ end: * 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; @@ -1708,8 +1724,8 @@ int cmd_disable_event(struct command_ctx *cmd_ctx, 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; } @@ -1746,13 +1762,11 @@ int cmd_disable_event(struct command_ctx *cmd_ctx, 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; @@ -1788,8 +1802,7 @@ int cmd_disable_event(struct command_ctx *cmd_ctx, 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; @@ -1804,8 +1817,7 @@ int cmd_disable_event(struct command_ctx *cmd_ctx, 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; @@ -1816,8 +1828,7 @@ int cmd_disable_event(struct command_ctx *cmd_ctx, 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: @@ -1877,7 +1888,8 @@ error: * 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; @@ -1907,8 +1919,7 @@ int cmd_add_context(struct command_ctx *cmd_ctx, 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; } @@ -1924,13 +1935,11 @@ int cmd_add_context(struct command_ctx *cmd_ctx, * 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; } @@ -1962,8 +1971,7 @@ int cmd_add_context(struct command_ctx *cmd_ctx, 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; } @@ -1979,24 +1987,20 @@ int cmd_add_context(struct command_ctx *cmd_ctx, 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: @@ -2025,8 +2029,8 @@ static int validate_ust_event_name(const char *name) * 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; } @@ -2041,12 +2045,14 @@ end: * 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; @@ -2086,29 +2092,24 @@ static int _cmd_enable_event(struct ltt_session *session, * 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; } @@ -2116,8 +2117,7 @@ static int _cmd_enable_event(struct ltt_session *session, } /* 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; @@ -2151,9 +2151,8 @@ static int _cmd_enable_event(struct ltt_session *session, } 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; @@ -2166,9 +2165,9 @@ static int _cmd_enable_event(struct ltt_session *session, 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; @@ -2182,8 +2181,7 @@ static int _cmd_enable_event(struct ltt_session *session, 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; @@ -2196,8 +2194,7 @@ static int _cmd_enable_event(struct ltt_session *session, } 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; @@ -2231,31 +2228,27 @@ static int _cmd_enable_event(struct ltt_session *session, } /* 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); } @@ -2276,17 +2269,15 @@ static int _cmd_enable_event(struct ltt_session *session, */ 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; @@ -2330,8 +2321,7 @@ static int _cmd_enable_event(struct ltt_session *session, 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; @@ -2367,9 +2357,8 @@ static int _cmd_enable_event(struct ltt_session *session, 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(filter_size); if (!filter_copy) { @@ -2378,8 +2367,7 @@ static int _cmd_enable_event(struct ltt_session *session, } 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; } @@ -2391,10 +2379,14 @@ static int _cmd_enable_event(struct ltt_session *session, } } - 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) { @@ -2405,11 +2397,9 @@ static int _cmd_enable_event(struct ltt_session *session, /* 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; @@ -2441,11 +2431,11 @@ error: * 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; /* @@ -2462,9 +2452,14 @@ int cmd_enable_event(struct command_ctx *cmd_ctx, * - 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; @@ -2477,22 +2472,30 @@ int cmd_enable_event(struct command_ctx *cmd_ctx, * 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; @@ -2506,8 +2509,8 @@ enum lttng_error_code cmd_list_tracepoints(enum lttng_domain_type domain, /* 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; @@ -2543,8 +2546,7 @@ enum lttng_error_code cmd_list_tracepoints(enum lttng_domain_type domain, } 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; @@ -2559,8 +2561,9 @@ enum lttng_error_code cmd_list_tracepoints(enum lttng_domain_type domain, /* 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: @@ -2572,7 +2575,7 @@ 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; @@ -2586,8 +2589,8 @@ enum lttng_error_code cmd_list_tracepoint_fields(enum lttng_domain_type domain, /* 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; @@ -2603,7 +2606,7 @@ enum lttng_error_code cmd_list_tracepoint_fields(enum lttng_domain_type domain, break; case LTTNG_DOMAIN_KERNEL: - default: /* fall-through */ + default: /* fall-through */ ret_code = LTTNG_ERR_UND; goto error; } @@ -2627,8 +2630,9 @@ enum lttng_error_code cmd_list_tracepoint_fields(enum lttng_domain_type domain, /* 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; @@ -2637,8 +2641,7 @@ error: 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; @@ -2652,8 +2655,8 @@ enum lttng_error_code cmd_list_syscalls( /* 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; @@ -2661,13 +2664,12 @@ enum lttng_error_code cmd_list_syscalls( 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; @@ -2682,8 +2684,9 @@ enum lttng_error_code cmd_list_syscalls( /* 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: @@ -2702,10 +2705,8 @@ int cmd_start_trace(struct ltt_session *session) 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); @@ -2721,7 +2722,7 @@ int cmd_start_trace(struct ltt_session *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 @@ -2731,7 +2732,7 @@ int cmd_start_trace(struct ltt_session *session) * 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; } @@ -2758,17 +2759,15 @@ int cmd_start_trace(struct ltt_session *session) 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; @@ -2776,7 +2775,7 @@ int cmd_start_trace(struct ltt_session *session) } } 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 @@ -2787,8 +2786,8 @@ int cmd_start_trace(struct ltt_session *session) * 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; } @@ -2832,7 +2831,7 @@ int cmd_start_trace(struct ltt_session *session) 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"); @@ -2850,10 +2849,8 @@ error: } 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; @@ -2894,8 +2891,7 @@ int cmd_stop_trace(struct ltt_session *session) } } - 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; @@ -2908,16 +2904,14 @@ error: * Set the base_path of the session only if subdir of a control uris is set. * Return LTTNG_OK on success, otherwise LTTNG_ERR_*. */ -static int set_session_base_path_from_uris(struct ltt_session *session, - size_t nb_uri, - struct lttng_uri *uris) +static int +set_session_base_path_from_uris(struct ltt_session *session, size_t nb_uri, struct lttng_uri *uris) { int ret; size_t i; for (i = 0; i < nb_uri; i++) { - if (uris[i].stype != LTTNG_STREAM_CONTROL || - uris[i].subdir[0] == '\0') { + if (uris[i].stype != LTTNG_STREAM_CONTROL || uris[i].subdir[0] == '\0') { /* Not interested in these URIs */ continue; } @@ -2931,12 +2925,14 @@ static int set_session_base_path_from_uris(struct ltt_session *session, 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: @@ -2946,8 +2942,7 @@ 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; @@ -2975,8 +2970,7 @@ int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri, /* 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; } @@ -2986,8 +2980,9 @@ int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri, 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; } @@ -2998,8 +2993,9 @@ int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri, 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; } @@ -3026,17 +3022,16 @@ 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; @@ -3044,13 +3039,11 @@ enum lttng_error_code set_session_output_from_descriptor( 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: @@ -3070,12 +3063,15 @@ enum lttng_error_code set_session_output_from_descriptor( } 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; } @@ -3096,11 +3092,10 @@ 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; @@ -3117,8 +3112,7 @@ enum lttng_error_code cmd_create_session_from_descriptor( } } - 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; @@ -3130,61 +3124,57 @@ enum lttng_error_code cmd_create_session_from_descriptor( 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)) { @@ -3193,8 +3183,7 @@ enum lttng_error_code cmd_create_session_from_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; @@ -3217,8 +3206,9 @@ end: 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; @@ -3229,19 +3219,18 @@ enum lttng_error_code cmd_create_session(struct command_ctx *cmd_ctx, int sock, 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; @@ -3256,28 +3245,26 @@ enum lttng_error_code cmd_create_session(struct command_ctx *cmd_ctx, int sock, } 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; @@ -3288,9 +3275,10 @@ enum lttng_error_code cmd_create_session(struct command_ctx *cmd_ctx, int sock, * 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; } @@ -3304,14 +3292,12 @@ 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; @@ -3319,8 +3305,7 @@ void cmd_destroy_session_reply(const struct ltt_session *session, .cmd_type = LTTCOMM_SESSIOND_COMMAND_DESTROY_SESSION, .ret_code = reply_context->destruction_status, .pid = UINT32_MAX, - .cmd_header_size = - sizeof(struct lttcomm_session_destroy_command_header), + .cmd_header_size = sizeof(struct lttcomm_session_destroy_command_header), .data_size = 0, .fd_count = 0, }; @@ -3334,12 +3319,10 @@ void cmd_destroy_session_reply(const struct ltt_session *session, 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; @@ -3347,40 +3330,38 @@ void cmd_destroy_session_reply(const struct ltt_session *session, 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); @@ -3397,8 +3378,8 @@ error: * 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; @@ -3417,25 +3398,24 @@ int cmd_destroy_session(struct ltt_session *session, /* 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; } } @@ -3450,11 +3430,12 @@ int cmd_destroy_session(struct ltt_session *session, * 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) { @@ -3470,8 +3451,8 @@ int cmd_destroy_session(struct ltt_session *session, * 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 @@ -3479,10 +3460,10 @@ int cmd_destroy_session(struct ltt_session *session, * 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; } } @@ -3536,8 +3517,8 @@ int cmd_destroy_session(struct ltt_session *session, */ 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); } @@ -3549,9 +3530,8 @@ int cmd_destroy_session(struct ltt_session *session, 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; @@ -3568,8 +3548,9 @@ 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; @@ -3647,8 +3628,7 @@ error: /* * 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; @@ -3665,8 +3645,8 @@ ssize_t cmd_list_domains(struct ltt_session *session, 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++; } @@ -3699,8 +3679,8 @@ ssize_t cmd_list_domains(struct ltt_session *session, 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; @@ -3717,13 +3697,12 @@ error: 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; @@ -3740,7 +3719,7 @@ enum lttng_error_code cmd_list_channels(enum lttng_domain_type domain, /* 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; @@ -3752,16 +3731,16 @@ enum lttng_error_code cmd_list_channels(enum lttng_domain_type domain, /* 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; @@ -3774,11 +3753,10 @@ enum lttng_error_code cmd_list_channels(enum lttng_domain_type domain, 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; } @@ -3794,8 +3772,10 @@ enum lttng_error_code cmd_list_channels(enum lttng_domain_type domain, 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; @@ -3806,11 +3786,10 @@ enum lttng_error_code cmd_list_channels(enum lttng_domain_type domain, 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; @@ -3820,11 +3799,10 @@ enum lttng_error_code cmd_list_channels(enum lttng_domain_type domain, 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; @@ -3848,8 +3826,7 @@ enum lttng_error_code cmd_list_channels(enum lttng_domain_type domain, /* 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: @@ -3860,9 +3837,9 @@ 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; @@ -3874,9 +3851,9 @@ enum lttng_error_code cmd_list_events(enum lttng_domain_type domain, /* 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; @@ -3885,17 +3862,19 @@ enum lttng_error_code cmd_list_events(enum lttng_domain_type domain, 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; @@ -3908,11 +3887,11 @@ enum lttng_error_code cmd_list_events(enum lttng_domain_type domain, 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; } } @@ -3932,8 +3911,9 @@ enum lttng_error_code cmd_list_events(enum lttng_domain_type domain, /* 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; @@ -3947,30 +3927,29 @@ end: * 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; } @@ -3979,13 +3958,15 @@ void cmd_list_lttng_sessions(struct lttng_session *sessions, 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"); @@ -4076,7 +4057,8 @@ error: * 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; @@ -4111,9 +4093,14 @@ int cmd_snapshot_add_output(struct ltt_session *session, 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; @@ -4143,8 +4130,7 @@ error: * * 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; @@ -4164,12 +4150,12 @@ int cmd_snapshot_del_output(struct ltt_session *session, } 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) { @@ -4194,7 +4180,7 @@ error: * 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; @@ -4228,27 +4214,26 @@ ssize_t cmd_snapshot_list_outputs(struct ltt_session *session, /* 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; @@ -4256,7 +4241,8 @@ ssize_t cmd_snapshot_list_outputs(struct ltt_session *session, /* 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; @@ -4281,8 +4267,7 @@ end: * * 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; @@ -4310,7 +4295,7 @@ int check_regenerate_metadata_support(struct ltt_session *session) } } 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; } @@ -4341,8 +4326,7 @@ int cmd_regenerate_metadata(struct ltt_session *session) } 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; @@ -4382,8 +4366,7 @@ int cmd_regenerate_statedump(struct ltt_session *session) } 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. @@ -4417,31 +4400,28 @@ end: 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) { @@ -4452,15 +4432,15 @@ enum lttng_error_code synchronize_tracer_notifier_register( 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; @@ -4473,8 +4453,7 @@ enum lttng_error_code synchronize_tracer_notifier_register( 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); @@ -4505,10 +4484,10 @@ end_unlock_session_list: } 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; @@ -4516,29 +4495,27 @@ enum lttng_error_code cmd_register_trigger(const struct lttng_credentials *cmd_c 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; } @@ -4551,7 +4528,9 @@ enum lttng_error_code cmd_register_trigger(const struct lttng_credentials *cmd_c 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; } @@ -4566,26 +4545,26 @@ enum lttng_error_code cmd_register_trigger(const struct lttng_credentials *cmd_c * 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; } } @@ -4607,20 +4586,17 @@ 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) { @@ -4639,8 +4615,7 @@ enum lttng_error_code synchronize_tracer_notifier_unregister( 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 @@ -4667,8 +4642,8 @@ end_unlock_session_list: } 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; @@ -4682,21 +4657,21 @@ enum lttng_error_code cmd_unregister_trigger(const struct lttng_credentials *cmd 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; } @@ -4704,10 +4679,12 @@ enum lttng_error_code cmd_unregister_trigger(const struct lttng_credentials *cmd /* 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; } @@ -4724,11 +4701,12 @@ enum lttng_error_code cmd_unregister_trigger(const struct lttng_credentials *cmd */ 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; } @@ -4744,7 +4722,6 @@ enum lttng_error_code cmd_unregister_trigger(const struct lttng_credentials *cmd ERR("Error unregistering trigger to tracer."); goto end; } - } end: @@ -4753,8 +4730,8 @@ 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; @@ -4762,7 +4739,7 @@ enum lttng_error_code cmd_list_triggers(struct command_ctx *cmd_ctx, /* 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; } @@ -4781,10 +4758,11 @@ 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; @@ -4800,12 +4778,10 @@ enum lttng_error_code cmd_execute_error_query(const struct lttng_credentials *cm 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(); @@ -4813,8 +4789,8 @@ enum lttng_error_code cmd_execute_error_query(const struct lttng_credentials *cm 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; } @@ -4822,19 +4798,15 @@ enum lttng_error_code cmd_execute_error_query(const struct lttng_credentials *cm /* 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(); @@ -4844,21 +4816,22 @@ enum lttng_error_code cmd_execute_error_query(const struct lttng_credentials *cm } 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; } @@ -4866,8 +4839,7 @@ enum lttng_error_code cmd_execute_error_query(const struct lttng_credentials *cm 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: @@ -4880,8 +4852,8 @@ enum lttng_error_code cmd_execute_error_query(const struct lttng_credentials *cm 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: @@ -4896,8 +4868,7 @@ enum lttng_error_code cmd_execute_error_query(const struct lttng_credentials *cm 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: @@ -4929,9 +4900,8 @@ end: * * 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; @@ -4945,10 +4915,8 @@ static enum lttng_error_code set_relayd_for_snapshot( 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; @@ -4979,17 +4947,19 @@ static enum lttng_error_code set_relayd_for_snapshot( * 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(); @@ -5007,11 +4977,10 @@ error: * * 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; @@ -5019,8 +4988,7 @@ static enum lttng_error_code record_kernel_snapshot( 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; } @@ -5030,9 +4998,9 @@ static enum lttng_error_code record_kernel_snapshot( * 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; @@ -5040,23 +5008,20 @@ static enum lttng_error_code record_ust_snapshot(struct ltt_ust_session *usess, 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 @@ -5064,16 +5029,14 @@ uint64_t get_session_size_one_more_packet_per_stream( */ 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; @@ -5099,23 +5062,22 @@ uint64_t get_session_size_one_more_packet_per_stream( * 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; @@ -5133,9 +5095,8 @@ int64_t get_session_nb_packets_per_stream(const struct ltt_session *session, 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]; @@ -5147,19 +5108,21 @@ enum lttng_error_code snapshot_record(struct ltt_session *session, 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; @@ -5167,70 +5130,60 @@ enum lttng_error_code snapshot_record(struct ltt_session *session, } 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; } @@ -5240,13 +5193,13 @@ enum lttng_error_code snapshot_record(struct ltt_session *session, 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; @@ -5254,8 +5207,9 @@ enum lttng_error_code snapshot_record(struct ltt_session *session, 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; } @@ -5263,8 +5217,9 @@ enum lttng_error_code snapshot_record(struct ltt_session *session, 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; } @@ -5272,19 +5227,19 @@ enum lttng_error_code snapshot_record(struct ltt_session *session, 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; } @@ -5295,8 +5250,7 @@ error: 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); @@ -5312,8 +5266,8 @@ error: * 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; @@ -5327,8 +5281,7 @@ int cmd_snapshot_record(struct ltt_session *session, 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; @@ -5357,11 +5310,14 @@ int cmd_snapshot_record(struct ltt_session *session, 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; @@ -5385,8 +5341,8 @@ int cmd_snapshot_record(struct ltt_session *session, 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; /* @@ -5401,14 +5357,13 @@ int cmd_snapshot_record(struct ltt_session *session, } 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; @@ -5441,8 +5396,7 @@ 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); @@ -5454,8 +5408,7 @@ int cmd_set_session_shm_path(struct ltt_session *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; @@ -5470,9 +5423,9 @@ int cmd_set_session_shm_path(struct ltt_session *session, * 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; @@ -5496,16 +5449,15 @@ int cmd_rotate_session(struct ltt_session *session, * 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; } @@ -5518,7 +5470,7 @@ int cmd_rotate_session(struct ltt_session *session, 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; } @@ -5529,7 +5481,7 @@ int cmd_rotate_session(struct ltt_session *session, */ 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; } @@ -5540,14 +5492,13 @@ int cmd_rotate_session(struct ltt_session *session, */ 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; @@ -5561,8 +5512,7 @@ int cmd_rotate_session(struct ltt_session *session, * 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; @@ -5589,7 +5539,7 @@ int cmd_rotate_session(struct ltt_session *session, 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; @@ -5599,12 +5549,11 @@ int cmd_rotate_session(struct ltt_session *session, } 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; @@ -5616,8 +5565,7 @@ int cmd_rotate_session(struct ltt_session *session, } 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; @@ -5631,27 +5579,25 @@ int cmd_rotate_session(struct ltt_session *session, 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; } @@ -5664,30 +5610,28 @@ error: * 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; @@ -5697,15 +5641,18 @@ int cmd_rotate_get_info(struct ltt_session *session, 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: { @@ -5715,20 +5662,20 @@ int cmd_rotate_get_info(struct ltt_session *session, 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; @@ -5740,17 +5687,16 @@ int cmd_rotate_get_info(struct ltt_session *session, { 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; @@ -5762,7 +5708,7 @@ int cmd_rotate_get_info(struct ltt_session *session, 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"); @@ -5776,8 +5722,8 @@ int cmd_rotate_get_info(struct ltt_session *session, 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"); @@ -5789,8 +5735,10 @@ int cmd_rotate_get_info(struct ltt_session *session, 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(); @@ -5813,9 +5761,10 @@ end: * 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; @@ -5837,8 +5786,10 @@ int cmd_rotation_set_schedule(struct ltt_session *session, 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; } @@ -5898,16 +5849,14 @@ int cmd_rotation_set_schedule(struct ltt_session *session, * 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; @@ -5917,22 +5866,21 @@ int cmd_rotation_set_schedule(struct ltt_session *session, 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: @@ -5954,7 +5902,7 @@ static enum lttng_error_code wait_on_path(void *path_data) 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; @@ -5970,7 +5918,7 @@ static enum lttng_error_code wait_on_path(void *path_data) } 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; } }