2 * Copyright (C) 2019 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 * SPDX-License-Identifier: LGPL-2.1-only
8 #include <common/compat/directory-handle.h>
9 #include <common/credentials.h>
10 #include <common/defaults.h>
11 #include <common/dynamic-array.h>
12 #include <common/error.h>
13 #include <common/fd-tracker/fd-tracker.h>
14 #include <common/fd-tracker/utils.h>
15 #include <common/fs-handle.h>
16 #include <common/fs-handle-internal.h>
17 #include <common/hashtable/hashtable.h>
18 #include <common/hashtable/utils.h>
19 #include <common/optional.h>
20 #include <common/string-utils/format.h>
21 #include <common/time.h>
22 #include <common/trace-chunk-registry.h>
23 #include <common/trace-chunk.h>
24 #include <common/utils.h>
25 #include <lttng/constant.h>
31 #include <urcu/rculfhash.h>
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>.
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)
41 enum trace_chunk_mode
{
42 TRACE_CHUNK_MODE_USER
,
43 TRACE_CHUNK_MODE_OWNER
,
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).
52 typedef int (*chunk_command
)(struct lttng_trace_chunk
*trace_chunk
);
54 /* Move a completed trace chunk to the 'completed' trace archive folder. */
56 int lttng_trace_chunk_move_to_completed_post_release(struct lttng_trace_chunk
*trace_chunk
);
59 int lttng_trace_chunk_no_operation(struct lttng_trace_chunk
*trace_chunk
);
60 /* Unlink old chunk files. */
62 int lttng_trace_chunk_delete_post_release(struct lttng_trace_chunk
*trace_chunk
);
64 enum lttng_trace_chunk_status
lttng_trace_chunk_rename_path_no_lock(
65 struct lttng_trace_chunk
*chunk
, const char *path
);
67 struct chunk_credentials
{
68 bool use_current_user
;
69 struct lttng_credentials user
;
73 * NOTE: Make sure to update:
74 * - lttng_trace_chunk_copy(),
75 * - lttng_trace_chunk_registry_element_create_from_chunk()
76 * if you modify this structure.
78 struct lttng_trace_chunk
{
81 LTTNG_OPTIONAL(enum trace_chunk_mode
) mode
;
83 * First-level directories created within the trace chunk.
84 * Elements are of type 'char *'.
86 * Only used by _owner_ mode chunks.
88 struct lttng_dynamic_pointer_array top_level_directories
;
90 * All files contained within the trace chunk.
91 * Array of paths (char *).
93 struct lttng_dynamic_pointer_array files
;
94 /* Is contained within an lttng_trace_chunk_registry_element? */
95 bool in_registry_element
;
99 /* An unset id means the chunk is anonymous. */
100 LTTNG_OPTIONAL(uint64_t) id
;
103 * The creation and close timestamps are NOT monotonic.
104 * They must not be used in context were monotonicity is required.
106 LTTNG_OPTIONAL(time_t) timestamp_creation
;
107 LTTNG_OPTIONAL(time_t) timestamp_close
;
109 LTTNG_OPTIONAL(struct chunk_credentials
) credentials
;
110 struct lttng_directory_handle
*session_output_directory
;
111 struct lttng_directory_handle
*chunk_directory
;
112 LTTNG_OPTIONAL(enum lttng_trace_chunk_command_type
) close_command
;
114 * fd_tracker instance through which file descriptors should be
117 * An fd_tracker always outlives any trace chunk; there is no
118 * need to perform any reference counting of that object.
120 struct fd_tracker
*fd_tracker
;
123 /* A trace chunk is uniquely identified by its (session id, chunk id) tuple. */
124 struct lttng_trace_chunk_registry_element
{
125 struct lttng_trace_chunk chunk
;
127 /* Weak and only set when added. */
128 struct lttng_trace_chunk_registry
*registry
;
129 struct cds_lfht_node trace_chunk_registry_ht_node
;
130 /* call_rcu delayed reclaim. */
131 struct rcu_head rcu_node
;
134 struct lttng_trace_chunk_registry
{
138 struct fs_handle_untracked
{
139 struct fs_handle parent
;
142 struct lttng_directory_handle
*directory_handle
;
148 int fs_handle_untracked_get_fd(struct fs_handle
*handle
);
150 void fs_handle_untracked_put_fd(struct fs_handle
*handle
);
152 int fs_handle_untracked_unlink(struct fs_handle
*handle
);
154 int fs_handle_untracked_close(struct fs_handle
*handle
);
157 const char *lttng_trace_chunk_command_type_str(
158 lttng_trace_chunk_command_type type
) {
160 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED
:
161 return "move to completed chunk folder";
162 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION
:
163 return "no operation";
164 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_DELETE
:
166 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_MAX
:
174 const chunk_command
close_command_get_post_release_func(
175 lttng_trace_chunk_command_type type
) {
177 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED
:
178 return lttng_trace_chunk_move_to_completed_post_release
;
179 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION
:
180 return lttng_trace_chunk_no_operation
;
181 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_DELETE
:
182 return lttng_trace_chunk_delete_post_release
;
183 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_MAX
:
191 struct fs_handle
*fs_handle_untracked_create(
192 struct lttng_directory_handle
*directory_handle
,
196 struct fs_handle_untracked
*handle
= NULL
;
197 bool reference_acquired
;
198 char *path_copy
= strdup(path
);
200 LTTNG_ASSERT(fd
>= 0);
202 PERROR("Failed to copy file path while creating untracked filesystem handle");
206 handle
= (fs_handle_untracked
*) zmalloc(sizeof(typeof(*handle
)));
208 PERROR("Failed to allocate untracked filesystem handle");
212 handle
->parent
= (typeof(handle
->parent
)) {
213 .get_fd
= fs_handle_untracked_get_fd
,
214 .put_fd
= fs_handle_untracked_put_fd
,
215 .unlink
= fs_handle_untracked_unlink
,
216 .close
= fs_handle_untracked_close
,
220 reference_acquired
= lttng_directory_handle_get(directory_handle
);
221 LTTNG_ASSERT(reference_acquired
);
222 handle
->location
.directory_handle
= directory_handle
;
223 /* Ownership is transferred. */
224 handle
->location
.path
= path_copy
;
228 return handle
? &handle
->parent
: NULL
;
232 int fs_handle_untracked_get_fd(struct fs_handle
*_handle
)
234 struct fs_handle_untracked
*handle
= container_of(
235 _handle
, struct fs_handle_untracked
, parent
);
241 void fs_handle_untracked_put_fd(struct fs_handle
*_handle
)
247 int fs_handle_untracked_unlink(struct fs_handle
*_handle
)
249 struct fs_handle_untracked
*handle
= container_of(
250 _handle
, struct fs_handle_untracked
, parent
);
252 return lttng_directory_handle_unlink_file(
253 handle
->location
.directory_handle
,
254 handle
->location
.path
);
258 void fs_handle_untracked_destroy(struct fs_handle_untracked
*handle
)
260 lttng_directory_handle_put(handle
->location
.directory_handle
);
261 free(handle
->location
.path
);
266 int fs_handle_untracked_close(struct fs_handle
*_handle
)
268 struct fs_handle_untracked
*handle
= container_of(
269 _handle
, struct fs_handle_untracked
, parent
);
270 int ret
= close(handle
->fd
);
272 fs_handle_untracked_destroy(handle
);
277 bool lttng_trace_chunk_registry_element_equals(
278 const struct lttng_trace_chunk_registry_element
*a
,
279 const struct lttng_trace_chunk_registry_element
*b
)
281 if (a
->session_id
!= b
->session_id
) {
284 if (a
->chunk
.id
.is_set
!= b
->chunk
.id
.is_set
) {
287 if (a
->chunk
.id
.is_set
&& a
->chunk
.id
.value
!= b
->chunk
.id
.value
) {
296 int lttng_trace_chunk_registry_element_match(struct cds_lfht_node
*node
,
299 const struct lttng_trace_chunk_registry_element
*element_a
, *element_b
;
301 element_a
= (const struct lttng_trace_chunk_registry_element
*) key
;
302 element_b
= caa_container_of(node
, typeof(*element_b
),
303 trace_chunk_registry_ht_node
);
304 return lttng_trace_chunk_registry_element_equals(element_a
, element_b
);
308 unsigned long lttng_trace_chunk_registry_element_hash(
309 const struct lttng_trace_chunk_registry_element
*element
)
311 unsigned long hash
= hash_key_u64(&element
->session_id
,
314 if (element
->chunk
.id
.is_set
) {
315 hash
^= hash_key_u64(&element
->chunk
.id
.value
, lttng_ht_seed
);
322 char *generate_chunk_name(uint64_t chunk_id
, time_t creation_timestamp
,
323 const time_t *close_timestamp
)
326 char *new_name
= NULL
;
327 char start_datetime
[ISO8601_STR_LEN
] = {};
328 /* Add 1 for a '-' prefix. */
329 char end_datetime_suffix
[ISO8601_STR_LEN
+ 1] = {};
331 ret
= time_to_iso8601_str(
333 start_datetime
, sizeof(start_datetime
));
335 ERR("Failed to format trace chunk start date time");
338 if (close_timestamp
) {
339 *end_datetime_suffix
= '-';
340 ret
= time_to_iso8601_str(
342 end_datetime_suffix
+ 1,
343 sizeof(end_datetime_suffix
) - 1);
345 ERR("Failed to format trace chunk end date time");
349 new_name
= (char *) zmalloc(GENERATED_CHUNK_NAME_LEN
);
351 ERR("Failed to allocate buffer for automatically-generated trace chunk name");
354 ret
= snprintf(new_name
, GENERATED_CHUNK_NAME_LEN
, "%s%s-%" PRIu64
,
355 start_datetime
, end_datetime_suffix
, chunk_id
);
356 if (ret
>= GENERATED_CHUNK_NAME_LEN
|| ret
== -1) {
357 ERR("Failed to format trace chunk name");
368 void lttng_trace_chunk_init(struct lttng_trace_chunk
*chunk
)
370 urcu_ref_init(&chunk
->ref
);
371 pthread_mutex_init(&chunk
->lock
, NULL
);
372 lttng_dynamic_pointer_array_init(&chunk
->top_level_directories
, free
);
373 lttng_dynamic_pointer_array_init(&chunk
->files
, free
);
377 void lttng_trace_chunk_fini(struct lttng_trace_chunk
*chunk
)
379 if (chunk
->session_output_directory
) {
380 lttng_directory_handle_put(
381 chunk
->session_output_directory
);
382 chunk
->session_output_directory
= NULL
;
384 if (chunk
->chunk_directory
) {
385 lttng_directory_handle_put(chunk
->chunk_directory
);
386 chunk
->chunk_directory
= NULL
;
392 lttng_dynamic_pointer_array_reset(&chunk
->top_level_directories
);
393 lttng_dynamic_pointer_array_reset(&chunk
->files
);
394 pthread_mutex_destroy(&chunk
->lock
);
398 struct lttng_trace_chunk
*lttng_trace_chunk_allocate(void)
400 struct lttng_trace_chunk
*chunk
= NULL
;
402 chunk
= (lttng_trace_chunk
*) zmalloc(sizeof(*chunk
));
404 ERR("Failed to allocate trace chunk");
407 lttng_trace_chunk_init(chunk
);
412 struct lttng_trace_chunk
*lttng_trace_chunk_create_anonymous(void)
414 DBG("Creating anonymous trace chunk");
415 return lttng_trace_chunk_allocate();
418 struct lttng_trace_chunk
*lttng_trace_chunk_create(
419 uint64_t chunk_id
, time_t chunk_creation_time
, const char *path
)
421 struct lttng_trace_chunk
*chunk
;
422 char chunk_creation_datetime_buf
[16] = {};
423 const char *chunk_creation_datetime_str
= "(formatting error)";
424 struct tm timeinfo_buf
, *timeinfo
;
426 timeinfo
= localtime_r(&chunk_creation_time
, &timeinfo_buf
);
430 /* Don't fail because of this; it is only used for logging. */
431 strftime_ret
= strftime(chunk_creation_datetime_buf
,
432 sizeof(chunk_creation_datetime_buf
),
433 "%Y%m%d-%H%M%S", timeinfo
);
435 chunk_creation_datetime_str
=
436 chunk_creation_datetime_buf
;
440 DBG("Creating trace chunk: chunk_id = %" PRIu64
", creation time = %s",
441 chunk_id
, chunk_creation_datetime_str
);
442 chunk
= lttng_trace_chunk_allocate();
447 LTTNG_OPTIONAL_SET(&chunk
->id
, chunk_id
);
448 LTTNG_OPTIONAL_SET(&chunk
->timestamp_creation
, chunk_creation_time
);
450 chunk
->name
= generate_chunk_name(chunk_id
,
451 chunk_creation_time
, NULL
);
453 ERR("Failed to allocate trace chunk name storage");
458 chunk
->path
= strdup(path
);
464 chunk
->path
= strdup(chunk
->name
);
471 DBG("Chunk name set to \"%s\"", chunk
->name
? : "(none)");
475 lttng_trace_chunk_put(chunk
);
479 void lttng_trace_chunk_set_fd_tracker(struct lttng_trace_chunk
*chunk
,
480 struct fd_tracker
*fd_tracker
)
482 LTTNG_ASSERT(!chunk
->session_output_directory
);
483 LTTNG_ASSERT(!chunk
->chunk_directory
);
484 LTTNG_ASSERT(lttng_dynamic_pointer_array_get_count(&chunk
->files
) == 0);
485 chunk
->fd_tracker
= fd_tracker
;
488 struct lttng_trace_chunk
*lttng_trace_chunk_copy(
489 struct lttng_trace_chunk
*source_chunk
)
491 struct lttng_trace_chunk
*new_chunk
= lttng_trace_chunk_allocate();
497 pthread_mutex_lock(&source_chunk
->lock
);
499 * A new chunk is always a user; it shall create no new trace
502 new_chunk
->mode
= (typeof(new_chunk
->mode
)) {
504 .value
= TRACE_CHUNK_MODE_USER
,
507 * top_level_directories is not copied as it is never used
508 * by _user_ mode chunks.
510 /* The new chunk is not part of a registry (yet, at least). */
511 new_chunk
->in_registry_element
= false;
512 new_chunk
->name_overridden
= source_chunk
->name_overridden
;
513 if (source_chunk
->name
) {
514 new_chunk
->name
= strdup(source_chunk
->name
);
515 if (!new_chunk
->name
) {
516 ERR("Failed to copy source trace chunk name in %s()",
521 if (source_chunk
->path
) {
522 new_chunk
->path
= strdup(source_chunk
->path
);
523 if (!new_chunk
->path
) {
524 ERR("Failed to copy source trace chunk path in %s()",
528 new_chunk
->id
= source_chunk
->id
;
529 new_chunk
->timestamp_creation
= source_chunk
->timestamp_creation
;
530 new_chunk
->timestamp_close
= source_chunk
->timestamp_close
;
531 new_chunk
->credentials
= source_chunk
->credentials
;
532 if (source_chunk
->session_output_directory
) {
533 const bool reference_acquired
= lttng_directory_handle_get(
534 source_chunk
->session_output_directory
);
536 LTTNG_ASSERT(reference_acquired
);
537 new_chunk
->session_output_directory
=
538 source_chunk
->session_output_directory
;
540 if (source_chunk
->chunk_directory
) {
541 const bool reference_acquired
= lttng_directory_handle_get(
542 source_chunk
->chunk_directory
);
544 LTTNG_ASSERT(reference_acquired
);
545 new_chunk
->chunk_directory
= source_chunk
->chunk_directory
;
547 new_chunk
->close_command
= source_chunk
->close_command
;
548 new_chunk
->fd_tracker
= source_chunk
->fd_tracker
;
549 pthread_mutex_unlock(&source_chunk
->lock
);
553 pthread_mutex_unlock(&source_chunk
->lock
);
554 lttng_trace_chunk_put(new_chunk
);
558 enum lttng_trace_chunk_status
lttng_trace_chunk_get_id(
559 struct lttng_trace_chunk
*chunk
, uint64_t *id
)
561 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
563 pthread_mutex_lock(&chunk
->lock
);
564 if (chunk
->id
.is_set
) {
565 *id
= chunk
->id
.value
;
567 status
= LTTNG_TRACE_CHUNK_STATUS_NONE
;
569 pthread_mutex_unlock(&chunk
->lock
);
573 enum lttng_trace_chunk_status
lttng_trace_chunk_get_creation_timestamp(
574 struct lttng_trace_chunk
*chunk
, time_t *creation_ts
)
577 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
579 pthread_mutex_lock(&chunk
->lock
);
580 if (chunk
->timestamp_creation
.is_set
) {
581 *creation_ts
= chunk
->timestamp_creation
.value
;
583 status
= LTTNG_TRACE_CHUNK_STATUS_NONE
;
585 pthread_mutex_unlock(&chunk
->lock
);
589 enum lttng_trace_chunk_status
lttng_trace_chunk_get_close_timestamp(
590 struct lttng_trace_chunk
*chunk
, time_t *close_ts
)
592 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
594 pthread_mutex_lock(&chunk
->lock
);
595 if (chunk
->timestamp_close
.is_set
) {
596 *close_ts
= chunk
->timestamp_close
.value
;
598 status
= LTTNG_TRACE_CHUNK_STATUS_NONE
;
600 pthread_mutex_unlock(&chunk
->lock
);
604 enum lttng_trace_chunk_status
lttng_trace_chunk_set_close_timestamp(
605 struct lttng_trace_chunk
*chunk
, time_t close_ts
)
607 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
609 pthread_mutex_lock(&chunk
->lock
);
610 if (!chunk
->timestamp_creation
.is_set
) {
611 ERR("Failed to set trace chunk close timestamp: creation timestamp is unset");
612 status
= LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION
;
617 * Note: we do not enforce that the closing timestamp be greater or
618 * equal to the begin timestamp. These timestamps are used for
619 * generating the chunk name and should only be used in context where
620 * the monotonicity of time is not important. The source of those
621 * timestamps is NOT monotonic and represent the system calendar time,
622 * also know as the wall time.
624 if (chunk
->timestamp_creation
.value
> close_ts
) {
625 WARN("Set trace chunk close timestamp: close timestamp is before creation timestamp, begin : %ld, close : %ld",
626 chunk
->timestamp_creation
.value
, close_ts
);
629 LTTNG_OPTIONAL_SET(&chunk
->timestamp_close
, close_ts
);
630 if (!chunk
->name_overridden
) {
632 chunk
->name
= generate_chunk_name(LTTNG_OPTIONAL_GET(chunk
->id
),
633 LTTNG_OPTIONAL_GET(chunk
->timestamp_creation
),
636 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
640 pthread_mutex_unlock(&chunk
->lock
);
644 enum lttng_trace_chunk_status
lttng_trace_chunk_get_name(
645 struct lttng_trace_chunk
*chunk
, const char **name
,
646 bool *name_overridden
)
648 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
650 pthread_mutex_lock(&chunk
->lock
);
651 if (name_overridden
) {
652 *name_overridden
= chunk
->name_overridden
;
655 status
= LTTNG_TRACE_CHUNK_STATUS_NONE
;
660 pthread_mutex_unlock(&chunk
->lock
);
664 bool lttng_trace_chunk_get_name_overridden(struct lttng_trace_chunk
*chunk
)
666 bool name_overridden
;
668 pthread_mutex_lock(&chunk
->lock
);
669 name_overridden
= chunk
->name_overridden
;
670 pthread_mutex_unlock(&chunk
->lock
);
671 return name_overridden
;
675 bool is_valid_chunk_name(const char *name
)
683 len
= lttng_strnlen(name
, LTTNG_NAME_MAX
);
684 if (len
== 0 || len
== LTTNG_NAME_MAX
) {
688 if (strchr(name
, '/') || strchr(name
, '.')) {
695 enum lttng_trace_chunk_status
lttng_trace_chunk_override_name(
696 struct lttng_trace_chunk
*chunk
, const char *name
)
699 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
700 char *new_name
, *new_path
;
702 DBG("Override trace chunk name from %s to %s", chunk
->name
, name
);
703 if (!is_valid_chunk_name(name
)) {
704 ERR("Attempted to set an invalid name on a trace chunk: name = %s",
706 status
= LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT
;
710 pthread_mutex_lock(&chunk
->lock
);
711 if (!chunk
->id
.is_set
) {
712 ERR("Attempted to set an override name on an anonymous trace chunk: name = %s",
714 status
= LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION
;
718 new_name
= strdup(name
);
720 ERR("Failed to allocate new trace chunk name");
721 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
725 chunk
->name
= new_name
;
727 new_path
= strdup(name
);
729 ERR("Failed to allocate new trace chunk path");
730 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
734 chunk
->path
= new_path
;
736 chunk
->name_overridden
= true;
738 pthread_mutex_unlock(&chunk
->lock
);
744 enum lttng_trace_chunk_status
lttng_trace_chunk_rename_path_no_lock(
745 struct lttng_trace_chunk
*chunk
, const char *path
)
748 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
749 struct lttng_directory_handle
*rename_directory
= NULL
;
750 char *new_path
, *old_path
;
753 if (chunk
->name_overridden
) {
754 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
758 old_path
= chunk
->path
;
759 DBG("lttng_trace_chunk_rename_path from %s to %s", old_path
, path
);
761 if ((!old_path
&& !path
) ||
762 (old_path
&& path
&& !strcmp(old_path
, path
))) {
766 * Use chunk name as path if NULL path is specified.
772 /* Renaming from "" to "" is not accepted. */
773 if (path
[0] == '\0' && old_path
[0] == '\0') {
774 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
779 * If a rename is performed on a chunk for which the chunk_directory
780 * is not set (yet), or the session_output_directory is not set
781 * (interacting with a relay daemon), there is no rename to perform.
783 if (!chunk
->chunk_directory
||
784 !chunk
->session_output_directory
) {
788 if (old_path
&& old_path
[0] != '\0' && path
[0] != '\0') {
789 /* Rename chunk directory. */
790 ret
= lttng_directory_handle_rename_as_user(
791 chunk
->session_output_directory
,
793 chunk
->session_output_directory
,
795 LTTNG_OPTIONAL_GET(chunk
->credentials
).use_current_user
?
797 &chunk
->credentials
.value
.user
);
799 PERROR("Failed to move trace chunk directory \"%s\" to \"%s\"",
801 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
804 rename_directory
= chunk
->fd_tracker
?
805 fd_tracker_create_directory_handle_from_handle(
807 chunk
->session_output_directory
,
809 lttng_directory_handle_create_from_handle(
811 chunk
->session_output_directory
);
812 if (!rename_directory
) {
813 ERR("Failed to get handle to trace chunk rename directory");
814 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
818 /* Release old handle. */
819 lttng_directory_handle_put(chunk
->chunk_directory
);
821 * Transfer new handle reference to chunk as the current chunk
824 chunk
->chunk_directory
= rename_directory
;
825 rename_directory
= NULL
;
826 } else if (old_path
&& old_path
[0] == '\0') {
827 size_t i
, count
= lttng_dynamic_pointer_array_get_count(
828 &chunk
->top_level_directories
);
830 ret
= lttng_directory_handle_create_subdirectory_as_user(
831 chunk
->session_output_directory
,
834 LTTNG_OPTIONAL_GET(chunk
->credentials
).use_current_user
?
836 &chunk
->credentials
.value
.user
);
838 PERROR("Failed to create trace chunk rename directory \"%s\"",
840 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
844 rename_directory
= lttng_directory_handle_create_from_handle(
845 path
, chunk
->session_output_directory
);
846 if (!rename_directory
) {
847 ERR("Failed to get handle to trace chunk rename directory");
848 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
852 /* Move toplevel directories. */
853 for (i
= 0; i
< count
; i
++) {
854 const char *top_level_name
=
855 (const char *) lttng_dynamic_pointer_array_get_pointer(
856 &chunk
->top_level_directories
, i
);
858 ret
= lttng_directory_handle_rename_as_user(
859 chunk
->chunk_directory
,
863 LTTNG_OPTIONAL_GET(chunk
->credentials
).use_current_user
?
865 &chunk
->credentials
.value
.user
);
867 PERROR("Failed to move \"%s\" to trace chunk rename directory",
869 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
873 /* Release old handle. */
874 lttng_directory_handle_put(chunk
->chunk_directory
);
876 * Transfer new handle reference to chunk as the current chunk
879 chunk
->chunk_directory
= rename_directory
;
880 rename_directory
= NULL
;
881 } else if (old_path
) {
882 size_t i
, count
= lttng_dynamic_pointer_array_get_count(
883 &chunk
->top_level_directories
);
884 const bool reference_acquired
= lttng_directory_handle_get(
885 chunk
->session_output_directory
);
887 LTTNG_ASSERT(reference_acquired
);
888 rename_directory
= chunk
->session_output_directory
;
890 /* Move toplevel directories. */
891 for (i
= 0; i
< count
; i
++) {
892 const char *top_level_name
=
893 (const char *) lttng_dynamic_pointer_array_get_pointer(
894 &chunk
->top_level_directories
, i
);
896 ret
= lttng_directory_handle_rename_as_user(
897 chunk
->chunk_directory
,
901 LTTNG_OPTIONAL_GET(chunk
->credentials
).use_current_user
?
903 &chunk
->credentials
.value
.user
);
905 PERROR("Failed to move \"%s\" to trace chunk rename directory",
907 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
911 /* Release old handle. */
912 lttng_directory_handle_put(chunk
->chunk_directory
);
914 * Transfer new handle reference to chunk as the current chunk
917 chunk
->chunk_directory
= rename_directory
;
918 rename_directory
= NULL
;
920 /* Remove old directory. */
921 status
= (lttng_trace_chunk_status
) lttng_directory_handle_remove_subdirectory(
922 chunk
->session_output_directory
,
924 if (status
!= LTTNG_TRACE_CHUNK_STATUS_OK
) {
925 ERR("Error removing subdirectory '%s' file when deleting chunk",
930 /* Unexpected !old_path && !path. */
931 status
= LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT
;
936 new_path
= strdup(path
);
938 ERR("Failed to allocate new trace chunk path");
939 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
943 chunk
->path
= new_path
;
945 lttng_directory_handle_put(rename_directory
);
949 enum lttng_trace_chunk_status
lttng_trace_chunk_rename_path(
950 struct lttng_trace_chunk
*chunk
, const char *path
)
953 enum lttng_trace_chunk_status status
;
955 pthread_mutex_lock(&chunk
->lock
);
956 status
= lttng_trace_chunk_rename_path_no_lock(chunk
, path
);
957 pthread_mutex_unlock(&chunk
->lock
);
962 enum lttng_trace_chunk_status
lttng_trace_chunk_get_credentials(
963 struct lttng_trace_chunk
*chunk
,
964 struct lttng_credentials
*credentials
)
966 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
968 pthread_mutex_lock(&chunk
->lock
);
969 if (chunk
->credentials
.is_set
) {
970 if (chunk
->credentials
.value
.use_current_user
) {
971 LTTNG_OPTIONAL_SET(&credentials
->uid
, geteuid());
972 LTTNG_OPTIONAL_SET(&credentials
->gid
, getegid());
974 *credentials
= chunk
->credentials
.value
.user
;
977 status
= LTTNG_TRACE_CHUNK_STATUS_NONE
;
979 pthread_mutex_unlock(&chunk
->lock
);
983 enum lttng_trace_chunk_status
lttng_trace_chunk_set_credentials(
984 struct lttng_trace_chunk
*chunk
,
985 const struct lttng_credentials
*user_credentials
)
987 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
988 const struct chunk_credentials credentials
= {
989 .use_current_user
= false,
990 .user
= *user_credentials
,
993 pthread_mutex_lock(&chunk
->lock
);
994 if (chunk
->credentials
.is_set
) {
995 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
998 LTTNG_OPTIONAL_SET(&chunk
->credentials
, credentials
);
1000 pthread_mutex_unlock(&chunk
->lock
);
1004 enum lttng_trace_chunk_status
lttng_trace_chunk_set_credentials_current_user(
1005 struct lttng_trace_chunk
*chunk
)
1007 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
1008 const struct chunk_credentials credentials
= {
1009 .use_current_user
= true,
1012 pthread_mutex_lock(&chunk
->lock
);
1013 if (chunk
->credentials
.is_set
) {
1014 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1017 LTTNG_OPTIONAL_SET(&chunk
->credentials
, credentials
);
1019 pthread_mutex_unlock(&chunk
->lock
);
1024 enum lttng_trace_chunk_status
lttng_trace_chunk_set_as_owner(
1025 struct lttng_trace_chunk
*chunk
,
1026 struct lttng_directory_handle
*session_output_directory
)
1029 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
1030 struct lttng_directory_handle
*chunk_directory_handle
= NULL
;
1031 bool reference_acquired
;
1033 pthread_mutex_lock(&chunk
->lock
);
1034 if (chunk
->mode
.is_set
) {
1035 status
= LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION
;
1038 if (!chunk
->credentials
.is_set
) {
1040 * Fatal error, credentials must be set before a
1041 * directory is created.
1043 ERR("Credentials of trace chunk are unset: refusing to set session output directory");
1044 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1047 if (chunk
->path
&& chunk
->path
[0] != '\0') {
1048 ret
= lttng_directory_handle_create_subdirectory_as_user(
1049 session_output_directory
,
1052 !chunk
->credentials
.value
.use_current_user
?
1053 &chunk
->credentials
.value
.user
: NULL
);
1055 PERROR("Failed to create chunk output directory \"%s\"",
1057 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1060 chunk_directory_handle
=
1062 fd_tracker_create_directory_handle_from_handle(
1064 session_output_directory
,
1066 lttng_directory_handle_create_from_handle(
1068 session_output_directory
);
1069 if (!chunk_directory_handle
) {
1070 /* The function already logs on all error paths. */
1071 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1076 * A nameless chunk does not need its own output directory.
1077 * The session's output directory will be used.
1079 reference_acquired
= lttng_directory_handle_get(
1080 session_output_directory
);
1082 LTTNG_ASSERT(reference_acquired
);
1083 chunk_directory_handle
= session_output_directory
;
1085 chunk
->chunk_directory
= chunk_directory_handle
;
1086 chunk_directory_handle
= NULL
;
1087 reference_acquired
= lttng_directory_handle_get(
1088 session_output_directory
);
1089 LTTNG_ASSERT(reference_acquired
);
1090 chunk
->session_output_directory
= session_output_directory
;
1091 LTTNG_OPTIONAL_SET(&chunk
->mode
, TRACE_CHUNK_MODE_OWNER
);
1093 pthread_mutex_unlock(&chunk
->lock
);
1097 enum lttng_trace_chunk_status
lttng_trace_chunk_set_as_user(
1098 struct lttng_trace_chunk
*chunk
,
1099 struct lttng_directory_handle
*chunk_directory
)
1101 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
1102 bool reference_acquired
;
1104 pthread_mutex_lock(&chunk
->lock
);
1105 if (chunk
->mode
.is_set
) {
1106 status
= LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION
;
1109 if (!chunk
->credentials
.is_set
) {
1110 ERR("Credentials of trace chunk are unset: refusing to set chunk output directory");
1111 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1114 reference_acquired
= lttng_directory_handle_get(chunk_directory
);
1115 LTTNG_ASSERT(reference_acquired
);
1116 chunk
->chunk_directory
= chunk_directory
;
1117 LTTNG_OPTIONAL_SET(&chunk
->mode
, TRACE_CHUNK_MODE_USER
);
1119 pthread_mutex_unlock(&chunk
->lock
);
1123 enum lttng_trace_chunk_status
1124 lttng_trace_chunk_get_session_output_directory_handle(
1125 struct lttng_trace_chunk
*chunk
,
1126 struct lttng_directory_handle
**handle
)
1128 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
1130 pthread_mutex_lock(&chunk
->lock
);
1131 if (!chunk
->session_output_directory
) {
1132 status
= LTTNG_TRACE_CHUNK_STATUS_NONE
;
1136 const bool reference_acquired
= lttng_directory_handle_get(
1137 chunk
->session_output_directory
);
1139 LTTNG_ASSERT(reference_acquired
);
1140 *handle
= chunk
->session_output_directory
;
1143 pthread_mutex_unlock(&chunk
->lock
);
1147 enum lttng_trace_chunk_status
lttng_trace_chunk_borrow_chunk_directory_handle(
1148 struct lttng_trace_chunk
*chunk
,
1149 const struct lttng_directory_handle
**handle
)
1151 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
1153 pthread_mutex_lock(&chunk
->lock
);
1154 if (!chunk
->chunk_directory
) {
1155 status
= LTTNG_TRACE_CHUNK_STATUS_NONE
;
1159 *handle
= chunk
->chunk_directory
;
1161 pthread_mutex_unlock(&chunk
->lock
);
1165 /* Add a top-level directory to the trace chunk if it was previously unknown. */
1167 int add_top_level_directory_unique(struct lttng_trace_chunk
*chunk
,
1168 const char *new_path
)
1172 size_t i
, count
= lttng_dynamic_pointer_array_get_count(
1173 &chunk
->top_level_directories
);
1174 const char *new_path_separator_pos
= strchr(new_path
, '/');
1175 const ptrdiff_t new_path_top_level_len
= new_path_separator_pos
?
1176 new_path_separator_pos
- new_path
: strlen(new_path
);
1178 for (i
= 0; i
< count
; i
++) {
1179 const char *path
= (const char *) lttng_dynamic_pointer_array_get_pointer(
1180 &chunk
->top_level_directories
, i
);
1181 const ptrdiff_t path_top_level_len
= strlen(path
);
1183 if (path_top_level_len
!= new_path_top_level_len
) {
1186 if (!strncmp(path
, new_path
, path_top_level_len
)) {
1193 char *copy
= lttng_strndup(new_path
, new_path_top_level_len
);
1195 DBG("Adding new top-level directory \"%s\" to trace chunk \"%s\"",
1196 new_path
, chunk
->name
? : "(unnamed)");
1198 PERROR("Failed to copy path");
1202 ret
= lttng_dynamic_pointer_array_add_pointer(
1203 &chunk
->top_level_directories
, copy
);
1205 ERR("Allocation failure while adding top-level directory entry to a trace chunk");
1214 enum lttng_trace_chunk_status
lttng_trace_chunk_create_subdirectory(
1215 struct lttng_trace_chunk
*chunk
,
1219 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
1221 DBG("Creating trace chunk subdirectory \"%s\"", path
);
1222 pthread_mutex_lock(&chunk
->lock
);
1223 if (!chunk
->credentials
.is_set
) {
1225 * Fatal error, credentials must be set before a
1226 * directory is created.
1228 ERR("Credentials of trace chunk are unset: refusing to create subdirectory \"%s\"",
1230 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1233 if (!chunk
->mode
.is_set
||
1234 chunk
->mode
.value
!= TRACE_CHUNK_MODE_OWNER
) {
1235 ERR("Attempted to create trace chunk subdirectory \"%s\" through a non-owner chunk",
1237 status
= LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION
;
1240 if (!chunk
->chunk_directory
) {
1241 ERR("Attempted to create trace chunk subdirectory \"%s\" before setting the chunk output directory",
1243 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1247 ERR("Refusing to create absolute trace chunk directory \"%s\"",
1249 status
= LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT
;
1252 ret
= lttng_directory_handle_create_subdirectory_recursive_as_user(
1253 chunk
->chunk_directory
, path
,
1255 chunk
->credentials
.value
.use_current_user
?
1256 NULL
: &chunk
->credentials
.value
.user
);
1258 PERROR("Failed to create trace chunk subdirectory \"%s\"",
1260 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1263 ret
= add_top_level_directory_unique(chunk
, path
);
1265 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1269 pthread_mutex_unlock(&chunk
->lock
);
1274 * TODO: Implement O(1) lookup.
1277 bool lttng_trace_chunk_find_file(struct lttng_trace_chunk
*chunk
,
1278 const char *path
, size_t *index
)
1282 count
= lttng_dynamic_pointer_array_get_count(&chunk
->files
);
1283 for (i
= 0; i
< count
; i
++) {
1284 const char *iter_path
=
1285 (const char *) lttng_dynamic_pointer_array_get_pointer(
1287 if (!strcmp(iter_path
, path
)) {
1298 enum lttng_trace_chunk_status
lttng_trace_chunk_add_file(
1299 struct lttng_trace_chunk
*chunk
,
1304 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
1306 if (lttng_trace_chunk_find_file(chunk
, path
, NULL
)) {
1307 return LTTNG_TRACE_CHUNK_STATUS_OK
;
1309 DBG("Adding new file \"%s\" to trace chunk \"%s\"",
1310 path
, chunk
->name
? : "(unnamed)");
1311 copy
= strdup(path
);
1313 PERROR("Failed to copy path");
1314 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1317 ret
= lttng_dynamic_pointer_array_add_pointer(
1318 &chunk
->files
, copy
);
1320 ERR("Allocation failure while adding file to a trace chunk");
1322 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1330 void lttng_trace_chunk_remove_file(
1331 struct lttng_trace_chunk
*chunk
,
1338 found
= lttng_trace_chunk_find_file(chunk
, path
, &index
);
1342 ret
= lttng_dynamic_pointer_array_remove_pointer(
1343 &chunk
->files
, index
);
1348 enum lttng_trace_chunk_status
_lttng_trace_chunk_open_fs_handle_locked(
1349 struct lttng_trace_chunk
*chunk
,
1350 const char *file_path
,
1353 struct fs_handle
**out_handle
,
1354 bool expect_no_file
)
1357 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
1359 DBG("Opening trace chunk file \"%s\"", file_path
);
1360 if (!chunk
->credentials
.is_set
) {
1362 * Fatal error, credentials must be set before a
1365 ERR("Credentials of trace chunk are unset: refusing to open file \"%s\"",
1367 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1370 if (!chunk
->chunk_directory
) {
1371 ERR("Attempted to open trace chunk file \"%s\" before setting the chunk output directory",
1373 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1376 status
= lttng_trace_chunk_add_file(chunk
, file_path
);
1377 if (status
!= LTTNG_TRACE_CHUNK_STATUS_OK
) {
1380 if (chunk
->fd_tracker
) {
1381 LTTNG_ASSERT(chunk
->credentials
.value
.use_current_user
);
1382 *out_handle
= fd_tracker_open_fs_handle(chunk
->fd_tracker
,
1383 chunk
->chunk_directory
, file_path
, flags
, &mode
);
1384 ret
= *out_handle
? 0 : -1;
1386 ret
= lttng_directory_handle_open_file_as_user(
1387 chunk
->chunk_directory
, file_path
, flags
, mode
,
1388 chunk
->credentials
.value
.use_current_user
?
1390 &chunk
->credentials
.value
.user
);
1392 *out_handle
= fs_handle_untracked_create(
1393 chunk
->chunk_directory
, file_path
, ret
);
1395 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1401 if (errno
== ENOENT
&& expect_no_file
) {
1402 status
= LTTNG_TRACE_CHUNK_STATUS_NO_FILE
;
1404 PERROR("Failed to open file relative to trace chunk file_path = \"%s\", flags = %d, mode = %d",
1405 file_path
, flags
, (int) mode
);
1406 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1408 lttng_trace_chunk_remove_file(chunk
, file_path
);
1415 enum lttng_trace_chunk_status
lttng_trace_chunk_open_fs_handle(
1416 struct lttng_trace_chunk
*chunk
,
1417 const char *file_path
,
1420 struct fs_handle
**out_handle
,
1421 bool expect_no_file
)
1423 enum lttng_trace_chunk_status status
;
1425 pthread_mutex_lock(&chunk
->lock
);
1426 status
= _lttng_trace_chunk_open_fs_handle_locked(chunk
, file_path
,
1427 flags
, mode
, out_handle
, expect_no_file
);
1428 pthread_mutex_unlock(&chunk
->lock
);
1432 enum lttng_trace_chunk_status
lttng_trace_chunk_open_file(
1433 struct lttng_trace_chunk
*chunk
,
1434 const char *file_path
,
1438 bool expect_no_file
)
1440 enum lttng_trace_chunk_status status
;
1441 struct fs_handle
*fs_handle
;
1443 pthread_mutex_lock(&chunk
->lock
);
1445 * Using this method is never valid when an fd_tracker is being
1446 * used since the resulting file descriptor would not be tracked.
1448 LTTNG_ASSERT(!chunk
->fd_tracker
);
1449 status
= _lttng_trace_chunk_open_fs_handle_locked(chunk
, file_path
,
1450 flags
, mode
, &fs_handle
, expect_no_file
);
1451 pthread_mutex_unlock(&chunk
->lock
);
1453 if (status
== LTTNG_TRACE_CHUNK_STATUS_OK
) {
1454 *out_fd
= fs_handle_get_fd(fs_handle
);
1456 * Does not close the fd; we just "unbox" it from the fs_handle.
1458 fs_handle_untracked_destroy(container_of(
1459 fs_handle
, struct fs_handle_untracked
, parent
));
1465 int lttng_trace_chunk_unlink_file(struct lttng_trace_chunk
*chunk
,
1466 const char *file_path
)
1469 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
1471 DBG("Unlinking trace chunk file \"%s\"", file_path
);
1472 pthread_mutex_lock(&chunk
->lock
);
1473 if (!chunk
->credentials
.is_set
) {
1475 * Fatal error, credentials must be set before a
1478 ERR("Credentials of trace chunk are unset: refusing to unlink file \"%s\"",
1480 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1483 if (!chunk
->chunk_directory
) {
1484 ERR("Attempted to unlink trace chunk file \"%s\" before setting the chunk output directory",
1486 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1489 ret
= lttng_directory_handle_unlink_file_as_user(
1490 chunk
->chunk_directory
, file_path
,
1491 chunk
->credentials
.value
.use_current_user
?
1492 NULL
: &chunk
->credentials
.value
.user
);
1494 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1497 lttng_trace_chunk_remove_file(chunk
, file_path
);
1499 pthread_mutex_unlock(&chunk
->lock
);
1504 int lttng_trace_chunk_remove_subdirectory_recursive(struct lttng_trace_chunk
*chunk
,
1508 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
1510 DBG("Recursively removing trace chunk directory \"%s\"", path
);
1511 pthread_mutex_lock(&chunk
->lock
);
1512 if (!chunk
->credentials
.is_set
) {
1514 * Fatal error, credentials must be set before a
1515 * directory is removed.
1517 ERR("Credentials of trace chunk are unset: refusing to recursively remove directory \"%s\"",
1519 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1522 if (!chunk
->chunk_directory
) {
1523 ERR("Attempted to recursively remove trace chunk directory \"%s\" before setting the chunk output directory",
1525 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1528 ret
= lttng_directory_handle_remove_subdirectory_recursive_as_user(
1529 chunk
->chunk_directory
, path
,
1530 chunk
->credentials
.value
.use_current_user
?
1531 NULL
: &chunk
->credentials
.value
.user
,
1532 LTTNG_DIRECTORY_HANDLE_SKIP_NON_EMPTY_FLAG
);
1534 status
= LTTNG_TRACE_CHUNK_STATUS_ERROR
;
1538 pthread_mutex_unlock(&chunk
->lock
);
1543 int lttng_trace_chunk_move_to_completed_post_release(
1544 struct lttng_trace_chunk
*trace_chunk
)
1547 char *archived_chunk_name
= NULL
;
1548 const uint64_t chunk_id
= LTTNG_OPTIONAL_GET(trace_chunk
->id
);
1549 const time_t creation_timestamp
=
1550 LTTNG_OPTIONAL_GET(trace_chunk
->timestamp_creation
);
1551 const time_t close_timestamp
=
1552 LTTNG_OPTIONAL_GET(trace_chunk
->timestamp_close
);
1553 struct lttng_directory_handle
*archived_chunks_directory
= NULL
;
1554 enum lttng_trace_chunk_status status
;
1556 if (!trace_chunk
->mode
.is_set
||
1557 trace_chunk
->mode
.value
!= TRACE_CHUNK_MODE_OWNER
||
1558 !trace_chunk
->session_output_directory
) {
1560 * This command doesn't need to run if the output is remote
1561 * or if the trace chunk is not owned by this process.
1566 LTTNG_ASSERT(trace_chunk
->mode
.value
== TRACE_CHUNK_MODE_OWNER
);
1567 LTTNG_ASSERT(!trace_chunk
->name_overridden
);
1568 LTTNG_ASSERT(trace_chunk
->path
);
1570 archived_chunk_name
= generate_chunk_name(chunk_id
, creation_timestamp
,
1572 if (!archived_chunk_name
) {
1573 ERR("Failed to generate archived trace chunk name while renaming trace chunk");
1578 ret
= lttng_directory_handle_create_subdirectory_as_user(
1579 trace_chunk
->session_output_directory
,
1580 DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY
,
1582 !trace_chunk
->credentials
.value
.use_current_user
?
1583 &trace_chunk
->credentials
.value
.user
:
1586 PERROR("Failed to create \"" DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY
1587 "\" directory for archived trace chunks");
1591 archived_chunks_directory
= trace_chunk
->fd_tracker
?
1592 fd_tracker_create_directory_handle_from_handle(
1593 trace_chunk
->fd_tracker
,
1594 trace_chunk
->session_output_directory
,
1595 DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY
) :
1596 lttng_directory_handle_create_from_handle(
1597 DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY
,
1598 trace_chunk
->session_output_directory
);
1599 if (!archived_chunks_directory
) {
1600 PERROR("Failed to get handle to archived trace chunks directory");
1606 * Make sure chunk is renamed to old directory if not already done by
1607 * the creation of the next chunk. This happens if a rotation is
1608 * performed while tracing is stopped.
1610 if (!trace_chunk
->path
|| strcmp(trace_chunk
->path
,
1611 DEFAULT_CHUNK_TMP_OLD_DIRECTORY
)) {
1612 status
= lttng_trace_chunk_rename_path_no_lock(trace_chunk
,
1613 DEFAULT_CHUNK_TMP_OLD_DIRECTORY
);
1614 if (status
!= LTTNG_TRACE_CHUNK_STATUS_OK
) {
1615 ERR("Failed to rename chunk to %s", DEFAULT_CHUNK_TMP_OLD_DIRECTORY
);
1621 ret
= lttng_directory_handle_rename_as_user(
1622 trace_chunk
->session_output_directory
,
1624 archived_chunks_directory
,
1625 archived_chunk_name
,
1626 LTTNG_OPTIONAL_GET(trace_chunk
->credentials
).use_current_user
?
1628 &trace_chunk
->credentials
.value
.user
);
1630 PERROR("Failed to rename folder \"%s\" to \"%s\"",
1632 archived_chunk_name
);
1636 lttng_directory_handle_put(archived_chunks_directory
);
1637 free(archived_chunk_name
);
1642 int lttng_trace_chunk_no_operation(struct lttng_trace_chunk
*trace_chunk
)
1648 int lttng_trace_chunk_delete_post_release_user(
1649 struct lttng_trace_chunk
*trace_chunk
)
1653 DBG("Trace chunk \"delete\" close command post-release (User)");
1655 /* Unlink all files. */
1656 while (lttng_dynamic_pointer_array_get_count(&trace_chunk
->files
) != 0) {
1657 enum lttng_trace_chunk_status status
;
1661 path
= (const char *) lttng_dynamic_pointer_array_get_pointer(
1662 &trace_chunk
->files
, 0);
1663 DBG("Unlink file: %s", path
);
1664 status
= (lttng_trace_chunk_status
) lttng_trace_chunk_unlink_file(trace_chunk
, path
);
1665 if (status
!= LTTNG_TRACE_CHUNK_STATUS_OK
) {
1666 ERR("Error unlinking file '%s' when deleting chunk", path
);
1676 int lttng_trace_chunk_delete_post_release_owner(
1677 struct lttng_trace_chunk
*trace_chunk
)
1679 enum lttng_trace_chunk_status status
;
1683 ret
= lttng_trace_chunk_delete_post_release_user(trace_chunk
);
1688 DBG("Trace chunk \"delete\" close command post-release (Owner)");
1690 LTTNG_ASSERT(trace_chunk
->session_output_directory
);
1691 LTTNG_ASSERT(trace_chunk
->chunk_directory
);
1693 /* Remove empty directories. */
1694 count
= lttng_dynamic_pointer_array_get_count(
1695 &trace_chunk
->top_level_directories
);
1697 for (i
= 0; i
< count
; i
++) {
1698 const char *top_level_name
=
1699 (const char *) lttng_dynamic_pointer_array_get_pointer(
1700 &trace_chunk
->top_level_directories
, i
);
1702 status
= (lttng_trace_chunk_status
) lttng_trace_chunk_remove_subdirectory_recursive(trace_chunk
, top_level_name
);
1703 if (status
!= LTTNG_TRACE_CHUNK_STATUS_OK
) {
1704 ERR("Error recursively removing subdirectory '%s' file when deleting chunk",
1711 lttng_directory_handle_put(trace_chunk
->chunk_directory
);
1712 trace_chunk
->chunk_directory
= NULL
;
1714 if (trace_chunk
->path
&& trace_chunk
->path
[0] != '\0') {
1715 status
= (lttng_trace_chunk_status
) lttng_directory_handle_remove_subdirectory(
1716 trace_chunk
->session_output_directory
,
1718 if (status
!= LTTNG_TRACE_CHUNK_STATUS_OK
) {
1719 ERR("Error removing subdirectory '%s' file when deleting chunk",
1725 free(trace_chunk
->path
);
1726 trace_chunk
->path
= NULL
;
1732 * For local files, session and consumer daemons all run the delete hook. The
1733 * consumer daemons have the list of files to unlink, and technically the
1734 * session daemon is the owner of the chunk. Unlink all files owned by each
1738 int lttng_trace_chunk_delete_post_release(
1739 struct lttng_trace_chunk
*trace_chunk
)
1741 if (!trace_chunk
->chunk_directory
) {
1745 if (trace_chunk
->mode
.value
== TRACE_CHUNK_MODE_OWNER
) {
1746 return lttng_trace_chunk_delete_post_release_owner(trace_chunk
);
1748 return lttng_trace_chunk_delete_post_release_user(trace_chunk
);
1752 enum lttng_trace_chunk_status
lttng_trace_chunk_get_close_command(
1753 struct lttng_trace_chunk
*chunk
,
1754 enum lttng_trace_chunk_command_type
*command_type
)
1756 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
1758 pthread_mutex_lock(&chunk
->lock
);
1759 if (chunk
->close_command
.is_set
) {
1760 *command_type
= chunk
->close_command
.value
;
1761 status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
1763 status
= LTTNG_TRACE_CHUNK_STATUS_NONE
;
1765 pthread_mutex_unlock(&chunk
->lock
);
1769 enum lttng_trace_chunk_status
lttng_trace_chunk_set_close_command(
1770 struct lttng_trace_chunk
*chunk
,
1771 enum lttng_trace_chunk_command_type close_command
)
1773 enum lttng_trace_chunk_status status
= LTTNG_TRACE_CHUNK_STATUS_OK
;
1775 if (close_command
< LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED
||
1776 close_command
>= LTTNG_TRACE_CHUNK_COMMAND_TYPE_MAX
) {
1777 status
= LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT
;
1781 pthread_mutex_lock(&chunk
->lock
);
1782 if (chunk
->close_command
.is_set
) {
1783 DBG("Overriding trace chunk close command from \"%s\" to \"%s\"",
1784 lttng_trace_chunk_command_type_str(chunk
->close_command
.value
),
1785 lttng_trace_chunk_command_type_str(close_command
));
1787 DBG("Setting trace chunk close command to \"%s\"",
1788 lttng_trace_chunk_command_type_str(close_command
));
1791 * Unset close command for no-op for backward compatibility with relayd
1794 if (close_command
!= LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION
) {
1795 LTTNG_OPTIONAL_SET(&chunk
->close_command
, close_command
);
1797 LTTNG_OPTIONAL_UNSET(&chunk
->close_command
);
1799 pthread_mutex_unlock(&chunk
->lock
);
1804 const char *lttng_trace_chunk_command_type_get_name(
1805 enum lttng_trace_chunk_command_type command
)
1808 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED
:
1809 return "move to completed trace chunk folder";
1810 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION
:
1811 return "no operation";
1812 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_DELETE
:
1819 bool lttng_trace_chunk_ids_equal(const struct lttng_trace_chunk
*chunk_a
,
1820 const struct lttng_trace_chunk
*chunk_b
)
1824 if (chunk_a
== chunk_b
) {
1829 if (!!chunk_a
^ !!chunk_b
) {
1833 if (chunk_a
->id
.is_set
^ chunk_a
->id
.is_set
) {
1834 /* One id is set and not the other, thus they are not equal. */
1838 if (!chunk_a
->id
.is_set
) {
1839 /* Both ids are unset. */
1842 equal
= chunk_a
->id
.value
== chunk_b
->id
.value
;
1849 bool lttng_trace_chunk_get(struct lttng_trace_chunk
*chunk
)
1851 return urcu_ref_get_unless_zero(&chunk
->ref
);
1855 void free_lttng_trace_chunk_registry_element(struct rcu_head
*node
)
1857 struct lttng_trace_chunk_registry_element
*element
=
1858 container_of(node
, typeof(*element
), rcu_node
);
1860 lttng_trace_chunk_fini(&element
->chunk
);
1865 void lttng_trace_chunk_release(struct urcu_ref
*ref
)
1867 struct lttng_trace_chunk
*chunk
= container_of(ref
, typeof(*chunk
),
1870 if (chunk
->close_command
.is_set
) {
1871 chunk_command func
= close_command_get_post_release_func(chunk
->close_command
.value
);
1874 ERR("Trace chunk post-release command %s has failed.",
1875 lttng_trace_chunk_command_type_str(chunk
->close_command
.value
));
1879 if (chunk
->in_registry_element
) {
1880 struct lttng_trace_chunk_registry_element
*element
;
1882 element
= container_of(chunk
, typeof(*element
), chunk
);
1883 if (element
->registry
) {
1885 cds_lfht_del(element
->registry
->ht
,
1886 &element
->trace_chunk_registry_ht_node
);
1888 call_rcu(&element
->rcu_node
,
1889 free_lttng_trace_chunk_registry_element
);
1891 /* Never published, can be free'd immediately. */
1892 free_lttng_trace_chunk_registry_element(
1893 &element
->rcu_node
);
1896 /* Not RCU-protected, free immediately. */
1897 lttng_trace_chunk_fini(chunk
);
1902 void lttng_trace_chunk_put(struct lttng_trace_chunk
*chunk
)
1907 LTTNG_ASSERT(chunk
->ref
.refcount
);
1908 urcu_ref_put(&chunk
->ref
, lttng_trace_chunk_release
);
1911 struct lttng_trace_chunk_registry
*lttng_trace_chunk_registry_create(void)
1913 struct lttng_trace_chunk_registry
*registry
;
1915 registry
= (lttng_trace_chunk_registry
*) zmalloc(sizeof(*registry
));
1920 registry
->ht
= cds_lfht_new(DEFAULT_HT_SIZE
, 1, 0,
1921 CDS_LFHT_AUTO_RESIZE
| CDS_LFHT_ACCOUNTING
, NULL
);
1922 if (!registry
->ht
) {
1928 lttng_trace_chunk_registry_destroy(registry
);
1932 void lttng_trace_chunk_registry_destroy(
1933 struct lttng_trace_chunk_registry
*registry
)
1939 int ret
= cds_lfht_destroy(registry
->ht
, NULL
);
1946 struct lttng_trace_chunk_registry_element
*
1947 lttng_trace_chunk_registry_element_create_from_chunk(
1948 struct lttng_trace_chunk
*chunk
, uint64_t session_id
)
1950 struct lttng_trace_chunk_registry_element
*element
=
1951 (lttng_trace_chunk_registry_element
*) zmalloc(sizeof(*element
));
1956 cds_lfht_node_init(&element
->trace_chunk_registry_ht_node
);
1957 element
->session_id
= session_id
;
1959 element
->chunk
= *chunk
;
1960 lttng_trace_chunk_init(&element
->chunk
);
1961 if (chunk
->session_output_directory
) {
1962 /* Transferred ownership. */
1963 element
->chunk
.session_output_directory
=
1964 chunk
->session_output_directory
;
1965 chunk
->session_output_directory
= NULL
;
1967 if (chunk
->chunk_directory
) {
1968 /* Transferred ownership. */
1969 element
->chunk
.chunk_directory
= chunk
->chunk_directory
;
1970 chunk
->chunk_directory
= NULL
;
1973 * The original chunk becomes invalid; the name and path attributes are
1974 * transferred to the new chunk instance.
1978 element
->chunk
.fd_tracker
= chunk
->fd_tracker
;
1979 element
->chunk
.in_registry_element
= true;
1984 struct lttng_trace_chunk
*
1985 lttng_trace_chunk_registry_publish_chunk(
1986 struct lttng_trace_chunk_registry
*registry
,
1987 uint64_t session_id
, struct lttng_trace_chunk
*chunk
)
1989 struct lttng_trace_chunk_registry_element
*element
;
1990 unsigned long element_hash
;
1992 pthread_mutex_lock(&chunk
->lock
);
1993 element
= lttng_trace_chunk_registry_element_create_from_chunk(chunk
,
1995 pthread_mutex_unlock(&chunk
->lock
);
2000 * chunk is now invalid, the only valid operation is a 'put' from the
2004 element_hash
= lttng_trace_chunk_registry_element_hash(element
);
2008 struct cds_lfht_node
*published_node
;
2009 struct lttng_trace_chunk
*published_chunk
;
2010 struct lttng_trace_chunk_registry_element
*published_element
;
2012 published_node
= cds_lfht_add_unique(registry
->ht
,
2014 lttng_trace_chunk_registry_element_match
,
2016 &element
->trace_chunk_registry_ht_node
);
2017 if (published_node
== &element
->trace_chunk_registry_ht_node
) {
2018 /* Successfully published the new element. */
2019 element
->registry
= registry
;
2020 /* Acquire a reference for the caller. */
2021 if (lttng_trace_chunk_get(&element
->chunk
)) {
2025 * Another thread concurrently unpublished the
2026 * trace chunk. This is currently unexpected.
2028 * Re-attempt to publish.
2030 ERR("Attempt to publish a trace chunk to the chunk registry raced with a trace chunk deletion");
2036 * An equivalent trace chunk was published before this trace
2037 * chunk. Attempt to acquire a reference to the one that was
2038 * already published and release the reference to the copy we
2039 * created if successful.
2041 published_element
= container_of(published_node
,
2042 typeof(*published_element
),
2043 trace_chunk_registry_ht_node
);
2044 published_chunk
= &published_element
->chunk
;
2045 if (lttng_trace_chunk_get(published_chunk
)) {
2046 lttng_trace_chunk_put(&element
->chunk
);
2047 element
= published_element
;
2051 * A reference to the previously published trace chunk could not
2052 * be acquired. Hence, retry to publish our copy of the trace
2058 return element
? &element
->chunk
: NULL
;
2062 * Note that the caller must be registered as an RCU thread.
2063 * However, it does not need to hold the RCU read lock. The RCU read lock is
2064 * acquired to perform the look-up in the registry's hash table and held until
2065 * after a reference to the "found" trace chunk is acquired.
2067 * IOW, holding a reference guarantees the existence of the object for the
2071 struct lttng_trace_chunk
*_lttng_trace_chunk_registry_find_chunk(
2072 const struct lttng_trace_chunk_registry
*registry
,
2073 uint64_t session_id
, uint64_t *chunk_id
)
2075 lttng_trace_chunk_registry_element target_element
{};
2077 target_element
.chunk
.id
.is_set
= !!chunk_id
;
2078 target_element
.chunk
.id
.value
= chunk_id
? *chunk_id
: 0;
2079 target_element
.session_id
= session_id
;
2081 const unsigned long element_hash
=
2082 lttng_trace_chunk_registry_element_hash(
2084 struct cds_lfht_node
*published_node
;
2085 struct lttng_trace_chunk_registry_element
*published_element
;
2086 struct lttng_trace_chunk
*published_chunk
= NULL
;
2087 struct cds_lfht_iter iter
;
2090 cds_lfht_lookup(registry
->ht
,
2092 lttng_trace_chunk_registry_element_match
,
2095 published_node
= cds_lfht_iter_get_node(&iter
);
2096 if (!published_node
) {
2100 published_element
= container_of(published_node
,
2101 typeof(*published_element
),
2102 trace_chunk_registry_ht_node
);
2103 if (lttng_trace_chunk_get(&published_element
->chunk
)) {
2104 published_chunk
= &published_element
->chunk
;
2108 return published_chunk
;
2111 struct lttng_trace_chunk
*
2112 lttng_trace_chunk_registry_find_chunk(
2113 const struct lttng_trace_chunk_registry
*registry
,
2114 uint64_t session_id
, uint64_t chunk_id
)
2116 return _lttng_trace_chunk_registry_find_chunk(registry
,
2117 session_id
, &chunk_id
);
2120 int lttng_trace_chunk_registry_chunk_exists(
2121 const struct lttng_trace_chunk_registry
*registry
,
2122 uint64_t session_id
, uint64_t chunk_id
, bool *chunk_exists
)
2125 lttng_trace_chunk_registry_element target_element
;
2127 target_element
.chunk
.id
.is_set
= true;
2128 target_element
.chunk
.id
.value
= chunk_id
;
2129 target_element
.session_id
= session_id
;
2131 const unsigned long element_hash
=
2132 lttng_trace_chunk_registry_element_hash(
2134 struct cds_lfht_node
*published_node
;
2135 struct cds_lfht_iter iter
;
2138 cds_lfht_lookup(registry
->ht
,
2140 lttng_trace_chunk_registry_element_match
,
2143 published_node
= cds_lfht_iter_get_node(&iter
);
2144 if (!published_node
) {
2145 *chunk_exists
= false;
2149 *chunk_exists
= !cds_lfht_is_node_deleted(published_node
);
2155 struct lttng_trace_chunk
*
2156 lttng_trace_chunk_registry_find_anonymous_chunk(
2157 const struct lttng_trace_chunk_registry
*registry
,
2158 uint64_t session_id
)
2160 return _lttng_trace_chunk_registry_find_chunk(registry
,
2164 unsigned int lttng_trace_chunk_registry_put_each_chunk(
2165 const struct lttng_trace_chunk_registry
*registry
)
2167 struct cds_lfht_iter iter
;
2168 struct lttng_trace_chunk_registry_element
*chunk_element
;
2169 unsigned int trace_chunks_left
= 0;
2171 DBG("Releasing trace chunk registry to all trace chunks");
2173 cds_lfht_for_each_entry(registry
->ht
,
2174 &iter
, chunk_element
, trace_chunk_registry_ht_node
) {
2175 const char *chunk_id_str
= "none";
2176 char chunk_id_buf
[MAX_INT_DEC_LEN(uint64_t)];
2178 pthread_mutex_lock(&chunk_element
->chunk
.lock
);
2179 if (chunk_element
->chunk
.id
.is_set
) {
2182 fmt_ret
= snprintf(chunk_id_buf
, sizeof(chunk_id_buf
),
2184 chunk_element
->chunk
.id
.value
);
2185 if (fmt_ret
< 0 || fmt_ret
>= sizeof(chunk_id_buf
)) {
2186 chunk_id_str
= "formatting error";
2188 chunk_id_str
= chunk_id_buf
;
2192 DBG("Releasing reference to trace chunk: session_id = %" PRIu64
2193 "chunk_id = %s, name = \"%s\", status = %s",
2194 chunk_element
->session_id
,
2196 chunk_element
->chunk
.name
? : "none",
2197 chunk_element
->chunk
.close_command
.is_set
?
2199 pthread_mutex_unlock(&chunk_element
->chunk
.lock
);
2200 lttng_trace_chunk_put(&chunk_element
->chunk
);
2201 trace_chunks_left
++;
2204 DBG("Released reference to %u trace chunks in %s()", trace_chunks_left
,
2207 return trace_chunks_left
;