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