X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=53850f74aae784b97a668f30c429c92cca8858be;hp=577647a1c074597ecd7935e5e3d1e3a37e2d9b32;hb=dbfee52cc949c9ac51976ef4680f2e145aa1f1a9;hpb=46ef21888c975515837d5dab104c938c424792ed diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index 577647a1c..53850f74a 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -73,6 +73,11 @@ 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); @@ -107,7 +112,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, @@ -912,6 +917,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; } @@ -989,6 +998,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 */ @@ -1003,6 +1014,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 { @@ -1176,6 +1197,7 @@ 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); @@ -1189,8 +1211,6 @@ int cmd_setup_relayd(struct ltt_session *session) } } - rcu_read_lock(); - if (usess && usess->consumer && usess->consumer->type == CONSUMER_DST_NET && usess->consumer->enabled) { /* For each consumer socket, send relayd sockets */ @@ -1216,6 +1236,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 @@ -1242,6 +1264,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: @@ -1252,7 +1276,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; @@ -1304,7 +1328,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; @@ -1314,6 +1338,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. */ @@ -1336,7 +1407,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: @@ -1394,7 +1465,7 @@ int cmd_track_pid(struct ltt_session *session, enum lttng_domain_type domain, goto error; } - kernel_wait_quiescent(kernel_tracer_fd); + kernel_wait_quiescent(); break; } case LTTNG_DOMAIN_UST: @@ -1445,7 +1516,7 @@ int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain, goto error; } - kernel_wait_quiescent(kernel_tracer_fd); + kernel_wait_quiescent(); break; } case LTTNG_DOMAIN_UST: @@ -1478,27 +1549,29 @@ error: * 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) + 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(_attr); assert(domain); - len = lttng_strnlen(attr->name, sizeof(attr->name)); + attr = *_attr; + len = lttng_strnlen(attr.name, sizeof(attr.name)); /* Validate channel name */ - if (attr->name[0] == '.' || - memchr(attr->name, '/', len) != NULL) { + if (attr.name[0] == '.' || + memchr(attr.name, '/', len) != NULL) { ret = LTTNG_ERR_INVALID_CHANNEL_NAME; goto end; } - DBG("Enabling channel %s for session %s", attr->name, session->name); + DBG("Enabling channel %s for session %s", attr.name, session->name); rcu_read_lock(); @@ -1517,21 +1590,21 @@ int cmd_enable_channel(struct ltt_session *session, * beacons for inactive streams. */ if (session->live_timer > 0) { - attr->attr.live_timer_interval = session->live_timer; - attr->attr.switch_timer_interval = 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) { + 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); + attr.name, session->name); + lttng_channel_set_monitor_timer_interval(&attr, 0); } break; } @@ -1556,16 +1629,16 @@ int cmd_enable_channel(struct ltt_session *session, { 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 { @@ -1576,7 +1649,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: @@ -1595,19 +1668,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; @@ -1616,10 +1689,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 { @@ -1632,7 +1705,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: @@ -1645,11 +1718,11 @@ end: * 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); @@ -1711,7 +1784,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: @@ -1822,7 +1895,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; @@ -1993,7 +2066,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, @@ -2161,7 +2234,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: @@ -2390,7 +2463,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, @@ -2407,7 +2481,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, @@ -2429,7 +2503,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; @@ -2560,6 +2634,10 @@ int cmd_start_trace(struct ltt_session *session) unsigned long nb_chan = 0; struct ltt_kernel_session *ksession; struct ltt_ust_session *usess; + const bool session_rotated_after_last_stop = + session->rotated_after_last_stop; + const bool session_cleared_after_last_stop = + session->cleared_after_last_stop; assert(session); @@ -2573,6 +2651,22 @@ int cmd_start_trace(struct ltt_session *session) goto error; } + 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; + } + /* * Starting a session without channel is useless since after that it's not * possible to enable channel thus inform the client. @@ -2588,29 +2682,54 @@ int cmd_start_trace(struct ltt_session *session) goto error; } - if (session->output_traces && !session->current_trace_chunk && - session_output_supports_trace_chunks(session)) { - struct lttng_trace_chunk *trace_chunk; + 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; - 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; + 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,10 +2745,6 @@ int cmd_start_trace(struct ltt_session *session) } } - /* Flag this after a successful start. */ - session->has_been_started = 1; - session->active = 1; - /* * Clear the flag that indicates that a rotation was done while the * session was stopped. @@ -2650,6 +2765,17 @@ 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; + } return ret; } @@ -2659,14 +2785,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 +2801,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 +2814,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 +2883,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; } @@ -2881,7 +3027,6 @@ enum lttng_error_code cmd_create_session_from_descriptor( const char *session_name; struct ltt_session *new_session = NULL; enum lttng_session_descriptor_status descriptor_status; - const char *base_path; session_lock_list(); if (home_path) { @@ -2904,13 +3049,9 @@ enum lttng_error_code cmd_create_session_from_descriptor( ret_code = LTTNG_ERR_INVALID; goto end; } - ret = lttng_session_descriptor_get_base_path(descriptor, &base_path); - if (ret) { - ret_code = LTTNG_ERR_INVALID; - goto end; - } + ret_code = session_create(session_name, creds->uid, creds->gid, - base_path, &new_session); + &new_session); if (ret_code != LTTNG_OK) { goto end; } @@ -3062,7 +3203,7 @@ void cmd_destroy_session_reply(const struct ltt_session *session, struct lttng_trace_archive_location *location = NULL; struct lttcomm_lttng_msg llm = { .cmd_type = LTTNG_DESTROY_SESSION, - .ret_code = LTTNG_OK, + .ret_code = reply_context->destruction_status, .pid = UINT32_MAX, .cmd_header_size = sizeof(struct lttcomm_session_destroy_command_header), @@ -3144,6 +3285,7 @@ int cmd_destroy_session(struct ltt_session *session, 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) { @@ -3168,6 +3310,7 @@ int cmd_destroy_session(struct ltt_session *session, /* 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; } } @@ -3176,6 +3319,7 @@ int cmd_destroy_session(struct ltt_session *session, session)) { ERR("Failed to stop the \"rotation schedule\" timer of session %s", session->name); + destruction_last_error = LTTNG_ERR_TIMER_STOP_ERROR; } } @@ -3184,23 +3328,22 @@ int cmd_destroy_session(struct ltt_session *session, session->rotate_size = 0; } - if (session->most_recent_chunk_id.is_set && - session->most_recent_chunk_id.value != 0 && - session->current_trace_chunk && session->output_traces) { + 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); + 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 && - session_output_supports_trace_chunks(session)) { + } 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 @@ -3210,10 +3353,12 @@ int cmd_destroy_session(struct ltt_session *session, * emitted and no renaming of the current trace chunk takes * place. */ - ret = cmd_rotate_session(session, NULL, true); + ret = cmd_rotate_session(session, NULL, true, + LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION); if (ret != LTTNG_OK) { 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; } } @@ -3278,6 +3423,7 @@ int cmd_destroy_session(struct ltt_session *session, */ session_destroy(session); if (reply_context) { + reply_context->destruction_status = destruction_last_error; ret = session_add_destroy_notifier(session, cmd_destroy_session_reply, (void *) reply_context); @@ -3708,7 +3854,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; @@ -3776,7 +3922,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; @@ -4478,6 +4624,8 @@ enum lttng_error_code snapshot_record(struct ltt_session *session, 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) { @@ -4498,6 +4646,8 @@ enum lttng_error_code snapshot_record(struct ltt_session *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) { @@ -4563,8 +4713,14 @@ enum lttng_error_code snapshot_record(struct ltt_session *session, } } - if (session_close_trace_chunk( - session, session->current_trace_chunk, NULL)) { + 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. @@ -4573,11 +4729,6 @@ enum lttng_error_code snapshot_record(struct ltt_session *session, session->name); ret_code = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER; } - if (session_set_trace_chunk(session, NULL, NULL)) { - ERR("Failed to release the current trace chunk of session \"%s\"", - session->name); - ret_code = LTTNG_ERR_UNK; - } error: if (original_ust_consumer_output) { session->ust_session->consumer = original_ust_consumer_output; @@ -4600,7 +4751,7 @@ error: * 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; @@ -4758,7 +4909,8 @@ int cmd_set_session_shm_path(struct ltt_session *session, */ int cmd_rotate_session(struct ltt_session *session, struct lttng_rotate_session_return *rotate_return, - bool quiet_rotation) + bool quiet_rotation, + enum lttng_trace_chunk_command_type command) { int ret; uint64_t ongoing_rotation_chunk_id; @@ -4766,6 +4918,8 @@ int cmd_rotate_session(struct ltt_session *session, 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); @@ -4787,13 +4941,19 @@ int cmd_rotate_session(struct ltt_session *session, } /* Unsupported feature in lttng-relayd before 2.11. */ - if (session->consumer->type == CONSUMER_DST_NET && + 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); @@ -4812,7 +4972,16 @@ int cmd_rotate_session(struct ltt_session *session, goto end; } - session->rotation_state = LTTNG_ROTATION_STATE_ONGOING; + /* + * After a stop followed by a clear, disallow following rotations a they would + * generate empty chunks. + */ + 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; + } if (session->active) { new_trace_chunk = session_create_new_trace_chunk(session, NULL, @@ -4823,7 +4992,13 @@ int cmd_rotate_session(struct ltt_session *session, } } - /* The current trace chunk becomes the chunk being archived. */ + /* + * 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 = session_set_trace_chunk(session, new_trace_chunk, &chunk_being_archived); if (ret) { @@ -4831,34 +5006,53 @@ int cmd_rotate_session(struct ltt_session *session, goto error; } - assert(chunk_being_archived); - chunk_status = lttng_trace_chunk_get_id(chunk_being_archived, - &ongoing_rotation_chunk_id); - assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK); - if (session->kernel_session) { 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) { 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, - quiet_rotation ? - NULL : - &((enum lttng_trace_chunk_command_type){ - LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED})); + 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); @@ -4867,10 +5061,6 @@ 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 = ongoing_rotation_chunk_id; } @@ -4945,7 +5135,7 @@ int cmd_rotate_get_info(struct ltt_session *session, switch (rotation_state) { case LTTNG_ROTATION_STATE_NO_ROTATION: - DBG("Reporting that no rotation has occured within the lifetime of session \"%s\"", + DBG("Reporting that no rotation has occurred within the lifetime of session \"%s\"", session->name); goto end; case LTTNG_ROTATION_STATE_EXPIRED: @@ -4974,8 +5164,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 = @@ -4994,25 +5197,23 @@ int cmd_rotate_get_info(struct ltt_session *session, 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(); } - 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; - } fmt_ret = lttng_strncpy(current_tracing_path_reply, chunk_path, current_tracing_path_reply_len);