src/plugins/ctf/fs-src/fs.c

   1 /*
   2  * fs.c
   3  *
   4  * Babeltrace CTF file system Reader Component
   5  *
   6  * Copyright 2015-2017 Philippe Proulx <pproulx@efficios.com>
   7  * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a copy
  10  * of this software and associated documentation files (the "Software"), to deal
  11  * in the Software without restriction, including without limitation the rights
  12  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  13  * copies of the Software, and to permit persons to whom the Software is
  14  * furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included in
  17  * all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  22  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  24  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  25  * SOFTWARE.
  26  */
  27
  28 #define BT_COMP_LOG_SELF_COMP self_comp
  29 #define BT_LOG_OUTPUT_LEVEL log_level
  30 #define BT_LOG_TAG "PLUGIN/SRC.CTF.FS"
  31 #include "logging/comp-logging.h"
  32
  33 #include "common/common.h"
  34 #include <babeltrace2/babeltrace.h>
  35 #include "common/uuid.h"
  36 #include <glib.h>
  37 #include "common/assert.h"
  38 #include <inttypes.h>
  39 #include <stdbool.h>
  40 #include "fs.h"
  41 #include "metadata.h"
  42 #include "data-stream-file.h"
  43 #include "file.h"
  44 #include "../common/metadata/decoder.h"
  45 #include "../common/metadata/ctf-meta-configure-ir-trace.h"
  46 #include "../common/msg-iter/msg-iter.h"
  47 #include "query.h"
  48 #include "plugins/common/param-validation/param-validation.h"
  49
  50 struct tracer_info {
  51         const char *name;
  52         int64_t major;
  53         int64_t minor;
  54         int64_t patch;
  55 };
  56
  57 static
  58 int msg_iter_data_set_current_ds_file(struct ctf_fs_msg_iter_data *msg_iter_data)
  59 {
  60         struct ctf_fs_ds_file_info *ds_file_info;
  61         int ret = 0;
  62
  63         BT_ASSERT(msg_iter_data->ds_file_info_index <
  64                 msg_iter_data->ds_file_group->ds_file_infos->len);
  65         ds_file_info = g_ptr_array_index(
  66                 msg_iter_data->ds_file_group->ds_file_infos,
  67                 msg_iter_data->ds_file_info_index);
  68
  69         ctf_fs_ds_file_destroy(msg_iter_data->ds_file);
  70         msg_iter_data->ds_file = ctf_fs_ds_file_create(
  71                 msg_iter_data->ds_file_group->ctf_fs_trace,
  72                 msg_iter_data->pc_msg_iter,
  73                 msg_iter_data->msg_iter,
  74                 msg_iter_data->ds_file_group->stream,
  75                 ds_file_info->path->str,
  76                 msg_iter_data->log_level);
  77         if (!msg_iter_data->ds_file) {
  78                 ret = -1;
  79         }
  80
  81         return ret;
  82 }
  83
  84 static
  85 void ctf_fs_msg_iter_data_destroy(
  86                 struct ctf_fs_msg_iter_data *msg_iter_data)
  87 {
  88         if (!msg_iter_data) {
  89                 return;
  90         }
  91
  92         ctf_fs_ds_file_destroy(msg_iter_data->ds_file);
  93
  94         if (msg_iter_data->msg_iter) {
  95                 bt_msg_iter_destroy(msg_iter_data->msg_iter);
  96         }
  97
  98         g_free(msg_iter_data);
  99 }
 100
 101 static
 102 void set_msg_iter_emits_stream_beginning_end_messages(
 103                 struct ctf_fs_msg_iter_data *msg_iter_data)
 104 {
 105         bt_msg_iter_set_emit_stream_beginning_message(
 106                 msg_iter_data->ds_file->msg_iter,
 107                 msg_iter_data->ds_file_info_index == 0);
 108         bt_msg_iter_set_emit_stream_end_message(
 109                 msg_iter_data->ds_file->msg_iter,
 110                 msg_iter_data->ds_file_info_index ==
 111                         msg_iter_data->ds_file_group->ds_file_infos->len - 1);
 112 }
 113
 114 static
 115 bt_component_class_message_iterator_next_method_status ctf_fs_iterator_next_one(
 116                 struct ctf_fs_msg_iter_data *msg_iter_data,
 117                 const bt_message **out_msg)
 118 {
 119         bt_component_class_message_iterator_next_method_status status;
 120
 121         BT_ASSERT(msg_iter_data->ds_file);
 122
 123         while (true) {
 124                 bt_message *msg;
 125
 126                 status = ctf_fs_ds_file_next(msg_iter_data->ds_file, &msg);
 127                 switch (status) {
 128                 case BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK:
 129                         *out_msg = msg;
 130                         msg = NULL;
 131                         goto end;
 132                 case BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_END:
 133                 {
 134                         int ret;
 135
 136                         if (msg_iter_data->ds_file_info_index ==
 137                                         msg_iter_data->ds_file_group->ds_file_infos->len - 1) {
 138                                 /* End of all group's stream files */
 139                                 goto end;
 140                         }
 141
 142                         msg_iter_data->ds_file_info_index++;
 143                         bt_msg_iter_reset_for_next_stream_file(
 144                                 msg_iter_data->msg_iter);
 145                         set_msg_iter_emits_stream_beginning_end_messages(
 146                                 msg_iter_data);
 147
 148                         /*
 149                          * Open and start reading the next stream file
 150                          * within our stream file group.
 151                          */
 152                         ret = msg_iter_data_set_current_ds_file(msg_iter_data);
 153                         if (ret) {
 154                                 status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_ERROR;
 155                                 goto end;
 156                         }
 157
 158                         /* Continue the loop to get the next message */
 159                         break;
 160                 }
 161                 default:
 162                         goto end;
 163                 }
 164         }
 165
 166 end:
 167         return status;
 168 }
 169
 170 BT_HIDDEN
 171 bt_component_class_message_iterator_next_method_status ctf_fs_iterator_next(
 172                 bt_self_message_iterator *iterator,
 173                 bt_message_array_const msgs, uint64_t capacity,
 174                 uint64_t *count)
 175 {
 176         bt_component_class_message_iterator_next_method_status status =
 177                 BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK;
 178         struct ctf_fs_msg_iter_data *msg_iter_data =
 179                 bt_self_message_iterator_get_data(iterator);
 180         uint64_t i = 0;
 181
 182         while (i < capacity &&
 183                         status == BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK) {
 184                 status = ctf_fs_iterator_next_one(msg_iter_data, &msgs[i]);
 185                 if (status == BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK) {
 186                         i++;
 187                 }
 188         }
 189
 190         if (i > 0) {
 191                 /*
 192                  * Even if ctf_fs_iterator_next_one() returned something
 193                  * else than BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK, we
 194                  * accumulated message objects in the output
 195                  * message array, so we need to return
 196                  * BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK so that they are
 197                  * transfered to downstream. This other status occurs
 198                  * again the next time muxer_msg_iter_do_next() is
 199                  * called, possibly without any accumulated
 200                  * message, in which case we'll return it.
 201                  */
 202                 *count = i;
 203                 status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK;
 204         }
 205
 206         return status;
 207 }
 208
 209 static
 210 int ctf_fs_iterator_reset(struct ctf_fs_msg_iter_data *msg_iter_data)
 211 {
 212         int ret;
 213
 214         msg_iter_data->ds_file_info_index = 0;
 215         ret = msg_iter_data_set_current_ds_file(msg_iter_data);
 216         if (ret) {
 217                 goto end;
 218         }
 219
 220         bt_msg_iter_reset(msg_iter_data->msg_iter);
 221         set_msg_iter_emits_stream_beginning_end_messages(msg_iter_data);
 222
 223 end:
 224         return ret;
 225 }
 226
 227 BT_HIDDEN
 228 bt_component_class_message_iterator_seek_beginning_method_status
 229 ctf_fs_iterator_seek_beginning(bt_self_message_iterator *it)
 230 {
 231         struct ctf_fs_msg_iter_data *msg_iter_data =
 232                 bt_self_message_iterator_get_data(it);
 233         bt_component_class_message_iterator_seek_beginning_method_status status =
 234                 BT_COMPONENT_CLASS_MESSAGE_ITERATOR_SEEK_BEGINNING_METHOD_STATUS_OK;
 235
 236         BT_ASSERT(msg_iter_data);
 237         if (ctf_fs_iterator_reset(msg_iter_data)) {
 238                 status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_SEEK_BEGINNING_METHOD_STATUS_ERROR;
 239         }
 240
 241         return status;
 242 }
 243
 244 BT_HIDDEN
 245 void ctf_fs_iterator_finalize(bt_self_message_iterator *it)
 246 {
 247         ctf_fs_msg_iter_data_destroy(
 248                 bt_self_message_iterator_get_data(it));
 249 }
 250
 251 BT_HIDDEN
 252 bt_component_class_message_iterator_initialize_method_status ctf_fs_iterator_init(
 253                 bt_self_message_iterator *self_msg_iter,
 254                 bt_self_message_iterator_configuration *config,
 255                 bt_self_component_source *self_comp_src,
 256                 bt_self_component_port_output *self_port)
 257 {
 258         struct ctf_fs_port_data *port_data;
 259         struct ctf_fs_msg_iter_data *msg_iter_data = NULL;
 260         bt_component_class_message_iterator_initialize_method_status ret =
 261                 BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INITIALIZE_METHOD_STATUS_OK;
 262         bt_logging_level log_level;
 263         bt_self_component *self_comp =
 264                 bt_self_component_source_as_self_component(self_comp_src);
 265
 266         port_data = bt_self_component_port_get_data(
 267                 bt_self_component_port_output_as_self_component_port(
 268                         self_port));
 269         BT_ASSERT(port_data);
 270         log_level = port_data->ctf_fs->log_level;
 271         msg_iter_data = g_new0(struct ctf_fs_msg_iter_data, 1);
 272         if (!msg_iter_data) {
 273                 ret = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
 274                 goto error;
 275         }
 276
 277         msg_iter_data->log_level = log_level;
 278         msg_iter_data->self_comp = self_comp;
 279         msg_iter_data->pc_msg_iter = self_msg_iter;
 280         msg_iter_data->msg_iter = bt_msg_iter_create(
 281                 port_data->ds_file_group->ctf_fs_trace->metadata->tc,
 282                 bt_common_get_page_size(msg_iter_data->log_level) * 8,
 283                 ctf_fs_ds_file_medops, NULL, msg_iter_data->log_level,
 284                 self_comp);
 285         if (!msg_iter_data->msg_iter) {
 286                 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot create a CTF message iterator.");
 287                 ret = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
 288                 goto error;
 289         }
 290
 291         msg_iter_data->ds_file_group = port_data->ds_file_group;
 292         if (ctf_fs_iterator_reset(msg_iter_data)) {
 293                 ret = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INITIALIZE_METHOD_STATUS_ERROR;
 294                 goto error;
 295         }
 296
 297         /*
 298          * This iterator can seek forward if its stream class has a default
 299          * clock class.
 300          */
 301         if (msg_iter_data->ds_file_group->sc->default_clock_class) {
 302                 bt_self_message_iterator_configuration_set_can_seek_forward(
 303                         config, true);
 304         }
 305
 306         bt_self_message_iterator_set_data(self_msg_iter,
 307                 msg_iter_data);
 308         if (ret != BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INITIALIZE_METHOD_STATUS_OK) {
 309                 goto error;
 310         }
 311         msg_iter_data = NULL;
 312         goto end;
 313
 314 error:
 315         bt_self_message_iterator_set_data(self_msg_iter, NULL);
 316
 317 end:
 318         ctf_fs_msg_iter_data_destroy(msg_iter_data);
 319         return ret;
 320 }
 321
 322 static
 323 void ctf_fs_trace_destroy(struct ctf_fs_trace *ctf_fs_trace)
 324 {
 325         if (!ctf_fs_trace) {
 326                 return;
 327         }
 328
 329         if (ctf_fs_trace->ds_file_groups) {
 330                 g_ptr_array_free(ctf_fs_trace->ds_file_groups, TRUE);
 331         }
 332
 333         BT_TRACE_PUT_REF_AND_RESET(ctf_fs_trace->trace);
 334
 335         if (ctf_fs_trace->path) {
 336                 g_string_free(ctf_fs_trace->path, TRUE);
 337         }
 338
 339         if (ctf_fs_trace->metadata) {
 340                 ctf_fs_metadata_fini(ctf_fs_trace->metadata);
 341                 g_free(ctf_fs_trace->metadata);
 342         }
 343
 344         g_free(ctf_fs_trace);
 345 }
 346
 347 BT_HIDDEN
 348 void ctf_fs_destroy(struct ctf_fs_component *ctf_fs)
 349 {
 350         if (!ctf_fs) {
 351                 return;
 352         }
 353
 354         ctf_fs_trace_destroy(ctf_fs->trace);
 355
 356         if (ctf_fs->port_data) {
 357                 g_ptr_array_free(ctf_fs->port_data, TRUE);
 358         }
 359
 360         g_free(ctf_fs);
 361 }
 362
 363 static
 364 void port_data_destroy(struct ctf_fs_port_data *port_data)
 365 {
 366         if (!port_data) {
 367                 return;
 368         }
 369
 370         g_free(port_data);
 371 }
 372
 373 static
 374 void port_data_destroy_notifier(void *data) {
 375         port_data_destroy(data);
 376 }
 377
 378 static
 379 void ctf_fs_trace_destroy_notifier(void *data)
 380 {
 381         struct ctf_fs_trace *trace = data;
 382         ctf_fs_trace_destroy(trace);
 383 }
 384
 385 struct ctf_fs_component *ctf_fs_component_create(bt_logging_level log_level,
 386                 bt_self_component *self_comp)
 387 {
 388         struct ctf_fs_component *ctf_fs;
 389
 390         ctf_fs = g_new0(struct ctf_fs_component, 1);
 391         if (!ctf_fs) {
 392                 goto error;
 393         }
 394
 395         ctf_fs->log_level = log_level;
 396         ctf_fs->port_data =
 397                 g_ptr_array_new_with_free_func(port_data_destroy_notifier);
 398         if (!ctf_fs->port_data) {
 399                 goto error;
 400         }
 401
 402         goto end;
 403
 404 error:
 405         ctf_fs_destroy(ctf_fs);
 406         ctf_fs = NULL;
 407
 408 end:
 409         return ctf_fs;
 410 }
 411
 412 void ctf_fs_finalize(bt_self_component_source *component)
 413 {
 414         ctf_fs_destroy(bt_self_component_get_data(
 415                 bt_self_component_source_as_self_component(component)));
 416 }
 417
 418 gchar *ctf_fs_make_port_name(struct ctf_fs_ds_file_group *ds_file_group)
 419 {
 420         GString *name = g_string_new(NULL);
 421
 422         /*
 423          * The unique port name is generated by concatenating unique identifiers
 424          * for:
 425          *
 426          *   - the trace
 427          *   - the stream class
 428          *   - the stream
 429          */
 430
 431         /* For the trace, use the uuid if present, else the path. */
 432         if (ds_file_group->ctf_fs_trace->metadata->tc->is_uuid_set) {
 433                 char uuid_str[BT_UUID_STR_LEN + 1];
 434
 435                 bt_uuid_to_str(ds_file_group->ctf_fs_trace->metadata->tc->uuid, uuid_str);
 436                 g_string_assign(name, uuid_str);
 437         } else {
 438                 g_string_assign(name, ds_file_group->ctf_fs_trace->path->str);
 439         }
 440
 441         /*
 442          * For the stream class, use the id if present.  We can omit this field
 443          * otherwise, as there will only be a single stream class.
 444          */
 445         if (ds_file_group->sc->id != UINT64_C(-1)) {
 446                 g_string_append_printf(name, " | %" PRIu64, ds_file_group->sc->id);
 447         }
 448
 449         /* For the stream, use the id if present, else, use the path. */
 450         if (ds_file_group->stream_id != UINT64_C(-1)) {
 451                 g_string_append_printf(name, " | %" PRIu64, ds_file_group->stream_id);
 452         } else {
 453                 BT_ASSERT(ds_file_group->ds_file_infos->len == 1);
 454                 struct ctf_fs_ds_file_info *ds_file_info =
 455                         g_ptr_array_index(ds_file_group->ds_file_infos, 0);
 456                 g_string_append_printf(name, " | %s", ds_file_info->path->str);
 457         }
 458
 459         return g_string_free(name, FALSE);
 460 }
 461
 462 static
 463 int create_one_port_for_trace(struct ctf_fs_component *ctf_fs,
 464                 struct ctf_fs_trace *ctf_fs_trace,
 465                 struct ctf_fs_ds_file_group *ds_file_group,
 466                 bt_self_component_source *self_comp_src)
 467 {
 468         int ret = 0;
 469         struct ctf_fs_port_data *port_data = NULL;
 470         gchar *port_name;
 471         bt_logging_level log_level = ctf_fs->log_level;
 472         bt_self_component *self_comp =
 473                 bt_self_component_source_as_self_component(self_comp_src);
 474
 475         port_name = ctf_fs_make_port_name(ds_file_group);
 476         if (!port_name) {
 477                 goto error;
 478         }
 479
 480         BT_COMP_LOGI("Creating one port named `%s`", port_name);
 481
 482         /* Create output port for this file */
 483         port_data = g_new0(struct ctf_fs_port_data, 1);
 484         if (!port_data) {
 485                 goto error;
 486         }
 487
 488         port_data->ctf_fs = ctf_fs;
 489         port_data->ds_file_group = ds_file_group;
 490         ret = bt_self_component_source_add_output_port(
 491                 self_comp_src, port_name, port_data, NULL);
 492         if (ret) {
 493                 goto error;
 494         }
 495
 496         g_ptr_array_add(ctf_fs->port_data, port_data);
 497         port_data = NULL;
 498         goto end;
 499
 500 error:
 501         ret = -1;
 502
 503 end:
 504         g_free(port_name);
 505
 506         port_data_destroy(port_data);
 507         return ret;
 508 }
 509
 510 static
 511 int create_ports_for_trace(struct ctf_fs_component *ctf_fs,
 512                 struct ctf_fs_trace *ctf_fs_trace,
 513                 bt_self_component_source *self_comp_src)
 514 {
 515         int ret = 0;
 516         size_t i;
 517         bt_logging_level log_level = ctf_fs_trace->log_level;
 518         bt_self_component *self_comp =
 519                 bt_self_component_source_as_self_component(self_comp_src);
 520
 521         /* Create one output port for each stream file group */
 522         for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) {
 523                 struct ctf_fs_ds_file_group *ds_file_group =
 524                         g_ptr_array_index(ctf_fs_trace->ds_file_groups, i);
 525
 526                 ret = create_one_port_for_trace(ctf_fs, ctf_fs_trace,
 527                         ds_file_group, self_comp_src);
 528                 if (ret) {
 529                         BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot create output port.");
 530                         goto end;
 531                 }
 532         }
 533
 534 end:
 535         return ret;
 536 }
 537
 538 static
 539 void ctf_fs_ds_file_info_destroy(struct ctf_fs_ds_file_info *ds_file_info)
 540 {
 541         if (!ds_file_info) {
 542                 return;
 543         }
 544
 545         if (ds_file_info->path) {
 546                 g_string_free(ds_file_info->path, TRUE);
 547         }
 548
 549         g_free(ds_file_info);
 550 }
 551
 552 static
 553 struct ctf_fs_ds_file_info *ctf_fs_ds_file_info_create(const char *path,
 554                 int64_t begin_ns)
 555 {
 556         struct ctf_fs_ds_file_info *ds_file_info;
 557
 558         ds_file_info = g_new0(struct ctf_fs_ds_file_info, 1);
 559         if (!ds_file_info) {
 560                 goto end;
 561         }
 562
 563         ds_file_info->path = g_string_new(path);
 564         if (!ds_file_info->path) {
 565                 ctf_fs_ds_file_info_destroy(ds_file_info);
 566                 ds_file_info = NULL;
 567                 goto end;
 568         }
 569
 570         ds_file_info->begin_ns = begin_ns;
 571
 572 end:
 573         return ds_file_info;
 574 }
 575
 576 static
 577 void ctf_fs_ds_file_group_destroy(struct ctf_fs_ds_file_group *ds_file_group)
 578 {
 579         if (!ds_file_group) {
 580                 return;
 581         }
 582
 583         if (ds_file_group->ds_file_infos) {
 584                 g_ptr_array_free(ds_file_group->ds_file_infos, TRUE);
 585         }
 586
 587         if (ds_file_group->index) {
 588                 if (ds_file_group->index->entries) {
 589                         g_ptr_array_free(ds_file_group->index->entries, TRUE);
 590                 }
 591                 g_free(ds_file_group->index);
 592         }
 593
 594         bt_stream_put_ref(ds_file_group->stream);
 595         g_free(ds_file_group);
 596 }
 597
 598 static
 599 struct ctf_fs_ds_file_group *ctf_fs_ds_file_group_create(
 600                 struct ctf_fs_trace *ctf_fs_trace,
 601                 struct ctf_stream_class *sc,
 602                 uint64_t stream_instance_id,
 603                 struct ctf_fs_ds_index *index)
 604 {
 605         struct ctf_fs_ds_file_group *ds_file_group;
 606
 607         ds_file_group = g_new0(struct ctf_fs_ds_file_group, 1);
 608         if (!ds_file_group) {
 609                 goto error;
 610         }
 611
 612         ds_file_group->ds_file_infos = g_ptr_array_new_with_free_func(
 613                 (GDestroyNotify) ctf_fs_ds_file_info_destroy);
 614         if (!ds_file_group->ds_file_infos) {
 615                 goto error;
 616         }
 617
 618         ds_file_group->index = index;
 619
 620         ds_file_group->stream_id = stream_instance_id;
 621         BT_ASSERT(sc);
 622         ds_file_group->sc = sc;
 623         ds_file_group->ctf_fs_trace = ctf_fs_trace;
 624         goto end;
 625
 626 error:
 627         ctf_fs_ds_file_group_destroy(ds_file_group);
 628         ctf_fs_ds_index_destroy(index);
 629         ds_file_group = NULL;
 630
 631 end:
 632         return ds_file_group;
 633 }
 634
 635 /* Replace by g_ptr_array_insert when we depend on glib >= 2.40. */
 636 static
 637 void array_insert(GPtrArray *array, gpointer element, size_t pos)
 638 {
 639         size_t original_array_len = array->len;
 640
 641         /* Allocate an unused element at the end of the array. */
 642         g_ptr_array_add(array, NULL);
 643
 644         /* If we are not inserting at the end, move the elements by one. */
 645         if (pos < original_array_len) {
 646                 memmove(&(array->pdata[pos + 1]),
 647                         &(array->pdata[pos]),
 648                         (original_array_len - pos) * sizeof(gpointer));
 649         }
 650
 651         /* Insert the value. */
 652         array->pdata[pos] = element;
 653 }
 654
 655 /*
 656  * Insert ds_file_info in ds_file_group's list of ds_file_infos at the right
 657  * place to keep it sorted.
 658  */
 659
 660 static
 661 void ds_file_group_insert_ds_file_info_sorted(
 662                 struct ctf_fs_ds_file_group *ds_file_group,
 663                 struct ctf_fs_ds_file_info *ds_file_info)
 664 {
 665         guint i;
 666
 667         /* Find the spot where to insert this ds_file_info. */
 668         for (i = 0; i < ds_file_group->ds_file_infos->len; i++) {
 669                 struct ctf_fs_ds_file_info *other_ds_file_info =
 670                         g_ptr_array_index(ds_file_group->ds_file_infos, i);
 671
 672                 if (ds_file_info->begin_ns < other_ds_file_info->begin_ns) {
 673                         break;
 674                 }
 675         }
 676
 677         array_insert(ds_file_group->ds_file_infos, ds_file_info, i);
 678 }
 679
 680 static
 681 void ds_file_group_insert_ds_index_entry_sorted(
 682         struct ctf_fs_ds_file_group *ds_file_group,
 683         struct ctf_fs_ds_index_entry *entry)
 684 {
 685         guint i;
 686
 687         /* Find the spot where to insert this index entry. */
 688         for (i = 0; i < ds_file_group->index->entries->len; i++) {
 689                 struct ctf_fs_ds_index_entry *other_entry = g_ptr_array_index(
 690                         ds_file_group->index->entries, i);
 691
 692                 if (entry->timestamp_begin_ns < other_entry->timestamp_begin_ns) {
 693                         break;
 694                 }
 695         }
 696
 697         array_insert(ds_file_group->index->entries, entry, i);
 698 }
 699
 700 static
 701 int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace,
 702                 const char *path)
 703 {
 704         int64_t stream_instance_id = -1;
 705         int64_t begin_ns = -1;
 706         struct ctf_fs_ds_file_group *ds_file_group = NULL;
 707         bool add_group = false;
 708         int ret;
 709         size_t i;
 710         struct ctf_fs_ds_file *ds_file = NULL;
 711         struct ctf_fs_ds_file_info *ds_file_info = NULL;
 712         struct ctf_fs_ds_index *index = NULL;
 713         struct bt_msg_iter *msg_iter = NULL;
 714         struct ctf_stream_class *sc = NULL;
 715         struct bt_msg_iter_packet_properties props;
 716         bt_logging_level log_level = ctf_fs_trace->log_level;
 717         bt_self_component *self_comp = ctf_fs_trace->self_comp;
 718
 719         msg_iter = bt_msg_iter_create(ctf_fs_trace->metadata->tc,
 720                 bt_common_get_page_size(log_level) * 8,
 721                 ctf_fs_ds_file_medops, NULL, log_level, self_comp);
 722         if (!msg_iter) {
 723                 BT_COMP_LOGE_STR("Cannot create a CTF message iterator.");
 724                 goto error;
 725         }
 726
 727         ds_file = ctf_fs_ds_file_create(ctf_fs_trace, NULL, msg_iter,
 728                 NULL, path, log_level);
 729         if (!ds_file) {
 730                 goto error;
 731         }
 732
 733         ret = bt_msg_iter_get_packet_properties(ds_file->msg_iter, &props);
 734         if (ret) {
 735                 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
 736                         "Cannot get stream file's first packet's header and context fields (`%s`).",
 737                         path);
 738                 goto error;
 739         }
 740
 741         sc = ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc,
 742                 props.stream_class_id);
 743         BT_ASSERT(sc);
 744         stream_instance_id = props.data_stream_id;
 745
 746         if (props.snapshots.beginning_clock != UINT64_C(-1)) {
 747                 BT_ASSERT(sc->default_clock_class);
 748                 ret = bt_util_clock_cycles_to_ns_from_origin(
 749                         props.snapshots.beginning_clock,
 750                         sc->default_clock_class->frequency,
 751                         sc->default_clock_class->offset_seconds,
 752                         sc->default_clock_class->offset_cycles, &begin_ns);
 753                 if (ret) {
 754                         BT_COMP_LOGE_APPEND_CAUSE(self_comp,
 755                                 "Cannot convert clock cycles to nanoseconds from origin (`%s`).",
 756                                 path);
 757                         goto error;
 758                 }
 759         }
 760
 761         ds_file_info = ctf_fs_ds_file_info_create(path, begin_ns);
 762         if (!ds_file_info) {
 763                 goto error;
 764         }
 765
 766         index = ctf_fs_ds_file_build_index(ds_file, ds_file_info);
 767         if (!index) {
 768                 BT_COMP_LOGW("Failed to index CTF stream file \'%s\'",
 769                         ds_file->file->path->str);
 770         }
 771
 772         if (begin_ns == -1) {
 773                 /*
 774                  * No beggining timestamp to sort the stream files
 775                  * within a stream file group, so consider that this
 776                  * file must be the only one within its group.
 777                  */
 778                 stream_instance_id = -1;
 779         }
 780
 781         if (stream_instance_id == -1) {
 782                 /*
 783                  * No stream instance ID or no beginning timestamp:
 784                  * create a unique stream file group for this stream
 785                  * file because, even if there's a stream instance ID,
 786                  * there's no timestamp to order the file within its
 787                  * group.
 788                  */
 789                 ds_file_group = ctf_fs_ds_file_group_create(ctf_fs_trace,
 790                         sc, UINT64_C(-1), index);
 791                 /* Ownership of index is transferred. */
 792                 index = NULL;
 793
 794                 if (!ds_file_group) {
 795                         goto error;
 796                 }
 797
 798                 ds_file_group_insert_ds_file_info_sorted(ds_file_group, ds_file_info);
 799
 800                 add_group = true;
 801                 goto end;
 802         }
 803
 804         BT_ASSERT(stream_instance_id != -1);
 805         BT_ASSERT(begin_ns != -1);
 806
 807         /* Find an existing stream file group with this ID */
 808         for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) {
 809                 ds_file_group = g_ptr_array_index(
 810                         ctf_fs_trace->ds_file_groups, i);
 811
 812                 if (ds_file_group->sc == sc &&
 813                                 ds_file_group->stream_id ==
 814                                 stream_instance_id) {
 815                         break;
 816                 }
 817
 818                 ds_file_group = NULL;
 819         }
 820
 821         if (!ds_file_group) {
 822                 ds_file_group = ctf_fs_ds_file_group_create(ctf_fs_trace,
 823                         sc, stream_instance_id, index);
 824                 /* Ownership of index is transferred. */
 825                 index = NULL;
 826                 if (!ds_file_group) {
 827                         goto error;
 828                 }
 829
 830                 add_group = true;
 831         }
 832
 833         ds_file_group_insert_ds_file_info_sorted(ds_file_group, ds_file_info);
 834
 835         goto end;
 836
 837 error:
 838         ctf_fs_ds_file_group_destroy(ds_file_group);
 839         ds_file_group = NULL;
 840         ret = -1;
 841
 842 end:
 843         if (add_group && ds_file_group) {
 844                 g_ptr_array_add(ctf_fs_trace->ds_file_groups, ds_file_group);
 845         }
 846
 847         ctf_fs_ds_file_destroy(ds_file);
 848
 849         if (msg_iter) {
 850                 bt_msg_iter_destroy(msg_iter);
 851         }
 852
 853         ctf_fs_ds_index_destroy(index);
 854         return ret;
 855 }
 856
 857 static
 858 int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace)
 859 {
 860         int ret = 0;
 861         const char *basename;
 862         GError *error = NULL;
 863         GDir *dir = NULL;
 864         bt_logging_level log_level = ctf_fs_trace->log_level;
 865         bt_self_component *self_comp = ctf_fs_trace->self_comp;
 866
 867         /* Check each file in the path directory, except specific ones */
 868         dir = g_dir_open(ctf_fs_trace->path->str, 0, &error);
 869         if (!dir) {
 870                 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot open directory `%s`: %s (code %d)",
 871                         ctf_fs_trace->path->str, error->message,
 872                         error->code);
 873                 goto error;
 874         }
 875
 876         while ((basename = g_dir_read_name(dir))) {
 877                 struct ctf_fs_file *file;
 878
 879                 if (strcmp(basename, CTF_FS_METADATA_FILENAME) == 0) {
 880                         /* Ignore the metadata stream. */
 881                         BT_COMP_LOGI("Ignoring metadata file `%s" G_DIR_SEPARATOR_S "%s`",
 882                                 ctf_fs_trace->path->str, basename);
 883                         continue;
 884                 }
 885
 886                 if (basename[0] == '.') {
 887                         BT_COMP_LOGI("Ignoring hidden file `%s" G_DIR_SEPARATOR_S "%s`",
 888                                 ctf_fs_trace->path->str, basename);
 889                         continue;
 890                 }
 891
 892                 /* Create the file. */
 893                 file = ctf_fs_file_create(log_level, self_comp);
 894                 if (!file) {
 895                         BT_COMP_LOGE_APPEND_CAUSE(self_comp,
 896                                 "Cannot create stream file object for file `%s" G_DIR_SEPARATOR_S "%s`",
 897                                 ctf_fs_trace->path->str, basename);
 898                         goto error;
 899                 }
 900
 901                 /* Create full path string. */
 902                 g_string_append_printf(file->path, "%s" G_DIR_SEPARATOR_S "%s",
 903                                 ctf_fs_trace->path->str, basename);
 904                 if (!g_file_test(file->path->str, G_FILE_TEST_IS_REGULAR)) {
 905                         BT_COMP_LOGI("Ignoring non-regular file `%s`",
 906                                 file->path->str);
 907                         ctf_fs_file_destroy(file);
 908                         file = NULL;
 909                         continue;
 910                 }
 911
 912                 ret = ctf_fs_file_open(file, "rb");
 913                 if (ret) {
 914                         BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot open stream file `%s`",
 915                                 file->path->str);
 916                         goto error;
 917                 }
 918
 919                 if (file->size == 0) {
 920                         /* Skip empty stream. */
 921                         BT_COMP_LOGI("Ignoring empty file `%s`", file->path->str);
 922                         ctf_fs_file_destroy(file);
 923                         continue;
 924                 }
 925
 926                 ret = add_ds_file_to_ds_file_group(ctf_fs_trace,
 927                         file->path->str);
 928                 if (ret) {
 929                         BT_COMP_LOGE_APPEND_CAUSE(self_comp,
 930                                 "Cannot add stream file `%s` to stream file group",
 931                                 file->path->str);
 932                         ctf_fs_file_destroy(file);
 933                         goto error;
 934                 }
 935
 936                 ctf_fs_file_destroy(file);
 937         }
 938
 939         goto end;
 940
 941 error:
 942         ret = -1;
 943
 944 end:
 945         if (dir) {
 946                 g_dir_close(dir);
 947                 dir = NULL;
 948         }
 949
 950         if (error) {
 951                 g_error_free(error);
 952         }
 953
 954         return ret;
 955 }
 956
 957 static
 958 int set_trace_name(bt_trace *trace, const char *name_suffix,
 959                 bt_logging_level log_level, bt_self_component *self_comp)
 960 {
 961         int ret = 0;
 962         const bt_value *val;
 963         GString *name;
 964
 965         name = g_string_new(NULL);
 966         if (!name) {
 967                 BT_COMP_LOGE_STR("Failed to allocate a GString.");
 968                 ret = -1;
 969                 goto end;
 970         }
 971
 972         /*
 973          * Check if we have a trace environment string value named `hostname`.
 974          * If so, use it as the trace name's prefix.
 975          */
 976         val = bt_trace_borrow_environment_entry_value_by_name_const(
 977                 trace, "hostname");
 978         if (val && bt_value_is_string(val)) {
 979                 g_string_append(name, bt_value_string_get(val));
 980
 981                 if (name_suffix) {
 982                         g_string_append_c(name, G_DIR_SEPARATOR);
 983                 }
 984         }
 985
 986         if (name_suffix) {
 987                 g_string_append(name, name_suffix);
 988         }
 989
 990         ret = bt_trace_set_name(trace, name->str);
 991         if (ret) {
 992                 goto end;
 993         }
 994
 995         goto end;
 996
 997 end:
 998         if (name) {
 999                 g_string_free(name, TRUE);
1000         }
1001
1002         return ret;
1003 }
1004
1005 static
1006 struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component *self_comp,
1007                 const char *path, const char *name,
1008                 struct ctf_fs_metadata_config *metadata_config,
1009                 bt_logging_level log_level)
1010 {
1011         struct ctf_fs_trace *ctf_fs_trace;
1012         int ret;
1013
1014         ctf_fs_trace = g_new0(struct ctf_fs_trace, 1);
1015         if (!ctf_fs_trace) {
1016                 goto end;
1017         }
1018
1019         ctf_fs_trace->log_level = log_level;
1020         ctf_fs_trace->self_comp = self_comp;
1021         ctf_fs_trace->path = g_string_new(path);
1022         if (!ctf_fs_trace->path) {
1023                 goto error;
1024         }
1025
1026         ctf_fs_trace->metadata = g_new0(struct ctf_fs_metadata, 1);
1027         if (!ctf_fs_trace->metadata) {
1028                 goto error;
1029         }
1030
1031         ctf_fs_metadata_init(ctf_fs_trace->metadata);
1032         ctf_fs_trace->ds_file_groups = g_ptr_array_new_with_free_func(
1033                 (GDestroyNotify) ctf_fs_ds_file_group_destroy);
1034         if (!ctf_fs_trace->ds_file_groups) {
1035                 goto error;
1036         }
1037
1038         ret = ctf_fs_metadata_set_trace_class(self_comp, ctf_fs_trace,
1039                 metadata_config);
1040         if (ret) {
1041                 goto error;
1042         }
1043
1044         if (ctf_fs_trace->metadata->trace_class) {
1045                 ctf_fs_trace->trace =
1046                         bt_trace_create(ctf_fs_trace->metadata->trace_class);
1047                 if (!ctf_fs_trace->trace) {
1048                         goto error;
1049                 }
1050         }
1051
1052         if (ctf_fs_trace->trace) {
1053                 ret = ctf_trace_class_configure_ir_trace(
1054                         ctf_fs_trace->metadata->tc, ctf_fs_trace->trace);
1055                 if (ret) {
1056                         goto error;
1057                 }
1058
1059                 ret = set_trace_name(ctf_fs_trace->trace, name, log_level,
1060                         self_comp);
1061                 if (ret) {
1062                         goto error;
1063                 }
1064         }
1065
1066         ret = create_ds_file_groups(ctf_fs_trace);
1067         if (ret) {
1068                 goto error;
1069         }
1070
1071         goto end;
1072
1073 error:
1074         ctf_fs_trace_destroy(ctf_fs_trace);
1075         ctf_fs_trace = NULL;
1076
1077 end:
1078         return ctf_fs_trace;
1079 }
1080
1081 static
1082 int path_is_ctf_trace(const char *path)
1083 {
1084         GString *metadata_path = g_string_new(NULL);
1085         int ret = 0;
1086
1087         if (!metadata_path) {
1088                 ret = -1;
1089                 goto end;
1090         }
1091
1092         g_string_printf(metadata_path, "%s" G_DIR_SEPARATOR_S "%s", path, CTF_FS_METADATA_FILENAME);
1093
1094         if (g_file_test(metadata_path->str, G_FILE_TEST_IS_REGULAR)) {
1095                 ret = 1;
1096                 goto end;
1097         }
1098
1099 end:
1100         g_string_free(metadata_path, TRUE);
1101         return ret;
1102 }
1103
1104 /* Helper for ctf_fs_component_create_ctf_fs_trace, to handle a single path. */
1105
1106 static
1107 int ctf_fs_component_create_ctf_fs_trace_one_path(
1108                 struct ctf_fs_component *ctf_fs,
1109                 const char *path_param,
1110                 const char *trace_name,
1111                 GPtrArray *traces,
1112                 bt_self_component *self_comp,
1113                 bt_self_component_class *self_comp_class)
1114 {
1115         struct ctf_fs_trace *ctf_fs_trace;
1116         int ret;
1117         GString *norm_path;
1118         bt_logging_level log_level = ctf_fs->log_level;
1119
1120         norm_path = bt_common_normalize_path(path_param, NULL);
1121         if (!norm_path) {
1122                 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
1123                         "Failed to normalize path: `%s`.", path_param);
1124                 goto error;
1125         }
1126
1127         ret = path_is_ctf_trace(norm_path->str);
1128         if (ret < 0) {
1129                 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
1130                         "Failed to check if path is a CTF trace: path=%s", norm_path->str);
1131                 goto error;
1132         } else if (ret == 0) {
1133                 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
1134                         "Path is not a CTF trace (does not contain a metadata file): `%s`.", norm_path->str);
1135                 goto error;
1136         }
1137
1138         // FIXME: Remove or ifdef for __MINGW32__
1139         if (strcmp(norm_path->str, "/") == 0) {
1140                 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
1141                         "Opening a trace in `/` is not supported.");
1142                 ret = -1;
1143                 goto end;
1144         }
1145
1146         ctf_fs_trace = ctf_fs_trace_create(self_comp, norm_path->str,
1147                 trace_name, &ctf_fs->metadata_config, log_level);
1148         if (!ctf_fs_trace) {
1149                 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot create trace for `%s`.",
1150                         norm_path->str);
1151                 goto error;
1152         }
1153
1154         g_ptr_array_add(traces, ctf_fs_trace);
1155         ctf_fs_trace = NULL;
1156
1157         ret = 0;
1158         goto end;
1159
1160 error:
1161         ret = -1;
1162
1163 end:
1164         if (norm_path) {
1165                 g_string_free(norm_path, TRUE);
1166         }
1167
1168         return ret;
1169 }
1170
1171 /*
1172  * Count the number of stream and event classes defined by this trace's metadata.
1173  *
1174  * This is used to determine which metadata is the "latest", out of multiple
1175  * traces sharing the same UUID.  It is assumed that amongst all these metadatas,
1176  * a bigger metadata is a superset of a smaller metadata.  Therefore, it is
1177  * enough to just count the classes.
1178  */
1179
1180 static
1181 unsigned int metadata_count_stream_and_event_classes(struct ctf_fs_trace *trace)
1182 {
1183         unsigned int num = trace->metadata->tc->stream_classes->len;
1184         guint i;
1185
1186         for (i = 0; i < trace->metadata->tc->stream_classes->len; i++) {
1187                 struct ctf_stream_class *sc = trace->metadata->tc->stream_classes->pdata[i];
1188                 num += sc->event_classes->len;
1189         }
1190
1191         return num;
1192 }
1193
1194 /*
1195  * Merge the src ds_file_group into dest.  This consists of merging their
1196  * ds_file_infos, making sure to keep the result sorted.
1197  */
1198
1199 static
1200 void merge_ctf_fs_ds_file_groups(struct ctf_fs_ds_file_group *dest, struct ctf_fs_ds_file_group *src)
1201 {
1202         guint i;
1203
1204         for (i = 0; i < src->ds_file_infos->len; i++) {
1205                 struct ctf_fs_ds_file_info *ds_file_info =
1206                         g_ptr_array_index(src->ds_file_infos, i);
1207
1208                 /* Ownership of the ds_file_info is transferred to dest. */
1209                 g_ptr_array_index(src->ds_file_infos, i) = NULL;
1210
1211                 ds_file_group_insert_ds_file_info_sorted(dest, ds_file_info);
1212         }
1213
1214         /* Merge both indexes. */
1215         for (i = 0; i < src->index->entries->len; i++) {
1216                 struct ctf_fs_ds_index_entry *entry = g_ptr_array_index(
1217                         src->index->entries, i);
1218
1219                 /*
1220                  * Ownership of the ctf_fs_ds_index_entry is transferred to
1221                  * dest.
1222                  */
1223                 g_ptr_array_index(src->index->entries, i) = NULL;
1224
1225                 ds_file_group_insert_ds_index_entry_sorted(dest, entry);
1226         }
1227 }
1228 /* Merge src_trace's data stream file groups into dest_trace's. */
1229
1230 static
1231 int merge_matching_ctf_fs_ds_file_groups(
1232                 struct ctf_fs_trace *dest_trace,
1233                 struct ctf_fs_trace *src_trace)
1234 {
1235
1236         GPtrArray *dest = dest_trace->ds_file_groups;
1237         GPtrArray *src = src_trace->ds_file_groups;
1238         guint s_i;
1239         int ret = 0;
1240
1241         /*
1242          * Save the initial length of dest: we only want to check against the
1243          * original elements in the inner loop.
1244          */
1245         const guint dest_len = dest->len;
1246
1247         for (s_i = 0; s_i < src->len; s_i++) {
1248                 struct ctf_fs_ds_file_group *src_group = g_ptr_array_index(src, s_i);
1249                 struct ctf_fs_ds_file_group *dest_group = NULL;
1250
1251                 /* A stream instance without ID can't match a stream in the other trace.  */
1252                 if (src_group->stream_id != -1) {
1253                         guint d_i;
1254
1255                         /* Let's search for a matching ds_file_group in the destination.  */
1256                         for (d_i = 0; d_i < dest_len; d_i++) {
1257                                 struct ctf_fs_ds_file_group *candidate_dest = g_ptr_array_index(dest, d_i);
1258
1259                                 /* Can't match a stream instance without ID.  */
1260                                 if (candidate_dest->stream_id == -1) {
1261                                         continue;
1262                                 }
1263
1264                                 /*
1265                                  * If the two groups have the same stream instance id
1266                                  * and belong to the same stream class (stream instance
1267                                  * ids are per-stream class), they represent the same
1268                                  * stream instance.
1269                                  */
1270                                 if (candidate_dest->stream_id != src_group->stream_id ||
1271                                                 candidate_dest->sc->id != src_group->sc->id) {
1272                                         continue;
1273                                 }
1274
1275                                 dest_group = candidate_dest;
1276                                 break;
1277                         }
1278                 }
1279
1280                 /*
1281                  * Didn't find a friend in dest to merge our src_group into?
1282                  * Create a new empty one. This can happen if a stream was
1283                  * active in the source trace chunk but not in the destination
1284                  * trace chunk.
1285                  */
1286                 if (!dest_group) {
1287                         struct ctf_stream_class *sc;
1288                         struct ctf_fs_ds_index *index;
1289
1290                         sc = ctf_trace_class_borrow_stream_class_by_id(
1291                                 dest_trace->metadata->tc, src_group->sc->id);
1292                         BT_ASSERT(sc);
1293
1294                         index = ctf_fs_ds_index_create(dest_trace->log_level,
1295                                 dest_trace->self_comp);
1296                         if (!index) {
1297                                 ret = -1;
1298                                 goto end;
1299                         }
1300
1301                         dest_group = ctf_fs_ds_file_group_create(dest_trace, sc,
1302                                 src_group->stream_id, index);
1303                         /* Ownership of index is transferred. */
1304                         index = NULL;
1305                         if (!dest_group) {
1306                                 ret = -1;
1307                                 goto end;
1308                         }
1309
1310                         g_ptr_array_add(dest_trace->ds_file_groups, dest_group);
1311                 }
1312
1313                 BT_ASSERT(dest_group);
1314                 merge_ctf_fs_ds_file_groups(dest_group, src_group);
1315         }
1316
1317 end:
1318         return ret;
1319 }
1320
1321 /*
1322  * Collapse the given traces, which must all share the same UUID, in a single
1323  * one.
1324  *
1325  * The trace with the most expansive metadata is chosen and all other traces
1326  * are merged into that one.  The array slots of all the traces that get merged
1327  * in the chosen one are set to NULL, so only the slot of the chosen trace
1328  * remains non-NULL.
1329  */
1330
1331 static
1332 int merge_ctf_fs_traces(struct ctf_fs_trace **traces, unsigned int num_traces,
1333                 struct ctf_fs_trace **out_trace)
1334 {
1335         unsigned int winner_count;
1336         struct ctf_fs_trace *winner;
1337         guint i, winner_i;
1338         int ret = 0;
1339
1340         BT_ASSERT(num_traces >= 2);
1341
1342         winner_count = metadata_count_stream_and_event_classes(traces[0]);
1343         winner = traces[0];
1344         winner_i = 0;
1345
1346         /* Find the trace with the largest metadata. */
1347         for (i = 1; i < num_traces; i++) {
1348                 struct ctf_fs_trace *candidate;
1349                 unsigned int candidate_count;
1350
1351                 candidate = traces[i];
1352
1353                 /* A bit of sanity check. */
1354                 BT_ASSERT(bt_uuid_compare(winner->metadata->tc->uuid, candidate->metadata->tc->uuid) == 0);
1355
1356                 candidate_count = metadata_count_stream_and_event_classes(candidate);
1357
1358                 if (candidate_count > winner_count) {
1359                         winner_count = candidate_count;
1360                         winner = candidate;
1361                         winner_i = i;
1362                 }
1363         }
1364
1365         /* Merge all the other traces in the winning trace. */
1366         for (i = 0; i < num_traces; i++) {
1367                 struct ctf_fs_trace *trace = traces[i];
1368
1369                 /* Don't merge the winner into itself. */
1370                 if (trace == winner) {
1371                         continue;
1372                 }
1373
1374                 /* Merge trace's data stream file groups into winner's. */
1375                 ret = merge_matching_ctf_fs_ds_file_groups(winner, trace);
1376                 if (ret) {
1377                         goto end;
1378                 }
1379         }
1380
1381         /*
1382          * Move the winner out of the array, into `*out_trace`.
1383          */
1384         *out_trace = winner;
1385         traces[winner_i] = NULL;
1386
1387 end:
1388         return ret;
1389 }
1390
1391 enum target_event {
1392         FIRST_EVENT,
1393         LAST_EVENT,
1394 };
1395
1396 static
1397 int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace,
1398         struct ctf_clock_class *default_cc,
1399         struct ctf_fs_ds_index_entry *index_entry,
1400         enum target_event target_event, uint64_t *cs, int64_t *ts_ns)
1401 {
1402         enum bt_msg_iter_status iter_status = BT_MSG_ITER_STATUS_OK;
1403         struct ctf_fs_ds_file *ds_file = NULL;
1404         struct bt_msg_iter *msg_iter = NULL;
1405         bt_logging_level log_level = ctf_fs_trace->log_level;
1406         bt_self_component *self_comp = ctf_fs_trace->self_comp;
1407         int ret = 0;
1408
1409         BT_ASSERT(ctf_fs_trace);
1410         BT_ASSERT(ctf_fs_trace->metadata);
1411         BT_ASSERT(ctf_fs_trace->metadata->tc);
1412
1413         msg_iter = bt_msg_iter_create(ctf_fs_trace->metadata->tc,
1414                 bt_common_get_page_size(log_level) * 8, ctf_fs_ds_file_medops,
1415                 NULL, log_level, self_comp);
1416         if (!msg_iter) {
1417                 /* bt_msg_iter_create() logs errors. */
1418                 ret = -1;
1419                 goto end;
1420         }
1421
1422         BT_ASSERT(index_entry);
1423         BT_ASSERT(index_entry->path);
1424
1425         ds_file = ctf_fs_ds_file_create(ctf_fs_trace, NULL, msg_iter,
1426                 NULL, index_entry->path, log_level);
1427         if (!ds_file) {
1428                 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to create a ctf_fs_ds_file");
1429                 ret = -1;
1430                 goto end;
1431         }
1432
1433         /*
1434          * Turn on dry run mode to prevent the creation and usage of Babeltrace
1435          * library objects (bt_field, bt_message_*, etc.).
1436          */
1437         bt_msg_iter_set_dry_run(msg_iter, true);
1438
1439         /* Seek to the beginning of the target packet. */
1440         iter_status = bt_msg_iter_seek(ds_file->msg_iter, index_entry->offset);
1441         if (iter_status) {
1442                 /* bt_msg_iter_seek() logs errors. */
1443                 ret = -1;
1444                 goto end;
1445         }
1446
1447         switch (target_event) {
1448         case FIRST_EVENT:
1449                 /*
1450                  * Start to decode the packet until we reach the end of
1451                  * the first event. To extract the first event's clock
1452                  * snapshot.
1453                  */
1454                 iter_status = bt_msg_iter_curr_packet_first_event_clock_snapshot(
1455                         ds_file->msg_iter, cs);
1456                 break;
1457         case LAST_EVENT:
1458                 /* Decode the packet to extract the last event's clock snapshot. */
1459                 iter_status = bt_msg_iter_curr_packet_last_event_clock_snapshot(
1460                         ds_file->msg_iter, cs);
1461                 break;
1462         default:
1463                 abort();
1464         }
1465         if (iter_status) {
1466                 ret = -1;
1467                 goto end;
1468         }
1469
1470         /* Convert clock snapshot to timestamp. */
1471         ret = bt_util_clock_cycles_to_ns_from_origin(*cs,
1472                 default_cc->frequency, default_cc->offset_seconds,
1473                 default_cc->offset_cycles, ts_ns);
1474         if (ret) {
1475                 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1476                         "Failed to convert clock snapshot to timestamp");
1477                 goto end;
1478         }
1479
1480 end:
1481         if (ds_file) {
1482                 ctf_fs_ds_file_destroy(ds_file);
1483         }
1484         if (msg_iter) {
1485                 bt_msg_iter_destroy(msg_iter);
1486         }
1487
1488         return ret;
1489 }
1490
1491 static
1492 int decode_packet_first_event_timestamp(struct ctf_fs_trace *ctf_fs_trace,
1493         struct ctf_clock_class *default_cc,
1494         struct ctf_fs_ds_index_entry *index_entry, uint64_t *cs, int64_t *ts_ns)
1495 {
1496         return decode_clock_snapshot_after_event(ctf_fs_trace, default_cc,
1497                 index_entry, FIRST_EVENT, cs, ts_ns);
1498 }
1499
1500 static
1501 int decode_packet_last_event_timestamp(struct ctf_fs_trace *ctf_fs_trace,
1502         struct ctf_clock_class *default_cc,
1503         struct ctf_fs_ds_index_entry *index_entry, uint64_t *cs, int64_t *ts_ns)
1504 {
1505         return decode_clock_snapshot_after_event(ctf_fs_trace, default_cc,
1506                 index_entry, LAST_EVENT, cs, ts_ns);
1507 }
1508
1509 /*
1510  * Fix up packet index entries for lttng's "event-after-packet" bug.
1511  * Some buggy lttng tracer versions may emit events with a timestamp that is
1512  * larger (after) than the timestamp_end of the their packets.
1513  *
1514  * To fix up this erroneous data we do the following:
1515  *  1. If it's not the stream file's last packet: set the packet index entry's
1516  *      end time to the next packet's beginning time.
1517  *  2. If it's the stream file's last packet, set the packet index entry's end
1518  *      time to the packet's last event's time, if any, or to the packet's
1519  *      beginning time otherwise.
1520  *
1521  * Known buggy tracer versions:
1522  *  - before lttng-ust 2.11.0
1523  *  - before lttng-module 2.11.0
1524  *  - before lttng-module 2.10.10
1525  *  - before lttng-module 2.9.13
1526  */
1527 static
1528 int fix_index_lttng_event_after_packet_bug(struct ctf_fs_trace *trace)
1529 {
1530         int ret = 0;
1531         guint ds_file_group_i;
1532         GPtrArray *ds_file_groups = trace->ds_file_groups;
1533         bt_logging_level log_level = trace->log_level;
1534
1535         for (ds_file_group_i = 0; ds_file_group_i < ds_file_groups->len;
1536                         ds_file_group_i++) {
1537                 guint entry_i;
1538                 struct ctf_clock_class *default_cc;
1539                 struct ctf_fs_ds_index_entry *last_entry;
1540                 struct ctf_fs_ds_index *index;
1541
1542                 struct ctf_fs_ds_file_group *ds_file_group =
1543                         g_ptr_array_index(ds_file_groups, ds_file_group_i);
1544
1545                 BT_ASSERT(ds_file_group);
1546                 index = ds_file_group->index;
1547
1548                 BT_ASSERT(index);
1549                 BT_ASSERT(index->entries);
1550                 BT_ASSERT(index->entries->len > 0);
1551
1552                 /*
1553                  * Iterate over all entries but the last one. The last one is
1554                  * fixed differently after.
1555                  */
1556                 for (entry_i = 0; entry_i < index->entries->len - 1;
1557                                 entry_i++) {
1558                         struct ctf_fs_ds_index_entry *curr_entry, *next_entry;
1559
1560                         curr_entry = g_ptr_array_index(index->entries, entry_i);
1561                         next_entry = g_ptr_array_index(index->entries, entry_i + 1);
1562
1563                         /*
1564                          * 1. Set the current index entry `end` timestamp to
1565                          * the next index entry `begin` timestamp.
1566                          */
1567                         curr_entry->timestamp_end = next_entry->timestamp_begin;
1568                         curr_entry->timestamp_end_ns = next_entry->timestamp_begin_ns;
1569                 }
1570
1571                 /*
1572                  * 2. Fix the last entry by decoding the last event of the last
1573                  * packet.
1574                  */
1575                 last_entry = g_ptr_array_index(index->entries,
1576                         index->entries->len - 1);
1577                 BT_ASSERT(last_entry);
1578
1579                 BT_ASSERT(ds_file_group->sc->default_clock_class);
1580                 default_cc = ds_file_group->sc->default_clock_class;
1581
1582                 /*
1583                  * Decode packet to read the timestamp of the last event of the
1584                  * entry.
1585                  */
1586                 ret = decode_packet_last_event_timestamp(trace, default_cc,
1587                         last_entry, &last_entry->timestamp_end,
1588                         &last_entry->timestamp_end_ns);
1589                 if (ret) {
1590                         BT_COMP_LOGE_APPEND_CAUSE(trace->self_comp,
1591                                 "Failed to decode stream's last packet to get its last event's clock snapshot.");
1592                         goto end;
1593                 }
1594         }
1595
1596 end:
1597         return ret;
1598 }
1599
1600 /*
1601  * Fix up packet index entries for barectf's "event-before-packet" bug.
1602  * Some buggy barectf tracer versions may emit events with a timestamp that is
1603  * less than the timestamp_begin of the their packets.
1604  *
1605  * To fix up this erroneous data we do the following:
1606  *  1. Starting at the second index entry, set the timestamp_begin of the
1607  *     current entry to the timestamp of the first event of the packet.
1608  *  2. Set the previous entry's timestamp_end to the timestamp_begin of the
1609  *     current packet.
1610  *
1611  * Known buggy tracer versions:
1612  *  - before barectf 2.3.1
1613  */
1614 static
1615 int fix_index_barectf_event_before_packet_bug(struct ctf_fs_trace *trace)
1616 {
1617         int ret = 0;
1618         guint ds_file_group_i;
1619         GPtrArray *ds_file_groups = trace->ds_file_groups;
1620         bt_logging_level log_level = trace->log_level;
1621
1622         for (ds_file_group_i = 0; ds_file_group_i < ds_file_groups->len;
1623                         ds_file_group_i++) {
1624                 guint entry_i;
1625                 struct ctf_clock_class *default_cc;
1626                 struct ctf_fs_ds_file_group *ds_file_group =
1627                         g_ptr_array_index(ds_file_groups, ds_file_group_i);
1628
1629                 struct ctf_fs_ds_index *index = ds_file_group->index;
1630
1631                 BT_ASSERT(index);
1632                 BT_ASSERT(index->entries);
1633                 BT_ASSERT(index->entries->len > 0);
1634
1635                 BT_ASSERT(ds_file_group->sc->default_clock_class);
1636                 default_cc = ds_file_group->sc->default_clock_class;
1637
1638                 /*
1639                  * 1. Iterate over the index, starting from the second entry
1640                  * (index = 1).
1641                  */
1642                 for (entry_i = 1; entry_i < index->entries->len;
1643                                 entry_i++) {
1644                         struct ctf_fs_ds_index_entry *curr_entry, *prev_entry;
1645                         prev_entry = g_ptr_array_index(index->entries, entry_i - 1);
1646                         curr_entry = g_ptr_array_index(index->entries, entry_i);
1647                         /*
1648                          * 2. Set the current entry `begin` timestamp to the
1649                          * timestamp of the first event of the current packet.
1650                          */
1651                         ret = decode_packet_first_event_timestamp(trace, default_cc,
1652                                 curr_entry, &curr_entry->timestamp_begin,
1653                                 &curr_entry->timestamp_begin_ns);
1654                         if (ret) {
1655                                 BT_COMP_LOGE_APPEND_CAUSE(trace->self_comp,
1656                                         "Failed to decode first event's clock snapshot");
1657                                 goto end;
1658                         }
1659
1660                         /*
1661                          * 3. Set the previous entry `end` timestamp to the
1662                          * timestamp of the first event of the current packet.
1663                          */
1664                         prev_entry->timestamp_end = curr_entry->timestamp_begin;
1665                         prev_entry->timestamp_end_ns = curr_entry->timestamp_begin_ns;
1666                 }
1667         }
1668 end:
1669         return ret;
1670 }
1671
1672 /*
1673  * When using the lttng-crash feature it's likely that the last packets of each
1674  * stream have their timestamp_end set to zero. This is caused by the fact that
1675  * the tracer crashed and was not able to properly close the packets.
1676  *
1677  * To fix up this erroneous data we do the following:
1678  * For each index entry, if the entry's timestamp_end is 0 and the
1679  * timestamp_begin is not 0:
1680  *  - If it's the stream file's last packet: set the packet index entry's end
1681  *    time to the packet's last event's time, if any, or to the packet's
1682  *    beginning time otherwise.
1683  *  - If it's not the stream file's last packet: set the packet index
1684  *    entry's end time to the next packet's beginning time.
1685  *
1686  * Affected versions:
1687  * - All current and future lttng-ust and lttng-modules versions.
1688  */
1689 static
1690 int fix_index_lttng_crash_quirk(struct ctf_fs_trace *trace)
1691 {
1692         int ret = 0;
1693         guint ds_file_group_idx;
1694         GPtrArray *ds_file_groups = trace->ds_file_groups;
1695         bt_logging_level log_level = trace->log_level;
1696
1697         for (ds_file_group_idx = 0; ds_file_group_idx < ds_file_groups->len;
1698                         ds_file_group_idx++) {
1699                 guint entry_idx;
1700                 struct ctf_clock_class *default_cc;
1701                 struct ctf_fs_ds_index_entry *last_entry;
1702                 struct ctf_fs_ds_index *index;
1703
1704                 struct ctf_fs_ds_file_group *ds_file_group =
1705                         g_ptr_array_index(ds_file_groups, ds_file_group_idx);
1706
1707                 BT_ASSERT(ds_file_group);
1708                 index = ds_file_group->index;
1709
1710                 BT_ASSERT(ds_file_group->sc->default_clock_class);
1711                 default_cc = ds_file_group->sc->default_clock_class;
1712
1713                 BT_ASSERT(index);
1714                 BT_ASSERT(index->entries);
1715                 BT_ASSERT(index->entries->len > 0);
1716
1717                 last_entry = g_ptr_array_index(index->entries,
1718                         index->entries->len - 1);
1719                 BT_ASSERT(last_entry);
1720
1721
1722                 /* 1. Fix the last entry first. */
1723                 if (last_entry->timestamp_end == 0 &&
1724                                 last_entry->timestamp_begin != 0) {
1725                         /*
1726                          * Decode packet to read the timestamp of the
1727                          * last event of the stream file.
1728                          */
1729                         ret = decode_packet_last_event_timestamp(trace,
1730                                 default_cc, last_entry,
1731                                 &last_entry->timestamp_end,
1732                                 &last_entry->timestamp_end_ns);
1733                         if (ret) {
1734                                 BT_COMP_LOGE_APPEND_CAUSE(trace->self_comp,
1735                                         "Failed to decode last event's clock snapshot");
1736                                 goto end;
1737                         }
1738                 }
1739
1740                 /* Iterate over all entries but the last one. */
1741                 for (entry_idx = 0; entry_idx < index->entries->len - 1;
1742                                 entry_idx++) {
1743                         struct ctf_fs_ds_index_entry *curr_entry, *next_entry;
1744                         curr_entry = g_ptr_array_index(index->entries, entry_idx);
1745                         next_entry = g_ptr_array_index(index->entries, entry_idx + 1);
1746
1747                         if (curr_entry->timestamp_end == 0 &&
1748                                         curr_entry->timestamp_begin != 0) {
1749                                 /*
1750                                  * 2. Set the current index entry `end` timestamp to
1751                                  * the next index entry `begin` timestamp.
1752                                  */
1753                                 curr_entry->timestamp_end = next_entry->timestamp_begin;
1754                                 curr_entry->timestamp_end_ns = next_entry->timestamp_begin_ns;
1755                         }
1756                 }
1757         }
1758
1759 end:
1760         return ret;
1761 }
1762
1763 /*
1764  * Extract the tracer information necessary to compare versions.
1765  * Returns 0 on success, and -1 if the extraction is not successful because the
1766  * necessary fields are absents in the trace metadata.
1767  */
1768 static
1769 int extract_tracer_info(struct ctf_fs_trace *trace,
1770                 struct tracer_info *current_tracer_info)
1771 {
1772         int ret = 0;
1773         struct ctf_trace_class_env_entry *entry;
1774
1775         /* Clear the current_tracer_info struct */
1776         memset(current_tracer_info, 0, sizeof(*current_tracer_info));
1777
1778         /*
1779          * To compare 2 tracer versions, at least the tracer name and it's
1780          * major version are needed. If one of these is missing, consider it an
1781          * extraction failure.
1782          */
1783         entry = ctf_trace_class_borrow_env_entry_by_name(
1784                 trace->metadata->tc, "tracer_name");
1785         if (!entry || entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_STR) {
1786                 goto missing_bare_minimum;
1787         }
1788
1789         /* Set tracer name. */
1790         current_tracer_info->name = entry->value.str->str;
1791
1792         entry = ctf_trace_class_borrow_env_entry_by_name(
1793                 trace->metadata->tc, "tracer_major");
1794         if (!entry || entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT) {
1795                 goto missing_bare_minimum;
1796         }
1797
1798         /* Set major version number. */
1799         current_tracer_info->major = entry->value.i;
1800
1801         entry = ctf_trace_class_borrow_env_entry_by_name(
1802                 trace->metadata->tc, "tracer_minor");
1803         if (!entry || entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT) {
1804                 goto end;
1805         }
1806
1807         /* Set minor version number. */
1808         current_tracer_info->minor = entry->value.i;
1809
1810         entry = ctf_trace_class_borrow_env_entry_by_name(
1811                 trace->metadata->tc, "tracer_patch");
1812         if (!entry) {
1813                 /*
1814                  * If `tracer_patch` doesn't exist `tracer_patchlevel` might.
1815                  * For example, `lttng-modules` uses entry name
1816                  * `tracer_patchlevel`.
1817                  */
1818                 entry = ctf_trace_class_borrow_env_entry_by_name(
1819                         trace->metadata->tc, "tracer_patchlevel");
1820         }
1821
1822         if (!entry || entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT) {
1823                 goto end;
1824         }
1825
1826         /* Set patch version number. */
1827         current_tracer_info->patch = entry->value.i;
1828
1829         goto end;
1830
1831 missing_bare_minimum:
1832         ret = -1;
1833 end:
1834         return ret;
1835 }
1836
1837 static
1838 bool is_tracer_affected_by_lttng_event_after_packet_bug(
1839                 struct tracer_info *curr_tracer_info)
1840 {
1841         bool is_affected = false;
1842
1843         if (strcmp(curr_tracer_info->name, "lttng-ust") == 0) {
1844                 if (curr_tracer_info->major < 2) {
1845                         is_affected = true;
1846                 } else if (curr_tracer_info->major == 2) {
1847                         /* fixed in lttng-ust 2.11.0 */
1848                         if (curr_tracer_info->minor < 11) {
1849                                 is_affected = true;
1850                         }
1851                 }
1852         } else if (strcmp(curr_tracer_info->name, "lttng-modules") == 0) {
1853                 if (curr_tracer_info->major < 2) {
1854                         is_affected = true;
1855                 } else if (curr_tracer_info->major == 2) {
1856                         /* fixed in lttng-modules 2.11.0 */
1857                         if (curr_tracer_info->minor == 10) {
1858                                 /* fixed in lttng-modules 2.10.10 */
1859                                 if (curr_tracer_info->patch < 10) {
1860                                         is_affected = true;
1861                                 }
1862                         } else if (curr_tracer_info->minor == 9) {
1863                                 /* fixed in lttng-modules 2.9.13 */
1864                                 if (curr_tracer_info->patch < 13) {
1865                                         is_affected = true;
1866                                 }
1867                         } else if (curr_tracer_info->minor < 9) {
1868                                 is_affected = true;
1869                         }
1870                 }
1871         }
1872
1873         return is_affected;
1874 }
1875
1876 static
1877 bool is_tracer_affected_by_barectf_event_before_packet_bug(
1878                 struct tracer_info *curr_tracer_info)
1879 {
1880         bool is_affected = false;
1881
1882         if (strcmp(curr_tracer_info->name, "barectf") == 0) {
1883                 if (curr_tracer_info->major < 2) {
1884                         is_affected = true;
1885                 } else if (curr_tracer_info->major == 2) {
1886                         if (curr_tracer_info->minor < 3) {
1887                                 is_affected = true;
1888                         } else if (curr_tracer_info->minor == 3) {
1889                                 /* fixed in barectf 2.3.1 */
1890                                 if (curr_tracer_info->patch < 1) {
1891                                         is_affected = true;
1892                                 }
1893                         }
1894                 }
1895         }
1896
1897         return is_affected;
1898 }
1899
1900 static
1901 bool is_tracer_affected_by_lttng_crash_quirk(
1902                 struct tracer_info *curr_tracer_info)
1903 {
1904         bool is_affected = false;
1905
1906         /* All LTTng tracer may be affected by this lttng crash quirk. */
1907         if (strcmp(curr_tracer_info->name, "lttng-ust") == 0) {
1908                 is_affected = true;
1909         } else if (strcmp(curr_tracer_info->name, "lttng-modules") == 0) {
1910                 is_affected = true;
1911         }
1912
1913         return is_affected;
1914 }
1915
1916 /*
1917  * Looks for trace produced by known buggy tracers and fix up the index
1918  * produced earlier.
1919  */
1920 static
1921 int fix_packet_index_tracer_bugs(struct ctf_fs_component *ctf_fs,
1922                 bt_self_component *self_comp)
1923 {
1924         int ret = 0;
1925         struct tracer_info current_tracer_info;
1926         bt_logging_level log_level = ctf_fs->log_level;
1927
1928         ret = extract_tracer_info(ctf_fs->trace, &current_tracer_info);
1929         if (ret) {
1930                 /*
1931                  * A trace may not have all the necessary environment
1932                  * entries to do the tracer version comparison.
1933                  * At least, the tracer name and major version number
1934                  * are needed. Failing to extract these entries is not
1935                  * an error.
1936                  */
1937                 ret = 0;
1938                 BT_LOGI_STR("Cannot extract tracer information necessary to compare with buggy versions.");
1939                 goto end;;
1940         }
1941
1942         /* Check if the trace may be affected by old tracer bugs. */
1943         if (is_tracer_affected_by_lttng_event_after_packet_bug(
1944                         &current_tracer_info)) {
1945                 BT_LOGI_STR("Trace may be affected by LTTng tracer packet timestamp bug. Fixing up.");
1946                 ret = fix_index_lttng_event_after_packet_bug(ctf_fs->trace);
1947                 if (ret) {
1948                         BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1949                                 "Failed to fix LTTng event-after-packet bug.");
1950                         goto end;
1951                 }
1952                 ctf_fs->trace->metadata->tc->quirks.lttng_event_after_packet = true;
1953         }
1954
1955         if (is_tracer_affected_by_barectf_event_before_packet_bug(
1956                         &current_tracer_info)) {
1957                 BT_LOGI_STR("Trace may be affected by barectf tracer packet timestamp bug. Fixing up.");
1958                 ret = fix_index_barectf_event_before_packet_bug(ctf_fs->trace);
1959                 if (ret) {
1960                         BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1961                                 "Failed to fix barectf event-before-packet bug.");
1962                         goto end;
1963                 }
1964                 ctf_fs->trace->metadata->tc->quirks.barectf_event_before_packet = true;
1965         }
1966
1967         if (is_tracer_affected_by_lttng_crash_quirk(
1968                         &current_tracer_info)) {
1969                 ret = fix_index_lttng_crash_quirk(ctf_fs->trace);
1970                 if (ret) {
1971                         BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1972                                 "Failed to fix lttng-crash timestamp quirks.");
1973                         goto end;
1974                 }
1975                 ctf_fs->trace->metadata->tc->quirks.lttng_crash = true;
1976         }
1977
1978 end:
1979         return ret;
1980 }
1981
1982 static
1983 gint compare_ds_file_groups_by_first_path(gconstpointer a, gconstpointer b)
1984 {
1985         struct ctf_fs_ds_file_group * const *ds_file_group_a = a;
1986         struct ctf_fs_ds_file_group * const *ds_file_group_b = b;
1987         const struct ctf_fs_ds_file_info *first_ds_file_info_a;
1988         const struct ctf_fs_ds_file_info *first_ds_file_info_b;
1989
1990         BT_ASSERT((*ds_file_group_a)->ds_file_infos->len > 0);
1991         BT_ASSERT((*ds_file_group_b)->ds_file_infos->len > 0);
1992         first_ds_file_info_a = (*ds_file_group_a)->ds_file_infos->pdata[0];
1993         first_ds_file_info_b = (*ds_file_group_b)->ds_file_infos->pdata[0];
1994         return strcmp(first_ds_file_info_a->path->str,
1995                 first_ds_file_info_b->path->str);
1996 }
1997
1998 int ctf_fs_component_create_ctf_fs_trace(
1999                 struct ctf_fs_component *ctf_fs,
2000                 const bt_value *paths_value,
2001                 const bt_value *trace_name_value,
2002                 bt_self_component *self_comp,
2003                 bt_self_component_class *self_comp_class)
2004 {
2005         int ret = 0;
2006         uint64_t i;
2007         bt_logging_level log_level = ctf_fs->log_level;
2008         GPtrArray *traces;
2009         const char *trace_name;
2010
2011         BT_ASSERT(bt_value_get_type(paths_value) == BT_VALUE_TYPE_ARRAY);
2012         BT_ASSERT(!bt_value_array_is_empty(paths_value));
2013
2014         traces = g_ptr_array_new_with_free_func(ctf_fs_trace_destroy_notifier);
2015         if (!traces) {
2016                 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
2017                         "Failed to allocate a GPtrArray.");
2018                 goto error;
2019         }
2020
2021         trace_name = trace_name_value ? bt_value_string_get(trace_name_value) : NULL;
2022
2023         /* Start by creating a separate ctf_fs_trace object for each path. */
2024         for (i = 0; i < bt_value_array_get_length(paths_value); i++) {
2025                 const bt_value *path_value = bt_value_array_borrow_element_by_index_const(paths_value, i);
2026                 const char *input = bt_value_string_get(path_value);
2027
2028                 ret = ctf_fs_component_create_ctf_fs_trace_one_path(ctf_fs,
2029                         input, trace_name, traces, self_comp, self_comp_class);
2030                 if (ret) {
2031                         goto end;
2032                 }
2033         }
2034
2035         if (traces->len > 1) {
2036                 struct ctf_fs_trace *first_trace = (struct ctf_fs_trace *) traces->pdata[0];
2037                 const uint8_t *first_trace_uuid = first_trace->metadata->tc->uuid;
2038                 struct ctf_fs_trace *trace;
2039
2040                 /*
2041                  * We have more than one trace, they must all share the same
2042                  * UUID, verify that.
2043                  */
2044                 for (i = 0; i < traces->len; i++) {
2045                         struct ctf_fs_trace *this_trace =
2046                                 (struct ctf_fs_trace *) traces->pdata[i];
2047                         const uint8_t *this_trace_uuid = this_trace->metadata->tc->uuid;
2048
2049                         if (!this_trace->metadata->tc->is_uuid_set) {
2050                                 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
2051                                         "Multiple traces given, but a trace does not have a UUID: path=%s",
2052                                         this_trace->path->str);
2053                                 goto error;
2054                         }
2055
2056                         if (bt_uuid_compare(first_trace_uuid, this_trace_uuid) != 0) {
2057                                 char first_trace_uuid_str[BT_UUID_STR_LEN + 1];
2058                                 char this_trace_uuid_str[BT_UUID_STR_LEN + 1];
2059
2060                                 bt_uuid_to_str(first_trace_uuid, first_trace_uuid_str);
2061                                 bt_uuid_to_str(this_trace_uuid, this_trace_uuid_str);
2062
2063                                 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
2064                                         "Multiple traces given, but UUIDs don't match: "
2065                                         "first-trace-uuid=%s, first-trace-path=%s, "
2066                                         "trace-uuid=%s, trace-path=%s",
2067                                         first_trace_uuid_str, first_trace->path->str,
2068                                         this_trace_uuid_str, this_trace->path->str);
2069                                 goto error;
2070                         }
2071                 }
2072
2073                 ret = merge_ctf_fs_traces((struct ctf_fs_trace **) traces->pdata,
2074                         traces->len, &trace);
2075                 if (ret) {
2076                         BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
2077                                 "Failed to merge traces with the same UUID.");
2078                         goto error;
2079                 }
2080
2081                 ctf_fs->trace = trace;
2082         } else {
2083                 /* Just one trace, it may or may not have a UUID, both are fine. */
2084                 ctf_fs->trace = traces->pdata[0];
2085                 traces->pdata[0] = NULL;
2086         }
2087
2088         ret = fix_packet_index_tracer_bugs(ctf_fs, self_comp);
2089         if (ret) {
2090                 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
2091                         "Failed to fix packet index tracer bugs.");
2092         }
2093
2094         /*
2095          * Sort data stream file groups by first data stream file info
2096          * path to get a deterministic order. This order influences the
2097          * order of the output ports. It also influences the order of
2098          * the automatic stream IDs if the trace's packet headers do not
2099          * contain a `stream_instance_id` field, in which case the data
2100          * stream file to stream ID association is always the same,
2101          * whatever the build and the system.
2102          *
2103          * Having a deterministic order here can help debugging and
2104          * testing.
2105          */
2106         g_ptr_array_sort(ctf_fs->trace->ds_file_groups,
2107                 compare_ds_file_groups_by_first_path);
2108         goto end;
2109 error:
2110         ret = -1;
2111
2112 end:
2113         g_ptr_array_free(traces, TRUE);
2114         return ret;
2115 }
2116
2117 static
2118 GString *get_stream_instance_unique_name(
2119                 struct ctf_fs_ds_file_group *ds_file_group)
2120 {
2121         GString *name;
2122         struct ctf_fs_ds_file_info *ds_file_info;
2123
2124         name = g_string_new(NULL);
2125         if (!name) {
2126                 goto end;
2127         }
2128
2129         /*
2130          * If there's more than one stream file in the stream file
2131          * group, the first (earliest) stream file's path is used as
2132          * the stream's unique name.
2133          */
2134         BT_ASSERT(ds_file_group->ds_file_infos->len > 0);
2135         ds_file_info = g_ptr_array_index(ds_file_group->ds_file_infos, 0);
2136         g_string_assign(name, ds_file_info->path->str);
2137
2138 end:
2139         return name;
2140 }
2141
2142 /* Create the IR stream objects for ctf_fs_trace. */
2143
2144 static
2145 int create_streams_for_trace(struct ctf_fs_trace *ctf_fs_trace)
2146 {
2147         int ret;
2148         GString *name = NULL;
2149         guint i;
2150         bt_logging_level log_level = ctf_fs_trace->log_level;
2151         bt_self_component *self_comp = ctf_fs_trace->self_comp;
2152
2153         for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) {
2154                 struct ctf_fs_ds_file_group *ds_file_group =
2155                         g_ptr_array_index(ctf_fs_trace->ds_file_groups, i);
2156                 name = get_stream_instance_unique_name(ds_file_group);
2157
2158                 if (!name) {
2159                         goto error;
2160                 }
2161
2162                 if (ds_file_group->sc->ir_sc) {
2163                         BT_ASSERT(ctf_fs_trace->trace);
2164
2165                         if (ds_file_group->stream_id == UINT64_C(-1)) {
2166                                 /* No stream ID: use 0 */
2167                                 ds_file_group->stream = bt_stream_create_with_id(
2168                                         ds_file_group->sc->ir_sc,
2169                                         ctf_fs_trace->trace,
2170                                         ctf_fs_trace->next_stream_id);
2171                                 ctf_fs_trace->next_stream_id++;
2172                         } else {
2173                                 /* Specific stream ID */
2174                                 ds_file_group->stream = bt_stream_create_with_id(
2175                                         ds_file_group->sc->ir_sc,
2176                                         ctf_fs_trace->trace,
2177                                         (uint64_t) ds_file_group->stream_id);
2178                         }
2179                 } else {
2180                         ds_file_group->stream = NULL;
2181                 }
2182
2183                 if (!ds_file_group->stream) {
2184                         BT_COMP_LOGE_APPEND_CAUSE(self_comp,
2185                                 "Cannot create stream for DS file group: "
2186                                 "addr=%p, stream-name=\"%s\"",
2187                                 ds_file_group, name->str);
2188                         goto error;
2189                 }
2190
2191                 ret = bt_stream_set_name(ds_file_group->stream,
2192                         name->str);
2193                 if (ret) {
2194                         BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot set stream's name: "
2195                                 "addr=%p, stream-name=\"%s\"",
2196                                 ds_file_group->stream, name->str);
2197                         goto error;
2198                 }
2199
2200                 g_string_free(name, TRUE);
2201                 name = NULL;
2202         }
2203
2204         ret = 0;
2205         goto end;
2206
2207 error:
2208         ret = -1;
2209
2210 end:
2211
2212         if (name) {
2213                 g_string_free(name, TRUE);
2214         }
2215         return ret;
2216 }
2217
2218 static const struct bt_param_validation_value_descr inputs_elem_descr = {
2219         .type = BT_VALUE_TYPE_STRING,
2220 };
2221
2222 static const struct bt_param_validation_map_value_entry_descr fs_params_entries_descr[] = {
2223         { "inputs", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_MANDATORY, {
2224                 BT_VALUE_TYPE_ARRAY,
2225                 .array = {
2226                         .min_length = 1,
2227                         .max_length = BT_PARAM_VALIDATION_INFINITE,
2228                         .element_type = &inputs_elem_descr,
2229                 }
2230         }},
2231         { "trace-name", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_STRING } },
2232         { "clock-class-offset-s", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_SIGNED_INTEGER } },
2233         { "clock-class-offset-ns", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_SIGNED_INTEGER } },
2234         { "force-clock-class-origin-unix-epoch", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
2235         BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_END
2236 };
2237
2238
2239 bool read_src_fs_parameters(const bt_value *params,
2240                 const bt_value **inputs,
2241                 const bt_value **trace_name,
2242                 struct ctf_fs_component *ctf_fs,
2243                 bt_self_component *self_comp,
2244                 bt_self_component_class *self_comp_class) {
2245         bool ret;
2246         const bt_value *value;
2247         bt_logging_level log_level = ctf_fs->log_level;
2248         enum bt_param_validation_status validate_value_status;
2249         gchar *error = NULL;
2250
2251         validate_value_status = bt_param_validation_validate(params,
2252                 fs_params_entries_descr, &error);
2253         if (validate_value_status != BT_PARAM_VALIDATION_STATUS_OK) {
2254                 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
2255                         "%s", error);
2256                 ret = false;
2257                 goto end;
2258         }
2259
2260         /* inputs parameter */
2261         *inputs = bt_value_map_borrow_entry_value_const(params, "inputs");
2262
2263         /* clock-class-offset-s parameter */
2264         value = bt_value_map_borrow_entry_value_const(params,
2265                 "clock-class-offset-s");
2266         if (value) {
2267                 ctf_fs->metadata_config.clock_class_offset_s =
2268                         bt_value_integer_signed_get(value);
2269         }
2270
2271         /* clock-class-offset-ns parameter */
2272         value = bt_value_map_borrow_entry_value_const(params,
2273                 "clock-class-offset-ns");
2274         if (value) {
2275                 ctf_fs->metadata_config.clock_class_offset_ns =
2276                         bt_value_integer_signed_get(value);
2277         }
2278
2279         /* force-clock-class-origin-unix-epoch parameter */
2280         value = bt_value_map_borrow_entry_value_const(params,
2281                 "force-clock-class-origin-unix-epoch");
2282         if (value) {
2283                 ctf_fs->metadata_config.force_clock_class_origin_unix_epoch =
2284                         bt_value_bool_get(value);
2285         }
2286
2287         /* trace-name parameter */
2288         *trace_name = bt_value_map_borrow_entry_value_const(params, "trace-name");
2289
2290         ret = true;
2291
2292 end:
2293         g_free(error);
2294         return ret;
2295 }
2296
2297 static
2298 struct ctf_fs_component *ctf_fs_create(
2299         const bt_value *params,
2300         bt_self_component_source *self_comp_src,
2301         bt_self_component_class *self_comp_class)
2302 {
2303         struct ctf_fs_component *ctf_fs = NULL;
2304         const bt_value *inputs_value;
2305         const bt_value *trace_name_value;
2306         bt_self_component *self_comp =
2307                 bt_self_component_source_as_self_component(self_comp_src);
2308
2309         ctf_fs = ctf_fs_component_create(bt_component_get_logging_level(
2310                 bt_self_component_as_component(self_comp)), self_comp);
2311         if (!ctf_fs) {
2312                 goto error;
2313         }
2314
2315         if (!read_src_fs_parameters(params, &inputs_value, &trace_name_value,
2316                         ctf_fs, self_comp, self_comp_class)) {
2317                 goto error;
2318         }
2319
2320         bt_self_component_set_data(self_comp, ctf_fs);
2321
2322         if (ctf_fs_component_create_ctf_fs_trace(ctf_fs, inputs_value,
2323                         trace_name_value, self_comp, self_comp_class)) {
2324                 goto error;
2325         }
2326
2327         if (create_streams_for_trace(ctf_fs->trace)) {
2328                 goto error;
2329         }
2330
2331         if (create_ports_for_trace(ctf_fs, ctf_fs->trace, self_comp_src)) {
2332                 goto error;
2333         }
2334
2335         goto end;
2336
2337 error:
2338         ctf_fs_destroy(ctf_fs);
2339         ctf_fs = NULL;
2340         bt_self_component_set_data(self_comp, NULL);
2341
2342 end:
2343         return ctf_fs;
2344 }
2345
2346 BT_HIDDEN
2347 bt_component_class_initialize_method_status ctf_fs_init(
2348                 bt_self_component_source *self_comp_src,
2349                 bt_self_component_source_configuration *config,
2350                 const bt_value *params, __attribute__((unused)) void *init_method_data)
2351 {
2352         struct ctf_fs_component *ctf_fs;
2353         bt_component_class_initialize_method_status ret =
2354                 BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
2355
2356         ctf_fs = ctf_fs_create(params, self_comp_src, NULL);
2357         if (!ctf_fs) {
2358                 ret = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
2359         }
2360
2361         return ret;
2362 }
2363
2364 BT_HIDDEN
2365 bt_component_class_query_method_status ctf_fs_query(
2366                 bt_self_component_class_source *comp_class,
2367                 bt_private_query_executor *priv_query_exec,
2368                 const char *object, const bt_value *params,
2369                 __attribute__((unused)) void *method_data,
2370                 const bt_value **result)
2371 {
2372         bt_component_class_query_method_status status =
2373                 BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
2374         bt_logging_level log_level = bt_query_executor_get_logging_level(
2375                 bt_private_query_executor_as_query_executor_const(
2376                         priv_query_exec));
2377
2378         if (strcmp(object, "metadata-info") == 0) {
2379                 status = metadata_info_query(comp_class, params, log_level,
2380                         result);
2381         } else if (strcmp(object, "babeltrace.trace-infos") == 0) {
2382                 status = trace_infos_query(comp_class, params, log_level,
2383                         result);
2384         } else if (!strcmp(object, "babeltrace.support-info")) {
2385                 status = support_info_query(comp_class, params, log_level, result);
2386         } else {
2387                 BT_LOGE("Unknown query object `%s`", object);
2388                 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_UNKNOWN_OBJECT;
2389                 goto end;
2390         }
2391 end:
2392         return status;
2393 }