df6bc102ae19d434464c636d815959ff65bbe924
[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 _LGPL_SOURCE
21 #include <common/common.h>
22 #include <common/uuid.h>
23 #include <common/time.h>
24 #include <common/utils.h>
25 #include <common/uuid.h>
26 #include <urcu/rculist.h>
27
28 #include <sys/stat.h>
29
30 #include "ctf-trace.h"
31 #include "lttng-relayd.h"
32 #include "session.h"
33 #include "sessiond-trace-chunks.h"
34 #include "stream.h"
35 #include <common/defaults.h>
36 #include "utils.h"
37
38 /* Global session id used in the session creation. */
39 static uint64_t last_relay_session_id;
40 static pthread_mutex_t last_relay_session_id_lock = PTHREAD_MUTEX_INITIALIZER;
41
42 static int init_session_output_path_group_by_host(struct relay_session *session)
43 {
44 /*
45 * session_directory:
46 *
47 * if base_path is \0'
48 * hostname/session_name
49 * else
50 * hostname/base_path
51 */
52 char *session_directory = NULL;
53 int ret = 0;
54
55 if (session->output_path[0] != '\0') {
56 goto end;
57 }
58 /*
59 * If base path is set, it overrides the session name for the
60 * session relative base path. No timestamp is appended if the
61 * base path is overridden.
62 *
63 * If the session name already contains the creation time (e.g.
64 * auto-<timestamp>, don't append yet another timestamp after
65 * the session name in the generated path.
66 *
67 * Otherwise, generate the path with session_name-<timestamp>.
68 */
69 if (session->base_path[0] != '\0') {
70 ret = asprintf(&session_directory, "%s/%s", session->hostname,
71 session->base_path);
72 } else if (session->session_name_contains_creation_time) {
73 ret = asprintf(&session_directory, "%s/%s", session->hostname,
74 session->session_name);
75 } else {
76 char session_creation_datetime[DATETIME_STR_LEN];
77
78 ret = time_to_datetime_str(
79 LTTNG_OPTIONAL_GET(session->creation_time),
80 session_creation_datetime,
81 sizeof(session_creation_datetime));
82 if (ret) {
83 ERR("Failed to format session creation timestamp while initializing session output directory handle");
84 ret = -1;
85 goto end;
86 }
87
88 ret = asprintf(&session_directory, "%s/%s-%s",
89 session->hostname, session->session_name,
90 session_creation_datetime);
91 }
92 if (ret < 0) {
93 PERROR("Failed to format session directory name");
94 goto end;
95 }
96
97 if (strlen(session_directory) >= LTTNG_PATH_MAX) {
98 ERR("Session output directory exceeds maximal length");
99 ret = -1;
100 goto end;
101 }
102 strcpy(session->output_path, session_directory);
103 ret = 0;
104
105 end:
106 free(session_directory);
107 return ret;
108 }
109
110 static int init_session_output_path_group_by_session(
111 struct relay_session *session)
112 {
113 /*
114 * session_directory:
115 *
116 * session_name/hostname-creation_time/base_path
117 *
118 * For session name including the datetime, use it as the complete name
119 * since. Do not perform modification on it since the datetime is an
120 * integral part of the name and how a user identify a session.
121 */
122 int ret = 0;
123 char *session_directory = NULL;
124 char creation_datetime[DATETIME_STR_LEN];
125
126 if (session->output_path[0] != '\0') {
127 /* output_path as been generated already */
128 goto end;
129 }
130
131 ret = time_to_datetime_str(LTTNG_OPTIONAL_GET(session->creation_time),
132 creation_datetime, sizeof(creation_datetime));
133 if (ret) {
134 ERR("Failed to format session creation timestamp while initializing session output directory handle");
135 ret = -1;
136 goto end;
137 }
138
139 ret = asprintf(&session_directory, "%s/%s-%s%s%s",
140 session->session_name, session->hostname,
141 creation_datetime,
142 session->base_path[0] != '\0' ? "/" : "",
143 session->base_path);
144 if (ret < 0) {
145 PERROR("Failed to format session directory name");
146 goto end;
147 }
148
149 if (strlen(session_directory) >= LTTNG_PATH_MAX) {
150 ERR("Session output directory exceeds maximal length");
151 ret = -1;
152 goto end;
153 }
154
155 strcpy(session->output_path, session_directory);
156 ret = 0;
157
158 end:
159 free(session_directory);
160 return ret;
161 }
162
163 static int init_session_output_path(struct relay_session *session)
164 {
165 int ret;
166
167 switch (opt_group_output_by) {
168 case RELAYD_GROUP_OUTPUT_BY_HOST:
169 ret = init_session_output_path_group_by_host(session);
170 break;
171 case RELAYD_GROUP_OUTPUT_BY_SESSION:
172 ret = init_session_output_path_group_by_session(session);
173 break;
174 case RELAYD_GROUP_OUTPUT_BY_UNKNOWN:
175 default:
176 abort();
177 break;
178 }
179
180 return ret;
181 }
182
183 static int session_set_anonymous_chunk(struct relay_session *session)
184 {
185 int ret = 0;
186 struct lttng_trace_chunk *chunk = NULL;
187 enum lttng_trace_chunk_status status;
188 struct lttng_directory_handle *output_directory;
189
190 output_directory = session_create_output_directory_handle(session);
191 if (!output_directory) {
192 goto end;
193 }
194
195 chunk = lttng_trace_chunk_create_anonymous();
196 if (!chunk) {
197 goto end;
198 }
199
200 status = lttng_trace_chunk_set_credentials_current_user(chunk);
201 if (status != LTTNG_TRACE_CHUNK_STATUS_OK) {
202 ret = -1;
203 goto end;
204 }
205
206 status = lttng_trace_chunk_set_as_owner(chunk, output_directory);
207 if (status != LTTNG_TRACE_CHUNK_STATUS_OK) {
208 ret = -1;
209 goto end;
210 }
211 output_directory = NULL;
212 session->current_trace_chunk = chunk;
213 chunk = NULL;
214 end:
215 lttng_trace_chunk_put(chunk);
216 lttng_directory_handle_put(output_directory);
217 return ret;
218 }
219
220 /*
221 * Create a new session by assigning a new session ID.
222 *
223 * Return allocated session or else NULL.
224 */
225 struct relay_session *session_create(const char *session_name,
226 const char *hostname, const char *base_path,
227 uint32_t live_timer,
228 bool snapshot,
229 const lttng_uuid sessiond_uuid,
230 const uint64_t *id_sessiond,
231 const uint64_t *current_chunk_id,
232 const time_t *creation_time,
233 uint32_t major,
234 uint32_t minor,
235 bool session_name_contains_creation_time)
236 {
237 int ret;
238 struct relay_session *session = NULL;
239
240 assert(session_name);
241 assert(hostname);
242 assert(base_path);
243
244 if (strstr(session_name, ".")) {
245 ERR("Illegal character in session name: \"%s\"",
246 session_name);
247 goto error;
248 }
249 if (strstr(base_path, "../")) {
250 ERR("Invalid session base path walks up the path hierarchy: \"%s\"",
251 base_path);
252 goto error;
253 }
254 if (strstr(hostname, ".")) {
255 ERR("Invalid character in hostname: \"%s\"",
256 hostname);
257 goto error;
258 }
259
260 session = zmalloc(sizeof(*session));
261 if (!session) {
262 PERROR("Failed to allocate session");
263 goto error;
264 }
265 if (lttng_strncpy(session->session_name, session_name,
266 sizeof(session->session_name))) {
267 WARN("Session name exceeds maximal allowed length");
268 goto error;
269 }
270 if (lttng_strncpy(session->hostname, hostname,
271 sizeof(session->hostname))) {
272 WARN("Hostname exceeds maximal allowed length");
273 goto error;
274 }
275 if (lttng_strncpy(session->base_path, base_path,
276 sizeof(session->base_path))) {
277 WARN("Base path exceeds maximal allowed length");
278 goto error;
279 }
280 if (creation_time) {
281 LTTNG_OPTIONAL_SET(&session->creation_time, *creation_time);
282 }
283 session->session_name_contains_creation_time =
284 session_name_contains_creation_time;
285
286 session->ctf_traces_ht = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
287 if (!session->ctf_traces_ht) {
288 goto error;
289 }
290
291 pthread_mutex_lock(&last_relay_session_id_lock);
292 session->id = ++last_relay_session_id;
293 pthread_mutex_unlock(&last_relay_session_id_lock);
294
295 session->major = major;
296 session->minor = minor;
297 lttng_ht_node_init_u64(&session->session_n, session->id);
298 urcu_ref_init(&session->ref);
299 CDS_INIT_LIST_HEAD(&session->recv_list);
300 pthread_mutex_init(&session->lock, NULL);
301 pthread_mutex_init(&session->recv_list_lock, NULL);
302
303 session->live_timer = live_timer;
304 session->snapshot = snapshot;
305 lttng_uuid_copy(session->sessiond_uuid, sessiond_uuid);
306
307 if (id_sessiond) {
308 LTTNG_OPTIONAL_SET(&session->id_sessiond, *id_sessiond);
309 }
310
311 if (major == 2 && minor >= 11) {
312 /* Only applies for 2.11+ peers using trace chunks. */
313 ret = init_session_output_path(session);
314 if (ret) {
315 goto error;
316 }
317 }
318
319 ret = sessiond_trace_chunk_registry_session_created(
320 sessiond_trace_chunk_registry, sessiond_uuid);
321 if (ret) {
322 goto error;
323 }
324
325 if (id_sessiond && current_chunk_id) {
326 session->current_trace_chunk =
327 sessiond_trace_chunk_registry_get_chunk(
328 sessiond_trace_chunk_registry,
329 session->sessiond_uuid,
330 session->id_sessiond.value,
331 *current_chunk_id);
332 if (!session->current_trace_chunk) {
333 char uuid_str[LTTNG_UUID_STR_LEN];
334
335 lttng_uuid_to_str(sessiond_uuid, uuid_str);
336 ERR("Could not find trace chunk: sessiond = {%s}, sessiond session id = %" PRIu64 ", trace chunk id = %" PRIu64,
337 uuid_str, *id_sessiond,
338 *current_chunk_id);
339 }
340 } else if (!id_sessiond) {
341 /*
342 * Pre-2.11 peers will not announce trace chunks. An
343 * anonymous trace chunk which will remain set for the
344 * duration of the session is created.
345 */
346 ret = session_set_anonymous_chunk(session);
347 if (ret) {
348 goto error;
349 }
350 }
351
352 lttng_ht_add_unique_u64(sessions_ht, &session->session_n);
353 return session;
354
355 error:
356 session_put(session);
357 return NULL;
358 }
359
360 /* Should be called with RCU read-side lock held. */
361 bool session_get(struct relay_session *session)
362 {
363 return urcu_ref_get_unless_zero(&session->ref);
364 }
365
366 /*
367 * Lookup a session within the session hash table using the session id
368 * as key. A session reference is taken when a session is returned.
369 * session_put() must be called on that session.
370 *
371 * Return session or NULL if not found.
372 */
373 struct relay_session *session_get_by_id(uint64_t id)
374 {
375 struct relay_session *session = NULL;
376 struct lttng_ht_node_u64 *node;
377 struct lttng_ht_iter iter;
378
379 rcu_read_lock();
380 lttng_ht_lookup(sessions_ht, &id, &iter);
381 node = lttng_ht_iter_get_node_u64(&iter);
382 if (!node) {
383 DBG("Session find by ID %" PRIu64 " id NOT found", id);
384 goto end;
385 }
386 session = caa_container_of(node, struct relay_session, session_n);
387 DBG("Session find by ID %" PRIu64 " id found", id);
388 if (!session_get(session)) {
389 session = NULL;
390 }
391 end:
392 rcu_read_unlock();
393 return session;
394 }
395
396 static void rcu_destroy_session(struct rcu_head *rcu_head)
397 {
398 struct relay_session *session =
399 caa_container_of(rcu_head, struct relay_session,
400 rcu_node);
401 /*
402 * Since each trace has a reference on the session, it means
403 * that if we are at the point where we teardown the session, no
404 * trace belonging to that session exist at this point.
405 * Calling lttng_ht_destroy in call_rcu worker thread so we
406 * don't hold the RCU read-side lock while calling it.
407 */
408 lttng_ht_destroy(session->ctf_traces_ht);
409 free(session);
410 }
411
412 /*
413 * Delete session from the given hash table.
414 *
415 * Return lttng ht del error code being 0 on success and 1 on failure.
416 */
417 static int session_delete(struct relay_session *session)
418 {
419 struct lttng_ht_iter iter;
420
421 iter.iter.node = &session->session_n.node;
422 return lttng_ht_del(sessions_ht, &iter);
423 }
424
425
426 static void destroy_session(struct relay_session *session)
427 {
428 int ret;
429
430 ret = session_delete(session);
431 assert(!ret);
432 lttng_trace_chunk_put(session->current_trace_chunk);
433 session->current_trace_chunk = NULL;
434 lttng_trace_chunk_put(session->pending_closure_trace_chunk);
435 session->pending_closure_trace_chunk = NULL;
436 ret = sessiond_trace_chunk_registry_session_destroyed(
437 sessiond_trace_chunk_registry, session->sessiond_uuid);
438 assert(!ret);
439 call_rcu(&session->rcu_node, rcu_destroy_session);
440 }
441
442 static void session_release(struct urcu_ref *ref)
443 {
444 struct relay_session *session =
445 caa_container_of(ref, struct relay_session, ref);
446
447 destroy_session(session);
448 }
449
450 void session_put(struct relay_session *session)
451 {
452 if (!session) {
453 return;
454 }
455 rcu_read_lock();
456 urcu_ref_put(&session->ref, session_release);
457 rcu_read_unlock();
458 }
459
460 int session_close(struct relay_session *session)
461 {
462 int ret = 0;
463 struct ctf_trace *trace;
464 struct lttng_ht_iter iter;
465 struct relay_stream *stream;
466
467 pthread_mutex_lock(&session->lock);
468 DBG("closing session %" PRIu64 ": is conn already closed %d",
469 session->id, session->connection_closed);
470 session->connection_closed = true;
471 pthread_mutex_unlock(&session->lock);
472
473 rcu_read_lock();
474 cds_lfht_for_each_entry(session->ctf_traces_ht->ht,
475 &iter.iter, trace, node.node) {
476 ret = ctf_trace_close(trace);
477 if (ret) {
478 goto rcu_unlock;
479 }
480 }
481 cds_list_for_each_entry_rcu(stream, &session->recv_list,
482 recv_node) {
483 /* Close streams which have not been published yet. */
484 try_stream_close(stream);
485 }
486 rcu_unlock:
487 rcu_read_unlock();
488 if (ret) {
489 return ret;
490 }
491 /* Put self-reference from create. */
492 session_put(session);
493 return ret;
494 }
495
496 int session_abort(struct relay_session *session)
497 {
498 int ret = 0;
499
500 if (!session) {
501 return 0;
502 }
503
504 pthread_mutex_lock(&session->lock);
505 DBG("aborting session %" PRIu64, session->id);
506 session->aborted = true;
507 pthread_mutex_unlock(&session->lock);
508 return ret;
509 }
510
511 void print_sessions(void)
512 {
513 struct lttng_ht_iter iter;
514 struct relay_session *session;
515
516 if (!sessions_ht) {
517 return;
518 }
519
520 rcu_read_lock();
521 cds_lfht_for_each_entry(sessions_ht->ht, &iter.iter, session,
522 session_n.node) {
523 if (!session_get(session)) {
524 continue;
525 }
526 DBG("session %p refcount %ld session %" PRIu64,
527 session,
528 session->ref.refcount,
529 session->id);
530 session_put(session);
531 }
532 rcu_read_unlock();
533 }
534
535 struct lttng_directory_handle *session_create_output_directory_handle(
536 struct relay_session *session)
537 {
538 int ret;
539 /*
540 * relayd_output_path/session_directory
541 * e.g. /home/user/lttng-traces/hostname/session_name
542 */
543 char *full_session_path = NULL;
544 struct lttng_directory_handle *handle = NULL;
545
546 pthread_mutex_lock(&session->lock);
547 full_session_path = create_output_path(session->output_path);
548 if (!full_session_path) {
549 goto end;
550 }
551
552 ret = utils_mkdir_recursive(
553 full_session_path, S_IRWXU | S_IRWXG, -1, -1);
554 if (ret) {
555 ERR("Failed to create session output path \"%s\"",
556 full_session_path);
557 goto end;
558 }
559
560 handle = lttng_directory_handle_create(full_session_path);
561 end:
562 pthread_mutex_unlock(&session->lock);
563 free(full_session_path);
564 return handle;
565 }
This page took 0.063792 seconds and 4 git commands to generate.