X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fsession.c;h=ed68d153f20749630012c93a4487f6dad6efec96;hp=4b5c22bfb8626ef8f52b48ebbb75a77d9b4b05e8;hb=1f4962443f25c371e4b54e97f9eb867d67cbf88e;hpb=bbc4768c20f1c552222e1746f9475d145d7bf04e diff --git a/src/bin/lttng-sessiond/session.c b/src/bin/lttng-sessiond/session.c index 4b5c22bfb..ed68d153f 100644 --- a/src/bin/lttng-sessiond/session.c +++ b/src/bin/lttng-sessiond/session.c @@ -39,6 +39,7 @@ #include "utils.h" #include "trace-ust.h" #include "timer.h" +#include "cmd.h" struct ltt_session_destroy_notifier_element { ltt_session_destroy_notifier notifier; @@ -261,15 +262,15 @@ struct lttng_trace_archive_location *session_get_trace_archive_location( goto end; } - ret = asprintf(&chunk_path, "%s/" DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY "/%s", - session_get_base_path(session), - session->last_archived_chunk_name); - if (ret == -1) { - goto end; - } - switch (session_get_consumer_destination_type(session)) { case CONSUMER_DST_LOCAL: + ret = asprintf(&chunk_path, + "%s/" DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY "/%s", + session_get_base_path(session), + session->last_archived_chunk_name); + if (ret == -1) { + goto end; + } location = lttng_trace_archive_location_local_create( chunk_path); break; @@ -285,7 +286,7 @@ struct lttng_trace_archive_location *session_get_trace_archive_location( location = lttng_trace_archive_location_relay_create( hostname, LTTNG_TRACE_ARCHIVE_LOCATION_RELAY_PROTOCOL_TYPE_TCP, - control_port, data_port, chunk_path); + control_port, data_port, session->last_chunk_path); break; } default: @@ -422,7 +423,7 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session, struct lttng_trace_chunk *new_trace_chunk, struct lttng_trace_chunk **_current_trace_chunk) { - int ret; + int ret = 0; unsigned int i, refs_to_acquire = 0, refs_acquired = 0, refs_to_release = 0; struct cds_lfht_iter iter; struct consumer_socket *socket; @@ -481,7 +482,6 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session, ret_error_code = ust_app_create_channel_subdirectories( session->ust_session); if (ret_error_code != LTTNG_OK) { - ret = -ret_error_code; goto error; } } @@ -512,7 +512,6 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session, ret_error_code = kernel_create_channel_subdirectories( session->kernel_session); if (ret_error_code != LTTNG_OK) { - ret = -ret_error_code; goto error; } } @@ -564,34 +563,9 @@ error: goto end_no_move; } -static -bool output_supports_trace_chunks(const struct ltt_session *session) -{ - if (session->consumer->type == CONSUMER_DST_LOCAL) { - return true; - } else { - struct consumer_output *output; - - if (session->ust_session) { - output = session->ust_session->consumer; - } else if (session->kernel_session) { - output = session->kernel_session->consumer; - } else { - abort(); - } - - if (output->relay_major_version > 2) { - return true; - } else if (output->relay_major_version == 2 && - output->relay_minor_version >= 11) { - return true; - } - } - return false; -} - struct lttng_trace_chunk *session_create_new_trace_chunk( - struct ltt_session *session, + const struct ltt_session *session, + const struct consumer_output *consumer_output_override, const char *session_base_path_override, const char *chunk_name_override) { @@ -599,16 +573,28 @@ struct lttng_trace_chunk *session_create_new_trace_chunk( struct lttng_trace_chunk *trace_chunk = NULL; enum lttng_trace_chunk_status chunk_status; const time_t chunk_creation_ts = time(NULL); - const bool is_local_trace = - session->consumer->type == CONSUMER_DST_LOCAL; - const char *base_path = session_base_path_override ? : - session_get_base_path(session); + bool is_local_trace; + const char *base_path; struct lttng_directory_handle session_output_directory; const struct lttng_credentials session_credentials = { .uid = session->uid, .gid = session->gid, }; uint64_t next_chunk_id; + const struct consumer_output *output; + + if (consumer_output_override) { + output = consumer_output_override; + } else { + assert(session->ust_session || session->kernel_session); + output = session->ust_session ? + session->ust_session->consumer : + session->kernel_session->consumer; + } + + is_local_trace = output->type == CONSUMER_DST_LOCAL; + base_path = session_base_path_override ? : + consumer_output_get_base_path(output); if (chunk_creation_ts == (time_t) -1) { PERROR("Failed to sample time while creation session \"%s\" trace chunk", @@ -616,9 +602,6 @@ struct lttng_trace_chunk *session_create_new_trace_chunk( goto error; } - if (!output_supports_trace_chunks(session)) { - goto end; - } next_chunk_id = session->most_recent_chunk_id.is_set ? session->most_recent_chunk_id.value + 1 : 0; @@ -678,7 +661,8 @@ error: int session_close_trace_chunk(const struct ltt_session *session, struct lttng_trace_chunk *trace_chunk, - const enum lttng_trace_chunk_command_type *close_command) + const enum lttng_trace_chunk_command_type *close_command, + char *closed_trace_chunk_path) { int ret = 0; bool error_occurred = false; @@ -712,14 +696,17 @@ int session_close_trace_chunk(const struct ltt_session *session, } if (session->ust_session) { + const uint64_t relayd_id = + session->ust_session->consumer->net_seq_index; + cds_lfht_for_each_entry( session->ust_session->consumer->socks->ht, &iter, socket, node.node) { pthread_mutex_lock(socket->lock); ret = consumer_close_trace_chunk(socket, - session->consumer->net_seq_index, + relayd_id, session->id, - trace_chunk); + trace_chunk, closed_trace_chunk_path); pthread_mutex_unlock(socket->lock); if (ret) { ERR("Failed to close trace chunk on user space consumer"); @@ -728,14 +715,17 @@ int session_close_trace_chunk(const struct ltt_session *session, } } if (session->kernel_session) { + const uint64_t relayd_id = + session->kernel_session->consumer->net_seq_index; + cds_lfht_for_each_entry( session->kernel_session->consumer->socks->ht, &iter, socket, node.node) { pthread_mutex_lock(socket->lock); ret = consumer_close_trace_chunk(socket, - session->consumer->net_seq_index, + relayd_id, session->id, - trace_chunk); + trace_chunk, closed_trace_chunk_path); pthread_mutex_unlock(socket->lock); if (ret) { ERR("Failed to close trace chunk on kernel consumer"); @@ -785,32 +775,17 @@ void session_release(struct urcu_ref *ref) struct ltt_ust_session *usess; struct ltt_kernel_session *ksess; struct ltt_session *session = container_of(ref, typeof(*session), ref); + const bool session_published = session->published; assert(!session->chunk_being_archived); usess = session->ust_session; ksess = session->kernel_session; - session_notify_destruction(session); - lttng_dynamic_array_reset(&session->destroy_notifiers); - if (session->current_trace_chunk) { - ret = session_close_trace_chunk(session, session->current_trace_chunk, NULL); - if (ret) { - ERR("Failed to close the current trace chunk of session \"%s\" during its release", - session->name); - } - ret = _session_set_trace_chunk_no_lock_check(session, NULL, NULL); - if (ret) { - ERR("Failed to release the current trace chunk of session \"%s\" during its release", - session->name); - } - } - - /* Clean kernel session teardown */ + /* Clean kernel session teardown, keeping data for destroy notifier. */ kernel_destroy_session(ksess); - session->kernel_session = NULL; - /* UST session teardown */ + /* UST session teardown, keeping data for destroy notifier. */ if (usess) { /* Close any relayd session */ consumer_output_send_destroy_relayd(usess->consumer); @@ -821,9 +796,8 @@ void session_release(struct urcu_ref *ref) ERR("Error in ust_app_destroy_trace_all"); } - /* Clean up the rest. */ + /* Clean up the rest, keeping destroy notifier data. */ trace_ust_destroy_session(usess); - session->ust_session = NULL; } /* @@ -837,19 +811,35 @@ void session_release(struct urcu_ref *ref) DBG("Destroying session %s (id %" PRIu64 ")", session->name, session->id); - consumer_output_put(session->consumer); snapshot_destroy(&session->snapshot); pthread_mutex_destroy(&session->lock); - if (session->published) { + if (session_published) { ASSERT_LOCKED(ltt_session_list.lock); del_session_list(session); del_session_ht(session); - pthread_cond_broadcast(<t_session_list.removal_cond); } + session_notify_destruction(session); + + consumer_output_put(session->consumer); + kernel_free_session(ksess); + session->kernel_session = NULL; + if (usess) { + trace_ust_free_session(usess); + session->ust_session = NULL; + } + lttng_dynamic_array_reset(&session->destroy_notifiers); free(session->last_archived_chunk_name); + free(session->base_path); free(session); + if (session_published) { + /* + * Broadcast after free-ing to ensure the memory is + * reclaimed before the main thread exits. + */ + pthread_cond_broadcast(<t_session_list.removal_cond); + } } /* @@ -1055,6 +1045,7 @@ enum lttng_error_code session_create(const char *name, uid_t uid, gid_t gid, DEFAULT_SESSION_NAME, i, datetime); } + new_session->name_contains_creation_time = true; if (ret == -1 || ret >= sizeof(new_session->name)) { /* * Null-terminate in case the name is used @@ -1162,7 +1153,7 @@ int session_access_ok(struct ltt_session *session, uid_t uid, gid_t gid) * * Be careful of the result passed to this function. For instance, * on failure to launch a rotation, a client will expect the rotation - * state to be set to "NO_ROTATION". If an error occured while the + * state to be set to "NO_ROTATION". If an error occurred while the * rotation was "ONGOING", result should be set to "ERROR", which will * allow a client to report it. *