Fix: Wait for in-flight data before closing a stream
[lttng-tools.git] / src / bin / lttng-relayd / session.c
1 /*
2 * Copyright (C) 2013 - Julien Desfossez <jdesfossez@efficios.com>
3 * David Goulet <dgoulet@efficios.com>
4 * 2015 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License, version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc., 51
17 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20 #define _GNU_SOURCE
21 #define _LGPL_SOURCE
22 #include <common/common.h>
23 #include <urcu/rculist.h>
24
25 #include "lttng-relayd.h"
26 #include "ctf-trace.h"
27 #include "session.h"
28 #include "stream.h"
29
30 /* Global session id used in the session creation. */
31 static uint64_t last_relay_session_id;
32 static pthread_mutex_t last_relay_session_id_lock = PTHREAD_MUTEX_INITIALIZER;
33
34 /*
35 * Create a new session by assigning a new session ID.
36 *
37 * Return allocated session or else NULL.
38 */
39 struct relay_session *session_create(const char *session_name,
40 const char *hostname, uint32_t live_timer,
41 bool snapshot, uint32_t major, uint32_t minor)
42 {
43 struct relay_session *session;
44
45 session = zmalloc(sizeof(*session));
46 if (!session) {
47 PERROR("relay session zmalloc");
48 goto error;
49 }
50
51 session->ctf_traces_ht = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
52 if (!session->ctf_traces_ht) {
53 free(session);
54 session = NULL;
55 goto error;
56 }
57
58 pthread_mutex_lock(&last_relay_session_id_lock);
59 session->id = ++last_relay_session_id;
60 pthread_mutex_unlock(&last_relay_session_id_lock);
61
62 session->major = major;
63 session->minor = minor;
64 lttng_ht_node_init_u64(&session->session_n, session->id);
65 urcu_ref_init(&session->ref);
66 CDS_INIT_LIST_HEAD(&session->recv_list);
67 pthread_mutex_init(&session->lock, NULL);
68 pthread_mutex_init(&session->reflock, NULL);
69 pthread_mutex_init(&session->recv_list_lock, NULL);
70
71 strncpy(session->session_name, session_name,
72 sizeof(session->session_name));
73 strncpy(session->hostname, hostname,
74 sizeof(session->hostname));
75 session->live_timer = live_timer;
76 session->snapshot = snapshot;
77
78 lttng_ht_add_unique_u64(sessions_ht, &session->session_n);
79
80 error:
81 return session;
82 }
83
84 /* Should be called with RCU read-side lock held. */
85 bool session_get(struct relay_session *session)
86 {
87 bool has_ref = false;
88
89 pthread_mutex_lock(&session->reflock);
90 if (session->ref.refcount != 0) {
91 has_ref = true;
92 urcu_ref_get(&session->ref);
93 }
94 pthread_mutex_unlock(&session->reflock);
95
96 return has_ref;
97 }
98
99 /*
100 * Lookup a session within the session hash table using the session id
101 * as key. A session reference is taken when a session is returned.
102 * session_put() must be called on that session.
103 *
104 * Return session or NULL if not found.
105 */
106 struct relay_session *session_get_by_id(uint64_t id)
107 {
108 struct relay_session *session = NULL;
109 struct lttng_ht_node_u64 *node;
110 struct lttng_ht_iter iter;
111
112 rcu_read_lock();
113 lttng_ht_lookup(sessions_ht, &id, &iter);
114 node = lttng_ht_iter_get_node_u64(&iter);
115 if (!node) {
116 DBG("Session find by ID %" PRIu64 " id NOT found", id);
117 goto end;
118 }
119 session = caa_container_of(node, struct relay_session, session_n);
120 DBG("Session find by ID %" PRIu64 " id found", id);
121 if (!session_get(session)) {
122 session = NULL;
123 }
124 end:
125 rcu_read_unlock();
126 return session;
127 }
128
129 static void rcu_destroy_session(struct rcu_head *rcu_head)
130 {
131 struct relay_session *session =
132 caa_container_of(rcu_head, struct relay_session,
133 rcu_node);
134
135 free(session);
136 }
137
138 /*
139 * Delete session from the given hash table.
140 *
141 * Return lttng ht del error code being 0 on success and 1 on failure.
142 */
143 static int session_delete(struct relay_session *session)
144 {
145 struct lttng_ht_iter iter;
146
147 iter.iter.node = &session->session_n.node;
148 return lttng_ht_del(sessions_ht, &iter);
149 }
150
151
152 static void destroy_session(struct relay_session *session)
153 {
154 int ret;
155
156 ret = session_delete(session);
157 assert(!ret);
158 /*
159 * Since each trace has a reference on the session, it means
160 * that if we are at the point where we teardown the session, no
161 * trace belonging to that session exist at this point.
162 */
163 lttng_ht_destroy(session->ctf_traces_ht);
164 call_rcu(&session->rcu_node, rcu_destroy_session);
165 }
166
167 void session_release(struct urcu_ref *ref)
168 {
169 struct relay_session *session =
170 caa_container_of(ref, struct relay_session, ref);
171
172 destroy_session(session);
173 }
174
175 void session_put(struct relay_session *session)
176 {
177 rcu_read_lock();
178 pthread_mutex_lock(&session->reflock);
179 urcu_ref_put(&session->ref, session_release);
180 pthread_mutex_unlock(&session->reflock);
181 rcu_read_unlock();
182 }
183
184 int session_close(struct relay_session *session)
185 {
186 int ret = 0;
187 struct ctf_trace *trace;
188 struct lttng_ht_iter iter;
189 struct relay_stream *stream;
190
191 pthread_mutex_lock(&session->lock);
192 DBG("closing session %" PRIu64 ": is conn already closed %d",
193 session->id, session->connection_closed);
194 if (session->connection_closed) {
195 ret = -1;
196 goto unlock;
197 }
198 session->connection_closed = true;
199 unlock:
200 pthread_mutex_unlock(&session->lock);
201 if (ret) {
202 return ret;
203 }
204
205 rcu_read_lock();
206 cds_lfht_for_each_entry(session->ctf_traces_ht->ht,
207 &iter.iter, trace, node.node) {
208 ret = ctf_trace_close(trace);
209 if (ret) {
210 goto rcu_unlock;
211 }
212 }
213 cds_list_for_each_entry_rcu(stream, &session->recv_list,
214 recv_node) {
215 /* Close streams which have not been published yet. */
216 try_stream_close(stream);
217 }
218 rcu_unlock:
219 rcu_read_unlock();
220 if (ret) {
221 return ret;
222 }
223 /* Put self-reference from create. */
224 session_put(session);
225 return ret;
226 }
227
228 void print_sessions(void)
229 {
230 struct lttng_ht_iter iter;
231 struct relay_session *session;
232
233 rcu_read_lock();
234 cds_lfht_for_each_entry(sessions_ht->ht, &iter.iter, session,
235 session_n.node) {
236 if (!session_get(session)) {
237 continue;
238 }
239 DBG("session %p refcount %ld session %" PRIu64,
240 session,
241 session->ref.refcount,
242 session->id);
243 session_put(session);
244 }
245 rcu_read_unlock();
246 }
This page took 0.051191 seconds and 5 git commands to generate.