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