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