relay: use urcu_ref_get_unless_zero

[lttng-tools.git] / src / bin / lttng-relayd / session.c

diff --git a/src/bin/lttng-relayd/session.c b/src/bin/lttng-relayd/session.c
index 14ae874ea782ef45624447659d988c1bd3a05258..3ea8e50d6f9aaf60d64789069636c9ea13736e50 100644 (file)
--- a/src/bin/lttng-relayd/session.c
+++ b/src/bin/lttng-relayd/session.c
@@ -17,7 +17,6 @@
  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-#define _GNU_SOURCE
 #define _LGPL_SOURCE
 #include <common/common.h>
 #include <urcu/rculist.h>
@@ -47,11 +46,16 @@ struct relay_session *session_create(const char *session_name,
                PERROR("relay session zmalloc");
                goto error;
        }
-
+       if (lttng_strncpy(session->session_name, session_name,
+                       sizeof(session->session_name))) {
+               goto error;
+       }
+       if (lttng_strncpy(session->hostname, hostname,
+                       sizeof(session->hostname))) {
+               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 +69,23 @@ 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_ht_add_unique_u64(sessions_ht, &session->session_n);
+       return session;
 
 error:
-       return session;
+       free(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 +123,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 +154,6 @@ 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);
        call_rcu(&session->rcu_node, rcu_destroy_session);
 }
 
@@ -175,9 +168,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();
 }
 
@@ -225,11 +216,36 @@ 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);
+       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;
+}
+
 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) {