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