consumer: add extra debug output
[lttng-tools.git] / src / common / trace-chunk.c
CommitLineData
2c5ff4e4
JG
1/*
2 * Copyright (C) 2019 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
3 *
4 * This library is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU Lesser General Public License, version 2.1 only,
6 * as published by the Free Software Foundation.
7 *
8 * This library is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
11 * for more details.
12 *
13 * You should have received a copy of the GNU Lesser General Public License
14 * along with this library; if not, write to the Free Software Foundation,
15 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16 */
17
18#include <lttng/constant.h>
19#include <common/string-utils/format.h>
20#include <common/trace-chunk.h>
21#include <common/trace-chunk-registry.h>
22#include <common/hashtable/utils.h>
23#include <common/hashtable/hashtable.h>
24#include <common/error.h>
25#include <common/utils.h>
26#include <common/time.h>
27#include <common/optional.h>
28#include <common/compat/directory-handle.h>
29#include <common/credentials.h>
30#include <common/defaults.h>
31#include <common/dynamic-array.h>
32
33#include <urcu/ref.h>
34#include <urcu/rculfhash.h>
35#include <sys/stat.h>
36#include <inttypes.h>
37#include <pthread.h>
38#include <stdio.h>
39
40/*
41 * Two ISO 8601-compatible timestamps, separated by a hypen, followed an
42 * index, i.e. <start-iso-8601>-<end-iso-8601>-<id-uint64_t>.
43 */
44#define GENERATED_CHUNK_NAME_LEN (2 * sizeof("YYYYmmddTHHMMSS+HHMM") + MAX_INT_DEC_LEN(uint64_t))
45#define DIR_CREATION_MODE (S_IRWXU | S_IRWXG)
46
47enum trace_chunk_mode {
48 TRACE_CHUNK_MODE_USER,
49 TRACE_CHUNK_MODE_OWNER,
50};
51
52/*
53 * Callback to invoke on release of a trace chunk. Note that there is no
54 * need to 'lock' the trace chunk during the execution of these callbacks
55 * since only one thread may access a chunk during its destruction (the last
56 * to release its reference to the chunk).
57 */
58typedef void (*chunk_close_command)(struct lttng_trace_chunk *trace_chunk);
59
60/* Move a completed trace chunk to the 'completed' trace archive folder. */
61static
62void lttng_trace_chunk_move_to_completed(struct lttng_trace_chunk *trace_chunk);
63
64struct chunk_credentials {
65 bool use_current_user;
66 struct lttng_credentials user;
67};
68
1a414e3a 69/* NOTE: Make sure to update lttng_trace_chunk_copy if you modify this. */
2c5ff4e4
JG
70struct lttng_trace_chunk {
71 pthread_mutex_t lock;
72 struct urcu_ref ref;
73 LTTNG_OPTIONAL(enum trace_chunk_mode) mode;
74 /*
75 * First-level directories created within the trace chunk.
76 * Elements are of type 'char *'.
1a414e3a
JG
77 *
78 * Only used by _owner_ mode chunks.
2c5ff4e4
JG
79 */
80 struct lttng_dynamic_pointer_array top_level_directories;
6cb32e5a
MD
81 /*
82 * All files contained within the trace chunk.
83 * Array of paths (char *).
84 */
85 struct lttng_dynamic_pointer_array files;
2c5ff4e4
JG
86 /* Is contained within an lttng_trace_chunk_registry_element? */
87 bool in_registry_element;
913a542b 88 bool name_overridden;
2c5ff4e4
JG
89 char *name;
90 /* An unset id means the chunk is anonymous. */
91 LTTNG_OPTIONAL(uint64_t) id;
92 LTTNG_OPTIONAL(time_t) timestamp_creation;
93 LTTNG_OPTIONAL(time_t) timestamp_close;
94 LTTNG_OPTIONAL(struct chunk_credentials) credentials;
cbf53d23
JG
95 struct lttng_directory_handle *session_output_directory;
96 struct lttng_directory_handle *chunk_directory;
2c5ff4e4
JG
97 LTTNG_OPTIONAL(enum lttng_trace_chunk_command_type) close_command;
98};
99
100/* A trace chunk is uniquely identified by its (session id, chunk id) tuple. */
101struct lttng_trace_chunk_registry_element {
2c5ff4e4 102 struct lttng_trace_chunk chunk;
1f2292f6 103 uint64_t session_id;
2c5ff4e4
JG
104 /* Weak and only set when added. */
105 struct lttng_trace_chunk_registry *registry;
106 struct cds_lfht_node trace_chunk_registry_ht_node;
107 /* call_rcu delayed reclaim. */
108 struct rcu_head rcu_node;
109};
110
111struct lttng_trace_chunk_registry {
112 struct cds_lfht *ht;
113};
114
606846ba
JG
115static const
116char *close_command_names[] = {
2c5ff4e4
JG
117 [LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED] =
118 "move to completed chunk folder",
343defc2
MD
119 [LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION] =
120 "no operation",
121 [LTTNG_TRACE_CHUNK_COMMAND_TYPE_DELETE] =
122 "delete",
2c5ff4e4
JG
123};
124
606846ba 125static const
2c5ff4e4
JG
126chunk_close_command close_command_funcs[] = {
127 [LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED] =
128 lttng_trace_chunk_move_to_completed,
129};
130
131static
132bool lttng_trace_chunk_registry_element_equals(
133 const struct lttng_trace_chunk_registry_element *a,
134 const struct lttng_trace_chunk_registry_element *b)
135{
136 if (a->session_id != b->session_id) {
137 goto not_equal;
138 }
139 if (a->chunk.id.is_set != b->chunk.id.is_set) {
140 goto not_equal;
141 }
142 if (a->chunk.id.is_set && a->chunk.id.value != b->chunk.id.value) {
143 goto not_equal;
144 }
145 return true;
146not_equal:
147 return false;
148}
149
150static
151int lttng_trace_chunk_registry_element_match(struct cds_lfht_node *node,
152 const void *key)
153{
154 const struct lttng_trace_chunk_registry_element *element_a, *element_b;
155
156 element_a = (const struct lttng_trace_chunk_registry_element *) key;
157 element_b = caa_container_of(node, typeof(*element_b),
158 trace_chunk_registry_ht_node);
159 return lttng_trace_chunk_registry_element_equals(element_a, element_b);
160}
161
162static
163unsigned long lttng_trace_chunk_registry_element_hash(
164 const struct lttng_trace_chunk_registry_element *element)
165{
166 unsigned long hash = hash_key_u64(&element->session_id,
167 lttng_ht_seed);
168
169 if (element->chunk.id.is_set) {
170 hash ^= hash_key_u64(&element->chunk.id.value, lttng_ht_seed);
171 }
172
173 return hash;
174}
175
176static
177char *generate_chunk_name(uint64_t chunk_id, time_t creation_timestamp,
178 const time_t *close_timestamp)
179{
180 int ret = 0;
181 char *new_name= NULL;
6e7e5048
JG
182 char start_datetime[ISO8601_STR_LEN] = {};
183 /* Add 1 for a '-' prefix. */
184 char end_datetime_suffix[ISO8601_STR_LEN + 1] = {};
2c5ff4e4
JG
185
186 ret = time_to_iso8601_str(
187 creation_timestamp,
188 start_datetime, sizeof(start_datetime));
189 if (ret) {
190 ERR("Failed to format trace chunk start date time");
191 goto error;
192 }
193 if (close_timestamp) {
194 *end_datetime_suffix = '-';
195 ret = time_to_iso8601_str(
196 *close_timestamp,
197 end_datetime_suffix + 1,
6e7e5048 198 sizeof(end_datetime_suffix) - 1);
2c5ff4e4
JG
199 if (ret) {
200 ERR("Failed to format trace chunk end date time");
201 goto error;
202 }
203 }
204 new_name = zmalloc(GENERATED_CHUNK_NAME_LEN);
205 if (!new_name) {
206 ERR("Failed to allocate buffer for automatically-generated trace chunk name");
207 goto error;
208 }
209 ret = snprintf(new_name, GENERATED_CHUNK_NAME_LEN, "%s%s-%" PRIu64,
210 start_datetime, end_datetime_suffix, chunk_id);
211 if (ret >= GENERATED_CHUNK_NAME_LEN || ret == -1) {
212 ERR("Failed to format trace chunk name");
213 goto error;
214 }
215
216 return new_name;
217error:
218 free(new_name);
219 return NULL;
220}
221
222static
223void lttng_trace_chunk_init(struct lttng_trace_chunk *chunk)
224{
225 urcu_ref_init(&chunk->ref);
226 pthread_mutex_init(&chunk->lock, NULL);
93bed9fe 227 lttng_dynamic_pointer_array_init(&chunk->top_level_directories, free);
6cb32e5a 228 lttng_dynamic_pointer_array_init(&chunk->files, free);
2c5ff4e4
JG
229}
230
231static
232void lttng_trace_chunk_fini(struct lttng_trace_chunk *chunk)
233{
cbf53d23
JG
234 if (chunk->session_output_directory) {
235 lttng_directory_handle_put(
236 chunk->session_output_directory);
237 chunk->session_output_directory = NULL;
2c5ff4e4 238 }
cbf53d23
JG
239 if (chunk->chunk_directory) {
240 lttng_directory_handle_put(chunk->chunk_directory);
241 chunk->chunk_directory = NULL;
2c5ff4e4
JG
242 }
243 free(chunk->name);
244 chunk->name = NULL;
93bed9fe 245 lttng_dynamic_pointer_array_reset(&chunk->top_level_directories);
6cb32e5a 246 lttng_dynamic_pointer_array_reset(&chunk->files);
2c5ff4e4
JG
247 pthread_mutex_destroy(&chunk->lock);
248}
249
250static
251struct lttng_trace_chunk *lttng_trace_chunk_allocate(void)
252{
253 struct lttng_trace_chunk *chunk = NULL;
254
255 chunk = zmalloc(sizeof(*chunk));
256 if (!chunk) {
257 ERR("Failed to allocate trace chunk");
258 goto end;
259 }
260 lttng_trace_chunk_init(chunk);
261end:
262 return chunk;
263}
264
265LTTNG_HIDDEN
266struct lttng_trace_chunk *lttng_trace_chunk_create_anonymous(void)
267{
268 DBG("Creating anonymous trace chunk");
269 return lttng_trace_chunk_allocate();
270}
271
272LTTNG_HIDDEN
273struct lttng_trace_chunk *lttng_trace_chunk_create(
274 uint64_t chunk_id, time_t chunk_creation_time)
275{
276 struct lttng_trace_chunk *chunk;
277 char chunk_creation_datetime_buf[16] = {};
278 const char *chunk_creation_datetime_str = "(formatting error)";
279 struct tm timeinfo_buf, *timeinfo;
280
281 timeinfo = localtime_r(&chunk_creation_time, &timeinfo_buf);
282 if (timeinfo) {
283 size_t strftime_ret;
284
285 /* Don't fail because of this; it is only used for logging. */
286 strftime_ret = strftime(chunk_creation_datetime_buf,
287 sizeof(chunk_creation_datetime_buf),
288 "%Y%m%d-%H%M%S", timeinfo);
289 if (strftime_ret) {
290 chunk_creation_datetime_str =
291 chunk_creation_datetime_buf;
292 }
293 }
294
295 DBG("Creating trace chunk: chunk_id = %" PRIu64 ", creation time = %s",
296 chunk_id, chunk_creation_datetime_str);
297 chunk = lttng_trace_chunk_allocate();
298 if (!chunk) {
299 goto end;
300 }
301
302 LTTNG_OPTIONAL_SET(&chunk->id, chunk_id);
303 LTTNG_OPTIONAL_SET(&chunk->timestamp_creation, chunk_creation_time);
304 if (chunk_id != 0) {
305 chunk->name = generate_chunk_name(chunk_id,
306 chunk_creation_time, NULL);
307 if (!chunk->name) {
308 ERR("Failed to allocate trace chunk name storage");
309 goto error;
310 }
311 }
312
313 DBG("Chunk name set to \"%s\"", chunk->name ? : "(none)");
314end:
315 return chunk;
316error:
317 lttng_trace_chunk_put(chunk);
318 return NULL;
319}
320
1a414e3a
JG
321LTTNG_HIDDEN
322struct lttng_trace_chunk *lttng_trace_chunk_copy(
323 struct lttng_trace_chunk *source_chunk)
324{
325 struct lttng_trace_chunk *new_chunk = lttng_trace_chunk_allocate();
326
327 if (!new_chunk) {
328 goto end;
329 }
330
331 pthread_mutex_lock(&source_chunk->lock);
332 /*
333 * A new chunk is always a user; it shall create no new trace
334 * subdirectories.
335 */
336 new_chunk->mode = (typeof(new_chunk->mode)) {
337 .is_set = true,
338 .value = TRACE_CHUNK_MODE_USER,
339 };
340 /*
341 * top_level_directories is not copied as it is never used
342 * by _user_ mode chunks.
343 */
344 /* The new chunk is not part of a registry (yet, at least). */
345 new_chunk->in_registry_element = false;
346 new_chunk->name_overridden = source_chunk->name_overridden;
347 if (source_chunk->name) {
348 new_chunk->name = strdup(source_chunk->name);
349 if (!new_chunk->name) {
350 ERR("Failed to copy source trace chunk name in %s()",
351 __FUNCTION__);
352 goto error_unlock;
353 }
354 }
355 new_chunk->id = source_chunk->id;
356 new_chunk->timestamp_creation = source_chunk->timestamp_creation;
357 new_chunk->timestamp_close = source_chunk->timestamp_close;
358 new_chunk->credentials = source_chunk->credentials;
cbf53d23
JG
359 if (source_chunk->session_output_directory) {
360 const bool reference_acquired = lttng_directory_handle_get(
361 source_chunk->session_output_directory);
362
363 assert(reference_acquired);
364 new_chunk->session_output_directory =
365 source_chunk->session_output_directory;
1a414e3a 366 }
cbf53d23
JG
367 if (source_chunk->chunk_directory) {
368 const bool reference_acquired = lttng_directory_handle_get(
369 source_chunk->chunk_directory);
370
371 assert(reference_acquired);
372 new_chunk->chunk_directory = source_chunk->chunk_directory;
1a414e3a
JG
373 }
374 new_chunk->close_command = source_chunk->close_command;
375 pthread_mutex_unlock(&source_chunk->lock);
376end:
377 return new_chunk;
378error_unlock:
379 pthread_mutex_unlock(&source_chunk->lock);
41d2ab71 380 lttng_trace_chunk_put(new_chunk);
1a414e3a
JG
381 return NULL;
382}
383
2c5ff4e4
JG
384LTTNG_HIDDEN
385enum lttng_trace_chunk_status lttng_trace_chunk_get_id(
386 struct lttng_trace_chunk *chunk, uint64_t *id)
387{
388 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
389
390 pthread_mutex_lock(&chunk->lock);
391 if (chunk->id.is_set) {
392 *id = chunk->id.value;
393 } else {
394 status = LTTNG_TRACE_CHUNK_STATUS_NONE;
395 }
396 pthread_mutex_unlock(&chunk->lock);
397 return status;
398}
399
400LTTNG_HIDDEN
401enum lttng_trace_chunk_status lttng_trace_chunk_get_creation_timestamp(
402 struct lttng_trace_chunk *chunk, time_t *creation_ts)
403
404{
405 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
406
407 pthread_mutex_lock(&chunk->lock);
408 if (chunk->timestamp_creation.is_set) {
409 *creation_ts = chunk->timestamp_creation.value;
410 } else {
411 status = LTTNG_TRACE_CHUNK_STATUS_NONE;
412 }
413 pthread_mutex_unlock(&chunk->lock);
414 return status;
415}
416
417LTTNG_HIDDEN
418enum lttng_trace_chunk_status lttng_trace_chunk_get_close_timestamp(
419 struct lttng_trace_chunk *chunk, time_t *close_ts)
420{
421 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
422
423 pthread_mutex_lock(&chunk->lock);
424 if (chunk->timestamp_close.is_set) {
425 *close_ts = chunk->timestamp_close.value;
426 } else {
427 status = LTTNG_TRACE_CHUNK_STATUS_NONE;
428 }
429 pthread_mutex_unlock(&chunk->lock);
430 return status;
431}
432
433LTTNG_HIDDEN
434enum lttng_trace_chunk_status lttng_trace_chunk_set_close_timestamp(
435 struct lttng_trace_chunk *chunk, time_t close_ts)
436{
437 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
438
439 pthread_mutex_lock(&chunk->lock);
440 if (!chunk->timestamp_creation.is_set) {
441 ERR("Failed to set trace chunk close timestamp: creation timestamp is unset");
442 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION;
443 goto end;
444 }
445 if (chunk->timestamp_creation.value > close_ts) {
446 ERR("Failed to set trace chunk close timestamp: close timestamp is before creation timestamp");
447 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT;
448 goto end;
449 }
450 LTTNG_OPTIONAL_SET(&chunk->timestamp_close, close_ts);
ecd1a12f
MD
451 if (!chunk->name_overridden) {
452 free(chunk->name);
453 chunk->name = generate_chunk_name(LTTNG_OPTIONAL_GET(chunk->id),
454 LTTNG_OPTIONAL_GET(chunk->timestamp_creation),
455 &close_ts);
456 if (!chunk->name) {
457 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
458 }
2c5ff4e4
JG
459 }
460end:
461 pthread_mutex_unlock(&chunk->lock);
462 return status;
463}
464
465LTTNG_HIDDEN
466enum lttng_trace_chunk_status lttng_trace_chunk_get_name(
467 struct lttng_trace_chunk *chunk, const char **name,
913a542b 468 bool *name_overridden)
2c5ff4e4
JG
469{
470 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
471
472 pthread_mutex_lock(&chunk->lock);
913a542b
MD
473 if (name_overridden) {
474 *name_overridden = chunk->name_overridden;
2c5ff4e4
JG
475 }
476 if (!chunk->name) {
477 status = LTTNG_TRACE_CHUNK_STATUS_NONE;
478 goto end;
479 }
480 *name = chunk->name;
481end:
482 pthread_mutex_unlock(&chunk->lock);
483 return status;
484}
485
0e2d816a
MD
486LTTNG_HIDDEN
487bool lttng_trace_chunk_get_name_overridden(struct lttng_trace_chunk *chunk)
488{
489 bool name_overridden;
490
491 pthread_mutex_lock(&chunk->lock);
492 name_overridden = chunk->name_overridden;
493 pthread_mutex_unlock(&chunk->lock);
494 return name_overridden;
495}
496
84fa4db5
JG
497static
498bool is_valid_chunk_name(const char *name)
499{
500 size_t len;
501
502 if (!name) {
503 return false;
504 }
505
f7399c50 506 len = lttng_strnlen(name, LTTNG_NAME_MAX);
84fa4db5
JG
507 if (len == 0 || len == LTTNG_NAME_MAX) {
508 return false;
509 }
510
511 if (strchr(name, '/') || strchr(name, '.')) {
512 return false;
513 }
514
515 return true;
516}
517
2c5ff4e4
JG
518LTTNG_HIDDEN
519enum lttng_trace_chunk_status lttng_trace_chunk_override_name(
520 struct lttng_trace_chunk *chunk, const char *name)
521
522{
523 char *new_name;
524 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
525
84fa4db5 526 if (!is_valid_chunk_name(name)) {
2c5ff4e4
JG
527 ERR("Attempted to set an invalid name on a trace chunk: name = %s",
528 name ? : "NULL");
529 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT;
530 goto end;
531 }
532
533 pthread_mutex_lock(&chunk->lock);
534 if (!chunk->id.is_set) {
535 ERR("Attempted to set an override name on an anonymous trace chunk: name = %s",
536 name);
537 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION;
538 goto end_unlock;
539 }
540 new_name = strdup(name);
541 if (!new_name) {
542 ERR("Failed to allocate new trace chunk name");
543 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
544 goto end_unlock;
545 }
546 free(chunk->name);
547 chunk->name = new_name;
913a542b 548 chunk->name_overridden = true;
2c5ff4e4
JG
549end_unlock:
550 pthread_mutex_unlock(&chunk->lock);
551end:
552 return status;
553}
554
555LTTNG_HIDDEN
556enum lttng_trace_chunk_status lttng_trace_chunk_get_credentials(
557 struct lttng_trace_chunk *chunk,
558 struct lttng_credentials *credentials)
559{
560 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
561
562 pthread_mutex_lock(&chunk->lock);
563 if (chunk->credentials.is_set) {
564 if (chunk->credentials.value.use_current_user) {
565 credentials->uid = geteuid();
566 credentials->gid = getegid();
567 } else {
568 *credentials = chunk->credentials.value.user;
569 }
570 } else {
571 status = LTTNG_TRACE_CHUNK_STATUS_NONE;
572 }
573 pthread_mutex_unlock(&chunk->lock);
574 return status;
575}
576
577LTTNG_HIDDEN
578enum lttng_trace_chunk_status lttng_trace_chunk_set_credentials(
579 struct lttng_trace_chunk *chunk,
580 const struct lttng_credentials *user_credentials)
581{
582 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
583 const struct chunk_credentials credentials = {
584 .user = *user_credentials,
585 .use_current_user = false,
586 };
587
588 pthread_mutex_lock(&chunk->lock);
589 if (chunk->credentials.is_set) {
590 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
591 goto end;
592 }
593 LTTNG_OPTIONAL_SET(&chunk->credentials, credentials);
594end:
595 pthread_mutex_unlock(&chunk->lock);
596 return status;
597}
598
599LTTNG_HIDDEN
600enum lttng_trace_chunk_status lttng_trace_chunk_set_credentials_current_user(
601 struct lttng_trace_chunk *chunk)
602{
603 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
604 const struct chunk_credentials credentials = {
605 .use_current_user = true,
606 };
607
608 pthread_mutex_lock(&chunk->lock);
609 if (chunk->credentials.is_set) {
610 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
611 goto end;
612 }
613 LTTNG_OPTIONAL_SET(&chunk->credentials, credentials);
614end:
615 pthread_mutex_unlock(&chunk->lock);
616 return status;
617}
618
619
620LTTNG_HIDDEN
621enum lttng_trace_chunk_status lttng_trace_chunk_set_as_owner(
622 struct lttng_trace_chunk *chunk,
623 struct lttng_directory_handle *session_output_directory)
624{
625 int ret;
626 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
cbf53d23
JG
627 struct lttng_directory_handle *chunk_directory_handle = NULL;
628 bool reference_acquired;
2c5ff4e4
JG
629
630 pthread_mutex_lock(&chunk->lock);
631 if (chunk->mode.is_set) {
632 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION;
633 goto end;
634 }
635 if (!chunk->credentials.is_set) {
636 /*
637 * Fatal error, credentials must be set before a
638 * directory is created.
639 */
640 ERR("Credentials of trace chunk are unset: refusing to set session output directory");
641 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
642 goto end;
643 }
644
645 if (chunk->name) {
646 /*
647 * A nameless chunk does not need its own output directory.
648 * The session's output directory will be used.
649 */
650 ret = lttng_directory_handle_create_subdirectory_as_user(
651 session_output_directory,
652 chunk->name,
653 DIR_CREATION_MODE,
654 !chunk->credentials.value.use_current_user ?
655 &chunk->credentials.value.user : NULL);
656 if (ret) {
657 PERROR("Failed to create chunk output directory \"%s\"",
658 chunk->name);
659 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
660 goto end;
661 }
662 }
cbf53d23 663 chunk_directory_handle = lttng_directory_handle_create_from_handle(
2c5ff4e4
JG
664 chunk->name,
665 session_output_directory);
cbf53d23 666 if (!chunk_directory_handle) {
2c5ff4e4
JG
667 /* The function already logs on all error paths. */
668 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
669 goto end;
670 }
cbf53d23
JG
671 chunk->chunk_directory = chunk_directory_handle;
672 chunk_directory_handle = NULL;
673 reference_acquired = lttng_directory_handle_get(
674 session_output_directory);
675 assert(reference_acquired);
676 chunk->session_output_directory = session_output_directory;
2c5ff4e4
JG
677 LTTNG_OPTIONAL_SET(&chunk->mode, TRACE_CHUNK_MODE_OWNER);
678end:
679 pthread_mutex_unlock(&chunk->lock);
680 return status;
681}
682
683LTTNG_HIDDEN
684enum lttng_trace_chunk_status lttng_trace_chunk_set_as_user(
685 struct lttng_trace_chunk *chunk,
686 struct lttng_directory_handle *chunk_directory)
687{
688 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
cbf53d23 689 bool reference_acquired;
2c5ff4e4
JG
690
691 pthread_mutex_lock(&chunk->lock);
692 if (chunk->mode.is_set) {
693 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION;
694 goto end;
695 }
696 if (!chunk->credentials.is_set) {
697 ERR("Credentials of trace chunk are unset: refusing to set chunk output directory");
698 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
699 goto end;
700 }
cbf53d23
JG
701 reference_acquired = lttng_directory_handle_get(chunk_directory);
702 assert(reference_acquired);
703 chunk->chunk_directory = chunk_directory;
2c5ff4e4
JG
704 LTTNG_OPTIONAL_SET(&chunk->mode, TRACE_CHUNK_MODE_USER);
705end:
706 pthread_mutex_unlock(&chunk->lock);
707 return status;
708}
709
710LTTNG_HIDDEN
cbf53d23 711enum lttng_trace_chunk_status lttng_trace_chunk_borrow_chunk_directory_handle(
2c5ff4e4
JG
712 struct lttng_trace_chunk *chunk,
713 const struct lttng_directory_handle **handle)
714{
715 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
716
717 pthread_mutex_lock(&chunk->lock);
cbf53d23 718 if (!chunk->chunk_directory) {
2c5ff4e4
JG
719 status = LTTNG_TRACE_CHUNK_STATUS_NONE;
720 goto end;
721 }
722
cbf53d23 723 *handle = chunk->chunk_directory;
2c5ff4e4
JG
724end:
725 pthread_mutex_unlock(&chunk->lock);
726 return status;
727}
728
729/* Add a top-level directory to the trace chunk if it was previously unknown. */
730static
731int add_top_level_directory_unique(struct lttng_trace_chunk *chunk,
732 const char *new_path)
733{
734 int ret = 0;
735 bool found = false;
736 size_t i, count = lttng_dynamic_pointer_array_get_count(
737 &chunk->top_level_directories);
738 const char *new_path_separator_pos = strchr(new_path, '/');
739 const ptrdiff_t new_path_top_level_len = new_path_separator_pos ?
740 new_path_separator_pos - new_path : strlen(new_path);
741
742 for (i = 0; i < count; i++) {
743 const char *path = lttng_dynamic_pointer_array_get_pointer(
744 &chunk->top_level_directories, i);
745 const ptrdiff_t path_top_level_len = strlen(path);
746
747 if (path_top_level_len != new_path_top_level_len) {
748 continue;
749 }
750 if (!strncmp(path, new_path, path_top_level_len)) {
751 found = true;
752 break;
753 }
754 }
755
756 if (!found) {
c36a763b 757 char *copy = lttng_strndup(new_path, new_path_top_level_len);
2c5ff4e4
JG
758
759 DBG("Adding new top-level directory \"%s\" to trace chunk \"%s\"",
760 new_path, chunk->name ? : "(unnamed)");
761 if (!copy) {
762 PERROR("Failed to copy path");
763 ret = -1;
764 goto end;
765 }
766 ret = lttng_dynamic_pointer_array_add_pointer(
767 &chunk->top_level_directories, copy);
768 if (ret) {
769 ERR("Allocation failure while adding top-level directory entry to a trace chunk");
770 free(copy);
771 goto end;
772 }
773 }
774end:
775 return ret;
776}
777
778LTTNG_HIDDEN
779enum lttng_trace_chunk_status lttng_trace_chunk_create_subdirectory(
780 struct lttng_trace_chunk *chunk,
781 const char *path)
782{
783 int ret;
784 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
785
786 DBG("Creating trace chunk subdirectory \"%s\"", path);
787 pthread_mutex_lock(&chunk->lock);
788 if (!chunk->credentials.is_set) {
789 /*
790 * Fatal error, credentials must be set before a
791 * directory is created.
792 */
793 ERR("Credentials of trace chunk are unset: refusing to create subdirectory \"%s\"",
794 path);
795 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
796 goto end;
797 }
798 if (!chunk->mode.is_set ||
799 chunk->mode.value != TRACE_CHUNK_MODE_OWNER) {
800 ERR("Attempted to create trace chunk subdirectory \"%s\" through a non-owner chunk",
801 path);
802 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION;
803 goto end;
804 }
cbf53d23 805 if (!chunk->chunk_directory) {
2c5ff4e4
JG
806 ERR("Attempted to create trace chunk subdirectory \"%s\" before setting the chunk output directory",
807 path);
808 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
809 goto end;
810 }
811 if (*path == '/') {
812 ERR("Refusing to create absolute trace chunk directory \"%s\"",
813 path);
814 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT;
815 goto end;
816 }
817 ret = lttng_directory_handle_create_subdirectory_recursive_as_user(
cbf53d23 818 chunk->chunk_directory, path,
2c5ff4e4
JG
819 DIR_CREATION_MODE,
820 chunk->credentials.value.use_current_user ?
821 NULL : &chunk->credentials.value.user);
822 if (ret) {
823 PERROR("Failed to create trace chunk subdirectory \"%s\"",
824 path);
825 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
826 goto end;
827 }
828 ret = add_top_level_directory_unique(chunk, path);
829 if (ret) {
830 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
831 goto end;
832 }
833end:
834 pthread_mutex_unlock(&chunk->lock);
835 return status;
836}
837
6cb32e5a
MD
838/*
839 * TODO: Implement O(1) lookup.
840 */
841static
842bool lttng_trace_chunk_find_file(struct lttng_trace_chunk *chunk,
843 const char *path, size_t *index)
844{
845 size_t i, count;
846
847 count = lttng_dynamic_pointer_array_get_count(&chunk->files);
848 for (i = 0; i < count; i++) {
849 const char *iter_path =
850 lttng_dynamic_pointer_array_get_pointer(
851 &chunk->files, i);
852 if (!strcmp(iter_path, path)) {
853 if (index) {
854 *index = i;
855 }
856 return true;
857 }
858 }
859 return false;
860}
861
862static
863enum lttng_trace_chunk_status lttng_trace_chunk_add_file(
864 struct lttng_trace_chunk *chunk,
865 const char *path)
866{
867 char *copy;
868 int ret;
869 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
870
871 if (lttng_trace_chunk_find_file(chunk, path, NULL)) {
872 return LTTNG_TRACE_CHUNK_STATUS_OK;
873 }
874 DBG("Adding new file \"%s\" to trace chunk \"%s\"",
875 path, chunk->name ? : "(unnamed)");
876 copy = strdup(path);
877 if (!copy) {
878 PERROR("Failed to copy path");
879 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
880 goto end;
881 }
882 ret = lttng_dynamic_pointer_array_add_pointer(
883 &chunk->files, copy);
884 if (ret) {
885 ERR("Allocation failure while adding file to a trace chunk");
886 free(copy);
887 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
888 goto end;
889 }
890end:
891 return status;
892}
893
894static
895void lttng_trace_chunk_remove_file(
896 struct lttng_trace_chunk *chunk,
897 const char *path)
898{
899 size_t index;
900 bool found;
901 int ret;
902
903 found = lttng_trace_chunk_find_file(chunk, path, &index);
904 if (!found) {
905 return;
906 }
907 ret = lttng_dynamic_pointer_array_remove_pointer(
908 &chunk->files, index);
909 assert(!ret);
910}
911
2c5ff4e4
JG
912LTTNG_HIDDEN
913enum lttng_trace_chunk_status lttng_trace_chunk_open_file(
914 struct lttng_trace_chunk *chunk, const char *file_path,
3ff5c5db 915 int flags, mode_t mode, int *out_fd, bool expect_no_file)
2c5ff4e4
JG
916{
917 int ret;
918 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
919
920 DBG("Opening trace chunk file \"%s\"", file_path);
921 pthread_mutex_lock(&chunk->lock);
922 if (!chunk->credentials.is_set) {
923 /*
924 * Fatal error, credentials must be set before a
925 * file is created.
926 */
927 ERR("Credentials of trace chunk are unset: refusing to open file \"%s\"",
928 file_path);
929 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
930 goto end;
931 }
cbf53d23 932 if (!chunk->chunk_directory) {
2c5ff4e4
JG
933 ERR("Attempted to open trace chunk file \"%s\" before setting the chunk output directory",
934 file_path);
935 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
936 goto end;
937 }
6cb32e5a
MD
938 status = lttng_trace_chunk_add_file(chunk, file_path);
939 if (status != LTTNG_TRACE_CHUNK_STATUS_OK) {
940 goto end;
941 }
2c5ff4e4 942 ret = lttng_directory_handle_open_file_as_user(
cbf53d23 943 chunk->chunk_directory, file_path, flags, mode,
2c5ff4e4
JG
944 chunk->credentials.value.use_current_user ?
945 NULL : &chunk->credentials.value.user);
946 if (ret < 0) {
3ff5c5db
MD
947 if (errno == ENOENT && expect_no_file) {
948 status = LTTNG_TRACE_CHUNK_STATUS_NO_FILE;
949 } else {
950 PERROR("Failed to open file relative to trace chunk file_path = \"%s\", flags = %d, mode = %d",
d2956687 951 file_path, flags, (int) mode);
3ff5c5db
MD
952 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
953 }
6cb32e5a 954 lttng_trace_chunk_remove_file(chunk, file_path);
2c5ff4e4
JG
955 goto end;
956 }
957 *out_fd = ret;
958end:
959 pthread_mutex_unlock(&chunk->lock);
960 return status;
961}
962
963LTTNG_HIDDEN
964int lttng_trace_chunk_unlink_file(struct lttng_trace_chunk *chunk,
965 const char *file_path)
966{
967 int ret;
968 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
969
970 DBG("Unlinking trace chunk file \"%s\"", file_path);
971 pthread_mutex_lock(&chunk->lock);
972 if (!chunk->credentials.is_set) {
973 /*
974 * Fatal error, credentials must be set before a
975 * directory is created.
976 */
977 ERR("Credentials of trace chunk are unset: refusing to unlink file \"%s\"",
978 file_path);
979 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
980 goto end;
981 }
cbf53d23 982 if (!chunk->chunk_directory) {
2c5ff4e4
JG
983 ERR("Attempted to unlink trace chunk file \"%s\" before setting the chunk output directory",
984 file_path);
985 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
986 goto end;
987 }
988 ret = lttng_directory_handle_unlink_file_as_user(
cbf53d23 989 chunk->chunk_directory, file_path,
2c5ff4e4
JG
990 chunk->credentials.value.use_current_user ?
991 NULL : &chunk->credentials.value.user);
992 if (ret < 0) {
993 status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
994 goto end;
995 }
6cb32e5a 996 lttng_trace_chunk_remove_file(chunk, file_path);
2c5ff4e4
JG
997end:
998 pthread_mutex_unlock(&chunk->lock);
999 return status;
1000}
1001
1002static
1003void lttng_trace_chunk_move_to_completed(struct lttng_trace_chunk *trace_chunk)
1004{
1005 int ret;
1006 char *directory_to_rename = NULL;
1007 bool free_directory_to_rename = false;
2c5ff4e4
JG
1008 char *archived_chunk_name = NULL;
1009 const uint64_t chunk_id = LTTNG_OPTIONAL_GET(trace_chunk->id);
1010 const time_t creation_timestamp =
1011 LTTNG_OPTIONAL_GET(trace_chunk->timestamp_creation);
1012 const time_t close_timestamp =
1013 LTTNG_OPTIONAL_GET(trace_chunk->timestamp_close);
cbf53d23 1014 struct lttng_directory_handle *archived_chunks_directory = NULL;
2c5ff4e4 1015
bbc4768c
JG
1016 if (!trace_chunk->mode.is_set ||
1017 trace_chunk->mode.value != TRACE_CHUNK_MODE_OWNER ||
cbf53d23 1018 !trace_chunk->session_output_directory) {
bbc4768c
JG
1019 /*
1020 * This command doesn't need to run if the output is remote
1021 * or if the trace chunk is not owned by this process.
1022 */
1023 goto end;
1024 }
1025
2c5ff4e4 1026 assert(trace_chunk->mode.value == TRACE_CHUNK_MODE_OWNER);
913a542b 1027 assert(!trace_chunk->name_overridden);
2c5ff4e4
JG
1028
1029 /*
1030 * The fist trace chunk of a session is directly output to the
1031 * session's output folder. In this case, the top level directories
1032 * must be moved to a temporary folder before that temporary directory
1033 * is renamed to match the chunk's name.
1034 */
1035 if (chunk_id == 0) {
cbf53d23
JG
1036 struct lttng_directory_handle *temporary_rename_directory =
1037 NULL;
2c5ff4e4 1038 size_t i, count = lttng_dynamic_pointer_array_get_count(
cbf53d23 1039 &trace_chunk->top_level_directories);
2c5ff4e4
JG
1040
1041 ret = lttng_directory_handle_create_subdirectory_as_user(
cbf53d23 1042 trace_chunk->session_output_directory,
2c5ff4e4
JG
1043 DEFAULT_TEMPORARY_CHUNK_RENAME_DIRECTORY,
1044 DIR_CREATION_MODE,
1045 !trace_chunk->credentials.value.use_current_user ?
1046 &trace_chunk->credentials.value.user : NULL);
1047 if (ret) {
1048 PERROR("Failed to create temporary trace chunk rename directory \"%s\"",
1049 DEFAULT_TEMPORARY_CHUNK_RENAME_DIRECTORY);
1050 }
1051
cbf53d23 1052 temporary_rename_directory = lttng_directory_handle_create_from_handle(
2c5ff4e4 1053 DEFAULT_TEMPORARY_CHUNK_RENAME_DIRECTORY,
cbf53d23
JG
1054 trace_chunk->session_output_directory);
1055 if (!temporary_rename_directory) {
2c5ff4e4
JG
1056 ERR("Failed to get handle to temporary trace chunk rename directory");
1057 goto end;
1058 }
1059
1060 for (i = 0; i < count; i++) {
2c5ff4e4
JG
1061 const char *top_level_name =
1062 lttng_dynamic_pointer_array_get_pointer(
1063 &trace_chunk->top_level_directories, i);
1064
9de831f8 1065 ret = lttng_directory_handle_rename_as_user(
cbf53d23 1066 trace_chunk->session_output_directory,
9de831f8 1067 top_level_name,
cbf53d23 1068 temporary_rename_directory,
9de831f8
JG
1069 top_level_name,
1070 LTTNG_OPTIONAL_GET(trace_chunk->credentials).use_current_user ?
1071 NULL :
1072 &trace_chunk->credentials.value.user);
2c5ff4e4
JG
1073 if (ret) {
1074 PERROR("Failed to move \"%s\" to temporary trace chunk rename directory",
1075 top_level_name);
cbf53d23
JG
1076 lttng_directory_handle_put(
1077 temporary_rename_directory);
2c5ff4e4
JG
1078 goto end;
1079 }
1080 }
cbf53d23 1081 lttng_directory_handle_put(temporary_rename_directory);
2c5ff4e4
JG
1082 directory_to_rename = DEFAULT_TEMPORARY_CHUNK_RENAME_DIRECTORY;
1083 free_directory_to_rename = false;
1084 } else {
1085 directory_to_rename = generate_chunk_name(chunk_id,
1086 creation_timestamp, NULL);
1087 if (!directory_to_rename) {
1088 ERR("Failed to generate initial trace chunk name while renaming trace chunk");
c222b016 1089 goto end;
2c5ff4e4
JG
1090 }
1091 free_directory_to_rename = true;
1092 }
1093
1094 archived_chunk_name = generate_chunk_name(chunk_id, creation_timestamp,
1095 &close_timestamp);
1096 if (!archived_chunk_name) {
1097 ERR("Failed to generate archived trace chunk name while renaming trace chunk");
1098 goto end;
1099 }
1100
1101 ret = lttng_directory_handle_create_subdirectory_as_user(
cbf53d23 1102 trace_chunk->session_output_directory,
2c5ff4e4
JG
1103 DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY,
1104 DIR_CREATION_MODE,
1105 !trace_chunk->credentials.value.use_current_user ?
1106 &trace_chunk->credentials.value.user :
1107 NULL);
1108 if (ret) {
1109 PERROR("Failed to create \"" DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY
1110 "\" directory for archived trace chunks");
1111 goto end;
1112 }
1113
cbf53d23 1114 archived_chunks_directory = lttng_directory_handle_create_from_handle(
2c5ff4e4 1115 DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY,
cbf53d23
JG
1116 trace_chunk->session_output_directory);
1117 if (!archived_chunks_directory) {
2c5ff4e4
JG
1118 PERROR("Failed to get handle to archived trace chunks directory");
1119 goto end;
1120 }
2c5ff4e4 1121
9de831f8 1122 ret = lttng_directory_handle_rename_as_user(
cbf53d23 1123 trace_chunk->session_output_directory,
9de831f8 1124 directory_to_rename,
cbf53d23 1125 archived_chunks_directory,
9de831f8
JG
1126 archived_chunk_name,
1127 LTTNG_OPTIONAL_GET(trace_chunk->credentials).use_current_user ?
1128 NULL :
1129 &trace_chunk->credentials.value.user);
2c5ff4e4
JG
1130 if (ret) {
1131 PERROR("Failed to rename folder \"%s\" to \"%s\"",
1132 directory_to_rename, archived_chunk_name);
1133 }
1134
1135end:
cbf53d23 1136 lttng_directory_handle_put(archived_chunks_directory);
2c5ff4e4
JG
1137 free(archived_chunk_name);
1138 if (free_directory_to_rename) {
1139 free(directory_to_rename);
1140 }
1141}
1142
bbc4768c
JG
1143LTTNG_HIDDEN
1144enum lttng_trace_chunk_status lttng_trace_chunk_get_close_command(
1145 struct lttng_trace_chunk *chunk,
1146 enum lttng_trace_chunk_command_type *command_type)
1147{
1148 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
1149
1150 pthread_mutex_lock(&chunk->lock);
1151 if (chunk->close_command.is_set) {
1152 *command_type = chunk->close_command.value;
1153 status = LTTNG_TRACE_CHUNK_STATUS_OK;
1154 } else {
1155 status = LTTNG_TRACE_CHUNK_STATUS_NONE;
1156 }
1157 pthread_mutex_unlock(&chunk->lock);
1158 return status;
1159}
1160
2c5ff4e4
JG
1161LTTNG_HIDDEN
1162enum lttng_trace_chunk_status lttng_trace_chunk_set_close_command(
1163 struct lttng_trace_chunk *chunk,
1164 enum lttng_trace_chunk_command_type close_command)
1165{
1166 enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK;
1167
1168 if (close_command < LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED ||
1169 close_command >= LTTNG_TRACE_CHUNK_COMMAND_TYPE_MAX) {
1170 status = LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT;
6def6cd7 1171 goto end;
2c5ff4e4
JG
1172 }
1173
1174 pthread_mutex_lock(&chunk->lock);
1175 if (chunk->close_command.is_set) {
1176 DBG("Overriding trace chunk close command from \"%s\" to \"%s\"",
1177 close_command_names[chunk->close_command.value],
1178 close_command_names[close_command]);
1179 } else {
1180 DBG("Setting trace chunk close command to \"%s\"",
1181 close_command_names[close_command]);
1182 }
343defc2
MD
1183 /*
1184 * Unset close command for no-op for backward compatibility with relayd
1185 * 2.11.
1186 */
1187 if (close_command != LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION) {
1188 LTTNG_OPTIONAL_SET(&chunk->close_command, close_command);
1189 } else {
1190 LTTNG_OPTIONAL_UNSET(&chunk->close_command);
1191 }
2c5ff4e4 1192 pthread_mutex_unlock(&chunk->lock);
6def6cd7 1193end:
2c5ff4e4
JG
1194 return status;
1195}
1196
bbc4768c
JG
1197LTTNG_HIDDEN
1198const char *lttng_trace_chunk_command_type_get_name(
1199 enum lttng_trace_chunk_command_type command)
1200{
1201 switch (command) {
1202 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED:
1203 return "move to completed trace chunk folder";
343defc2
MD
1204 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION:
1205 return "no operation";
1206 case LTTNG_TRACE_CHUNK_COMMAND_TYPE_DELETE:
1207 return "delete";
bbc4768c
JG
1208 default:
1209 abort();
1210 }
1211}
1212
2c5ff4e4
JG
1213LTTNG_HIDDEN
1214bool lttng_trace_chunk_get(struct lttng_trace_chunk *chunk)
1215{
1216 return urcu_ref_get_unless_zero(&chunk->ref);
1217}
1218
1219static
1220void free_lttng_trace_chunk_registry_element(struct rcu_head *node)
1221{
1222 struct lttng_trace_chunk_registry_element *element =
1223 container_of(node, typeof(*element), rcu_node);
1224
1225 lttng_trace_chunk_fini(&element->chunk);
1226 free(element);
1227}
1228
1229static
1230void lttng_trace_chunk_release(struct urcu_ref *ref)
1231{
1232 struct lttng_trace_chunk *chunk = container_of(ref, typeof(*chunk),
1233 ref);
1234
1235 if (chunk->close_command.is_set) {
1236 close_command_funcs[chunk->close_command.value](chunk);
1237 }
1238
1239 if (chunk->in_registry_element) {
1240 struct lttng_trace_chunk_registry_element *element;
1241
1242 element = container_of(chunk, typeof(*element), chunk);
1243 if (element->registry) {
1244 rcu_read_lock();
1245 cds_lfht_del(element->registry->ht,
1246 &element->trace_chunk_registry_ht_node);
1247 rcu_read_unlock();
1248 call_rcu(&element->rcu_node,
1249 free_lttng_trace_chunk_registry_element);
1250 } else {
1251 /* Never published, can be free'd immediately. */
1252 free_lttng_trace_chunk_registry_element(
1253 &element->rcu_node);
1254 }
1255 } else {
1256 /* Not RCU-protected, free immediately. */
1257 lttng_trace_chunk_fini(chunk);
1258 free(chunk);
1259 }
1260}
1261
1262LTTNG_HIDDEN
1263void lttng_trace_chunk_put(struct lttng_trace_chunk *chunk)
1264{
1265 if (!chunk) {
1266 return;
1267 }
1268 assert(chunk->ref.refcount);
1269 urcu_ref_put(&chunk->ref, lttng_trace_chunk_release);
1270}
1271
1272LTTNG_HIDDEN
1273struct lttng_trace_chunk_registry *lttng_trace_chunk_registry_create(void)
1274{
1275 struct lttng_trace_chunk_registry *registry;
1276
1277 registry = zmalloc(sizeof(*registry));
1278 if (!registry) {
1279 goto end;
1280 }
1281
1282 registry->ht = cds_lfht_new(DEFAULT_HT_SIZE, 1, 0,
1283 CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);
1284 if (!registry->ht) {
1285 goto error;
1286 }
1287end:
1288 return registry;
1289error:
1290 lttng_trace_chunk_registry_destroy(registry);
8243bf12 1291 return NULL;
2c5ff4e4
JG
1292}
1293
1294LTTNG_HIDDEN
1295void lttng_trace_chunk_registry_destroy(
1296 struct lttng_trace_chunk_registry *registry)
1297{
1298 if (!registry) {
1299 return;
1300 }
1301 if (registry->ht) {
1302 int ret = cds_lfht_destroy(registry->ht, NULL);
1303 assert(!ret);
1304 }
1305 free(registry);
1306}
1307
1308static
1309struct lttng_trace_chunk_registry_element *
1310lttng_trace_chunk_registry_element_create_from_chunk(
1311 struct lttng_trace_chunk *chunk, uint64_t session_id)
1312{
1313 struct lttng_trace_chunk_registry_element *element =
1314 zmalloc(sizeof(*element));
1315
1316 if (!element) {
1317 goto end;
1318 }
1319 cds_lfht_node_init(&element->trace_chunk_registry_ht_node);
1320 element->session_id = session_id;
1321
1322 element->chunk = *chunk;
1323 lttng_trace_chunk_init(&element->chunk);
cbf53d23
JG
1324 if (chunk->session_output_directory) {
1325 /* Transferred ownership. */
1326 element->chunk.session_output_directory =
1327 chunk->session_output_directory;
1328 chunk->session_output_directory = NULL;
1329 }
1330 if (chunk->chunk_directory) {
1331 /* Transferred ownership. */
1332 element->chunk.chunk_directory = chunk->chunk_directory;
1333 chunk->chunk_directory = NULL;
2c5ff4e4
JG
1334 }
1335 /*
1336 * The original chunk becomes invalid; the name attribute is transferred
1337 * to the new chunk instance.
1338 */
1339 chunk->name = NULL;
1340 element->chunk.in_registry_element = true;
1341end:
1342 return element;
1343}
1344
1345LTTNG_HIDDEN
1346struct lttng_trace_chunk *
1347lttng_trace_chunk_registry_publish_chunk(
1348 struct lttng_trace_chunk_registry *registry,
1349 uint64_t session_id, struct lttng_trace_chunk *chunk)
1350{
1351 struct lttng_trace_chunk_registry_element *element;
1352 unsigned long element_hash;
1353
1354 pthread_mutex_lock(&chunk->lock);
1355 element = lttng_trace_chunk_registry_element_create_from_chunk(chunk,
1356 session_id);
1357 pthread_mutex_unlock(&chunk->lock);
1358 if (!element) {
1359 goto end;
1360 }
1361 /*
1362 * chunk is now invalid, the only valid operation is a 'put' from the
1363 * caller.
1364 */
1365 chunk = NULL;
1366 element_hash = lttng_trace_chunk_registry_element_hash(element);
1367
1368 rcu_read_lock();
1369 while (1) {
1370 struct cds_lfht_node *published_node;
1371 struct lttng_trace_chunk *published_chunk;
1372 struct lttng_trace_chunk_registry_element *published_element;
1373
1374 published_node = cds_lfht_add_unique(registry->ht,
1375 element_hash,
1376 lttng_trace_chunk_registry_element_match,
1377 element,
1378 &element->trace_chunk_registry_ht_node);
1379 if (published_node == &element->trace_chunk_registry_ht_node) {
1380 /* Successfully published the new element. */
1381 element->registry = registry;
1382 /* Acquire a reference for the caller. */
1383 if (lttng_trace_chunk_get(&element->chunk)) {
1384 break;
1385 } else {
1386 /*
1387 * Another thread concurrently unpublished the
1388 * trace chunk. This is currently unexpected.
1389 *
1390 * Re-attempt to publish.
1391 */
87cee602 1392 ERR("Attempt to publish a trace chunk to the chunk registry raced with a trace chunk deletion");
2c5ff4e4
JG
1393 continue;
1394 }
1395 }
1396
1397 /*
1398 * An equivalent trace chunk was published before this trace
1399 * chunk. Attempt to acquire a reference to the one that was
1400 * already published and release the reference to the copy we
1401 * created if successful.
1402 */
1403 published_element = container_of(published_node,
1404 typeof(*published_element),
1405 trace_chunk_registry_ht_node);
1406 published_chunk = &published_element->chunk;
1407 if (lttng_trace_chunk_get(published_chunk)) {
1408 lttng_trace_chunk_put(&element->chunk);
1409 element = published_element;
1410 break;
1411 }
1412 /*
1413 * A reference to the previously published trace chunk could not
1414 * be acquired. Hence, retry to publish our copy of the trace
1415 * chunk.
1416 */
1417 }
1418 rcu_read_unlock();
1419end:
1420 return element ? &element->chunk : NULL;
1421}
1422
1423/*
1424 * Note that the caller must be registered as an RCU thread.
1425 * However, it does not need to hold the RCU read lock. The RCU read lock is
1426 * acquired to perform the look-up in the registry's hash table and held until
1427 * after a reference to the "found" trace chunk is acquired.
1428 *
1429 * IOW, holding a reference guarantees the existence of the object for the
1430 * caller.
1431 */
1432static
1433struct lttng_trace_chunk *_lttng_trace_chunk_registry_find_chunk(
1434 const struct lttng_trace_chunk_registry *registry,
1435 uint64_t session_id, uint64_t *chunk_id)
1436{
1437 const struct lttng_trace_chunk_registry_element target_element = {
1438 .chunk.id.is_set = !!chunk_id,
1439 .chunk.id.value = chunk_id ? *chunk_id : 0,
1440 .session_id = session_id,
1441 };
1442 const unsigned long element_hash =
1443 lttng_trace_chunk_registry_element_hash(
1444 &target_element);
1445 struct cds_lfht_node *published_node;
1446 struct lttng_trace_chunk_registry_element *published_element;
1447 struct lttng_trace_chunk *published_chunk = NULL;
1448 struct cds_lfht_iter iter;
1449
1450 rcu_read_lock();
1451 cds_lfht_lookup(registry->ht,
1452 element_hash,
1453 lttng_trace_chunk_registry_element_match,
1454 &target_element,
1455 &iter);
1456 published_node = cds_lfht_iter_get_node(&iter);
1457 if (!published_node) {
1458 goto end;
1459 }
1460
1461 published_element = container_of(published_node,
1462 typeof(*published_element),
1463 trace_chunk_registry_ht_node);
1464 if (lttng_trace_chunk_get(&published_element->chunk)) {
1465 published_chunk = &published_element->chunk;
1466 }
1467end:
1468 rcu_read_unlock();
1469 return published_chunk;
1470}
1471
1472LTTNG_HIDDEN
1473struct lttng_trace_chunk *
1474lttng_trace_chunk_registry_find_chunk(
1475 const struct lttng_trace_chunk_registry *registry,
1476 uint64_t session_id, uint64_t chunk_id)
1477{
1478 return _lttng_trace_chunk_registry_find_chunk(registry,
1479 session_id, &chunk_id);
1480}
1481
6b584c2e
JG
1482LTTNG_HIDDEN
1483int lttng_trace_chunk_registry_chunk_exists(
1484 const struct lttng_trace_chunk_registry *registry,
1485 uint64_t session_id, uint64_t chunk_id, bool *chunk_exists)
1486{
1487 int ret = 0;
1488 const struct lttng_trace_chunk_registry_element target_element = {
1489 .chunk.id.is_set = true,
1490 .chunk.id.value = chunk_id,
1491 .session_id = session_id,
1492 };
1493 const unsigned long element_hash =
1494 lttng_trace_chunk_registry_element_hash(
1495 &target_element);
1496 struct cds_lfht_node *published_node;
1497 struct cds_lfht_iter iter;
1498
1499 rcu_read_lock();
1500 cds_lfht_lookup(registry->ht,
1501 element_hash,
1502 lttng_trace_chunk_registry_element_match,
1503 &target_element,
1504 &iter);
1505 published_node = cds_lfht_iter_get_node(&iter);
1506 if (!published_node) {
1507 *chunk_exists = false;
1508 goto end;
1509 }
1510
1511 *chunk_exists = !cds_lfht_is_node_deleted(published_node);
1512end:
1513 rcu_read_unlock();
1514 return ret;
1515}
1516
2c5ff4e4
JG
1517LTTNG_HIDDEN
1518struct lttng_trace_chunk *
1519lttng_trace_chunk_registry_find_anonymous_chunk(
1520 const struct lttng_trace_chunk_registry *registry,
1521 uint64_t session_id)
1522{
1523 return _lttng_trace_chunk_registry_find_chunk(registry,
1524 session_id, NULL);
1525}
e10aec8f
MD
1526
1527unsigned int lttng_trace_chunk_registry_put_each_chunk(
1528 struct lttng_trace_chunk_registry *registry)
1529{
1530 struct cds_lfht_iter iter;
1531 struct lttng_trace_chunk_registry_element *chunk_element;
1532 unsigned int trace_chunks_left = 0;
1533
1534 DBG("Releasing trace chunk registry to all trace chunks");
1535 rcu_read_lock();
1536 cds_lfht_for_each_entry(registry->ht,
1537 &iter, chunk_element, trace_chunk_registry_ht_node) {
1538 const char *chunk_id_str = "none";
1539 char chunk_id_buf[MAX_INT_DEC_LEN(uint64_t)];
1540
1541 pthread_mutex_lock(&chunk_element->chunk.lock);
1542 if (chunk_element->chunk.id.is_set) {
1543 int fmt_ret;
1544
1545 fmt_ret = snprintf(chunk_id_buf, sizeof(chunk_id_buf),
1546 "%" PRIu64,
1547 chunk_element->chunk.id.value);
1548 if (fmt_ret < 0 || fmt_ret >= sizeof(chunk_id_buf)) {
1549 chunk_id_str = "formatting error";
1550 } else {
1551 chunk_id_str = chunk_id_buf;
1552 }
1553 }
1554
1555 DBG("Releasing reference to trace chunk: session_id = %" PRIu64
1556 "chunk_id = %s, name = \"%s\", status = %s",
1557 chunk_element->session_id,
1558 chunk_id_str,
1559 chunk_element->chunk.name ? : "none",
1560 chunk_element->chunk.close_command.is_set ?
1561 "open" : "closed");
1562 pthread_mutex_unlock(&chunk_element->chunk.lock);
1563 lttng_trace_chunk_put(&chunk_element->chunk);
1564 trace_chunks_left++;
1565 }
1566 rcu_read_unlock();
1567 DBG("Released reference to %u trace chunks in %s()", trace_chunks_left,
1568 __FUNCTION__);
1569
1570 return trace_chunks_left;
1571}
This page took 0.14958 seconds and 4 git commands to generate.