Fix: waiter: futex wait: handle spurious futex wakeups
[lttng-tools.git] / src / common / trace-chunk.cpp
... / ...
CommitLineData
1/*
2 * Copyright (C) 2019 Jérémie Galarneau <jeremie.galarneau@efficios.com>
3 *
4 * SPDX-License-Identifier: LGPL-2.1-only
5 *
6 */
7
8#include <common/compat/directory-handle.hpp>
9#include <common/credentials.hpp>
10#include <common/defaults.hpp>
11#include <common/dynamic-array.hpp>
12#include <common/error.hpp>
13#include <common/fd-tracker/fd-tracker.hpp>
14#include <common/fd-tracker/utils.hpp>
15#include <common/fs-handle.hpp>
16#include <common/fs-handle-internal.hpp>
17#include <common/hashtable/hashtable.hpp>
18#include <common/hashtable/utils.hpp>
19#include <common/optional.hpp>
20#include <common/string-utils/format.hpp>
21#include <common/time.hpp>
22#include <common/trace-chunk-registry.hpp>
23#include <common/trace-chunk.hpp>
24#include <common/utils.hpp>
25#include <lttng/constant.h>
26
27#include <inttypes.h>
28#include <pthread.h>
29#include <stdio.h>
30#include <sys/stat.h>
31#include <urcu/rculfhash.h>
32#include <urcu/ref.h>
33
34/*
35 * Two ISO 8601-compatible timestamps, separated by a hypen, followed an
36 * index, i.e. <start-iso-8601>-<end-iso-8601>-<id-uint64_t>.
37 */
38#define GENERATED_CHUNK_NAME_LEN (2 * sizeof("YYYYmmddTHHMMSS+HHMM") + MAX_INT_DEC_LEN(uint64_t))
39#define DIR_CREATION_MODE (S_IRWXU | S_IRWXG)
40
41enum trace_chunk_mode {
42 TRACE_CHUNK_MODE_USER,
43 TRACE_CHUNK_MODE_OWNER,
44};
45
46/*
47 * Callback to invoke on release of a trace chunk. Note that there is no
48 * need to 'lock' the trace chunk during the execution of these callbacks
49 * since only one thread may access a chunk during its destruction (the last
50 * to release its reference to the chunk).
51 */
52typedef int (*chunk_command)(struct lttng_trace_chunk *trace_chunk);
53
54/* Move a completed trace chunk to the 'completed' trace archive folder. */
55static
56int lttng_trace_chunk_move_to_completed_post_release(struct lttng_trace_chunk *trace_chunk);
57/* Empty callback. */
58static
59int lttng_trace_chunk_no_operation(struct lttng_trace_chunk *trace_chunk);
60/* Unlink old chunk files. */
61static
62int lttng_trace_chunk_delete_post_release(struct lttng_trace_chunk *trace_chunk);
63static
64enum lttng_trace_chunk_status lttng_trace_chunk_rename_path_no_lock(
65 struct lttng_trace_chunk *chunk, const char *path);
66
67namespace {
68struct chunk_credentials {
69 bool use_current_user;
70 struct lttng_credentials user;
71};
72} /* namespace */
73
74/*
75 * NOTE: Make sure to update:
76 * - lttng_trace_chunk_copy(),
77 * - lttng_trace_chunk_registry_element_create_from_chunk()
78 * if you modify this structure.
79 */
80struct lttng_trace_chunk {
81 pthread_mutex_t lock;
82 struct urcu_ref ref;
83 LTTNG_OPTIONAL(enum trace_chunk_mode) mode;
84 /*
85 * First-level directories created within the trace chunk.
86 * Elements are of type 'char *'.
87 *
88 * Only used by _owner_ mode chunks.
89 */
90 struct lttng_dynamic_pointer_array top_level_directories;
91 /*
92 * All files contained within the trace chunk.
93 * Array of paths (char *).
94 */
95 struct lttng_dynamic_pointer_array files;
96 /* Is contained within an lttng_trace_chunk_registry_element? */
97 bool in_registry_element;
98 bool name_overridden;
99 char *name;
100 char *path;
101 /* An unset id means the chunk is anonymous. */
102 LTTNG_OPTIONAL(uint64_t) id;
103
104 /*
105 * The creation and close timestamps are NOT monotonic.
106 * They must not be used in context were monotonicity is required.
107 */
108 LTTNG_OPTIONAL(time_t) timestamp_creation;
109 LTTNG_OPTIONAL(time_t) timestamp_close;
110
111 LTTNG_OPTIONAL(struct chunk_credentials) credentials;
112 struct lttng_directory_handle *session_output_directory;
113 struct lttng_directory_handle *chunk_directory;
114 LTTNG_OPTIONAL(enum lttng_trace_chunk_command_type) close_command;
115 /*
116 * fd_tracker instance through which file descriptors should be
117 * created/closed.
118 *
119 * An fd_tracker always outlives any trace chunk; there is no
120 * need to perform any reference counting of that object.
121 */
122 struct fd_tracker *fd_tracker;
123};
124
125namespace {
126/* A trace chunk is uniquely identified by its (session id, chunk id) tuple. */
127struct lttng_trace_chunk_registry_element {
128 struct lttng_trace_chunk chunk;
129 uint64_t session_id;
130 /* Weak and only set when added. */
131 struct lttng_trace_chunk_registry *registry;
132 struct cds_lfht_node trace_chunk_registry_ht_node;
133 /* call_rcu delayed reclaim. */
134 struct rcu_head rcu_node;
135};
136} /* namespace */
137
138struct lttng_trace_chunk_registry {
139 struct cds_lfht *ht;
140};
141
142namespace {
143struct fs_handle_untracked {
144 struct fs_handle parent;
145 int fd;
146 struct {
147 struct lttng_directory_handle *directory_handle;
148 char *path;
149 } location;
150};
151} /* namespace */
152
153static
154int fs_handle_untracked_get_fd(struct fs_handle *handle);
155static
156void fs_handle_untracked_put_fd(struct fs_handle *handle);
157static
158int fs_handle_untracked_unlink(struct fs_handle *handle);
159static
160int fs_handle_untracked_close(struct fs_handle *handle);
161
162static
163const char *lttng_trace_chunk_command_type_str(
164 lttng_trace_chunk_command_type type) {
165 switch (type) {
166 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED:
167 return "move to completed chunk folder";
168 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION:
169 return "no operation";
170 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_DELETE:
171 return "delete";
172 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_MAX:
173 abort();
174 }
175
176 abort();
177};
178
179static
180chunk_command close_command_get_post_release_func(
181 lttng_trace_chunk_command_type type) {
182 switch (type) {
183 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED:
184 return lttng_trace_chunk_move_to_completed_post_release;
185 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION:
186 return lttng_trace_chunk_no_operation;
187 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_DELETE:
188 return lttng_trace_chunk_delete_post_release;
189 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_MAX:
190 abort();
191 }
192
193 abort();
194};
195
196static
197struct fs_handle *fs_handle_untracked_create(
198 struct lttng_directory_handle *directory_handle,
199 const char *path,
200 int fd)
201{
202 struct fs_handle_untracked *handle = NULL;
203 bool reference_acquired;
204 char *path_copy = strdup(path);
205
206 LTTNG_ASSERT(fd >= 0);
207 if (!path_copy) {
208 PERROR("Failed to copy file path while creating untracked filesystem handle");
209 goto end;
210 }
211
212 handle = zmalloc<fs_handle_untracked>();
213 if (!handle) {
214 PERROR("Failed to allocate untracked filesystem handle");
215 goto end;
216 }
217
218 handle->parent = (typeof(handle->parent)) {
219 .get_fd = fs_handle_untracked_get_fd,
220 .put_fd = fs_handle_untracked_put_fd,
221 .unlink = fs_handle_untracked_unlink,
222 .close = fs_handle_untracked_close,
223 };
224
225 handle->fd = fd;
226 reference_acquired = lttng_directory_handle_get(directory_handle);
227 LTTNG_ASSERT(reference_acquired);
228 handle->location.directory_handle = directory_handle;
229 /* Ownership is transferred. */
230 handle->location.path = path_copy;
231 path_copy = NULL;
232end:
233 free(path_copy);
234 return handle ? &handle->parent : NULL;
235}
236
237static
238int fs_handle_untracked_get_fd(struct fs_handle *_handle)
239{
240 struct fs_handle_untracked *handle = lttng::utils::container_of(
241 _handle, &fs_handle_untracked::parent);
242
243 return handle->fd;
244}
245
246static
247void fs_handle_untracked_put_fd(struct fs_handle *_handle __attribute__((unused)))
248{
249 /* no-op. */
250}
251
252static
253int fs_handle_untracked_unlink(struct fs_handle *_handle)
254{
255 struct fs_handle_untracked *handle = lttng::utils::container_of(
256 _handle, &fs_handle_untracked::parent);
257
258 return lttng_directory_handle_unlink_file(
259 handle->location.directory_handle,
260 handle->location.path);
261}
262
263static
264void fs_handle_untracked_destroy(struct fs_handle_untracked *handle)
265{
266 lttng_directory_handle_put(handle->location.directory_handle);
267 free(handle->location.path);
268 free(handle);
269}
270
271static
272int fs_handle_untracked_close(struct fs_handle *_handle)
273{
274 struct fs_handle_untracked *handle = lttng::utils::container_of(
275 _handle, &fs_handle_untracked::parent);
276 int ret = close(handle->fd);
277
278 fs_handle_untracked_destroy(handle);
279 return ret;
280}
281
282static
283bool lttng_trace_chunk_registry_element_equals(
284 const struct lttng_trace_chunk_registry_element *a,
285 const struct lttng_trace_chunk_registry_element *b)
286{
287 if (a->session_id != b->session_id) {
288 goto not_equal;
289 }
290 if (a->chunk.id.is_set != b->chunk.id.is_set) {
291 goto not_equal;
292 }
293 if (a->chunk.id.is_set && a->chunk.id.value != b->chunk.id.value) {
294 goto not_equal;
295 }
296 return true;
297not_equal:
298 return false;
299}
300
301static
302int lttng_trace_chunk_registry_element_match(struct cds_lfht_node *node,
303 const void *key)
304{
305 const struct lttng_trace_chunk_registry_element *element_a, *element_b;
306
307 element_a = (const struct lttng_trace_chunk_registry_element *) key;
308 element_b = caa_container_of(node, typeof(*element_b),
309 trace_chunk_registry_ht_node);
310 return lttng_trace_chunk_registry_element_equals(element_a, element_b);
311}
312
313static
314unsigned long lttng_trace_chunk_registry_element_hash(
315 const struct lttng_trace_chunk_registry_element *element)
316{
317 unsigned long hash = hash_key_u64(&element->session_id,
318 lttng_ht_seed);
319
320 if (element->chunk.id.is_set) {
321 hash ^= hash_key_u64(&element->chunk.id.value, lttng_ht_seed);
322 }
323
324 return hash;
325}
326
327static
328char *generate_chunk_name(uint64_t chunk_id, time_t creation_timestamp,
329 const time_t *close_timestamp)
330{
331 int ret = 0;
332 char *new_name= NULL;
333 char start_datetime[ISO8601_STR_LEN] = {};
334 /* Add 1 for a '-' prefix. */
335 char end_datetime_suffix[ISO8601_STR_LEN + 1] = {};
336
337 ret = time_to_iso8601_str(
338 creation_timestamp,
339 start_datetime, sizeof(start_datetime));
340 if (ret) {
341 ERR("Failed to format trace chunk start date time");
342 goto error;
343 }
344 if (close_timestamp) {
345 *end_datetime_suffix = '-';
346 ret = time_to_iso8601_str(
347 *close_timestamp,
348 end_datetime_suffix + 1,
349 sizeof(end_datetime_suffix) - 1);
350 if (ret) {
351 ERR("Failed to format trace chunk end date time");
352 goto error;
353 }
354 }
355 new_name = calloc<char>(GENERATED_CHUNK_NAME_LEN);
356 if (!new_name) {
357 ERR("Failed to allocate buffer for automatically-generated trace chunk name");
358 goto error;
359 }
360 ret = snprintf(new_name, GENERATED_CHUNK_NAME_LEN, "%s%s-%" PRIu64,
361 start_datetime, end_datetime_suffix, chunk_id);
362 if (ret >= GENERATED_CHUNK_NAME_LEN || ret == -1) {
363 ERR("Failed to format trace chunk name");
364 goto error;
365 }
366
367 return new_name;
368error:
369 free(new_name);
370 return NULL;
371}
372
373static
374void lttng_trace_chunk_init(struct lttng_trace_chunk *chunk)
375{
376 urcu_ref_init(&chunk->ref);
377 pthread_mutex_init(&chunk->lock, NULL);
378 lttng_dynamic_pointer_array_init(&chunk->top_level_directories, free);
379 lttng_dynamic_pointer_array_init(&chunk->files, free);
380}
381
382static
383void lttng_trace_chunk_fini(struct lttng_trace_chunk *chunk)
384{
385 if (chunk->session_output_directory) {
386 lttng_directory_handle_put(
387 chunk->session_output_directory);
388 chunk->session_output_directory = NULL;
389 }
390 if (chunk->chunk_directory) {
391 lttng_directory_handle_put(chunk->chunk_directory);
392 chunk->chunk_directory = NULL;
393 }
394 free(chunk->name);
395 chunk->name = NULL;
396 free(chunk->path);
397 chunk->path = NULL;
398 lttng_dynamic_pointer_array_reset(&chunk->top_level_directories);
399 lttng_dynamic_pointer_array_reset(&chunk->files);
400 pthread_mutex_destroy(&chunk->lock);
401}
402
403static
404struct lttng_trace_chunk *lttng_trace_chunk_allocate(void)
405{
406 struct lttng_trace_chunk *chunk = NULL;
407
408 chunk = zmalloc<lttng_trace_chunk>();
409 if (!chunk) {
410 ERR("Failed to allocate trace chunk");
411 goto end;
412 }
413 lttng_trace_chunk_init(chunk);
414end:
415 return chunk;
416}
417
418struct lttng_trace_chunk *lttng_trace_chunk_create_anonymous(void)
419{
420 DBG("Creating anonymous trace chunk");
421 return lttng_trace_chunk_allocate();
422}
423
424struct lttng_trace_chunk *lttng_trace_chunk_create(
425 uint64_t chunk_id, time_t chunk_creation_time, const char *path)
426{
427 struct lttng_trace_chunk *chunk;
428 char chunk_creation_datetime_buf[16] = {};
429 const char *chunk_creation_datetime_str = "(formatting error)";
430 struct tm timeinfo_buf, *timeinfo;
431
432 timeinfo = localtime_r(&chunk_creation_time, &timeinfo_buf);
433 if (timeinfo) {
434 size_t strftime_ret;
435
436 /* Don't fail because of this; it is only used for logging. */
437 strftime_ret = strftime(chunk_creation_datetime_buf,
438 sizeof(chunk_creation_datetime_buf),
439 "%Y%m%d-%H%M%S", timeinfo);
440 if (strftime_ret) {
441 chunk_creation_datetime_str =
442 chunk_creation_datetime_buf;
443 }
444 }
445
446 DBG("Creating trace chunk: chunk_id = %" PRIu64 ", creation time = %s",
447 chunk_id, chunk_creation_datetime_str);
448 chunk = lttng_trace_chunk_allocate();
449 if (!chunk) {
450 goto end;
451 }
452
453 LTTNG_OPTIONAL_SET(&chunk->id, chunk_id);
454 LTTNG_OPTIONAL_SET(&chunk->timestamp_creation, chunk_creation_time);
455 if (chunk_id != 0) {
456 chunk->name = generate_chunk_name(chunk_id,
457 chunk_creation_time, NULL);
458 if (!chunk->name) {
459 ERR("Failed to allocate trace chunk name storage");
460 goto error;
461 }
462 }
463 if (path) {
464 chunk->path = strdup(path);
465 if (!chunk->path) {
466 goto error;
467 }
468 } else {
469 if (chunk->name) {
470 chunk->path = strdup(chunk->name);
471 if (!chunk->path) {
472 goto error;
473 }
474 }
475 }
476
477 DBG("Chunk name set to \"%s\"", chunk->name ? : "(none)");
478end:
479 return chunk;
480error:
481 lttng_trace_chunk_put(chunk);
482 return NULL;
483}
484
485void lttng_trace_chunk_set_fd_tracker(struct lttng_trace_chunk *chunk,
486 struct fd_tracker *fd_tracker)
487{
488 LTTNG_ASSERT(!chunk->session_output_directory);
489 LTTNG_ASSERT(!chunk->chunk_directory);
490 LTTNG_ASSERT(lttng_dynamic_pointer_array_get_count(&chunk->files) == 0);
491 chunk->fd_tracker = fd_tracker;
492}
493
494struct lttng_trace_chunk *lttng_trace_chunk_copy(
495 struct lttng_trace_chunk *source_chunk)
496{
497 struct lttng_trace_chunk *new_chunk = lttng_trace_chunk_allocate();
498
499 if (!new_chunk) {
500 goto end;
501 }
502
503 pthread_mutex_lock(&source_chunk->lock);
504 /*
505 * A new chunk is always a user; it shall create no new trace
506 * subdirectories.
507 */
508 new_chunk->mode = (typeof(new_chunk->mode)) {
509 .is_set = true,
510 .value = TRACE_CHUNK_MODE_USER,
511 };
512 /*
513 * top_level_directories is not copied as it is never used
514 * by _user_ mode chunks.
515 */
516 /* The new chunk is not part of a registry (yet, at least). */
517 new_chunk->in_registry_element = false;
518 new_chunk->name_overridden = source_chunk->name_overridden;
519 if (source_chunk->name) {
520 new_chunk->name = strdup(source_chunk->name);
521 if (!new_chunk->name) {
522 ERR("Failed to copy source trace chunk name in %s()",
523 __FUNCTION__);
524 goto error_unlock;
525 }
526 }
527 if (source_chunk->path) {
528 new_chunk->path = strdup(source_chunk->path);
529 if (!new_chunk->path) {
530 ERR("Failed to copy source trace chunk path in %s()",
531 __FUNCTION__);
532 }
533 }
534 new_chunk->id = source_chunk->id;
535 new_chunk->timestamp_creation = source_chunk->timestamp_creation;
536 new_chunk->timestamp_close = source_chunk->timestamp_close;
537 new_chunk->credentials = source_chunk->credentials;
538 if (source_chunk->session_output_directory) {
539 const bool reference_acquired = lttng_directory_handle_get(
540 source_chunk->session_output_directory);
541
542 LTTNG_ASSERT(reference_acquired);
543 new_chunk->session_output_directory =
544 source_chunk->session_output_directory;
545 }
546 if (source_chunk->chunk_directory) {
547 const bool reference_acquired = lttng_directory_handle_get(
548 source_chunk->chunk_directory);
549
550 LTTNG_ASSERT(reference_acquired);
551 new_chunk->chunk_directory = source_chunk->chunk_directory;
552 }
553 new_chunk->close_command = source_chunk->close_command;
554 new_chunk->fd_tracker = source_chunk->fd_tracker;
555 pthread_mutex_unlock(&source_chunk->lock);
556end:
557 return new_chunk;
558error_unlock:
559 pthread_mutex_unlock(&source_chunk->lock);
560 lttng_trace_chunk_put(new_chunk);
561 return NULL;
562}
563
564enum lttng_trace_chunk_status lttng_trace_chunk_get_id(
565 struct lttng_trace_chunk *chunk, uint64_t *id)
566{
567 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
568
569 pthread_mutex_lock(&chunk->lock);
570 if (chunk->id.is_set) {
571 *id = chunk->id.value;
572 } else {
573 status = LTTNG_TRACE_CHUNK_STATUS_NONE;
574 }
575 pthread_mutex_unlock(&chunk->lock);
576 return status;
577}
578
579enum lttng_trace_chunk_status lttng_trace_chunk_get_creation_timestamp(
580 struct lttng_trace_chunk *chunk, time_t *creation_ts)
581
582{
583 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
584
585 pthread_mutex_lock(&chunk->lock);
586 if (chunk->timestamp_creation.is_set) {
587 *creation_ts = chunk->timestamp_creation.value;
588 } else {
589 status = LTTNG_TRACE_CHUNK_STATUS_NONE;
590 }
591 pthread_mutex_unlock(&chunk->lock);
592 return status;
593}
594
595enum lttng_trace_chunk_status lttng_trace_chunk_get_close_timestamp(
596 struct lttng_trace_chunk *chunk, time_t *close_ts)
597{
598 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
599
600 pthread_mutex_lock(&chunk->lock);
601 if (chunk->timestamp_close.is_set) {
602 *close_ts = chunk->timestamp_close.value;
603 } else {
604 status = LTTNG_TRACE_CHUNK_STATUS_NONE;
605 }
606 pthread_mutex_unlock(&chunk->lock);
607 return status;
608}
609
610enum lttng_trace_chunk_status lttng_trace_chunk_set_close_timestamp(
611 struct lttng_trace_chunk *chunk, time_t close_ts)
612{
613 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
614
615 pthread_mutex_lock(&chunk->lock);
616 if (!chunk->timestamp_creation.is_set) {
617 ERR("Failed to set trace chunk close timestamp: creation timestamp is unset");
618 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION;
619 goto end;
620 }
621
622 /*
623 * Note: we do not enforce that the closing timestamp be greater or
624 * equal to the begin timestamp. These timestamps are used for
625 * generating the chunk name and should only be used in context where
626 * the monotonicity of time is not important. The source of those
627 * timestamps is NOT monotonic and represent the system calendar time,
628 * also know as the wall time.
629 */
630 if (chunk->timestamp_creation.value > close_ts) {
631 WARN("Set trace chunk close timestamp: close timestamp is before creation timestamp, begin : %ld, close : %ld",
632 chunk->timestamp_creation.value, close_ts);
633 }
634
635 LTTNG_OPTIONAL_SET(&chunk->timestamp_close, close_ts);
636 if (!chunk->name_overridden) {
637 free(chunk->name);
638 chunk->name = generate_chunk_name(LTTNG_OPTIONAL_GET(chunk->id),
639 LTTNG_OPTIONAL_GET(chunk->timestamp_creation),
640 &close_ts);
641 if (!chunk->name) {
642 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
643 }
644 }
645end:
646 pthread_mutex_unlock(&chunk->lock);
647 return status;
648}
649
650enum lttng_trace_chunk_status lttng_trace_chunk_get_name(
651 struct lttng_trace_chunk *chunk, const char **name,
652 bool *name_overridden)
653{
654 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
655
656 pthread_mutex_lock(&chunk->lock);
657 if (name_overridden) {
658 *name_overridden = chunk->name_overridden;
659 }
660 if (!chunk->name) {
661 status = LTTNG_TRACE_CHUNK_STATUS_NONE;
662 goto end;
663 }
664 *name = chunk->name;
665end:
666 pthread_mutex_unlock(&chunk->lock);
667 return status;
668}
669
670bool lttng_trace_chunk_get_name_overridden(struct lttng_trace_chunk *chunk)
671{
672 bool name_overridden;
673
674 pthread_mutex_lock(&chunk->lock);
675 name_overridden = chunk->name_overridden;
676 pthread_mutex_unlock(&chunk->lock);
677 return name_overridden;
678}
679
680static
681bool is_valid_chunk_name(const char *name)
682{
683 size_t len;
684
685 if (!name) {
686 return false;
687 }
688
689 len = lttng_strnlen(name, LTTNG_NAME_MAX);
690 if (len == 0 || len == LTTNG_NAME_MAX) {
691 return false;
692 }
693
694 if (strchr(name, '/') || strchr(name, '.')) {
695 return false;
696 }
697
698 return true;
699}
700
701enum lttng_trace_chunk_status lttng_trace_chunk_override_name(
702 struct lttng_trace_chunk *chunk, const char *name)
703
704{
705 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
706 char *new_name, *new_path;
707
708 DBG("Override trace chunk name from %s to %s", chunk->name, name);
709 if (!is_valid_chunk_name(name)) {
710 ERR("Attempted to set an invalid name on a trace chunk: name = %s",
711 name ? : "NULL");
712 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT;
713 goto end;
714 }
715
716 pthread_mutex_lock(&chunk->lock);
717 if (!chunk->id.is_set) {
718 ERR("Attempted to set an override name on an anonymous trace chunk: name = %s",
719 name);
720 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION;
721 goto end_unlock;
722 }
723
724 new_name = strdup(name);
725 if (!new_name) {
726 ERR("Failed to allocate new trace chunk name");
727 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
728 goto end_unlock;
729 }
730 free(chunk->name);
731 chunk->name = new_name;
732
733 new_path = strdup(name);
734 if (!new_path) {
735 ERR("Failed to allocate new trace chunk path");
736 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
737 goto end_unlock;
738 }
739 free(chunk->path);
740 chunk->path = new_path;
741
742 chunk->name_overridden = true;
743end_unlock:
744 pthread_mutex_unlock(&chunk->lock);
745end:
746 return status;
747}
748
749static
750enum lttng_trace_chunk_status lttng_trace_chunk_rename_path_no_lock(
751 struct lttng_trace_chunk *chunk, const char *path)
752
753{
754 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
755 struct lttng_directory_handle *rename_directory = NULL;
756 char *new_path, *old_path;
757 int ret;
758
759 if (chunk->name_overridden) {
760 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
761 goto end;
762 }
763
764 old_path = chunk->path;
765 DBG("lttng_trace_chunk_rename_path from %s to %s", old_path, path);
766
767 if ((!old_path && !path) ||
768 (old_path && path && !strcmp(old_path, path))) {
769 goto end;
770 }
771 /*
772 * Use chunk name as path if NULL path is specified.
773 */
774 if (!path) {
775 path = chunk->name;
776 }
777
778 /* Renaming from "" to "" is not accepted. */
779 if (path[0] == '\0' && old_path[0] == '\0') {
780 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
781 goto end;
782 }
783
784 /*
785 * If a rename is performed on a chunk for which the chunk_directory
786 * is not set (yet), or the session_output_directory is not set
787 * (interacting with a relay daemon), there is no rename to perform.
788 */
789 if (!chunk->chunk_directory ||
790 !chunk->session_output_directory) {
791 goto skip_move;
792 }
793
794 if (old_path && old_path[0] != '\0' && path[0] != '\0') {
795 /* Rename chunk directory. */
796 ret = lttng_directory_handle_rename_as_user(
797 chunk->session_output_directory,
798 old_path,
799 chunk->session_output_directory,
800 path,
801 LTTNG_OPTIONAL_GET(chunk->credentials).use_current_user ?
802 NULL :
803 &chunk->credentials.value.user);
804 if (ret) {
805 PERROR("Failed to move trace chunk directory \"%s\" to \"%s\"",
806 old_path, path);
807 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
808 goto end;
809 }
810 rename_directory = chunk->fd_tracker ?
811 fd_tracker_create_directory_handle_from_handle(
812 chunk->fd_tracker,
813 chunk->session_output_directory,
814 path) :
815 lttng_directory_handle_create_from_handle(
816 path,
817 chunk->session_output_directory);
818 if (!rename_directory) {
819 ERR("Failed to get handle to trace chunk rename directory");
820 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
821 goto end;
822 }
823
824 /* Release old handle. */
825 lttng_directory_handle_put(chunk->chunk_directory);
826 /*
827 * Transfer new handle reference to chunk as the current chunk
828 * handle.
829 */
830 chunk->chunk_directory = rename_directory;
831 rename_directory = NULL;
832 } else if (old_path && old_path[0] == '\0') {
833 size_t i, count = lttng_dynamic_pointer_array_get_count(
834 &chunk->top_level_directories);
835
836 ret = lttng_directory_handle_create_subdirectory_as_user(
837 chunk->session_output_directory,
838 path,
839 DIR_CREATION_MODE,
840 LTTNG_OPTIONAL_GET(chunk->credentials).use_current_user ?
841 NULL :
842 &chunk->credentials.value.user);
843 if (ret) {
844 PERROR("Failed to create trace chunk rename directory \"%s\"",
845 path);
846 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
847 goto end;
848 }
849
850 rename_directory = lttng_directory_handle_create_from_handle(
851 path, chunk->session_output_directory);
852 if (!rename_directory) {
853 ERR("Failed to get handle to trace chunk rename directory");
854 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
855 goto end;
856 }
857
858 /* Move toplevel directories. */
859 for (i = 0; i < count; i++) {
860 const char *top_level_name =
861 (const char *) lttng_dynamic_pointer_array_get_pointer(
862 &chunk->top_level_directories, i);
863
864 ret = lttng_directory_handle_rename_as_user(
865 chunk->chunk_directory,
866 top_level_name,
867 rename_directory,
868 top_level_name,
869 LTTNG_OPTIONAL_GET(chunk->credentials).use_current_user ?
870 NULL :
871 &chunk->credentials.value.user);
872 if (ret) {
873 PERROR("Failed to move \"%s\" to trace chunk rename directory",
874 top_level_name);
875 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
876 goto end;
877 }
878 }
879 /* Release old handle. */
880 lttng_directory_handle_put(chunk->chunk_directory);
881 /*
882 * Transfer new handle reference to chunk as the current chunk
883 * handle.
884 */
885 chunk->chunk_directory = rename_directory;
886 rename_directory = NULL;
887 } else if (old_path) {
888 size_t i, count = lttng_dynamic_pointer_array_get_count(
889 &chunk->top_level_directories);
890 const bool reference_acquired = lttng_directory_handle_get(
891 chunk->session_output_directory);
892
893 LTTNG_ASSERT(reference_acquired);
894 rename_directory = chunk->session_output_directory;
895
896 /* Move toplevel directories. */
897 for (i = 0; i < count; i++) {
898 const char *top_level_name =
899 (const char *) lttng_dynamic_pointer_array_get_pointer(
900 &chunk->top_level_directories, i);
901
902 ret = lttng_directory_handle_rename_as_user(
903 chunk->chunk_directory,
904 top_level_name,
905 rename_directory,
906 top_level_name,
907 LTTNG_OPTIONAL_GET(chunk->credentials).use_current_user ?
908 NULL :
909 &chunk->credentials.value.user);
910 if (ret) {
911 PERROR("Failed to move \"%s\" to trace chunk rename directory",
912 top_level_name);
913 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
914 goto end;
915 }
916 }
917 /* Release old handle. */
918 lttng_directory_handle_put(chunk->chunk_directory);
919 /*
920 * Transfer new handle reference to chunk as the current chunk
921 * handle.
922 */
923 chunk->chunk_directory = rename_directory;
924 rename_directory = NULL;
925
926 /* Remove old directory. */
927 status = (lttng_trace_chunk_status) lttng_directory_handle_remove_subdirectory(
928 chunk->session_output_directory,
929 old_path);
930 if (status != LTTNG_TRACE_CHUNK_STATUS_OK) {
931 ERR("Error removing subdirectory '%s' file when deleting chunk",
932 old_path);
933 goto end;
934 }
935 } else {
936 /* Unexpected !old_path && !path. */
937 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT;
938 goto end;
939 }
940
941skip_move:
942 new_path = strdup(path);
943 if (!new_path) {
944 ERR("Failed to allocate new trace chunk path");
945 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
946 goto end;
947 }
948 free(chunk->path);
949 chunk->path = new_path;
950end:
951 lttng_directory_handle_put(rename_directory);
952 return status;
953}
954
955enum lttng_trace_chunk_status lttng_trace_chunk_rename_path(
956 struct lttng_trace_chunk *chunk, const char *path)
957
958{
959 enum lttng_trace_chunk_status status;
960
961 pthread_mutex_lock(&chunk->lock);
962 status = lttng_trace_chunk_rename_path_no_lock(chunk, path);
963 pthread_mutex_unlock(&chunk->lock);
964
965 return status;
966}
967
968enum lttng_trace_chunk_status lttng_trace_chunk_get_credentials(
969 struct lttng_trace_chunk *chunk,
970 struct lttng_credentials *credentials)
971{
972 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
973
974 pthread_mutex_lock(&chunk->lock);
975 if (chunk->credentials.is_set) {
976 if (chunk->credentials.value.use_current_user) {
977 LTTNG_OPTIONAL_SET(&credentials->uid, geteuid());
978 LTTNG_OPTIONAL_SET(&credentials->gid, getegid());
979 } else {
980 *credentials = chunk->credentials.value.user;
981 }
982 } else {
983 status = LTTNG_TRACE_CHUNK_STATUS_NONE;
984 }
985 pthread_mutex_unlock(&chunk->lock);
986 return status;
987}
988
989enum lttng_trace_chunk_status lttng_trace_chunk_set_credentials(
990 struct lttng_trace_chunk *chunk,
991 const struct lttng_credentials *user_credentials)
992{
993 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
994 const struct chunk_credentials credentials = {
995 .use_current_user = false,
996 .user = *user_credentials,
997 };
998
999 pthread_mutex_lock(&chunk->lock);
1000 if (chunk->credentials.is_set) {
1001 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1002 goto end;
1003 }
1004 LTTNG_OPTIONAL_SET(&chunk->credentials, credentials);
1005end:
1006 pthread_mutex_unlock(&chunk->lock);
1007 return status;
1008}
1009
1010enum lttng_trace_chunk_status lttng_trace_chunk_set_credentials_current_user(
1011 struct lttng_trace_chunk *chunk)
1012{
1013 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
1014 const struct chunk_credentials credentials = {
1015 .use_current_user = true,
1016 .user = {},
1017 };
1018
1019 pthread_mutex_lock(&chunk->lock);
1020 if (chunk->credentials.is_set) {
1021 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1022 goto end;
1023 }
1024 LTTNG_OPTIONAL_SET(&chunk->credentials, credentials);
1025end:
1026 pthread_mutex_unlock(&chunk->lock);
1027 return status;
1028}
1029
1030
1031enum lttng_trace_chunk_status lttng_trace_chunk_set_as_owner(
1032 struct lttng_trace_chunk *chunk,
1033 struct lttng_directory_handle *session_output_directory)
1034{
1035 int ret;
1036 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
1037 struct lttng_directory_handle *chunk_directory_handle = NULL;
1038 bool reference_acquired;
1039
1040 pthread_mutex_lock(&chunk->lock);
1041 if (chunk->mode.is_set) {
1042 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION;
1043 goto end;
1044 }
1045 if (!chunk->credentials.is_set) {
1046 /*
1047 * Fatal error, credentials must be set before a
1048 * directory is created.
1049 */
1050 ERR("Credentials of trace chunk are unset: refusing to set session output directory");
1051 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1052 goto end;
1053 }
1054 if (chunk->path && chunk->path[0] != '\0') {
1055 ret = lttng_directory_handle_create_subdirectory_as_user(
1056 session_output_directory,
1057 chunk->path,
1058 DIR_CREATION_MODE,
1059 !chunk->credentials.value.use_current_user ?
1060 &chunk->credentials.value.user : NULL);
1061 if (ret) {
1062 PERROR("Failed to create chunk output directory \"%s\"",
1063 chunk->path);
1064 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1065 goto end;
1066 }
1067 chunk_directory_handle =
1068 chunk->fd_tracker ?
1069 fd_tracker_create_directory_handle_from_handle(
1070 chunk->fd_tracker,
1071 session_output_directory,
1072 chunk->path) :
1073 lttng_directory_handle_create_from_handle(
1074 chunk->path,
1075 session_output_directory);
1076 if (!chunk_directory_handle) {
1077 /* The function already logs on all error paths. */
1078 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1079 goto end;
1080 }
1081 } else {
1082 /*
1083 * A nameless chunk does not need its own output directory.
1084 * The session's output directory will be used.
1085 */
1086 reference_acquired = lttng_directory_handle_get(
1087 session_output_directory);
1088
1089 LTTNG_ASSERT(reference_acquired);
1090 chunk_directory_handle = session_output_directory;
1091 }
1092 chunk->chunk_directory = chunk_directory_handle;
1093 chunk_directory_handle = NULL;
1094 reference_acquired = lttng_directory_handle_get(
1095 session_output_directory);
1096 LTTNG_ASSERT(reference_acquired);
1097 chunk->session_output_directory = session_output_directory;
1098 LTTNG_OPTIONAL_SET(&chunk->mode, TRACE_CHUNK_MODE_OWNER);
1099end:
1100 pthread_mutex_unlock(&chunk->lock);
1101 return status;
1102}
1103
1104enum lttng_trace_chunk_status lttng_trace_chunk_set_as_user(
1105 struct lttng_trace_chunk *chunk,
1106 struct lttng_directory_handle *chunk_directory)
1107{
1108 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
1109 bool reference_acquired;
1110
1111 pthread_mutex_lock(&chunk->lock);
1112 if (chunk->mode.is_set) {
1113 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION;
1114 goto end;
1115 }
1116 if (!chunk->credentials.is_set) {
1117 ERR("Credentials of trace chunk are unset: refusing to set chunk output directory");
1118 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1119 goto end;
1120 }
1121 reference_acquired = lttng_directory_handle_get(chunk_directory);
1122 LTTNG_ASSERT(reference_acquired);
1123 chunk->chunk_directory = chunk_directory;
1124 LTTNG_OPTIONAL_SET(&chunk->mode, TRACE_CHUNK_MODE_USER);
1125end:
1126 pthread_mutex_unlock(&chunk->lock);
1127 return status;
1128}
1129
1130enum lttng_trace_chunk_status
1131lttng_trace_chunk_get_session_output_directory_handle(
1132 struct lttng_trace_chunk *chunk,
1133 struct lttng_directory_handle **handle)
1134{
1135 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
1136
1137 pthread_mutex_lock(&chunk->lock);
1138 if (!chunk->session_output_directory) {
1139 status = LTTNG_TRACE_CHUNK_STATUS_NONE;
1140 *handle = NULL;
1141 goto end;
1142 } else {
1143 const bool reference_acquired = lttng_directory_handle_get(
1144 chunk->session_output_directory);
1145
1146 LTTNG_ASSERT(reference_acquired);
1147 *handle = chunk->session_output_directory;
1148 }
1149end:
1150 pthread_mutex_unlock(&chunk->lock);
1151 return status;
1152}
1153
1154enum lttng_trace_chunk_status lttng_trace_chunk_borrow_chunk_directory_handle(
1155 struct lttng_trace_chunk *chunk,
1156 const struct lttng_directory_handle **handle)
1157{
1158 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
1159
1160 pthread_mutex_lock(&chunk->lock);
1161 if (!chunk->chunk_directory) {
1162 status = LTTNG_TRACE_CHUNK_STATUS_NONE;
1163 goto end;
1164 }
1165
1166 *handle = chunk->chunk_directory;
1167end:
1168 pthread_mutex_unlock(&chunk->lock);
1169 return status;
1170}
1171
1172/* Add a top-level directory to the trace chunk if it was previously unknown. */
1173static
1174int add_top_level_directory_unique(struct lttng_trace_chunk *chunk,
1175 const char *new_path)
1176{
1177 int ret = 0;
1178 bool found = false;
1179 size_t i, count = lttng_dynamic_pointer_array_get_count(
1180 &chunk->top_level_directories);
1181 const char *new_path_separator_pos = strchr(new_path, '/');
1182 const ptrdiff_t new_path_top_level_len = new_path_separator_pos ?
1183 new_path_separator_pos - new_path : strlen(new_path);
1184
1185 for (i = 0; i < count; i++) {
1186 const char *path = (const char *) lttng_dynamic_pointer_array_get_pointer(
1187 &chunk->top_level_directories, i);
1188 const ptrdiff_t path_top_level_len = strlen(path);
1189
1190 if (path_top_level_len != new_path_top_level_len) {
1191 continue;
1192 }
1193 if (!strncmp(path, new_path, path_top_level_len)) {
1194 found = true;
1195 break;
1196 }
1197 }
1198
1199 if (!found) {
1200 char *copy = lttng_strndup(new_path, new_path_top_level_len);
1201
1202 DBG("Adding new top-level directory \"%s\" to trace chunk \"%s\"",
1203 new_path, chunk->name ? : "(unnamed)");
1204 if (!copy) {
1205 PERROR("Failed to copy path");
1206 ret = -1;
1207 goto end;
1208 }
1209 ret = lttng_dynamic_pointer_array_add_pointer(
1210 &chunk->top_level_directories, copy);
1211 if (ret) {
1212 ERR("Allocation failure while adding top-level directory entry to a trace chunk");
1213 free(copy);
1214 goto end;
1215 }
1216 }
1217end:
1218 return ret;
1219}
1220
1221enum lttng_trace_chunk_status lttng_trace_chunk_create_subdirectory(
1222 struct lttng_trace_chunk *chunk,
1223 const char *path)
1224{
1225 int ret;
1226 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
1227
1228 DBG("Creating trace chunk subdirectory \"%s\"", path);
1229 pthread_mutex_lock(&chunk->lock);
1230 if (!chunk->credentials.is_set) {
1231 /*
1232 * Fatal error, credentials must be set before a
1233 * directory is created.
1234 */
1235 ERR("Credentials of trace chunk are unset: refusing to create subdirectory \"%s\"",
1236 path);
1237 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1238 goto end;
1239 }
1240 if (!chunk->mode.is_set ||
1241 chunk->mode.value != TRACE_CHUNK_MODE_OWNER) {
1242 ERR("Attempted to create trace chunk subdirectory \"%s\" through a non-owner chunk",
1243 path);
1244 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION;
1245 goto end;
1246 }
1247 if (!chunk->chunk_directory) {
1248 ERR("Attempted to create trace chunk subdirectory \"%s\" before setting the chunk output directory",
1249 path);
1250 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1251 goto end;
1252 }
1253 if (*path == '/') {
1254 ERR("Refusing to create absolute trace chunk directory \"%s\"",
1255 path);
1256 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT;
1257 goto end;
1258 }
1259 ret = lttng_directory_handle_create_subdirectory_recursive_as_user(
1260 chunk->chunk_directory, path,
1261 DIR_CREATION_MODE,
1262 chunk->credentials.value.use_current_user ?
1263 NULL : &chunk->credentials.value.user);
1264 if (ret) {
1265 PERROR("Failed to create trace chunk subdirectory \"%s\"",
1266 path);
1267 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1268 goto end;
1269 }
1270 ret = add_top_level_directory_unique(chunk, path);
1271 if (ret) {
1272 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1273 goto end;
1274 }
1275end:
1276 pthread_mutex_unlock(&chunk->lock);
1277 return status;
1278}
1279
1280/*
1281 * TODO: Implement O(1) lookup.
1282 */
1283static
1284bool lttng_trace_chunk_find_file(struct lttng_trace_chunk *chunk,
1285 const char *path, size_t *index)
1286{
1287 size_t i, count;
1288
1289 count = lttng_dynamic_pointer_array_get_count(&chunk->files);
1290 for (i = 0; i < count; i++) {
1291 const char *iter_path =
1292 (const char *) lttng_dynamic_pointer_array_get_pointer(
1293 &chunk->files, i);
1294 if (!strcmp(iter_path, path)) {
1295 if (index) {
1296 *index = i;
1297 }
1298 return true;
1299 }
1300 }
1301 return false;
1302}
1303
1304static
1305enum lttng_trace_chunk_status lttng_trace_chunk_add_file(
1306 struct lttng_trace_chunk *chunk,
1307 const char *path)
1308{
1309 char *copy;
1310 int ret;
1311 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
1312
1313 if (lttng_trace_chunk_find_file(chunk, path, NULL)) {
1314 return LTTNG_TRACE_CHUNK_STATUS_OK;
1315 }
1316 DBG("Adding new file \"%s\" to trace chunk \"%s\"",
1317 path, chunk->name ? : "(unnamed)");
1318 copy = strdup(path);
1319 if (!copy) {
1320 PERROR("Failed to copy path");
1321 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1322 goto end;
1323 }
1324 ret = lttng_dynamic_pointer_array_add_pointer(
1325 &chunk->files, copy);
1326 if (ret) {
1327 ERR("Allocation failure while adding file to a trace chunk");
1328 free(copy);
1329 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1330 goto end;
1331 }
1332end:
1333 return status;
1334}
1335
1336static
1337void lttng_trace_chunk_remove_file(
1338 struct lttng_trace_chunk *chunk,
1339 const char *path)
1340{
1341 size_t index;
1342 bool found;
1343 int ret;
1344
1345 found = lttng_trace_chunk_find_file(chunk, path, &index);
1346 if (!found) {
1347 return;
1348 }
1349 ret = lttng_dynamic_pointer_array_remove_pointer(
1350 &chunk->files, index);
1351 LTTNG_ASSERT(!ret);
1352}
1353
1354static
1355enum lttng_trace_chunk_status _lttng_trace_chunk_open_fs_handle_locked(
1356 struct lttng_trace_chunk *chunk,
1357 const char *file_path,
1358 int flags,
1359 mode_t mode,
1360 struct fs_handle **out_handle,
1361 bool expect_no_file)
1362{
1363 int ret;
1364 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
1365
1366 DBG("Opening trace chunk file \"%s\"", file_path);
1367 if (!chunk->credentials.is_set) {
1368 /*
1369 * Fatal error, credentials must be set before a
1370 * file is created.
1371 */
1372 ERR("Credentials of trace chunk are unset: refusing to open file \"%s\"",
1373 file_path);
1374 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1375 goto end;
1376 }
1377 if (!chunk->chunk_directory) {
1378 ERR("Attempted to open trace chunk file \"%s\" before setting the chunk output directory",
1379 file_path);
1380 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1381 goto end;
1382 }
1383 status = lttng_trace_chunk_add_file(chunk, file_path);
1384 if (status != LTTNG_TRACE_CHUNK_STATUS_OK) {
1385 goto end;
1386 }
1387 if (chunk->fd_tracker) {
1388 LTTNG_ASSERT(chunk->credentials.value.use_current_user);
1389 *out_handle = fd_tracker_open_fs_handle(chunk->fd_tracker,
1390 chunk->chunk_directory, file_path, flags, &mode);
1391 ret = *out_handle ? 0 : -1;
1392 } else {
1393 ret = lttng_directory_handle_open_file_as_user(
1394 chunk->chunk_directory, file_path, flags, mode,
1395 chunk->credentials.value.use_current_user ?
1396 NULL :
1397 &chunk->credentials.value.user);
1398 if (ret >= 0) {
1399 *out_handle = fs_handle_untracked_create(
1400 chunk->chunk_directory, file_path, ret);
1401 if (!*out_handle) {
1402 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1403 goto end;
1404 }
1405 }
1406 }
1407 if (ret < 0) {
1408 if (errno == ENOENT && expect_no_file) {
1409 status = LTTNG_TRACE_CHUNK_STATUS_NO_FILE;
1410 } else {
1411 PERROR("Failed to open file relative to trace chunk file_path = \"%s\", flags = %d, mode = %d",
1412 file_path, flags, (int) mode);
1413 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1414 }
1415 lttng_trace_chunk_remove_file(chunk, file_path);
1416 goto end;
1417 }
1418end:
1419 return status;
1420}
1421
1422enum lttng_trace_chunk_status lttng_trace_chunk_open_fs_handle(
1423 struct lttng_trace_chunk *chunk,
1424 const char *file_path,
1425 int flags,
1426 mode_t mode,
1427 struct fs_handle **out_handle,
1428 bool expect_no_file)
1429{
1430 enum lttng_trace_chunk_status status;
1431
1432 pthread_mutex_lock(&chunk->lock);
1433 status = _lttng_trace_chunk_open_fs_handle_locked(chunk, file_path,
1434 flags, mode, out_handle, expect_no_file);
1435 pthread_mutex_unlock(&chunk->lock);
1436 return status;
1437}
1438
1439enum lttng_trace_chunk_status lttng_trace_chunk_open_file(
1440 struct lttng_trace_chunk *chunk,
1441 const char *file_path,
1442 int flags,
1443 mode_t mode,
1444 int *out_fd,
1445 bool expect_no_file)
1446{
1447 enum lttng_trace_chunk_status status;
1448 struct fs_handle *fs_handle;
1449
1450 pthread_mutex_lock(&chunk->lock);
1451 /*
1452 * Using this method is never valid when an fd_tracker is being
1453 * used since the resulting file descriptor would not be tracked.
1454 */
1455 LTTNG_ASSERT(!chunk->fd_tracker);
1456 status = _lttng_trace_chunk_open_fs_handle_locked(chunk, file_path,
1457 flags, mode, &fs_handle, expect_no_file);
1458 pthread_mutex_unlock(&chunk->lock);
1459
1460 if (status == LTTNG_TRACE_CHUNK_STATUS_OK) {
1461 *out_fd = fs_handle_get_fd(fs_handle);
1462 /*
1463 * Does not close the fd; we just "unbox" it from the fs_handle.
1464 */
1465 fs_handle_untracked_destroy(lttng::utils::container_of(
1466 fs_handle, &fs_handle_untracked::parent));
1467 }
1468
1469 return status;
1470}
1471
1472int lttng_trace_chunk_unlink_file(struct lttng_trace_chunk *chunk,
1473 const char *file_path)
1474{
1475 int ret;
1476 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
1477
1478 DBG("Unlinking trace chunk file \"%s\"", file_path);
1479 pthread_mutex_lock(&chunk->lock);
1480 if (!chunk->credentials.is_set) {
1481 /*
1482 * Fatal error, credentials must be set before a
1483 * file is unlinked.
1484 */
1485 ERR("Credentials of trace chunk are unset: refusing to unlink file \"%s\"",
1486 file_path);
1487 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1488 goto end;
1489 }
1490 if (!chunk->chunk_directory) {
1491 ERR("Attempted to unlink trace chunk file \"%s\" before setting the chunk output directory",
1492 file_path);
1493 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1494 goto end;
1495 }
1496 ret = lttng_directory_handle_unlink_file_as_user(
1497 chunk->chunk_directory, file_path,
1498 chunk->credentials.value.use_current_user ?
1499 NULL : &chunk->credentials.value.user);
1500 if (ret < 0) {
1501 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1502 goto end;
1503 }
1504 lttng_trace_chunk_remove_file(chunk, file_path);
1505end:
1506 pthread_mutex_unlock(&chunk->lock);
1507 return status;
1508}
1509
1510static
1511int lttng_trace_chunk_remove_subdirectory_recursive(struct lttng_trace_chunk *chunk,
1512 const char *path)
1513{
1514 int ret;
1515 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
1516
1517 DBG("Recursively removing trace chunk directory \"%s\"", path);
1518 pthread_mutex_lock(&chunk->lock);
1519 if (!chunk->credentials.is_set) {
1520 /*
1521 * Fatal error, credentials must be set before a
1522 * directory is removed.
1523 */
1524 ERR("Credentials of trace chunk are unset: refusing to recursively remove directory \"%s\"",
1525 path);
1526 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1527 goto end;
1528 }
1529 if (!chunk->chunk_directory) {
1530 ERR("Attempted to recursively remove trace chunk directory \"%s\" before setting the chunk output directory",
1531 path);
1532 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1533 goto end;
1534 }
1535 ret = lttng_directory_handle_remove_subdirectory_recursive_as_user(
1536 chunk->chunk_directory, path,
1537 chunk->credentials.value.use_current_user ?
1538 NULL : &chunk->credentials.value.user,
1539 LTTNG_DIRECTORY_HANDLE_SKIP_NON_EMPTY_FLAG);
1540 if (ret < 0) {
1541 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
1542 goto end;
1543 }
1544end:
1545 pthread_mutex_unlock(&chunk->lock);
1546 return status;
1547}
1548
1549static
1550int lttng_trace_chunk_move_to_completed_post_release(
1551 struct lttng_trace_chunk *trace_chunk)
1552{
1553 int ret = 0;
1554 char *archived_chunk_name = NULL;
1555 const uint64_t chunk_id = LTTNG_OPTIONAL_GET(trace_chunk->id);
1556 const time_t creation_timestamp =
1557 LTTNG_OPTIONAL_GET(trace_chunk->timestamp_creation);
1558 const time_t close_timestamp =
1559 LTTNG_OPTIONAL_GET(trace_chunk->timestamp_close);
1560 struct lttng_directory_handle *archived_chunks_directory = NULL;
1561 enum lttng_trace_chunk_status status;
1562
1563 if (!trace_chunk->mode.is_set ||
1564 trace_chunk->mode.value != TRACE_CHUNK_MODE_OWNER ||
1565 !trace_chunk->session_output_directory) {
1566 /*
1567 * This command doesn't need to run if the output is remote
1568 * or if the trace chunk is not owned by this process.
1569 */
1570 goto end;
1571 }
1572
1573 LTTNG_ASSERT(trace_chunk->mode.value == TRACE_CHUNK_MODE_OWNER);
1574 LTTNG_ASSERT(!trace_chunk->name_overridden);
1575 LTTNG_ASSERT(trace_chunk->path);
1576
1577 archived_chunk_name = generate_chunk_name(chunk_id, creation_timestamp,
1578 &close_timestamp);
1579 if (!archived_chunk_name) {
1580 ERR("Failed to generate archived trace chunk name while renaming trace chunk");
1581 ret = -1;
1582 goto end;
1583 }
1584
1585 ret = lttng_directory_handle_create_subdirectory_as_user(
1586 trace_chunk->session_output_directory,
1587 DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY,
1588 DIR_CREATION_MODE,
1589 !trace_chunk->credentials.value.use_current_user ?
1590 &trace_chunk->credentials.value.user :
1591 NULL);
1592 if (ret) {
1593 PERROR("Failed to create \"" DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY
1594 "\" directory for archived trace chunks");
1595 goto end;
1596 }
1597
1598 archived_chunks_directory = trace_chunk->fd_tracker ?
1599 fd_tracker_create_directory_handle_from_handle(
1600 trace_chunk->fd_tracker,
1601 trace_chunk->session_output_directory,
1602 DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY) :
1603 lttng_directory_handle_create_from_handle(
1604 DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY,
1605 trace_chunk->session_output_directory);
1606 if (!archived_chunks_directory) {
1607 PERROR("Failed to get handle to archived trace chunks directory");
1608 ret = -1;
1609 goto end;
1610 }
1611
1612 /*
1613 * Make sure chunk is renamed to old directory if not already done by
1614 * the creation of the next chunk. This happens if a rotation is
1615 * performed while tracing is stopped.
1616 */
1617 if (!trace_chunk->path || strcmp(trace_chunk->path,
1618 DEFAULT_CHUNK_TMP_OLD_DIRECTORY)) {
1619 status = lttng_trace_chunk_rename_path_no_lock(trace_chunk,
1620 DEFAULT_CHUNK_TMP_OLD_DIRECTORY);
1621 if (status != LTTNG_TRACE_CHUNK_STATUS_OK) {
1622 ERR("Failed to rename chunk to %s", DEFAULT_CHUNK_TMP_OLD_DIRECTORY);
1623 ret = -1;
1624 goto end;
1625 }
1626 }
1627
1628 ret = lttng_directory_handle_rename_as_user(
1629 trace_chunk->session_output_directory,
1630 trace_chunk->path,
1631 archived_chunks_directory,
1632 archived_chunk_name,
1633 LTTNG_OPTIONAL_GET(trace_chunk->credentials).use_current_user ?
1634 NULL :
1635 &trace_chunk->credentials.value.user);
1636 if (ret) {
1637 PERROR("Failed to rename folder \"%s\" to \"%s\"",
1638 trace_chunk->path,
1639 archived_chunk_name);
1640 }
1641
1642end:
1643 lttng_directory_handle_put(archived_chunks_directory);
1644 free(archived_chunk_name);
1645 return ret;
1646}
1647
1648static
1649int lttng_trace_chunk_no_operation(struct lttng_trace_chunk *trace_chunk __attribute__((unused)))
1650{
1651 return 0;
1652}
1653
1654static
1655int lttng_trace_chunk_delete_post_release_user(
1656 struct lttng_trace_chunk *trace_chunk)
1657{
1658 int ret = 0;
1659
1660 DBG("Trace chunk \"delete\" close command post-release (User)");
1661
1662 /* Unlink all files. */
1663 while (lttng_dynamic_pointer_array_get_count(&trace_chunk->files) != 0) {
1664 enum lttng_trace_chunk_status status;
1665 const char *path;
1666
1667 /* Remove first. */
1668 path = (const char *) lttng_dynamic_pointer_array_get_pointer(
1669 &trace_chunk->files, 0);
1670 DBG("Unlink file: %s", path);
1671 status = (lttng_trace_chunk_status) lttng_trace_chunk_unlink_file(trace_chunk, path);
1672 if (status != LTTNG_TRACE_CHUNK_STATUS_OK) {
1673 ERR("Error unlinking file '%s' when deleting chunk", path);
1674 ret = -1;
1675 goto end;
1676 }
1677 }
1678end:
1679 return ret;
1680}
1681
1682static
1683int lttng_trace_chunk_delete_post_release_owner(
1684 struct lttng_trace_chunk *trace_chunk)
1685{
1686 enum lttng_trace_chunk_status status;
1687 size_t i, count;
1688 int ret = 0;
1689
1690 ret = lttng_trace_chunk_delete_post_release_user(trace_chunk);
1691 if (ret) {
1692 goto end;
1693 }
1694
1695 DBG("Trace chunk \"delete\" close command post-release (Owner)");
1696
1697 LTTNG_ASSERT(trace_chunk->session_output_directory);
1698 LTTNG_ASSERT(trace_chunk->chunk_directory);
1699
1700 /* Remove empty directories. */
1701 count = lttng_dynamic_pointer_array_get_count(
1702 &trace_chunk->top_level_directories);
1703
1704 for (i = 0; i < count; i++) {
1705 const char *top_level_name =
1706 (const char *) lttng_dynamic_pointer_array_get_pointer(
1707 &trace_chunk->top_level_directories, i);
1708
1709 status = (lttng_trace_chunk_status) lttng_trace_chunk_remove_subdirectory_recursive(trace_chunk, top_level_name);
1710 if (status != LTTNG_TRACE_CHUNK_STATUS_OK) {
1711 ERR("Error recursively removing subdirectory '%s' file when deleting chunk",
1712 top_level_name);
1713 ret = -1;
1714 break;
1715 }
1716 }
1717 if (!ret) {
1718 lttng_directory_handle_put(trace_chunk->chunk_directory);
1719 trace_chunk->chunk_directory = NULL;
1720
1721 if (trace_chunk->path && trace_chunk->path[0] != '\0') {
1722 status = (lttng_trace_chunk_status) lttng_directory_handle_remove_subdirectory(
1723 trace_chunk->session_output_directory,
1724 trace_chunk->path);
1725 if (status != LTTNG_TRACE_CHUNK_STATUS_OK) {
1726 ERR("Error removing subdirectory '%s' file when deleting chunk",
1727 trace_chunk->path);
1728 ret = -1;
1729 }
1730 }
1731 }
1732 free(trace_chunk->path);
1733 trace_chunk->path = NULL;
1734end:
1735 return ret;
1736}
1737
1738/*
1739 * For local files, session and consumer daemons all run the delete hook. The
1740 * consumer daemons have the list of files to unlink, and technically the
1741 * session daemon is the owner of the chunk. Unlink all files owned by each
1742 * consumer daemon.
1743 */
1744static
1745int lttng_trace_chunk_delete_post_release(
1746 struct lttng_trace_chunk *trace_chunk)
1747{
1748 if (!trace_chunk->chunk_directory) {
1749 return 0;
1750 }
1751
1752 if (trace_chunk->mode.value == TRACE_CHUNK_MODE_OWNER) {
1753 return lttng_trace_chunk_delete_post_release_owner(trace_chunk);
1754 } else {
1755 return lttng_trace_chunk_delete_post_release_user(trace_chunk);
1756 }
1757}
1758
1759enum lttng_trace_chunk_status lttng_trace_chunk_get_close_command(
1760 struct lttng_trace_chunk *chunk,
1761 enum lttng_trace_chunk_command_type *command_type)
1762{
1763 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
1764
1765 pthread_mutex_lock(&chunk->lock);
1766 if (chunk->close_command.is_set) {
1767 *command_type = chunk->close_command.value;
1768 status = LTTNG_TRACE_CHUNK_STATUS_OK;
1769 } else {
1770 status = LTTNG_TRACE_CHUNK_STATUS_NONE;
1771 }
1772 pthread_mutex_unlock(&chunk->lock);
1773 return status;
1774}
1775
1776enum lttng_trace_chunk_status lttng_trace_chunk_set_close_command(
1777 struct lttng_trace_chunk *chunk,
1778 enum lttng_trace_chunk_command_type close_command)
1779{
1780 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
1781
1782 if (close_command < LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED ||
1783 close_command >= LTTNG_TRACE_CHUNK_COMMAND_TYPE_MAX) {
1784 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT;
1785 goto end;
1786 }
1787
1788 pthread_mutex_lock(&chunk->lock);
1789 if (chunk->close_command.is_set) {
1790 DBG("Overriding trace chunk close command from \"%s\" to \"%s\"",
1791 lttng_trace_chunk_command_type_str(chunk->close_command.value),
1792 lttng_trace_chunk_command_type_str(close_command));
1793 } else {
1794 DBG("Setting trace chunk close command to \"%s\"",
1795 lttng_trace_chunk_command_type_str(close_command));
1796 }
1797 /*
1798 * Unset close command for no-op for backward compatibility with relayd
1799 * 2.11.
1800 */
1801 if (close_command != LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION) {
1802 LTTNG_OPTIONAL_SET(&chunk->close_command, close_command);
1803 } else {
1804 LTTNG_OPTIONAL_UNSET(&chunk->close_command);
1805 }
1806 pthread_mutex_unlock(&chunk->lock);
1807end:
1808 return status;
1809}
1810
1811const char *lttng_trace_chunk_command_type_get_name(
1812 enum lttng_trace_chunk_command_type command)
1813{
1814 switch (command) {
1815 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED:
1816 return "move to completed trace chunk folder";
1817 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION:
1818 return "no operation";
1819 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_DELETE:
1820 return "delete";
1821 default:
1822 abort();
1823 }
1824}
1825
1826bool lttng_trace_chunk_ids_equal(const struct lttng_trace_chunk *chunk_a,
1827 const struct lttng_trace_chunk *chunk_b)
1828{
1829 bool equal = false;
1830
1831 if (chunk_a == chunk_b) {
1832 equal = true;
1833 goto end;
1834 }
1835
1836 if (!!chunk_a ^ !!chunk_b) {
1837 goto end;
1838 }
1839
1840 if (chunk_a->id.is_set ^ chunk_a->id.is_set) {
1841 /* One id is set and not the other, thus they are not equal. */
1842 goto end;
1843 }
1844
1845 if (!chunk_a->id.is_set) {
1846 /* Both ids are unset. */
1847 equal = true;
1848 } else {
1849 equal = chunk_a->id.value == chunk_b->id.value;
1850 }
1851
1852end:
1853 return equal;
1854}
1855
1856bool lttng_trace_chunk_get(struct lttng_trace_chunk *chunk)
1857{
1858 return urcu_ref_get_unless_zero(&chunk->ref);
1859}
1860
1861static
1862void free_lttng_trace_chunk_registry_element(struct rcu_head *node)
1863{
1864 struct lttng_trace_chunk_registry_element *element = lttng::utils::container_of(
1865 node, &lttng_trace_chunk_registry_element::rcu_node);
1866
1867 free(element);
1868}
1869
1870static
1871void lttng_trace_chunk_release(struct urcu_ref *ref)
1872{
1873 struct lttng_trace_chunk *chunk = lttng::utils::container_of(ref, &lttng_trace_chunk::ref);
1874
1875 if (chunk->close_command.is_set) {
1876 chunk_command func = close_command_get_post_release_func(chunk->close_command.value);
1877
1878 if (func(chunk)) {
1879 ERR("Trace chunk post-release command %s has failed.",
1880 lttng_trace_chunk_command_type_str(chunk->close_command.value));
1881 }
1882 }
1883
1884 if (chunk->in_registry_element) {
1885 struct lttng_trace_chunk_registry_element *element;
1886
1887 /*
1888 * Release internal chunk attributes immediately and
1889 * only use the deferred `call_rcu` work to reclaim the
1890 * storage.
1891 *
1892 * This ensures that file handles are released as soon as
1893 * possible which works around a problem we encounter with PRAM fs
1894 * mounts (and possibly other non-POSIX compliant file systems):
1895 * directories that contain files which are open can't be
1896 * rmdir().
1897 *
1898 * This means that the recording of a snapshot could be
1899 * completed, but that it would be impossible for the user to
1900 * delete it until the deferred clean-up released the file
1901 * handles to its contents.
1902 */
1903 lttng_trace_chunk_fini(chunk);
1904
1905 element = lttng::utils::container_of(
1906 chunk, &lttng_trace_chunk_registry_element::chunk);
1907 if (element->registry) {
1908 rcu_read_lock();
1909 cds_lfht_del(element->registry->ht,
1910 &element->trace_chunk_registry_ht_node);
1911 rcu_read_unlock();
1912 call_rcu(&element->rcu_node,
1913 free_lttng_trace_chunk_registry_element);
1914 } else {
1915 /* Never published, can be free'd immediately. */
1916 free_lttng_trace_chunk_registry_element(
1917 &element->rcu_node);
1918 }
1919 } else {
1920 /* Not RCU-protected, free immediately. */
1921 lttng_trace_chunk_fini(chunk);
1922 free(chunk);
1923 }
1924}
1925
1926void lttng_trace_chunk_put(struct lttng_trace_chunk *chunk)
1927{
1928 if (!chunk) {
1929 return;
1930 }
1931 LTTNG_ASSERT(chunk->ref.refcount);
1932 urcu_ref_put(&chunk->ref, lttng_trace_chunk_release);
1933}
1934
1935struct lttng_trace_chunk_registry *lttng_trace_chunk_registry_create(void)
1936{
1937 struct lttng_trace_chunk_registry *registry;
1938
1939 registry = zmalloc<lttng_trace_chunk_registry>();
1940 if (!registry) {
1941 goto end;
1942 }
1943
1944 registry->ht = cds_lfht_new(DEFAULT_HT_SIZE, 1, 0,
1945 CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);
1946 if (!registry->ht) {
1947 goto error;
1948 }
1949end:
1950 return registry;
1951error:
1952 lttng_trace_chunk_registry_destroy(registry);
1953 return NULL;
1954}
1955
1956void lttng_trace_chunk_registry_destroy(
1957 struct lttng_trace_chunk_registry *registry)
1958{
1959 if (!registry) {
1960 return;
1961 }
1962 if (registry->ht) {
1963 int ret = cds_lfht_destroy(registry->ht, NULL);
1964 LTTNG_ASSERT(!ret);
1965 }
1966 free(registry);
1967}
1968
1969static
1970struct lttng_trace_chunk_registry_element *
1971lttng_trace_chunk_registry_element_create_from_chunk(
1972 struct lttng_trace_chunk *chunk, uint64_t session_id)
1973{
1974 struct lttng_trace_chunk_registry_element *element =
1975 zmalloc<lttng_trace_chunk_registry_element>();
1976
1977 if (!element) {
1978 goto end;
1979 }
1980 cds_lfht_node_init(&element->trace_chunk_registry_ht_node);
1981 element->session_id = session_id;
1982
1983 element->chunk = *chunk;
1984 lttng_trace_chunk_init(&element->chunk);
1985 if (chunk->session_output_directory) {
1986 /* Transferred ownership. */
1987 element->chunk.session_output_directory =
1988 chunk->session_output_directory;
1989 chunk->session_output_directory = NULL;
1990 }
1991 if (chunk->chunk_directory) {
1992 /* Transferred ownership. */
1993 element->chunk.chunk_directory = chunk->chunk_directory;
1994 chunk->chunk_directory = NULL;
1995 }
1996 /*
1997 * The original chunk becomes invalid; the name and path attributes are
1998 * transferred to the new chunk instance.
1999 */
2000 chunk->name = NULL;
2001 chunk->path = NULL;
2002 element->chunk.fd_tracker = chunk->fd_tracker;
2003 element->chunk.in_registry_element = true;
2004end:
2005 return element;
2006}
2007
2008struct lttng_trace_chunk *
2009lttng_trace_chunk_registry_publish_chunk(
2010 struct lttng_trace_chunk_registry *registry,
2011 uint64_t session_id,
2012 struct lttng_trace_chunk *chunk)
2013{
2014 bool unused;
2015
2016 return lttng_trace_chunk_registry_publish_chunk(
2017 registry, session_id, chunk, &unused);
2018}
2019
2020struct lttng_trace_chunk *
2021lttng_trace_chunk_registry_publish_chunk(
2022 struct lttng_trace_chunk_registry *registry,
2023 uint64_t session_id, struct lttng_trace_chunk *chunk,
2024 bool *previously_published)
2025{
2026 struct lttng_trace_chunk_registry_element *element;
2027 unsigned long element_hash;
2028
2029 pthread_mutex_lock(&chunk->lock);
2030 element = lttng_trace_chunk_registry_element_create_from_chunk(chunk,
2031 session_id);
2032 pthread_mutex_unlock(&chunk->lock);
2033 if (!element) {
2034 goto end;
2035 }
2036 /*
2037 * chunk is now invalid, the only valid operation is a 'put' from the
2038 * caller.
2039 */
2040 chunk = NULL;
2041 element_hash = lttng_trace_chunk_registry_element_hash(element);
2042
2043 rcu_read_lock();
2044 while (1) {
2045 struct cds_lfht_node *published_node;
2046 struct lttng_trace_chunk *published_chunk;
2047 struct lttng_trace_chunk_registry_element *published_element;
2048
2049 published_node = cds_lfht_add_unique(registry->ht,
2050 element_hash,
2051 lttng_trace_chunk_registry_element_match,
2052 element,
2053 &element->trace_chunk_registry_ht_node);
2054 if (published_node == &element->trace_chunk_registry_ht_node) {
2055 /* Successfully published the new element. */
2056 element->registry = registry;
2057 /* Acquire a reference for the caller. */
2058 if (lttng_trace_chunk_get(&element->chunk)) {
2059 *previously_published = false;
2060 break;
2061 } else {
2062 /*
2063 * Another thread concurrently unpublished the
2064 * trace chunk. This is currently unexpected.
2065 *
2066 * Re-attempt to publish.
2067 */
2068 ERR("Attempt to publish a trace chunk to the chunk registry raced with a trace chunk deletion");
2069 continue;
2070 }
2071 }
2072
2073 /*
2074 * An equivalent trace chunk was published before this trace
2075 * chunk. Attempt to acquire a reference to the one that was
2076 * already published and release the reference to the copy we
2077 * created if successful.
2078 */
2079 published_element = lttng::utils::container_of(published_node,
2080 &lttng_trace_chunk_registry_element::trace_chunk_registry_ht_node);
2081 published_chunk = &published_element->chunk;
2082 if (lttng_trace_chunk_get(published_chunk)) {
2083 lttng_trace_chunk_put(&element->chunk);
2084 element = published_element;
2085 *previously_published = true;
2086 break;
2087 }
2088 /*
2089 * A reference to the previously published trace chunk could not
2090 * be acquired. Hence, retry to publish our copy of the trace
2091 * chunk.
2092 */
2093 }
2094 rcu_read_unlock();
2095end:
2096 return element ? &element->chunk : NULL;
2097}
2098
2099/*
2100 * Note that the caller must be registered as an RCU thread.
2101 * However, it does not need to hold the RCU read lock. The RCU read lock is
2102 * acquired to perform the look-up in the registry's hash table and held until
2103 * after a reference to the "found" trace chunk is acquired.
2104 *
2105 * IOW, holding a reference guarantees the existence of the object for the
2106 * caller.
2107 */
2108static
2109struct lttng_trace_chunk *_lttng_trace_chunk_registry_find_chunk(
2110 const struct lttng_trace_chunk_registry *registry,
2111 uint64_t session_id, uint64_t *chunk_id)
2112{
2113 lttng_trace_chunk_registry_element target_element {};
2114
2115 target_element.chunk.id.is_set = !!chunk_id;
2116 target_element.chunk.id.value = chunk_id ? *chunk_id : 0;
2117 target_element.session_id = session_id;
2118
2119 const unsigned long element_hash =
2120 lttng_trace_chunk_registry_element_hash(
2121 &target_element);
2122 struct cds_lfht_node *published_node;
2123 struct lttng_trace_chunk_registry_element *published_element;
2124 struct lttng_trace_chunk *published_chunk = NULL;
2125 struct cds_lfht_iter iter;
2126
2127 rcu_read_lock();
2128 cds_lfht_lookup(registry->ht,
2129 element_hash,
2130 lttng_trace_chunk_registry_element_match,
2131 &target_element,
2132 &iter);
2133 published_node = cds_lfht_iter_get_node(&iter);
2134 if (!published_node) {
2135 goto end;
2136 }
2137
2138 published_element = lttng::utils::container_of(published_node,
2139 &lttng_trace_chunk_registry_element::trace_chunk_registry_ht_node);
2140 if (lttng_trace_chunk_get(&published_element->chunk)) {
2141 published_chunk = &published_element->chunk;
2142 }
2143end:
2144 rcu_read_unlock();
2145 return published_chunk;
2146}
2147
2148struct lttng_trace_chunk *
2149lttng_trace_chunk_registry_find_chunk(
2150 const struct lttng_trace_chunk_registry *registry,
2151 uint64_t session_id, uint64_t chunk_id)
2152{
2153 return _lttng_trace_chunk_registry_find_chunk(registry,
2154 session_id, &chunk_id);
2155}
2156
2157int lttng_trace_chunk_registry_chunk_exists(
2158 const struct lttng_trace_chunk_registry *registry,
2159 uint64_t session_id, uint64_t chunk_id, bool *chunk_exists)
2160{
2161 int ret = 0;
2162 lttng_trace_chunk_registry_element target_element;
2163
2164 target_element.chunk.id.is_set = true;
2165 target_element.chunk.id.value = chunk_id;
2166 target_element.session_id = session_id;
2167
2168 const unsigned long element_hash =
2169 lttng_trace_chunk_registry_element_hash(
2170 &target_element);
2171 struct cds_lfht_node *published_node;
2172 struct cds_lfht_iter iter;
2173
2174 rcu_read_lock();
2175 cds_lfht_lookup(registry->ht,
2176 element_hash,
2177 lttng_trace_chunk_registry_element_match,
2178 &target_element,
2179 &iter);
2180 published_node = cds_lfht_iter_get_node(&iter);
2181 if (!published_node) {
2182 *chunk_exists = false;
2183 goto end;
2184 }
2185
2186 *chunk_exists = !cds_lfht_is_node_deleted(published_node);
2187end:
2188 rcu_read_unlock();
2189 return ret;
2190}
2191
2192struct lttng_trace_chunk *
2193lttng_trace_chunk_registry_find_anonymous_chunk(
2194 const struct lttng_trace_chunk_registry *registry,
2195 uint64_t session_id)
2196{
2197 return _lttng_trace_chunk_registry_find_chunk(registry,
2198 session_id, NULL);
2199}
2200
2201unsigned int lttng_trace_chunk_registry_put_each_chunk(
2202 const struct lttng_trace_chunk_registry *registry)
2203{
2204 struct cds_lfht_iter iter;
2205 struct lttng_trace_chunk_registry_element *chunk_element;
2206 unsigned int trace_chunks_left = 0;
2207
2208 DBG("Releasing trace chunk registry to all trace chunks");
2209 rcu_read_lock();
2210 cds_lfht_for_each_entry(registry->ht,
2211 &iter, chunk_element, trace_chunk_registry_ht_node) {
2212 const char *chunk_id_str = "none";
2213 char chunk_id_buf[MAX_INT_DEC_LEN(uint64_t)];
2214
2215 pthread_mutex_lock(&chunk_element->chunk.lock);
2216 if (chunk_element->chunk.id.is_set) {
2217 int fmt_ret;
2218
2219 fmt_ret = snprintf(chunk_id_buf, sizeof(chunk_id_buf),
2220 "%" PRIu64,
2221 chunk_element->chunk.id.value);
2222 if (fmt_ret < 0 || fmt_ret >= sizeof(chunk_id_buf)) {
2223 chunk_id_str = "formatting error";
2224 } else {
2225 chunk_id_str = chunk_id_buf;
2226 }
2227 }
2228
2229 DBG("Releasing reference to trace chunk: session_id = %" PRIu64
2230 "chunk_id = %s, name = \"%s\", status = %s",
2231 chunk_element->session_id,
2232 chunk_id_str,
2233 chunk_element->chunk.name ? : "none",
2234 chunk_element->chunk.close_command.is_set ?
2235 "open" : "closed");
2236 pthread_mutex_unlock(&chunk_element->chunk.lock);
2237 lttng_trace_chunk_put(&chunk_element->chunk);
2238 trace_chunks_left++;
2239 }
2240 rcu_read_unlock();
2241 DBG("Released reference to %u trace chunks in %s()", trace_chunks_left,
2242 __FUNCTION__);
2243
2244 return trace_chunks_left;
2245}
This page took 0.047851 seconds and 4 git commands to generate.