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