X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-relayd%2Fsession.c;h=c4a62c986946ac09f73fe66108b060b534915ff3;hp=42c29aeb0b4816f5d83437f14aa6a4f3631762aa;hb=334dfcb7fdb6c4fabb16eea4fb25cf344c063579;hpb=fd0f1e3ef290b9d70e3856676298df5afb78d8dc diff --git a/src/bin/lttng-relayd/session.c b/src/bin/lttng-relayd/session.c index 42c29aeb0..c4a62c986 100644 --- a/src/bin/lttng-relayd/session.c +++ b/src/bin/lttng-relayd/session.c @@ -19,41 +19,145 @@ #define _LGPL_SOURCE #include +#include +#include #include -#include "lttng-relayd.h" #include "ctf-trace.h" +#include "lttng-relayd.h" #include "session.h" +#include "sessiond-trace-chunks.h" #include "stream.h" +#include /* Global session id used in the session creation. */ static uint64_t last_relay_session_id; static pthread_mutex_t last_relay_session_id_lock = PTHREAD_MUTEX_INITIALIZER; +static int session_set_anonymous_chunk(struct relay_session *session) +{ + int ret = 0; + struct lttng_trace_chunk *chunk = NULL; + enum lttng_trace_chunk_status status; + struct lttng_directory_handle output_directory; + char *output_path; + bool output_path_allocated = false; + + if (!opt_output_path) { + /* No output path defined */ + const char *home_dir = utils_get_home_dir(); + if (!home_dir) { + ERR("Home path not found." + " Please specify an output path using -o, --output PATH"); + ret = -1; + goto end; + } + ret = asprintf(&output_path, "%s/%s", home_dir, DEFAULT_TRACE_DIR_NAME); + if (ret < 0) { + PERROR("asprintf trace dir name"); + ret = -1; + goto end; + } + output_path_allocated = true; + } else { + output_path = opt_output_path; + output_path_allocated = false; + } + + ret = lttng_directory_handle_init(&output_directory, output_path); + if (ret) { + goto end; + } + + chunk = lttng_trace_chunk_create_anonymous(); + if (!chunk) { + goto end; + } + + status = lttng_trace_chunk_set_credentials_current_user(chunk); + if (status != LTTNG_TRACE_CHUNK_STATUS_OK) { + ret = -1; + goto end; + } + + status = lttng_trace_chunk_set_as_owner(chunk, &output_directory); + if (status != LTTNG_TRACE_CHUNK_STATUS_OK) { + ret = -1; + goto end; + } + session->current_trace_chunk = chunk; + chunk = NULL; +end: + lttng_trace_chunk_put(chunk); + lttng_directory_handle_fini(&output_directory); + if (output_path_allocated) { + free(output_path); + } + return ret; +} + /* * Create a new session by assigning a new session ID. * * Return allocated session or else NULL. */ struct relay_session *session_create(const char *session_name, - const char *hostname, uint32_t live_timer, - bool snapshot, uint32_t major, uint32_t minor) + const char *hostname, const char *base_path, + uint32_t live_timer, + bool snapshot, + const lttng_uuid sessiond_uuid, + const uint64_t *id_sessiond, + const uint64_t *current_chunk_id, + const time_t *creation_time, + uint32_t major, + uint32_t minor, + bool session_name_contains_creation_time) { - struct relay_session *session; + int ret; + struct relay_session *session = NULL; + + if (session_name && strstr(session_name, ".")) { + ERR("Illegal character in session name: \"%s\"", + session_name); + goto error; + } + if (base_path && strstr(base_path, "../")) { + ERR("Invalid session base path walks up the path hierarchy: \"%s\"", + base_path); + goto error; + } + if (hostname && strstr(hostname, ".")) { + ERR("Invalid character in hostname: \"%s\"", + hostname); + goto error; + } session = zmalloc(sizeof(*session)); if (!session) { - PERROR("relay session zmalloc"); + PERROR("Failed to allocate session"); goto error; } if (lttng_strncpy(session->session_name, session_name, sizeof(session->session_name))) { + WARN("Session name exceeds maximal allowed length"); goto error; } if (lttng_strncpy(session->hostname, hostname, sizeof(session->hostname))) { + WARN("Hostname exceeds maximal allowed length"); + goto error; + } + if (lttng_strncpy(session->base_path, base_path, + sizeof(session->base_path))) { + WARN("Base path exceeds maximal allowed length"); goto error; } + if (creation_time) { + LTTNG_OPTIONAL_SET(&session->creation_time, *creation_time); + } + session->session_name_contains_creation_time = + session_name_contains_creation_time; + session->ctf_traces_ht = lttng_ht_new(0, LTTNG_HT_TYPE_STRING); if (!session->ctf_traces_ht) { goto error; @@ -73,12 +177,50 @@ struct relay_session *session_create(const char *session_name, session->live_timer = live_timer; session->snapshot = snapshot; + lttng_uuid_copy(session->sessiond_uuid, sessiond_uuid); + + if (id_sessiond) { + LTTNG_OPTIONAL_SET(&session->id_sessiond, *id_sessiond); + } + + ret = sessiond_trace_chunk_registry_session_created( + sessiond_trace_chunk_registry, sessiond_uuid); + if (ret) { + goto error; + } + + if (id_sessiond && current_chunk_id) { + session->current_trace_chunk = + sessiond_trace_chunk_registry_get_chunk( + sessiond_trace_chunk_registry, + session->sessiond_uuid, + session->id_sessiond.value, + *current_chunk_id); + if (!session->current_trace_chunk) { + char uuid_str[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); + } + } else if (!id_sessiond) { + /* + * Pre-2.11 peers will not announce trace chunks. An + * anonymous trace chunk which will remain set for the + * duration of the session is created. + */ + ret = session_set_anonymous_chunk(session); + if (ret) { + goto error; + } + } lttng_ht_add_unique_u64(sessions_ht, &session->session_n); return session; error: - free(session); + session_put(session); return NULL; } @@ -154,6 +296,13 @@ static void destroy_session(struct relay_session *session) ret = session_delete(session); assert(!ret); + lttng_trace_chunk_put(session->current_trace_chunk); + session->current_trace_chunk = NULL; + lttng_trace_chunk_put(session->pending_closure_trace_chunk); + session->pending_closure_trace_chunk = NULL; + ret = sessiond_trace_chunk_registry_session_destroyed( + sessiond_trace_chunk_registry, session->sessiond_uuid); + assert(!ret); call_rcu(&session->rcu_node, rcu_destroy_session); }