X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=4447747de752608f08aa02719af5254ab3f2a26c;hp=f6c44d3be16e63096e856874344dd39e11b4d348;hb=070b6a86970c981e8f79cbd3dc199008b25cc0dc;hpb=b5893d8e91f64257e58a50c7f5b413a5b31cf076 diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index f6c44d3be..4447747de 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -1038,9 +1038,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) + time_t session_creation_time, + bool session_name_contains_creation_time) { int ret; struct lttcomm_relayd_sock *rsock = NULL; @@ -1068,8 +1069,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, - current_chunk_id, session_creation_time); + 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; @@ -1116,8 +1118,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 uint64_t *current_chunk_id, time_t session_creation_time) + 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; @@ -1128,8 +1131,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, - current_chunk_id, session_creation_time); + 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; } @@ -1139,8 +1143,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, - current_chunk_id, session_creation_time); + 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; } @@ -1195,9 +1200,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->base_path, session->live_timer, current_chunk_id.is_set ? ¤t_chunk_id.value : NULL, - session->creation_time); + session->creation_time, + session->name_contains_creation_time); pthread_mutex_unlock(socket->lock); if (ret != LTTNG_OK) { goto error; @@ -1219,9 +1226,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->base_path, session->live_timer, current_chunk_id.is_set ? ¤t_chunk_id.value : NULL, - session->creation_time); + session->creation_time, + session->name_contains_creation_time); pthread_mutex_unlock(socket->lock); if (ret != LTTNG_OK) { goto error; @@ -2579,8 +2588,7 @@ int cmd_start_trace(struct ltt_session *session) goto error; } - if (session->output_traces && !session->current_trace_chunk && - session_output_supports_trace_chunks(session)) { + if (session->output_traces && !session->current_trace_chunk) { struct lttng_trace_chunk *trace_chunk; trace_chunk = session_create_new_trace_chunk( @@ -2872,6 +2880,7 @@ 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) { @@ -2894,8 +2903,13 @@ 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, - &new_session); + base_path, &new_session); if (ret_code != LTTNG_OK) { goto end; } @@ -3176,7 +3190,7 @@ int cmd_destroy_session(struct ltt_session *session, * Perform a last rotation on destruction if rotations have * occurred during the session's lifetime. */ - ret = cmd_rotate_session(session, NULL); + ret = cmd_rotate_session(session, NULL, false); 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)); @@ -3184,7 +3198,22 @@ int cmd_destroy_session(struct ltt_session *session, 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); + 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)); + } + } if (session->shm_path[0]) { /* @@ -4213,6 +4242,7 @@ static enum lttng_error_code set_relayd_for_snapshot( struct lttng_ht_iter iter; struct consumer_socket *socket; LTTNG_OPTIONAL(uint64_t) current_chunk_id = {}; + const char *base_path; assert(output); assert(session); @@ -4239,6 +4269,16 @@ static enum lttng_error_code set_relayd_for_snapshot( 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. @@ -4250,9 +4290,11 @@ static enum lttng_error_code set_relayd_for_snapshot( status = send_consumer_relayd_sockets(0, session->id, output, socket, session->name, session->hostname, + base_path, session->live_timer, current_chunk_id.is_set ? ¤t_chunk_id.value : NULL, - session->creation_time); + session->creation_time, + session->name_contains_creation_time); pthread_mutex_unlock(socket->lock); if (status != LTTNG_OK) { rcu_read_unlock(); @@ -4713,7 +4755,8 @@ 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) { int ret; uint64_t ongoing_rotation_chunk_id; @@ -4729,13 +4772,20 @@ 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 && + 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; @@ -4798,13 +4848,16 @@ int cmd_rotate_session(struct ltt_session *session, } ret = session_close_trace_chunk(session, chunk_being_archived, - &((enum lttng_trace_chunk_command_type) { - LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED})); + quiet_rotation ? + NULL : + &((enum lttng_trace_chunk_command_type){ + LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED})); if (ret) { cmd_ret = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER; goto error; } + session->quiet_rotation = quiet_rotation; ret = timer_session_rotation_pending_check_start(session, DEFAULT_ROTATE_PENDING_TIMER); if (ret) { @@ -4822,14 +4875,16 @@ int cmd_rotate_session(struct ltt_session *session, session->chunk_being_archived = chunk_being_archived; chunk_being_archived = NULL; - 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; + 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",