X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fsession.c;h=95395c282a2ab79d89b23450a3cc531bea7e28ad;hp=2a7b8b83bb8d643ecdfcfdbd3c1364e69b562b10;hb=86eff0042bf0b9e6277b281c4f3a680d997790d2;hpb=6fa5fe7cc78bea0b0bba154a0f911d3df530e18f diff --git a/src/bin/lttng-sessiond/session.c b/src/bin/lttng-sessiond/session.c index 2a7b8b83b..95395c282 100644 --- a/src/bin/lttng-sessiond/session.c +++ b/src/bin/lttng-sessiond/session.c @@ -1,18 +1,8 @@ /* - * Copyright (C) 2011 - David Goulet + * Copyright (C) 2011 David Goulet * - * 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 @@ -46,6 +36,11 @@ struct ltt_session_destroy_notifier_element { void *user_data; }; +struct ltt_session_clear_notifier_element { + ltt_session_clear_notifier notifier; + void *user_data; +}; + /* * NOTES: * @@ -262,15 +257,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; @@ -286,7 +281,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: @@ -302,7 +297,7 @@ end: * * The session list lock must be held. */ -int ltt_sessions_ht_alloc(void) +static int ltt_sessions_ht_alloc(void) { int ret = 0; @@ -423,7 +418,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; @@ -476,29 +471,29 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session, CONSUMER_DST_LOCAL; session->ust_session->current_trace_chunk = new_trace_chunk; - if (is_local_trace) { + if (is_local_trace) { enum lttng_error_code ret_error_code; ret_error_code = ust_app_create_channel_subdirectories( session->ust_session); if (ret_error_code != LTTNG_OK) { - ret = -ret_error_code; goto error; } - } + } cds_lfht_for_each_entry( session->ust_session->consumer->socks->ht, &iter, socket, node.node) { pthread_mutex_lock(socket->lock); ret = consumer_create_trace_chunk(socket, relayd_id, - session->id, new_trace_chunk); + session->id, new_trace_chunk, + DEFAULT_UST_TRACE_DIR); pthread_mutex_unlock(socket->lock); - if (ret) { + if (ret) { goto error; - } - } - } + } + } + } if (session->kernel_session) { const uint64_t relayd_id = session->kernel_session->consumer->net_seq_index; @@ -513,23 +508,23 @@ 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; } - } + } cds_lfht_for_each_entry( session->kernel_session->consumer->socks->ht, &iter, socket, node.node) { pthread_mutex_lock(socket->lock); ret = consumer_create_trace_chunk(socket, relayd_id, - session->id, new_trace_chunk); + session->id, new_trace_chunk, + DEFAULT_KERNEL_TRACE_DIR); pthread_mutex_unlock(socket->lock); - if (ret) { + if (ret) { goto error; - } - } - } + } + } + } /* * Update local current trace chunk state last, only if all remote @@ -553,7 +548,7 @@ error: if (session->kernel_session) { session->kernel_session->current_trace_chunk = NULL; } - /* + /* * Release references taken in the case where all references could not * be acquired. */ @@ -565,25 +560,6 @@ error: goto end_no_move; } -bool session_output_supports_trace_chunks(const struct ltt_session *session) -{ - const struct consumer_output *output = session->kernel_session ? - session->kernel_session->consumer : - session->ust_session->consumer; - - if (output->type == CONSUMER_DST_LOCAL) { - return true; - } else { - 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( const struct ltt_session *session, const struct consumer_output *consumer_output_override, @@ -596,13 +572,14 @@ struct lttng_trace_chunk *session_create_new_trace_chunk( const time_t chunk_creation_ts = time(NULL); bool is_local_trace; const char *base_path; - struct lttng_directory_handle session_output_directory; + struct lttng_directory_handle *session_output_directory = NULL; const struct lttng_credentials session_credentials = { .uid = session->uid, .gid = session->gid, }; uint64_t next_chunk_id; const struct consumer_output *output; + const char *new_path; if (consumer_output_override) { output = consumer_output_override; @@ -626,8 +603,26 @@ struct lttng_trace_chunk *session_create_new_trace_chunk( next_chunk_id = session->most_recent_chunk_id.is_set ? session->most_recent_chunk_id.value + 1 : 0; + if (session->current_trace_chunk && + !lttng_trace_chunk_get_name_overridden(session->current_trace_chunk)) { + chunk_status = lttng_trace_chunk_rename_path(session->current_trace_chunk, + DEFAULT_CHUNK_TMP_OLD_DIRECTORY); + if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) { + goto error; + } + } + if (!session->current_trace_chunk) { + if (!session->rotated) { + new_path = ""; + } else { + new_path = NULL; + } + } else { + new_path = DEFAULT_CHUNK_TMP_NEW_DIRECTORY; + } + trace_chunk = lttng_trace_chunk_create(next_chunk_id, - chunk_creation_ts); + chunk_creation_ts, new_path); if (!trace_chunk) { goto error; } @@ -661,28 +656,30 @@ struct lttng_trace_chunk *session_create_new_trace_chunk( if (ret) { goto error; } - ret = lttng_directory_handle_init(&session_output_directory, - base_path); - if (ret) { + session_output_directory = lttng_directory_handle_create(base_path); + if (!session_output_directory) { goto error; } chunk_status = lttng_trace_chunk_set_as_owner(trace_chunk, - &session_output_directory); - lttng_directory_handle_fini(&session_output_directory); + session_output_directory); + lttng_directory_handle_put(session_output_directory); + session_output_directory = NULL; if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) { goto error; } end: return trace_chunk; error: + lttng_directory_handle_put(session_output_directory); lttng_trace_chunk_put(trace_chunk); trace_chunk = NULL; goto end; } -int session_close_trace_chunk(const struct ltt_session *session, +int session_close_trace_chunk(struct ltt_session *session, struct lttng_trace_chunk *trace_chunk, - const enum lttng_trace_chunk_command_type *close_command) + enum lttng_trace_chunk_command_type close_command, + char *closed_trace_chunk_path) { int ret = 0; bool error_occurred = false; @@ -690,14 +687,13 @@ int session_close_trace_chunk(const struct ltt_session *session, struct consumer_socket *socket; enum lttng_trace_chunk_status chunk_status; const time_t chunk_close_timestamp = time(NULL); + const char *new_path; - if (close_command) { - chunk_status = lttng_trace_chunk_set_close_command( - trace_chunk, *close_command); - if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) { - ret = -1; - goto end; - } + chunk_status = lttng_trace_chunk_set_close_command( + trace_chunk, close_command); + if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) { + ret = -1; + goto end; } if (chunk_close_timestamp == (time_t) -1) { @@ -706,6 +702,44 @@ int session_close_trace_chunk(const struct ltt_session *session, ret = -1; goto end; } + + if (close_command == LTTNG_TRACE_CHUNK_COMMAND_TYPE_DELETE && !session->rotated) { + /* New chunk stays in session output directory. */ + new_path = ""; + } else { + /* Use chunk name for new chunk. */ + new_path = NULL; + } + if (session->current_trace_chunk && + !lttng_trace_chunk_get_name_overridden(session->current_trace_chunk)) { + /* Rename new chunk path. */ + chunk_status = lttng_trace_chunk_rename_path(session->current_trace_chunk, + new_path); + if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) { + ret = -1; + goto end; + } + } + if (!lttng_trace_chunk_get_name_overridden(trace_chunk) && + close_command == LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION) { + const char *old_path; + + if (!session->rotated) { + old_path = ""; + } else { + old_path = NULL; + } + /* We need to move back the .tmp_old_chunk to its rightful place. */ + chunk_status = lttng_trace_chunk_rename_path(trace_chunk, + old_path); + if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) { + ret = -1; + goto end; + } + } + if (close_command == LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED) { + session->rotated = true; + } chunk_status = lttng_trace_chunk_set_close_timestamp(trace_chunk, chunk_close_timestamp); if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) { @@ -726,7 +760,7 @@ int session_close_trace_chunk(const struct ltt_session *session, ret = consumer_close_trace_chunk(socket, 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"); @@ -745,7 +779,7 @@ int session_close_trace_chunk(const struct ltt_session *session, ret = consumer_close_trace_chunk(socket, 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"); @@ -758,6 +792,83 @@ end: return ret; } +/* + * This function skips the metadata channel as the begin/end timestamps of a + * metadata packet are useless. + * + * Moreover, opening a packet after a "clear" will cause problems for live + * sessions as it will introduce padding that was not part of the first trace + * chunk. The relay daemon expects the content of the metadata stream of + * successive metadata trace chunks to be strict supersets of one another. + * + * For example, flushing a packet at the beginning of the metadata stream of + * a trace chunk resulting from a "clear" session command will cause the + * size of the metadata stream of the new trace chunk to not match the size of + * the metadata stream of the original chunk. This will confuse the relay + * daemon as the same "offset" in a metadata stream will no longer point + * to the same content. + */ +static +enum lttng_error_code session_kernel_open_packets(struct ltt_session *session) +{ + enum lttng_error_code ret = LTTNG_OK; + struct consumer_socket *socket; + struct lttng_ht_iter iter; + struct cds_lfht_node *node; + struct ltt_kernel_channel *chan; + + rcu_read_lock(); + + cds_lfht_first(session->kernel_session->consumer->socks->ht, &iter.iter); + node = cds_lfht_iter_get_node(&iter.iter); + socket = container_of(node, typeof(*socket), node.node); + + cds_list_for_each_entry(chan, + &session->kernel_session->channel_list.head, list) { + int open_ret; + + DBG("Open packet of kernel channel: channel key = %" PRIu64 + ", session name = %s, session_id = %" PRIu64, + chan->key, session->name, session->id); + + open_ret = consumer_open_channel_packets(socket, chan->key); + if (open_ret < 0) { + /* General error (no known error expected). */ + ret = LTTNG_ERR_UNK; + goto end; + } + } + +end: + rcu_read_unlock(); + return ret; +} + +enum lttng_error_code session_open_packets(struct ltt_session *session) +{ + enum lttng_error_code ret = LTTNG_OK; + + DBG("Opening packets of session channels: session name = %s, session id = %" PRIu64, + session->name, session->id); + + if (session->ust_session) { + ret = ust_app_open_packets(session); + if (ret != LTTNG_OK) { + goto end; + } + } + + if (session->kernel_session) { + ret = session_kernel_open_packets(session); + if (ret != LTTNG_OK) { + goto end; + } + } + +end: + return ret; +} + /* * Set a session's current trace chunk. * @@ -788,6 +899,25 @@ void session_notify_destruction(const struct ltt_session *session) } } +/* + * Fire each clear notifier once, and remove them from the array. + */ +void session_notify_clear(struct ltt_session *session) +{ + size_t i; + const size_t count = lttng_dynamic_array_get_count( + &session->clear_notifiers); + + for (i = 0; i < count; i++) { + const struct ltt_session_clear_notifier_element *element = + lttng_dynamic_array_get_element( + &session->clear_notifiers, i); + + element->notifier(session, element->user_data); + } + lttng_dynamic_array_clear(&session->clear_notifiers); +} + static void session_release(struct urcu_ref *ref) { @@ -802,7 +932,7 @@ void session_release(struct urcu_ref *ref) usess = session->ust_session; ksess = session->kernel_session; - /* Clean kernel session teardown, keeping data for destroy notifier. */ + /* Clean kernel session teardown, keeping data for destroy notifier. */ kernel_destroy_session(ksess); /* UST session teardown, keeping data for destroy notifier. */ @@ -831,7 +961,6 @@ 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); @@ -843,6 +972,7 @@ void session_release(struct urcu_ref *ref) } session_notify_destruction(session); + consumer_output_put(session->consumer); kernel_free_session(ksess); session->kernel_session = NULL; if (usess) { @@ -850,6 +980,7 @@ void session_release(struct urcu_ref *ref) session->ust_session = NULL; } lttng_dynamic_array_reset(&session->destroy_notifiers); + lttng_dynamic_array_reset(&session->clear_notifiers); free(session->last_archived_chunk_name); free(session->base_path); free(session); @@ -918,6 +1049,18 @@ int session_add_destroy_notifier(struct ltt_session *session, &element); } +int session_add_clear_notifier(struct ltt_session *session, + ltt_session_clear_notifier notifier, void *user_data) +{ + const struct ltt_session_clear_notifier_element element = { + .notifier = notifier, + .user_data = user_data + }; + + return lttng_dynamic_array_add_element(&session->clear_notifiers, + &element); +} + /* * Return a ltt_session structure ptr that matches name. If no session found, * NULL is returned. This must be called with the session list lock held using @@ -982,7 +1125,7 @@ end: * Session list lock must be held by the caller. */ enum lttng_error_code session_create(const char *name, uid_t uid, gid_t gid, - const char *base_path, struct ltt_session **out_session) + struct ltt_session **out_session) { int ret; enum lttng_error_code ret_code; @@ -1009,6 +1152,9 @@ enum lttng_error_code session_create(const char *name, uid_t uid, gid_t gid, lttng_dynamic_array_init(&new_session->destroy_notifiers, sizeof(struct ltt_session_destroy_notifier_element), NULL); + lttng_dynamic_array_init(&new_session->clear_notifiers, + sizeof(struct ltt_session_clear_notifier_element), + NULL); urcu_ref_init(&new_session->ref); pthread_mutex_init(&new_session->lock, NULL); @@ -1065,6 +1211,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 @@ -1105,16 +1252,6 @@ enum lttng_error_code session_create(const char *name, uid_t uid, gid_t gid, } } - if (base_path) { - new_session->base_path = strdup(base_path); - if (!new_session->base_path) { - ERR("Failed to allocate base path of session \"%s\"", - name); - ret_code = LTTNG_ERR_SESSION_FAIL; - goto error; - } - } - new_session->uid = uid; new_session->gid = gid; @@ -1182,7 +1319,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. * @@ -1212,6 +1349,11 @@ int session_reset_rotation_state(struct ltt_session *session, chunk_id); lttng_trace_chunk_put(session->chunk_being_archived); session->chunk_being_archived = NULL; + /* + * Fire the clear reply notifiers if we are completing a clear + * rotation. + */ + session_notify_clear(session); } return ret; }