Fix: Check for NULL hash tables on relay daemon teardown
[lttng-tools.git] / src / bin / lttng-relayd / session.c
index 46d9cc66a587cfe6bbbb4520998e605217295e74..d1c2098f8591a3a8c9c5e87b022f43e8fff627ee 100644 (file)
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2013 - Julien Desfossez <jdesfossez@efficios.com>
  *                      David Goulet <dgoulet@efficios.com>
+ *               2015 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License, version 2 only, as
  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-#define _GNU_SOURCE
 #define _LGPL_SOURCE
 #include <common/common.h>
+#include <urcu/rculist.h>
 
+#include "lttng-relayd.h"
 #include "ctf-trace.h"
 #include "session.h"
 #include "stream.h"
 
 /* Global session id used in the session creation. */
 static uint64_t last_relay_session_id;
-
-static void rcu_destroy_session(struct rcu_head *head)
-{
-       struct relay_session *session =
-               caa_container_of(head, struct relay_session, rcu_node);
-
-       free(session);
-}
+static pthread_mutex_t last_relay_session_id_lock = PTHREAD_MUTEX_INITIALIZER;
 
 /*
  * Create a new session by assigning a new session ID.
  *
  * Return allocated session or else NULL.
  */
-struct relay_session *session_create(void)
+struct relay_session *session_create(const char *session_name,
+               const char *hostname, uint32_t live_timer,
+               bool snapshot, uint32_t major, uint32_t minor)
 {
        struct relay_session *session;
 
@@ -57,30 +54,62 @@ struct relay_session *session_create(void)
                goto error;
        }
 
-       pthread_mutex_init(&session->viewer_ready_lock, NULL);
+       pthread_mutex_lock(&last_relay_session_id_lock);
        session->id = ++last_relay_session_id;
+       pthread_mutex_unlock(&last_relay_session_id_lock);
+
+       session->major = major;
+       session->minor = minor;
        lttng_ht_node_init_u64(&session->session_n, session->id);
+       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_ht_add_unique_u64(sessions_ht, &session->session_n);
 
 error:
        return session;
 }
 
+/* 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;
+}
+
 /*
- * Lookup a session within the given hash table and session id. RCU read side
- * lock MUST be acquired before calling this and as long as the caller has a
- * reference to the object.
+ * Lookup a session within the session hash table using the session id
+ * as key. A session reference is taken when a session is returned.
+ * session_put() must be called on that session.
  *
  * Return session or NULL if not found.
  */
-struct relay_session *session_find_by_id(struct lttng_ht *ht, uint64_t id)
+struct relay_session *session_get_by_id(uint64_t id)
 {
        struct relay_session *session = NULL;
        struct lttng_ht_node_u64 *node;
        struct lttng_ht_iter iter;
 
-       assert(ht);
-
-       lttng_ht_lookup(ht, &id, &iter);
+       rcu_read_lock();
+       lttng_ht_lookup(sessions_ht, &id, &iter);
        node = lttng_ht_iter_get_node_u64(&iter);
        if (!node) {
                DBG("Session find by ID %" PRIu64 " id NOT found", id);
@@ -88,97 +117,134 @@ struct relay_session *session_find_by_id(struct lttng_ht *ht, uint64_t id)
        }
        session = caa_container_of(node, struct relay_session, session_n);
        DBG("Session find by ID %" PRIu64 " id found", id);
-
+       if (!session_get(session)) {
+               session = NULL;
+       }
 end:
+       rcu_read_unlock();
        return session;
 }
 
+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);
+}
+
 /*
  * Delete session from the given hash table.
  *
  * Return lttng ht del error code being 0 on success and 1 on failure.
  */
-int session_delete(struct lttng_ht *ht, struct relay_session *session)
+static int session_delete(struct relay_session *session)
 {
        struct lttng_ht_iter iter;
 
-       assert(ht);
-       assert(session);
-
        iter.iter.node = &session->session_n.node;
-       return lttng_ht_del(ht, &iter);
+       return lttng_ht_del(sessions_ht, &iter);
 }
 
-/*
- * The caller MUST be from the viewer thread since the viewer refcount is
- * decremented. With this calue down to 0, it will try to destroy the session.
- */
-void session_viewer_try_destroy(struct lttng_ht *ht,
-               struct relay_session *session)
+
+static void destroy_session(struct relay_session *session)
 {
-       unsigned long ret_ref;
+       int ret;
 
-       assert(session);
+       ret = session_delete(session);
+       assert(!ret);
+       call_rcu(&session->rcu_node, rcu_destroy_session);
+}
 
-       ret_ref = uatomic_add_return(&session->viewer_refcount, -1);
-       if (ret_ref == 0) {
-               session_try_destroy(ht, session);
-       }
+void session_release(struct urcu_ref *ref)
+{
+       struct relay_session *session =
+                       caa_container_of(ref, struct relay_session, ref);
+
+       destroy_session(session);
 }
 
-/*
- * Should only be called from the main streaming thread since it does not touch
- * the viewer refcount. If this refcount is down to 0, destroy the session only
- * and only if the session deletion succeeds. This is done because the viewer
- * *and* the streaming thread can both concurently try to destroy the session
- * thus the first come first serve.
- */
-void session_try_destroy(struct lttng_ht *ht, struct relay_session *session)
+void session_put(struct relay_session *session)
 {
-       int ret = 0;
-       unsigned long ret_ref;
+       rcu_read_lock();
+       pthread_mutex_lock(&session->reflock);
+       urcu_ref_put(&session->ref, session_release);
+       pthread_mutex_unlock(&session->reflock);
+       rcu_read_unlock();
+}
 
-       assert(session);
+int session_close(struct relay_session *session)
+{
+       int ret = 0;
+       struct ctf_trace *trace;
+       struct lttng_ht_iter iter;
+       struct relay_stream *stream;
+
+       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;
+       }
 
-       ret_ref = uatomic_read(&session->viewer_refcount);
-       if (ret_ref == 0 && session->close_flag) {
-               if (ht) {
-                       ret = session_delete(ht, session);
-               }
-               if (!ret) {
-                       /* Only destroy the session if the deletion was successful. */
-                       session_destroy(session);
+       rcu_read_lock();
+       cds_lfht_for_each_entry(session->ctf_traces_ht->ht,
+                       &iter.iter, trace, node.node) {
+               ret = ctf_trace_close(trace);
+               if (ret) {
+                       goto rcu_unlock;
                }
        }
+       cds_list_for_each_entry_rcu(stream, &session->recv_list,
+                       recv_node) {
+               /* Close streams which have not been published yet. */
+               try_stream_close(stream);
+       }
+rcu_unlock:
+       rcu_read_unlock();
+       if (ret) {
+               return ret;
+       }
+       /* Put self-reference from create. */
+       session_put(session);
+       return ret;
 }
 
-/*
- * Destroy a session object.
- *
- * This function must *NOT* be called with an RCU read lock held since
- * the session's ctf_traces_ht is destroyed.
- */
-void session_destroy(struct relay_session *session)
+void print_sessions(void)
 {
-       struct ctf_trace *ctf_trace;
        struct lttng_ht_iter iter;
+       struct relay_session *session;
 
-       assert(session);
-
-       DBG("Relay destroying session %" PRIu64, session->id);
+       if (!sessions_ht) {
+               return;
+       }
 
-       /*
-        * Empty the ctf trace hash table which will destroy the stream contained
-        * in that table.
-        */
        rcu_read_lock();
-       cds_lfht_for_each_entry(session->ctf_traces_ht->ht, &iter.iter, ctf_trace,
-                       node.node) {
-               ctf_trace_delete(session->ctf_traces_ht, ctf_trace);
-               ctf_trace_destroy(ctf_trace);
+       cds_lfht_for_each_entry(sessions_ht->ht, &iter.iter, session,
+                       session_n.node) {
+               if (!session_get(session)) {
+                       continue;
+               }
+               DBG("session %p refcount %ld session %" PRIu64,
+                       session,
+                       session->ref.refcount,
+                       session->id);
+               session_put(session);
        }
        rcu_read_unlock();
-       lttng_ht_destroy(session->ctf_traces_ht);
-
-       call_rcu(&session->rcu_node, rcu_destroy_session);
 }
This page took 0.037711 seconds and 4 git commands to generate.