X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fbin%2Flttng-relayd%2Fsession.c;h=31f27184f5e1abeefb0908dcb330b23d138b9c09;hb=ecd1a12fac39784bded85c0f06e47ace2dc98cde;hp=5eedffc94e657aa924fb90ab72bf24b6056c6080;hpb=4f00620d66e81d89a546b29a774dad49d38983b3;p=lttng-tools.git diff --git a/src/bin/lttng-relayd/session.c b/src/bin/lttng-relayd/session.c index 5eedffc94..31f27184f 100644 --- a/src/bin/lttng-relayd/session.c +++ b/src/bin/lttng-relayd/session.c @@ -28,31 +28,131 @@ #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 init_session_output_path(struct relay_session *session) +{ + /* + * session_directory: + * + * if base_path is \0' + * hostname/session_name + * else + * hostname/base_path + */ + char *session_directory = NULL; + int ret = 0; + + if (session->output_path[0] != '\0') { + goto end; + } + /* + * If base path is set, it overrides the session name for the + * session relative base path. No timestamp is appended if the + * base path is overridden. + * + * If the session name already contains the creation time (e.g. + * auto-, don't append yet another timestamp after + * the session name in the generated path. + * + * Otherwise, generate the path with session_name-. + */ + if (session->base_path[0] != '\0') { + ret = asprintf(&session_directory, "%s/%s", session->hostname, + session->base_path); + } else if (session->session_name_contains_creation_time) { + ret = asprintf(&session_directory, "%s/%s", session->hostname, + session->session_name); + } else { + char session_creation_datetime[16]; + size_t strftime_ret; + struct tm *timeinfo; + time_t creation_time; + + /* + * The 2.11+ protocol guarantees that a creation time + * is provided for a session. This would indicate a + * protocol error or an improper use of this util. + */ + if (!session->creation_time.is_set) { + ERR("Creation time missing for session \"%s\" (protocol error)", + session->session_name); + ret = -1; + goto end; + } + creation_time = LTTNG_OPTIONAL_GET(session->creation_time); + + timeinfo = localtime(&creation_time); + if (!timeinfo) { + ERR("Failed to get timeinfo while initializing session output directory handle"); + ret = -1; + goto end; + } + strftime_ret = strftime(session_creation_datetime, + sizeof(session_creation_datetime), + "%Y%m%d-%H%M%S", timeinfo); + if (strftime_ret == 0) { + ERR("Failed to format session creation timestamp while initializing session output directory handle"); + ret = -1; + goto end; + } + ret = asprintf(&session_directory, "%s/%s-%s", + session->hostname, session->session_name, + session_creation_datetime); + } + if (ret < 0) { + PERROR("Failed to format session directory name"); + goto end; + } + + if (strlen(session_directory) >= LTTNG_PATH_MAX) { + ERR("Session output directory exceeds maximal length"); + ret = -1; + goto end; + } + strcpy(session->output_path, session_directory); + ret = 0; + +end: + free(session_directory); + return ret; +} + 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; - const char *base_path = opt_output_path; + char *output_path; + bool output_path_allocated = false; - if (base_path == NULL) { + if (!opt_output_path) { /* No output path defined */ - base_path = utils_get_home_dir(); - if (base_path == NULL) { - ERR("Home path not found.\n \ - Please specify an output path using -o, --output PATH"); + 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, base_path); + ret = lttng_directory_handle_init(&output_directory, output_path); if (ret) { goto end; } @@ -78,6 +178,9 @@ static int session_set_anonymous_chunk(struct relay_session *session) end: lttng_trace_chunk_put(chunk); lttng_directory_handle_fini(&output_directory); + if (output_path_allocated) { + free(output_path); + } return ret; } @@ -87,7 +190,7 @@ end: * Return allocated session or else NULL. */ struct relay_session *session_create(const char *session_name, - const char *hostname, + const char *hostname, const char *base_path, uint32_t live_timer, bool snapshot, const lttng_uuid sessiond_uuid, @@ -95,10 +198,27 @@ struct relay_session *session_create(const char *session_name, const uint64_t *current_chunk_id, const time_t *creation_time, uint32_t major, - uint32_t minor) + uint32_t minor, + bool session_name_contains_creation_time) { int ret; - struct relay_session *session; + 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) { @@ -115,6 +235,17 @@ struct relay_session *session_create(const char *session_name, 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; @@ -140,6 +271,10 @@ struct relay_session *session_create(const char *session_name, LTTNG_OPTIONAL_SET(&session->id_sessiond, *id_sessiond); } + ret = init_session_output_path(session); + if (ret) { + goto error; + } ret = sessiond_trace_chunk_registry_session_created( sessiond_trace_chunk_registry, sessiond_uuid); if (ret) { @@ -174,9 +309,6 @@ struct relay_session *session_create(const char *session_name, } lttng_ht_add_unique_u64(sessions_ht, &session->session_n); - if (creation_time) { - LTTNG_OPTIONAL_SET(&session->creation_time, *creation_time); - } return session; error: