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