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