projects / babeltrace.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
lib: make can_seek_ns_from_origin logic use `can_seek_forward` property of iterator
[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_initialize_method_status ctf_fs_iterator_init(
252 bt_self_message_iterator *self_msg_iter,
253 bt_self_message_iterator_configuration *config,
254 bt_self_component_source *self_comp_src,
255 bt_self_component_port_output *self_port)
256 {
257 struct ctf_fs_port_data *port_data;
258 struct ctf_fs_msg_iter_data *msg_iter_data = NULL;
259 bt_component_class_message_iterator_initialize_method_status ret =
260 BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INITIALIZE_METHOD_STATUS_OK;
261 bt_logging_level log_level;
262 bt_self_component *self_comp =
263 bt_self_component_source_as_self_component(self_comp_src);
264
265 port_data = bt_self_component_port_get_data(
266 bt_self_component_port_output_as_self_component_port(
267 self_port));
268 BT_ASSERT(port_data);
269 log_level = port_data->ctf_fs->log_level;
270 msg_iter_data = g_new0(struct ctf_fs_msg_iter_data, 1);
271 if (!msg_iter_data) {
272 ret = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
273 goto error;
274 }
275
276 msg_iter_data->log_level = log_level;
277 msg_iter_data->self_comp = self_comp;
278 msg_iter_data->pc_msg_iter = self_msg_iter;
279 msg_iter_data->msg_iter = bt_msg_iter_create(
280 port_data->ds_file_group->ctf_fs_trace->metadata->tc,
281 bt_common_get_page_size(msg_iter_data->log_level) * 8,
282 ctf_fs_ds_file_medops, NULL, msg_iter_data->log_level,
283 self_comp);
284 if (!msg_iter_data->msg_iter) {
285 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot create a CTF message iterator.");
286 ret = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
287 goto error;
288 }
289
290 msg_iter_data->ds_file_group = port_data->ds_file_group;
291 if (ctf_fs_iterator_reset(msg_iter_data)) {
292 ret = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INITIALIZE_METHOD_STATUS_ERROR;
293 goto error;
294 }
295
296 /*
297 * This iterator can seek forward if its stream class has a default
298 * clock class.
299 */
300 if (msg_iter_data->ds_file_group->sc->default_clock_class) {
301 bt_self_message_iterator_configuration_set_can_seek_forward(
302 config, true);
303 }
304
305 bt_self_message_iterator_set_data(self_msg_iter,
306 msg_iter_data);
307 if (ret != BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INITIALIZE_METHOD_STATUS_OK) {
308 goto error;
309 }
310 msg_iter_data = NULL;
311 goto end;
312
313 error:
314 bt_self_message_iterator_set_data(self_msg_iter, NULL);
315
316 end:
317 ctf_fs_msg_iter_data_destroy(msg_iter_data);
318 return ret;
319 }
320
321 static
322 void ctf_fs_trace_destroy(struct ctf_fs_trace *ctf_fs_trace)
323 {
324 if (!ctf_fs_trace) {
325 return;
326 }
327
328 if (ctf_fs_trace->ds_file_groups) {
329 g_ptr_array_free(ctf_fs_trace->ds_file_groups, TRUE);
330 }
331
332 BT_TRACE_PUT_REF_AND_RESET(ctf_fs_trace->trace);
333
334 if (ctf_fs_trace->path) {
335 g_string_free(ctf_fs_trace->path, TRUE);
336 }
337
338 if (ctf_fs_trace->metadata) {
339 ctf_fs_metadata_fini(ctf_fs_trace->metadata);
340 g_free(ctf_fs_trace->metadata);
341 }
342
343 g_free(ctf_fs_trace);
344 }
345
346 BT_HIDDEN
347 void ctf_fs_destroy(struct ctf_fs_component *ctf_fs)
348 {
349 if (!ctf_fs) {
350 return;
351 }
352
353 ctf_fs_trace_destroy(ctf_fs->trace);
354
355 if (ctf_fs->port_data) {
356 g_ptr_array_free(ctf_fs->port_data, TRUE);
357 }
358
359 g_free(ctf_fs);
360 }
361
362 static
363 void port_data_destroy(struct ctf_fs_port_data *port_data)
364 {
365 if (!port_data) {
366 return;
367 }
368
369 g_free(port_data);
370 }
371
372 static
373 void port_data_destroy_notifier(void *data) {
374 port_data_destroy(data);
375 }
376
377 static
378 void ctf_fs_trace_destroy_notifier(void *data)
379 {
380 struct ctf_fs_trace *trace = data;
381 ctf_fs_trace_destroy(trace);
382 }
383
384 struct ctf_fs_component *ctf_fs_component_create(bt_logging_level log_level,
385 bt_self_component *self_comp)
386 {
387 struct ctf_fs_component *ctf_fs;
388
389 ctf_fs = g_new0(struct ctf_fs_component, 1);
390 if (!ctf_fs) {
391 goto error;
392 }
393
394 ctf_fs->log_level = log_level;
395 ctf_fs->port_data =
396 g_ptr_array_new_with_free_func(port_data_destroy_notifier);
397 if (!ctf_fs->port_data) {
398 goto error;
399 }
400
401 goto end;
402
403 error:
404 ctf_fs_destroy(ctf_fs);
405 ctf_fs = NULL;
406
407 end:
408 return ctf_fs;
409 }
410
411 void ctf_fs_finalize(bt_self_component_source *component)
412 {
413 ctf_fs_destroy(bt_self_component_get_data(
414 bt_self_component_source_as_self_component(component)));
415 }
416
417 gchar *ctf_fs_make_port_name(struct ctf_fs_ds_file_group *ds_file_group)
418 {
419 GString *name = g_string_new(NULL);
420
421 /*
422 * The unique port name is generated by concatenating unique identifiers
423 * for:
424 *
425 * - the trace
426 * - the stream class
427 * - the stream
428 */
429
430 /* For the trace, use the uuid if present, else the path. */
431 if (ds_file_group->ctf_fs_trace->metadata->tc->is_uuid_set) {
432 char uuid_str[BT_UUID_STR_LEN + 1];
433
434 bt_uuid_to_str(ds_file_group->ctf_fs_trace->metadata->tc->uuid, uuid_str);
435 g_string_assign(name, uuid_str);
436 } else {
437 g_string_assign(name, ds_file_group->ctf_fs_trace->path->str);
438 }
439
440 /*
441 * For the stream class, use the id if present. We can omit this field
442 * otherwise, as there will only be a single stream class.
443 */
444 if (ds_file_group->sc->id != UINT64_C(-1)) {
445 g_string_append_printf(name, " | %" PRIu64, ds_file_group->sc->id);
446 }
447
448 /* For the stream, use the id if present, else, use the path. */
449 if (ds_file_group->stream_id != UINT64_C(-1)) {
450 g_string_append_printf(name, " | %" PRIu64, ds_file_group->stream_id);
451 } else {
452 BT_ASSERT(ds_file_group->ds_file_infos->len == 1);
453 struct ctf_fs_ds_file_info *ds_file_info =
454 g_ptr_array_index(ds_file_group->ds_file_infos, 0);
455 g_string_append_printf(name, " | %s", ds_file_info->path->str);
456 }
457
458 return g_string_free(name, FALSE);
459 }
460
461 static
462 int create_one_port_for_trace(struct ctf_fs_component *ctf_fs,
463 struct ctf_fs_trace *ctf_fs_trace,
464 struct ctf_fs_ds_file_group *ds_file_group,
465 bt_self_component_source *self_comp_src)
466 {
467 int ret = 0;
468 struct ctf_fs_port_data *port_data = NULL;
469 gchar *port_name;
470 bt_logging_level log_level = ctf_fs->log_level;
471 bt_self_component *self_comp =
472 bt_self_component_source_as_self_component(self_comp_src);
473
474 port_name = ctf_fs_make_port_name(ds_file_group);
475 if (!port_name) {
476 goto error;
477 }
478
479 BT_COMP_LOGI("Creating one port named `%s`", port_name);
480
481 /* Create output port for this file */
482 port_data = g_new0(struct ctf_fs_port_data, 1);
483 if (!port_data) {
484 goto error;
485 }
486
487 port_data->ctf_fs = ctf_fs;
488 port_data->ds_file_group = ds_file_group;
489 ret = bt_self_component_source_add_output_port(
490 self_comp_src, port_name, port_data, NULL);
491 if (ret) {
492 goto error;
493 }
494
495 g_ptr_array_add(ctf_fs->port_data, port_data);
496 port_data = NULL;
497 goto end;
498
499 error:
500 ret = -1;
501
502 end:
503 g_free(port_name);
504
505 port_data_destroy(port_data);
506 return ret;
507 }
508
509 static
510 int create_ports_for_trace(struct ctf_fs_component *ctf_fs,
511 struct ctf_fs_trace *ctf_fs_trace,
512 bt_self_component_source *self_comp_src)
513 {
514 int ret = 0;
515 size_t i;
516 bt_logging_level log_level = ctf_fs_trace->log_level;
517 bt_self_component *self_comp =
518 bt_self_component_source_as_self_component(self_comp_src);
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, self_comp_src);
527 if (ret) {
528 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "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_APPEND_CAUSE(self_comp,
735 "Cannot get stream file's first packet's header and context fields (`%s`).",
736 path);
737 goto error;
738 }
739
740 sc = ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc,
741 props.stream_class_id);
742 BT_ASSERT(sc);
743 stream_instance_id = props.data_stream_id;
744
745 if (props.snapshots.beginning_clock != UINT64_C(-1)) {
746 BT_ASSERT(sc->default_clock_class);
747 ret = bt_util_clock_cycles_to_ns_from_origin(
748 props.snapshots.beginning_clock,
749 sc->default_clock_class->frequency,
750 sc->default_clock_class->offset_seconds,
751 sc->default_clock_class->offset_cycles, &begin_ns);
752 if (ret) {
753 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
754 "Cannot convert clock cycles to nanoseconds from origin (`%s`).",
755 path);
756 goto error;
757 }
758 }
759
760 ds_file_info = ctf_fs_ds_file_info_create(path, begin_ns);
761 if (!ds_file_info) {
762 goto error;
763 }
764
765 index = ctf_fs_ds_file_build_index(ds_file, ds_file_info);
766 if (!index) {
767 BT_COMP_LOGW("Failed to index CTF stream file \'%s\'",
768 ds_file->file->path->str);
769 }
770
771 if (begin_ns == -1) {
772 /*
773 * No beggining timestamp to sort the stream files
774 * within a stream file group, so consider that this
775 * file must be the only one within its group.
776 */
777 stream_instance_id = -1;
778 }
779
780 if (stream_instance_id == -1) {
781 /*
782 * No stream instance ID or no beginning timestamp:
783 * create a unique stream file group for this stream
784 * file because, even if there's a stream instance ID,
785 * there's no timestamp to order the file within its
786 * group.
787 */
788 ds_file_group = ctf_fs_ds_file_group_create(ctf_fs_trace,
789 sc, UINT64_C(-1), index);
790 /* Ownership of index is transferred. */
791 index = NULL;
792
793 if (!ds_file_group) {
794 goto error;
795 }
796
797 ds_file_group_insert_ds_file_info_sorted(ds_file_group, ds_file_info);
798
799 add_group = true;
800 goto end;
801 }
802
803 BT_ASSERT(stream_instance_id != -1);
804 BT_ASSERT(begin_ns != -1);
805
806 /* Find an existing stream file group with this ID */
807 for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) {
808 ds_file_group = g_ptr_array_index(
809 ctf_fs_trace->ds_file_groups, i);
810
811 if (ds_file_group->sc == sc &&
812 ds_file_group->stream_id ==
813 stream_instance_id) {
814 break;
815 }
816
817 ds_file_group = NULL;
818 }
819
820 if (!ds_file_group) {
821 ds_file_group = ctf_fs_ds_file_group_create(ctf_fs_trace,
822 sc, stream_instance_id, index);
823 /* Ownership of index is transferred. */
824 index = NULL;
825 if (!ds_file_group) {
826 goto error;
827 }
828
829 add_group = true;
830 }
831
832 ds_file_group_insert_ds_file_info_sorted(ds_file_group, ds_file_info);
833
834 goto end;
835
836 error:
837 ctf_fs_ds_file_group_destroy(ds_file_group);
838 ds_file_group = NULL;
839 ret = -1;
840
841 end:
842 if (add_group && ds_file_group) {
843 g_ptr_array_add(ctf_fs_trace->ds_file_groups, ds_file_group);
844 }
845
846 ctf_fs_ds_file_destroy(ds_file);
847
848 if (msg_iter) {
849 bt_msg_iter_destroy(msg_iter);
850 }
851
852 ctf_fs_ds_index_destroy(index);
853 return ret;
854 }
855
856 static
857 int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace)
858 {
859 int ret = 0;
860 const char *basename;
861 GError *error = NULL;
862 GDir *dir = NULL;
863 bt_logging_level log_level = ctf_fs_trace->log_level;
864 bt_self_component *self_comp = ctf_fs_trace->self_comp;
865
866 /* Check each file in the path directory, except specific ones */
867 dir = g_dir_open(ctf_fs_trace->path->str, 0, &error);
868 if (!dir) {
869 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot open directory `%s`: %s (code %d)",
870 ctf_fs_trace->path->str, error->message,
871 error->code);
872 goto error;
873 }
874
875 while ((basename = g_dir_read_name(dir))) {
876 struct ctf_fs_file *file;
877
878 if (strcmp(basename, CTF_FS_METADATA_FILENAME) == 0) {
879 /* Ignore the metadata stream. */
880 BT_COMP_LOGI("Ignoring metadata file `%s" G_DIR_SEPARATOR_S "%s`",
881 ctf_fs_trace->path->str, basename);
882 continue;
883 }
884
885 if (basename[0] == '.') {
886 BT_COMP_LOGI("Ignoring hidden file `%s" G_DIR_SEPARATOR_S "%s`",
887 ctf_fs_trace->path->str, basename);
888 continue;
889 }
890
891 /* Create the file. */
892 file = ctf_fs_file_create(log_level, self_comp);
893 if (!file) {
894 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
895 "Cannot create stream file object for file `%s" G_DIR_SEPARATOR_S "%s`",
896 ctf_fs_trace->path->str, basename);
897 goto error;
898 }
899
900 /* Create full path string. */
901 g_string_append_printf(file->path, "%s" G_DIR_SEPARATOR_S "%s",
902 ctf_fs_trace->path->str, basename);
903 if (!g_file_test(file->path->str, G_FILE_TEST_IS_REGULAR)) {
904 BT_COMP_LOGI("Ignoring non-regular file `%s`",
905 file->path->str);
906 ctf_fs_file_destroy(file);
907 file = NULL;
908 continue;
909 }
910
911 ret = ctf_fs_file_open(file, "rb");
912 if (ret) {
913 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot open stream file `%s`",
914 file->path->str);
915 goto error;
916 }
917
918 if (file->size == 0) {
919 /* Skip empty stream. */
920 BT_COMP_LOGI("Ignoring empty file `%s`", file->path->str);
921 ctf_fs_file_destroy(file);
922 continue;
923 }
924
925 ret = add_ds_file_to_ds_file_group(ctf_fs_trace,
926 file->path->str);
927 if (ret) {
928 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
929 "Cannot add stream file `%s` to stream file group",
930 file->path->str);
931 ctf_fs_file_destroy(file);
932 goto error;
933 }
934
935 ctf_fs_file_destroy(file);
936 }
937
938 goto end;
939
940 error:
941 ret = -1;
942
943 end:
944 if (dir) {
945 g_dir_close(dir);
946 dir = NULL;
947 }
948
949 if (error) {
950 g_error_free(error);
951 }
952
953 return ret;
954 }
955
956 static
957 int set_trace_name(bt_trace *trace, const char *name_suffix,
958 bt_logging_level log_level, bt_self_component *self_comp)
959 {
960 int ret = 0;
961 const bt_value *val;
962 GString *name;
963
964 name = g_string_new(NULL);
965 if (!name) {
966 BT_COMP_LOGE_STR("Failed to allocate a GString.");
967 ret = -1;
968 goto end;
969 }
970
971 /*
972 * Check if we have a trace environment string value named `hostname`.
973 * If so, use it as the trace name's prefix.
974 */
975 val = bt_trace_borrow_environment_entry_value_by_name_const(
976 trace, "hostname");
977 if (val && bt_value_is_string(val)) {
978 g_string_append(name, bt_value_string_get(val));
979
980 if (name_suffix) {
981 g_string_append_c(name, G_DIR_SEPARATOR);
982 }
983 }
984
985 if (name_suffix) {
986 g_string_append(name, name_suffix);
987 }
988
989 ret = bt_trace_set_name(trace, name->str);
990 if (ret) {
991 goto end;
992 }
993
994 goto end;
995
996 end:
997 if (name) {
998 g_string_free(name, TRUE);
999 }
1000
1001 return ret;
1002 }
1003
1004 static
1005 struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component *self_comp,
1006 const char *path, const char *name,
1007 struct ctf_fs_metadata_config *metadata_config,
1008 bt_logging_level log_level)
1009 {
1010 struct ctf_fs_trace *ctf_fs_trace;
1011 int ret;
1012
1013 ctf_fs_trace = g_new0(struct ctf_fs_trace, 1);
1014 if (!ctf_fs_trace) {
1015 goto end;
1016 }
1017
1018 ctf_fs_trace->log_level = log_level;
1019 ctf_fs_trace->self_comp = self_comp;
1020 ctf_fs_trace->path = g_string_new(path);
1021 if (!ctf_fs_trace->path) {
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 /* Helper for ctf_fs_component_create_ctf_fs_trace, to handle a single path. */
1104
1105 static
1106 int ctf_fs_component_create_ctf_fs_trace_one_path(
1107 struct ctf_fs_component *ctf_fs,
1108 const char *path_param,
1109 const char *trace_name,
1110 GPtrArray *traces,
1111 bt_self_component *self_comp,
1112 bt_self_component_class *self_comp_class)
1113 {
1114 struct ctf_fs_trace *ctf_fs_trace;
1115 int ret;
1116 GString *norm_path;
1117 bt_logging_level log_level = ctf_fs->log_level;
1118
1119 norm_path = bt_common_normalize_path(path_param, NULL);
1120 if (!norm_path) {
1121 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
1122 "Failed to normalize path: `%s`.", path_param);
1123 goto error;
1124 }
1125
1126 ret = path_is_ctf_trace(norm_path->str);
1127 if (ret < 0) {
1128 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
1129 "Failed to check if path is a CTF trace: path=%s", norm_path->str);
1130 goto error;
1131 } else if (ret == 0) {
1132 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
1133 "Path is not a CTF trace (does not contain a metadata file): `%s`.", norm_path->str);
1134 goto error;
1135 }
1136
1137 // FIXME: Remove or ifdef for __MINGW32__
1138 if (strcmp(norm_path->str, "/") == 0) {
1139 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
1140 "Opening a trace in `/` is not supported.");
1141 ret = -1;
1142 goto end;
1143 }
1144
1145 ctf_fs_trace = ctf_fs_trace_create(self_comp, norm_path->str,
1146 trace_name, &ctf_fs->metadata_config, log_level);
1147 if (!ctf_fs_trace) {
1148 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot create trace for `%s`.",
1149 norm_path->str);
1150 goto error;
1151 }
1152
1153 g_ptr_array_add(traces, ctf_fs_trace);
1154 ctf_fs_trace = NULL;
1155
1156 ret = 0;
1157 goto end;
1158
1159 error:
1160 ret = -1;
1161
1162 end:
1163 if (norm_path) {
1164 g_string_free(norm_path, TRUE);
1165 }
1166
1167 return ret;
1168 }
1169
1170 /*
1171 * Count the number of stream and event classes defined by this trace's metadata.
1172 *
1173 * This is used to determine which metadata is the "latest", out of multiple
1174 * traces sharing the same UUID. It is assumed that amongst all these metadatas,
1175 * a bigger metadata is a superset of a smaller metadata. Therefore, it is
1176 * enough to just count the classes.
1177 */
1178
1179 static
1180 unsigned int metadata_count_stream_and_event_classes(struct ctf_fs_trace *trace)
1181 {
1182 unsigned int num = trace->metadata->tc->stream_classes->len;
1183 guint i;
1184
1185 for (i = 0; i < trace->metadata->tc->stream_classes->len; i++) {
1186 struct ctf_stream_class *sc = trace->metadata->tc->stream_classes->pdata[i];
1187 num += sc->event_classes->len;
1188 }
1189
1190 return num;
1191 }
1192
1193 /*
1194 * Merge the src ds_file_group into dest. This consists of merging their
1195 * ds_file_infos, making sure to keep the result sorted.
1196 */
1197
1198 static
1199 void merge_ctf_fs_ds_file_groups(struct ctf_fs_ds_file_group *dest, struct ctf_fs_ds_file_group *src)
1200 {
1201 guint i;
1202
1203 for (i = 0; i < src->ds_file_infos->len; i++) {
1204 struct ctf_fs_ds_file_info *ds_file_info =
1205 g_ptr_array_index(src->ds_file_infos, i);
1206
1207 /* Ownership of the ds_file_info is transferred to dest. */
1208 g_ptr_array_index(src->ds_file_infos, i) = NULL;
1209
1210 ds_file_group_insert_ds_file_info_sorted(dest, ds_file_info);
1211 }
1212
1213 /* Merge both indexes. */
1214 for (i = 0; i < src->index->entries->len; i++) {
1215 struct ctf_fs_ds_index_entry *entry = g_ptr_array_index(
1216 src->index->entries, i);
1217
1218 /*
1219 * Ownership of the ctf_fs_ds_index_entry is transferred to
1220 * dest.
1221 */
1222 g_ptr_array_index(src->index->entries, i) = NULL;
1223
1224 ds_file_group_insert_ds_index_entry_sorted(dest, entry);
1225 }
1226 }
1227 /* Merge src_trace's data stream file groups into dest_trace's. */
1228
1229 static
1230 int merge_matching_ctf_fs_ds_file_groups(
1231 struct ctf_fs_trace *dest_trace,
1232 struct ctf_fs_trace *src_trace)
1233 {
1234
1235 GPtrArray *dest = dest_trace->ds_file_groups;
1236 GPtrArray *src = src_trace->ds_file_groups;
1237 guint s_i;
1238 int ret = 0;
1239
1240 /*
1241 * Save the initial length of dest: we only want to check against the
1242 * original elements in the inner loop.
1243 */
1244 const guint dest_len = dest->len;
1245
1246 for (s_i = 0; s_i < src->len; s_i++) {
1247 struct ctf_fs_ds_file_group *src_group = g_ptr_array_index(src, s_i);
1248 struct ctf_fs_ds_file_group *dest_group = NULL;
1249
1250 /* A stream instance without ID can't match a stream in the other trace. */
1251 if (src_group->stream_id != -1) {
1252 guint d_i;
1253
1254 /* Let's search for a matching ds_file_group in the destination. */
1255 for (d_i = 0; d_i < dest_len; d_i++) {
1256 struct ctf_fs_ds_file_group *candidate_dest = g_ptr_array_index(dest, d_i);
1257
1258 /* Can't match a stream instance without ID. */
1259 if (candidate_dest->stream_id == -1) {
1260 continue;
1261 }
1262
1263 /*
1264 * If the two groups have the same stream instance id
1265 * and belong to the same stream class (stream instance
1266 * ids are per-stream class), they represent the same
1267 * stream instance.
1268 */
1269 if (candidate_dest->stream_id != src_group->stream_id ||
1270 candidate_dest->sc->id != src_group->sc->id) {
1271 continue;
1272 }
1273
1274 dest_group = candidate_dest;
1275 break;
1276 }
1277 }
1278
1279 /*
1280 * Didn't find a friend in dest to merge our src_group into?
1281 * Create a new empty one. This can happen if a stream was
1282 * active in the source trace chunk but not in the destination
1283 * trace chunk.
1284 */
1285 if (!dest_group) {
1286 struct ctf_stream_class *sc;
1287 struct ctf_fs_ds_index *index;
1288
1289 sc = ctf_trace_class_borrow_stream_class_by_id(
1290 dest_trace->metadata->tc, src_group->sc->id);
1291 BT_ASSERT(sc);
1292
1293 index = ctf_fs_ds_index_create(dest_trace->log_level,
1294 dest_trace->self_comp);
1295 if (!index) {
1296 ret = -1;
1297 goto end;
1298 }
1299
1300 dest_group = ctf_fs_ds_file_group_create(dest_trace, sc,
1301 src_group->stream_id, index);
1302 /* Ownership of index is transferred. */
1303 index = NULL;
1304 if (!dest_group) {
1305 ret = -1;
1306 goto end;
1307 }
1308
1309 g_ptr_array_add(dest_trace->ds_file_groups, dest_group);
1310 }
1311
1312 BT_ASSERT(dest_group);
1313 merge_ctf_fs_ds_file_groups(dest_group, src_group);
1314 }
1315
1316 end:
1317 return ret;
1318 }
1319
1320 /*
1321 * Collapse the given traces, which must all share the same UUID, in a single
1322 * one.
1323 *
1324 * The trace with the most expansive metadata is chosen and all other traces
1325 * are merged into that one. The array slots of all the traces that get merged
1326 * in the chosen one are set to NULL, so only the slot of the chosen trace
1327 * remains non-NULL.
1328 */
1329
1330 static
1331 int merge_ctf_fs_traces(struct ctf_fs_trace **traces, unsigned int num_traces,
1332 struct ctf_fs_trace **out_trace)
1333 {
1334 unsigned int winner_count;
1335 struct ctf_fs_trace *winner;
1336 guint i, winner_i;
1337 int ret = 0;
1338
1339 BT_ASSERT(num_traces >= 2);
1340
1341 winner_count = metadata_count_stream_and_event_classes(traces[0]);
1342 winner = traces[0];
1343 winner_i = 0;
1344
1345 /* Find the trace with the largest metadata. */
1346 for (i = 1; i < num_traces; i++) {
1347 struct ctf_fs_trace *candidate;
1348 unsigned int candidate_count;
1349
1350 candidate = traces[i];
1351
1352 /* A bit of sanity check. */
1353 BT_ASSERT(bt_uuid_compare(winner->metadata->tc->uuid, candidate->metadata->tc->uuid) == 0);
1354
1355 candidate_count = metadata_count_stream_and_event_classes(candidate);
1356
1357 if (candidate_count > winner_count) {
1358 winner_count = candidate_count;
1359 winner = candidate;
1360 winner_i = i;
1361 }
1362 }
1363
1364 /* Merge all the other traces in the winning trace. */
1365 for (i = 0; i < num_traces; i++) {
1366 struct ctf_fs_trace *trace = traces[i];
1367
1368 /* Don't merge the winner into itself. */
1369 if (trace == winner) {
1370 continue;
1371 }
1372
1373 /* Merge trace's data stream file groups into winner's. */
1374 ret = merge_matching_ctf_fs_ds_file_groups(winner, trace);
1375 if (ret) {
1376 goto end;
1377 }
1378 }
1379
1380 /*
1381 * Move the winner out of the array, into `*out_trace`.
1382 */
1383 *out_trace = winner;
1384 traces[winner_i] = NULL;
1385
1386 end:
1387 return ret;
1388 }
1389
1390 enum target_event {
1391 FIRST_EVENT,
1392 LAST_EVENT,
1393 };
1394
1395 static
1396 int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace,
1397 struct ctf_clock_class *default_cc,
1398 struct ctf_fs_ds_index_entry *index_entry,
1399 enum target_event target_event, uint64_t *cs, int64_t *ts_ns)
1400 {
1401 enum bt_msg_iter_status iter_status = BT_MSG_ITER_STATUS_OK;
1402 struct ctf_fs_ds_file *ds_file = NULL;
1403 struct bt_msg_iter *msg_iter = NULL;
1404 bt_logging_level log_level = ctf_fs_trace->log_level;
1405 bt_self_component *self_comp = ctf_fs_trace->self_comp;
1406 int ret = 0;
1407
1408 BT_ASSERT(ctf_fs_trace);
1409 BT_ASSERT(ctf_fs_trace->metadata);
1410 BT_ASSERT(ctf_fs_trace->metadata->tc);
1411
1412 msg_iter = bt_msg_iter_create(ctf_fs_trace->metadata->tc,
1413 bt_common_get_page_size(log_level) * 8, ctf_fs_ds_file_medops,
1414 NULL, log_level, self_comp);
1415 if (!msg_iter) {
1416 /* bt_msg_iter_create() logs errors. */
1417 ret = -1;
1418 goto end;
1419 }
1420
1421 BT_ASSERT(index_entry);
1422 BT_ASSERT(index_entry->path);
1423
1424 ds_file = ctf_fs_ds_file_create(ctf_fs_trace, NULL, msg_iter,
1425 NULL, index_entry->path, log_level);
1426 if (!ds_file) {
1427 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to create a ctf_fs_ds_file");
1428 ret = -1;
1429 goto end;
1430 }
1431
1432 /*
1433 * Turn on dry run mode to prevent the creation and usage of Babeltrace
1434 * library objects (bt_field, bt_message_*, etc.).
1435 */
1436 bt_msg_iter_set_dry_run(msg_iter, true);
1437
1438 /* Seek to the beginning of the target packet. */
1439 iter_status = bt_msg_iter_seek(ds_file->msg_iter, index_entry->offset);
1440 if (iter_status) {
1441 /* bt_msg_iter_seek() logs errors. */
1442 ret = -1;
1443 goto end;
1444 }
1445
1446 switch (target_event) {
1447 case FIRST_EVENT:
1448 /*
1449 * Start to decode the packet until we reach the end of
1450 * the first event. To extract the first event's clock
1451 * snapshot.
1452 */
1453 iter_status = bt_msg_iter_curr_packet_first_event_clock_snapshot(
1454 ds_file->msg_iter, cs);
1455 break;
1456 case LAST_EVENT:
1457 /* Decode the packet to extract the last event's clock snapshot. */
1458 iter_status = bt_msg_iter_curr_packet_last_event_clock_snapshot(
1459 ds_file->msg_iter, cs);
1460 break;
1461 default:
1462 abort();
1463 }
1464 if (iter_status) {
1465 ret = -1;
1466 goto end;
1467 }
1468
1469 /* Convert clock snapshot to timestamp. */
1470 ret = bt_util_clock_cycles_to_ns_from_origin(*cs,
1471 default_cc->frequency, default_cc->offset_seconds,
1472 default_cc->offset_cycles, ts_ns);
1473 if (ret) {
1474 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1475 "Failed to convert clock snapshot to timestamp");
1476 goto end;
1477 }
1478
1479 end:
1480 if (ds_file) {
1481 ctf_fs_ds_file_destroy(ds_file);
1482 }
1483 if (msg_iter) {
1484 bt_msg_iter_destroy(msg_iter);
1485 }
1486
1487 return ret;
1488 }
1489
1490 static
1491 int decode_packet_first_event_timestamp(struct ctf_fs_trace *ctf_fs_trace,
1492 struct ctf_clock_class *default_cc,
1493 struct ctf_fs_ds_index_entry *index_entry, uint64_t *cs, int64_t *ts_ns)
1494 {
1495 return decode_clock_snapshot_after_event(ctf_fs_trace, default_cc,
1496 index_entry, FIRST_EVENT, cs, ts_ns);
1497 }
1498
1499 static
1500 int decode_packet_last_event_timestamp(struct ctf_fs_trace *ctf_fs_trace,
1501 struct ctf_clock_class *default_cc,
1502 struct ctf_fs_ds_index_entry *index_entry, uint64_t *cs, int64_t *ts_ns)
1503 {
1504 return decode_clock_snapshot_after_event(ctf_fs_trace, default_cc,
1505 index_entry, LAST_EVENT, cs, ts_ns);
1506 }
1507
1508 /*
1509 * Fix up packet index entries for lttng's "event-after-packet" bug.
1510 * Some buggy lttng tracer versions may emit events with a timestamp that is
1511 * larger (after) than the timestamp_end of the their packets.
1512 *
1513 * To fix up this erroneous data we do the following:
1514 * 1. If it's not the stream file's last packet: set the packet index entry's
1515 * end time to the next packet's beginning time.
1516 * 2. If it's the stream file's last packet, set the packet index entry's end
1517 * time to the packet's last event's time, if any, or to the packet's
1518 * beginning time otherwise.
1519 *
1520 * Known buggy tracer versions:
1521 * - before lttng-ust 2.11.0
1522 * - before lttng-module 2.11.0
1523 * - before lttng-module 2.10.10
1524 * - before lttng-module 2.9.13
1525 */
1526 static
1527 int fix_index_lttng_event_after_packet_bug(struct ctf_fs_trace *trace)
1528 {
1529 int ret = 0;
1530 guint ds_file_group_i;
1531 GPtrArray *ds_file_groups = trace->ds_file_groups;
1532 bt_logging_level log_level = trace->log_level;
1533
1534 for (ds_file_group_i = 0; ds_file_group_i < ds_file_groups->len;
1535 ds_file_group_i++) {
1536 guint entry_i;
1537 struct ctf_clock_class *default_cc;
1538 struct ctf_fs_ds_index_entry *last_entry;
1539 struct ctf_fs_ds_index *index;
1540
1541 struct ctf_fs_ds_file_group *ds_file_group =
1542 g_ptr_array_index(ds_file_groups, ds_file_group_i);
1543
1544 BT_ASSERT(ds_file_group);
1545 index = ds_file_group->index;
1546
1547 BT_ASSERT(index);
1548 BT_ASSERT(index->entries);
1549 BT_ASSERT(index->entries->len > 0);
1550
1551 /*
1552 * Iterate over all entries but the last one. The last one is
1553 * fixed differently after.
1554 */
1555 for (entry_i = 0; entry_i < index->entries->len - 1;
1556 entry_i++) {
1557 struct ctf_fs_ds_index_entry *curr_entry, *next_entry;
1558
1559 curr_entry = g_ptr_array_index(index->entries, entry_i);
1560 next_entry = g_ptr_array_index(index->entries, entry_i + 1);
1561
1562 /*
1563 * 1. Set the current index entry `end` timestamp to
1564 * the next index entry `begin` timestamp.
1565 */
1566 curr_entry->timestamp_end = next_entry->timestamp_begin;
1567 curr_entry->timestamp_end_ns = next_entry->timestamp_begin_ns;
1568 }
1569
1570 /*
1571 * 2. Fix the last entry by decoding the last event of the last
1572 * packet.
1573 */
1574 last_entry = g_ptr_array_index(index->entries,
1575 index->entries->len - 1);
1576 BT_ASSERT(last_entry);
1577
1578 BT_ASSERT(ds_file_group->sc->default_clock_class);
1579 default_cc = ds_file_group->sc->default_clock_class;
1580
1581 /*
1582 * Decode packet to read the timestamp of the last event of the
1583 * entry.
1584 */
1585 ret = decode_packet_last_event_timestamp(trace, default_cc,
1586 last_entry, &last_entry->timestamp_end,
1587 &last_entry->timestamp_end_ns);
1588 if (ret) {
1589 BT_COMP_LOGE_APPEND_CAUSE(trace->self_comp,
1590 "Failed to decode stream's last packet to get its last event's clock snapshot.");
1591 goto end;
1592 }
1593 }
1594
1595 end:
1596 return ret;
1597 }
1598
1599 /*
1600 * Fix up packet index entries for barectf's "event-before-packet" bug.
1601 * Some buggy barectf tracer versions may emit events with a timestamp that is
1602 * less than the timestamp_begin of the their packets.
1603 *
1604 * To fix up this erroneous data we do the following:
1605 * 1. Starting at the second index entry, set the timestamp_begin of the
1606 * current entry to the timestamp of the first event of the packet.
1607 * 2. Set the previous entry's timestamp_end to the timestamp_begin of the
1608 * current packet.
1609 *
1610 * Known buggy tracer versions:
1611 * - before barectf 2.3.1
1612 */
1613 static
1614 int fix_index_barectf_event_before_packet_bug(struct ctf_fs_trace *trace)
1615 {
1616 int ret = 0;
1617 guint ds_file_group_i;
1618 GPtrArray *ds_file_groups = trace->ds_file_groups;
1619 bt_logging_level log_level = trace->log_level;
1620
1621 for (ds_file_group_i = 0; ds_file_group_i < ds_file_groups->len;
1622 ds_file_group_i++) {
1623 guint entry_i;
1624 struct ctf_clock_class *default_cc;
1625 struct ctf_fs_ds_file_group *ds_file_group =
1626 g_ptr_array_index(ds_file_groups, ds_file_group_i);
1627
1628 struct ctf_fs_ds_index *index = ds_file_group->index;
1629
1630 BT_ASSERT(index);
1631 BT_ASSERT(index->entries);
1632 BT_ASSERT(index->entries->len > 0);
1633
1634 BT_ASSERT(ds_file_group->sc->default_clock_class);
1635 default_cc = ds_file_group->sc->default_clock_class;
1636
1637 /*
1638 * 1. Iterate over the index, starting from the second entry
1639 * (index = 1).
1640 */
1641 for (entry_i = 1; entry_i < index->entries->len;
1642 entry_i++) {
1643 struct ctf_fs_ds_index_entry *curr_entry, *prev_entry;
1644 prev_entry = g_ptr_array_index(index->entries, entry_i - 1);
1645 curr_entry = g_ptr_array_index(index->entries, entry_i);
1646 /*
1647 * 2. Set the current entry `begin` timestamp to the
1648 * timestamp of the first event of the current packet.
1649 */
1650 ret = decode_packet_first_event_timestamp(trace, default_cc,
1651 curr_entry, &curr_entry->timestamp_begin,
1652 &curr_entry->timestamp_begin_ns);
1653 if (ret) {
1654 BT_COMP_LOGE_APPEND_CAUSE(trace->self_comp,
1655 "Failed to decode first event's clock snapshot");
1656 goto end;
1657 }
1658
1659 /*
1660 * 3. Set the previous entry `end` timestamp to the
1661 * timestamp of the first event of the current packet.
1662 */
1663 prev_entry->timestamp_end = curr_entry->timestamp_begin;
1664 prev_entry->timestamp_end_ns = curr_entry->timestamp_begin_ns;
1665 }
1666 }
1667 end:
1668 return ret;
1669 }
1670
1671 /*
1672 * When using the lttng-crash feature it's likely that the last packets of each
1673 * stream have their timestamp_end set to zero. This is caused by the fact that
1674 * the tracer crashed and was not able to properly close the packets.
1675 *
1676 * To fix up this erroneous data we do the following:
1677 * For each index entry, if the entry's timestamp_end is 0 and the
1678 * timestamp_begin is not 0:
1679 * - If it's the stream file's last packet: set the packet index entry's end
1680 * time to the packet's last event's time, if any, or to the packet's
1681 * beginning time otherwise.
1682 * - If it's not the stream file's last packet: set the packet index
1683 * entry's end time to the next packet's beginning time.
1684 *
1685 * Affected versions:
1686 * - All current and future lttng-ust and lttng-modules versions.
1687 */
1688 static
1689 int fix_index_lttng_crash_quirk(struct ctf_fs_trace *trace)
1690 {
1691 int ret = 0;
1692 guint ds_file_group_idx;
1693 GPtrArray *ds_file_groups = trace->ds_file_groups;
1694 bt_logging_level log_level = trace->log_level;
1695
1696 for (ds_file_group_idx = 0; ds_file_group_idx < ds_file_groups->len;
1697 ds_file_group_idx++) {
1698 guint entry_idx;
1699 struct ctf_clock_class *default_cc;
1700 struct ctf_fs_ds_index_entry *last_entry;
1701 struct ctf_fs_ds_index *index;
1702
1703 struct ctf_fs_ds_file_group *ds_file_group =
1704 g_ptr_array_index(ds_file_groups, ds_file_group_idx);
1705
1706 BT_ASSERT(ds_file_group);
1707 index = ds_file_group->index;
1708
1709 BT_ASSERT(ds_file_group->sc->default_clock_class);
1710 default_cc = ds_file_group->sc->default_clock_class;
1711
1712 BT_ASSERT(index);
1713 BT_ASSERT(index->entries);
1714 BT_ASSERT(index->entries->len > 0);
1715
1716 last_entry = g_ptr_array_index(index->entries,
1717 index->entries->len - 1);
1718 BT_ASSERT(last_entry);
1719
1720
1721 /* 1. Fix the last entry first. */
1722 if (last_entry->timestamp_end == 0 &&
1723 last_entry->timestamp_begin != 0) {
1724 /*
1725 * Decode packet to read the timestamp of the
1726 * last event of the stream file.
1727 */
1728 ret = decode_packet_last_event_timestamp(trace,
1729 default_cc, last_entry,
1730 &last_entry->timestamp_end,
1731 &last_entry->timestamp_end_ns);
1732 if (ret) {
1733 BT_COMP_LOGE_APPEND_CAUSE(trace->self_comp,
1734 "Failed to decode last event's clock snapshot");
1735 goto end;
1736 }
1737 }
1738
1739 /* Iterate over all entries but the last one. */
1740 for (entry_idx = 0; entry_idx < index->entries->len - 1;
1741 entry_idx++) {
1742 struct ctf_fs_ds_index_entry *curr_entry, *next_entry;
1743 curr_entry = g_ptr_array_index(index->entries, entry_idx);
1744 next_entry = g_ptr_array_index(index->entries, entry_idx + 1);
1745
1746 if (curr_entry->timestamp_end == 0 &&
1747 curr_entry->timestamp_begin != 0) {
1748 /*
1749 * 2. Set the current index entry `end` timestamp to
1750 * the next index entry `begin` timestamp.
1751 */
1752 curr_entry->timestamp_end = next_entry->timestamp_begin;
1753 curr_entry->timestamp_end_ns = next_entry->timestamp_begin_ns;
1754 }
1755 }
1756 }
1757
1758 end:
1759 return ret;
1760 }
1761
1762 /*
1763 * Extract the tracer information necessary to compare versions.
1764 * Returns 0 on success, and -1 if the extraction is not successful because the
1765 * necessary fields are absents in the trace metadata.
1766 */
1767 static
1768 int extract_tracer_info(struct ctf_fs_trace *trace,
1769 struct tracer_info *current_tracer_info)
1770 {
1771 int ret = 0;
1772 struct ctf_trace_class_env_entry *entry;
1773
1774 /* Clear the current_tracer_info struct */
1775 memset(current_tracer_info, 0, sizeof(*current_tracer_info));
1776
1777 /*
1778 * To compare 2 tracer versions, at least the tracer name and it's
1779 * major version are needed. If one of these is missing, consider it an
1780 * extraction failure.
1781 */
1782 entry = ctf_trace_class_borrow_env_entry_by_name(
1783 trace->metadata->tc, "tracer_name");
1784 if (!entry || entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_STR) {
1785 goto missing_bare_minimum;
1786 }
1787
1788 /* Set tracer name. */
1789 current_tracer_info->name = entry->value.str->str;
1790
1791 entry = ctf_trace_class_borrow_env_entry_by_name(
1792 trace->metadata->tc, "tracer_major");
1793 if (!entry || entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT) {
1794 goto missing_bare_minimum;
1795 }
1796
1797 /* Set major version number. */
1798 current_tracer_info->major = entry->value.i;
1799
1800 entry = ctf_trace_class_borrow_env_entry_by_name(
1801 trace->metadata->tc, "tracer_minor");
1802 if (!entry || entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT) {
1803 goto end;
1804 }
1805
1806 /* Set minor version number. */
1807 current_tracer_info->minor = entry->value.i;
1808
1809 entry = ctf_trace_class_borrow_env_entry_by_name(
1810 trace->metadata->tc, "tracer_patch");
1811 if (!entry) {
1812 /*
1813 * If `tracer_patch` doesn't exist `tracer_patchlevel` might.
1814 * For example, `lttng-modules` uses entry name
1815 * `tracer_patchlevel`.
1816 */
1817 entry = ctf_trace_class_borrow_env_entry_by_name(
1818 trace->metadata->tc, "tracer_patchlevel");
1819 }
1820
1821 if (!entry || entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT) {
1822 goto end;
1823 }
1824
1825 /* Set patch version number. */
1826 current_tracer_info->patch = entry->value.i;
1827
1828 goto end;
1829
1830 missing_bare_minimum:
1831 ret = -1;
1832 end:
1833 return ret;
1834 }
1835
1836 static
1837 bool is_tracer_affected_by_lttng_event_after_packet_bug(
1838 struct tracer_info *curr_tracer_info)
1839 {
1840 bool is_affected = false;
1841
1842 if (strcmp(curr_tracer_info->name, "lttng-ust") == 0) {
1843 if (curr_tracer_info->major < 2) {
1844 is_affected = true;
1845 } else if (curr_tracer_info->major == 2) {
1846 /* fixed in lttng-ust 2.11.0 */
1847 if (curr_tracer_info->minor < 11) {
1848 is_affected = true;
1849 }
1850 }
1851 } else if (strcmp(curr_tracer_info->name, "lttng-modules") == 0) {
1852 if (curr_tracer_info->major < 2) {
1853 is_affected = true;
1854 } else if (curr_tracer_info->major == 2) {
1855 /* fixed in lttng-modules 2.11.0 */
1856 if (curr_tracer_info->minor == 10) {
1857 /* fixed in lttng-modules 2.10.10 */
1858 if (curr_tracer_info->patch < 10) {
1859 is_affected = true;
1860 }
1861 } else if (curr_tracer_info->minor == 9) {
1862 /* fixed in lttng-modules 2.9.13 */
1863 if (curr_tracer_info->patch < 13) {
1864 is_affected = true;
1865 }
1866 } else if (curr_tracer_info->minor < 9) {
1867 is_affected = true;
1868 }
1869 }
1870 }
1871
1872 return is_affected;
1873 }
1874
1875 static
1876 bool is_tracer_affected_by_barectf_event_before_packet_bug(
1877 struct tracer_info *curr_tracer_info)
1878 {
1879 bool is_affected = false;
1880
1881 if (strcmp(curr_tracer_info->name, "barectf") == 0) {
1882 if (curr_tracer_info->major < 2) {
1883 is_affected = true;
1884 } else if (curr_tracer_info->major == 2) {
1885 if (curr_tracer_info->minor < 3) {
1886 is_affected = true;
1887 } else if (curr_tracer_info->minor == 3) {
1888 /* fixed in barectf 2.3.1 */
1889 if (curr_tracer_info->patch < 1) {
1890 is_affected = true;
1891 }
1892 }
1893 }
1894 }
1895
1896 return is_affected;
1897 }
1898
1899 static
1900 bool is_tracer_affected_by_lttng_crash_quirk(
1901 struct tracer_info *curr_tracer_info)
1902 {
1903 bool is_affected = false;
1904
1905 /* All LTTng tracer may be affected by this lttng crash quirk. */
1906 if (strcmp(curr_tracer_info->name, "lttng-ust") == 0) {
1907 is_affected = true;
1908 } else if (strcmp(curr_tracer_info->name, "lttng-modules") == 0) {
1909 is_affected = true;
1910 }
1911
1912 return is_affected;
1913 }
1914
1915 /*
1916 * Looks for trace produced by known buggy tracers and fix up the index
1917 * produced earlier.
1918 */
1919 static
1920 int fix_packet_index_tracer_bugs(struct ctf_fs_component *ctf_fs,
1921 bt_self_component *self_comp)
1922 {
1923 int ret = 0;
1924 struct tracer_info current_tracer_info;
1925 bt_logging_level log_level = ctf_fs->log_level;
1926
1927 ret = extract_tracer_info(ctf_fs->trace, &current_tracer_info);
1928 if (ret) {
1929 /*
1930 * A trace may not have all the necessary environment
1931 * entries to do the tracer version comparison.
1932 * At least, the tracer name and major version number
1933 * are needed. Failing to extract these entries is not
1934 * an error.
1935 */
1936 ret = 0;
1937 BT_LOGI_STR("Cannot extract tracer information necessary to compare with buggy versions.");
1938 goto end;;
1939 }
1940
1941 /* Check if the trace may be affected by old tracer bugs. */
1942 if (is_tracer_affected_by_lttng_event_after_packet_bug(
1943 &current_tracer_info)) {
1944 BT_LOGI_STR("Trace may be affected by LTTng tracer packet timestamp bug. Fixing up.");
1945 ret = fix_index_lttng_event_after_packet_bug(ctf_fs->trace);
1946 if (ret) {
1947 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1948 "Failed to fix LTTng event-after-packet bug.");
1949 goto end;
1950 }
1951 ctf_fs->trace->metadata->tc->quirks.lttng_event_after_packet = true;
1952 }
1953
1954 if (is_tracer_affected_by_barectf_event_before_packet_bug(
1955 &current_tracer_info)) {
1956 BT_LOGI_STR("Trace may be affected by barectf tracer packet timestamp bug. Fixing up.");
1957 ret = fix_index_barectf_event_before_packet_bug(ctf_fs->trace);
1958 if (ret) {
1959 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1960 "Failed to fix barectf event-before-packet bug.");
1961 goto end;
1962 }
1963 ctf_fs->trace->metadata->tc->quirks.barectf_event_before_packet = true;
1964 }
1965
1966 if (is_tracer_affected_by_lttng_crash_quirk(
1967 &current_tracer_info)) {
1968 ret = fix_index_lttng_crash_quirk(ctf_fs->trace);
1969 if (ret) {
1970 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1971 "Failed to fix lttng-crash timestamp quirks.");
1972 goto end;
1973 }
1974 ctf_fs->trace->metadata->tc->quirks.lttng_crash = true;
1975 }
1976
1977 end:
1978 return ret;
1979 }
1980
1981 static
1982 gint compare_ds_file_groups_by_first_path(gconstpointer a, gconstpointer b)
1983 {
1984 struct ctf_fs_ds_file_group * const *ds_file_group_a = a;
1985 struct ctf_fs_ds_file_group * const *ds_file_group_b = b;
1986 const struct ctf_fs_ds_file_info *first_ds_file_info_a;
1987 const struct ctf_fs_ds_file_info *first_ds_file_info_b;
1988
1989 BT_ASSERT((*ds_file_group_a)->ds_file_infos->len > 0);
1990 BT_ASSERT((*ds_file_group_b)->ds_file_infos->len > 0);
1991 first_ds_file_info_a = (*ds_file_group_a)->ds_file_infos->pdata[0];
1992 first_ds_file_info_b = (*ds_file_group_b)->ds_file_infos->pdata[0];
1993 return strcmp(first_ds_file_info_a->path->str,
1994 first_ds_file_info_b->path->str);
1995 }
1996
1997 int ctf_fs_component_create_ctf_fs_trace(
1998 struct ctf_fs_component *ctf_fs,
1999 const bt_value *paths_value,
2000 const bt_value *trace_name_value,
2001 bt_self_component *self_comp,
2002 bt_self_component_class *self_comp_class)
2003 {
2004 int ret = 0;
2005 uint64_t i;
2006 bt_logging_level log_level = ctf_fs->log_level;
2007 GPtrArray *traces;
2008 const char *trace_name;
2009
2010 BT_ASSERT(bt_value_get_type(paths_value) == BT_VALUE_TYPE_ARRAY);
2011 BT_ASSERT(!bt_value_array_is_empty(paths_value));
2012
2013 traces = g_ptr_array_new_with_free_func(ctf_fs_trace_destroy_notifier);
2014 if (!traces) {
2015 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
2016 "Failed to allocate a GPtrArray.");
2017 goto error;
2018 }
2019
2020 trace_name = trace_name_value ? bt_value_string_get(trace_name_value) : NULL;
2021
2022 /* Start by creating a separate ctf_fs_trace object for each path. */
2023 for (i = 0; i < bt_value_array_get_length(paths_value); i++) {
2024 const bt_value *path_value = bt_value_array_borrow_element_by_index_const(paths_value, i);
2025 const char *input = bt_value_string_get(path_value);
2026
2027 ret = ctf_fs_component_create_ctf_fs_trace_one_path(ctf_fs,
2028 input, trace_name, traces, self_comp, self_comp_class);
2029 if (ret) {
2030 goto end;
2031 }
2032 }
2033
2034 if (traces->len > 1) {
2035 struct ctf_fs_trace *first_trace = (struct ctf_fs_trace *) traces->pdata[0];
2036 const uint8_t *first_trace_uuid = first_trace->metadata->tc->uuid;
2037 struct ctf_fs_trace *trace;
2038
2039 /*
2040 * We have more than one trace, they must all share the same
2041 * UUID, verify that.
2042 */
2043 for (i = 0; i < traces->len; i++) {
2044 struct ctf_fs_trace *this_trace =
2045 (struct ctf_fs_trace *) traces->pdata[i];
2046 const uint8_t *this_trace_uuid = this_trace->metadata->tc->uuid;
2047
2048 if (!this_trace->metadata->tc->is_uuid_set) {
2049 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
2050 "Multiple traces given, but a trace does not have a UUID: path=%s",
2051 this_trace->path->str);
2052 goto error;
2053 }
2054
2055 if (bt_uuid_compare(first_trace_uuid, this_trace_uuid) != 0) {
2056 char first_trace_uuid_str[BT_UUID_STR_LEN + 1];
2057 char this_trace_uuid_str[BT_UUID_STR_LEN + 1];
2058
2059 bt_uuid_to_str(first_trace_uuid, first_trace_uuid_str);
2060 bt_uuid_to_str(this_trace_uuid, this_trace_uuid_str);
2061
2062 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
2063 "Multiple traces given, but UUIDs don't match: "
2064 "first-trace-uuid=%s, first-trace-path=%s, "
2065 "trace-uuid=%s, trace-path=%s",
2066 first_trace_uuid_str, first_trace->path->str,
2067 this_trace_uuid_str, this_trace->path->str);
2068 goto error;
2069 }
2070 }
2071
2072 ret = merge_ctf_fs_traces((struct ctf_fs_trace **) traces->pdata,
2073 traces->len, &trace);
2074 if (ret) {
2075 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
2076 "Failed to merge traces with the same UUID.");
2077 goto error;
2078 }
2079
2080 ctf_fs->trace = trace;
2081 } else {
2082 /* Just one trace, it may or may not have a UUID, both are fine. */
2083 ctf_fs->trace = traces->pdata[0];
2084 traces->pdata[0] = NULL;
2085 }
2086
2087 ret = fix_packet_index_tracer_bugs(ctf_fs, self_comp);
2088 if (ret) {
2089 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
2090 "Failed to fix packet index tracer bugs.");
2091 }
2092
2093 /*
2094 * Sort data stream file groups by first data stream file info
2095 * path to get a deterministic order. This order influences the
2096 * order of the output ports. It also influences the order of
2097 * the automatic stream IDs if the trace's packet headers do not
2098 * contain a `stream_instance_id` field, in which case the data
2099 * stream file to stream ID association is always the same,
2100 * whatever the build and the system.
2101 *
2102 * Having a deterministic order here can help debugging and
2103 * testing.
2104 */
2105 g_ptr_array_sort(ctf_fs->trace->ds_file_groups,
2106 compare_ds_file_groups_by_first_path);
2107 goto end;
2108 error:
2109 ret = -1;
2110
2111 end:
2112 g_ptr_array_free(traces, TRUE);
2113 return ret;
2114 }
2115
2116 static
2117 GString *get_stream_instance_unique_name(
2118 struct ctf_fs_ds_file_group *ds_file_group)
2119 {
2120 GString *name;
2121 struct ctf_fs_ds_file_info *ds_file_info;
2122
2123 name = g_string_new(NULL);
2124 if (!name) {
2125 goto end;
2126 }
2127
2128 /*
2129 * If there's more than one stream file in the stream file
2130 * group, the first (earliest) stream file's path is used as
2131 * the stream's unique name.
2132 */
2133 BT_ASSERT(ds_file_group->ds_file_infos->len > 0);
2134 ds_file_info = g_ptr_array_index(ds_file_group->ds_file_infos, 0);
2135 g_string_assign(name, ds_file_info->path->str);
2136
2137 end:
2138 return name;
2139 }
2140
2141 /* Create the IR stream objects for ctf_fs_trace. */
2142
2143 static
2144 int create_streams_for_trace(struct ctf_fs_trace *ctf_fs_trace)
2145 {
2146 int ret;
2147 GString *name = NULL;
2148 guint i;
2149 bt_logging_level log_level = ctf_fs_trace->log_level;
2150 bt_self_component *self_comp = ctf_fs_trace->self_comp;
2151
2152 for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) {
2153 struct ctf_fs_ds_file_group *ds_file_group =
2154 g_ptr_array_index(ctf_fs_trace->ds_file_groups, i);
2155 name = get_stream_instance_unique_name(ds_file_group);
2156
2157 if (!name) {
2158 goto error;
2159 }
2160
2161 if (ds_file_group->sc->ir_sc) {
2162 BT_ASSERT(ctf_fs_trace->trace);
2163
2164 if (ds_file_group->stream_id == UINT64_C(-1)) {
2165 /* No stream ID: use 0 */
2166 ds_file_group->stream = bt_stream_create_with_id(
2167 ds_file_group->sc->ir_sc,
2168 ctf_fs_trace->trace,
2169 ctf_fs_trace->next_stream_id);
2170 ctf_fs_trace->next_stream_id++;
2171 } else {
2172 /* Specific stream ID */
2173 ds_file_group->stream = bt_stream_create_with_id(
2174 ds_file_group->sc->ir_sc,
2175 ctf_fs_trace->trace,
2176 (uint64_t) ds_file_group->stream_id);
2177 }
2178 } else {
2179 ds_file_group->stream = NULL;
2180 }
2181
2182 if (!ds_file_group->stream) {
2183 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
2184 "Cannot create stream for DS file group: "
2185 "addr=%p, stream-name=\"%s\"",
2186 ds_file_group, name->str);
2187 goto error;
2188 }
2189
2190 ret = bt_stream_set_name(ds_file_group->stream,
2191 name->str);
2192 if (ret) {
2193 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot set stream's name: "
2194 "addr=%p, stream-name=\"%s\"",
2195 ds_file_group->stream, name->str);
2196 goto error;
2197 }
2198
2199 g_string_free(name, TRUE);
2200 name = NULL;
2201 }
2202
2203 ret = 0;
2204 goto end;
2205
2206 error:
2207 ret = -1;
2208
2209 end:
2210
2211 if (name) {
2212 g_string_free(name, TRUE);
2213 }
2214 return ret;
2215 }
2216
2217 /*
2218 * Validate the "paths" parameter passed to this component. It must be
2219 * present, and it must be an array of strings.
2220 */
2221
2222 static
2223 bool validate_inputs_parameter(struct ctf_fs_component *ctf_fs,
2224 const bt_value *inputs, bt_self_component *self_comp,
2225 bt_self_component_class *self_comp_class)
2226 {
2227 bool ret;
2228 bt_value_type type;
2229 uint64_t i;
2230 bt_logging_level log_level = ctf_fs->log_level;
2231
2232 if (!inputs) {
2233 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp,
2234 self_comp_class, "missing \"inputs\" parameter");
2235 goto error;
2236 }
2237
2238 type = bt_value_get_type(inputs);
2239 if (type != BT_VALUE_TYPE_ARRAY) {
2240 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp,
2241 self_comp_class, "`inputs` parameter: expecting array value: type=%s",
2242 bt_common_value_type_string(type));
2243 goto error;
2244 }
2245
2246 if (bt_value_array_is_empty(inputs)) {
2247 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp,
2248 self_comp_class, "`inputs` parameter must not be empty");
2249 goto error;
2250 }
2251
2252 for (i = 0; i < bt_value_array_get_length(inputs); i++) {
2253 const bt_value *elem;
2254
2255 elem = bt_value_array_borrow_element_by_index_const(inputs, i);
2256 type = bt_value_get_type(elem);
2257 if (type != BT_VALUE_TYPE_STRING) {
2258 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
2259 "`inputs` parameter: expecting string value: index=%" PRIu64 ", type=%s",
2260 i, bt_common_value_type_string(type));
2261 goto error;
2262 }
2263 }
2264
2265 ret = true;
2266 goto end;
2267
2268 error:
2269 ret = false;
2270
2271 end:
2272 return ret;
2273 }
2274
2275 bool read_src_fs_parameters(const bt_value *params,
2276 const bt_value **inputs,
2277 const bt_value **trace_name,
2278 struct ctf_fs_component *ctf_fs,
2279 bt_self_component *self_comp,
2280 bt_self_component_class *self_comp_class) {
2281 bool ret;
2282 const bt_value *value;
2283 bt_logging_level log_level = ctf_fs->log_level;
2284
2285 /* inputs parameter */
2286 *inputs = bt_value_map_borrow_entry_value_const(params, "inputs");
2287 if (!validate_inputs_parameter(ctf_fs, *inputs, self_comp, self_comp_class)) {
2288 goto error;
2289 }
2290
2291 /* clock-class-offset-s parameter */
2292 value = bt_value_map_borrow_entry_value_const(params,
2293 "clock-class-offset-s");
2294 if (value) {
2295 if (!bt_value_is_signed_integer(value)) {
2296 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
2297 "clock-class-offset-s must be an integer");
2298 goto error;
2299 }
2300 ctf_fs->metadata_config.clock_class_offset_s =
2301 bt_value_integer_signed_get(value);
2302 }
2303
2304 /* clock-class-offset-ns parameter */
2305 value = bt_value_map_borrow_entry_value_const(params,
2306 "clock-class-offset-ns");
2307 if (value) {
2308 if (!bt_value_is_signed_integer(value)) {
2309 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
2310 "clock-class-offset-ns must be an integer");
2311 goto error;
2312 }
2313 ctf_fs->metadata_config.clock_class_offset_ns =
2314 bt_value_integer_signed_get(value);
2315 }
2316
2317 /* force-clock-class-origin-unix-epoch parameter */
2318 value = bt_value_map_borrow_entry_value_const(params,
2319 "force-clock-class-origin-unix-epoch");
2320 if (value) {
2321 if (!bt_value_is_bool(value)) {
2322 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
2323 "force-clock-class-origin-unix-epoch must be a boolean");
2324 goto error;
2325 }
2326
2327 ctf_fs->metadata_config.force_clock_class_origin_unix_epoch =
2328 bt_value_bool_get(value);
2329 }
2330
2331 /* trace-name parameter */
2332 *trace_name = bt_value_map_borrow_entry_value_const(params, "trace-name");
2333 if (*trace_name) {
2334 if (!bt_value_is_string(*trace_name)) {
2335 BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
2336 "trace-name must be a string");
2337 goto error;
2338 }
2339 }
2340
2341 ret = true;
2342 goto end;
2343
2344 error:
2345 ret = false;
2346
2347 end:
2348 return ret;
2349 }
2350
2351 static
2352 struct ctf_fs_component *ctf_fs_create(
2353 const bt_value *params,
2354 bt_self_component_source *self_comp_src,
2355 bt_self_component_class *self_comp_class)
2356 {
2357 struct ctf_fs_component *ctf_fs = NULL;
2358 const bt_value *inputs_value;
2359 const bt_value *trace_name_value;
2360 bt_self_component *self_comp =
2361 bt_self_component_source_as_self_component(self_comp_src);
2362
2363 ctf_fs = ctf_fs_component_create(bt_component_get_logging_level(
2364 bt_self_component_as_component(self_comp)), self_comp);
2365 if (!ctf_fs) {
2366 goto error;
2367 }
2368
2369 if (!read_src_fs_parameters(params, &inputs_value, &trace_name_value,
2370 ctf_fs, self_comp, self_comp_class)) {
2371 goto error;
2372 }
2373
2374 bt_self_component_set_data(self_comp, ctf_fs);
2375
2376 if (ctf_fs_component_create_ctf_fs_trace(ctf_fs, inputs_value,
2377 trace_name_value, self_comp, self_comp_class)) {
2378 goto error;
2379 }
2380
2381 if (create_streams_for_trace(ctf_fs->trace)) {
2382 goto error;
2383 }
2384
2385 if (create_ports_for_trace(ctf_fs, ctf_fs->trace, self_comp_src)) {
2386 goto error;
2387 }
2388
2389 goto end;
2390
2391 error:
2392 ctf_fs_destroy(ctf_fs);
2393 ctf_fs = NULL;
2394 bt_self_component_set_data(self_comp, NULL);
2395
2396 end:
2397 return ctf_fs;
2398 }
2399
2400 BT_HIDDEN
2401 bt_component_class_initialize_method_status ctf_fs_init(
2402 bt_self_component_source *self_comp_src,
2403 bt_self_component_source_configuration *config,
2404 const bt_value *params, __attribute__((unused)) void *init_method_data)
2405 {
2406 struct ctf_fs_component *ctf_fs;
2407 bt_component_class_initialize_method_status ret =
2408 BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
2409
2410 ctf_fs = ctf_fs_create(params, self_comp_src, NULL);
2411 if (!ctf_fs) {
2412 ret = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
2413 }
2414
2415 return ret;
2416 }
2417
2418 BT_HIDDEN
2419 bt_component_class_query_method_status ctf_fs_query(
2420 bt_self_component_class_source *comp_class,
2421 bt_private_query_executor *priv_query_exec,
2422 const char *object, const bt_value *params,
2423 __attribute__((unused)) void *method_data,
2424 const bt_value **result)
2425 {
2426 bt_component_class_query_method_status status =
2427 BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
2428 bt_logging_level log_level = bt_query_executor_get_logging_level(
2429 bt_private_query_executor_as_query_executor_const(
2430 priv_query_exec));
2431
2432 if (strcmp(object, "metadata-info") == 0) {
2433 status = metadata_info_query(comp_class, params, log_level,
2434 result);
2435 } else if (strcmp(object, "babeltrace.trace-infos") == 0) {
2436 status = trace_infos_query(comp_class, params, log_level,
2437 result);
2438 } else if (!strcmp(object, "babeltrace.support-info")) {
2439 status = support_info_query(comp_class, params, log_level, result);
2440 } else {
2441 BT_LOGE("Unknown query object `%s`", object);
2442 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_UNKNOWN_OBJECT;
2443 goto end;
2444 }
2445 end:
2446 return status;
2447 }
BabelTrace - Trace Format Babel Tower
This page took 0.108456 seconds and 5 git commands to generate.