X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=d8d17b59cba2b07956ff7e08bf13c685dfca37da;hp=3cf8c518c9493aefa7a6e650b5b7f2dffaa2047e;hb=64eafdf60552bbd7e22fb1c8fc8fc2b42a3cf68b;hpb=fb9a95c4d6242bd8336b638c90a7d8f846125659 diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index 3cf8c518c..d8d17b59c 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -1,19 +1,9 @@ /* - * Copyright (C) 2012 - David Goulet - * Copyright (C) 2016 - Jérémie Galarneau + * Copyright (C) 2012 David Goulet + * Copyright (C) 2016 Jérémie Galarneau * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License, version 2 only, as - * published by the Free Software Foundation. + * SPDX-License-Identifier: GPL-2.0-only * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for - * more details. - * - * You should have received a copy of the GNU General Public License along with - * this program; if not, write to the Free Software Foundation, Inc., 51 - * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #define _LGPL_SOURCE @@ -22,6 +12,7 @@ #include #include #include +#include #include #include @@ -32,7 +23,10 @@ #include #include #include +#include +#include #include +#include #include #include #include @@ -43,6 +37,8 @@ #include #include #include +#include +#include #include #include "channel.h" @@ -62,12 +58,23 @@ #include "rotation-thread.h" #include "timer.h" #include "agent-thread.h" +#include "tracker.h" #include "cmd.h" /* Sleep for 100ms between each check for the shm path's deletion. */ #define SESSION_DESTROY_SHM_PATH_CHECK_DELAY_US 100000 +struct cmd_destroy_session_reply_context { + int reply_sock_fd; + bool implicit_rotation_on_destroy; + /* + * Indicates whether or not an error occurred while launching the + * destruction of a session. + */ + enum lttng_error_code destruction_status; +}; + static enum lttng_error_code wait_on_path(void *path); /* @@ -100,7 +107,7 @@ static uint64_t relayd_net_seq_idx; static int validate_ust_event_name(const char *); static int cmd_enable_event_internal(struct ltt_session *session, - struct lttng_domain *domain, + const struct lttng_domain *domain, char *channel_name, struct lttng_event *event, char *filter_expression, struct lttng_filter_bytecode *filter, @@ -388,95 +395,69 @@ end: } } -static int increment_extended_len(const char *filter_expression, - struct lttng_event_exclusion *exclusion, - const struct lttng_userspace_probe_location *probe_location, - size_t *extended_len) -{ - int ret = 0; - - *extended_len += sizeof(struct lttcomm_event_extended_header); - - if (filter_expression) { - *extended_len += strlen(filter_expression) + 1; - } - - if (exclusion) { - *extended_len += exclusion->count * LTTNG_SYMBOL_NAME_LEN; - } - - if (probe_location) { - ret = lttng_userspace_probe_location_serialize(probe_location, - NULL, NULL); - if (ret < 0) { - goto end; - } - *extended_len += ret; - } - ret = 0; -end: - return ret; -} - static int append_extended_info(const char *filter_expression, struct lttng_event_exclusion *exclusion, struct lttng_userspace_probe_location *probe_location, - void **extended_at) + struct lttng_payload *payload) { int ret = 0; size_t filter_len = 0; size_t nb_exclusions = 0; size_t userspace_probe_location_len = 0; - struct lttng_dynamic_buffer location_buffer; - struct lttcomm_event_extended_header extended_header; + struct lttcomm_event_extended_header extended_header = {}; + struct lttcomm_event_extended_header *p_extended_header; + const size_t original_payload_size = payload->buffer.size; + + ret = lttng_dynamic_buffer_append(&payload->buffer, &extended_header, + sizeof(extended_header)); + if (ret) { + goto end; + } if (filter_expression) { filter_len = strlen(filter_expression) + 1; + ret = lttng_dynamic_buffer_append(&payload->buffer, + filter_expression, filter_len); + if (ret) { + goto end; + } } if (exclusion) { + const size_t len = exclusion->count * LTTNG_SYMBOL_NAME_LEN; + nb_exclusions = exclusion->count; + + ret = lttng_dynamic_buffer_append( + &payload->buffer, &exclusion->names, len); + if (ret) { + goto end; + } } if (probe_location) { - lttng_dynamic_buffer_init(&location_buffer); + const size_t size_before_probe = payload->buffer.size; + ret = lttng_userspace_probe_location_serialize(probe_location, - &location_buffer, NULL); + payload); if (ret < 0) { ret = -1; goto end; } - userspace_probe_location_len = location_buffer.size; - } - - /* Set header fields */ - extended_header.filter_len = filter_len; - extended_header.nb_exclusions = nb_exclusions; - extended_header.userspace_probe_location_len = userspace_probe_location_len; - - /* Copy header */ - memcpy(*extended_at, &extended_header, sizeof(extended_header)); - *extended_at += sizeof(extended_header); - /* Copy filter string */ - if (filter_expression) { - memcpy(*extended_at, filter_expression, filter_len); - *extended_at += filter_len; + userspace_probe_location_len = + payload->buffer.size - size_before_probe; } - /* Copy exclusion names */ - if (exclusion) { - size_t len = nb_exclusions * LTTNG_SYMBOL_NAME_LEN; + /* Set header fields */ + p_extended_header = (struct lttcomm_event_extended_header *) + (payload->buffer.data + original_payload_size); - memcpy(*extended_at, &exclusion->names, len); - *extended_at += len; - } + p_extended_header->filter_len = filter_len; + p_extended_header->nb_exclusions = nb_exclusions; + p_extended_header->userspace_probe_location_len = + userspace_probe_location_len; - if (probe_location) { - memcpy(*extended_at, location_buffer.data, location_buffer.size); - *extended_at += location_buffer.size; - lttng_dynamic_buffer_reset(&location_buffer); - } ret = 0; end: return ret; @@ -488,89 +469,55 @@ end: * Return number of events in list on success or else a negative value. */ static int list_lttng_agent_events(struct agent *agt, - struct lttng_event **events, size_t *total_size) + struct lttng_payload *payload) { - int i = 0, ret = 0; - unsigned int nb_event = 0; - struct agent_event *event; - struct lttng_event *tmp_events = NULL; + int nb_events = 0, ret = 0; + const struct agent_event *agent_event; struct lttng_ht_iter iter; - size_t extended_len = 0; - void *extended_at; assert(agt); - assert(events); DBG3("Listing agent events"); rcu_read_lock(); - nb_event = lttng_ht_get_count(agt->events); - rcu_read_unlock(); - if (nb_event == 0) { - ret = nb_event; - *total_size = 0; - goto error; - } - - /* Compute required extended infos size */ - extended_len = nb_event * sizeof(struct lttcomm_event_extended_header); - - /* - * This is only valid because the commands which add events are - * processed in the same thread as the listing. - */ - rcu_read_lock(); - cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) { - ret = increment_extended_len(event->filter_expression, NULL, NULL, - &extended_len); + cds_lfht_for_each_entry ( + agt->events->ht, &iter.iter, agent_event, node.node) { + struct lttng_event event = { + .enabled = agent_event->enabled, + .loglevel = agent_event->loglevel_value, + .loglevel_type = agent_event->loglevel_type, + }; + + strncpy(event.name, agent_event->name, sizeof(event.name)); + event.name[sizeof(event.name) - 1] = '\0'; + + ret = lttng_dynamic_buffer_append( + &payload->buffer, &event, sizeof(event)); if (ret) { - DBG("Error computing the length of extended info message"); - ret = -LTTNG_ERR_FATAL; - goto error; + ERR("Failed to append event to payload"); + ret = -LTTNG_ERR_NOMEM; + goto end; } - } - rcu_read_unlock(); - *total_size = nb_event * sizeof(*tmp_events) + extended_len; - tmp_events = zmalloc(*total_size); - if (!tmp_events) { - PERROR("zmalloc agent events session"); - ret = -LTTNG_ERR_FATAL; - goto error; + nb_events++; } - extended_at = ((uint8_t *) tmp_events) + - nb_event * sizeof(struct lttng_event); - - rcu_read_lock(); - cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) { - strncpy(tmp_events[i].name, event->name, sizeof(tmp_events[i].name)); - tmp_events[i].name[sizeof(tmp_events[i].name) - 1] = '\0'; - tmp_events[i].enabled = event->enabled; - tmp_events[i].loglevel = event->loglevel_value; - tmp_events[i].loglevel_type = event->loglevel_type; - i++; - - /* Append extended info */ - ret = append_extended_info(event->filter_expression, NULL, NULL, - &extended_at); + cds_lfht_for_each_entry ( + agt->events->ht, &iter.iter, agent_event, node.node) { + /* Append extended info. */ + ret = append_extended_info(agent_event->filter_expression, NULL, + NULL, payload); if (ret) { - DBG("Error appending extended info message"); - ret = -LTTNG_ERR_FATAL; - goto error; + ERR("Failed to append extended event info to payload"); + ret = -LTTNG_ERR_NOMEM; + goto end; } } - *events = tmp_events; - ret = nb_event; - assert(nb_event == i); - + ret = nb_events; end: rcu_read_unlock(); return ret; -error: - free(tmp_events); - goto end; } /* @@ -578,23 +525,20 @@ error: */ static int list_lttng_ust_global_events(char *channel_name, struct ltt_ust_domain_global *ust_global, - struct lttng_event **events, size_t *total_size) + struct lttng_payload *payload) { - int i = 0, ret = 0; - unsigned int nb_event = 0; + int ret = 0; + unsigned int nb_events = 0; struct lttng_ht_iter iter; - struct lttng_ht_node_str *node; - struct ltt_ust_channel *uchan; - struct ltt_ust_event *uevent; - struct lttng_event *tmp; - size_t extended_len = 0; - void *extended_at; + const struct lttng_ht_node_str *node; + const struct ltt_ust_channel *uchan; + const struct ltt_ust_event *uevent; DBG("Listing UST global events for channel %s", channel_name); rcu_read_lock(); - lttng_ht_lookup(ust_global->channels, (void *)channel_name, &iter); + lttng_ht_lookup(ust_global->channels, (void *) channel_name, &iter); node = lttng_ht_iter_get_node_str(&iter); if (node == NULL) { ret = LTTNG_ERR_UST_CHAN_NOT_FOUND; @@ -603,99 +547,75 @@ static int list_lttng_ust_global_events(char *channel_name, uchan = caa_container_of(&node->node, struct ltt_ust_channel, node.node); - nb_event = lttng_ht_get_count(uchan->events); - if (nb_event == 0) { - ret = nb_event; - *total_size = 0; - goto end; - } + DBG3("Listing UST global events"); - DBG3("Listing UST global %d events", nb_event); - - /* Compute required extended infos size */ cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) { + struct lttng_event event = {}; + if (uevent->internal) { - nb_event--; continue; } - ret = increment_extended_len(uevent->filter_expression, - uevent->exclusion, NULL, &extended_len); - if (ret) { - DBG("Error computing the length of extended info message"); - ret = -LTTNG_ERR_FATAL; - goto end; - } - } - if (nb_event == 0) { - /* All events are internal, skip. */ - ret = 0; - *total_size = 0; - goto end; - } - - *total_size = nb_event * sizeof(struct lttng_event) + extended_len; - tmp = zmalloc(*total_size); - if (tmp == NULL) { - ret = -LTTNG_ERR_FATAL; - goto end; - } - - extended_at = ((uint8_t *) tmp) + nb_event * sizeof(struct lttng_event); + strncpy(event.name, uevent->attr.name, sizeof(event.name)); + event.name[sizeof(event.name) - 1] = '\0'; - cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) { - if (uevent->internal) { - /* This event should remain hidden from clients */ - continue; - } - strncpy(tmp[i].name, uevent->attr.name, LTTNG_SYMBOL_NAME_LEN); - tmp[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; - tmp[i].enabled = uevent->enabled; + event.enabled = uevent->enabled; switch (uevent->attr.instrumentation) { case LTTNG_UST_TRACEPOINT: - tmp[i].type = LTTNG_EVENT_TRACEPOINT; + event.type = LTTNG_EVENT_TRACEPOINT; break; case LTTNG_UST_PROBE: - tmp[i].type = LTTNG_EVENT_PROBE; + event.type = LTTNG_EVENT_PROBE; break; case LTTNG_UST_FUNCTION: - tmp[i].type = LTTNG_EVENT_FUNCTION; + event.type = LTTNG_EVENT_FUNCTION; break; } - tmp[i].loglevel = uevent->attr.loglevel; + event.loglevel = uevent->attr.loglevel; switch (uevent->attr.loglevel_type) { case LTTNG_UST_LOGLEVEL_ALL: - tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL; + event.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL; break; case LTTNG_UST_LOGLEVEL_RANGE: - tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE; + event.loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE; break; case LTTNG_UST_LOGLEVEL_SINGLE: - tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE; + event.loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE; break; } + if (uevent->filter) { - tmp[i].filter = 1; + event.filter = 1; } + if (uevent->exclusion) { - tmp[i].exclusion = 1; + event.exclusion = 1; } - i++; - /* Append extended info */ + ret = lttng_dynamic_buffer_append(&payload->buffer, &event, sizeof(event)); + if (ret) { + ERR("Failed to append event to payload"); + ret = -LTTNG_ERR_NOMEM; + goto end; + } + + nb_events++; + } + + cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) { + /* Append extended info. */ ret = append_extended_info(uevent->filter_expression, - uevent->exclusion, NULL, &extended_at); + uevent->exclusion, NULL, payload); if (ret) { - DBG("Error appending extended info message"); + ERR("Failed to append extended event info to payload"); ret = -LTTNG_ERR_FATAL; goto end; } } - ret = nb_event; - *events = tmp; + ret = nb_events; end: rcu_read_unlock(); return ret; @@ -706,14 +626,12 @@ end: */ static int list_lttng_kernel_events(char *channel_name, struct ltt_kernel_session *kernel_session, - struct lttng_event **events, size_t *total_size) + struct lttng_payload *payload) { - int i = 0, ret; + int ret; unsigned int nb_event; - struct ltt_kernel_event *event; - struct ltt_kernel_channel *kchan; - size_t extended_len = 0; - void *extended_at; + const struct ltt_kernel_event *kevent; + const struct ltt_kernel_channel *kchan; kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session); if (kchan == NULL) { @@ -725,69 +643,42 @@ static int list_lttng_kernel_events(char *channel_name, DBG("Listing events for channel %s", kchan->channel->name); - if (nb_event == 0) { - *total_size = 0; - *events = NULL; - goto end; - } - - /* Compute required extended infos size */ - cds_list_for_each_entry(event, &kchan->events_list.head, list) { - ret = increment_extended_len(event->filter_expression, NULL, - event->userspace_probe_location, - &extended_len); - if (ret) { - DBG("Error computing the length of extended info message"); - ret = -LTTNG_ERR_FATAL; - goto error; - } - } - - *total_size = nb_event * sizeof(struct lttng_event) + extended_len; - *events = zmalloc(*total_size); - if (*events == NULL) { - ret = -LTTNG_ERR_FATAL; - goto error; - } + /* Kernel channels */ + cds_list_for_each_entry(kevent, &kchan->events_list.head , list) { + struct lttng_event event = {}; - extended_at = ((void *) *events) + - nb_event * sizeof(struct lttng_event); + strncpy(event.name, kevent->event->name, sizeof(event.name)); + event.name[sizeof(event.name) - 1] = '\0'; + event.enabled = kevent->enabled; + event.filter = (unsigned char) !!kevent->filter_expression; - /* Kernel channels */ - cds_list_for_each_entry(event, &kchan->events_list.head , list) { - strncpy((*events)[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN); - (*events)[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; - (*events)[i].enabled = event->enabled; - (*events)[i].filter = - (unsigned char) !!event->filter_expression; - - switch (event->event->instrumentation) { + switch (kevent->event->instrumentation) { case LTTNG_KERNEL_TRACEPOINT: - (*events)[i].type = LTTNG_EVENT_TRACEPOINT; + event.type = LTTNG_EVENT_TRACEPOINT; break; case LTTNG_KERNEL_KRETPROBE: - (*events)[i].type = LTTNG_EVENT_FUNCTION; - memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe, + event.type = LTTNG_EVENT_FUNCTION; + memcpy(&event.attr.probe, &kevent->event->u.kprobe, sizeof(struct lttng_kernel_kprobe)); break; case LTTNG_KERNEL_KPROBE: - (*events)[i].type = LTTNG_EVENT_PROBE; - memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe, + event.type = LTTNG_EVENT_PROBE; + memcpy(&event.attr.probe, &kevent->event->u.kprobe, sizeof(struct lttng_kernel_kprobe)); break; case LTTNG_KERNEL_UPROBE: - (*events)[i].type = LTTNG_EVENT_USERSPACE_PROBE; + event.type = LTTNG_EVENT_USERSPACE_PROBE; break; case LTTNG_KERNEL_FUNCTION: - (*events)[i].type = LTTNG_EVENT_FUNCTION; - memcpy(&((*events)[i].attr.ftrace), &event->event->u.ftrace, + event.type = LTTNG_EVENT_FUNCTION; + memcpy(&event.attr.ftrace, &kevent->event->u.ftrace, sizeof(struct lttng_kernel_function)); break; case LTTNG_KERNEL_NOOP: - (*events)[i].type = LTTNG_EVENT_NOOP; + event.type = LTTNG_EVENT_NOOP; break; case LTTNG_KERNEL_SYSCALL: - (*events)[i].type = LTTNG_EVENT_SYSCALL; + event.type = LTTNG_EVENT_SYSCALL; break; case LTTNG_KERNEL_ALL: /* fall-through. */ @@ -795,11 +686,20 @@ static int list_lttng_kernel_events(char *channel_name, assert(0); break; } - i++; - /* Append extended info */ - ret = append_extended_info(event->filter_expression, NULL, - event->userspace_probe_location, &extended_at); + ret = lttng_dynamic_buffer_append( + &payload->buffer, &event, sizeof(event)); + if (ret) { + ERR("Failed to append event to payload"); + ret = -LTTNG_ERR_NOMEM; + goto end; + } + } + + cds_list_for_each_entry(kevent, &kchan->events_list.head , list) { + /* Append extended info. */ + ret = append_extended_info(kevent->filter_expression, NULL, + kevent->userspace_probe_location, payload); if (ret) { DBG("Error appending extended info message"); ret = -LTTNG_ERR_FATAL; @@ -809,10 +709,8 @@ static int list_lttng_kernel_events(char *channel_name, end: return nb_event; - error: - /* Negate the error code to differentiate the size from an error */ - return -ret; + return ret; } /* @@ -905,6 +803,10 @@ static enum lttng_error_code add_uri_to_consumer( ret = lttng_strncpy(consumer->dst.session_root_path, uri->dst.path, sizeof(consumer->dst.session_root_path)); + if (ret) { + ret_code = LTTNG_ERR_FATAL; + goto error; + } consumer->type = CONSUMER_DST_LOCAL; break; } @@ -982,6 +884,8 @@ static enum lttng_error_code create_connect_relayd(struct lttng_uri *uri, /* Create socket for control stream. */ if (uri->stype == LTTNG_STREAM_CONTROL) { + uint64_t result_flags; + DBG3("Creating relayd stream socket from URI"); /* Check relayd version */ @@ -996,6 +900,16 @@ 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); + if (ret < 0) { + ERR("Unable to get relayd configuration"); + status = LTTNG_ERR_RELAYD_CONNECT_FAIL; + goto close_sock; + } + if (result_flags & LTTCOMM_RELAYD_CONFIGURATION_FLAG_CLEAR_ALLOWED) { + consumer->relay_allows_clear = true; + } } else if (uri->stype == LTTNG_STREAM_DATA) { DBG3("Creating relayd data socket from URI"); } else { @@ -1031,7 +945,10 @@ static enum lttng_error_code send_consumer_relayd_socket( struct consumer_output *consumer, struct consumer_socket *consumer_sock, const char *session_name, const char *hostname, - int session_live_timer) + 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; @@ -1059,7 +976,9 @@ 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, session_live_timer); + 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; @@ -1106,7 +1025,9 @@ static enum lttng_error_code send_consumer_relayd_sockets( enum lttng_domain_type domain, unsigned int session_id, struct consumer_output *consumer, struct consumer_socket *sock, const char *session_name, - const char *hostname, int session_live_timer) + 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; @@ -1117,7 +1038,9 @@ static enum lttng_error_code send_consumer_relayd_sockets( if (!sock->control_sock_sent) { status = send_consumer_relayd_socket(session_id, &consumer->dst.net.control, consumer, sock, - session_name, hostname, session_live_timer); + 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; } @@ -1127,7 +1050,9 @@ static enum lttng_error_code send_consumer_relayd_sockets( if (!sock->data_sock_sent) { status = send_consumer_relayd_socket(session_id, &consumer->dst.net.data, consumer, sock, - session_name, hostname, session_live_timer); + 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; } @@ -1149,6 +1074,7 @@ int cmd_setup_relayd(struct ltt_session *session) struct ltt_kernel_session *ksess; struct consumer_socket *socket; struct lttng_ht_iter iter; + LTTNG_OPTIONAL(uint64_t) current_chunk_id = {}; assert(session); @@ -1158,6 +1084,18 @@ int cmd_setup_relayd(struct ltt_session *session) DBG("Setting relayd for session %s", session->name); rcu_read_lock(); + if (session->current_trace_chunk) { + enum lttng_trace_chunk_status status = lttng_trace_chunk_get_id( + session->current_trace_chunk, ¤t_chunk_id.value); + + if (status == LTTNG_TRACE_CHUNK_STATUS_OK) { + current_chunk_id.is_set = true; + } else { + ERR("Failed to get current trace chunk id"); + ret = LTTNG_ERR_UNK; + goto error; + } + } if (usess && usess->consumer && usess->consumer->type == CONSUMER_DST_NET && usess->consumer->enabled) { @@ -1168,7 +1106,11 @@ int cmd_setup_relayd(struct ltt_session *session) ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_UST, session->id, usess->consumer, socket, session->name, session->hostname, - session->live_timer); + 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; @@ -1180,6 +1122,8 @@ int cmd_setup_relayd(struct ltt_session *session) 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 @@ -1190,7 +1134,11 @@ int cmd_setup_relayd(struct ltt_session *session) ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_KERNEL, session->id, ksess->consumer, socket, session->name, session->hostname, - session->live_timer); + 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; @@ -1202,6 +1150,8 @@ int cmd_setup_relayd(struct ltt_session *session) 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: @@ -1212,7 +1162,7 @@ error: /* * Start a kernel session by opening all necessary streams. */ -static int start_kernel_session(struct ltt_kernel_session *ksess, int wpipe) +int start_kernel_session(struct ltt_kernel_session *ksess) { int ret; struct ltt_kernel_channel *kchan; @@ -1264,7 +1214,7 @@ static int start_kernel_session(struct ltt_kernel_session *ksess, int wpipe) } /* Quiescent wait after starting trace */ - kernel_wait_quiescent(wpipe); + kernel_wait_quiescent(); ksess->active = 1; @@ -1274,6 +1224,53 @@ error: return ret; } +int stop_kernel_session(struct ltt_kernel_session *ksess) +{ + struct ltt_kernel_channel *kchan; + bool error_occurred = false; + int ret; + + if (!ksess || !ksess->active) { + return LTTNG_OK; + } + DBG("Stopping kernel tracing"); + + ret = kernel_stop_session(ksess); + if (ret < 0) { + ret = LTTNG_ERR_KERN_STOP_FAIL; + goto error; + } + + kernel_wait_quiescent(); + + /* Flush metadata after stopping (if exists) */ + if (ksess->metadata_stream_fd >= 0) { + ret = kernel_metadata_flush_buffer(ksess->metadata_stream_fd); + if (ret < 0) { + ERR("Kernel metadata flush failed"); + error_occurred = true; + } + } + + /* Flush all buffers after stopping */ + cds_list_for_each_entry(kchan, &ksess->channel_list.head, list) { + ret = kernel_flush_buffer(kchan); + if (ret < 0) { + ERR("Kernel flush buffer error"); + error_occurred = true; + } + } + + ksess->active = 0; + if (error_occurred) { + ret = LTTNG_ERR_UNK; + } else { + ret = LTTNG_OK; + } +error: + return ret; +} + /* * Command LTTNG_DISABLE_CHANNEL processed by the client thread. */ @@ -1296,7 +1293,7 @@ int cmd_disable_channel(struct ltt_session *session, goto error; } - kernel_wait_quiescent(kernel_tracer_fd); + kernel_wait_quiescent(); break; } case LTTNG_DOMAIN_UST: @@ -1331,201 +1328,101 @@ error: } /* - * Command LTTNG_TRACK_PID processed by the client thread. + * Command LTTNG_ENABLE_CHANNEL processed by the client thread. * - * Called with session lock held. + * The wpipe arguments is used as a notifier for the kernel thread. */ -int cmd_track_pid(struct ltt_session *session, enum lttng_domain_type domain, - int pid) +int cmd_enable_channel(struct ltt_session *session, + const struct lttng_domain *domain, const struct lttng_channel *_attr, int wpipe) { int ret; + struct ltt_ust_session *usess = session->ust_session; + struct lttng_ht *chan_ht; + size_t len; + struct lttng_channel attr; + + assert(session); + assert(_attr); + assert(domain); + + attr = *_attr; + len = lttng_strnlen(attr.name, sizeof(attr.name)); + + /* Validate channel name */ + if (attr.name[0] == '.' || + memchr(attr.name, '/', len) != NULL) { + ret = LTTNG_ERR_INVALID_CHANNEL_NAME; + goto end; + } + + DBG("Enabling channel %s for session %s", attr.name, session->name); rcu_read_lock(); - switch (domain) { - case LTTNG_DOMAIN_KERNEL: - { - struct ltt_kernel_session *ksess; + /* + * Don't try to enable a channel if the session has been started at + * some point in time before. The tracer does not allow it. + */ + if (session->has_been_started) { + ret = LTTNG_ERR_TRACE_ALREADY_STARTED; + goto error; + } - ksess = session->kernel_session; + /* + * If the session is a live session, remove the switch timer, the + * live timer does the same thing but sends also synchronisation + * beacons for inactive streams. + */ + if (session->live_timer > 0) { + attr.attr.live_timer_interval = session->live_timer; + attr.attr.switch_timer_interval = 0; + } - ret = kernel_track_pid(ksess, pid); - if (ret != LTTNG_OK) { - goto error; + /* Check for feature support */ + switch (domain->type) { + case LTTNG_DOMAIN_KERNEL: + { + 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); + lttng_channel_set_monitor_timer_interval(&attr, 0); } - - kernel_wait_quiescent(kernel_tracer_fd); break; } case LTTNG_DOMAIN_UST: - { - struct ltt_ust_session *usess; - - usess = session->ust_session; - - ret = trace_ust_track_pid(usess, pid); - if (ret != LTTNG_OK) { + break; + case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_LOG4J: + case LTTNG_DOMAIN_PYTHON: + if (!agent_tracing_is_enabled()) { + DBG("Attempted to enable a channel in an agent domain but the agent thread is not running"); + ret = LTTNG_ERR_AGENT_TRACING_DISABLED; goto error; } break; - } default: ret = LTTNG_ERR_UNKNOWN_DOMAIN; goto error; } - ret = LTTNG_OK; - -error: - rcu_read_unlock(); - return ret; -} + switch (domain->type) { + case LTTNG_DOMAIN_KERNEL: + { + struct ltt_kernel_channel *kchan; -/* - * Command LTTNG_UNTRACK_PID processed by the client thread. - * - * Called with session lock held. - */ -int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain, - int pid) -{ - int ret; - - rcu_read_lock(); - - switch (domain) { - case LTTNG_DOMAIN_KERNEL: - { - struct ltt_kernel_session *ksess; - - ksess = session->kernel_session; - - ret = kernel_untrack_pid(ksess, pid); - if (ret != LTTNG_OK) { - goto error; - } - - kernel_wait_quiescent(kernel_tracer_fd); - break; - } - case LTTNG_DOMAIN_UST: - { - struct ltt_ust_session *usess; - - usess = session->ust_session; - - ret = trace_ust_untrack_pid(usess, pid); - if (ret != LTTNG_OK) { - goto error; - } - break; - } - default: - ret = LTTNG_ERR_UNKNOWN_DOMAIN; - goto error; - } - - ret = LTTNG_OK; - -error: - rcu_read_unlock(); - return ret; -} - -/* - * Command LTTNG_ENABLE_CHANNEL processed by the client thread. - * - * The wpipe arguments is used as a notifier for the kernel thread. - */ -int cmd_enable_channel(struct ltt_session *session, - struct lttng_domain *domain, struct lttng_channel *attr, int wpipe) -{ - int ret; - struct ltt_ust_session *usess = session->ust_session; - struct lttng_ht *chan_ht; - size_t len; - - assert(session); - assert(attr); - assert(domain); - - len = lttng_strnlen(attr->name, sizeof(attr->name)); - - /* Validate channel name */ - if (attr->name[0] == '.' || - memchr(attr->name, '/', len) != NULL) { - ret = LTTNG_ERR_INVALID_CHANNEL_NAME; - goto end; - } - - DBG("Enabling channel %s for session %s", attr->name, session->name); - - rcu_read_lock(); - - /* - * Don't try to enable a channel if the session has been started at - * some point in time before. The tracer does not allow it. - */ - if (session->has_been_started) { - ret = LTTNG_ERR_TRACE_ALREADY_STARTED; - goto error; - } - - /* - * If the session is a live session, remove the switch timer, the - * live timer does the same thing but sends also synchronisation - * beacons for inactive streams. - */ - if (session->live_timer > 0) { - attr->attr.live_timer_interval = session->live_timer; - attr->attr.switch_timer_interval = 0; - } - - /* Check for feature support */ - switch (domain->type) { - case LTTNG_DOMAIN_KERNEL: - { - if (kernel_supports_ring_buffer_snapshot_sample_positions(kernel_tracer_fd) != 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); - lttng_channel_set_monitor_timer_interval(attr, 0); - } - break; - } - case LTTNG_DOMAIN_UST: - break; - case LTTNG_DOMAIN_JUL: - case LTTNG_DOMAIN_LOG4J: - case LTTNG_DOMAIN_PYTHON: - if (!agent_tracing_is_enabled()) { - DBG("Attempted to enable a channel in an agent domain but the agent thread is not running"); - ret = LTTNG_ERR_AGENT_TRACING_DISABLED; - goto error; - } - break; - default: - ret = LTTNG_ERR_UNKNOWN_DOMAIN; - goto error; - } - - switch (domain->type) { - case LTTNG_DOMAIN_KERNEL: - { - struct ltt_kernel_channel *kchan; - - kchan = trace_kernel_get_channel_by_name(attr->name, + kchan = trace_kernel_get_channel_by_name(attr.name, session->kernel_session); if (kchan == NULL) { if (session->snapshot.nb_output > 0 || session->snapshot_mode) { /* Enforce mmap output for snapshot sessions. */ - attr->attr.output = LTTNG_EVENT_MMAP; + attr.attr.output = LTTNG_EVENT_MMAP; } - ret = channel_kernel_create(session->kernel_session, attr, wpipe); - if (attr->name[0] != '\0') { + ret = channel_kernel_create(session->kernel_session, &attr, wpipe); + if (attr.name[0] != '\0') { session->kernel_session->has_non_default_channel = 1; } } else { @@ -1536,7 +1433,7 @@ int cmd_enable_channel(struct ltt_session *session, goto error; } - kernel_wait_quiescent(kernel_tracer_fd); + kernel_wait_quiescent(); break; } case LTTNG_DOMAIN_UST: @@ -1555,19 +1452,19 @@ int cmd_enable_channel(struct ltt_session *session, * adhered to. */ if (domain->type == LTTNG_DOMAIN_JUL) { - if (strncmp(attr->name, DEFAULT_JUL_CHANNEL_NAME, + if (strncmp(attr.name, DEFAULT_JUL_CHANNEL_NAME, LTTNG_SYMBOL_NAME_LEN)) { ret = LTTNG_ERR_INVALID_CHANNEL_NAME; goto error; } } else if (domain->type == LTTNG_DOMAIN_LOG4J) { - if (strncmp(attr->name, DEFAULT_LOG4J_CHANNEL_NAME, + if (strncmp(attr.name, DEFAULT_LOG4J_CHANNEL_NAME, LTTNG_SYMBOL_NAME_LEN)) { ret = LTTNG_ERR_INVALID_CHANNEL_NAME; goto error; } } else if (domain->type == LTTNG_DOMAIN_PYTHON) { - if (strncmp(attr->name, DEFAULT_PYTHON_CHANNEL_NAME, + if (strncmp(attr.name, DEFAULT_PYTHON_CHANNEL_NAME, LTTNG_SYMBOL_NAME_LEN)) { ret = LTTNG_ERR_INVALID_CHANNEL_NAME; goto error; @@ -1576,10 +1473,10 @@ int cmd_enable_channel(struct ltt_session *session, chan_ht = usess->domain_global.channels; - uchan = trace_ust_find_channel_by_name(chan_ht, attr->name); + uchan = trace_ust_find_channel_by_name(chan_ht, attr.name); if (uchan == NULL) { - ret = channel_ust_create(usess, attr, domain->buf_type); - if (attr->name[0] != '\0') { + ret = channel_ust_create(usess, &attr, domain->buf_type); + if (attr.name[0] != '\0') { usess->has_non_default_channel = 1; } } else { @@ -1592,7 +1489,7 @@ int cmd_enable_channel(struct ltt_session *session, goto error; } - if (ret == LTTNG_OK && attr->attr.output != LTTNG_EVENT_MMAP) { + if (ret == LTTNG_OK && attr.attr.output != LTTNG_EVENT_MMAP) { session->has_non_mmap_channel = true; } error: @@ -1601,15 +1498,220 @@ end: return ret; } +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; + + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + if (!session->kernel_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + 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); + break; + default: + ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN; + goto end; + } + if (tracker) { + *policy = process_attr_tracker_get_tracking_policy(tracker); + } else { + ret_code = LTTNG_ERR_INVALID; + } +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 ret_code = LTTNG_OK; + + switch (policy) { + case LTTNG_TRACKING_POLICY_INCLUDE_SET: + case LTTNG_TRACKING_POLICY_EXCLUDE_ALL: + case LTTNG_TRACKING_POLICY_INCLUDE_ALL: + break; + default: + ret_code = LTTNG_ERR_INVALID; + goto end; + } + + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + if (!session->kernel_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + ret_code = kernel_process_attr_tracker_set_tracking_policy( + session->kernel_session, process_attr, policy); + break; + case LTTNG_DOMAIN_UST: + if (!session->ust_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + ret_code = trace_ust_process_attr_tracker_set_tracking_policy( + session->ust_session, process_attr, policy); + break; + default: + ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN; + break; + } +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 ret_code = LTTNG_OK; + + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + if (!session->kernel_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + ret_code = kernel_process_attr_tracker_inclusion_set_add_value( + session->kernel_session, process_attr, value); + break; + case LTTNG_DOMAIN_UST: + if (!session->ust_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + ret_code = trace_ust_process_attr_tracker_inclusion_set_add_value( + session->ust_session, process_attr, value); + break; + default: + ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN; + break; + } +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 ret_code = LTTNG_OK; + + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + if (!session->kernel_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + ret_code = kernel_process_attr_tracker_inclusion_set_remove_value( + session->kernel_session, process_attr, value); + break; + case LTTNG_DOMAIN_UST: + if (!session->ust_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + ret_code = trace_ust_process_attr_tracker_inclusion_set_remove_value( + session->ust_session, process_attr, value); + break; + default: + ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN; + break; + } +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 ret_code = LTTNG_OK; + const struct process_attr_tracker *tracker; + enum process_attr_tracker_status status; + + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + if (!session->kernel_session) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + 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); + break; + default: + ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN; + goto end; + } + + if (!tracker) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + + status = process_attr_tracker_get_inclusion_set(tracker, values); + switch (status) { + case PROCESS_ATTR_TRACKER_STATUS_OK: + ret_code = LTTNG_OK; + break; + case PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY: + ret_code = LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY; + break; + case PROCESS_ATTR_TRACKER_STATUS_ERROR: + ret_code = LTTNG_ERR_NOMEM; + break; + default: + ret_code = LTTNG_ERR_UNK; + break; + } + +end: + return ret_code; +} + /* * Command LTTNG_DISABLE_EVENT processed by the client thread. */ int cmd_disable_event(struct ltt_session *session, - enum lttng_domain_type domain, char *channel_name, - struct lttng_event *event) + enum lttng_domain_type domain, const char *channel_name, + const struct lttng_event *event) { int ret; - char *event_name; + const char *event_name; DBG("Disable event command for event \'%s\'", event->name); @@ -1671,7 +1773,7 @@ int cmd_disable_event(struct ltt_session *session, goto error_unlock; } - kernel_wait_quiescent(kernel_tracer_fd); + kernel_wait_quiescent(); break; } case LTTNG_DOMAIN_UST: @@ -1782,7 +1884,7 @@ error: * Command LTTNG_ADD_CONTEXT processed by the client thread. */ int cmd_add_context(struct ltt_session *session, enum lttng_domain_type domain, - char *channel_name, struct lttng_event_context *ctx, int kwpipe) + char *channel_name, const struct lttng_event_context *ctx, int kwpipe) { int ret, chan_kern_created = 0, chan_ust_created = 0; char *app_ctx_provider_name = NULL, *app_ctx_name = NULL; @@ -1953,7 +2055,7 @@ end: * enable the events through which all "agent" events are funeled. */ static int _cmd_enable_event(struct ltt_session *session, - struct lttng_domain *domain, + const struct lttng_domain *domain, char *channel_name, struct lttng_event *event, char *filter_expression, struct lttng_filter_bytecode *filter, @@ -2121,7 +2223,7 @@ static int _cmd_enable_event(struct ltt_session *session, goto error; } - kernel_wait_quiescent(kernel_tracer_fd); + kernel_wait_quiescent(); break; } case LTTNG_DOMAIN_UST: @@ -2186,7 +2288,7 @@ 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.", + WARN("Userspace event name %s failed validation.", event->name); ret = LTTNG_ERR_INVALID_EVENT_NAME; goto error; @@ -2350,7 +2452,8 @@ error: * Command LTTNG_ENABLE_EVENT processed by the client thread. * We own filter, exclusion, and filter_expression. */ -int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, +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_filter_bytecode *filter, @@ -2367,7 +2470,7 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, * reserved names. */ static int cmd_enable_event_internal(struct ltt_session *session, - struct lttng_domain *domain, + const struct lttng_domain *domain, char *channel_name, struct lttng_event *event, char *filter_expression, struct lttng_filter_bytecode *filter, @@ -2389,7 +2492,7 @@ ssize_t cmd_list_tracepoints(enum lttng_domain_type domain, switch (domain) { case LTTNG_DOMAIN_KERNEL: - nb_events = kernel_list_events(kernel_tracer_fd, events); + nb_events = kernel_list_events(events); if (nb_events < 0) { ret = LTTNG_ERR_KERN_LIST_FAIL; goto error; @@ -2459,119 +2562,20 @@ ssize_t cmd_list_syscalls(struct lttng_event **events) } /* - * Command LTTNG_LIST_TRACKER_PIDS processed by the client thread. + * Command LTTNG_START_TRACE processed by the client thread. * - * Called with session lock held. + * Called with session mutex held. */ -ssize_t cmd_list_tracker_pids(struct ltt_session *session, - enum lttng_domain_type domain, int32_t **pids) -{ - int ret; - ssize_t nr_pids = 0; - - switch (domain) { - case LTTNG_DOMAIN_KERNEL: - { - struct ltt_kernel_session *ksess; - - ksess = session->kernel_session; - nr_pids = kernel_list_tracker_pids(ksess, pids); - if (nr_pids < 0) { - ret = LTTNG_ERR_KERN_LIST_FAIL; - goto error; - } - break; - } - case LTTNG_DOMAIN_UST: - { - struct ltt_ust_session *usess; - - usess = session->ust_session; - nr_pids = trace_ust_list_tracker_pids(usess, pids); - if (nr_pids < 0) { - ret = LTTNG_ERR_UST_LIST_FAIL; - goto error; - } - break; - } - case LTTNG_DOMAIN_LOG4J: - case LTTNG_DOMAIN_JUL: - case LTTNG_DOMAIN_PYTHON: - default: - ret = LTTNG_ERR_UND; - goto error; - } - - return nr_pids; - -error: - /* Return negative value to differentiate return code */ - return -ret; -} - -static -int domain_mkdir(const struct consumer_output *output, - const struct ltt_session *session, - uid_t uid, gid_t gid) -{ - struct consumer_socket *socket; - struct lttng_ht_iter iter; - int ret; - char path[LTTNG_PATH_MAX]; - - if (!output || !output->socks) { - ERR("No consumer output found"); - ret = -1; - goto end; - } - - ret = snprintf(path, sizeof(path), "%s/%s%s", - session_get_base_path(session), - output->chunk_path, - output->domain_subdir); - if (ret < 0 || ret >= LTTNG_PATH_MAX) { - ERR("Failed to format path new chunk domain path"); - ret = -1; - goto end; - } - - DBG("Domain mkdir %s for session %" PRIu64, path, session->id); - rcu_read_lock(); - /* - * We have to iterate to find a socket, but we only need to send the - * rename command to one consumer, so we break after the first one. - */ - cds_lfht_for_each_entry(output->socks->ht, &iter.iter, socket, node.node) { - pthread_mutex_lock(socket->lock); - ret = consumer_mkdir(socket, session->id, output, path, uid, gid); - pthread_mutex_unlock(socket->lock); - if (ret) { - ERR("Failed to create directory at \"%s\"", path); - ret = -1; - goto end_unlock; - } - break; - } - - ret = 0; - -end_unlock: - rcu_read_unlock(); -end: - return ret; -} - -/* - * Command LTTNG_START_TRACE processed by the client thread. - * - * Called with session mutex held. - */ -int cmd_start_trace(struct ltt_session *session) +int cmd_start_trace(struct ltt_session *session) { enum lttng_error_code ret; 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; assert(session); @@ -2582,6 +2586,23 @@ int cmd_start_trace(struct ltt_session *session) /* Is the session already started? */ if (session->active) { ret = LTTNG_ERR_TRACE_ALREADY_STARTED; + /* Perform nothing */ + goto end; + } + + if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING && + !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 + * the session since starting the session here would require a + * rotation from "NULL" to a new trace chunk. That rotation + * would overlap with the ongoing rotation, which is not + * supported. + */ + WARN("Refusing to start session \"%s\" as a rotation launched after the last \"stop\" is still ongoing", + session->name); + ret = LTTNG_ERR_ROTATION_PENDING; goto error; } @@ -2600,17 +2621,54 @@ int cmd_start_trace(struct ltt_session *session) goto error; } - if (!session->has_been_started && session->output_traces) { - ret = session_switch_trace_chunk(session, NULL, NULL); - if (ret != LTTNG_OK) { - goto error; + session->active = 1; + session->rotated_after_last_stop = false; + session->cleared_after_last_stop = false; + if (session->output_traces && !session->current_trace_chunk) { + if (!session->has_been_started) { + struct lttng_trace_chunk *trace_chunk; + + DBG("Creating initial trace chunk of session \"%s\"", + session->name); + trace_chunk = session_create_new_trace_chunk( + session, NULL, NULL, NULL); + if (!trace_chunk) { + ret = LTTNG_ERR_CREATE_DIR_FAIL; + goto error; + } + assert(!session->current_trace_chunk); + ret = session_set_trace_chunk(session, trace_chunk, + NULL); + lttng_trace_chunk_put(trace_chunk); + if (ret) { + ret = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER; + goto error; + } + } else { + DBG("Rotating session \"%s\" from its current \"NULL\" trace chunk to a new chunk", + session->name); + /* + * Rotate existing streams into the new chunk. + * This is a "quiet" rotation has no client has + * explicitly requested this operation. + * + * There is also no need to wait for the rotation + * to complete as it will happen immediately. No data + * was produced as the session was stopped, so the + * rotation should happen on reception of the command. + */ + ret = cmd_rotate_session(session, NULL, true, + LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION); + if (ret != LTTNG_OK) { + goto error; + } } } /* Kernel tracing */ if (ksession != NULL) { DBG("Start kernel tracing session %s", session->name); - ret = start_kernel_session(ksession, kernel_tracer_fd); + ret = start_kernel_session(ksession); if (ret != LTTNG_OK) { goto error; } @@ -2626,9 +2684,15 @@ int cmd_start_trace(struct ltt_session *session) } } - /* Flag this after a successful start. */ - session->has_been_started = 1; - session->active = 1; + /* + * Open a packet in every stream of the session to ensure that viewers + * can correctly identify the boundaries of the periods during which + * tracing was active for this session. + */ + ret = session_open_packets(session); + if (ret != LTTNG_OK) { + goto error; + } /* * Clear the flag that indicates that a rotation was done while the @@ -2650,6 +2714,18 @@ int cmd_start_trace(struct ltt_session *session) ret = LTTNG_OK; error: + if (ret == LTTNG_OK) { + /* Flag this after a successful start. */ + session->has_been_started |= 1; + } 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; + } +end: return ret; } @@ -2659,14 +2735,12 @@ error: int cmd_stop_trace(struct ltt_session *session) { int ret; - struct ltt_kernel_channel *kchan; struct ltt_kernel_session *ksession; struct ltt_ust_session *usess; - bool error_occurred = false; assert(session); - DBG("Begin stop session %s (id %" PRIu64 ")", session->name, session->id); + DBG("Begin stop session \"%s\" (id %" PRIu64 ")", session->name, session->id); /* Short cut */ ksession = session->kernel_session; usess = session->ust_session; @@ -2677,37 +2751,9 @@ int cmd_stop_trace(struct ltt_session *session) goto error; } - /* Kernel tracer */ - if (ksession && ksession->active) { - DBG("Stop kernel tracing"); - - ret = kernel_stop_session(ksession); - if (ret < 0) { - ret = LTTNG_ERR_KERN_STOP_FAIL; - goto error; - } - - kernel_wait_quiescent(kernel_tracer_fd); - - /* Flush metadata after stopping (if exists) */ - if (ksession->metadata_stream_fd >= 0) { - ret = kernel_metadata_flush_buffer(ksession->metadata_stream_fd); - if (ret < 0) { - ERR("Kernel metadata flush failed"); - } - } - - /* Flush all buffers after stopping */ - cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) { - ret = kernel_flush_buffer(kchan); - if (ret < 0) { - ERR("Kernel flush buffer error"); - } - } - - ksession->active = 0; - DBG("Kernel session stopped %s (id %" PRIu64 ")", session->name, - session->id); + ret = stop_kernel_session(ksession); + if (ret != LTTNG_OK) { + goto error; } if (usess && usess->active) { @@ -2718,10 +2764,51 @@ int cmd_stop_trace(struct ltt_session *session) } } + DBG("Completed stop session \"%s\" (id %" PRIu64 ")", session->name, + session->id); /* Flag inactive after a successful stop. */ session->active = 0; - ret = !error_occurred ? LTTNG_OK : LTTNG_ERR_UNK; + ret = LTTNG_OK; + +error: + return ret; +} + +/* + * 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) +{ + int ret; + size_t i; + + for (i = 0; i < nb_uri; i++) { + if (uris[i].stype != LTTNG_STREAM_CONTROL || + uris[i].subdir[0] == '\0') { + /* Not interested in these URIs */ + continue; + } + if (session->base_path != NULL) { + free(session->base_path); + session->base_path = NULL; + } + + /* Set session base_path */ + session->base_path = strdup(uris[i].subdir); + if (!session->base_path) { + PERROR("Failed to copy base path \"%s\" to session \"%s\"", + uris[i].subdir, session->name); + ret = LTTNG_ERR_NOMEM; + goto error; + } + DBG2("Setting base path \"%s\" for session \"%s\"", + session->base_path, session->name); + } + ret = LTTNG_OK; error: return ret; } @@ -2746,11 +2833,20 @@ int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri, goto error; } + /* + * Set the session base path if any. This is done inside + * cmd_set_consumer_uri to preserve backward compatibility of the + * previous session creation api vs the session descriptor api. + */ + ret = set_session_base_path_from_uris(session, nb_uri, uris); + if (ret != LTTNG_OK) { + goto error; + } + /* 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; } @@ -2903,6 +2999,7 @@ enum lttng_error_code cmd_create_session_from_descriptor( ret_code = LTTNG_ERR_INVALID; goto end; } + ret_code = session_create(session_name, creds->uid, creds->gid, &new_session); if (ret_code != LTTNG_OK) { @@ -2980,19 +3077,19 @@ 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 >= + 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 > + if (cmd_ctx->lsm.u.create_session.session_descriptor_size > 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; + payload_size = cmd_ctx->lsm.u.create_session.home_dir_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; @@ -3009,11 +3106,11 @@ 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); + cmd_ctx->lsm.u.create_session.home_dir_size); 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); + cmd_ctx->lsm.u.create_session.home_dir_size, + cmd_ctx->lsm.u.create_session.session_descriptor_size); ret = lttng_session_descriptor_create_from_buffer( &session_descriptor_view, &session_descriptor); @@ -3043,26 +3140,136 @@ error: return ret_code; } +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 = + _reply_context; + struct lttng_dynamic_buffer payload; + struct lttcomm_session_destroy_command_header cmd_header; + struct lttng_trace_archive_location *location = NULL; + struct lttcomm_lttng_msg llm = { + .cmd_type = LTTNG_DESTROY_SESSION, + .ret_code = reply_context->destruction_status, + .pid = UINT32_MAX, + .cmd_header_size = + sizeof(struct lttcomm_session_destroy_command_header), + .data_size = 0, + }; + size_t payload_size_before_location; + + lttng_dynamic_buffer_init(&payload); + + ret = lttng_dynamic_buffer_append(&payload, &llm, sizeof(llm)); + if (ret) { + ERR("Failed to append session destruction message"); + 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)); + if (ret) { + ERR("Failed to append session destruction command header"); + goto error; + } + + if (!reply_context->implicit_rotation_on_destroy) { + DBG("No implicit rotation performed during the destruction of session \"%s\", sending reply", + session->name); + 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); + 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); + goto error; + } + + payload_size_before_location = payload.size; + comm_ret = lttng_trace_archive_location_serialize(location, + &payload); + if (comm_ret < 0) { + ERR("Failed to serialize the location of the trace archive produced during the destruction of session \"%s\"", + 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; +send_reply: + 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); + } +error: + ret = close(reply_context->reply_sock_fd); + if (ret) { + PERROR("Failed to close client socket in deferred session destroy reply"); + } + lttng_dynamic_buffer_reset(&payload); + free(_reply_context); +} + /* * Command LTTNG_DESTROY_SESSION processed by the client thread. * * Called with session lock held. */ int cmd_destroy_session(struct ltt_session *session, - struct notification_thread_handle *notification_thread_handle) + struct notification_thread_handle *notification_thread_handle, + int *sock_fd) { int ret; + enum lttng_error_code destruction_last_error = LTTNG_OK; + struct cmd_destroy_session_reply_context *reply_context = NULL; + + if (sock_fd) { + reply_context = zmalloc(sizeof(*reply_context)); + if (!reply_context) { + ret = LTTNG_ERR_NOMEM; + goto end; + } + reply_context->reply_sock_fd = *sock_fd; + } /* Safety net */ 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); + 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)); + destruction_last_error = ret; + } + } if (session->rotation_schedule_timer_enabled) { if (timer_session_rotation_schedule_timer_stop( session)) { ERR("Failed to stop the \"rotation schedule\" timer of session %s", session->name); + destruction_last_error = LTTNG_ERR_TIMER_STOP_ERROR; } } @@ -3071,26 +3278,45 @@ int cmd_destroy_session(struct ltt_session *session, session->rotate_size = 0; } - if (session->current_archive_id != 0) { - if (!session->rotated_after_last_stop) { - ret = cmd_rotate_session(session, NULL); - if (ret != LTTNG_OK) { - ERR("Failed to perform an implicit rotation as part of the rotation: %s", lttng_strerror(-ret)); - } - } else { - /* - * Rename the active chunk to ensure it has a name - * of the form ts_begin-ts_end-id. - * - * Note that no trace data has been produced since - * the last rotation; the directory should be - * removed. - */ - ret = rename_active_chunk(session); - if (ret) { - ERR("Failed to rename active chunk during the destruction of session \"%s\"", - session->name); - } + if (session->rotated && session->current_trace_chunk && session->output_traces) { + /* + * 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); + 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)); + destruction_last_error = -ret; + } + if (reply_context) { + reply_context->implicit_rotation_on_destroy = true; + } + } else if (session->has_been_started && session->current_trace_chunk) { + /* + * The user has not triggered a session rotation. However, to + * ensure all data has been consumed, the session is rotated + * to a 'null' trace chunk before it is destroyed. + * + * This is a "quiet" rotation meaning that no notification is + * 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); + /* + * Rotation operations may not be supported by the kernel + * tracer. Hence, do not consider this implicit rotation as + * a session destruction error. The library has already stopped + * 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) { + ERR("Failed to perform a quiet rotation as part of the destruction of session \"%s\": %s", + session->name, lttng_strerror(ret)); + destruction_last_error = -ret; } } @@ -3154,8 +3380,20 @@ int cmd_destroy_session(struct ltt_session *session, * _at least_ up to the point when that reference is released. */ 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); + if (ret) { + ret = LTTNG_ERR_FATAL; + goto end; + } else { + *sock_fd = -1; + } + } ret = LTTNG_OK; - +end: return ret; } @@ -3383,25 +3621,33 @@ end: */ ssize_t cmd_list_events(enum lttng_domain_type domain, struct ltt_session *session, char *channel_name, - struct lttng_event **events, size_t *total_size) + struct lttng_payload *payload) { int ret = 0; - ssize_t nb_event = 0; + ssize_t nb_events = 0; + struct lttcomm_event_command_header cmd_header = {}; + const size_t cmd_header_offset = payload->buffer.size; + + ret = lttng_dynamic_buffer_append( + &payload->buffer, &cmd_header, sizeof(cmd_header)); + if (ret) { + ret = LTTNG_ERR_NOMEM; + goto error; + } switch (domain) { case LTTNG_DOMAIN_KERNEL: if (session->kernel_session != NULL) { - nb_event = list_lttng_kernel_events(channel_name, - session->kernel_session, events, - total_size); + nb_events = list_lttng_kernel_events(channel_name, + session->kernel_session, payload); } break; case LTTNG_DOMAIN_UST: { if (session->ust_session != NULL) { - nb_event = list_lttng_ust_global_events(channel_name, - &session->ust_session->domain_global, events, - total_size); + nb_events = list_lttng_ust_global_events(channel_name, + &session->ust_session->domain_global, + payload); } break; } @@ -3416,9 +3662,8 @@ ssize_t cmd_list_events(enum lttng_domain_type domain, cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter, agt, node.node) { if (agt->domain == domain) { - nb_event = list_lttng_agent_events( - agt, events, - total_size); + nb_events = list_lttng_agent_events( + agt, payload); break; } } @@ -3430,7 +3675,10 @@ ssize_t cmd_list_events(enum lttng_domain_type domain, goto error; } - return nb_event; + ((struct lttcomm_event_command_header *) (payload->buffer.data + + cmd_header_offset))->nb_events = (uint32_t) nb_events; + + return nb_events; error: /* Return negative value to differentiate return code */ @@ -3451,7 +3699,7 @@ void cmd_list_lttng_sessions(struct lttng_session *sessions, unsigned int i = 0; struct ltt_session *session; struct ltt_session_list *list = session_get_list(); - struct lttng_session_extended *extended = + struct lttng_session_extended *extended = (typeof(extended)) (&sessions[session_count]); DBG("Getting all available session for UID %d GID %d", @@ -3467,7 +3715,7 @@ void cmd_list_lttng_sessions(struct lttng_session *sessions, /* * Only list the sessions the user can control. */ - if (!session_access_ok(session, uid, gid) || + if (!session_access_ok(session, uid) || session->destroyed) { session_put(session); continue; @@ -3574,7 +3822,7 @@ error: * Return LTTNG_OK on success or else a LTTNG_ERR code. */ int cmd_snapshot_add_output(struct ltt_session *session, - struct lttng_snapshot_output *output, uint32_t *id) + const struct lttng_snapshot_output *output, uint32_t *id) { int ret; struct snapshot_output *new_output; @@ -3642,7 +3890,7 @@ error: * Return LTTNG_OK on success or else a LTTNG_ERR code. */ int cmd_snapshot_del_output(struct ltt_session *session, - struct lttng_snapshot_output *output) + const struct lttng_snapshot_output *output) { int ret; struct snapshot_output *sout = NULL; @@ -4015,19 +4263,23 @@ int cmd_register_trigger(struct command_ctx *cmd_ctx, int sock, size_t trigger_len; ssize_t sock_recv_len; struct lttng_trigger *trigger = NULL; - struct lttng_buffer_view view; - struct lttng_dynamic_buffer trigger_buffer; - - lttng_dynamic_buffer_init(&trigger_buffer); - trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length; - ret = lttng_dynamic_buffer_set_size(&trigger_buffer, trigger_len); + struct lttng_payload trigger_payload; + struct lttng_credentials cmd_creds = { + .uid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.uid), + .gid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.gid), + }; + + lttng_payload_init(&trigger_payload); + trigger_len = (size_t) cmd_ctx->lsm.u.trigger.length; + ret = lttng_dynamic_buffer_set_size( + &trigger_payload.buffer, trigger_len); if (ret) { ret = LTTNG_ERR_NOMEM; goto end; } - sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_buffer.data, - trigger_len); + sock_recv_len = lttcomm_recv_unix_sock( + sock, trigger_payload.buffer.data, trigger_len); if (sock_recv_len < 0 || sock_recv_len != trigger_len) { ERR("Failed to receive \"register trigger\" command payload"); /* TODO: should this be a new error enum ? */ @@ -4035,44 +4287,84 @@ int cmd_register_trigger(struct command_ctx *cmd_ctx, int sock, goto end; } - view = lttng_buffer_view_from_dynamic_buffer(&trigger_buffer, 0, -1); - if (lttng_trigger_create_from_buffer(&view, &trigger) != - trigger_len) { - ERR("Invalid trigger payload received in \"register trigger\" command"); - ret = LTTNG_ERR_INVALID_TRIGGER; - goto end; + /* Receive fds, if any. */ + if (cmd_ctx->lsm.fd_count > 0) { + ret = lttcomm_recv_payload_fds_unix_sock( + sock, cmd_ctx->lsm.fd_count, &trigger_payload); + if (ret > 0 && ret != cmd_ctx->lsm.fd_count * sizeof(int)) { + ret = LTTNG_ERR_INVALID_PROTOCOL; + goto end; + } else if (ret <= 0) { + ret = LTTNG_ERR_FATAL; + goto end; + } } - ret = notification_thread_command_register_trigger(notification_thread, - trigger); - /* Ownership of trigger was transferred. */ - trigger = NULL; -end: - lttng_trigger_destroy(trigger); - lttng_dynamic_buffer_reset(&trigger_buffer); - return ret; -} - -int cmd_unregister_trigger(struct command_ctx *cmd_ctx, int sock, + /* Deserialize trigger. */ + { + struct lttng_payload_view view = + lttng_payload_view_from_payload( + &trigger_payload, 0, -1); + + if (lttng_trigger_create_from_payload(&view, &trigger) != + trigger_len) { + ERR("Invalid trigger payload received in \"register trigger\" command"); + ret = LTTNG_ERR_INVALID_TRIGGER; + goto end; + } + } + + + /* + * 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_get_uid(&cmd_creds) != 0) { + ERR("Trigger credentials do not match the command credentials"); + ret = LTTNG_ERR_INVALID_TRIGGER; + goto end; + } + } + + /* Inform the notification thread */ + ret = notification_thread_command_register_trigger(notification_thread, + trigger); + /* Ownership of trigger was transferred. */ + trigger = NULL; +end: + lttng_trigger_destroy(trigger); + lttng_payload_reset(&trigger_payload); + return ret; +} + +int cmd_unregister_trigger(struct command_ctx *cmd_ctx, int sock, struct notification_thread_handle *notification_thread) { int ret; size_t trigger_len; ssize_t sock_recv_len; struct lttng_trigger *trigger = NULL; - struct lttng_buffer_view view; - struct lttng_dynamic_buffer trigger_buffer; - - lttng_dynamic_buffer_init(&trigger_buffer); - trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length; - ret = lttng_dynamic_buffer_set_size(&trigger_buffer, trigger_len); + struct lttng_payload trigger_payload; + struct lttng_credentials cmd_creds = { + .uid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.uid), + .gid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.gid), + }; + + lttng_payload_init(&trigger_payload); + trigger_len = (size_t) cmd_ctx->lsm.u.trigger.length; + ret = lttng_dynamic_buffer_set_size( + &trigger_payload.buffer, trigger_len); if (ret) { ret = LTTNG_ERR_NOMEM; goto end; } - sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_buffer.data, - trigger_len); + sock_recv_len = lttcomm_recv_unix_sock( + sock, trigger_payload.buffer.data, trigger_len); if (sock_recv_len < 0 || sock_recv_len != trigger_len) { ERR("Failed to receive \"unregister trigger\" command payload"); /* TODO: should this be a new error enum ? */ @@ -4080,19 +4372,52 @@ int cmd_unregister_trigger(struct command_ctx *cmd_ctx, int sock, goto end; } - view = lttng_buffer_view_from_dynamic_buffer(&trigger_buffer, 0, -1); - if (lttng_trigger_create_from_buffer(&view, &trigger) != - trigger_len) { - ERR("Invalid trigger payload received in \"unregister trigger\" command"); - ret = LTTNG_ERR_INVALID_TRIGGER; - goto end; + /* Receive fds, if any. */ + if (cmd_ctx->lsm.fd_count > 0) { + ret = lttcomm_recv_payload_fds_unix_sock( + sock, cmd_ctx->lsm.fd_count, &trigger_payload); + if (ret > 0 && ret != cmd_ctx->lsm.fd_count * sizeof(int)) { + ret = LTTNG_ERR_INVALID_PROTOCOL; + goto end; + } else if (ret <= 0) { + ret = LTTNG_ERR_FATAL; + goto end; + } + } + + { + struct lttng_payload_view view = + lttng_payload_view_from_payload( + &trigger_payload, 0, -1); + + if (lttng_trigger_create_from_payload(&view, &trigger) != + trigger_len) { + ERR("Invalid trigger payload received in \"unregister trigger\" command"); + ret = LTTNG_ERR_INVALID_TRIGGER; + goto end; + } + } + + /* + * 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_get_uid(&cmd_creds) != 0) { + ERR("Trigger credentials do not match the command credentials"); + ret = LTTNG_ERR_INVALID_TRIGGER; + goto end; + } } ret = notification_thread_command_unregister_trigger(notification_thread, trigger); end: lttng_trigger_destroy(trigger); - lttng_dynamic_buffer_reset(&trigger_buffer); + lttng_payload_reset(&trigger_payload); return ret; } @@ -4103,37 +4428,66 @@ end: * Return LTTNG_OK on success or a LTTNG_ERR code. */ static enum lttng_error_code set_relayd_for_snapshot( - struct consumer_output *consumer, - const struct snapshot_output *snap_output, + struct consumer_output *output, const struct ltt_session *session) { enum lttng_error_code status = LTTNG_OK; struct lttng_ht_iter iter; struct consumer_socket *socket; + LTTNG_OPTIONAL(uint64_t) current_chunk_id = {}; + const char *base_path; - assert(consumer); - assert(snap_output); + assert(output); assert(session); 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); + + if (chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK) { + current_chunk_id.is_set = true; + } else { + ERR("Failed to get current trace chunk id"); + status = LTTNG_ERR_UNK; + goto error; + } + } + /* Ignore if snapshot consumer output is not network. */ - if (snap_output->consumer->type != CONSUMER_DST_NET) { + if (output->type != CONSUMER_DST_NET) { goto error; } + /* + * The snapshot record URI base path overrides the session + * base path. + */ + if (output->dst.net.control.subdir[0] != '\0') { + base_path = output->dst.net.control.subdir; + } else { + base_path = session->base_path; + } + /* * For each consumer socket, create and send the relayd object of the * snapshot output. */ rcu_read_lock(); - cds_lfht_for_each_entry(snap_output->consumer->socks->ht, &iter.iter, + cds_lfht_for_each_entry(output->socks->ht, &iter.iter, socket, node.node) { pthread_mutex_lock(socket->lock); status = send_consumer_relayd_sockets(0, session->id, - snap_output->consumer, socket, + output, socket, session->name, session->hostname, - session->live_timer); + 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(); @@ -4153,44 +4507,18 @@ error: */ static enum lttng_error_code record_kernel_snapshot( struct ltt_kernel_session *ksess, - const struct snapshot_output *output, + const struct consumer_output *output, const struct ltt_session *session, int wait, uint64_t nb_packets_per_stream) { - int ret; enum lttng_error_code status; assert(ksess); assert(output); assert(session); - /* - * Copy kernel session sockets so we can communicate with the right - * consumer for the snapshot record command. - */ - ret = consumer_copy_sockets(output->consumer, ksess->consumer); - if (ret < 0) { - status = LTTNG_ERR_NOMEM; - goto error; - } - - status = set_relayd_for_snapshot(ksess->consumer, output, session); - if (status != LTTNG_OK) { - goto error_snapshot; - } - - status = kernel_snapshot_record(ksess, output, wait, nb_packets_per_stream); - if (status != LTTNG_OK) { - goto error_snapshot; - } - - goto end; - -error_snapshot: - /* Clean up copied sockets so this output can use some other later on. */ - consumer_destroy_output_sockets(output->consumer); -error: -end: + status = kernel_snapshot_record( + ksess, output, wait, nb_packets_per_stream); return status; } @@ -4200,45 +4528,18 @@ end: * 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 snapshot_output *output, - const struct ltt_session *session, int wait, - uint64_t nb_packets_per_stream) + const struct consumer_output *output, + const struct ltt_session *session, + int wait, uint64_t nb_packets_per_stream) { - int ret; enum lttng_error_code status; assert(usess); assert(output); assert(session); - /* - * Copy UST session sockets so we can communicate with the right - * consumer for the snapshot record command. - */ - ret = consumer_copy_sockets(output->consumer, usess->consumer); - if (ret < 0) { - status = LTTNG_ERR_NOMEM; - goto error; - } - - status = set_relayd_for_snapshot(usess->consumer, output, session); - if (status != LTTNG_OK) { - goto error_snapshot; - } - - status = ust_app_snapshot_record(usess, output, wait, - nb_packets_per_stream); - if (status != LTTNG_OK) { - goto error_snapshot; - } - - goto end; - -error_snapshot: - /* Clean up copied sockets so this output can use some other later on. */ - consumer_destroy_output_sockets(output->consumer); -error: -end: + status = ust_app_snapshot_record( + usess, output, wait, nb_packets_per_stream); return status; } @@ -4323,7 +4624,7 @@ int64_t get_session_nb_packets_per_stream(const struct ltt_session *session, } cur_nb_packets++; } - if (!cur_nb_packets) { + if (!cur_nb_packets && size_left != max_size) { /* Not enough room to grab one packet of each stream, error. */ return -1; } @@ -4331,38 +4632,160 @@ int64_t get_session_nb_packets_per_stream(const struct ltt_session *session, } static -enum lttng_error_code snapshot_record(const struct ltt_session *session, +enum lttng_error_code snapshot_record(struct ltt_session *session, const struct snapshot_output *snapshot_output, int wait) { int64_t nb_packets_per_stream; - enum lttng_error_code ret = LTTNG_OK; + char snapshot_chunk_name[LTTNG_NAME_MAX]; + int ret; + enum lttng_error_code ret_code = LTTNG_OK; + struct lttng_trace_chunk *snapshot_trace_chunk; + struct consumer_output *original_ust_consumer_output = NULL; + struct consumer_output *original_kernel_consumer_output = NULL; + struct consumer_output *snapshot_ust_consumer_output = NULL; + struct consumer_output *snapshot_kernel_consumer_output = NULL; + + ret = snprintf(snapshot_chunk_name, sizeof(snapshot_chunk_name), + "%s-%s-%" PRIu64, + snapshot_output->name, + snapshot_output->datetime, + snapshot_output->nb_snapshot); + 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); + if (!session->kernel_session && !session->ust_session) { + ERR("Failed to record snapshot as no channels exist"); + ret_code = LTTNG_ERR_NO_CHANNEL; + goto error; + } + + 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); + ret = consumer_copy_sockets(snapshot_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); + 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; + } + 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); + ret = consumer_copy_sockets(snapshot_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); + 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; + } + + 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); + ret_code = LTTNG_ERR_CREATE_DIR_FAIL; + goto error; + } + assert(!session->current_trace_chunk); + ret = session_set_trace_chunk(session, snapshot_trace_chunk, NULL); + lttng_trace_chunk_put(snapshot_trace_chunk); + snapshot_trace_chunk = NULL; + if (ret) { + ERR("Failed to set temporary trace chunk to record a snapshot of session \"%s\"", + 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); if (nb_packets_per_stream < 0) { - ret = LTTNG_ERR_MAX_SIZE_INVALID; - goto end; + ret_code = LTTNG_ERR_MAX_SIZE_INVALID; + goto error_close_trace_chunk; } if (session->kernel_session) { - ret = record_kernel_snapshot(session->kernel_session, - snapshot_output, session, + ret_code = record_kernel_snapshot(session->kernel_session, + snapshot_kernel_consumer_output, session, wait, nb_packets_per_stream); - if (ret != LTTNG_OK) { - goto end; + if (ret_code != LTTNG_OK) { + goto error_close_trace_chunk; } } if (session->ust_session) { - ret = record_ust_snapshot(session->ust_session, - snapshot_output, session, + ret_code = record_ust_snapshot(session->ust_session, + snapshot_ust_consumer_output, session, wait, nb_packets_per_stream); - if (ret != LTTNG_OK) { - goto end; + if (ret_code != LTTNG_OK) { + goto error_close_trace_chunk; } } -end: - return ret; + +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); + ret_code = LTTNG_ERR_UNK; + } + + 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); + ret_code = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER; + } +error: + if (original_ust_consumer_output) { + session->ust_session->consumer = original_ust_consumer_output; + } + if (original_kernel_consumer_output) { + session->kernel_session->consumer = + original_kernel_consumer_output; + } + consumer_output_put(snapshot_ust_consumer_output); + consumer_output_put(snapshot_kernel_consumer_output); + return ret_code; } /* @@ -4374,14 +4797,13 @@ end: * Return LTTNG_OK on success or else a LTTNG_ERR code. */ int cmd_snapshot_record(struct ltt_session *session, - struct lttng_snapshot_output *output, int wait) + const struct lttng_snapshot_output *output, int wait) { enum lttng_error_code cmd_ret = LTTNG_OK; int ret; - unsigned int use_tmp_output = 0; - struct snapshot_output tmp_output; unsigned int snapshot_success = 0; char datetime[16]; + struct snapshot_output *tmp_output = NULL; assert(session); assert(output); @@ -4413,11 +4835,17 @@ int cmd_snapshot_record(struct ltt_session *session, /* Use temporary output for the session. */ if (*output->ctrl_url != '\0') { + tmp_output = snapshot_output_alloc(); + if (!tmp_output) { + cmd_ret = LTTNG_ERR_NOMEM; + goto error; + } + ret = snapshot_output_init(session, output->max_size, output->name, output->ctrl_url, output->data_url, session->consumer, - &tmp_output, NULL); + tmp_output, NULL); if (ret < 0) { if (ret == -ENOMEM) { cmd_ret = LTTNG_ERR_NOMEM; @@ -4427,15 +4855,11 @@ int cmd_snapshot_record(struct ltt_session *session, goto error; } /* Use the global session count for the temporary snapshot. */ - tmp_output.nb_snapshot = session->snapshot.nb_snapshot; + tmp_output->nb_snapshot = session->snapshot.nb_snapshot; /* Use the global datetime */ - memcpy(tmp_output.datetime, datetime, sizeof(datetime)); - use_tmp_output = 1; - } - - if (use_tmp_output) { - cmd_ret = snapshot_record(session, &tmp_output, wait); + memcpy(tmp_output->datetime, datetime, sizeof(datetime)); + cmd_ret = snapshot_record(session, tmp_output, wait); if (cmd_ret != LTTNG_OK) { goto error; } @@ -4447,30 +4871,35 @@ int cmd_snapshot_record(struct ltt_session *session, rcu_read_lock(); cds_lfht_for_each_entry(session->snapshot.output_ht->ht, &iter.iter, sout, node.node) { + struct snapshot_output output_copy; + /* - * Make a local copy of the output and assign the - * possible temporary value given by the caller. + * Make a local copy of the output and override output + * parameters with those provided as part of the + * command. */ - memcpy(&tmp_output, sout, sizeof(tmp_output)); + memcpy(&output_copy, sout, sizeof(output_copy)); if (output->max_size != (uint64_t) -1ULL) { - tmp_output.max_size = output->max_size; + output_copy.max_size = output->max_size; } - tmp_output.nb_snapshot = session->snapshot.nb_snapshot; - memcpy(tmp_output.datetime, datetime, sizeof(datetime)); + output_copy.nb_snapshot = session->snapshot.nb_snapshot; + memcpy(output_copy.datetime, datetime, + sizeof(datetime)); /* Use temporary name. */ if (*output->name != '\0') { - if (lttng_strncpy(tmp_output.name, output->name, - sizeof(tmp_output.name))) { + if (lttng_strncpy(output_copy.name, + output->name, + sizeof(output_copy.name))) { cmd_ret = LTTNG_ERR_INVALID; rcu_read_unlock(); goto error; } } - cmd_ret = snapshot_record(session, &tmp_output, wait); + cmd_ret = snapshot_record(session, &output_copy, wait); if (cmd_ret != LTTNG_OK) { rcu_read_unlock(); goto error; @@ -4487,6 +4916,9 @@ int cmd_snapshot_record(struct ltt_session *session, } error: + if (tmp_output) { + snapshot_output_destroy(tmp_output); + } return cmd_ret; } @@ -4522,19 +4954,18 @@ 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) + struct lttng_rotate_session_return *rotate_return, + bool quiet_rotation, + enum lttng_trace_chunk_command_type command) { int ret; + uint64_t ongoing_rotation_chunk_id; enum lttng_error_code cmd_ret = LTTNG_OK; - size_t strf_ret; - struct tm *timeinfo; - char datetime[21]; - time_t now; - /* - * Used to roll-back timestamps in case of failure to launch the - * rotation. - */ - time_t original_last_chunk_start_ts, original_current_chunk_start_ts; + struct lttng_trace_chunk *chunk_being_archived = NULL; + struct lttng_trace_chunk *new_trace_chunk = NULL; + enum lttng_trace_chunk_status chunk_status; + bool failed_to_rotate = false; + enum lttng_error_code rotation_fail_code = LTTNG_OK; assert(session); @@ -4543,21 +4974,32 @@ int cmd_rotate_session(struct ltt_session *session, goto end; } - if (session->live_timer || !session->output_traces) { + /* + * Explicit rotation is not supported for live sessions. + * However, live sessions can perform a quiet rotation on + * destroy. + * Rotation is not supported for snapshot traces (no output). + */ + 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 (session->consumer->type == CONSUMER_DST_NET && + /* 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)) { cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE_RELAY; goto end; } + /* Unsupported feature in lttng-modules before 2.8 (lack of sequence number). */ + if (session->kernel_session && !kernel_supports_ring_buffer_packet_sequence_number()) { + cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE_KERNEL; + goto end; + } + if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING) { DBG("Refusing to launch a rotation; a rotation is already in progress for session %s", session->name); @@ -4576,156 +5018,88 @@ int cmd_rotate_session(struct ltt_session *session, goto end; } - /* Special case for the first rotation. */ - if (session->current_archive_id == 0) { - const char *base_path = NULL; - - assert(session->kernel_session || session->ust_session); - /* Either one of the two sessions is enough to get the root path. */ - base_path = session_get_base_path(session); - assert(base_path); - - ret = lttng_strncpy(session->rotation_chunk.current_rotate_path, - base_path, - sizeof(session->rotation_chunk.current_rotate_path)); - if (ret) { - ERR("Failed to copy session base path to current rotation chunk path"); - cmd_ret = LTTNG_ERR_UNK; - goto end; - } - } else { - /* - * The currently active tracing path is now the folder we - * want to rotate. - */ - ret = lttng_strncpy(session->rotation_chunk.current_rotate_path, - session->rotation_chunk.active_tracing_path, - sizeof(session->rotation_chunk.current_rotate_path)); - if (ret) { - ERR("Failed to copy the active tracing path to the current rotate path"); - cmd_ret = LTTNG_ERR_UNK; - goto end; - } - } - DBG("Current rotate path %s", session->rotation_chunk.current_rotate_path); - /* - * Channels created after this point will belong to the next - * archive id. + * After a stop followed by a clear, disallow following rotations a they would + * generate empty chunks. */ - session->current_archive_id++; - - now = time(NULL); - if (now == (time_t) -1) { - cmd_ret = LTTNG_ERR_UNK; - goto end; - } - - /* Sample chunk bounds for roll-back in case of error. */ - original_last_chunk_start_ts = session->last_chunk_start_ts; - original_current_chunk_start_ts = session->current_chunk_start_ts; - - session->last_chunk_start_ts = session->current_chunk_start_ts; - session->current_chunk_start_ts = now; - - timeinfo = localtime(&now); - if (!timeinfo) { - PERROR("Failed to sample local time in rotate session command"); - cmd_ret = LTTNG_ERR_UNK; - goto end; - } - strf_ret = strftime(datetime, sizeof(datetime), "%Y%m%dT%H%M%S%z", - timeinfo); - if (!strf_ret) { - ERR("Failed to format local time timestamp in rotate session command"); - cmd_ret = LTTNG_ERR_UNK; + if (session->cleared_after_last_stop) { + DBG("Session \"%s\" was already cleared after stop, refusing rotation", + session->name); + cmd_ret = LTTNG_ERR_ROTATION_AFTER_STOP_CLEAR; goto end; } - /* Current chunk directory, ex: 20170922-111754-42 */ - ret = snprintf(session->consumer->chunk_path, - sizeof(session->consumer->chunk_path), - "%s-%" PRIu64, datetime, - session->current_archive_id + 1); - if (ret < 0 || ret >= sizeof(session->consumer->chunk_path)) { - ERR("Failed to format the new chunk's directory in rotate session command"); - cmd_ret = LTTNG_ERR_UNK; - goto error; + if (session->active) { + 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; + } } /* - * The active path for the next rotation/destroy. - * Ex: ~/lttng-traces/auto-20170922-111748/20170922-111754-42 + * The current trace chunk becomes the chunk being archived. + * + * After this point, "chunk_being_archived" must absolutely + * be closed on the consumer(s), otherwise it will never be + * cleaned-up, which will result in a leak. */ - ret = snprintf(session->rotation_chunk.active_tracing_path, - sizeof(session->rotation_chunk.active_tracing_path), - "%s/%s", - session_get_base_path(session), - session->consumer->chunk_path); - if (ret < 0 || ret >= sizeof(session->rotation_chunk.active_tracing_path)) { - ERR("Failed to format active tracing path in rotate session command"); - cmd_ret = LTTNG_ERR_UNK; + 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; } - /* - * A rotation has a local step even if the destination is a relay - * daemon; the buffers must be consumed by the consumer daemon. - */ - session->rotation_pending_local = true; - session->rotation_pending_relay = - session_get_consumer_destination_type(session) == CONSUMER_DST_NET; - session->rotation_state = LTTNG_ROTATION_STATE_ONGOING; - if (session->kernel_session) { - ret = lttng_strncpy( - session->kernel_session->consumer->chunk_path, - session->consumer->chunk_path, - sizeof(session->kernel_session->consumer->chunk_path)); - if (ret) { - ERR("Failed to copy current chunk directory to kernel session"); - cmd_ret = LTTNG_ERR_UNK; - goto error; - } - /* - * Create the new chunk folder, before the rotation begins so we - * don't race with the consumer/tracer activity. - */ - ret = domain_mkdir(session->kernel_session->consumer, session, - session->kernel_session->uid, - session->kernel_session->gid); - if (ret) { - cmd_ret = LTTNG_ERR_CREATE_DIR_FAIL; - goto error; - } cmd_ret = kernel_rotate_session(session); if (cmd_ret != LTTNG_OK) { - goto error; + failed_to_rotate = true; + rotation_fail_code = cmd_ret; } } if (session->ust_session) { - ret = lttng_strncpy( - session->ust_session->consumer->chunk_path, - session->consumer->chunk_path, - sizeof(session->ust_session->consumer->chunk_path)); - if (ret) { - ERR("Failed to copy current chunk directory to userspace session"); - cmd_ret = LTTNG_ERR_UNK; - goto error; - } - ret = domain_mkdir(session->ust_session->consumer, session, - session->ust_session->uid, - session->ust_session->gid); - if (ret) { - cmd_ret = LTTNG_ERR_CREATE_DIR_FAIL; - goto error; - } cmd_ret = ust_app_rotate_session(session); if (cmd_ret != LTTNG_OK) { + failed_to_rotate = true; + rotation_fail_code = cmd_ret; + } + } + + if (!session->active) { + session->rotated_after_last_stop = true; + } + + if (!chunk_being_archived) { + DBG("Rotating session \"%s\" from a \"NULL\" trace chunk to a new trace chunk, skipping completion check", + session->name); + if (failed_to_rotate) { + cmd_ret = rotation_fail_code; goto error; } + cmd_ret = LTTNG_OK; + goto end; + } + + session->rotation_state = LTTNG_ROTATION_STATE_ONGOING; + chunk_status = lttng_trace_chunk_get_id(chunk_being_archived, + &ongoing_rotation_chunk_id); + assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK); + + 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; + } + + if (failed_to_rotate) { + cmd_ret = rotation_fail_code; + goto error; } + session->quiet_rotation = quiet_rotation; ret = timer_session_rotation_pending_check_start(session, DEFAULT_ROTATE_PENDING_TIMER); if (ret) { @@ -4733,34 +5107,34 @@ int cmd_rotate_session(struct ltt_session *session, goto error; } - if (!session->active) { - session->rotated_after_last_stop = true; - } - if (rotate_return) { - rotate_return->rotation_id = session->current_archive_id; + rotate_return->rotation_id = ongoing_rotation_chunk_id; } - ret = notification_thread_command_session_rotation_ongoing( - notification_thread_handle, - session->name, session->uid, session->gid, - session->current_archive_id - 1); - if (ret != LTTNG_OK) { - ERR("Failed to notify notification thread that a session rotation is ongoing for session %s", - session->name); - cmd_ret = ret; + session->chunk_being_archived = chunk_being_archived; + chunk_being_archived = NULL; + if (!quiet_rotation) { + ret = notification_thread_command_session_rotation_ongoing( + notification_thread_handle, + session->name, session->uid, session->gid, + 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); + cmd_ret = ret; + } } DBG("Cmd rotate session %s, archive_id %" PRIu64 " sent", - session->name, session->current_archive_id - 1); + 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: - session->last_chunk_start_ts = original_last_chunk_start_ts; - session->current_archive_id = original_current_chunk_start_ts; if (session_reset_rotation_state(session, - LTTNG_ROTATION_STATE_NO_ROTATION)) { + LTTNG_ROTATION_STATE_ERROR)) { ERR("Failed to reset rotation state of session \"%s\"", session->name); } @@ -4772,35 +5146,62 @@ error: * * Check if the session has finished its rotation. * - * Return 0 on success or else a LTTNG_ERR code. + * 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) { - int ret; - - assert(session); + 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->current_archive_id); + session->most_recent_chunk_id.value); - if (session->current_archive_id != rotation_id) { - info_return->status = (int32_t) LTTNG_ROTATION_STATE_EXPIRED; - ret = LTTNG_OK; - goto end; + 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); + assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK); + + 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_state = LTTNG_ROTATION_STATE_EXPIRED; + } else { + rotation_state = session->rotation_state; + } } - switch (session->rotation_state) { + switch (rotation_state) { + case LTTNG_ROTATION_STATE_NO_ROTATION: + DBG("Reporting that no rotation has occurred within the lifetime of session \"%s\"", + session->name); + 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); + break; case LTTNG_ROTATION_STATE_ONGOING: - DBG("Reporting that rotation id %" PRIu64 " of session %s is still pending", + DBG("Reporting that rotation id %" PRIu64 " of session \"%s\" is still pending", rotation_id, session->name); break; case LTTNG_ROTATION_STATE_COMPLETED: { + int fmt_ret; + char *chunk_path; char *current_tracing_path_reply; size_t current_tracing_path_reply_len; + DBG("Reporting that rotation id %" PRIu64 " of session \"%s\" is completed", + rotation_id, session->name); + switch (session_get_consumer_destination_type(session)) { case CONSUMER_DST_LOCAL: current_tracing_path_reply = @@ -4809,8 +5210,21 @@ int cmd_rotate_get_info(struct ltt_session *session, sizeof(info_return->location.local.absolute_path); info_return->location_type = (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); + if (fmt_ret == -1) { + PERROR("Failed to format the path of the last archived trace chunk"); + info_return->status = LTTNG_ROTATION_STATUS_ERROR; + cmd_ret = LTTNG_ERR_UNK; + goto end; + } break; case CONSUMER_DST_NET: + { + uint16_t ctrl_port, data_port; + current_tracing_path_reply = info_return->location.relay.relative_path; current_tracing_path_reply_len = @@ -4819,49 +5233,58 @@ int cmd_rotate_get_info(struct ltt_session *session, info_return->location.relay.protocol = (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_RELAY_PROTOCOL_TYPE_TCP; - ret = lttng_strncpy(info_return->location.relay.host, + fmt_ret = lttng_strncpy(info_return->location.relay.host, session_get_net_consumer_hostname(session), sizeof(info_return->location.relay.host)); - if (ret) { - ERR("Failed to host name to rotate_get_info reply"); + if (fmt_ret) { + ERR("Failed to copy host name to rotate_get_info reply"); info_return->status = LTTNG_ROTATION_STATUS_ERROR; - ret = -LTTNG_ERR_UNK; + cmd_ret = LTTNG_ERR_SET_URL; goto end; } - session_get_net_consumer_ports(session, - &info_return->location.relay.ports.control, - &info_return->location.relay.ports.data); + session_get_net_consumer_ports(session, &ctrl_port, &data_port); + 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; + chunk_path = strdup(session->last_chunk_path); + if (!chunk_path) { + ERR("Failed to allocate the path of the last archived trace chunk"); + info_return->status = LTTNG_ROTATION_STATUS_ERROR; + cmd_ret = LTTNG_ERR_UNK; + goto end; + } break; + } default: abort(); } - ret = lttng_strncpy(current_tracing_path_reply, - session->rotation_chunk.current_rotate_path, - current_tracing_path_reply_len); - if (ret) { - ERR("Failed to copy current tracing path to rotate_get_info reply"); + + 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"); info_return->status = LTTNG_ROTATION_STATUS_ERROR; - ret = -LTTNG_ERR_UNK; + cmd_ret = LTTNG_ERR_UNK; goto end; } break; } case LTTNG_ROTATION_STATE_ERROR: - DBG("Reporting that an error occurred during rotation %" PRIu64 " of session %s", + DBG("Reporting that an error occurred during rotation %" PRIu64 " of session \"%s\"", rotation_id, session->name); break; default: abort(); } - info_return->status = (int32_t) session->rotation_state; - ret = LTTNG_OK; + cmd_ret = LTTNG_OK; end: - return ret; + info_return->status = (int32_t) rotation_state; + return cmd_ret; } /*