X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-relayd%2Fsession.c;h=de059aae203e2df17054f9bd1d415279e0bd23bf;hp=9702bd220b0d134bc4502ecd6e4435e682e22ba1;hb=590f0324d6dfd382f79229a7934fa8b5b661641f;hpb=bb5d54e7416f8af61ac931c3b50b4df576e76731 diff --git a/src/bin/lttng-relayd/session.c b/src/bin/lttng-relayd/session.c index 9702bd220..de059aae2 100644 --- a/src/bin/lttng-relayd/session.c +++ b/src/bin/lttng-relayd/session.c @@ -19,41 +19,124 @@ #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" /* 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; + const char *base_path = opt_output_path; + + if (base_path == NULL) { + /* 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"); + ret = -1; + goto end; + } + } + + ret = lttng_directory_handle_init(&output_directory, base_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); + 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) { - 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; + } + session->ctf_traces_ht = lttng_ht_new(0, LTTNG_HT_TYPE_STRING); if (!session->ctf_traces_ht) { goto error; @@ -69,33 +152,64 @@ struct relay_session *session_create(const char *session_name, urcu_ref_init(&session->ref); CDS_INIT_LIST_HEAD(&session->recv_list); pthread_mutex_init(&session->lock, NULL); - pthread_mutex_init(&session->reflock, NULL); pthread_mutex_init(&session->recv_list_lock, NULL); 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); + if (creation_time) { + LTTNG_OPTIONAL_SET(&session->creation_time, *creation_time); + } return session; error: - free(session); + session_put(session); return NULL; } /* Should be called with RCU read-side lock held. */ bool session_get(struct relay_session *session) { - bool has_ref = false; - - pthread_mutex_lock(&session->reflock); - if (session->ref.refcount != 0) { - has_ref = true; - urcu_ref_get(&session->ref); - } - pthread_mutex_unlock(&session->reflock); - - return has_ref; + return urcu_ref_get_unless_zero(&session->ref); } /* @@ -164,6 +278,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); } @@ -178,9 +299,7 @@ void session_release(struct urcu_ref *ref) void session_put(struct relay_session *session) { rcu_read_lock(); - pthread_mutex_lock(&session->reflock); urcu_ref_put(&session->ref, session_release); - pthread_mutex_unlock(&session->reflock); rcu_read_unlock(); } @@ -194,16 +313,8 @@ int session_close(struct relay_session *session) pthread_mutex_lock(&session->lock); DBG("closing session %" PRIu64 ": is conn already closed %d", session->id, session->connection_closed); - if (session->connection_closed) { - ret = -1; - goto unlock; - } session->connection_closed = true; -unlock: pthread_mutex_unlock(&session->lock); - if (ret) { - return ret; - } rcu_read_lock(); cds_lfht_for_each_entry(session->ctf_traces_ht->ht, @@ -228,6 +339,21 @@ rcu_unlock: return ret; } +int session_abort(struct relay_session *session) +{ + int ret = 0; + + if (!session) { + return 0; + } + + pthread_mutex_lock(&session->lock); + DBG("aborting session %" PRIu64, session->id); + session->aborted = true; + pthread_mutex_unlock(&session->lock); + return ret; +} + void print_sessions(void) { struct lttng_ht_iter iter;