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