cli, plugins/ctf/fs-src: Make src.ctf.fs accept multiple root paths
[deliverable/babeltrace.git] / plugins / ctf / fs-src / fs.c
index 46086905259d8d9869249b60892a978b60eda76f..801fc883d6cf829ddd7c12893e9bc20e4d798bf6 100644 (file)
@@ -87,105 +87,68 @@ void ctf_fs_msg_iter_data_destroy(
        g_free(msg_iter_data);
 }
 
+static
+void set_msg_iter_emits_stream_beginning_end_messages(
+               struct ctf_fs_msg_iter_data *msg_iter_data)
+{
+       bt_msg_iter_set_emit_stream_beginning_message(
+               msg_iter_data->ds_file->msg_iter,
+               msg_iter_data->ds_file_info_index == 0);
+       bt_msg_iter_set_emit_stream_end_message(
+               msg_iter_data->ds_file->msg_iter,
+               msg_iter_data->ds_file_info_index ==
+                       msg_iter_data->ds_file_group->ds_file_infos->len - 1);
+}
+
 static
 bt_self_message_iterator_status ctf_fs_iterator_next_one(
                struct ctf_fs_msg_iter_data *msg_iter_data,
-               const bt_message **msg)
+               const bt_message **out_msg)
 {
        bt_self_message_iterator_status status;
-       bt_message *priv_msg;
-       int ret;
 
        BT_ASSERT(msg_iter_data->ds_file);
-       status = ctf_fs_ds_file_next(msg_iter_data->ds_file, &priv_msg);
-       *msg = priv_msg;
 
-       if (status == BT_SELF_MESSAGE_ITERATOR_STATUS_OK &&
-                       bt_message_get_type(*msg) ==
-                       BT_MESSAGE_TYPE_STREAM_BEGINNING) {
-               if (msg_iter_data->skip_stream_begin_msgs) {
-                       /*
-                        * We already emitted a
-                        * BT_MESSAGE_TYPE_STREAM_BEGINNING
-                        * message: skip this one, get a new one.
-                        */
-                       BT_MESSAGE_PUT_REF_AND_RESET(*msg);
-                       status = ctf_fs_ds_file_next(msg_iter_data->ds_file,
-                               &priv_msg);
-                       *msg = priv_msg;
-                       BT_ASSERT(status != BT_SELF_MESSAGE_ITERATOR_STATUS_END);
-                       goto end;
-               } else {
-                       /*
-                        * First BT_MESSAGE_TYPE_STREAM_BEGINNING
-                        * message: skip all following.
-                        */
-                       msg_iter_data->skip_stream_begin_msgs = true;
-                       goto end;
-               }
-       }
+       while (true) {
+               bt_message *msg;
 
-       if (status == BT_SELF_MESSAGE_ITERATOR_STATUS_OK &&
-                       bt_message_get_type(*msg) ==
-                       BT_MESSAGE_TYPE_STREAM_END) {
-               msg_iter_data->ds_file_info_index++;
+               status = ctf_fs_ds_file_next(msg_iter_data->ds_file, &msg);
+               switch (status) {
+               case BT_SELF_MESSAGE_ITERATOR_STATUS_OK:
+                       *out_msg = msg;
+                       msg = NULL;
+                       goto end;
+               case BT_SELF_MESSAGE_ITERATOR_STATUS_END:
+               {
+                       int ret;
+
+                       if (msg_iter_data->ds_file_info_index ==
+                                       msg_iter_data->ds_file_group->ds_file_infos->len - 1) {
+                               /* End of all group's stream files */
+                               goto end;
+                       }
+
+                       msg_iter_data->ds_file_info_index++;
+                       bt_msg_iter_reset_for_next_stream_file(
+                               msg_iter_data->msg_iter);
+                       set_msg_iter_emits_stream_beginning_end_messages(
+                               msg_iter_data);
 
-               if (msg_iter_data->ds_file_info_index ==
-                               msg_iter_data->ds_file_group->ds_file_infos->len) {
                        /*
-                        * No more stream files to read: we reached the
-                        * real end. Emit this
-                        * BT_MESSAGE_TYPE_STREAM_END message.
-                        * The next time ctf_fs_iterator_next() is
-                        * called for this message iterator,
-                        * ctf_fs_ds_file_next() will return
-                        * BT_SELF_MESSAGE_ITERATOR_STATUS_END().
+                        * Open and start reading the next stream file
+                        * within our stream file group.
                         */
-                       goto end;
-               }
-
-               BT_MESSAGE_PUT_REF_AND_RESET(*msg);
-               bt_msg_iter_reset(msg_iter_data->msg_iter);
+                       ret = msg_iter_data_set_current_ds_file(msg_iter_data);
+                       if (ret) {
+                               status = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR;
+                               goto end;
+                       }
 
-               /*
-                * Open and start reading the next stream file within
-                * our stream file group.
-                */
-               ret = msg_iter_data_set_current_ds_file(msg_iter_data);
-               if (ret) {
-                       status = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR;
-                       goto end;
+                       /* Continue the loop to get the next message */
+                       break;
                }
-
-               status = ctf_fs_ds_file_next(msg_iter_data->ds_file, &priv_msg);
-               *msg = priv_msg;
-
-               /*
-                * If we get a message, we expect to get a
-                * BT_MESSAGE_TYPE_STREAM_BEGINNING message
-                * because the iterator's state machine emits one before
-                * even requesting the first block of data from the
-                * medium. Skip this message because we're not
-                * really starting a new stream here, and try getting a
-                * new message (which, if it works, is a
-                * BT_MESSAGE_TYPE_PACKET_BEGINNING one). We're sure to
-                * get at least one pair of
-                * BT_MESSAGE_TYPE_PACKET_BEGINNING and
-                * BT_MESSAGE_TYPE_PACKET_END messages in the
-                * case of a single, empty packet. We know there's at
-                * least one packet because the stream file group does
-                * not contain empty stream files.
-                */
-               BT_ASSERT(msg_iter_data->skip_stream_begin_msgs);
-
-               if (status == BT_SELF_MESSAGE_ITERATOR_STATUS_OK) {
-                       BT_ASSERT(bt_message_get_type(*msg) ==
-                               BT_MESSAGE_TYPE_STREAM_BEGINNING);
-                       BT_MESSAGE_PUT_REF_AND_RESET(*msg);
-                       status = ctf_fs_ds_file_next(msg_iter_data->ds_file,
-                               &priv_msg);
-                       *msg = priv_msg;
-                       BT_ASSERT(status != BT_SELF_MESSAGE_ITERATOR_STATUS_END);
+               default:
+                       goto end;
                }
        }
 
@@ -231,12 +194,49 @@ bt_self_message_iterator_status ctf_fs_iterator_next(
        return status;
 }
 
+static
+int ctf_fs_iterator_reset(struct ctf_fs_msg_iter_data *msg_iter_data)
+{
+       int ret;
+
+       msg_iter_data->ds_file_info_index = 0;
+       ret = msg_iter_data_set_current_ds_file(msg_iter_data);
+       if (ret) {
+               goto end;
+       }
+
+       bt_msg_iter_reset(msg_iter_data->msg_iter);
+       set_msg_iter_emits_stream_beginning_end_messages(msg_iter_data);
+
+end:
+       return ret;
+}
+
+BT_HIDDEN
+bt_self_message_iterator_status ctf_fs_iterator_seek_beginning(
+               bt_self_message_iterator *it)
+{
+       struct ctf_fs_msg_iter_data *msg_iter_data =
+               bt_self_message_iterator_get_data(it);
+       bt_self_message_iterator_status status =
+               BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
+
+       BT_ASSERT(msg_iter_data);
+       if (ctf_fs_iterator_reset(msg_iter_data)) {
+               status = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR;
+       }
+
+       return status;
+}
+
+BT_HIDDEN
 void ctf_fs_iterator_finalize(bt_self_message_iterator *it)
 {
        ctf_fs_msg_iter_data_destroy(
                bt_self_message_iterator_get_data(it));
 }
 
+BT_HIDDEN
 bt_self_message_iterator_status ctf_fs_iterator_init(
                bt_self_message_iterator *self_msg_iter,
                bt_self_component_source *self_comp,
@@ -246,7 +246,6 @@ bt_self_message_iterator_status ctf_fs_iterator_init(
        struct ctf_fs_msg_iter_data *msg_iter_data = NULL;
        bt_self_message_iterator_status ret =
                BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
-       int iret;
 
        port_data = bt_self_component_port_get_data(
                bt_self_component_port_output_as_self_component_port(
@@ -270,8 +269,7 @@ bt_self_message_iterator_status ctf_fs_iterator_init(
        }
 
        msg_iter_data->ds_file_group = port_data->ds_file_group;
-       iret = msg_iter_data_set_current_ds_file(msg_iter_data);
-       if (iret) {
+       if (ctf_fs_iterator_reset(msg_iter_data)) {
                ret = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR;
                goto error;
        }
@@ -293,7 +291,7 @@ end:
        return ret;
 }
 
-static
+BT_HIDDEN
 void ctf_fs_destroy(struct ctf_fs_component *ctf_fs)
 {
        if (!ctf_fs) {
@@ -311,7 +309,22 @@ void ctf_fs_destroy(struct ctf_fs_component *ctf_fs)
        g_free(ctf_fs);
 }
 
-BT_HIDDEN
+static
+void port_data_destroy(struct ctf_fs_port_data *port_data)
+{
+       if (!port_data) {
+               return;
+       }
+
+       g_free(port_data);
+}
+
+static
+void port_data_destroy_notifier(void *data) {
+       port_data_destroy(data);
+}
+
+static
 void ctf_fs_trace_destroy(struct ctf_fs_trace *ctf_fs_trace)
 {
        if (!ctf_fs_trace) {
@@ -347,21 +360,42 @@ void ctf_fs_trace_destroy_notifier(void *data)
        ctf_fs_trace_destroy(trace);
 }
 
-void ctf_fs_finalize(bt_self_component_source *component)
+struct ctf_fs_component *ctf_fs_component_create(void)
 {
-       ctf_fs_destroy(bt_self_component_get_data(
-               bt_self_component_source_as_self_component(component)));
-}
+       struct ctf_fs_component *ctf_fs;
 
-static
-void port_data_destroy(void *data) {
-       struct ctf_fs_port_data *port_data = data;
+       ctf_fs = g_new0(struct ctf_fs_component, 1);
+       if (!ctf_fs) {
+               goto error;
+       }
 
-       if (!port_data) {
-               return;
+       ctf_fs->port_data =
+               g_ptr_array_new_with_free_func(port_data_destroy_notifier);
+       if (!ctf_fs->port_data) {
+               goto error;
        }
 
-       g_free(port_data);
+       ctf_fs->traces =
+               g_ptr_array_new_with_free_func(ctf_fs_trace_destroy_notifier);
+       if (!ctf_fs->traces) {
+               goto error;
+       }
+
+       goto end;
+
+error:
+       if (ctf_fs) {
+               ctf_fs_destroy(ctf_fs);
+       }
+
+end:
+       return ctf_fs;
+}
+
+void ctf_fs_finalize(bt_self_component_source *component)
+{
+       ctf_fs_destroy(bt_self_component_get_data(
+               bt_self_component_source_as_self_component(component)));
 }
 
 static
@@ -513,14 +547,13 @@ void ctf_fs_ds_file_group_destroy(struct ctf_fs_ds_file_group *ds_file_group)
        }
 
        bt_stream_put_ref(ds_file_group->stream);
-       bt_stream_class_put_ref(ds_file_group->stream_class);
        g_free(ds_file_group);
 }
 
 static
 struct ctf_fs_ds_file_group *ctf_fs_ds_file_group_create(
                struct ctf_fs_trace *ctf_fs_trace,
-               bt_stream_class *stream_class,
+               struct ctf_stream_class *sc,
                uint64_t stream_instance_id)
 {
        struct ctf_fs_ds_file_group *ds_file_group;
@@ -537,9 +570,8 @@ struct ctf_fs_ds_file_group *ctf_fs_ds_file_group_create(
        }
 
        ds_file_group->stream_id = stream_instance_id;
-       BT_ASSERT(stream_class);
-       ds_file_group->stream_class = stream_class;
-       bt_stream_class_get_ref(ds_file_group->stream_class);
+       BT_ASSERT(sc);
+       ds_file_group->sc = sc;
        ds_file_group->ctf_fs_trace = ctf_fs_trace;
        goto end;
 
@@ -614,7 +646,6 @@ static
 int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace,
                const char *path)
 {
-       bt_stream_class *stream_class = NULL;
        int64_t stream_instance_id = -1;
        int64_t begin_ns = -1;
        struct ctf_fs_ds_file_group *ds_file_group = NULL;
@@ -650,8 +681,6 @@ int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace,
        sc = ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc,
                props.stream_class_id);
        BT_ASSERT(sc);
-       stream_class = sc->ir_sc;
-       BT_ASSERT(stream_class);
        stream_instance_id = props.data_stream_id;
 
        if (props.snapshots.beginning_clock != UINT64_C(-1)) {
@@ -692,7 +721,7 @@ int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace,
                 * group.
                 */
                ds_file_group = ctf_fs_ds_file_group_create(ctf_fs_trace,
-                       stream_class, stream_instance_id);
+                       sc, UINT64_C(-1));
                if (!ds_file_group) {
                        goto error;
                }
@@ -717,7 +746,7 @@ int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace,
                ds_file_group = g_ptr_array_index(
                        ctf_fs_trace->ds_file_groups, i);
 
-               if (ds_file_group->stream_class == stream_class &&
+               if (ds_file_group->sc == sc &&
                                ds_file_group->stream_id ==
                                stream_instance_id) {
                        break;
@@ -728,7 +757,7 @@ int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace,
 
        if (!ds_file_group) {
                ds_file_group = ctf_fs_ds_file_group_create(ctf_fs_trace,
-                       stream_class, stream_instance_id);
+                       sc, stream_instance_id);
                if (!ds_file_group) {
                        goto error;
                }
@@ -771,7 +800,6 @@ int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace)
        const char *basename;
        GError *error = NULL;
        GDir *dir = NULL;
-       size_t i;
 
        /* Check each file in the path directory, except specific ones */
        dir = g_dir_open(ctf_fs_trace->path->str, 0, &error);
@@ -842,62 +870,6 @@ int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace)
                ctf_fs_file_destroy(file);
        }
 
-       if (!ctf_fs_trace->trace) {
-               goto end;
-       }
-
-       /*
-        * At this point, DS file groupes are created, but their
-        * associated stream objects do not exist yet. This is because
-        * we need to name the created stream object with the data
-        * stream file's path. We have everything we need here to do
-        * this.
-        */
-       for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) {
-               struct ctf_fs_ds_file_group *ds_file_group =
-                       g_ptr_array_index(ctf_fs_trace->ds_file_groups, i);
-               GString *name = get_stream_instance_unique_name(ds_file_group);
-
-               if (!name) {
-                       goto error;
-               }
-
-               if (ds_file_group->stream_id == UINT64_C(-1)) {
-                       /* No stream ID: use 0 */
-                       ds_file_group->stream = bt_stream_create_with_id(
-                               ds_file_group->stream_class,
-                               ctf_fs_trace->trace,
-                               ctf_fs_trace->next_stream_id);
-                       ctf_fs_trace->next_stream_id++;
-               } else {
-                       /* Specific stream ID */
-                       ds_file_group->stream = bt_stream_create_with_id(
-                               ds_file_group->stream_class,
-                               ctf_fs_trace->trace,
-                               (uint64_t) ds_file_group->stream_id);
-               }
-
-               if (!ds_file_group->stream) {
-                       BT_LOGE("Cannot create stream for DS file group: "
-                               "addr=%p, stream-name=\"%s\"",
-                               ds_file_group, name->str);
-                       g_string_free(name, TRUE);
-                       goto error;
-               }
-
-               ret = bt_stream_set_name(ds_file_group->stream,
-                       name->str);
-               if (ret) {
-                       BT_LOGE("Cannot set stream's name: "
-                               "addr=%p, stream-name=\"%s\"",
-                               ds_file_group->stream, name->str);
-                       g_string_free(name, TRUE);
-                       goto error;
-               }
-
-               g_string_free(name, TRUE);
-       }
-
        goto end;
 
 error:
@@ -964,7 +936,7 @@ end:
        return ret;
 }
 
-BT_HIDDEN
+static
 struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component_source *self_comp,
                const char *path, const char *name,
                struct ctf_fs_metadata_config *metadata_config)
@@ -1025,15 +997,6 @@ struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component_source *self_comp,
                goto error;
        }
 
-       /*
-        * create_ds_file_groups() created all the streams that this
-        * trace needs. There won't be any more. Therefore it is safe to
-        * make this trace static.
-        */
-       if (ctf_fs_trace->trace) {
-               (void) bt_trace_make_static(ctf_fs_trace->trace);
-       }
-
        goto end;
 
 error:
@@ -1099,7 +1062,7 @@ end:
        return ret;
 }
 
-BT_HIDDEN
+static
 int ctf_fs_find_traces(GList **trace_paths, const char *start_path)
 {
        int ret;
@@ -1170,7 +1133,7 @@ end:
        return ret;
 }
 
-BT_HIDDEN
+static
 GList *ctf_fs_create_trace_names(GList *trace_paths, const char *base_path) {
        GList *trace_names = NULL;
        GList *node;
@@ -1223,8 +1186,10 @@ GList *ctf_fs_create_trace_names(GList *trace_paths, const char *base_path) {
        return trace_names;
 }
 
+/* Helper for ctf_fs_component_create_ctf_fs_traces, to handle a single path/root. */
+
 static
-int create_ctf_fs_traces(bt_self_component_source *self_comp,
+int ctf_fs_component_create_ctf_fs_traces_one_root(bt_self_component_source *self_comp,
                struct ctf_fs_component *ctf_fs,
                const char *path_param)
 {
@@ -1275,11 +1240,6 @@ int create_ctf_fs_traces(bt_self_component_source *self_comp,
                        goto error;
                }
 
-               ret = create_ports_for_trace(ctf_fs, ctf_fs_trace);
-               if (ret) {
-                       goto error;
-               }
-
                g_ptr_array_add(ctf_fs->traces, ctf_fs_trace);
                ctf_fs_trace = NULL;
        }
@@ -1318,18 +1278,158 @@ end:
        return ret;
 }
 
+int ctf_fs_component_create_ctf_fs_traces(bt_self_component_source *self_comp,
+               struct ctf_fs_component *ctf_fs,
+               const bt_value *paths_value)
+{
+       int ret = 0;
+       uint64_t i;
+
+       for (i = 0; i < bt_value_array_get_size(paths_value); i++) {
+               const bt_value *path_value = bt_value_array_borrow_element_by_index_const(paths_value, i);
+               const char *path = bt_value_string_get(path_value);
+
+               ret = ctf_fs_component_create_ctf_fs_traces_one_root(self_comp, ctf_fs, path);
+               if (ret) {
+                       goto end;
+               }
+       }
+
+end:
+       return ret;
+}
+
+/* Create the IR stream objects for ctf_fs_trace. */
+
+static
+int create_streams_for_trace(struct ctf_fs_trace *ctf_fs_trace)
+{
+       int ret;
+       GString *name = NULL;
+       guint i;
+
+       for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) {
+               struct ctf_fs_ds_file_group *ds_file_group =
+                       g_ptr_array_index(ctf_fs_trace->ds_file_groups, i);
+               name = get_stream_instance_unique_name(ds_file_group);
+
+               if (!name) {
+                       goto error;
+               }
+
+               if (ds_file_group->sc->ir_sc) {
+                       BT_ASSERT(ctf_fs_trace->trace);
+
+                       if (ds_file_group->stream_id == UINT64_C(-1)) {
+                               /* No stream ID: use 0 */
+                               ds_file_group->stream = bt_stream_create_with_id(
+                                       ds_file_group->sc->ir_sc,
+                                       ctf_fs_trace->trace,
+                                       ctf_fs_trace->next_stream_id);
+                               ctf_fs_trace->next_stream_id++;
+                       } else {
+                               /* Specific stream ID */
+                               ds_file_group->stream = bt_stream_create_with_id(
+                                       ds_file_group->sc->ir_sc,
+                                       ctf_fs_trace->trace,
+                                       (uint64_t) ds_file_group->stream_id);
+                       }
+               } else {
+                       ds_file_group->stream = NULL;
+               }
+
+               if (!ds_file_group->stream) {
+                       BT_LOGE("Cannot create stream for DS file group: "
+                               "addr=%p, stream-name=\"%s\"",
+                               ds_file_group, name->str);
+                       goto error;
+               }
+
+               ret = bt_stream_set_name(ds_file_group->stream,
+                       name->str);
+               if (ret) {
+                       BT_LOGE("Cannot set stream's name: "
+                               "addr=%p, stream-name=\"%s\"",
+                               ds_file_group->stream, name->str);
+                       goto error;
+               }
+
+               g_string_free(name, TRUE);
+               name = NULL;
+       }
+
+       ret = 0;
+       goto end;
+
+error:
+       ret = -1;
+
+end:
+
+       if (name) {
+               g_string_free(name, TRUE);
+       }
+       return ret;
+}
+
+bool validate_paths_parameter(const bt_value *paths)
+{
+       bool ret;
+       bt_value_type type;
+       uint64_t i;
+
+       if (!paths) {
+               BT_LOGE("missing \"paths\" parameter");
+               goto error;
+       }
+
+       type = bt_value_get_type(paths);
+       if (type != BT_VALUE_TYPE_ARRAY) {
+               BT_LOGE("`paths` parameter: expecting array value: type=%s",
+                       bt_common_value_type_string(type));
+               goto error;
+       }
+
+       for (i = 0; i < bt_value_array_get_size(paths); i++) {
+               const bt_value *elem;
+
+               elem = bt_value_array_borrow_element_by_index_const(paths, i);
+               type = bt_value_get_type(elem);
+               if (type != BT_VALUE_TYPE_STRING) {
+                       BT_LOGE("`paths` parameter: expecting string value: index=%" PRIu64 ", type=%s",
+                               i, bt_common_value_type_string(type));
+                       goto error;
+               }
+       }
+
+       ret = true;
+       goto end;
+
+error:
+       ret = false;
+
+end:
+       return ret;
+}
+
 static
 struct ctf_fs_component *ctf_fs_create(
                bt_self_component_source *self_comp,
                const bt_value *params)
 {
-       struct ctf_fs_component *ctf_fs;
+       struct ctf_fs_component *ctf_fs = NULL;
        const bt_value *value = NULL;
-       const char *path_param;
+       guint i;
+       const bt_value *paths_value;
 
-       ctf_fs = g_new0(struct ctf_fs_component, 1);
+       paths_value = bt_value_map_borrow_entry_value_const(params, "paths");
+       if (!validate_paths_parameter(paths_value)) {
+               goto error;
+       }
+
+       ctf_fs = ctf_fs_component_create();
        if (!ctf_fs) {
-               goto end;
+               goto error;
        }
 
        bt_self_component_set_data(
@@ -1342,12 +1442,7 @@ struct ctf_fs_component *ctf_fs_create(
         * private component should also exist.
         */
        ctf_fs->self_comp = self_comp;
-       value = bt_value_map_borrow_entry_value_const(params, "path");
-       if (value && !bt_value_is_string(value)) {
-               goto error;
-       }
 
-       path_param = bt_value_string_get(value);
        value = bt_value_map_borrow_entry_value_const(params,
                "clock-class-offset-s");
        if (value) {
@@ -1368,19 +1463,20 @@ struct ctf_fs_component *ctf_fs_create(
                ctf_fs->metadata_config.clock_class_offset_ns = bt_value_integer_get(value);
        }
 
-       ctf_fs->port_data = g_ptr_array_new_with_free_func(port_data_destroy);
-       if (!ctf_fs->port_data) {
+       if (ctf_fs_component_create_ctf_fs_traces(self_comp, ctf_fs, paths_value)) {
                goto error;
        }
 
-       ctf_fs->traces = g_ptr_array_new_with_free_func(
-                       ctf_fs_trace_destroy_notifier);
-       if (!ctf_fs->traces) {
-               goto error;
-       }
+       for (i = 0; i < ctf_fs->traces->len; i++) {
+               struct ctf_fs_trace *trace = g_ptr_array_index(ctf_fs->traces, i);
 
-       if (create_ctf_fs_traces(self_comp, ctf_fs, path_param)) {
-               goto error;
+               if (create_streams_for_trace(trace)) {
+                       goto error;
+               }
+
+               if (create_ports_for_trace(ctf_fs, trace)) {
+                       goto error;
+               }
        }
 
        goto end;
This page took 0.033604 seconds and 5 git commands to generate.