X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-relayd%2Fsession.c;h=603a80978701f000d2aa0284d52dcbb83824c125;hp=f76fb4a42e7606b8ebfea427033b00e3de192020;hb=6fa5fe7cc78bea0b0bba154a0f911d3df530e18f;hpb=98ba050ed140ff29ac98f66dba0e47db70e4a0c5 diff --git a/src/bin/lttng-relayd/session.c b/src/bin/lttng-relayd/session.c index f76fb4a42..603a80978 100644 --- a/src/bin/lttng-relayd/session.c +++ b/src/bin/lttng-relayd/session.c @@ -19,41 +19,108 @@ #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) { + int ret; struct relay_session *session; 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 +136,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 +262,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 +283,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 +297,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, @@ -238,13 +333,7 @@ int session_abort(struct relay_session *session) pthread_mutex_lock(&session->lock); DBG("aborting session %" PRIu64, session->id); - if (session->aborted) { - ERR("session %" PRIu64 " is already aborted", session->id); - ret = -1; - goto unlock; - } session->aborted = true; -unlock: pthread_mutex_unlock(&session->lock); return ret; }