src/common/trace-chunk.c

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