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