X-Git-Url: https://git.liburcu.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-relayd%2Fsession.c;h=7888d38f2fefd30f3ce423bbccaff0633c092fcb;hb=acb26e636f4bbf703ea1172a31cd0f9648bbd721;hp=00dfbd7d2e6e5c873b01dd66b80a7d3098198162;hpb=6ec9dc48cf7f3d5e1fc01f741197c0bacc94bbf0;p=lttng-tools.git diff --git a/src/bin/lttng-relayd/session.c b/src/bin/lttng-relayd/session.c index 00dfbd7d2..7888d38f2 100644 --- a/src/bin/lttng-relayd/session.c +++ b/src/bin/lttng-relayd/session.c @@ -1,29 +1,19 @@ /* - * Copyright (C) 2013 - Julien Desfossez - * David Goulet - * 2015 - Mathieu Desnoyers + * Copyright (C) 2013 Julien Desfossez + * Copyright (C) 2013 David Goulet + * Copyright (C) 2015 Mathieu Desnoyers * - * 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 #include -#include +#include +#include #include #include #include -#include #include #include @@ -181,6 +171,38 @@ static int init_session_output_path(struct relay_session *session) return ret; } +static struct lttng_directory_handle *session_create_output_directory_handle( + struct relay_session *session) +{ + int ret; + /* + * relayd_output_path/session_directory + * e.g. /home/user/lttng-traces/hostname/session_name + */ + char *full_session_path = NULL; + struct lttng_directory_handle *handle = NULL; + + pthread_mutex_lock(&session->lock); + full_session_path = create_output_path(session->output_path); + if (!full_session_path) { + goto end; + } + + ret = utils_mkdir_recursive( + full_session_path, S_IRWXU | S_IRWXG, -1, -1); + if (ret) { + ERR("Failed to create session output path \"%s\"", + full_session_path); + goto end; + } + + handle = fd_tracker_create_directory_handle(the_fd_tracker, full_session_path); +end: + pthread_mutex_unlock(&session->lock); + free(full_session_path); + return handle; +} + static int session_set_anonymous_chunk(struct relay_session *session) { int ret = 0; @@ -198,6 +220,7 @@ static int session_set_anonymous_chunk(struct relay_session *session) goto end; } + lttng_trace_chunk_set_fd_tracker(chunk, the_fd_tracker); status = lttng_trace_chunk_set_credentials_current_user(chunk); if (status != LTTNG_TRACE_CHUNK_STATUS_OK) { ret = -1; @@ -209,7 +232,7 @@ static int session_set_anonymous_chunk(struct relay_session *session) ret = -1; goto end; } - output_directory = NULL; + session->current_trace_chunk = chunk; chunk = NULL; end: @@ -292,9 +315,20 @@ struct relay_session *session_create(const char *session_name, PERROR("Failed to allocate session"); goto error; } + + pthread_mutex_lock(&last_relay_session_id_lock); + session->id = ++last_relay_session_id; + pthread_mutex_unlock(&last_relay_session_id_lock); + + lttng_ht_node_init_u64(&session->session_n, session->id); + urcu_ref_init(&session->ref); + CDS_INIT_LIST_HEAD(&session->recv_list); + pthread_mutex_init(&session->lock, NULL); + pthread_mutex_init(&session->recv_list_lock, NULL); + if (lttng_strncpy(session->session_name, session_name, sizeof(session->session_name))) { - WARN("Session name exceeds maximal allowed length"); + WARN("Session name exceeds maximal allowed length"); goto error; } if (lttng_strncpy(session->hostname, hostname, @@ -309,6 +343,12 @@ struct relay_session *session_create(const char *session_name, } if (creation_time) { LTTNG_OPTIONAL_SET(&session->creation_time, *creation_time); + } else { + LTTNG_OPTIONAL_SET(&session->creation_time, time(NULL)); + if (session->creation_time.value == (time_t) -1) { + PERROR("Failed to sample session creation time"); + goto error; + } } session->session_name_contains_creation_time = session_name_contains_creation_time; @@ -318,17 +358,8 @@ struct relay_session *session_create(const char *session_name, goto error; } - pthread_mutex_lock(&last_relay_session_id_lock); - session->id = ++last_relay_session_id; - pthread_mutex_unlock(&last_relay_session_id_lock); - session->major = major; session->minor = minor; - lttng_ht_node_init_u64(&session->session_n, session->id); - urcu_ref_init(&session->ref); - CDS_INIT_LIST_HEAD(&session->recv_list); - pthread_mutex_init(&session->lock, NULL); - pthread_mutex_init(&session->recv_list_lock, NULL); session->live_timer = live_timer; session->snapshot = snapshot; @@ -353,6 +384,9 @@ struct relay_session *session_create(const char *session_name, } if (id_sessiond && current_chunk_id) { + enum lttng_trace_chunk_status chunk_status; + struct lttng_directory_handle *session_output_directory; + session->current_trace_chunk = sessiond_trace_chunk_registry_get_chunk( sessiond_trace_chunk_registry, @@ -360,13 +394,24 @@ struct relay_session *session_create(const char *session_name, session->id_sessiond.value, *current_chunk_id); if (!session->current_trace_chunk) { - char uuid_str[LTTNG_UUID_STR_LEN]; + char uuid_str[LTTNG_UUID_STR_LEN]; lttng_uuid_to_str(sessiond_uuid, uuid_str); ERR("Could not find trace chunk: sessiond = {%s}, sessiond session id = %" PRIu64 ", trace chunk id = %" PRIu64, uuid_str, *id_sessiond, *current_chunk_id); - } + goto error; + } + + chunk_status = lttng_trace_chunk_get_session_output_directory_handle( + session->current_trace_chunk, + &session_output_directory); + if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) { + goto error; + } + + assert(session_output_directory); + session->output_directory = session_output_directory; } else if (!id_sessiond) { /* * Pre-2.11 peers will not announce trace chunks. An @@ -377,6 +422,12 @@ struct relay_session *session_create(const char *session_name, if (ret) { goto error; } + } else { + session->output_directory = + session_create_output_directory_handle(session); + if (!session->output_directory) { + goto error; + } } lttng_ht_add_unique_u64(sessions_ht, &session->session_n); @@ -423,6 +474,89 @@ end: return session; } +/* + * Check if any of the relay sessions originating from the same + * session daemon session have the 'ongoing_rotation' state set. + * + * The caller must hold the lock of session. + */ +bool session_has_ongoing_rotation(struct relay_session *session) +{ + bool ongoing_rotation = false; + struct lttng_ht_iter iter; + struct relay_session *iterated_session; + + if (!session->id_sessiond.is_set) { + /* + * The peer that created this session is too old to + * support rotations; we can assume no rotations are ongoing. + */ + goto end; + } + + if (session->ongoing_rotation) { + ongoing_rotation = true; + goto end; + } + + rcu_read_lock(); + /* + * Sample the 'ongoing_rotation' status of all relay sessions that + * originate from the same session daemon session. + */ + cds_lfht_for_each_entry(sessions_ht->ht, &iter.iter, iterated_session, + session_n.node) { + if (!session_get(iterated_session)) { + continue; + } + + if (session == iterated_session) { + /* Skip this session. */ + goto next_session_no_unlock; + } + + pthread_mutex_lock(&iterated_session->lock); + + if (!iterated_session->id_sessiond.is_set) { + /* + * Session belongs to a peer that doesn't support + * rotations. + */ + goto next_session; + } + + if (!lttng_uuid_is_equal(session->sessiond_uuid, + iterated_session->sessiond_uuid)) { + /* Sessions do not originate from the same sessiond. */ + goto next_session; + } + + if (LTTNG_OPTIONAL_GET(session->id_sessiond) != + LTTNG_OPTIONAL_GET(iterated_session->id_sessiond)) { + /* + * Sessions do not originate from the same sessiond + * session. + */ + goto next_session; + } + + ongoing_rotation = iterated_session->ongoing_rotation; + +next_session: + pthread_mutex_unlock(&iterated_session->lock); +next_session_no_unlock: + session_put(iterated_session); + + if (ongoing_rotation) { + break; + } + } + rcu_read_unlock(); + +end: + return ongoing_rotation; +} + static void rcu_destroy_session(struct rcu_head *rcu_head) { struct relay_session *session = @@ -466,6 +600,8 @@ static void destroy_session(struct relay_session *session) ret = sessiond_trace_chunk_registry_session_destroyed( sessiond_trace_chunk_registry, session->sessiond_uuid); assert(!ret); + lttng_directory_handle_put(session->output_directory); + session->output_directory = NULL; call_rcu(&session->rcu_node, rcu_destroy_session); } @@ -561,35 +697,3 @@ void print_sessions(void) } rcu_read_unlock(); } - -struct lttng_directory_handle *session_create_output_directory_handle( - struct relay_session *session) -{ - int ret; - /* - * relayd_output_path/session_directory - * e.g. /home/user/lttng-traces/hostname/session_name - */ - char *full_session_path = NULL; - struct lttng_directory_handle *handle = NULL; - - pthread_mutex_lock(&session->lock); - full_session_path = create_output_path(session->output_path); - if (!full_session_path) { - goto end; - } - - ret = utils_mkdir_recursive( - full_session_path, S_IRWXU | S_IRWXG, -1, -1); - if (ret) { - ERR("Failed to create session output path \"%s\"", - full_session_path); - goto end; - } - - handle = lttng_directory_handle_create(full_session_path); -end: - pthread_mutex_unlock(&session->lock); - free(full_session_path); - return handle; -}