projects / babeltrace.git / blob
? search:


2dfaa19f1ee4bd2d3ef288f914aa3161aec23233
[babeltrace.git] / plugins / ctf / fs-src / fs.c
1 /*
2 * fs.c
3 *
4 * Babeltrace CTF file system Reader Component
5 *
6 * Copyright 2015-2017 Philippe Proulx <pproulx@efficios.com>
7 * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a copy
10 * of this software and associated documentation files (the "Software"), to deal
11 * in the Software without restriction, including without limitation the rights
12 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 * copies of the Software, and to permit persons to whom the Software is
14 * furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included in
17 * all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 * SOFTWARE.
26 */
27
28 #include <babeltrace/common-internal.h>
29 #include <babeltrace/babeltrace.h>
30 #include <plugins-common.h>
31 #include <glib.h>
32 #include <babeltrace/assert-internal.h>
33 #include <inttypes.h>
34 #include <stdbool.h>
35 #include "fs.h"
36 #include "metadata.h"
37 #include "data-stream-file.h"
38 #include "file.h"
39 #include "../common/metadata/decoder.h"
40 #include "../common/notif-iter/notif-iter.h"
41 #include "../common/utils/utils.h"
42 #include "query.h"
43
44 #define BT_LOG_TAG "PLUGIN-CTF-FS-SRC"
45 #include "logging.h"
46
47 static
48 int notif_iter_data_set_current_ds_file(struct ctf_fs_notif_iter_data *notif_iter_data)
49 {
50 struct ctf_fs_ds_file_info *ds_file_info;
51 int ret = 0;
52
53 BT_ASSERT(notif_iter_data->ds_file_info_index <
54 notif_iter_data->ds_file_group->ds_file_infos->len);
55 ds_file_info = g_ptr_array_index(
56 notif_iter_data->ds_file_group->ds_file_infos,
57 notif_iter_data->ds_file_info_index);
58
59 ctf_fs_ds_file_destroy(notif_iter_data->ds_file);
60 notif_iter_data->ds_file = ctf_fs_ds_file_create(
61 notif_iter_data->ds_file_group->ctf_fs_trace,
62 notif_iter_data->pc_notif_iter,
63 notif_iter_data->notif_iter,
64 notif_iter_data->ds_file_group->stream,
65 ds_file_info->path->str);
66 if (!notif_iter_data->ds_file) {
67 ret = -1;
68 }
69
70 return ret;
71 }
72
73 static
74 void ctf_fs_notif_iter_data_destroy(
75 struct ctf_fs_notif_iter_data *notif_iter_data)
76 {
77 if (!notif_iter_data) {
78 return;
79 }
80
81 ctf_fs_ds_file_destroy(notif_iter_data->ds_file);
82
83 if (notif_iter_data->notif_iter) {
84 bt_notif_iter_destroy(notif_iter_data->notif_iter);
85 }
86
87 g_free(notif_iter_data);
88 }
89
90 static
91 enum bt_self_notification_iterator_status ctf_fs_iterator_next_one(
92 struct ctf_fs_notif_iter_data *notif_iter_data,
93 struct bt_notification **notif)
94 {
95 enum bt_self_notification_iterator_status status;
96 struct bt_private_notification *priv_notif;
97 int ret;
98
99 BT_ASSERT(notif_iter_data->ds_file);
100 status = ctf_fs_ds_file_next(notif_iter_data->ds_file, &priv_notif);
101 *notif = bt_private_notification_as_notification(priv_notif);
102
103 if (status == BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK &&
104 bt_notification_get_type(*notif) ==
105 BT_NOTIFICATION_TYPE_STREAM_BEGIN) {
106 if (notif_iter_data->skip_stream_begin_notifs) {
107 /*
108 * We already emitted a
109 * BT_NOTIFICATION_TYPE_STREAM_BEGIN
110 * notification: skip this one, get a new one.
111 */
112 BT_OBJECT_PUT_REF_AND_RESET(*notif);
113 status = ctf_fs_ds_file_next(notif_iter_data->ds_file,
114 &priv_notif);
115 *notif = bt_private_notification_as_notification(priv_notif);
116 BT_ASSERT(status != BT_SELF_NOTIFICATION_ITERATOR_STATUS_END);
117 goto end;
118 } else {
119 /*
120 * First BT_NOTIFICATION_TYPE_STREAM_BEGIN
121 * notification: skip all following.
122 */
123 notif_iter_data->skip_stream_begin_notifs = true;
124 goto end;
125 }
126 }
127
128 if (status == BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK &&
129 bt_notification_get_type(*notif) ==
130 BT_NOTIFICATION_TYPE_STREAM_END) {
131 notif_iter_data->ds_file_info_index++;
132
133 if (notif_iter_data->ds_file_info_index ==
134 notif_iter_data->ds_file_group->ds_file_infos->len) {
135 /*
136 * No more stream files to read: we reached the
137 * real end. Emit this
138 * BT_NOTIFICATION_TYPE_STREAM_END notification.
139 * The next time ctf_fs_iterator_next() is
140 * called for this notification iterator,
141 * ctf_fs_ds_file_next() will return
142 * BT_SELF_NOTIFICATION_ITERATOR_STATUS_END().
143 */
144 goto end;
145 }
146
147 BT_OBJECT_PUT_REF_AND_RESET(*notif);
148 bt_notif_iter_reset(notif_iter_data->notif_iter);
149
150 /*
151 * Open and start reading the next stream file within
152 * our stream file group.
153 */
154 ret = notif_iter_data_set_current_ds_file(notif_iter_data);
155 if (ret) {
156 status = BT_SELF_NOTIFICATION_ITERATOR_STATUS_ERROR;
157 goto end;
158 }
159
160 status = ctf_fs_ds_file_next(notif_iter_data->ds_file, &priv_notif);
161 *notif = bt_private_notification_as_notification(priv_notif);
162
163 /*
164 * If we get a notification, we expect to get a
165 * BT_NOTIFICATION_TYPE_STREAM_BEGIN notification
166 * because the iterator's state machine emits one before
167 * even requesting the first block of data from the
168 * medium. Skip this notification because we're not
169 * really starting a new stream here, and try getting a
170 * new notification (which, if it works, is a
171 * BT_NOTIFICATION_TYPE_PACKET_BEGIN one). We're sure to
172 * get at least one pair of
173 * BT_NOTIFICATION_TYPE_PACKET_BEGIN and
174 * BT_NOTIFICATION_TYPE_PACKET_END notifications in the
175 * case of a single, empty packet. We know there's at
176 * least one packet because the stream file group does
177 * not contain empty stream files.
178 */
179 BT_ASSERT(notif_iter_data->skip_stream_begin_notifs);
180
181 if (status == BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK) {
182 BT_ASSERT(bt_notification_get_type(*notif) ==
183 BT_NOTIFICATION_TYPE_STREAM_BEGIN);
184 BT_OBJECT_PUT_REF_AND_RESET(*notif);
185 status = ctf_fs_ds_file_next(notif_iter_data->ds_file,
186 &priv_notif);
187 *notif = bt_private_notification_as_notification(priv_notif);
188 BT_ASSERT(status != BT_SELF_NOTIFICATION_ITERATOR_STATUS_END);
189 }
190 }
191
192 end:
193 return status;
194 }
195
196 BT_HIDDEN
197 enum bt_self_notification_iterator_status ctf_fs_iterator_next(
198 struct bt_self_notification_iterator *iterator,
199 bt_notification_array notifs, uint64_t capacity,
200 uint64_t *count)
201 {
202 enum bt_self_notification_iterator_status status =
203 BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK;
204 struct ctf_fs_notif_iter_data *notif_iter_data =
205 bt_self_notification_iterator_get_data(iterator);
206 uint64_t i = 0;
207
208 while (i < capacity && status == BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK) {
209 status = ctf_fs_iterator_next_one(notif_iter_data, &notifs[i]);
210 if (status == BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK) {
211 i++;
212 }
213 }
214
215 if (i > 0) {
216 /*
217 * Even if ctf_fs_iterator_next_one() returned something
218 * else than BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK, we
219 * accumulated notification objects in the output
220 * notification array, so we need to return
221 * BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK so that they are
222 * transfered to downstream. This other status occurs
223 * again the next time muxer_notif_iter_do_next() is
224 * called, possibly without any accumulated
225 * notification, in which case we'll return it.
226 */
227 *count = i;
228 status = BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK;
229 }
230
231 return status;
232 }
233
234 void ctf_fs_iterator_finalize(struct bt_self_notification_iterator *it)
235 {
236 ctf_fs_notif_iter_data_destroy(
237 bt_self_notification_iterator_get_data(it));
238 }
239
240 enum bt_self_notification_iterator_status ctf_fs_iterator_init(
241 struct bt_self_notification_iterator *self_notif_iter,
242 struct bt_self_component_source *self_comp,
243 struct bt_self_component_port_output *self_port)
244 {
245 struct ctf_fs_port_data *port_data;
246 struct ctf_fs_notif_iter_data *notif_iter_data = NULL;
247 enum bt_self_notification_iterator_status ret =
248 BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK;
249 int iret;
250
251 port_data = bt_self_component_port_get_data(
252 bt_self_component_port_output_as_self_component_port(
253 self_port));
254 BT_ASSERT(port_data);
255 notif_iter_data = g_new0(struct ctf_fs_notif_iter_data, 1);
256 if (!notif_iter_data) {
257 ret = BT_SELF_NOTIFICATION_ITERATOR_STATUS_NOMEM;
258 goto error;
259 }
260
261 notif_iter_data->pc_notif_iter = self_notif_iter;
262 notif_iter_data->notif_iter = bt_notif_iter_create(
263 port_data->ds_file_group->ctf_fs_trace->metadata->tc,
264 bt_common_get_page_size() * 8,
265 ctf_fs_ds_file_medops, NULL);
266 if (!notif_iter_data->notif_iter) {
267 BT_LOGE_STR("Cannot create a CTF notification iterator.");
268 ret = BT_SELF_NOTIFICATION_ITERATOR_STATUS_NOMEM;
269 goto error;
270 }
271
272 notif_iter_data->ds_file_group = port_data->ds_file_group;
273 iret = notif_iter_data_set_current_ds_file(notif_iter_data);
274 if (iret) {
275 ret = BT_SELF_NOTIFICATION_ITERATOR_STATUS_ERROR;
276 goto error;
277 }
278
279 bt_self_notification_iterator_set_data(self_notif_iter,
280 notif_iter_data);
281 if (ret != BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK) {
282 goto error;
283 }
284
285 notif_iter_data = NULL;
286 goto end;
287
288 error:
289 bt_self_notification_iterator_set_data(self_notif_iter, NULL);
290
291 end:
292 ctf_fs_notif_iter_data_destroy(notif_iter_data);
293 return ret;
294 }
295
296 static
297 void ctf_fs_destroy(struct ctf_fs_component *ctf_fs)
298 {
299 if (!ctf_fs) {
300 return;
301 }
302
303 if (ctf_fs->traces) {
304 g_ptr_array_free(ctf_fs->traces, TRUE);
305 }
306
307 if (ctf_fs->port_data) {
308 g_ptr_array_free(ctf_fs->port_data, TRUE);
309 }
310
311 g_free(ctf_fs);
312 }
313
314 BT_HIDDEN
315 void ctf_fs_trace_destroy(struct ctf_fs_trace *ctf_fs_trace)
316 {
317 if (!ctf_fs_trace) {
318 return;
319 }
320
321 if (ctf_fs_trace->ds_file_groups) {
322 g_ptr_array_free(ctf_fs_trace->ds_file_groups, TRUE);
323 }
324
325 if (ctf_fs_trace->path) {
326 g_string_free(ctf_fs_trace->path, TRUE);
327 }
328
329 if (ctf_fs_trace->name) {
330 g_string_free(ctf_fs_trace->name, TRUE);
331 }
332
333 if (ctf_fs_trace->metadata) {
334 ctf_fs_metadata_fini(ctf_fs_trace->metadata);
335 g_free(ctf_fs_trace->metadata);
336 }
337
338 g_free(ctf_fs_trace);
339 }
340
341 static
342 void ctf_fs_trace_destroy_notifier(void *data)
343 {
344 struct ctf_fs_trace *trace = data;
345 ctf_fs_trace_destroy(trace);
346 }
347
348 void ctf_fs_finalize(struct bt_self_component_source *component)
349 {
350 ctf_fs_destroy(bt_self_component_get_data(
351 bt_self_component_source_as_self_component(component)));
352 }
353
354 static
355 void port_data_destroy(void *data) {
356 struct ctf_fs_port_data *port_data = data;
357
358 if (!port_data) {
359 return;
360 }
361
362 g_free(port_data);
363 }
364
365 static
366 GString *get_stream_instance_unique_name(
367 struct ctf_fs_ds_file_group *ds_file_group)
368 {
369 GString *name;
370 struct ctf_fs_ds_file_info *ds_file_info;
371
372 name = g_string_new(NULL);
373 if (!name) {
374 goto end;
375 }
376
377 /*
378 * If there's more than one stream file in the stream file
379 * group, the first (earliest) stream file's path is used as
380 * the stream's unique name.
381 */
382 BT_ASSERT(ds_file_group->ds_file_infos->len > 0);
383 ds_file_info = g_ptr_array_index(ds_file_group->ds_file_infos, 0);
384 g_string_assign(name, ds_file_info->path->str);
385
386 end:
387 return name;
388 }
389
390 static
391 int create_one_port_for_trace(struct ctf_fs_component *ctf_fs,
392 struct ctf_fs_trace *ctf_fs_trace,
393 struct ctf_fs_ds_file_group *ds_file_group)
394 {
395 int ret = 0;
396 struct ctf_fs_port_data *port_data = NULL;
397 GString *port_name = NULL;
398
399 port_name = get_stream_instance_unique_name(ds_file_group);
400 if (!port_name) {
401 goto error;
402 }
403
404 BT_LOGD("Creating one port named `%s`", port_name->str);
405
406 /* Create output port for this file */
407 port_data = g_new0(struct ctf_fs_port_data, 1);
408 if (!port_data) {
409 goto error;
410 }
411
412 port_data->ctf_fs = ctf_fs;
413 port_data->ds_file_group = ds_file_group;
414 ret = bt_self_component_source_add_output_port(
415 ctf_fs->self_comp, port_name->str, port_data, NULL);
416 if (ret) {
417 goto error;
418 }
419
420 g_ptr_array_add(ctf_fs->port_data, port_data);
421 port_data = NULL;
422 goto end;
423
424 error:
425 ret = -1;
426
427 end:
428 if (port_name) {
429 g_string_free(port_name, TRUE);
430 }
431
432 port_data_destroy(port_data);
433 return ret;
434 }
435
436 static
437 int create_ports_for_trace(struct ctf_fs_component *ctf_fs,
438 struct ctf_fs_trace *ctf_fs_trace)
439 {
440 int ret = 0;
441 size_t i;
442
443 /* Create one output port for each stream file group */
444 for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) {
445 struct ctf_fs_ds_file_group *ds_file_group =
446 g_ptr_array_index(ctf_fs_trace->ds_file_groups, i);
447
448 ret = create_one_port_for_trace(ctf_fs, ctf_fs_trace,
449 ds_file_group);
450 if (ret) {
451 BT_LOGE("Cannot create output port.");
452 goto end;
453 }
454 }
455
456 end:
457 return ret;
458 }
459
460 static
461 void ctf_fs_ds_file_info_destroy(struct ctf_fs_ds_file_info *ds_file_info)
462 {
463 if (!ds_file_info) {
464 return;
465 }
466
467 if (ds_file_info->path) {
468 g_string_free(ds_file_info->path, TRUE);
469 }
470
471 ctf_fs_ds_index_destroy(ds_file_info->index);
472 g_free(ds_file_info);
473 }
474
475 static
476 struct ctf_fs_ds_file_info *ctf_fs_ds_file_info_create(const char *path,
477 int64_t begin_ns, struct ctf_fs_ds_index *index)
478 {
479 struct ctf_fs_ds_file_info *ds_file_info;
480
481 ds_file_info = g_new0(struct ctf_fs_ds_file_info, 1);
482 if (!ds_file_info) {
483 goto end;
484 }
485
486 ds_file_info->path = g_string_new(path);
487 if (!ds_file_info->path) {
488 ctf_fs_ds_file_info_destroy(ds_file_info);
489 ds_file_info = NULL;
490 goto end;
491 }
492
493 ds_file_info->begin_ns = begin_ns;
494 ds_file_info->index = index;
495 index = NULL;
496
497 end:
498 ctf_fs_ds_index_destroy(index);
499 return ds_file_info;
500 }
501
502 static
503 void ctf_fs_ds_file_group_destroy(struct ctf_fs_ds_file_group *ds_file_group)
504 {
505 if (!ds_file_group) {
506 return;
507 }
508
509 if (ds_file_group->ds_file_infos) {
510 g_ptr_array_free(ds_file_group->ds_file_infos, TRUE);
511 }
512
513 bt_object_put_ref(ds_file_group->stream);
514 bt_object_put_ref(ds_file_group->stream_class);
515 g_free(ds_file_group);
516 }
517
518 static
519 struct ctf_fs_ds_file_group *ctf_fs_ds_file_group_create(
520 struct ctf_fs_trace *ctf_fs_trace,
521 struct bt_private_stream_class *stream_class,
522 uint64_t stream_instance_id)
523 {
524 struct ctf_fs_ds_file_group *ds_file_group;
525
526 ds_file_group = g_new0(struct ctf_fs_ds_file_group, 1);
527 if (!ds_file_group) {
528 goto error;
529 }
530
531 ds_file_group->ds_file_infos = g_ptr_array_new_with_free_func(
532 (GDestroyNotify) ctf_fs_ds_file_info_destroy);
533 if (!ds_file_group->ds_file_infos) {
534 goto error;
535 }
536
537 ds_file_group->stream_id = stream_instance_id;
538 BT_ASSERT(stream_class);
539 ds_file_group->stream_class = stream_class;
540 bt_object_get_ref(ds_file_group->stream_class);
541 ds_file_group->ctf_fs_trace = ctf_fs_trace;
542 goto end;
543
544 error:
545 ctf_fs_ds_file_group_destroy(ds_file_group);
546 ds_file_group = NULL;
547
548 end:
549 return ds_file_group;
550 }
551
552 /* Replace by g_ptr_array_insert when we depend on glib >= 2.40. */
553 static
554 void array_insert(GPtrArray *array, gpointer element, size_t pos)
555 {
556 size_t original_array_len = array->len;
557
558 /* Allocate an unused element at the end of the array. */
559 g_ptr_array_add(array, NULL);
560
561 /* If we are not inserting at the end, move the elements by one. */
562 if (pos < original_array_len) {
563 memmove(&(array->pdata[pos + 1]),
564 &(array->pdata[pos]),
565 (original_array_len - pos) * sizeof(gpointer));
566 }
567
568 /* Insert the value and bump the array len */
569 array->pdata[pos] = element;
570 }
571
572 static
573 int ctf_fs_ds_file_group_add_ds_file_info(
574 struct ctf_fs_ds_file_group *ds_file_group,
575 const char *path, int64_t begin_ns,
576 struct ctf_fs_ds_index *index)
577 {
578 struct ctf_fs_ds_file_info *ds_file_info;
579 gint i = 0;
580 int ret = 0;
581
582 /* Onwership of index is transferred. */
583 ds_file_info = ctf_fs_ds_file_info_create(path, begin_ns, index);
584 index = NULL;
585 if (!ds_file_info) {
586 goto error;
587 }
588
589 /* Find a spot to insert this one */
590 for (i = 0; i < ds_file_group->ds_file_infos->len; i++) {
591 struct ctf_fs_ds_file_info *other_ds_file_info =
592 g_ptr_array_index(ds_file_group->ds_file_infos, i);
593
594 if (begin_ns < other_ds_file_info->begin_ns) {
595 break;
596 }
597 }
598
599 array_insert(ds_file_group->ds_file_infos, ds_file_info, i);
600 ds_file_info = NULL;
601 goto end;
602
603 error:
604 ctf_fs_ds_file_info_destroy(ds_file_info);
605 ctf_fs_ds_index_destroy(index);
606 ret = -1;
607 end:
608 return ret;
609 }
610
611 static
612 int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace,
613 const char *path)
614 {
615 struct bt_private_stream_class *stream_class = NULL;
616 int64_t stream_instance_id = -1;
617 int64_t begin_ns = -1;
618 struct ctf_fs_ds_file_group *ds_file_group = NULL;
619 bool add_group = false;
620 int ret;
621 size_t i;
622 struct ctf_fs_ds_file *ds_file = NULL;
623 struct ctf_fs_ds_index *index = NULL;
624 struct bt_notif_iter *notif_iter = NULL;
625 struct ctf_stream_class *sc = NULL;
626 struct bt_notif_iter_packet_properties props;
627
628 notif_iter = bt_notif_iter_create(ctf_fs_trace->metadata->tc,
629 bt_common_get_page_size() * 8, ctf_fs_ds_file_medops, NULL);
630 if (!notif_iter) {
631 BT_LOGE_STR("Cannot create a CTF notification iterator.");
632 goto error;
633 }
634
635 ds_file = ctf_fs_ds_file_create(ctf_fs_trace, NULL, notif_iter,
636 NULL, path);
637 if (!ds_file) {
638 goto error;
639 }
640
641 ret = ctf_fs_ds_file_borrow_packet_header_context_fields(ds_file,
642 NULL, NULL);
643 if (ret) {
644 BT_LOGE("Cannot get stream file's first packet's header and context fields (`%s`).",
645 path);
646 goto error;
647 }
648
649 ret = bt_notif_iter_get_packet_properties(ds_file->notif_iter, &props);
650 BT_ASSERT(ret == 0);
651 sc = ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc,
652 props.stream_class_id);
653 BT_ASSERT(sc);
654 stream_class = sc->ir_sc;
655 BT_ASSERT(stream_class);
656 stream_instance_id = props.data_stream_id;
657
658 if (props.snapshots.beginning_clock != UINT64_C(-1)) {
659 BT_ASSERT(sc->default_clock_class);
660 ret = bt_clock_class_cycles_to_ns_from_origin(
661 bt_private_clock_class_as_clock_class(
662 sc->default_clock_class),
663 props.snapshots.beginning_clock, &begin_ns);
664 if (ret) {
665 BT_LOGE("Cannot convert clock cycles to nanoseconds from origin (`%s`).",
666 path);
667 goto error;
668 }
669 }
670
671 index = ctf_fs_ds_file_build_index(ds_file);
672 if (!index) {
673 BT_LOGW("Failed to index CTF stream file \'%s\'",
674 ds_file->file->path->str);
675 }
676
677 if (begin_ns == -1) {
678 /*
679 * No beggining timestamp to sort the stream files
680 * within a stream file group, so consider that this
681 * file must be the only one within its group.
682 */
683 stream_instance_id = -1;
684 }
685
686 if (stream_instance_id == -1) {
687 /*
688 * No stream instance ID or no beginning timestamp:
689 * create a unique stream file group for this stream
690 * file because, even if there's a stream instance ID,
691 * there's no timestamp to order the file within its
692 * group.
693 */
694 ds_file_group = ctf_fs_ds_file_group_create(ctf_fs_trace,
695 stream_class, stream_instance_id);
696 if (!ds_file_group) {
697 goto error;
698 }
699
700 ret = ctf_fs_ds_file_group_add_ds_file_info(ds_file_group,
701 path, begin_ns, index);
702 /* Ownership of index is transferred. */
703 index = NULL;
704 if (ret) {
705 goto error;
706 }
707
708 add_group = true;
709 goto end;
710 }
711
712 BT_ASSERT(stream_instance_id != -1);
713 BT_ASSERT(begin_ns != -1);
714
715 /* Find an existing stream file group with this ID */
716 for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) {
717 ds_file_group = g_ptr_array_index(
718 ctf_fs_trace->ds_file_groups, i);
719
720 if (ds_file_group->stream_class == stream_class &&
721 ds_file_group->stream_id ==
722 stream_instance_id) {
723 break;
724 }
725
726 ds_file_group = NULL;
727 }
728
729 if (!ds_file_group) {
730 ds_file_group = ctf_fs_ds_file_group_create(ctf_fs_trace,
731 stream_class, stream_instance_id);
732 if (!ds_file_group) {
733 goto error;
734 }
735
736 add_group = true;
737 }
738
739 ret = ctf_fs_ds_file_group_add_ds_file_info(ds_file_group, path,
740 begin_ns, index);
741 index = NULL;
742 if (ret) {
743 goto error;
744 }
745
746 goto end;
747
748 error:
749 ctf_fs_ds_file_group_destroy(ds_file_group);
750 ret = -1;
751
752 end:
753 if (add_group && ds_file_group) {
754 g_ptr_array_add(ctf_fs_trace->ds_file_groups, ds_file_group);
755 }
756
757 ctf_fs_ds_file_destroy(ds_file);
758
759 if (notif_iter) {
760 bt_notif_iter_destroy(notif_iter);
761 }
762
763 ctf_fs_ds_index_destroy(index);
764 return ret;
765 }
766
767 static
768 int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace)
769 {
770 int ret = 0;
771 const char *basename;
772 GError *error = NULL;
773 GDir *dir = NULL;
774 size_t i;
775
776 /* Check each file in the path directory, except specific ones */
777 dir = g_dir_open(ctf_fs_trace->path->str, 0, &error);
778 if (!dir) {
779 BT_LOGE("Cannot open directory `%s`: %s (code %d)",
780 ctf_fs_trace->path->str, error->message,
781 error->code);
782 goto error;
783 }
784
785 while ((basename = g_dir_read_name(dir))) {
786 struct ctf_fs_file *file;
787
788 if (!strcmp(basename, CTF_FS_METADATA_FILENAME)) {
789 /* Ignore the metadata stream. */
790 BT_LOGD("Ignoring metadata file `%s" G_DIR_SEPARATOR_S "%s`",
791 ctf_fs_trace->path->str, basename);
792 continue;
793 }
794
795 if (basename[0] == '.') {
796 BT_LOGD("Ignoring hidden file `%s" G_DIR_SEPARATOR_S "%s`",
797 ctf_fs_trace->path->str, basename);
798 continue;
799 }
800
801 /* Create the file. */
802 file = ctf_fs_file_create();
803 if (!file) {
804 BT_LOGE("Cannot create stream file object for file `%s" G_DIR_SEPARATOR_S "%s`",
805 ctf_fs_trace->path->str, basename);
806 goto error;
807 }
808
809 /* Create full path string. */
810 g_string_append_printf(file->path, "%s" G_DIR_SEPARATOR_S "%s",
811 ctf_fs_trace->path->str, basename);
812 if (!g_file_test(file->path->str, G_FILE_TEST_IS_REGULAR)) {
813 BT_LOGD("Ignoring non-regular file `%s`",
814 file->path->str);
815 ctf_fs_file_destroy(file);
816 file = NULL;
817 continue;
818 }
819
820 ret = ctf_fs_file_open(file, "rb");
821 if (ret) {
822 BT_LOGE("Cannot open stream file `%s`", file->path->str);
823 goto error;
824 }
825
826 if (file->size == 0) {
827 /* Skip empty stream. */
828 BT_LOGD("Ignoring empty file `%s`", file->path->str);
829 ctf_fs_file_destroy(file);
830 continue;
831 }
832
833 ret = add_ds_file_to_ds_file_group(ctf_fs_trace,
834 file->path->str);
835 if (ret) {
836 BT_LOGE("Cannot add stream file `%s` to stream file group",
837 file->path->str);
838 ctf_fs_file_destroy(file);
839 goto error;
840 }
841
842 ctf_fs_file_destroy(file);
843 }
844
845 /*
846 * At this point, DS file groupes are created, but their
847 * associated stream objects do not exist yet. This is because
848 * we need to name the created stream object with the data
849 * stream file's path. We have everything we need here to do
850 * this.
851 */
852 for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) {
853 struct ctf_fs_ds_file_group *ds_file_group =
854 g_ptr_array_index(ctf_fs_trace->ds_file_groups, i);
855 GString *name = get_stream_instance_unique_name(ds_file_group);
856
857 if (!name) {
858 goto error;
859 }
860
861 if (ds_file_group->stream_id == UINT64_C(-1)) {
862 /* No stream ID: use 0 */
863 ds_file_group->stream = bt_private_stream_create_with_id(
864 ds_file_group->stream_class,
865 ctf_fs_trace->next_stream_id);
866 ctf_fs_trace->next_stream_id++;
867 } else {
868 /* Specific stream ID */
869 ds_file_group->stream = bt_private_stream_create_with_id(
870 ds_file_group->stream_class,
871 (uint64_t) ds_file_group->stream_id);
872 }
873
874 if (!ds_file_group->stream) {
875 BT_LOGE("Cannot create stream for DS file group: "
876 "addr=%p, stream-name=\"%s\"",
877 ds_file_group, name->str);
878 g_string_free(name, TRUE);
879 goto error;
880 }
881
882 ret = bt_private_stream_set_name(ds_file_group->stream,
883 name->str);
884 if (ret) {
885 BT_LOGE("Cannot set stream's name: "
886 "addr=%p, stream-name=\"%s\"",
887 ds_file_group->stream, name->str);
888 g_string_free(name, TRUE);
889 goto error;
890 }
891
892 g_string_free(name, TRUE);
893 }
894
895 goto end;
896
897 error:
898 ret = -1;
899
900 end:
901 if (dir) {
902 g_dir_close(dir);
903 dir = NULL;
904 }
905
906 if (error) {
907 g_error_free(error);
908 }
909
910 return ret;
911 }
912
913 BT_HIDDEN
914 struct ctf_fs_trace *ctf_fs_trace_create(const char *path, const char *name,
915 struct ctf_fs_metadata_config *metadata_config)
916 {
917 struct ctf_fs_trace *ctf_fs_trace;
918 int ret;
919
920 ctf_fs_trace = g_new0(struct ctf_fs_trace, 1);
921 if (!ctf_fs_trace) {
922 goto end;
923 }
924
925 ctf_fs_trace->path = g_string_new(path);
926 if (!ctf_fs_trace->path) {
927 goto error;
928 }
929
930 ctf_fs_trace->name = g_string_new(name);
931 if (!ctf_fs_trace->name) {
932 goto error;
933 }
934
935 ctf_fs_trace->metadata = g_new0(struct ctf_fs_metadata, 1);
936 if (!ctf_fs_trace->metadata) {
937 goto error;
938 }
939
940 ctf_fs_metadata_init(ctf_fs_trace->metadata);
941 ctf_fs_trace->ds_file_groups = g_ptr_array_new_with_free_func(
942 (GDestroyNotify) ctf_fs_ds_file_group_destroy);
943 if (!ctf_fs_trace->ds_file_groups) {
944 goto error;
945 }
946
947 ret = ctf_fs_metadata_set_trace(ctf_fs_trace, metadata_config);
948 if (ret) {
949 goto error;
950 }
951
952 ret = create_ds_file_groups(ctf_fs_trace);
953 if (ret) {
954 goto error;
955 }
956
957 /*
958 * create_ds_file_groups() created all the streams that this
959 * trace needs. There won't be any more. Therefore it is safe to
960 * make this trace static.
961 */
962 (void) bt_private_trace_make_static(ctf_fs_trace->metadata->trace);
963
964 goto end;
965
966 error:
967 ctf_fs_trace_destroy(ctf_fs_trace);
968 ctf_fs_trace = NULL;
969
970 end:
971 return ctf_fs_trace;
972 }
973
974 static
975 int path_is_ctf_trace(const char *path)
976 {
977 GString *metadata_path = g_string_new(NULL);
978 int ret = 0;
979
980 if (!metadata_path) {
981 ret = -1;
982 goto end;
983 }
984
985 g_string_printf(metadata_path, "%s" G_DIR_SEPARATOR_S "%s", path, CTF_FS_METADATA_FILENAME);
986
987 if (g_file_test(metadata_path->str, G_FILE_TEST_IS_REGULAR)) {
988 ret = 1;
989 goto end;
990 }
991
992 end:
993 g_string_free(metadata_path, TRUE);
994 return ret;
995 }
996
997 static
998 int add_trace_path(GList **trace_paths, const char *path)
999 {
1000 GString *norm_path = NULL;
1001 int ret = 0;
1002
1003 norm_path = bt_common_normalize_path(path, NULL);
1004 if (!norm_path) {
1005 BT_LOGE("Failed to normalize path `%s`.", path);
1006 ret = -1;
1007 goto end;
1008 }
1009
1010 // FIXME: Remove or ifdef for __MINGW32__
1011 if (strcmp(norm_path->str, "/") == 0) {
1012 BT_LOGE("Opening a trace in `/` is not supported.");
1013 ret = -1;
1014 goto end;
1015 }
1016
1017 *trace_paths = g_list_prepend(*trace_paths, norm_path);
1018 BT_ASSERT(*trace_paths);
1019 norm_path = NULL;
1020
1021 end:
1022 if (norm_path) {
1023 g_string_free(norm_path, TRUE);
1024 }
1025
1026 return ret;
1027 }
1028
1029 BT_HIDDEN
1030 int ctf_fs_find_traces(GList **trace_paths, const char *start_path)
1031 {
1032 int ret;
1033 GError *error = NULL;
1034 GDir *dir = NULL;
1035 const char *basename = NULL;
1036
1037 /* Check if the starting path is a CTF trace itself */
1038 ret = path_is_ctf_trace(start_path);
1039 if (ret < 0) {
1040 goto end;
1041 }
1042
1043 if (ret) {
1044 /*
1045 * Stop recursion: a CTF trace cannot contain another
1046 * CTF trace.
1047 */
1048 ret = add_trace_path(trace_paths, start_path);
1049 goto end;
1050 }
1051
1052 /* Look for subdirectories */
1053 if (!g_file_test(start_path, G_FILE_TEST_IS_DIR)) {
1054 /* Starting path is not a directory: end of recursion */
1055 goto end;
1056 }
1057
1058 dir = g_dir_open(start_path, 0, &error);
1059 if (!dir) {
1060 if (error->code == G_FILE_ERROR_ACCES) {
1061 BT_LOGD("Cannot open directory `%s`: %s (code %d): continuing",
1062 start_path, error->message, error->code);
1063 goto end;
1064 }
1065
1066 BT_LOGE("Cannot open directory `%s`: %s (code %d)",
1067 start_path, error->message, error->code);
1068 ret = -1;
1069 goto end;
1070 }
1071
1072 while ((basename = g_dir_read_name(dir))) {
1073 GString *sub_path = g_string_new(NULL);
1074
1075 if (!sub_path) {
1076 ret = -1;
1077 goto end;
1078 }
1079
1080 g_string_printf(sub_path, "%s" G_DIR_SEPARATOR_S "%s", start_path, basename);
1081 ret = ctf_fs_find_traces(trace_paths, sub_path->str);
1082 g_string_free(sub_path, TRUE);
1083 if (ret) {
1084 goto end;
1085 }
1086 }
1087
1088 end:
1089 if (dir) {
1090 g_dir_close(dir);
1091 }
1092
1093 if (error) {
1094 g_error_free(error);
1095 }
1096
1097 return ret;
1098 }
1099
1100 BT_HIDDEN
1101 GList *ctf_fs_create_trace_names(GList *trace_paths, const char *base_path) {
1102 GList *trace_names = NULL;
1103 GList *node;
1104 const char *last_sep;
1105 size_t base_dist;
1106
1107 /*
1108 * At this point we know that all the trace paths are
1109 * normalized, and so is the base path. This means that
1110 * they are absolute and they don't end with a separator.
1111 * We can simply find the location of the last separator
1112 * in the base path, which gives us the name of the actual
1113 * directory to look into, and use this location as the
1114 * start of each trace name within each trace path.
1115 *
1116 * For example:
1117 *
1118 * Base path: /home/user/my-traces/some-trace
1119 * Trace paths:
1120 * - /home/user/my-traces/some-trace/host1/trace1
1121 * - /home/user/my-traces/some-trace/host1/trace2
1122 * - /home/user/my-traces/some-trace/host2/trace
1123 * - /home/user/my-traces/some-trace/other-trace
1124 *
1125 * In this case the trace names are:
1126 *
1127 * - some-trace/host1/trace1
1128 * - some-trace/host1/trace2
1129 * - some-trace/host2/trace
1130 * - some-trace/other-trace
1131 */
1132 last_sep = strrchr(base_path, G_DIR_SEPARATOR);
1133
1134 /* We know there's at least one separator */
1135 BT_ASSERT(last_sep);
1136
1137 /* Distance to base */
1138 base_dist = last_sep - base_path + 1;
1139
1140 /* Create the trace names */
1141 for (node = trace_paths; node; node = g_list_next(node)) {
1142 GString *trace_name = g_string_new(NULL);
1143 GString *trace_path = node->data;
1144
1145 BT_ASSERT(trace_name);
1146 g_string_assign(trace_name, &trace_path->str[base_dist]);
1147 trace_names = g_list_append(trace_names, trace_name);
1148 }
1149
1150 return trace_names;
1151 }
1152
1153 static
1154 int create_ctf_fs_traces(struct ctf_fs_component *ctf_fs,
1155 const char *path_param)
1156 {
1157 struct ctf_fs_trace *ctf_fs_trace = NULL;
1158 int ret = 0;
1159 GString *norm_path = NULL;
1160 GList *trace_paths = NULL;
1161 GList *trace_names = NULL;
1162 GList *tp_node;
1163 GList *tn_node;
1164
1165 norm_path = bt_common_normalize_path(path_param, NULL);
1166 if (!norm_path) {
1167 BT_LOGE("Failed to normalize path: `%s`.",
1168 path_param);
1169 goto error;
1170 }
1171
1172 ret = ctf_fs_find_traces(&trace_paths, norm_path->str);
1173 if (ret) {
1174 goto error;
1175 }
1176
1177 if (!trace_paths) {
1178 BT_LOGE("No CTF traces recursively found in `%s`.",
1179 path_param);
1180 goto error;
1181 }
1182
1183 trace_names = ctf_fs_create_trace_names(trace_paths, norm_path->str);
1184 if (!trace_names) {
1185 BT_LOGE("Cannot create trace names from trace paths.");
1186 goto error;
1187 }
1188
1189 for (tp_node = trace_paths, tn_node = trace_names; tp_node;
1190 tp_node = g_list_next(tp_node),
1191 tn_node = g_list_next(tn_node)) {
1192 GString *trace_path = tp_node->data;
1193 GString *trace_name = tn_node->data;
1194
1195 ctf_fs_trace = ctf_fs_trace_create(trace_path->str,
1196 trace_name->str, &ctf_fs->metadata_config);
1197 if (!ctf_fs_trace) {
1198 BT_LOGE("Cannot create trace for `%s`.",
1199 trace_path->str);
1200 goto error;
1201 }
1202
1203 ret = create_ports_for_trace(ctf_fs, ctf_fs_trace);
1204 if (ret) {
1205 goto error;
1206 }
1207
1208 g_ptr_array_add(ctf_fs->traces, ctf_fs_trace);
1209 ctf_fs_trace = NULL;
1210 }
1211
1212 goto end;
1213
1214 error:
1215 ret = -1;
1216 ctf_fs_trace_destroy(ctf_fs_trace);
1217
1218 end:
1219 for (tp_node = trace_paths; tp_node; tp_node = g_list_next(tp_node)) {
1220 if (tp_node->data) {
1221 g_string_free(tp_node->data, TRUE);
1222 }
1223 }
1224
1225 for (tn_node = trace_names; tn_node; tn_node = g_list_next(tn_node)) {
1226 if (tn_node->data) {
1227 g_string_free(tn_node->data, TRUE);
1228 }
1229 }
1230
1231 if (trace_paths) {
1232 g_list_free(trace_paths);
1233 }
1234
1235 if (trace_names) {
1236 g_list_free(trace_names);
1237 }
1238
1239 if (norm_path) {
1240 g_string_free(norm_path, TRUE);
1241 }
1242
1243 return ret;
1244 }
1245
1246 static
1247 struct ctf_fs_component *ctf_fs_create(
1248 struct bt_self_component_source *self_comp,
1249 const struct bt_value *params)
1250 {
1251 struct ctf_fs_component *ctf_fs;
1252 const struct bt_value *value = NULL;
1253 const char *path_param;
1254
1255 ctf_fs = g_new0(struct ctf_fs_component, 1);
1256 if (!ctf_fs) {
1257 goto end;
1258 }
1259
1260 bt_self_component_set_data(
1261 bt_self_component_source_as_self_component(self_comp),
1262 ctf_fs);
1263
1264 /*
1265 * We don't need to get a new reference here because as long as
1266 * our private ctf_fs_component object exists, the containing
1267 * private component should also exist.
1268 */
1269 ctf_fs->self_comp = self_comp;
1270 value = bt_value_map_borrow_entry_value_const(params, "path");
1271 if (value && !bt_value_is_string(value)) {
1272 goto error;
1273 }
1274
1275 path_param = bt_value_string_get(value);
1276 value = bt_value_map_borrow_entry_value_const(params,
1277 "clock-class-offset-s");
1278 if (value) {
1279 if (!bt_value_is_integer(value)) {
1280 BT_LOGE("clock-class-offset-s should be an integer");
1281 goto error;
1282 }
1283 ctf_fs->metadata_config.clock_class_offset_s = bt_value_integer_get(value);
1284 }
1285
1286 value = bt_value_map_borrow_entry_value_const(params,
1287 "clock-class-offset-ns");
1288 if (value) {
1289 if (!bt_value_is_integer(value)) {
1290 BT_LOGE("clock-class-offset-ns should be an integer");
1291 goto error;
1292 }
1293 ctf_fs->metadata_config.clock_class_offset_ns = bt_value_integer_get(value);
1294 }
1295
1296 ctf_fs->port_data = g_ptr_array_new_with_free_func(port_data_destroy);
1297 if (!ctf_fs->port_data) {
1298 goto error;
1299 }
1300
1301 ctf_fs->traces = g_ptr_array_new_with_free_func(
1302 ctf_fs_trace_destroy_notifier);
1303 if (!ctf_fs->traces) {
1304 goto error;
1305 }
1306
1307 if (create_ctf_fs_traces(ctf_fs, path_param)) {
1308 goto error;
1309 }
1310
1311 goto end;
1312
1313 error:
1314 ctf_fs_destroy(ctf_fs);
1315 ctf_fs = NULL;
1316 bt_self_component_set_data(
1317 bt_self_component_source_as_self_component(self_comp),
1318 NULL);
1319
1320 end:
1321 return ctf_fs;
1322 }
1323
1324 BT_HIDDEN
1325 enum bt_self_component_status ctf_fs_init(
1326 struct bt_self_component_source *self_comp,
1327 const struct bt_value *params, UNUSED_VAR void *init_method_data)
1328 {
1329 struct ctf_fs_component *ctf_fs;
1330 enum bt_self_component_status ret = BT_SELF_COMPONENT_STATUS_OK;
1331
1332 ctf_fs = ctf_fs_create(self_comp, params);
1333 if (!ctf_fs) {
1334 ret = BT_SELF_COMPONENT_STATUS_ERROR;
1335 }
1336
1337 return ret;
1338 }
1339
1340 BT_HIDDEN
1341 enum bt_query_status ctf_fs_query(
1342 struct bt_self_component_class_source *comp_class,
1343 struct bt_query_executor *query_exec,
1344 const char *object, const struct bt_value *params,
1345 const struct bt_value **result)
1346 {
1347 enum bt_query_status status = BT_QUERY_STATUS_OK;
1348
1349 if (!strcmp(object, "metadata-info")) {
1350 status = metadata_info_query(comp_class, params, result);
1351 } else if (!strcmp(object, "trace-info")) {
1352 status = trace_info_query(comp_class, params, result);
1353 } else {
1354 BT_LOGE("Unknown query object `%s`", object);
1355 status = BT_QUERY_STATUS_INVALID_OBJECT;
1356 goto end;
1357 }
1358 end:
1359 return status;
1360 }
BabelTrace - Trace Format Babel Tower
This page took 0.083724 seconds and 3 git commands to generate.