Fix: relayd: don't call lttng_ht_destroy in RCU read-side C.S.
[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 * Since each trace has a reference on the session, it means
136 * that if we are at the point where we teardown the session, no
137 * trace belonging to that session exist at this point.
138 * Calling lttng_ht_destroy in call_rcu worker thread so we
139 * don't hold the RCU read-side lock while calling it.
140 */
141 lttng_ht_destroy(session->ctf_traces_ht);
142 free(session);
143 }
144
145 /*
146 * Delete session from the given hash table.
147 *
148 * Return lttng ht del error code being 0 on success and 1 on failure.
149 */
150 static int session_delete(struct relay_session *session)
151 {
152 struct lttng_ht_iter iter;
153
154 iter.iter.node = &session->session_n.node;
155 return lttng_ht_del(sessions_ht, &iter);
156 }
157
158
159 static void destroy_session(struct relay_session *session)
160 {
161 int ret;
162
163 ret = session_delete(session);
164 assert(!ret);
165 call_rcu(&session->rcu_node, rcu_destroy_session);
166 }
167
168 void session_release(struct urcu_ref *ref)
169 {
170 struct relay_session *session =
171 caa_container_of(ref, struct relay_session, ref);
172
173 destroy_session(session);
174 }
175
176 void session_put(struct relay_session *session)
177 {
178 rcu_read_lock();
179 pthread_mutex_lock(&session->reflock);
180 urcu_ref_put(&session->ref, session_release);
181 pthread_mutex_unlock(&session->reflock);
182 rcu_read_unlock();
183 }
184
185 int session_close(struct relay_session *session)
186 {
187 int ret = 0;
188 struct ctf_trace *trace;
189 struct lttng_ht_iter iter;
190 struct relay_stream *stream;
191
192 pthread_mutex_lock(&session->lock);
193 DBG("closing session %" PRIu64 ": is conn already closed %d",
194 session->id, session->connection_closed);
195 if (session->connection_closed) {
196 ret = -1;
197 goto unlock;
198 }
199 session->connection_closed = true;
200 unlock:
201 pthread_mutex_unlock(&session->lock);
202 if (ret) {
203 return ret;
204 }
205
206 rcu_read_lock();
207 cds_lfht_for_each_entry(session->ctf_traces_ht->ht,
208 &iter.iter, trace, node.node) {
209 ret = ctf_trace_close(trace);
210 if (ret) {
211 goto rcu_unlock;
212 }
213 }
214 cds_list_for_each_entry_rcu(stream, &session->recv_list,
215 recv_node) {
216 /* Close streams which have not been published yet. */
217 try_stream_close(stream);
218 }
219 rcu_unlock:
220 rcu_read_unlock();
221 if (ret) {
222 return ret;
223 }
224 /* Put self-reference from create. */
225 session_put(session);
226 return ret;
227 }
228
229 void print_sessions(void)
230 {
231 struct lttng_ht_iter iter;
232 struct relay_session *session;
233
234 rcu_read_lock();
235 cds_lfht_for_each_entry(sessions_ht->ht, &iter.iter, session,
236 session_n.node) {
237 if (!session_get(session)) {
238 continue;
239 }
240 DBG("session %p refcount %ld session %" PRIu64,
241 session,
242 session->ref.refcount,
243 session->id);
244 session_put(session);
245 }
246 rcu_read_unlock();
247 }
This page took 0.052625 seconds and 5 git commands to generate.