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