projects / babeltrace.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Re-organize sources
[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 #include "common/common.h"
29 #include <babeltrace2/babeltrace.h>
30 #include "compat/uuid.h"
31 #include "plugins/plugins-common.h"
32 #include <glib.h>
33 #include "common/assert.h"
34 #include <inttypes.h>
35 #include <stdbool.h>
36 #include "fs.h"
37 #include "metadata.h"
38 #include "data-stream-file.h"
39 #include "file.h"
40 #include "../common/metadata/decoder.h"
41 #include "../common/msg-iter/msg-iter.h"
42 #include "../common/utils/utils.h"
43 #include "query.h"
44
45 #define BT_LOG_TAG "PLUGIN-CTF-FS-SRC"
46 #include "logging.h"
47
48 static
49 int msg_iter_data_set_current_ds_file(struct ctf_fs_msg_iter_data *msg_iter_data)
50 {
51 struct ctf_fs_ds_file_info *ds_file_info;
52 int ret = 0;
53
54 BT_ASSERT(msg_iter_data->ds_file_info_index <
55 msg_iter_data->ds_file_group->ds_file_infos->len);
56 ds_file_info = g_ptr_array_index(
57 msg_iter_data->ds_file_group->ds_file_infos,
58 msg_iter_data->ds_file_info_index);
59
60 ctf_fs_ds_file_destroy(msg_iter_data->ds_file);
61 msg_iter_data->ds_file = ctf_fs_ds_file_create(
62 msg_iter_data->ds_file_group->ctf_fs_trace,
63 msg_iter_data->pc_msg_iter,
64 msg_iter_data->msg_iter,
65 msg_iter_data->ds_file_group->stream,
66 ds_file_info->path->str);
67 if (!msg_iter_data->ds_file) {
68 ret = -1;
69 }
70
71 return ret;
72 }
73
74 static
75 void ctf_fs_msg_iter_data_destroy(
76 struct ctf_fs_msg_iter_data *msg_iter_data)
77 {
78 if (!msg_iter_data) {
79 return;
80 }
81
82 ctf_fs_ds_file_destroy(msg_iter_data->ds_file);
83
84 if (msg_iter_data->msg_iter) {
85 bt_msg_iter_destroy(msg_iter_data->msg_iter);
86 }
87
88 g_free(msg_iter_data);
89 }
90
91 static
92 void set_msg_iter_emits_stream_beginning_end_messages(
93 struct ctf_fs_msg_iter_data *msg_iter_data)
94 {
95 bt_msg_iter_set_emit_stream_beginning_message(
96 msg_iter_data->ds_file->msg_iter,
97 msg_iter_data->ds_file_info_index == 0);
98 bt_msg_iter_set_emit_stream_end_message(
99 msg_iter_data->ds_file->msg_iter,
100 msg_iter_data->ds_file_info_index ==
101 msg_iter_data->ds_file_group->ds_file_infos->len - 1);
102 }
103
104 static
105 bt_self_message_iterator_status ctf_fs_iterator_next_one(
106 struct ctf_fs_msg_iter_data *msg_iter_data,
107 const bt_message **out_msg)
108 {
109 bt_self_message_iterator_status status;
110
111 BT_ASSERT(msg_iter_data->ds_file);
112
113 while (true) {
114 bt_message *msg;
115
116 status = ctf_fs_ds_file_next(msg_iter_data->ds_file, &msg);
117 switch (status) {
118 case BT_SELF_MESSAGE_ITERATOR_STATUS_OK:
119 *out_msg = msg;
120 msg = NULL;
121 goto end;
122 case BT_SELF_MESSAGE_ITERATOR_STATUS_END:
123 {
124 int ret;
125
126 if (msg_iter_data->ds_file_info_index ==
127 msg_iter_data->ds_file_group->ds_file_infos->len - 1) {
128 /* End of all group's stream files */
129 goto end;
130 }
131
132 msg_iter_data->ds_file_info_index++;
133 bt_msg_iter_reset_for_next_stream_file(
134 msg_iter_data->msg_iter);
135 set_msg_iter_emits_stream_beginning_end_messages(
136 msg_iter_data);
137
138 /*
139 * Open and start reading the next stream file
140 * within our stream file group.
141 */
142 ret = msg_iter_data_set_current_ds_file(msg_iter_data);
143 if (ret) {
144 status = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR;
145 goto end;
146 }
147
148 /* Continue the loop to get the next message */
149 break;
150 }
151 default:
152 goto end;
153 }
154 }
155
156 end:
157 return status;
158 }
159
160 BT_HIDDEN
161 bt_self_message_iterator_status ctf_fs_iterator_next(
162 bt_self_message_iterator *iterator,
163 bt_message_array_const msgs, uint64_t capacity,
164 uint64_t *count)
165 {
166 bt_self_message_iterator_status status =
167 BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
168 struct ctf_fs_msg_iter_data *msg_iter_data =
169 bt_self_message_iterator_get_data(iterator);
170 uint64_t i = 0;
171
172 while (i < capacity && status == BT_SELF_MESSAGE_ITERATOR_STATUS_OK) {
173 status = ctf_fs_iterator_next_one(msg_iter_data, &msgs[i]);
174 if (status == BT_SELF_MESSAGE_ITERATOR_STATUS_OK) {
175 i++;
176 }
177 }
178
179 if (i > 0) {
180 /*
181 * Even if ctf_fs_iterator_next_one() returned something
182 * else than BT_SELF_MESSAGE_ITERATOR_STATUS_OK, we
183 * accumulated message objects in the output
184 * message array, so we need to return
185 * BT_SELF_MESSAGE_ITERATOR_STATUS_OK so that they are
186 * transfered to downstream. This other status occurs
187 * again the next time muxer_msg_iter_do_next() is
188 * called, possibly without any accumulated
189 * message, in which case we'll return it.
190 */
191 *count = i;
192 status = BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
193 }
194
195 return status;
196 }
197
198 static
199 int ctf_fs_iterator_reset(struct ctf_fs_msg_iter_data *msg_iter_data)
200 {
201 int ret;
202
203 msg_iter_data->ds_file_info_index = 0;
204 ret = msg_iter_data_set_current_ds_file(msg_iter_data);
205 if (ret) {
206 goto end;
207 }
208
209 bt_msg_iter_reset(msg_iter_data->msg_iter);
210 set_msg_iter_emits_stream_beginning_end_messages(msg_iter_data);
211
212 end:
213 return ret;
214 }
215
216 BT_HIDDEN
217 bt_self_message_iterator_status ctf_fs_iterator_seek_beginning(
218 bt_self_message_iterator *it)
219 {
220 struct ctf_fs_msg_iter_data *msg_iter_data =
221 bt_self_message_iterator_get_data(it);
222 bt_self_message_iterator_status status =
223 BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
224
225 BT_ASSERT(msg_iter_data);
226 if (ctf_fs_iterator_reset(msg_iter_data)) {
227 status = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR;
228 }
229
230 return status;
231 }
232
233 BT_HIDDEN
234 void ctf_fs_iterator_finalize(bt_self_message_iterator *it)
235 {
236 ctf_fs_msg_iter_data_destroy(
237 bt_self_message_iterator_get_data(it));
238 }
239
240 BT_HIDDEN
241 bt_self_message_iterator_status ctf_fs_iterator_init(
242 bt_self_message_iterator *self_msg_iter,
243 bt_self_component_source *self_comp,
244 bt_self_component_port_output *self_port)
245 {
246 struct ctf_fs_port_data *port_data;
247 struct ctf_fs_msg_iter_data *msg_iter_data = NULL;
248 bt_self_message_iterator_status ret =
249 BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
250
251 port_data = bt_self_component_port_get_data(
252 bt_self_component_port_output_as_self_component_port(
253 self_port));
254 BT_ASSERT(port_data);
255 msg_iter_data = g_new0(struct ctf_fs_msg_iter_data, 1);
256 if (!msg_iter_data) {
257 ret = BT_SELF_MESSAGE_ITERATOR_STATUS_NOMEM;
258 goto error;
259 }
260
261 msg_iter_data->pc_msg_iter = self_msg_iter;
262 msg_iter_data->msg_iter = bt_msg_iter_create(
263 port_data->ds_file_group->ctf_fs_trace->metadata->tc,
264 bt_common_get_page_size() * 8,
265 ctf_fs_ds_file_medops, NULL);
266 if (!msg_iter_data->msg_iter) {
267 BT_LOGE_STR("Cannot create a CTF message iterator.");
268 ret = BT_SELF_MESSAGE_ITERATOR_STATUS_NOMEM;
269 goto error;
270 }
271
272 msg_iter_data->ds_file_group = port_data->ds_file_group;
273 if (ctf_fs_iterator_reset(msg_iter_data)) {
274 ret = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR;
275 goto error;
276 }
277
278 bt_self_message_iterator_set_data(self_msg_iter,
279 msg_iter_data);
280 if (ret != BT_SELF_MESSAGE_ITERATOR_STATUS_OK) {
281 goto error;
282 }
283
284 msg_iter_data = NULL;
285 goto end;
286
287 error:
288 bt_self_message_iterator_set_data(self_msg_iter, NULL);
289
290 end:
291 ctf_fs_msg_iter_data_destroy(msg_iter_data);
292 return ret;
293 }
294
295 BT_HIDDEN
296 void ctf_fs_destroy(struct ctf_fs_component *ctf_fs)
297 {
298 if (!ctf_fs) {
299 return;
300 }
301
302 if (ctf_fs->traces) {
303 g_ptr_array_free(ctf_fs->traces, TRUE);
304 }
305
306 if (ctf_fs->port_data) {
307 g_ptr_array_free(ctf_fs->port_data, TRUE);
308 }
309
310 g_free(ctf_fs);
311 }
312
313 static
314 void port_data_destroy(struct ctf_fs_port_data *port_data)
315 {
316 if (!port_data) {
317 return;
318 }
319
320 g_free(port_data);
321 }
322
323 static
324 void port_data_destroy_notifier(void *data) {
325 port_data_destroy(data);
326 }
327
328 static
329 void ctf_fs_trace_destroy(struct ctf_fs_trace *ctf_fs_trace)
330 {
331 if (!ctf_fs_trace) {
332 return;
333 }
334
335 if (ctf_fs_trace->ds_file_groups) {
336 g_ptr_array_free(ctf_fs_trace->ds_file_groups, TRUE);
337 }
338
339 BT_TRACE_PUT_REF_AND_RESET(ctf_fs_trace->trace);
340
341 if (ctf_fs_trace->path) {
342 g_string_free(ctf_fs_trace->path, TRUE);
343 }
344
345 if (ctf_fs_trace->name) {
346 g_string_free(ctf_fs_trace->name, TRUE);
347 }
348
349 if (ctf_fs_trace->metadata) {
350 ctf_fs_metadata_fini(ctf_fs_trace->metadata);
351 g_free(ctf_fs_trace->metadata);
352 }
353
354 g_free(ctf_fs_trace);
355 }
356
357 static
358 void ctf_fs_trace_destroy_notifier(void *data)
359 {
360 struct ctf_fs_trace *trace = data;
361 ctf_fs_trace_destroy(trace);
362 }
363
364 struct ctf_fs_component *ctf_fs_component_create(void)
365 {
366 struct ctf_fs_component *ctf_fs;
367
368 ctf_fs = g_new0(struct ctf_fs_component, 1);
369 if (!ctf_fs) {
370 goto error;
371 }
372
373 ctf_fs->port_data =
374 g_ptr_array_new_with_free_func(port_data_destroy_notifier);
375 if (!ctf_fs->port_data) {
376 goto error;
377 }
378
379 ctf_fs->traces =
380 g_ptr_array_new_with_free_func(ctf_fs_trace_destroy_notifier);
381 if (!ctf_fs->traces) {
382 goto error;
383 }
384
385 goto end;
386
387 error:
388 if (ctf_fs) {
389 ctf_fs_destroy(ctf_fs);
390 }
391
392 end:
393 return ctf_fs;
394 }
395
396 void ctf_fs_finalize(bt_self_component_source *component)
397 {
398 ctf_fs_destroy(bt_self_component_get_data(
399 bt_self_component_source_as_self_component(component)));
400 }
401
402 gchar *ctf_fs_make_port_name(struct ctf_fs_ds_file_group *ds_file_group)
403 {
404 GString *name = g_string_new(NULL);
405
406 /*
407 * The unique port name is generated by concatenating unique identifiers
408 * for:
409 *
410 * - the trace
411 * - the stream class
412 * - the stream
413 */
414
415 /* For the trace, use the uuid if present, else the path. */
416 if (ds_file_group->ctf_fs_trace->metadata->tc->is_uuid_set) {
417 char uuid_str[BABELTRACE_UUID_STR_LEN];
418
419 bt_uuid_unparse(ds_file_group->ctf_fs_trace->metadata->tc->uuid, uuid_str);
420 g_string_assign(name, uuid_str);
421 } else {
422 g_string_assign(name, ds_file_group->ctf_fs_trace->path->str);
423 }
424
425 /*
426 * For the stream class, use the id if present. We can omit this field
427 * otherwise, as there will only be a single stream class.
428 */
429 if (ds_file_group->sc->id != UINT64_C(-1)) {
430 g_string_append_printf(name, " | %" PRIu64, ds_file_group->sc->id);
431 }
432
433 /* For the stream, use the id if present, else, use the path. */
434 if (ds_file_group->stream_id != UINT64_C(-1)) {
435 g_string_append_printf(name, " | %" PRIu64, ds_file_group->stream_id);
436 } else {
437 BT_ASSERT(ds_file_group->ds_file_infos->len == 1);
438 struct ctf_fs_ds_file_info *ds_file_info =
439 g_ptr_array_index(ds_file_group->ds_file_infos, 0);
440 g_string_append_printf(name, " | %s", ds_file_info->path->str);
441 }
442
443 return g_string_free(name, FALSE);
444 }
445
446 static
447 int create_one_port_for_trace(struct ctf_fs_component *ctf_fs,
448 struct ctf_fs_trace *ctf_fs_trace,
449 struct ctf_fs_ds_file_group *ds_file_group)
450 {
451 int ret = 0;
452 struct ctf_fs_port_data *port_data = NULL;
453 gchar *port_name;
454
455 port_name = ctf_fs_make_port_name(ds_file_group);
456 if (!port_name) {
457 goto error;
458 }
459
460 BT_LOGD("Creating one port named `%s`", port_name);
461
462 /* Create output port for this file */
463 port_data = g_new0(struct ctf_fs_port_data, 1);
464 if (!port_data) {
465 goto error;
466 }
467
468 port_data->ctf_fs = ctf_fs;
469 port_data->ds_file_group = ds_file_group;
470 ret = bt_self_component_source_add_output_port(
471 ctf_fs->self_comp, port_name, port_data, NULL);
472 if (ret) {
473 goto error;
474 }
475
476 g_ptr_array_add(ctf_fs->port_data, port_data);
477 port_data = NULL;
478 goto end;
479
480 error:
481 ret = -1;
482
483 end:
484 if (port_name) {
485 g_free(port_name);
486 }
487
488 port_data_destroy(port_data);
489 return ret;
490 }
491
492 static
493 int create_ports_for_trace(struct ctf_fs_component *ctf_fs,
494 struct ctf_fs_trace *ctf_fs_trace)
495 {
496 int ret = 0;
497 size_t i;
498
499 /* Create one output port for each stream file group */
500 for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) {
501 struct ctf_fs_ds_file_group *ds_file_group =
502 g_ptr_array_index(ctf_fs_trace->ds_file_groups, i);
503
504 ret = create_one_port_for_trace(ctf_fs, ctf_fs_trace,
505 ds_file_group);
506 if (ret) {
507 BT_LOGE("Cannot create output port.");
508 goto end;
509 }
510 }
511
512 end:
513 return ret;
514 }
515
516 static
517 void ctf_fs_ds_file_info_destroy(struct ctf_fs_ds_file_info *ds_file_info)
518 {
519 if (!ds_file_info) {
520 return;
521 }
522
523 if (ds_file_info->path) {
524 g_string_free(ds_file_info->path, TRUE);
525 }
526
527 g_free(ds_file_info);
528 }
529
530 static
531 struct ctf_fs_ds_file_info *ctf_fs_ds_file_info_create(const char *path,
532 int64_t begin_ns)
533 {
534 struct ctf_fs_ds_file_info *ds_file_info;
535
536 ds_file_info = g_new0(struct ctf_fs_ds_file_info, 1);
537 if (!ds_file_info) {
538 goto end;
539 }
540
541 ds_file_info->path = g_string_new(path);
542 if (!ds_file_info->path) {
543 ctf_fs_ds_file_info_destroy(ds_file_info);
544 ds_file_info = NULL;
545 goto end;
546 }
547
548 ds_file_info->begin_ns = begin_ns;
549
550 end:
551 return ds_file_info;
552 }
553
554 static
555 void ctf_fs_ds_file_group_destroy(struct ctf_fs_ds_file_group *ds_file_group)
556 {
557 if (!ds_file_group) {
558 return;
559 }
560
561 if (ds_file_group->ds_file_infos) {
562 g_ptr_array_free(ds_file_group->ds_file_infos, TRUE);
563 }
564
565 if (ds_file_group->index) {
566 if (ds_file_group->index->entries) {
567 g_ptr_array_free(ds_file_group->index->entries, TRUE);
568 }
569 g_free(ds_file_group->index);
570 }
571
572 bt_stream_put_ref(ds_file_group->stream);
573 g_free(ds_file_group);
574 }
575
576 static
577 struct ctf_fs_ds_file_group *ctf_fs_ds_file_group_create(
578 struct ctf_fs_trace *ctf_fs_trace,
579 struct ctf_stream_class *sc,
580 uint64_t stream_instance_id,
581 struct ctf_fs_ds_index *index)
582 {
583 struct ctf_fs_ds_file_group *ds_file_group;
584
585 ds_file_group = g_new0(struct ctf_fs_ds_file_group, 1);
586 if (!ds_file_group) {
587 goto error;
588 }
589
590 ds_file_group->ds_file_infos = g_ptr_array_new_with_free_func(
591 (GDestroyNotify) ctf_fs_ds_file_info_destroy);
592 if (!ds_file_group->ds_file_infos) {
593 goto error;
594 }
595
596 ds_file_group->index = index;
597
598 ds_file_group->stream_id = stream_instance_id;
599 BT_ASSERT(sc);
600 ds_file_group->sc = sc;
601 ds_file_group->ctf_fs_trace = ctf_fs_trace;
602 goto end;
603
604 error:
605 ctf_fs_ds_file_group_destroy(ds_file_group);
606 ctf_fs_ds_index_destroy(index);
607 ds_file_group = NULL;
608
609 end:
610 return ds_file_group;
611 }
612
613 /* Replace by g_ptr_array_insert when we depend on glib >= 2.40. */
614 static
615 void array_insert(GPtrArray *array, gpointer element, size_t pos)
616 {
617 size_t original_array_len = array->len;
618
619 /* Allocate an unused element at the end of the array. */
620 g_ptr_array_add(array, NULL);
621
622 /* If we are not inserting at the end, move the elements by one. */
623 if (pos < original_array_len) {
624 memmove(&(array->pdata[pos + 1]),
625 &(array->pdata[pos]),
626 (original_array_len - pos) * sizeof(gpointer));
627 }
628
629 /* Insert the value. */
630 array->pdata[pos] = element;
631 }
632
633 /*
634 * Insert ds_file_info in ds_file_group's list of ds_file_infos at the right
635 * place to keep it sorted.
636 */
637
638 static
639 void ds_file_group_insert_ds_file_info_sorted(
640 struct ctf_fs_ds_file_group *ds_file_group,
641 struct ctf_fs_ds_file_info *ds_file_info)
642 {
643 guint i;
644
645 /* Find the spot where to insert this ds_file_info. */
646 for (i = 0; i < ds_file_group->ds_file_infos->len; i++) {
647 struct ctf_fs_ds_file_info *other_ds_file_info =
648 g_ptr_array_index(ds_file_group->ds_file_infos, i);
649
650 if (ds_file_info->begin_ns < other_ds_file_info->begin_ns) {
651 break;
652 }
653 }
654
655 array_insert(ds_file_group->ds_file_infos, ds_file_info, i);
656 }
657
658 static
659 void ds_file_group_insert_ds_index_entry_sorted(
660 struct ctf_fs_ds_file_group *ds_file_group,
661 struct ctf_fs_ds_index_entry *entry)
662 {
663 guint i;
664
665 /* Find the spot where to insert this index entry. */
666 for (i = 0; i < ds_file_group->index->entries->len; i++) {
667 struct ctf_fs_ds_index_entry *other_entry = g_ptr_array_index(
668 ds_file_group->index->entries, i);
669
670 if (entry->timestamp_begin_ns < other_entry->timestamp_begin_ns) {
671 break;
672 }
673 }
674
675 array_insert(ds_file_group->index->entries, entry, i);
676 }
677
678 /*
679 * Create a new ds_file_info using the provided path, begin_ns and index, then
680 * add it to ds_file_group's list of ds_file_infos.
681 */
682
683 static
684 int ctf_fs_ds_file_group_add_ds_file_info(
685 struct ctf_fs_ds_file_group *ds_file_group,
686 const char *path, int64_t begin_ns)
687 {
688 struct ctf_fs_ds_file_info *ds_file_info;
689 int ret = 0;
690
691 ds_file_info = ctf_fs_ds_file_info_create(path, begin_ns);
692 if (!ds_file_info) {
693 goto error;
694 }
695
696 ds_file_group_insert_ds_file_info_sorted(ds_file_group, ds_file_info);
697
698 ds_file_info = NULL;
699 goto end;
700
701 error:
702 ctf_fs_ds_file_info_destroy(ds_file_info);
703 ret = -1;
704 end:
705 return ret;
706 }
707
708 static
709 int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace,
710 const char *path)
711 {
712 int64_t stream_instance_id = -1;
713 int64_t begin_ns = -1;
714 struct ctf_fs_ds_file_group *ds_file_group = NULL;
715 bool add_group = false;
716 int ret;
717 size_t i;
718 struct ctf_fs_ds_file *ds_file = NULL;
719 struct ctf_fs_ds_index *index = NULL;
720 struct bt_msg_iter *msg_iter = NULL;
721 struct ctf_stream_class *sc = NULL;
722 struct bt_msg_iter_packet_properties props;
723
724 msg_iter = bt_msg_iter_create(ctf_fs_trace->metadata->tc,
725 bt_common_get_page_size() * 8, ctf_fs_ds_file_medops, NULL);
726 if (!msg_iter) {
727 BT_LOGE_STR("Cannot create a CTF message iterator.");
728 goto error;
729 }
730
731 ds_file = ctf_fs_ds_file_create(ctf_fs_trace, NULL, msg_iter,
732 NULL, path);
733 if (!ds_file) {
734 goto error;
735 }
736
737 ret = bt_msg_iter_get_packet_properties(ds_file->msg_iter, &props);
738 if (ret) {
739 BT_LOGE("Cannot get stream file's first packet's header and context fields (`%s`).",
740 path);
741 goto error;
742 }
743
744 sc = ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc,
745 props.stream_class_id);
746 BT_ASSERT(sc);
747 stream_instance_id = props.data_stream_id;
748
749 if (props.snapshots.beginning_clock != UINT64_C(-1)) {
750 BT_ASSERT(sc->default_clock_class);
751 ret = bt_util_clock_cycles_to_ns_from_origin(
752 props.snapshots.beginning_clock,
753 sc->default_clock_class->frequency,
754 sc->default_clock_class->offset_seconds,
755 sc->default_clock_class->offset_cycles, &begin_ns);
756 if (ret) {
757 BT_LOGE("Cannot convert clock cycles to nanoseconds from origin (`%s`).",
758 path);
759 goto error;
760 }
761 }
762
763 index = ctf_fs_ds_file_build_index(ds_file);
764 if (!index) {
765 BT_LOGW("Failed to index CTF stream file \'%s\'",
766 ds_file->file->path->str);
767 }
768
769 if (begin_ns == -1) {
770 /*
771 * No beggining timestamp to sort the stream files
772 * within a stream file group, so consider that this
773 * file must be the only one within its group.
774 */
775 stream_instance_id = -1;
776 }
777
778 if (stream_instance_id == -1) {
779 /*
780 * No stream instance ID or no beginning timestamp:
781 * create a unique stream file group for this stream
782 * file because, even if there's a stream instance ID,
783 * there's no timestamp to order the file within its
784 * group.
785 */
786 ds_file_group = ctf_fs_ds_file_group_create(ctf_fs_trace,
787 sc, UINT64_C(-1), index);
788 /* Ownership of index is transferred. */
789 index = NULL;
790
791 if (!ds_file_group) {
792 goto error;
793 }
794
795 ret = ctf_fs_ds_file_group_add_ds_file_info(ds_file_group,
796 path, begin_ns);
797 if (ret) {
798 goto error;
799 }
800
801 add_group = true;
802 goto end;
803 }
804
805 BT_ASSERT(stream_instance_id != -1);
806 BT_ASSERT(begin_ns != -1);
807
808 /* Find an existing stream file group with this ID */
809 for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) {
810 ds_file_group = g_ptr_array_index(
811 ctf_fs_trace->ds_file_groups, i);
812
813 if (ds_file_group->sc == sc &&
814 ds_file_group->stream_id ==
815 stream_instance_id) {
816 break;
817 }
818
819 ds_file_group = NULL;
820 }
821
822 if (!ds_file_group) {
823 ds_file_group = ctf_fs_ds_file_group_create(ctf_fs_trace,
824 sc, stream_instance_id, index);
825 /* Ownership of index is transferred. */
826 index = NULL;
827 if (!ds_file_group) {
828 goto error;
829 }
830
831 add_group = true;
832 }
833
834 ret = ctf_fs_ds_file_group_add_ds_file_info(ds_file_group, path,
835 begin_ns);
836 if (ret) {
837 goto error;
838 }
839
840 goto end;
841
842 error:
843 ctf_fs_ds_file_group_destroy(ds_file_group);
844 ds_file_group = NULL;
845 ret = -1;
846
847 end:
848 if (add_group && ds_file_group) {
849 g_ptr_array_add(ctf_fs_trace->ds_file_groups, ds_file_group);
850 }
851
852 ctf_fs_ds_file_destroy(ds_file);
853
854 if (msg_iter) {
855 bt_msg_iter_destroy(msg_iter);
856 }
857
858 ctf_fs_ds_index_destroy(index);
859 return ret;
860 }
861
862 static
863 int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace)
864 {
865 int ret = 0;
866 const char *basename;
867 GError *error = NULL;
868 GDir *dir = NULL;
869
870 /* Check each file in the path directory, except specific ones */
871 dir = g_dir_open(ctf_fs_trace->path->str, 0, &error);
872 if (!dir) {
873 BT_LOGE("Cannot open directory `%s`: %s (code %d)",
874 ctf_fs_trace->path->str, error->message,
875 error->code);
876 goto error;
877 }
878
879 while ((basename = g_dir_read_name(dir))) {
880 struct ctf_fs_file *file;
881
882 if (!strcmp(basename, CTF_FS_METADATA_FILENAME)) {
883 /* Ignore the metadata stream. */
884 BT_LOGD("Ignoring metadata file `%s" G_DIR_SEPARATOR_S "%s`",
885 ctf_fs_trace->path->str, basename);
886 continue;
887 }
888
889 if (basename[0] == '.') {
890 BT_LOGD("Ignoring hidden file `%s" G_DIR_SEPARATOR_S "%s`",
891 ctf_fs_trace->path->str, basename);
892 continue;
893 }
894
895 /* Create the file. */
896 file = ctf_fs_file_create();
897 if (!file) {
898 BT_LOGE("Cannot create stream file object for file `%s" G_DIR_SEPARATOR_S "%s`",
899 ctf_fs_trace->path->str, basename);
900 goto error;
901 }
902
903 /* Create full path string. */
904 g_string_append_printf(file->path, "%s" G_DIR_SEPARATOR_S "%s",
905 ctf_fs_trace->path->str, basename);
906 if (!g_file_test(file->path->str, G_FILE_TEST_IS_REGULAR)) {
907 BT_LOGD("Ignoring non-regular file `%s`",
908 file->path->str);
909 ctf_fs_file_destroy(file);
910 file = NULL;
911 continue;
912 }
913
914 ret = ctf_fs_file_open(file, "rb");
915 if (ret) {
916 BT_LOGE("Cannot open stream file `%s`", file->path->str);
917 goto error;
918 }
919
920 if (file->size == 0) {
921 /* Skip empty stream. */
922 BT_LOGD("Ignoring empty file `%s`", file->path->str);
923 ctf_fs_file_destroy(file);
924 continue;
925 }
926
927 ret = add_ds_file_to_ds_file_group(ctf_fs_trace,
928 file->path->str);
929 if (ret) {
930 BT_LOGE("Cannot add stream file `%s` to stream file group",
931 file->path->str);
932 ctf_fs_file_destroy(file);
933 goto error;
934 }
935
936 ctf_fs_file_destroy(file);
937 }
938
939 goto end;
940
941 error:
942 ret = -1;
943
944 end:
945 if (dir) {
946 g_dir_close(dir);
947 dir = NULL;
948 }
949
950 if (error) {
951 g_error_free(error);
952 }
953
954 return ret;
955 }
956
957 static
958 int set_trace_name(bt_trace *trace, const char *name_suffix)
959 {
960 int ret = 0;
961 const bt_trace_class *tc = bt_trace_borrow_class_const(trace);
962 const bt_value *val;
963 GString *name;
964
965 name = g_string_new(NULL);
966 if (!name) {
967 BT_LOGE_STR("Failed to allocate a GString.");
968 ret = -1;
969 goto end;
970 }
971
972 /*
973 * Check if we have a trace environment string value named `hostname`.
974 * If so, use it as the trace name's prefix.
975 */
976 val = bt_trace_class_borrow_environment_entry_value_by_name_const(
977 tc, "hostname");
978 if (val && bt_value_is_string(val)) {
979 g_string_append(name, bt_value_string_get(val));
980
981 if (name_suffix) {
982 g_string_append_c(name, G_DIR_SEPARATOR);
983 }
984 }
985
986 if (name_suffix) {
987 g_string_append(name, name_suffix);
988 }
989
990 ret = bt_trace_set_name(trace, name->str);
991 if (ret) {
992 goto end;
993 }
994
995 goto end;
996
997 end:
998 if (name) {
999 g_string_free(name, TRUE);
1000 }
1001
1002 return ret;
1003 }
1004
1005 static
1006 struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component_source *self_comp,
1007 const char *path, const char *name,
1008 struct ctf_fs_metadata_config *metadata_config)
1009 {
1010 struct ctf_fs_trace *ctf_fs_trace;
1011 int ret;
1012
1013 ctf_fs_trace = g_new0(struct ctf_fs_trace, 1);
1014 if (!ctf_fs_trace) {
1015 goto end;
1016 }
1017
1018 ctf_fs_trace->path = g_string_new(path);
1019 if (!ctf_fs_trace->path) {
1020 goto error;
1021 }
1022
1023 ctf_fs_trace->name = g_string_new(name);
1024 if (!ctf_fs_trace->name) {
1025 goto error;
1026 }
1027
1028 ctf_fs_trace->metadata = g_new0(struct ctf_fs_metadata, 1);
1029 if (!ctf_fs_trace->metadata) {
1030 goto error;
1031 }
1032
1033 ctf_fs_metadata_init(ctf_fs_trace->metadata);
1034 ctf_fs_trace->ds_file_groups = g_ptr_array_new_with_free_func(
1035 (GDestroyNotify) ctf_fs_ds_file_group_destroy);
1036 if (!ctf_fs_trace->ds_file_groups) {
1037 goto error;
1038 }
1039
1040 ret = ctf_fs_metadata_set_trace_class(self_comp,
1041 ctf_fs_trace, metadata_config);
1042 if (ret) {
1043 goto error;
1044 }
1045
1046 if (ctf_fs_trace->metadata->trace_class) {
1047 ctf_fs_trace->trace =
1048 bt_trace_create(ctf_fs_trace->metadata->trace_class);
1049 if (!ctf_fs_trace->trace) {
1050 goto error;
1051 }
1052 }
1053
1054 if (ctf_fs_trace->trace) {
1055 ret = set_trace_name(ctf_fs_trace->trace, name);
1056 if (ret) {
1057 goto error;
1058 }
1059 }
1060
1061 ret = create_ds_file_groups(ctf_fs_trace);
1062 if (ret) {
1063 goto error;
1064 }
1065
1066 goto end;
1067
1068 error:
1069 ctf_fs_trace_destroy(ctf_fs_trace);
1070 ctf_fs_trace = NULL;
1071
1072 end:
1073 return ctf_fs_trace;
1074 }
1075
1076 static
1077 int path_is_ctf_trace(const char *path)
1078 {
1079 GString *metadata_path = g_string_new(NULL);
1080 int ret = 0;
1081
1082 if (!metadata_path) {
1083 ret = -1;
1084 goto end;
1085 }
1086
1087 g_string_printf(metadata_path, "%s" G_DIR_SEPARATOR_S "%s", path, CTF_FS_METADATA_FILENAME);
1088
1089 if (g_file_test(metadata_path->str, G_FILE_TEST_IS_REGULAR)) {
1090 ret = 1;
1091 goto end;
1092 }
1093
1094 end:
1095 g_string_free(metadata_path, TRUE);
1096 return ret;
1097 }
1098
1099 static
1100 int add_trace_path(GList **trace_paths, const char *path)
1101 {
1102 GString *norm_path = NULL;
1103 int ret = 0;
1104
1105 norm_path = bt_common_normalize_path(path, NULL);
1106 if (!norm_path) {
1107 BT_LOGE("Failed to normalize path `%s`.", path);
1108 ret = -1;
1109 goto end;
1110 }
1111
1112 // FIXME: Remove or ifdef for __MINGW32__
1113 if (strcmp(norm_path->str, "/") == 0) {
1114 BT_LOGE("Opening a trace in `/` is not supported.");
1115 ret = -1;
1116 goto end;
1117 }
1118
1119 *trace_paths = g_list_prepend(*trace_paths, norm_path);
1120 BT_ASSERT(*trace_paths);
1121 norm_path = NULL;
1122
1123 end:
1124 if (norm_path) {
1125 g_string_free(norm_path, TRUE);
1126 }
1127
1128 return ret;
1129 }
1130
1131 static
1132 int ctf_fs_find_traces(GList **trace_paths, const char *start_path)
1133 {
1134 int ret;
1135 GError *error = NULL;
1136 GDir *dir = NULL;
1137 const char *basename = NULL;
1138
1139 /* Check if the starting path is a CTF trace itself */
1140 ret = path_is_ctf_trace(start_path);
1141 if (ret < 0) {
1142 goto end;
1143 }
1144
1145 if (ret) {
1146 /*
1147 * Stop recursion: a CTF trace cannot contain another
1148 * CTF trace.
1149 */
1150 ret = add_trace_path(trace_paths, start_path);
1151 goto end;
1152 }
1153
1154 /* Look for subdirectories */
1155 if (!g_file_test(start_path, G_FILE_TEST_IS_DIR)) {
1156 /* Starting path is not a directory: end of recursion */
1157 goto end;
1158 }
1159
1160 dir = g_dir_open(start_path, 0, &error);
1161 if (!dir) {
1162 if (error->code == G_FILE_ERROR_ACCES) {
1163 BT_LOGD("Cannot open directory `%s`: %s (code %d): continuing",
1164 start_path, error->message, error->code);
1165 goto end;
1166 }
1167
1168 BT_LOGE("Cannot open directory `%s`: %s (code %d)",
1169 start_path, error->message, error->code);
1170 ret = -1;
1171 goto end;
1172 }
1173
1174 while ((basename = g_dir_read_name(dir))) {
1175 GString *sub_path = g_string_new(NULL);
1176
1177 if (!sub_path) {
1178 ret = -1;
1179 goto end;
1180 }
1181
1182 g_string_printf(sub_path, "%s" G_DIR_SEPARATOR_S "%s", start_path, basename);
1183 ret = ctf_fs_find_traces(trace_paths, sub_path->str);
1184 g_string_free(sub_path, TRUE);
1185 if (ret) {
1186 goto end;
1187 }
1188 }
1189
1190 end:
1191 if (dir) {
1192 g_dir_close(dir);
1193 }
1194
1195 if (error) {
1196 g_error_free(error);
1197 }
1198
1199 return ret;
1200 }
1201
1202 static
1203 GList *ctf_fs_create_trace_names(GList *trace_paths, const char *base_path) {
1204 GList *trace_names = NULL;
1205 GList *node;
1206 const char *last_sep;
1207 size_t base_dist;
1208
1209 /*
1210 * At this point we know that all the trace paths are
1211 * normalized, and so is the base path. This means that
1212 * they are absolute and they don't end with a separator.
1213 * We can simply find the location of the last separator
1214 * in the base path, which gives us the name of the actual
1215 * directory to look into, and use this location as the
1216 * start of each trace name within each trace path.
1217 *
1218 * For example:
1219 *
1220 * Base path: /home/user/my-traces/some-trace
1221 * Trace paths:
1222 * - /home/user/my-traces/some-trace/host1/trace1
1223 * - /home/user/my-traces/some-trace/host1/trace2
1224 * - /home/user/my-traces/some-trace/host2/trace
1225 * - /home/user/my-traces/some-trace/other-trace
1226 *
1227 * In this case the trace names are:
1228 *
1229 * - some-trace/host1/trace1
1230 * - some-trace/host1/trace2
1231 * - some-trace/host2/trace
1232 * - some-trace/other-trace
1233 */
1234 last_sep = strrchr(base_path, G_DIR_SEPARATOR);
1235
1236 /* We know there's at least one separator */
1237 BT_ASSERT(last_sep);
1238
1239 /* Distance to base */
1240 base_dist = last_sep - base_path + 1;
1241
1242 /* Create the trace names */
1243 for (node = trace_paths; node; node = g_list_next(node)) {
1244 GString *trace_name = g_string_new(NULL);
1245 GString *trace_path = node->data;
1246
1247 BT_ASSERT(trace_name);
1248 g_string_assign(trace_name, &trace_path->str[base_dist]);
1249 trace_names = g_list_append(trace_names, trace_name);
1250 }
1251
1252 return trace_names;
1253 }
1254
1255 /* Helper for ctf_fs_component_create_ctf_fs_traces, to handle a single path/root. */
1256
1257 static
1258 int ctf_fs_component_create_ctf_fs_traces_one_root(bt_self_component_source *self_comp,
1259 struct ctf_fs_component *ctf_fs,
1260 const char *path_param)
1261 {
1262 struct ctf_fs_trace *ctf_fs_trace = NULL;
1263 int ret = 0;
1264 GString *norm_path = NULL;
1265 GList *trace_paths = NULL;
1266 GList *trace_names = NULL;
1267 GList *tp_node;
1268 GList *tn_node;
1269
1270 norm_path = bt_common_normalize_path(path_param, NULL);
1271 if (!norm_path) {
1272 BT_LOGE("Failed to normalize path: `%s`.",
1273 path_param);
1274 goto error;
1275 }
1276
1277 ret = ctf_fs_find_traces(&trace_paths, norm_path->str);
1278 if (ret) {
1279 goto error;
1280 }
1281
1282 if (!trace_paths) {
1283 BT_LOGE("No CTF traces recursively found in `%s`.",
1284 path_param);
1285 goto error;
1286 }
1287
1288 trace_names = ctf_fs_create_trace_names(trace_paths, norm_path->str);
1289 if (!trace_names) {
1290 BT_LOGE("Cannot create trace names from trace paths.");
1291 goto error;
1292 }
1293
1294 for (tp_node = trace_paths, tn_node = trace_names; tp_node;
1295 tp_node = g_list_next(tp_node),
1296 tn_node = g_list_next(tn_node)) {
1297 GString *trace_path = tp_node->data;
1298 GString *trace_name = tn_node->data;
1299
1300 ctf_fs_trace = ctf_fs_trace_create(self_comp,
1301 trace_path->str, trace_name->str,
1302 &ctf_fs->metadata_config);
1303 if (!ctf_fs_trace) {
1304 BT_LOGE("Cannot create trace for `%s`.",
1305 trace_path->str);
1306 goto error;
1307 }
1308
1309 g_ptr_array_add(ctf_fs->traces, ctf_fs_trace);
1310 ctf_fs_trace = NULL;
1311 }
1312
1313 goto end;
1314
1315 error:
1316 ret = -1;
1317 ctf_fs_trace_destroy(ctf_fs_trace);
1318
1319 end:
1320 for (tp_node = trace_paths; tp_node; tp_node = g_list_next(tp_node)) {
1321 if (tp_node->data) {
1322 g_string_free(tp_node->data, TRUE);
1323 }
1324 }
1325
1326 for (tn_node = trace_names; tn_node; tn_node = g_list_next(tn_node)) {
1327 if (tn_node->data) {
1328 g_string_free(tn_node->data, TRUE);
1329 }
1330 }
1331
1332 if (trace_paths) {
1333 g_list_free(trace_paths);
1334 }
1335
1336 if (trace_names) {
1337 g_list_free(trace_names);
1338 }
1339
1340 if (norm_path) {
1341 g_string_free(norm_path, TRUE);
1342 }
1343
1344 return ret;
1345 }
1346
1347 /* GCompareFunc to sort traces by UUID. */
1348
1349 static
1350 gint sort_traces_by_uuid(gconstpointer a, gconstpointer b)
1351 {
1352 const struct ctf_fs_trace *trace_a = *((const struct ctf_fs_trace **) a);
1353 const struct ctf_fs_trace *trace_b = *((const struct ctf_fs_trace **) b);
1354
1355 bool trace_a_has_uuid = trace_a->metadata->tc->is_uuid_set;
1356 bool trace_b_has_uuid = trace_b->metadata->tc->is_uuid_set;
1357 gint ret;
1358
1359 /* Order traces without uuid first. */
1360 if (!trace_a_has_uuid && trace_b_has_uuid) {
1361 ret = -1;
1362 } else if (trace_a_has_uuid && !trace_b_has_uuid) {
1363 ret = 1;
1364 } else if (!trace_a_has_uuid && !trace_b_has_uuid) {
1365 ret = 0;
1366 } else {
1367 ret = bt_uuid_compare(trace_a->metadata->tc->uuid, trace_b->metadata->tc->uuid);
1368 }
1369
1370 return ret;
1371 }
1372
1373 /*
1374 * Count the number of stream and event classes defined by this trace's metadata.
1375 *
1376 * This is used to determine which metadata is the "latest", out of multiple
1377 * traces sharing the same UUID. It is assumed that amongst all these metadatas,
1378 * a bigger metadata is a superset of a smaller metadata. Therefore, it is
1379 * enough to just count the classes.
1380 */
1381
1382 static
1383 unsigned int metadata_count_stream_and_event_classes(struct ctf_fs_trace *trace)
1384 {
1385 unsigned int num = trace->metadata->tc->stream_classes->len;
1386 guint i;
1387
1388 for (i = 0; i < trace->metadata->tc->stream_classes->len; i++) {
1389 struct ctf_stream_class *sc = trace->metadata->tc->stream_classes->pdata[i];
1390 num += sc->event_classes->len;
1391 }
1392
1393 return num;
1394 }
1395
1396 /*
1397 * Merge the src ds_file_group into dest. This consists of merging their
1398 * ds_file_infos, making sure to keep the result sorted.
1399 */
1400
1401 static
1402 void merge_ctf_fs_ds_file_groups(struct ctf_fs_ds_file_group *dest, struct ctf_fs_ds_file_group *src)
1403 {
1404 guint i;
1405
1406 for (i = 0; i < src->ds_file_infos->len; i++) {
1407 struct ctf_fs_ds_file_info *ds_file_info =
1408 g_ptr_array_index(src->ds_file_infos, i);
1409
1410 /* Ownership of the ds_file_info is transferred to dest. */
1411 g_ptr_array_index(src->ds_file_infos, i) = NULL;
1412
1413 ds_file_group_insert_ds_file_info_sorted(dest, ds_file_info);
1414 }
1415
1416 /* Merge both indexes. */
1417 for (i = 0; i < src->index->entries->len; i++) {
1418 struct ctf_fs_ds_index_entry *entry = g_ptr_array_index(
1419 src->index->entries, i);
1420
1421 /*
1422 * Ownership of the ctf_fs_ds_index_entry is transferred to
1423 * dest.
1424 */
1425 g_ptr_array_index(src->index->entries, i) = NULL;
1426
1427 ds_file_group_insert_ds_index_entry_sorted(dest, entry);
1428 }
1429 }
1430 /* Merge src_trace's data stream file groups into dest_trace's. */
1431
1432 static
1433 int merge_matching_ctf_fs_ds_file_groups(
1434 struct ctf_fs_trace *dest_trace,
1435 struct ctf_fs_trace *src_trace)
1436 {
1437
1438 GPtrArray *dest = dest_trace->ds_file_groups;
1439 GPtrArray *src = src_trace->ds_file_groups;
1440 guint s_i;
1441 int ret = 0;
1442
1443 /*
1444 * Save the initial length of dest: we only want to check against the
1445 * original elements in the inner loop.
1446 */
1447 const guint dest_len = dest->len;
1448
1449 for (s_i = 0; s_i < src->len; s_i++) {
1450 struct ctf_fs_ds_file_group *src_group = g_ptr_array_index(src, s_i);
1451 struct ctf_fs_ds_file_group *dest_group = NULL;
1452
1453 /* A stream instance without ID can't match a stream in the other trace. */
1454 if (src_group->stream_id != -1) {
1455 guint d_i;
1456
1457 /* Let's search for a matching ds_file_group in the destination. */
1458 for (d_i = 0; d_i < dest_len; d_i++) {
1459 struct ctf_fs_ds_file_group *candidate_dest = g_ptr_array_index(dest, d_i);
1460
1461 /* Can't match a stream instance without ID. */
1462 if (candidate_dest->stream_id == -1) {
1463 continue;
1464 }
1465
1466 /*
1467 * If the two groups have the same stream instance id
1468 * and belong to the same stream class (stream instance
1469 * ids are per-stream class), they represent the same
1470 * stream instance.
1471 */
1472 if (candidate_dest->stream_id != src_group->stream_id ||
1473 candidate_dest->sc->id != src_group->sc->id) {
1474 continue;
1475 }
1476
1477 dest_group = candidate_dest;
1478 break;
1479 }
1480 }
1481
1482 /*
1483 * Didn't find a friend in dest to merge our src_group into?
1484 * Create a new empty one. This can happen if a stream was
1485 * active in the source trace chunk but not in the destination
1486 * trace chunk.
1487 */
1488 if (!dest_group) {
1489 struct ctf_stream_class *sc;
1490 struct ctf_fs_ds_index *index;
1491
1492 sc = ctf_trace_class_borrow_stream_class_by_id(
1493 dest_trace->metadata->tc, src_group->sc->id);
1494 BT_ASSERT(sc);
1495
1496 index = ctf_fs_ds_index_create();
1497 if (!index) {
1498 ret = -1;
1499 goto end;
1500 }
1501
1502 dest_group = ctf_fs_ds_file_group_create(dest_trace, sc,
1503 src_group->stream_id, index);
1504 /* Ownership of index is transferred. */
1505 index = NULL;
1506 if (!dest_group) {
1507 ret = -1;
1508 goto end;
1509 }
1510
1511 g_ptr_array_add(dest_trace->ds_file_groups, dest_group);
1512 }
1513
1514 BT_ASSERT(dest_group);
1515 merge_ctf_fs_ds_file_groups(dest_group, src_group);
1516 }
1517
1518 end:
1519 return ret;
1520 }
1521
1522 /*
1523 * Collapse the given traces, which must all share the same UUID, in a single
1524 * one.
1525 *
1526 * The trace with the most expansive metadata is chosen and all other traces
1527 * are merged into that one. The array slots of all the traces that get merged
1528 * in the chosen one are set to NULL, so only the slot of the chosen trace
1529 * remains non-NULL.
1530 */
1531
1532 static
1533 int merge_ctf_fs_traces(struct ctf_fs_trace **traces, unsigned int num_traces)
1534 {
1535 unsigned int winner_count;
1536 struct ctf_fs_trace *winner;
1537 guint i;
1538 int ret = 0;
1539 char uuid_str[BABELTRACE_UUID_STR_LEN];
1540
1541 BT_ASSERT(num_traces >= 2);
1542
1543 winner_count = metadata_count_stream_and_event_classes(traces[0]);
1544 winner = traces[0];
1545
1546 /* Find the trace with the largest metadata. */
1547 for (i = 1; i < num_traces; i++) {
1548 struct ctf_fs_trace *candidate;
1549 unsigned int candidate_count;
1550
1551 candidate = traces[i];
1552
1553 /* A bit of sanity check. */
1554 BT_ASSERT(bt_uuid_compare(winner->metadata->tc->uuid, candidate->metadata->tc->uuid) == 0);
1555
1556 candidate_count = metadata_count_stream_and_event_classes(candidate);
1557
1558 if (candidate_count > winner_count) {
1559 winner_count = candidate_count;
1560 winner = candidate;
1561 }
1562 }
1563
1564 /* Merge all the other traces in the winning trace. */
1565 for (i = 0; i < num_traces; i++) {
1566 struct ctf_fs_trace *trace = traces[i];
1567
1568 /* Don't merge the winner into itself. */
1569 if (trace == winner) {
1570 continue;
1571 }
1572
1573 /* Merge trace's data stream file groups into winner's. */
1574 ret = merge_matching_ctf_fs_ds_file_groups(winner, trace);
1575 if (ret) {
1576 goto end;
1577 }
1578
1579 /* Free the trace that got merged into winner, clear the slot in the array. */
1580 ctf_fs_trace_destroy(trace);
1581 traces[i] = NULL;
1582 }
1583
1584 /* Use the string representation of the UUID as the trace name. */
1585 bt_uuid_unparse(winner->metadata->tc->uuid, uuid_str);
1586 g_string_printf(winner->name, "%s", uuid_str);
1587
1588 end:
1589 return ret;
1590 }
1591
1592 /*
1593 * Merge all traces of `ctf_fs` that share the same UUID in a single trace.
1594 * Traces with no UUID are not merged.
1595 */
1596
1597 static
1598 int merge_traces_with_same_uuid(struct ctf_fs_component *ctf_fs)
1599 {
1600 GPtrArray *traces = ctf_fs->traces;
1601 guint range_start_idx = 0;
1602 unsigned int num_traces = 0;
1603 guint i;
1604 int ret = 0;
1605
1606 /* Sort the traces by uuid, then collapse traces with the same uuid in a single one. */
1607 g_ptr_array_sort(traces, sort_traces_by_uuid);
1608
1609 /* Find ranges of consecutive traces that share the same UUID. */
1610 while (range_start_idx < traces->len) {
1611 guint range_len;
1612 struct ctf_fs_trace *range_start_trace = g_ptr_array_index(traces, range_start_idx);
1613
1614 /* Exclusive end of range. */
1615 guint range_end_exc_idx = range_start_idx + 1;
1616
1617 while (range_end_exc_idx < traces->len) {
1618 struct ctf_fs_trace *this_trace = g_ptr_array_index(traces, range_end_exc_idx);
1619
1620 if (!range_start_trace->metadata->tc->is_uuid_set ||
1621 (bt_uuid_compare(range_start_trace->metadata->tc->uuid, this_trace->metadata->tc->uuid) != 0)) {
1622 break;
1623 }
1624
1625 range_end_exc_idx++;
1626 }
1627
1628 /* If we have two or more traces with matching UUIDs, merge them. */
1629 range_len = range_end_exc_idx - range_start_idx;
1630 if (range_len > 1) {
1631 struct ctf_fs_trace **range_start = (struct ctf_fs_trace **) &traces->pdata[range_start_idx];
1632 ret = merge_ctf_fs_traces(range_start, range_len);
1633 if (ret) {
1634 goto end;
1635 }
1636 }
1637
1638 num_traces++;
1639 range_start_idx = range_end_exc_idx;
1640 }
1641
1642 /* Clear any NULL slot (traces that got merged in another one) in the array. */
1643 for (i = 0; i < traces->len;) {
1644 if (g_ptr_array_index(traces, i) == NULL) {
1645 g_ptr_array_remove_index_fast(traces, i);
1646 } else {
1647 i++;
1648 }
1649 }
1650
1651 BT_ASSERT(num_traces == traces->len);
1652
1653 end:
1654 return ret;
1655 }
1656
1657 int ctf_fs_component_create_ctf_fs_traces(bt_self_component_source *self_comp,
1658 struct ctf_fs_component *ctf_fs,
1659 const bt_value *paths_value)
1660 {
1661 int ret = 0;
1662 uint64_t i;
1663
1664 for (i = 0; i < bt_value_array_get_size(paths_value); i++) {
1665 const bt_value *path_value = bt_value_array_borrow_element_by_index_const(paths_value, i);
1666 const char *path = bt_value_string_get(path_value);
1667
1668 ret = ctf_fs_component_create_ctf_fs_traces_one_root(self_comp, ctf_fs, path);
1669 if (ret) {
1670 goto end;
1671 }
1672 }
1673
1674 ret = merge_traces_with_same_uuid(ctf_fs);
1675
1676 end:
1677 return ret;
1678 }
1679
1680 static
1681 GString *get_stream_instance_unique_name(
1682 struct ctf_fs_ds_file_group *ds_file_group)
1683 {
1684 GString *name;
1685 struct ctf_fs_ds_file_info *ds_file_info;
1686
1687 name = g_string_new(NULL);
1688 if (!name) {
1689 goto end;
1690 }
1691
1692 /*
1693 * If there's more than one stream file in the stream file
1694 * group, the first (earliest) stream file's path is used as
1695 * the stream's unique name.
1696 */
1697 BT_ASSERT(ds_file_group->ds_file_infos->len > 0);
1698 ds_file_info = g_ptr_array_index(ds_file_group->ds_file_infos, 0);
1699 g_string_assign(name, ds_file_info->path->str);
1700
1701 end:
1702 return name;
1703 }
1704
1705 /* Create the IR stream objects for ctf_fs_trace. */
1706
1707 static
1708 int create_streams_for_trace(struct ctf_fs_trace *ctf_fs_trace)
1709 {
1710 int ret;
1711 GString *name = NULL;
1712 guint i;
1713
1714 for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) {
1715 struct ctf_fs_ds_file_group *ds_file_group =
1716 g_ptr_array_index(ctf_fs_trace->ds_file_groups, i);
1717 name = get_stream_instance_unique_name(ds_file_group);
1718
1719 if (!name) {
1720 goto error;
1721 }
1722
1723 if (ds_file_group->sc->ir_sc) {
1724 BT_ASSERT(ctf_fs_trace->trace);
1725
1726 if (ds_file_group->stream_id == UINT64_C(-1)) {
1727 /* No stream ID: use 0 */
1728 ds_file_group->stream = bt_stream_create_with_id(
1729 ds_file_group->sc->ir_sc,
1730 ctf_fs_trace->trace,
1731 ctf_fs_trace->next_stream_id);
1732 ctf_fs_trace->next_stream_id++;
1733 } else {
1734 /* Specific stream ID */
1735 ds_file_group->stream = bt_stream_create_with_id(
1736 ds_file_group->sc->ir_sc,
1737 ctf_fs_trace->trace,
1738 (uint64_t) ds_file_group->stream_id);
1739 }
1740 } else {
1741 ds_file_group->stream = NULL;
1742 }
1743
1744 if (!ds_file_group->stream) {
1745 BT_LOGE("Cannot create stream for DS file group: "
1746 "addr=%p, stream-name=\"%s\"",
1747 ds_file_group, name->str);
1748 goto error;
1749 }
1750
1751 ret = bt_stream_set_name(ds_file_group->stream,
1752 name->str);
1753 if (ret) {
1754 BT_LOGE("Cannot set stream's name: "
1755 "addr=%p, stream-name=\"%s\"",
1756 ds_file_group->stream, name->str);
1757 goto error;
1758 }
1759
1760 g_string_free(name, TRUE);
1761 name = NULL;
1762 }
1763
1764 ret = 0;
1765 goto end;
1766
1767 error:
1768 ret = -1;
1769
1770 end:
1771
1772 if (name) {
1773 g_string_free(name, TRUE);
1774 }
1775 return ret;
1776 }
1777
1778 /*
1779 * Validate the "paths" parameter passed to this component. It must be
1780 * present, and it must be an array of strings.
1781 */
1782
1783 static
1784 bool validate_paths_parameter(const bt_value *paths)
1785 {
1786 bool ret;
1787 bt_value_type type;
1788 uint64_t i;
1789
1790 if (!paths) {
1791 BT_LOGE("missing \"paths\" parameter");
1792 goto error;
1793 }
1794
1795 type = bt_value_get_type(paths);
1796 if (type != BT_VALUE_TYPE_ARRAY) {
1797 BT_LOGE("`paths` parameter: expecting array value: type=%s",
1798 bt_common_value_type_string(type));
1799 goto error;
1800 }
1801
1802 for (i = 0; i < bt_value_array_get_size(paths); i++) {
1803 const bt_value *elem;
1804
1805 elem = bt_value_array_borrow_element_by_index_const(paths, i);
1806 type = bt_value_get_type(elem);
1807 if (type != BT_VALUE_TYPE_STRING) {
1808 BT_LOGE("`paths` parameter: expecting string value: index=%" PRIu64 ", type=%s",
1809 i, bt_common_value_type_string(type));
1810 goto error;
1811 }
1812 }
1813
1814 ret = true;
1815 goto end;
1816
1817 error:
1818 ret = false;
1819
1820 end:
1821 return ret;
1822 }
1823
1824 bool read_src_fs_parameters(const bt_value *params,
1825 const bt_value **paths, struct ctf_fs_component *ctf_fs) {
1826 bool ret;
1827 const bt_value *value;
1828
1829 /* paths parameter */
1830 *paths = bt_value_map_borrow_entry_value_const(params, "paths");
1831 if (!validate_paths_parameter(*paths)) {
1832 goto error;
1833 }
1834
1835 /* clock-class-offset-s parameter */
1836 value = bt_value_map_borrow_entry_value_const(params,
1837 "clock-class-offset-s");
1838 if (value) {
1839 if (!bt_value_is_signed_integer(value)) {
1840 BT_LOGE("clock-class-offset-s must be an integer");
1841 goto error;
1842 }
1843 ctf_fs->metadata_config.clock_class_offset_s =
1844 bt_value_signed_integer_get(value);
1845 }
1846
1847 /* clock-class-offset-ns parameter */
1848 value = bt_value_map_borrow_entry_value_const(params,
1849 "clock-class-offset-ns");
1850 if (value) {
1851 if (!bt_value_is_signed_integer(value)) {
1852 BT_LOGE("clock-class-offset-ns must be an integer");
1853 goto error;
1854 }
1855 ctf_fs->metadata_config.clock_class_offset_ns =
1856 bt_value_signed_integer_get(value);
1857 }
1858
1859
1860 ret = true;
1861 goto end;
1862
1863 error:
1864 ret = false;
1865
1866 end:
1867 return ret;
1868 }
1869
1870 static
1871 struct ctf_fs_component *ctf_fs_create(
1872 bt_self_component_source *self_comp,
1873 const bt_value *params)
1874 {
1875 struct ctf_fs_component *ctf_fs = NULL;
1876 guint i;
1877 const bt_value *paths_value;
1878
1879 ctf_fs = ctf_fs_component_create();
1880 if (!ctf_fs) {
1881 goto error;
1882 }
1883
1884 if (!read_src_fs_parameters(params, &paths_value, ctf_fs)) {
1885 goto error;
1886 }
1887
1888 bt_self_component_set_data(
1889 bt_self_component_source_as_self_component(self_comp),
1890 ctf_fs);
1891
1892 /*
1893 * We don't need to get a new reference here because as long as
1894 * our private ctf_fs_component object exists, the containing
1895 * private component should also exist.
1896 */
1897 ctf_fs->self_comp = self_comp;
1898
1899 if (ctf_fs_component_create_ctf_fs_traces(self_comp, ctf_fs, paths_value)) {
1900 goto error;
1901 }
1902
1903 for (i = 0; i < ctf_fs->traces->len; i++) {
1904 struct ctf_fs_trace *trace = g_ptr_array_index(ctf_fs->traces, i);
1905
1906 if (create_streams_for_trace(trace)) {
1907 goto error;
1908 }
1909
1910 if (create_ports_for_trace(ctf_fs, trace)) {
1911 goto error;
1912 }
1913 }
1914
1915 goto end;
1916
1917 error:
1918 ctf_fs_destroy(ctf_fs);
1919 ctf_fs = NULL;
1920 bt_self_component_set_data(
1921 bt_self_component_source_as_self_component(self_comp),
1922 NULL);
1923
1924 end:
1925 return ctf_fs;
1926 }
1927
1928 BT_HIDDEN
1929 bt_self_component_status ctf_fs_init(
1930 bt_self_component_source *self_comp,
1931 const bt_value *params, UNUSED_VAR void *init_method_data)
1932 {
1933 struct ctf_fs_component *ctf_fs;
1934 bt_self_component_status ret = BT_SELF_COMPONENT_STATUS_OK;
1935
1936 ctf_fs = ctf_fs_create(self_comp, params);
1937 if (!ctf_fs) {
1938 ret = BT_SELF_COMPONENT_STATUS_ERROR;
1939 }
1940
1941 return ret;
1942 }
1943
1944 BT_HIDDEN
1945 bt_query_status ctf_fs_query(
1946 bt_self_component_class_source *comp_class,
1947 const bt_query_executor *query_exec,
1948 const char *object, const bt_value *params,
1949 const bt_value **result)
1950 {
1951 bt_query_status status = BT_QUERY_STATUS_OK;
1952
1953 if (!strcmp(object, "metadata-info")) {
1954 status = metadata_info_query(comp_class, params, result);
1955 } else if (!strcmp(object, "trace-info")) {
1956 status = trace_info_query(comp_class, params, result);
1957 } else {
1958 BT_LOGE("Unknown query object `%s`", object);
1959 status = BT_QUERY_STATUS_INVALID_OBJECT;
1960 goto end;
1961 }
1962 end:
1963 return status;
1964 }
BabelTrace - Trace Format Babel Tower
This page took 0.117889 seconds and 5 git commands to generate.