Port: Use LTTNG_NAME_MAX instead of NAME_MAX
[lttng-tools.git] / src / bin / lttng-relayd / session.h
index 698e8ef7f9d11d90e02e82e3fee97b70b4b4a2ca..de1e44f0d7fd36410349a7c1f1ecbcac8bc3c76b 100644 (file)
@@ -1,6 +1,10 @@
+#ifndef _SESSION_H
+#define _SESSION_H
+
 /*
  * 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.
  */
 
-#ifndef _SESSION_H
-#define _SESSION_H
-
 #include <limits.h>
 #include <inttypes.h>
 #include <pthread.h>
+#include <urcu/list.h>
+#include <urcu/ref.h>
 
+#include <lttng/constant.h>
 #include <common/hashtable/hashtable.h>
 
 /*
  */
 struct relay_session {
        /*
-        * This session id is used to identify a set of stream to a tracing session
-        * but also make sure we have a unique session id associated with a session
-        * daemon which can provide multiple data source.
+        * This session id is generated by the relay daemon to guarantee
+        * its uniqueness even when serving multiple session daemons.
+        * It is used to match a set of streams to their session.
         */
        uint64_t id;
-       struct lttcomm_sock *sock;
-       char session_name[NAME_MAX];
+       char session_name[LTTNG_NAME_MAX];
        char hostname[HOST_NAME_MAX];
        uint32_t live_timer;
-       struct lttng_ht_node_ulong session_n;
-       struct rcu_head rcu_node;
-       uint32_t viewer_attached;
-       uint32_t stream_count;
-       /* Tell if this session is for a snapshot or not. */
-       unsigned int snapshot:1;
+
+       /* Session in snapshot mode. */
+       bool snapshot;
 
        /*
-        * Indicate version protocol for this session. This is especially useful
-        * for the data thread that has no idea which version it operates on since
-        * linking control/data sockets is non trivial.
+        * Session has no back reference to its connection because it
+        * has a life-time that can be longer than the consumer connection's
+        * life-time; a reference can still be held by the viewer
+        * connection through the viewer streams.
         */
-       uint64_t minor;
-       uint64_t major;
+
+       struct urcu_ref ref;
+       /* session reflock nests inside ctf_trace reflock. */
+       pthread_mutex_t reflock;
+
+       pthread_mutex_t lock;
+
+       /* major/minor version used for this session. */
+       uint32_t major;
+       uint32_t minor;
+
+       bool viewer_attached;
+       /* Tell if the session connection has been closed on the streaming side. */
+       bool connection_closed;
+
+       /* Contains ctf_trace object of that session indexed by path name. */
+       struct lttng_ht *ctf_traces_ht;
+
+       /*
+        * This contains streams that are received on that connection.
+        * It's used to store them until we get the streams sent
+        * command. When this is received, we remove those streams from
+        * the list and publish them.
+        *
+        * Updates are protected by the recv_list_lock.
+        * Traversals are protected by RCU.
+        * recv_list_lock also protects stream_count.
+        */
+       struct cds_list_head recv_list; /* RCU list. */
+       uint32_t stream_count;
+       pthread_mutex_t recv_list_lock;
+
        /*
         * Flag checked and exchanged with uatomic_cmpxchg to tell the
         * viewer-side if new streams got added since the last check.
@@ -60,13 +91,26 @@ struct relay_session {
        unsigned long new_streams;
 
        /*
-        * Used to synchronize the process where we flag every streams readiness
-        * for the viewer when the streams_sent message is received and the viewer
-        * process of sending those streams.
+        * Node in the global session hash table.
         */
-       pthread_mutex_t viewer_ready_lock;
+       struct lttng_ht_node_u64 session_n;
+       /*
+        * Member of the session list in struct relay_viewer_session.
+        * Updates are protected by the relay_viewer_session
+        * session_list_lock. Traversals are protected by RCU.
+        */
+       struct cds_list_head viewer_session_node;
+       struct rcu_head rcu_node;       /* For call_rcu teardown. */
 };
 
-struct relay_session *session_find_by_id(struct lttng_ht *ht, uint64_t id);
+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_get_by_id(uint64_t id);
+bool session_get(struct relay_session *session);
+void session_put(struct relay_session *session);
+
+int session_close(struct relay_session *session);
+void print_sessions(void);
 
 #endif /* _SESSION_H */
This page took 0.027398 seconds and 5 git commands to generate.