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