projects / babeltrace.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ctf: add weak ref to stream file in index entry
[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 static
701 int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace,
702 const char *path)
703 {
704 int64_t stream_instance_id = -1;
705 int64_t begin_ns = -1;
706 struct ctf_fs_ds_file_group *ds_file_group = NULL;
707 bool add_group = false;
708 int ret;
709 size_t i;
710 struct ctf_fs_ds_file *ds_file = NULL;
711 struct ctf_fs_ds_file_info *ds_file_info = NULL;
712 struct ctf_fs_ds_index *index = NULL;
713 struct bt_msg_iter *msg_iter = NULL;
714 struct ctf_stream_class *sc = NULL;
715 struct bt_msg_iter_packet_properties props;
716 bt_logging_level log_level = ctf_fs_trace->log_level;
717 bt_self_component *self_comp = ctf_fs_trace->self_comp;
718
719 msg_iter = bt_msg_iter_create(ctf_fs_trace->metadata->tc,
720 bt_common_get_page_size(log_level) * 8,
721 ctf_fs_ds_file_medops, NULL, log_level, self_comp);
722 if (!msg_iter) {
723 BT_COMP_LOGE_STR("Cannot create a CTF message iterator.");
724 goto error;
725 }
726
727 ds_file = ctf_fs_ds_file_create(ctf_fs_trace, NULL, msg_iter,
728 NULL, path, log_level);
729 if (!ds_file) {
730 goto error;
731 }
732
733 ret = bt_msg_iter_get_packet_properties(ds_file->msg_iter, &props);
734 if (ret) {
735 BT_COMP_LOGE("Cannot get stream file's first packet's header and context fields (`%s`).",
736 path);
737 goto error;
738 }
739
740 sc = ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc,
741 props.stream_class_id);
742 BT_ASSERT(sc);
743 stream_instance_id = props.data_stream_id;
744
745 if (props.snapshots.beginning_clock != UINT64_C(-1)) {
746 BT_ASSERT(sc->default_clock_class);
747 ret = bt_util_clock_cycles_to_ns_from_origin(
748 props.snapshots.beginning_clock,
749 sc->default_clock_class->frequency,
750 sc->default_clock_class->offset_seconds,
751 sc->default_clock_class->offset_cycles, &begin_ns);
752 if (ret) {
753 BT_COMP_LOGE("Cannot convert clock cycles to nanoseconds from origin (`%s`).",
754 path);
755 goto error;
756 }
757 }
758
759 ds_file_info = ctf_fs_ds_file_info_create(path, begin_ns);
760 if (!ds_file_info) {
761 goto error;
762 }
763
764 index = ctf_fs_ds_file_build_index(ds_file, ds_file_info);
765 if (!index) {
766 BT_COMP_LOGW("Failed to index CTF stream file \'%s\'",
767 ds_file->file->path->str);
768 }
769
770 if (begin_ns == -1) {
771 /*
772 * No beggining timestamp to sort the stream files
773 * within a stream file group, so consider that this
774 * file must be the only one within its group.
775 */
776 stream_instance_id = -1;
777 }
778
779 if (stream_instance_id == -1) {
780 /*
781 * No stream instance ID or no beginning timestamp:
782 * create a unique stream file group for this stream
783 * file because, even if there's a stream instance ID,
784 * there's no timestamp to order the file within its
785 * group.
786 */
787 ds_file_group = ctf_fs_ds_file_group_create(ctf_fs_trace,
788 sc, UINT64_C(-1), index);
789 /* Ownership of index is transferred. */
790 index = NULL;
791
792 if (!ds_file_group) {
793 goto error;
794 }
795
796 ds_file_group_insert_ds_file_info_sorted(ds_file_group, ds_file_info);
797
798 add_group = true;
799 goto end;
800 }
801
802 BT_ASSERT(stream_instance_id != -1);
803 BT_ASSERT(begin_ns != -1);
804
805 /* Find an existing stream file group with this ID */
806 for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) {
807 ds_file_group = g_ptr_array_index(
808 ctf_fs_trace->ds_file_groups, i);
809
810 if (ds_file_group->sc == sc &&
811 ds_file_group->stream_id ==
812 stream_instance_id) {
813 break;
814 }
815
816 ds_file_group = NULL;
817 }
818
819 if (!ds_file_group) {
820 ds_file_group = ctf_fs_ds_file_group_create(ctf_fs_trace,
821 sc, stream_instance_id, index);
822 /* Ownership of index is transferred. */
823 index = NULL;
824 if (!ds_file_group) {
825 goto error;
826 }
827
828 add_group = true;
829 }
830
831 ds_file_group_insert_ds_file_info_sorted(ds_file_group, ds_file_info);
832
833 goto end;
834
835 error:
836 ctf_fs_ds_file_group_destroy(ds_file_group);
837 ds_file_group = NULL;
838 ret = -1;
839
840 end:
841 if (add_group && ds_file_group) {
842 g_ptr_array_add(ctf_fs_trace->ds_file_groups, ds_file_group);
843 }
844
845 ctf_fs_ds_file_destroy(ds_file);
846
847 if (msg_iter) {
848 bt_msg_iter_destroy(msg_iter);
849 }
850
851 ctf_fs_ds_index_destroy(index);
852 return ret;
853 }
854
855 static
856 int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace)
857 {
858 int ret = 0;
859 const char *basename;
860 GError *error = NULL;
861 GDir *dir = NULL;
862 bt_logging_level log_level = ctf_fs_trace->log_level;
863 bt_self_component *self_comp = ctf_fs_trace->self_comp;
864
865 /* Check each file in the path directory, except specific ones */
866 dir = g_dir_open(ctf_fs_trace->path->str, 0, &error);
867 if (!dir) {
868 BT_COMP_LOGE("Cannot open directory `%s`: %s (code %d)",
869 ctf_fs_trace->path->str, error->message,
870 error->code);
871 goto error;
872 }
873
874 while ((basename = g_dir_read_name(dir))) {
875 struct ctf_fs_file *file;
876
877 if (strcmp(basename, CTF_FS_METADATA_FILENAME) == 0) {
878 /* Ignore the metadata stream. */
879 BT_COMP_LOGI("Ignoring metadata file `%s" G_DIR_SEPARATOR_S "%s`",
880 ctf_fs_trace->path->str, basename);
881 continue;
882 }
883
884 if (basename[0] == '.') {
885 BT_COMP_LOGI("Ignoring hidden file `%s" G_DIR_SEPARATOR_S "%s`",
886 ctf_fs_trace->path->str, basename);
887 continue;
888 }
889
890 /* Create the file. */
891 file = ctf_fs_file_create(log_level, self_comp);
892 if (!file) {
893 BT_COMP_LOGE("Cannot create stream file object for file `%s" G_DIR_SEPARATOR_S "%s`",
894 ctf_fs_trace->path->str, basename);
895 goto error;
896 }
897
898 /* Create full path string. */
899 g_string_append_printf(file->path, "%s" G_DIR_SEPARATOR_S "%s",
900 ctf_fs_trace->path->str, basename);
901 if (!g_file_test(file->path->str, G_FILE_TEST_IS_REGULAR)) {
902 BT_COMP_LOGI("Ignoring non-regular file `%s`",
903 file->path->str);
904 ctf_fs_file_destroy(file);
905 file = NULL;
906 continue;
907 }
908
909 ret = ctf_fs_file_open(file, "rb");
910 if (ret) {
911 BT_COMP_LOGE("Cannot open stream file `%s`", file->path->str);
912 goto error;
913 }
914
915 if (file->size == 0) {
916 /* Skip empty stream. */
917 BT_COMP_LOGI("Ignoring empty file `%s`", file->path->str);
918 ctf_fs_file_destroy(file);
919 continue;
920 }
921
922 ret = add_ds_file_to_ds_file_group(ctf_fs_trace,
923 file->path->str);
924 if (ret) {
925 BT_COMP_LOGE("Cannot add stream file `%s` to stream file group",
926 file->path->str);
927 ctf_fs_file_destroy(file);
928 goto error;
929 }
930
931 ctf_fs_file_destroy(file);
932 }
933
934 goto end;
935
936 error:
937 ret = -1;
938
939 end:
940 if (dir) {
941 g_dir_close(dir);
942 dir = NULL;
943 }
944
945 if (error) {
946 g_error_free(error);
947 }
948
949 return ret;
950 }
951
952 static
953 int set_trace_name(bt_trace *trace, const char *name_suffix,
954 bt_logging_level log_level, bt_self_component *self_comp)
955 {
956 int ret = 0;
957 const bt_value *val;
958 GString *name;
959
960 name = g_string_new(NULL);
961 if (!name) {
962 BT_COMP_LOGE_STR("Failed to allocate a GString.");
963 ret = -1;
964 goto end;
965 }
966
967 /*
968 * Check if we have a trace environment string value named `hostname`.
969 * If so, use it as the trace name's prefix.
970 */
971 val = bt_trace_borrow_environment_entry_value_by_name_const(
972 trace, "hostname");
973 if (val && bt_value_is_string(val)) {
974 g_string_append(name, bt_value_string_get(val));
975
976 if (name_suffix) {
977 g_string_append_c(name, G_DIR_SEPARATOR);
978 }
979 }
980
981 if (name_suffix) {
982 g_string_append(name, name_suffix);
983 }
984
985 ret = bt_trace_set_name(trace, name->str);
986 if (ret) {
987 goto end;
988 }
989
990 goto end;
991
992 end:
993 if (name) {
994 g_string_free(name, TRUE);
995 }
996
997 return ret;
998 }
999
1000 static
1001 struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component *self_comp,
1002 const char *path, const char *name,
1003 struct ctf_fs_metadata_config *metadata_config,
1004 bt_logging_level log_level)
1005 {
1006 struct ctf_fs_trace *ctf_fs_trace;
1007 int ret;
1008
1009 ctf_fs_trace = g_new0(struct ctf_fs_trace, 1);
1010 if (!ctf_fs_trace) {
1011 goto end;
1012 }
1013
1014 ctf_fs_trace->log_level = log_level;
1015 ctf_fs_trace->self_comp = self_comp;
1016 ctf_fs_trace->path = g_string_new(path);
1017 if (!ctf_fs_trace->path) {
1018 goto error;
1019 }
1020
1021 ctf_fs_trace->name = g_string_new(name);
1022 if (!ctf_fs_trace->name) {
1023 goto error;
1024 }
1025
1026 ctf_fs_trace->metadata = g_new0(struct ctf_fs_metadata, 1);
1027 if (!ctf_fs_trace->metadata) {
1028 goto error;
1029 }
1030
1031 ctf_fs_metadata_init(ctf_fs_trace->metadata);
1032 ctf_fs_trace->ds_file_groups = g_ptr_array_new_with_free_func(
1033 (GDestroyNotify) ctf_fs_ds_file_group_destroy);
1034 if (!ctf_fs_trace->ds_file_groups) {
1035 goto error;
1036 }
1037
1038 ret = ctf_fs_metadata_set_trace_class(self_comp, ctf_fs_trace,
1039 metadata_config);
1040 if (ret) {
1041 goto error;
1042 }
1043
1044 if (ctf_fs_trace->metadata->trace_class) {
1045 ctf_fs_trace->trace =
1046 bt_trace_create(ctf_fs_trace->metadata->trace_class);
1047 if (!ctf_fs_trace->trace) {
1048 goto error;
1049 }
1050 }
1051
1052 if (ctf_fs_trace->trace) {
1053 ret = ctf_trace_class_configure_ir_trace(
1054 ctf_fs_trace->metadata->tc, ctf_fs_trace->trace);
1055 if (ret) {
1056 goto error;
1057 }
1058
1059 ret = set_trace_name(ctf_fs_trace->trace, name, log_level,
1060 self_comp);
1061 if (ret) {
1062 goto error;
1063 }
1064 }
1065
1066 ret = create_ds_file_groups(ctf_fs_trace);
1067 if (ret) {
1068 goto error;
1069 }
1070
1071 goto end;
1072
1073 error:
1074 ctf_fs_trace_destroy(ctf_fs_trace);
1075 ctf_fs_trace = NULL;
1076
1077 end:
1078 return ctf_fs_trace;
1079 }
1080
1081 static
1082 int path_is_ctf_trace(const char *path)
1083 {
1084 GString *metadata_path = g_string_new(NULL);
1085 int ret = 0;
1086
1087 if (!metadata_path) {
1088 ret = -1;
1089 goto end;
1090 }
1091
1092 g_string_printf(metadata_path, "%s" G_DIR_SEPARATOR_S "%s", path, CTF_FS_METADATA_FILENAME);
1093
1094 if (g_file_test(metadata_path->str, G_FILE_TEST_IS_REGULAR)) {
1095 ret = 1;
1096 goto end;
1097 }
1098
1099 end:
1100 g_string_free(metadata_path, TRUE);
1101 return ret;
1102 }
1103
1104 static
1105 int add_trace_path(GList **trace_paths, const char *path,
1106 bt_logging_level log_level, bt_self_component *self_comp)
1107 {
1108 GString *norm_path = NULL;
1109 int ret = 0;
1110
1111 norm_path = bt_common_normalize_path(path, NULL);
1112 if (!norm_path) {
1113 BT_COMP_LOGE("Failed to normalize path `%s`.", path);
1114 ret = -1;
1115 goto end;
1116 }
1117
1118 // FIXME: Remove or ifdef for __MINGW32__
1119 if (strcmp(norm_path->str, "/") == 0) {
1120 BT_COMP_LOGE("Opening a trace in `/` is not supported.");
1121 ret = -1;
1122 goto end;
1123 }
1124
1125 *trace_paths = g_list_prepend(*trace_paths, norm_path);
1126 BT_ASSERT(*trace_paths);
1127 norm_path = NULL;
1128
1129 end:
1130 if (norm_path) {
1131 g_string_free(norm_path, TRUE);
1132 }
1133
1134 return ret;
1135 }
1136
1137 static
1138 int ctf_fs_find_traces(GList **trace_paths, const char *start_path,
1139 bt_logging_level log_level, bt_self_component *self_comp)
1140 {
1141 int ret;
1142 GError *error = NULL;
1143 GDir *dir = NULL;
1144 const char *basename = NULL;
1145
1146 /* Check if the starting path is a CTF trace itself */
1147 ret = path_is_ctf_trace(start_path);
1148 if (ret < 0) {
1149 goto end;
1150 }
1151
1152 if (ret) {
1153 /*
1154 * Stop recursion: a CTF trace cannot contain another
1155 * CTF trace.
1156 */
1157 ret = add_trace_path(trace_paths, start_path, log_level,
1158 self_comp);
1159 goto end;
1160 }
1161
1162 /* Look for subdirectories */
1163 if (!g_file_test(start_path, G_FILE_TEST_IS_DIR)) {
1164 /* Starting path is not a directory: end of recursion */
1165 goto end;
1166 }
1167
1168 dir = g_dir_open(start_path, 0, &error);
1169 if (!dir) {
1170 if (error->code == G_FILE_ERROR_ACCES) {
1171 BT_COMP_LOGI("Cannot open directory `%s`: %s (code %d): continuing",
1172 start_path, error->message, error->code);
1173 goto end;
1174 }
1175
1176 BT_COMP_LOGE("Cannot open directory `%s`: %s (code %d)",
1177 start_path, error->message, error->code);
1178 ret = -1;
1179 goto end;
1180 }
1181
1182 while ((basename = g_dir_read_name(dir))) {
1183 GString *sub_path = g_string_new(NULL);
1184
1185 if (!sub_path) {
1186 ret = -1;
1187 goto end;
1188 }
1189
1190 g_string_printf(sub_path, "%s" G_DIR_SEPARATOR_S "%s", start_path, basename);
1191 ret = ctf_fs_find_traces(trace_paths, sub_path->str,
1192 log_level, self_comp);
1193 g_string_free(sub_path, TRUE);
1194 if (ret) {
1195 goto end;
1196 }
1197 }
1198
1199 end:
1200 if (dir) {
1201 g_dir_close(dir);
1202 }
1203
1204 if (error) {
1205 g_error_free(error);
1206 }
1207
1208 return ret;
1209 }
1210
1211 static
1212 GList *ctf_fs_create_trace_names(GList *trace_paths, const char *base_path) {
1213 GList *trace_names = NULL;
1214 GList *node;
1215 const char *last_sep;
1216 size_t base_dist;
1217
1218 /*
1219 * At this point we know that all the trace paths are
1220 * normalized, and so is the base path. This means that
1221 * they are absolute and they don't end with a separator.
1222 * We can simply find the location of the last separator
1223 * in the base path, which gives us the name of the actual
1224 * directory to look into, and use this location as the
1225 * start of each trace name within each trace path.
1226 *
1227 * For example:
1228 *
1229 * Base path: /home/user/my-traces/some-trace
1230 * Trace paths:
1231 * - /home/user/my-traces/some-trace/host1/trace1
1232 * - /home/user/my-traces/some-trace/host1/trace2
1233 * - /home/user/my-traces/some-trace/host2/trace
1234 * - /home/user/my-traces/some-trace/other-trace
1235 *
1236 * In this case the trace names are:
1237 *
1238 * - some-trace/host1/trace1
1239 * - some-trace/host1/trace2
1240 * - some-trace/host2/trace
1241 * - some-trace/other-trace
1242 */
1243 last_sep = strrchr(base_path, G_DIR_SEPARATOR);
1244
1245 /* We know there's at least one separator */
1246 BT_ASSERT(last_sep);
1247
1248 /* Distance to base */
1249 base_dist = last_sep - base_path + 1;
1250
1251 /* Create the trace names */
1252 for (node = trace_paths; node; node = g_list_next(node)) {
1253 GString *trace_name = g_string_new(NULL);
1254 GString *trace_path = node->data;
1255
1256 BT_ASSERT(trace_name);
1257 g_string_assign(trace_name, &trace_path->str[base_dist]);
1258 trace_names = g_list_append(trace_names, trace_name);
1259 }
1260
1261 return trace_names;
1262 }
1263
1264 /* Helper for ctf_fs_component_create_ctf_fs_traces, to handle a single path/root. */
1265
1266 static
1267 int ctf_fs_component_create_ctf_fs_traces_one_root(
1268 struct ctf_fs_component *ctf_fs,
1269 const char *path_param)
1270 {
1271 struct ctf_fs_trace *ctf_fs_trace = NULL;
1272 int ret = 0;
1273 GString *norm_path = NULL;
1274 GList *trace_paths = NULL;
1275 GList *trace_names = NULL;
1276 GList *tp_node;
1277 GList *tn_node;
1278 bt_logging_level log_level = ctf_fs->log_level;
1279 bt_self_component *self_comp = ctf_fs->self_comp;
1280
1281 norm_path = bt_common_normalize_path(path_param, NULL);
1282 if (!norm_path) {
1283 BT_COMP_LOGE("Failed to normalize path: `%s`.",
1284 path_param);
1285 goto error;
1286 }
1287
1288 ret = ctf_fs_find_traces(&trace_paths, norm_path->str, log_level,
1289 self_comp);
1290 if (ret) {
1291 goto error;
1292 }
1293
1294 if (!trace_paths) {
1295 BT_COMP_LOGE("No CTF traces recursively found in `%s`.",
1296 path_param);
1297 (void) BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT(
1298 ctf_fs->self_comp,
1299 "No CTF traces recursively found in `%s`.", path_param);
1300 goto error;
1301 }
1302
1303 trace_names = ctf_fs_create_trace_names(trace_paths, norm_path->str);
1304 if (!trace_names) {
1305 BT_COMP_LOGE("Cannot create trace names from trace paths.");
1306 goto error;
1307 }
1308
1309 for (tp_node = trace_paths, tn_node = trace_names; tp_node;
1310 tp_node = g_list_next(tp_node),
1311 tn_node = g_list_next(tn_node)) {
1312 GString *trace_path = tp_node->data;
1313 GString *trace_name = tn_node->data;
1314
1315 ctf_fs_trace = ctf_fs_trace_create(self_comp,
1316 trace_path->str, trace_name->str,
1317 &ctf_fs->metadata_config,
1318 log_level);
1319 if (!ctf_fs_trace) {
1320 BT_COMP_LOGE("Cannot create trace for `%s`.",
1321 trace_path->str);
1322 goto error;
1323 }
1324
1325 g_ptr_array_add(ctf_fs->traces, ctf_fs_trace);
1326 ctf_fs_trace = NULL;
1327 }
1328
1329 goto end;
1330
1331 error:
1332 ret = -1;
1333 ctf_fs_trace_destroy(ctf_fs_trace);
1334
1335 end:
1336 for (tp_node = trace_paths; tp_node; tp_node = g_list_next(tp_node)) {
1337 if (tp_node->data) {
1338 g_string_free(tp_node->data, TRUE);
1339 }
1340 }
1341
1342 for (tn_node = trace_names; tn_node; tn_node = g_list_next(tn_node)) {
1343 if (tn_node->data) {
1344 g_string_free(tn_node->data, TRUE);
1345 }
1346 }
1347
1348 if (trace_paths) {
1349 g_list_free(trace_paths);
1350 }
1351
1352 if (trace_names) {
1353 g_list_free(trace_names);
1354 }
1355
1356 if (norm_path) {
1357 g_string_free(norm_path, TRUE);
1358 }
1359
1360 return ret;
1361 }
1362
1363 /* GCompareFunc to sort traces by UUID. */
1364
1365 static
1366 gint sort_traces_by_uuid(gconstpointer a, gconstpointer b)
1367 {
1368 const struct ctf_fs_trace *trace_a = *((const struct ctf_fs_trace **) a);
1369 const struct ctf_fs_trace *trace_b = *((const struct ctf_fs_trace **) b);
1370
1371 bool trace_a_has_uuid = trace_a->metadata->tc->is_uuid_set;
1372 bool trace_b_has_uuid = trace_b->metadata->tc->is_uuid_set;
1373 gint ret;
1374
1375 /* Order traces without uuid first. */
1376 if (!trace_a_has_uuid && trace_b_has_uuid) {
1377 ret = -1;
1378 } else if (trace_a_has_uuid && !trace_b_has_uuid) {
1379 ret = 1;
1380 } else if (!trace_a_has_uuid && !trace_b_has_uuid) {
1381 ret = 0;
1382 } else {
1383 ret = bt_uuid_compare(trace_a->metadata->tc->uuid, trace_b->metadata->tc->uuid);
1384 }
1385
1386 return ret;
1387 }
1388
1389 /*
1390 * Count the number of stream and event classes defined by this trace's metadata.
1391 *
1392 * This is used to determine which metadata is the "latest", out of multiple
1393 * traces sharing the same UUID. It is assumed that amongst all these metadatas,
1394 * a bigger metadata is a superset of a smaller metadata. Therefore, it is
1395 * enough to just count the classes.
1396 */
1397
1398 static
1399 unsigned int metadata_count_stream_and_event_classes(struct ctf_fs_trace *trace)
1400 {
1401 unsigned int num = trace->metadata->tc->stream_classes->len;
1402 guint i;
1403
1404 for (i = 0; i < trace->metadata->tc->stream_classes->len; i++) {
1405 struct ctf_stream_class *sc = trace->metadata->tc->stream_classes->pdata[i];
1406 num += sc->event_classes->len;
1407 }
1408
1409 return num;
1410 }
1411
1412 /*
1413 * Merge the src ds_file_group into dest. This consists of merging their
1414 * ds_file_infos, making sure to keep the result sorted.
1415 */
1416
1417 static
1418 void merge_ctf_fs_ds_file_groups(struct ctf_fs_ds_file_group *dest, struct ctf_fs_ds_file_group *src)
1419 {
1420 guint i;
1421
1422 for (i = 0; i < src->ds_file_infos->len; i++) {
1423 struct ctf_fs_ds_file_info *ds_file_info =
1424 g_ptr_array_index(src->ds_file_infos, i);
1425
1426 /* Ownership of the ds_file_info is transferred to dest. */
1427 g_ptr_array_index(src->ds_file_infos, i) = NULL;
1428
1429 ds_file_group_insert_ds_file_info_sorted(dest, ds_file_info);
1430 }
1431
1432 /* Merge both indexes. */
1433 for (i = 0; i < src->index->entries->len; i++) {
1434 struct ctf_fs_ds_index_entry *entry = g_ptr_array_index(
1435 src->index->entries, i);
1436
1437 /*
1438 * Ownership of the ctf_fs_ds_index_entry is transferred to
1439 * dest.
1440 */
1441 g_ptr_array_index(src->index->entries, i) = NULL;
1442
1443 ds_file_group_insert_ds_index_entry_sorted(dest, entry);
1444 }
1445 }
1446 /* Merge src_trace's data stream file groups into dest_trace's. */
1447
1448 static
1449 int merge_matching_ctf_fs_ds_file_groups(
1450 struct ctf_fs_trace *dest_trace,
1451 struct ctf_fs_trace *src_trace)
1452 {
1453
1454 GPtrArray *dest = dest_trace->ds_file_groups;
1455 GPtrArray *src = src_trace->ds_file_groups;
1456 guint s_i;
1457 int ret = 0;
1458
1459 /*
1460 * Save the initial length of dest: we only want to check against the
1461 * original elements in the inner loop.
1462 */
1463 const guint dest_len = dest->len;
1464
1465 for (s_i = 0; s_i < src->len; s_i++) {
1466 struct ctf_fs_ds_file_group *src_group = g_ptr_array_index(src, s_i);
1467 struct ctf_fs_ds_file_group *dest_group = NULL;
1468
1469 /* A stream instance without ID can't match a stream in the other trace. */
1470 if (src_group->stream_id != -1) {
1471 guint d_i;
1472
1473 /* Let's search for a matching ds_file_group in the destination. */
1474 for (d_i = 0; d_i < dest_len; d_i++) {
1475 struct ctf_fs_ds_file_group *candidate_dest = g_ptr_array_index(dest, d_i);
1476
1477 /* Can't match a stream instance without ID. */
1478 if (candidate_dest->stream_id == -1) {
1479 continue;
1480 }
1481
1482 /*
1483 * If the two groups have the same stream instance id
1484 * and belong to the same stream class (stream instance
1485 * ids are per-stream class), they represent the same
1486 * stream instance.
1487 */
1488 if (candidate_dest->stream_id != src_group->stream_id ||
1489 candidate_dest->sc->id != src_group->sc->id) {
1490 continue;
1491 }
1492
1493 dest_group = candidate_dest;
1494 break;
1495 }
1496 }
1497
1498 /*
1499 * Didn't find a friend in dest to merge our src_group into?
1500 * Create a new empty one. This can happen if a stream was
1501 * active in the source trace chunk but not in the destination
1502 * trace chunk.
1503 */
1504 if (!dest_group) {
1505 struct ctf_stream_class *sc;
1506 struct ctf_fs_ds_index *index;
1507
1508 sc = ctf_trace_class_borrow_stream_class_by_id(
1509 dest_trace->metadata->tc, src_group->sc->id);
1510 BT_ASSERT(sc);
1511
1512 index = ctf_fs_ds_index_create(dest_trace->log_level,
1513 dest_trace->self_comp);
1514 if (!index) {
1515 ret = -1;
1516 goto end;
1517 }
1518
1519 dest_group = ctf_fs_ds_file_group_create(dest_trace, sc,
1520 src_group->stream_id, index);
1521 /* Ownership of index is transferred. */
1522 index = NULL;
1523 if (!dest_group) {
1524 ret = -1;
1525 goto end;
1526 }
1527
1528 g_ptr_array_add(dest_trace->ds_file_groups, dest_group);
1529 }
1530
1531 BT_ASSERT(dest_group);
1532 merge_ctf_fs_ds_file_groups(dest_group, src_group);
1533 }
1534
1535 end:
1536 return ret;
1537 }
1538
1539 /*
1540 * Collapse the given traces, which must all share the same UUID, in a single
1541 * one.
1542 *
1543 * The trace with the most expansive metadata is chosen and all other traces
1544 * are merged into that one. The array slots of all the traces that get merged
1545 * in the chosen one are set to NULL, so only the slot of the chosen trace
1546 * remains non-NULL.
1547 */
1548
1549 static
1550 int merge_ctf_fs_traces(struct ctf_fs_trace **traces, unsigned int num_traces)
1551 {
1552 unsigned int winner_count;
1553 struct ctf_fs_trace *winner;
1554 guint i;
1555 int ret = 0;
1556 char uuid_str[BT_UUID_STR_LEN + 1];
1557
1558 BT_ASSERT(num_traces >= 2);
1559
1560 winner_count = metadata_count_stream_and_event_classes(traces[0]);
1561 winner = traces[0];
1562
1563 /* Find the trace with the largest metadata. */
1564 for (i = 1; i < num_traces; i++) {
1565 struct ctf_fs_trace *candidate;
1566 unsigned int candidate_count;
1567
1568 candidate = traces[i];
1569
1570 /* A bit of sanity check. */
1571 BT_ASSERT(bt_uuid_compare(winner->metadata->tc->uuid, candidate->metadata->tc->uuid) == 0);
1572
1573 candidate_count = metadata_count_stream_and_event_classes(candidate);
1574
1575 if (candidate_count > winner_count) {
1576 winner_count = candidate_count;
1577 winner = candidate;
1578 }
1579 }
1580
1581 /* Merge all the other traces in the winning trace. */
1582 for (i = 0; i < num_traces; i++) {
1583 struct ctf_fs_trace *trace = traces[i];
1584
1585 /* Don't merge the winner into itself. */
1586 if (trace == winner) {
1587 continue;
1588 }
1589
1590 /* Merge trace's data stream file groups into winner's. */
1591 ret = merge_matching_ctf_fs_ds_file_groups(winner, trace);
1592 if (ret) {
1593 goto end;
1594 }
1595
1596 /* Free the trace that got merged into winner, clear the slot in the array. */
1597 ctf_fs_trace_destroy(trace);
1598 traces[i] = NULL;
1599 }
1600
1601 /* Use the string representation of the UUID as the trace name. */
1602 bt_uuid_to_str(winner->metadata->tc->uuid, uuid_str);
1603 g_string_printf(winner->name, "%s", uuid_str);
1604
1605 end:
1606 return ret;
1607 }
1608
1609 /*
1610 * Merge all traces of `ctf_fs` that share the same UUID in a single trace.
1611 * Traces with no UUID are not merged.
1612 */
1613
1614 static
1615 int merge_traces_with_same_uuid(struct ctf_fs_component *ctf_fs)
1616 {
1617 GPtrArray *traces = ctf_fs->traces;
1618 guint range_start_idx = 0;
1619 unsigned int num_traces = 0;
1620 guint i;
1621 int ret = 0;
1622
1623 /* Sort the traces by uuid, then collapse traces with the same uuid in a single one. */
1624 g_ptr_array_sort(traces, sort_traces_by_uuid);
1625
1626 /* Find ranges of consecutive traces that share the same UUID. */
1627 while (range_start_idx < traces->len) {
1628 guint range_len;
1629 struct ctf_fs_trace *range_start_trace = g_ptr_array_index(traces, range_start_idx);
1630
1631 /* Exclusive end of range. */
1632 guint range_end_exc_idx = range_start_idx + 1;
1633
1634 while (range_end_exc_idx < traces->len) {
1635 struct ctf_fs_trace *this_trace = g_ptr_array_index(traces, range_end_exc_idx);
1636
1637 if (!range_start_trace->metadata->tc->is_uuid_set ||
1638 (bt_uuid_compare(range_start_trace->metadata->tc->uuid, this_trace->metadata->tc->uuid) != 0)) {
1639 break;
1640 }
1641
1642 range_end_exc_idx++;
1643 }
1644
1645 /* If we have two or more traces with matching UUIDs, merge them. */
1646 range_len = range_end_exc_idx - range_start_idx;
1647 if (range_len > 1) {
1648 struct ctf_fs_trace **range_start = (struct ctf_fs_trace **) &traces->pdata[range_start_idx];
1649 ret = merge_ctf_fs_traces(range_start, range_len);
1650 if (ret) {
1651 goto end;
1652 }
1653 }
1654
1655 num_traces++;
1656 range_start_idx = range_end_exc_idx;
1657 }
1658
1659 /* Clear any NULL slot (traces that got merged in another one) in the array. */
1660 for (i = 0; i < traces->len;) {
1661 if (!g_ptr_array_index(traces, i)) {
1662 g_ptr_array_remove_index_fast(traces, i);
1663 } else {
1664 i++;
1665 }
1666 }
1667
1668 BT_ASSERT(num_traces == traces->len);
1669
1670 end:
1671 return ret;
1672 }
1673
1674 /*
1675 * Extract the tracer information necessary to compare versions.
1676 * Returns 0 on success, and -1 if the extraction is not successful because the
1677 * necessary fields are absents in the trace metadata.
1678 */
1679 static
1680 int extract_tracer_info(struct ctf_fs_trace *trace,
1681 struct tracer_info *current_tracer_info) __attribute__((unused));
1682 static
1683 int extract_tracer_info(struct ctf_fs_trace *trace,
1684 struct tracer_info *current_tracer_info)
1685 {
1686 int ret = 0;
1687 struct ctf_trace_class_env_entry *entry;
1688
1689 /* Clear the current_tracer_info struct */
1690 memset(current_tracer_info, 0, sizeof(*current_tracer_info));
1691
1692 /*
1693 * To compare 2 tracer versions, at least the tracer name and it's
1694 * major version are needed. If one of these is missing, consider it an
1695 * extraction failure.
1696 */
1697 entry = ctf_trace_class_borrow_env_entry_by_name(
1698 trace->metadata->tc, "tracer_name");
1699 if (!entry || entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_STR) {
1700 goto missing_bare_minimum;
1701 }
1702
1703 /* Set tracer name. */
1704 current_tracer_info->name = entry->value.str->str;
1705
1706 entry = ctf_trace_class_borrow_env_entry_by_name(
1707 trace->metadata->tc, "tracer_major");
1708 if (!entry || entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT) {
1709 goto missing_bare_minimum;
1710 }
1711
1712 /* Set major version number. */
1713 current_tracer_info->major = entry->value.i;
1714
1715 entry = ctf_trace_class_borrow_env_entry_by_name(
1716 trace->metadata->tc, "tracer_minor");
1717 if (!entry || entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT) {
1718 goto end;
1719 }
1720
1721 /* Set minor version number. */
1722 current_tracer_info->minor = entry->value.i;
1723
1724 entry = ctf_trace_class_borrow_env_entry_by_name(
1725 trace->metadata->tc, "tracer_patch");
1726 if (!entry) {
1727 /*
1728 * If `tracer_patch` doesn't exist `tracer_patchlevel` might.
1729 * For example, `lttng-modules` uses entry name
1730 * `tracer_patchlevel`.
1731 */
1732 entry = ctf_trace_class_borrow_env_entry_by_name(
1733 trace->metadata->tc, "tracer_patchlevel");
1734 }
1735
1736 if (!entry || entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT) {
1737 goto end;
1738 }
1739
1740 /* Set patch version number. */
1741 current_tracer_info->patch = entry->value.i;
1742
1743 goto end;
1744
1745 missing_bare_minimum:
1746 ret = -1;
1747 end:
1748 return ret;
1749 }
1750
1751 int ctf_fs_component_create_ctf_fs_traces(bt_self_component_source *self_comp,
1752 struct ctf_fs_component *ctf_fs,
1753 const bt_value *paths_value)
1754 {
1755 int ret = 0;
1756 uint64_t i;
1757
1758 for (i = 0; i < bt_value_array_get_length(paths_value); i++) {
1759 const bt_value *path_value = bt_value_array_borrow_element_by_index_const(paths_value, i);
1760 const char *input = bt_value_string_get(path_value);
1761
1762 ret = ctf_fs_component_create_ctf_fs_traces_one_root(ctf_fs,
1763 input);
1764 if (ret) {
1765 goto end;
1766 }
1767 }
1768
1769 ret = merge_traces_with_same_uuid(ctf_fs);
1770
1771 end:
1772 return ret;
1773 }
1774
1775 static
1776 GString *get_stream_instance_unique_name(
1777 struct ctf_fs_ds_file_group *ds_file_group)
1778 {
1779 GString *name;
1780 struct ctf_fs_ds_file_info *ds_file_info;
1781
1782 name = g_string_new(NULL);
1783 if (!name) {
1784 goto end;
1785 }
1786
1787 /*
1788 * If there's more than one stream file in the stream file
1789 * group, the first (earliest) stream file's path is used as
1790 * the stream's unique name.
1791 */
1792 BT_ASSERT(ds_file_group->ds_file_infos->len > 0);
1793 ds_file_info = g_ptr_array_index(ds_file_group->ds_file_infos, 0);
1794 g_string_assign(name, ds_file_info->path->str);
1795
1796 end:
1797 return name;
1798 }
1799
1800 /* Create the IR stream objects for ctf_fs_trace. */
1801
1802 static
1803 int create_streams_for_trace(struct ctf_fs_trace *ctf_fs_trace)
1804 {
1805 int ret;
1806 GString *name = NULL;
1807 guint i;
1808 bt_logging_level log_level = ctf_fs_trace->log_level;
1809 bt_self_component *self_comp = ctf_fs_trace->self_comp;
1810
1811 for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) {
1812 struct ctf_fs_ds_file_group *ds_file_group =
1813 g_ptr_array_index(ctf_fs_trace->ds_file_groups, i);
1814 name = get_stream_instance_unique_name(ds_file_group);
1815
1816 if (!name) {
1817 goto error;
1818 }
1819
1820 if (ds_file_group->sc->ir_sc) {
1821 BT_ASSERT(ctf_fs_trace->trace);
1822
1823 if (ds_file_group->stream_id == UINT64_C(-1)) {
1824 /* No stream ID: use 0 */
1825 ds_file_group->stream = bt_stream_create_with_id(
1826 ds_file_group->sc->ir_sc,
1827 ctf_fs_trace->trace,
1828 ctf_fs_trace->next_stream_id);
1829 ctf_fs_trace->next_stream_id++;
1830 } else {
1831 /* Specific stream ID */
1832 ds_file_group->stream = bt_stream_create_with_id(
1833 ds_file_group->sc->ir_sc,
1834 ctf_fs_trace->trace,
1835 (uint64_t) ds_file_group->stream_id);
1836 }
1837 } else {
1838 ds_file_group->stream = NULL;
1839 }
1840
1841 if (!ds_file_group->stream) {
1842 BT_COMP_LOGE("Cannot create stream for DS file group: "
1843 "addr=%p, stream-name=\"%s\"",
1844 ds_file_group, name->str);
1845 goto error;
1846 }
1847
1848 ret = bt_stream_set_name(ds_file_group->stream,
1849 name->str);
1850 if (ret) {
1851 BT_COMP_LOGE("Cannot set stream's name: "
1852 "addr=%p, stream-name=\"%s\"",
1853 ds_file_group->stream, name->str);
1854 goto error;
1855 }
1856
1857 g_string_free(name, TRUE);
1858 name = NULL;
1859 }
1860
1861 ret = 0;
1862 goto end;
1863
1864 error:
1865 ret = -1;
1866
1867 end:
1868
1869 if (name) {
1870 g_string_free(name, TRUE);
1871 }
1872 return ret;
1873 }
1874
1875 /*
1876 * Validate the "paths" parameter passed to this component. It must be
1877 * present, and it must be an array of strings.
1878 */
1879
1880 static
1881 bool validate_inputs_parameter(struct ctf_fs_component *ctf_fs,
1882 const bt_value *inputs)
1883 {
1884 bool ret;
1885 bt_value_type type;
1886 uint64_t i;
1887 bt_logging_level log_level = ctf_fs->log_level;
1888 bt_self_component *self_comp = ctf_fs->self_comp;
1889
1890 if (!inputs) {
1891 BT_COMP_LOGE("missing \"inputs\" parameter");
1892 goto error;
1893 }
1894
1895 type = bt_value_get_type(inputs);
1896 if (type != BT_VALUE_TYPE_ARRAY) {
1897 BT_COMP_LOGE("`inputs` parameter: expecting array value: type=%s",
1898 bt_common_value_type_string(type));
1899 goto error;
1900 }
1901
1902 for (i = 0; i < bt_value_array_get_length(inputs); i++) {
1903 const bt_value *elem;
1904
1905 elem = bt_value_array_borrow_element_by_index_const(inputs, i);
1906 type = bt_value_get_type(elem);
1907 if (type != BT_VALUE_TYPE_STRING) {
1908 BT_COMP_LOGE("`inputs` parameter: expecting string value: index=%" PRIu64 ", type=%s",
1909 i, bt_common_value_type_string(type));
1910 goto error;
1911 }
1912 }
1913
1914 ret = true;
1915 goto end;
1916
1917 error:
1918 ret = false;
1919
1920 end:
1921 return ret;
1922 }
1923
1924 bool read_src_fs_parameters(const bt_value *params,
1925 const bt_value **inputs, struct ctf_fs_component *ctf_fs) {
1926 bool ret;
1927 const bt_value *value;
1928 bt_logging_level log_level = ctf_fs->log_level;
1929 bt_self_component *self_comp = ctf_fs->self_comp;
1930
1931 /* inputs parameter */
1932 *inputs = bt_value_map_borrow_entry_value_const(params, "inputs");
1933 if (!validate_inputs_parameter(ctf_fs, *inputs)) {
1934 goto error;
1935 }
1936
1937 /* clock-class-offset-s parameter */
1938 value = bt_value_map_borrow_entry_value_const(params,
1939 "clock-class-offset-s");
1940 if (value) {
1941 if (!bt_value_is_signed_integer(value)) {
1942 BT_COMP_LOGE("clock-class-offset-s must be an integer");
1943 goto error;
1944 }
1945 ctf_fs->metadata_config.clock_class_offset_s =
1946 bt_value_integer_signed_get(value);
1947 }
1948
1949 /* clock-class-offset-ns parameter */
1950 value = bt_value_map_borrow_entry_value_const(params,
1951 "clock-class-offset-ns");
1952 if (value) {
1953 if (!bt_value_is_signed_integer(value)) {
1954 BT_COMP_LOGE("clock-class-offset-ns must be an integer");
1955 goto error;
1956 }
1957 ctf_fs->metadata_config.clock_class_offset_ns =
1958 bt_value_integer_signed_get(value);
1959 }
1960
1961
1962 ret = true;
1963 goto end;
1964
1965 error:
1966 ret = false;
1967
1968 end:
1969 return ret;
1970 }
1971
1972 static
1973 struct ctf_fs_component *ctf_fs_create(
1974 bt_self_component_source *self_comp_src,
1975 const bt_value *params)
1976 {
1977 struct ctf_fs_component *ctf_fs = NULL;
1978 guint i;
1979 const bt_value *inputs_value;
1980 bt_self_component *self_comp =
1981 bt_self_component_source_as_self_component(self_comp_src);
1982
1983 ctf_fs = ctf_fs_component_create(bt_component_get_logging_level(
1984 bt_self_component_as_component(self_comp)), self_comp);
1985 if (!ctf_fs) {
1986 goto error;
1987 }
1988
1989 if (!read_src_fs_parameters(params, &inputs_value, ctf_fs)) {
1990 goto error;
1991 }
1992
1993 bt_self_component_set_data(self_comp, ctf_fs);
1994 ctf_fs->self_comp = self_comp;
1995 ctf_fs->self_comp_src = self_comp_src;
1996
1997 if (ctf_fs_component_create_ctf_fs_traces(self_comp_src, ctf_fs, inputs_value)) {
1998 goto error;
1999 }
2000
2001 for (i = 0; i < ctf_fs->traces->len; i++) {
2002 struct ctf_fs_trace *trace = g_ptr_array_index(ctf_fs->traces, i);
2003
2004 if (create_streams_for_trace(trace)) {
2005 goto error;
2006 }
2007
2008 if (create_ports_for_trace(ctf_fs, trace)) {
2009 goto error;
2010 }
2011 }
2012
2013 goto end;
2014
2015 error:
2016 ctf_fs_destroy(ctf_fs);
2017 ctf_fs = NULL;
2018 bt_self_component_set_data(self_comp, NULL);
2019
2020 end:
2021 return ctf_fs;
2022 }
2023
2024 BT_HIDDEN
2025 bt_component_class_init_method_status ctf_fs_init(
2026 bt_self_component_source *self_comp,
2027 const bt_value *params, __attribute__((unused)) void *init_method_data)
2028 {
2029 struct ctf_fs_component *ctf_fs;
2030 bt_component_class_init_method_status ret =
2031 BT_COMPONENT_CLASS_INIT_METHOD_STATUS_OK;
2032
2033 ctf_fs = ctf_fs_create(self_comp, params);
2034 if (!ctf_fs) {
2035 ret = BT_COMPONENT_CLASS_INIT_METHOD_STATUS_ERROR;
2036 }
2037
2038 return ret;
2039 }
2040
2041 BT_HIDDEN
2042 bt_component_class_query_method_status ctf_fs_query(
2043 bt_self_component_class_source *comp_class,
2044 bt_private_query_executor *priv_query_exec,
2045 const char *object, const bt_value *params,
2046 __attribute__((unused)) void *method_data,
2047 const bt_value **result)
2048 {
2049 bt_component_class_query_method_status status =
2050 BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
2051 bt_logging_level log_level = bt_query_executor_get_logging_level(
2052 bt_private_query_executor_as_query_executor_const(
2053 priv_query_exec));
2054
2055 if (strcmp(object, "metadata-info") == 0) {
2056 status = metadata_info_query(comp_class, params, log_level,
2057 result);
2058 } else if (strcmp(object, "babeltrace.trace-info") == 0) {
2059 status = trace_info_query(comp_class, params, log_level,
2060 result);
2061 } else if (!strcmp(object, "babeltrace.support-info")) {
2062 status = support_info_query(comp_class, params, log_level, result);
2063 } else {
2064 BT_LOGE("Unknown query object `%s`", object);
2065 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_UNKNOWN_OBJECT;
2066 goto end;
2067 }
2068 end:
2069 return status;
2070 }
BabelTrace - Trace Format Babel Tower
This page took 0.090827 seconds and 5 git commands to generate.