X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-relayd%2Fsession.c;h=0997fdd6579469098f0db94eb8d31fbfc0ef183c;hp=14ae874ea782ef45624447659d988c1bd3a05258;hb=c35f9726a22f1d93e14589688d830efccda196f3;hpb=bda7c7b9b4c633de16f3d8bf109f9d21fdd9a5fb diff --git a/src/bin/lttng-relayd/session.c b/src/bin/lttng-relayd/session.c index 14ae874ea..0997fdd65 100644 --- a/src/bin/lttng-relayd/session.c +++ b/src/bin/lttng-relayd/session.c @@ -17,41 +17,93 @@ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE #define _LGPL_SOURCE #include +#include #include #include "lttng-relayd.h" #include "ctf-trace.h" #include "session.h" #include "stream.h" +#include "sessiond-trace-chunks.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; + + ret = lttng_directory_handle_init(&output_directory, opt_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); + 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, + 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; } - session->ctf_traces_ht = lttng_ht_new(0, LTTNG_HT_TYPE_STRING); if (!session->ctf_traces_ht) { - free(session); - session = NULL; goto error; } @@ -65,35 +117,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); - strncpy(session->session_name, session_name, - sizeof(session->session_name)); - strncpy(session->hostname, hostname, - sizeof(session->hostname)); 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: - return 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); } /* @@ -131,7 +212,14 @@ static void rcu_destroy_session(struct rcu_head *rcu_head) struct relay_session *session = caa_container_of(rcu_head, struct relay_session, rcu_node); - + /* + * Since each trace has a reference on the session, it means + * that if we are at the point where we teardown the session, no + * trace belonging to that session exist at this point. + * Calling lttng_ht_destroy in call_rcu worker thread so we + * don't hold the RCU read-side lock while calling it. + */ + lttng_ht_destroy(session->ctf_traces_ht); free(session); } @@ -155,12 +243,11 @@ static void destroy_session(struct relay_session *session) ret = session_delete(session); assert(!ret); - /* - * Since each trace has a reference on the session, it means - * that if we are at the point where we teardown the session, no - * trace belonging to that session exist at this point. - */ - lttng_ht_destroy(session->ctf_traces_ht); + lttng_trace_chunk_put(session->current_trace_chunk); + session->current_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); } @@ -175,9 +262,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(); } @@ -191,16 +276,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, @@ -225,11 +302,30 @@ 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; struct relay_session *session; + if (!sessions_ht) { + return; + } + rcu_read_lock(); cds_lfht_for_each_entry(sessions_ht->ht, &iter.iter, session, session_n.node) {