[babeltrace.git] / src / plugins / ctf / fs-src / query.cpp

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * Babeltrace CTF file system Reader Component queries
 */

#define BT_LOG_OUTPUT_LEVEL log_level
#define BT_LOG_TAG          "PLUGIN/SRC.CTF.FS/QUERY"
#include "logging/log.h"

#include "query.hpp"
#include <stdbool.h>
#include <glib.h>
#include <glib/gstdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "common/assert.h"
#include "metadata.hpp"
#include "../common/metadata/decoder.hpp"
#include "common/common.h"
#include "common/macros.h"
#include <babeltrace2/babeltrace.h>
#include "fs.hpp"
#include "logging/comp-logging.h"

#define METADATA_TEXT_SIG "/* CTF 1.8"

struct range
{
    int64_t begin_ns = 0;
    int64_t end_ns = 0;
    bool set = false;
};

bt_component_class_query_method_status
metadata_info_query(bt_self_component_class_source *self_comp_class_src, const bt_value *params,
                    bt_logging_level log_level, const bt_value **user_result)
{
    bt_component_class_query_method_status status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
    bt_self_component_class *self_comp_class =
        bt_self_component_class_source_as_self_component_class(self_comp_class_src);
    bt_value *result = NULL;
    const bt_value *path_value = NULL;
    FILE *metadata_fp = NULL;
    int ret;
    int bo;
    const char *path;
    bool is_packetized;
    struct ctf_metadata_decoder *decoder = NULL;
    ctf_metadata_decoder_config decoder_cfg {};
    enum ctf_metadata_decoder_status decoder_status;

    result = bt_value_map_create();
    if (!result) {
        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
        goto error;
    }

    BT_ASSERT(params);

    if (!bt_value_is_map(params)) {
        BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
                                        "Query parameters is not a map value object.");
        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
        goto error;
    }

    path_value = bt_value_map_borrow_entry_value_const(params, "path");
    if (!path_value) {
        BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, "Mandatory `path` parameter missing");
        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
        goto error;
    }

    if (!bt_value_is_string(path_value)) {
        BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
                                        "`path` parameter is required to be a string value");
        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
        goto error;
    }

    path = bt_value_string_get(path_value);

    BT_ASSERT(path);
    metadata_fp = ctf_fs_metadata_open_file(path);
    if (!metadata_fp) {
        BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, "Cannot open trace metadata: path=\"%s\".",
                                        path);
        goto error;
    }

    ret = ctf_metadata_decoder_is_packetized(metadata_fp, &is_packetized, &bo, log_level, NULL);
    if (ret) {
        BT_COMP_CLASS_LOGE_APPEND_CAUSE(
            self_comp_class,
            "Cannot check whether or not the metadata stream is packetized: path=\"%s\".", path);
        goto error;
    }

    decoder_cfg.log_level = log_level;
    decoder_cfg.self_comp_class = self_comp_class;
    decoder_cfg.keep_plain_text = true;
    decoder = ctf_metadata_decoder_create(&decoder_cfg);
    if (!decoder) {
        BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
                                        "Cannot create metadata decoder: path=\"%s\".", path);
        goto error;
    }

    rewind(metadata_fp);
    decoder_status = ctf_metadata_decoder_append_content(decoder, metadata_fp);
    if (decoder_status) {
        BT_COMP_CLASS_LOGE_APPEND_CAUSE(
            self_comp_class, "Cannot update metadata decoder's content: path=\"%s\".", path);
        goto error;
    }

    ret = bt_value_map_insert_string_entry(result, "text", ctf_metadata_decoder_get_text(decoder));
    if (ret) {
        BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
                                        "Cannot insert metadata text into query result.");
        goto error;
    }

    ret = bt_value_map_insert_bool_entry(result, "is-packetized", is_packetized);
    if (ret) {
        BT_COMP_CLASS_LOGE_APPEND_CAUSE(
            self_comp_class, "Cannot insert \"is-packetized\" attribute into query result.");
        goto error;
    }

    goto end;

error:
    BT_VALUE_PUT_REF_AND_RESET(result);
    result = NULL;

    if (status >= 0) {
        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
    }

end:
    ctf_metadata_decoder_destroy(decoder);

    if (metadata_fp) {
        ret = fclose(metadata_fp);
        if (ret) {
            BT_LOGE_ERRNO("Cannot close metatada file stream", ": path=\"%s\"", path);
        }
    }

    *user_result = result;
    return status;
}

static int add_range(bt_value *info, struct range *range, const char *range_name)
{
    int ret = 0;
    bt_value_map_insert_entry_status status;
    bt_value *range_map;

    if (!range->set) {
        /* Not an error. */
        goto end;
    }

    status = bt_value_map_insert_empty_map_entry(info, range_name, &range_map);
    if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
        ret = -1;
        goto end;
    }

    status = bt_value_map_insert_signed_integer_entry(range_map, "begin", range->begin_ns);
    if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
        ret = -1;
        goto end;
    }

    status = bt_value_map_insert_signed_integer_entry(range_map, "end", range->end_ns);
    if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
        ret = -1;
        goto end;
    }

end:
    return ret;
}

static int populate_stream_info(struct ctf_fs_ds_file_group *group, bt_value *group_info,
                                struct range *stream_range)
{
    int ret = 0;
    bt_value_map_insert_entry_status insert_status;
    struct ctf_fs_ds_index_entry *first_ds_index_entry, *last_ds_index_entry;
    gchar *port_name = NULL;

    /*
     * Since each `struct ctf_fs_ds_file_group` has a sorted array of
     * `struct ctf_fs_ds_index_entry`, we can compute the stream range from
     * the timestamp_begin of the first index entry and the timestamp_end
     * of the last index entry.
     */
    BT_ASSERT(group->index);
    BT_ASSERT(group->index->entries);
    BT_ASSERT(group->index->entries->len > 0);

    /* First entry. */
    first_ds_index_entry =
        (struct ctf_fs_ds_index_entry *) g_ptr_array_index(group->index->entries, 0);

    /* Last entry. */
    last_ds_index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
        group->index->entries, group->index->entries->len - 1);

    stream_range->begin_ns = first_ds_index_entry->timestamp_begin_ns;
    stream_range->end_ns = last_ds_index_entry->timestamp_end_ns;

    /*
     * If any of the begin and end timestamps is not set it means that
     * packets don't include `timestamp_begin` _and_ `timestamp_end` fields
     * in their packet context so we can't set the range.
     */
    stream_range->set =
        stream_range->begin_ns != UINT64_C(-1) && stream_range->end_ns != UINT64_C(-1);

    ret = add_range(group_info, stream_range, "range-ns");
    if (ret) {
        goto end;
    }

    port_name = ctf_fs_make_port_name(group);
    if (!port_name) {
        ret = -1;
        goto end;
    }

    insert_status = bt_value_map_insert_string_entry(group_info, "port-name", port_name);
    if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
        ret = -1;
        goto end;
    }

end:
    g_free(port_name);
    return ret;
}

static int populate_trace_info(const struct ctf_fs_trace *trace, bt_value *trace_info,
                               bt_logging_level log_level, bt_self_component_class *self_comp_class)
{
    int ret = 0;
    size_t group_idx;
    bt_value_map_insert_entry_status insert_status;
    bt_value_array_append_element_status append_status;
    bt_value *file_groups = NULL;

    BT_ASSERT(trace->ds_file_groups);
    /* Add trace range info only if it contains streams. */
    if (trace->ds_file_groups->len == 0) {
        ret = -1;
        BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, "Trace has no streams: trace-path=%s",
                                        trace->path->str);
        goto end;
    }

    insert_status = bt_value_map_insert_empty_array_entry(trace_info, "stream-infos", &file_groups);
    if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
        ret = -1;
        goto end;
    }

    /* Find range of all stream groups, and of the trace. */
    for (group_idx = 0; group_idx < trace->ds_file_groups->len; group_idx++) {
        bt_value *group_info;
        range group_range;
        ctf_fs_ds_file_group *group =
            (ctf_fs_ds_file_group *) g_ptr_array_index(trace->ds_file_groups, group_idx);

        append_status = bt_value_array_append_empty_map_element(file_groups, &group_info);
        if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
            ret = -1;
            goto end;
        }

        ret = populate_stream_info(group, group_info, &group_range);
        if (ret) {
            goto end;
        }
    }

end:
    return ret;
}

bt_component_class_query_method_status
trace_infos_query(bt_self_component_class_source *self_comp_class_src, const bt_value *params,
                  bt_logging_level log_level, const bt_value **user_result)
{
    struct ctf_fs_component *ctf_fs = NULL;
    bt_component_class_query_method_status status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
    bt_self_component_class *self_comp_class =
        bt_self_component_class_source_as_self_component_class(self_comp_class_src);
    bt_value *result = NULL;
    const bt_value *inputs_value = NULL;
    const bt_value *trace_name_value;
    int ret = 0;
    bt_value *trace_info = NULL;
    bt_value_array_append_element_status append_status;

    BT_ASSERT(params);

    if (!bt_value_is_map(params)) {
        BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
                                        "Query parameters is not a map value object.");
        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
        goto error;
    }

    ctf_fs = ctf_fs_component_create(log_level, NULL);
    if (!ctf_fs) {
        goto error;
    }

    if (!read_src_fs_parameters(params, &inputs_value, &trace_name_value, ctf_fs, NULL,
                                self_comp_class)) {
        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
        goto error;
    }

    if (ctf_fs_component_create_ctf_fs_trace(ctf_fs, inputs_value, trace_name_value, NULL,
                                             self_comp_class)) {
        goto error;
    }

    result = bt_value_array_create();
    if (!result) {
        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
        goto error;
    }

    append_status = bt_value_array_append_empty_map_element(result, &trace_info);
    if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
        BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, "Failed to create trace info map.");
        goto error;
    }

    ret = populate_trace_info(ctf_fs->trace, trace_info, log_level, self_comp_class);
    if (ret) {
        goto error;
    }

    goto end;

error:
    BT_VALUE_PUT_REF_AND_RESET(result);

    if (status >= 0) {
        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
    }

end:
    if (ctf_fs) {
        ctf_fs_destroy(ctf_fs);
        ctf_fs = NULL;
    }

    *user_result = result;
    return status;
}

bt_component_class_query_method_status
support_info_query(bt_self_component_class_source *comp_class, const bt_value *params,
                   bt_logging_level log_level, const bt_value **user_result)
{
    const bt_value *input_type_value;
    const char *input_type;
    bt_component_class_query_method_status status;
    bt_value_map_insert_entry_status insert_entry_status;
    double weight = 0;
    gchar *metadata_path = NULL;
    bt_value *result = NULL;
    struct ctf_metadata_decoder *metadata_decoder = NULL;
    FILE *metadata_file = NULL;
    char uuid_str[BT_UUID_STR_LEN + 1];
    bool has_uuid = false;
    const bt_value *input_value;
    const char *input;

    input_type_value = bt_value_map_borrow_entry_value_const(params, "type");
    BT_ASSERT(input_type_value);
    BT_ASSERT(bt_value_get_type(input_type_value) == BT_VALUE_TYPE_STRING);
    input_type = bt_value_string_get(input_type_value);

    if (strcmp(input_type, "directory") != 0) {
        goto create_result;
    }

    input_value = bt_value_map_borrow_entry_value_const(params, "input");
    BT_ASSERT(input_value);
    BT_ASSERT(bt_value_get_type(input_value) == BT_VALUE_TYPE_STRING);
    input = bt_value_string_get(input_value);

    metadata_path = g_build_filename(input, CTF_FS_METADATA_FILENAME, NULL);
    if (!metadata_path) {
        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
        goto end;
    }

    metadata_file = g_fopen(metadata_path, "rb");
    if (metadata_file) {
        ctf_metadata_decoder_config metadata_decoder_config {};
        enum ctf_metadata_decoder_status decoder_status;
        bt_uuid_t uuid;

        metadata_decoder_config.log_level = log_level;
        metadata_decoder_config.self_comp_class =
            bt_self_component_class_source_as_self_component_class(comp_class);

        metadata_decoder = ctf_metadata_decoder_create(&metadata_decoder_config);
        if (!metadata_decoder) {
            status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
            goto end;
        }

        decoder_status = ctf_metadata_decoder_append_content(metadata_decoder, metadata_file);
        if (decoder_status != CTF_METADATA_DECODER_STATUS_OK) {
            BT_LOGW("cannot append metadata content: metadata-decoder-status=%d", decoder_status);
            status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
            goto end;
        }

        /*
         * We were able to parse the metadata file, so we are
         * confident it's a CTF trace.
         */
        weight = 0.75;

        /* If the trace has a UUID, return the stringified UUID as the group. */
        if (ctf_metadata_decoder_get_trace_class_uuid(metadata_decoder, uuid) == 0) {
            bt_uuid_to_str(uuid, uuid_str);
            has_uuid = true;
        }
    }

create_result:
    result = bt_value_map_create();
    if (!result) {
        status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
        goto end;
    }

    insert_entry_status = bt_value_map_insert_real_entry(result, "weight", weight);
    if (insert_entry_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
        status = (bt_component_class_query_method_status) insert_entry_status;
        goto end;
    }

    /* We are not supposed to have weight == 0 and a UUID. */
    BT_ASSERT(weight > 0 || !has_uuid);

    if (weight > 0 && has_uuid) {
        insert_entry_status = bt_value_map_insert_string_entry(result, "group", uuid_str);
        if (insert_entry_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
            status = (bt_component_class_query_method_status) insert_entry_status;
            goto end;
        }
    }

    *user_result = result;
    result = NULL;
    status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;

end:
    g_free(metadata_path);
    bt_value_put_ref(result);
    ctf_metadata_decoder_destroy(metadata_decoder);

    return status;
}
Commit	Line	Data
04c0ba87	1	/*
0235b0db	2	* SPDX-License-Identifier: MIT
04c0ba87 JG	3	*
	4	* Copyright 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	5	*
0235b0db	6	* Babeltrace CTF file system Reader Component queries
04c0ba87 JG	7	*/
04c0ba87 JG	8
98903a3e	9	#define BT_LOG_OUTPUT_LEVEL log_level
4164020e	10	#define BT_LOG_TAG "PLUGIN/SRC.CTF.FS/QUERY"
98903a3e PP	11	#include "logging/log.h"
98903a3e PP	12
087cd0f5	13	#include "query.hpp"
04c0ba87	14	#include <stdbool.h>
493917ba SM	15	#include <glib.h>
	16	#include <glib/gstdio.h>
	17	#include <fcntl.h>
	18	#include <sys/types.h>
	19	#include <sys/stat.h>
578e048b	20	#include "common/assert.h"
087cd0f5 SM	21	#include "metadata.hpp"
087cd0f5 SM	22	#include "../common/metadata/decoder.hpp"
578e048b	23	#include "common/common.h"
91d81473	24	#include "common/macros.h"
3fadfbc0	25	#include <babeltrace2/babeltrace.h>
087cd0f5	26	#include "fs.hpp"
d23b766e	27	#include "logging/comp-logging.h"
55314f2a	28
4164020e	29	#define METADATA_TEXT_SIG "/* CTF 1.8"
04c0ba87	30
4164020e SM	31	struct range
	32	{
	33	int64_t begin_ns = 0;
	34	int64_t end_ns = 0;
	35	bool set = false;
97ade20b JG	36	};
97ade20b JG	37
4164020e SM	38	bt_component_class_query_method_status
	39	metadata_info_query(bt_self_component_class_source self_comp_class_src, const bt_value params,
	40	bt_logging_level log_level, const bt_value **user_result)
04c0ba87	41	{
4164020e SM	42	bt_component_class_query_method_status status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
	43	bt_self_component_class *self_comp_class =
	44	bt_self_component_class_source_as_self_component_class(self_comp_class_src);
	45	bt_value *result = NULL;
	46	const bt_value *path_value = NULL;
	47	FILE *metadata_fp = NULL;
	48	int ret;
	49	int bo;
	50	const char *path;
	51	bool is_packetized;
	52	struct ctf_metadata_decoder *decoder = NULL;
	53	ctf_metadata_decoder_config decoder_cfg {};
	54	enum ctf_metadata_decoder_status decoder_status;
	55
	56	result = bt_value_map_create();
	57	if (!result) {
	58	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
	59	goto error;
	60	}
	61
	62	BT_ASSERT(params);
	63
	64	if (!bt_value_is_map(params)) {
	65	BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
	66	"Query parameters is not a map value object.");
	67	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	68	goto error;
	69	}
	70
	71	path_value = bt_value_map_borrow_entry_value_const(params, "path");
	72	if (!path_value) {
	73	BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, "Mandatory `path` parameter missing");
	74	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	75	goto error;
	76	}
	77
	78	if (!bt_value_is_string(path_value)) {
	79	BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
	80	"`path` parameter is required to be a string value");
	81	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	82	goto error;
	83	}
	84
	85	path = bt_value_string_get(path_value);
	86
	87	BT_ASSERT(path);
	88	metadata_fp = ctf_fs_metadata_open_file(path);
	89	if (!metadata_fp) {
	90	BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, "Cannot open trace metadata: path=\"%s\".",
	91	path);
	92	goto error;
	93	}
	94
	95	ret = ctf_metadata_decoder_is_packetized(metadata_fp, &is_packetized, &bo, log_level, NULL);
	96	if (ret) {
	97	BT_COMP_CLASS_LOGE_APPEND_CAUSE(
	98	self_comp_class,
	99	"Cannot check whether or not the metadata stream is packetized: path=\"%s\".", path);
	100	goto error;
	101	}
	102
	103	decoder_cfg.log_level = log_level;
	104	decoder_cfg.self_comp_class = self_comp_class;
	105	decoder_cfg.keep_plain_text = true;
106	decoder = ctf_metadata_decoder_create(&decoder_cfg);
107	if (!decoder) {
108	BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
109	"Cannot create metadata decoder: path=\"%s\".", path);
110	goto error;
111	}
112
113	rewind(metadata_fp);
114	decoder_status = ctf_metadata_decoder_append_content(decoder, metadata_fp);
115	if (decoder_status) {
116	BT_COMP_CLASS_LOGE_APPEND_CAUSE(
117	self_comp_class, "Cannot update metadata decoder's content: path=\"%s\".", path);
118	goto error;
119	}
120
121	ret = bt_value_map_insert_string_entry(result, "text", ctf_metadata_decoder_get_text(decoder));
122	if (ret) {
123	BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
124	"Cannot insert metadata text into query result.");
125	goto error;
126	}
127
128	ret = bt_value_map_insert_bool_entry(result, "is-packetized", is_packetized);
129	if (ret) {
130	BT_COMP_CLASS_LOGE_APPEND_CAUSE(
131	self_comp_class, "Cannot insert \"is-packetized\" attribute into query result.");
132	goto error;
133	}
134
135	goto end;
04c0ba87 JG	136
04c0ba87 JG	137	error:
4164020e SM	138	BT_VALUE_PUT_REF_AND_RESET(result);
4164020e SM	139	result = NULL;
c7eee084	140
4164020e SM	141	if (status >= 0) {
	142	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	143	}
04c0ba87 JG	144
04c0ba87 JG	145	end:
4164020e SM	146	ctf_metadata_decoder_destroy(decoder);
	147
	148	if (metadata_fp) {
	149	ret = fclose(metadata_fp);
	150	if (ret) {
	151	BT_LOGE_ERRNO("Cannot close metatada file stream", ": path=\"%s\"", path);
	152	}
	153	}
	154
	155	*user_result = result;
	156	return status;
97ade20b	157	}
9ec238a8	158
4164020e	159	static int add_range(bt_value info, struct range range, const char *range_name)
97ade20b	160	{
4164020e SM	161	int ret = 0;
	162	bt_value_map_insert_entry_status status;
	163	bt_value *range_map;
	164
	165	if (!range->set) {
	166	/* Not an error. */
	167	goto end;
	168	}
	169
	170	status = bt_value_map_insert_empty_map_entry(info, range_name, &range_map);
	171	if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	172	ret = -1;
	173	goto end;
	174	}
	175
	176	status = bt_value_map_insert_signed_integer_entry(range_map, "begin", range->begin_ns);
	177	if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	178	ret = -1;
	179	goto end;
	180	}
	181
	182	status = bt_value_map_insert_signed_integer_entry(range_map, "end", range->end_ns);
	183	if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	184	ret = -1;
	185	goto end;
	186	}
97ade20b	187
97ade20b	188	end:
4164020e	189	return ret;
97ade20b JG	190	}
97ade20b JG	191
4164020e SM	192	static int populate_stream_info(struct ctf_fs_ds_file_group group, bt_value group_info,
4164020e SM	193	struct range *stream_range)
97ade20b	194	{
4164020e SM	195	int ret = 0;
	196	bt_value_map_insert_entry_status insert_status;
	197	struct ctf_fs_ds_index_entry first_ds_index_entry, last_ds_index_entry;
	198	gchar *port_name = NULL;
	199
	200	/*
	201	* Since each `struct ctf_fs_ds_file_group` has a sorted array of
	202	* `struct ctf_fs_ds_index_entry`, we can compute the stream range from
	203	* the timestamp_begin of the first index entry and the timestamp_end
	204	* of the last index entry.
	205	*/
	206	BT_ASSERT(group->index);
	207	BT_ASSERT(group->index->entries);
	208	BT_ASSERT(group->index->entries->len > 0);
	209
	210	/* First entry. */
	211	first_ds_index_entry =
	212	(struct ctf_fs_ds_index_entry *) g_ptr_array_index(group->index->entries, 0);
	213
	214	/* Last entry. */
	215	last_ds_index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
	216	group->index->entries, group->index->entries->len - 1);
	217
	218	stream_range->begin_ns = first_ds_index_entry->timestamp_begin_ns;
	219	stream_range->end_ns = last_ds_index_entry->timestamp_end_ns;
	220
	221	/*
	222	* If any of the begin and end timestamps is not set it means that
	223	* packets don't include `timestamp_begin` _and_ `timestamp_end` fields
	224	* in their packet context so we can't set the range.
	225	*/
	226	stream_range->set =
	227	stream_range->begin_ns != UINT64_C(-1) && stream_range->end_ns != UINT64_C(-1);
	228
	229	ret = add_range(group_info, stream_range, "range-ns");
	230	if (ret) {
	231	goto end;
	232	}
	233
	234	port_name = ctf_fs_make_port_name(group);
	235	if (!port_name) {
	236	ret = -1;
	237	goto end;
	238	}
	239
	240	insert_status = bt_value_map_insert_string_entry(group_info, "port-name", port_name);
	241	if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	242	ret = -1;
	243	goto end;
	244	}
a38d7650	245
97ade20b	246	end:
4164020e SM	247	g_free(port_name);
4164020e SM	248	return ret;
97ade20b JG	249	}
97ade20b JG	250
4164020e SM	251	static int populate_trace_info(const struct ctf_fs_trace trace, bt_value trace_info,
4164020e SM	252	bt_logging_level log_level, bt_self_component_class *self_comp_class)
97ade20b	253	{
4164020e SM	254	int ret = 0;
	255	size_t group_idx;
	256	bt_value_map_insert_entry_status insert_status;
	257	bt_value_array_append_element_status append_status;
	258	bt_value *file_groups = NULL;
	259
	260	BT_ASSERT(trace->ds_file_groups);
	261	/* Add trace range info only if it contains streams. */
	262	if (trace->ds_file_groups->len == 0) {
	263	ret = -1;
	264	BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, "Trace has no streams: trace-path=%s",
	265	trace->path->str);
	266	goto end;
	267	}
	268
	269	insert_status = bt_value_map_insert_empty_array_entry(trace_info, "stream-infos", &file_groups);
	270	if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	271	ret = -1;
	272	goto end;
	273	}
	274
	275	/* Find range of all stream groups, and of the trace. */
	276	for (group_idx = 0; group_idx < trace->ds_file_groups->len; group_idx++) {
	277	bt_value *group_info;
	278	range group_range;
	279	ctf_fs_ds_file_group *group =
	280	(ctf_fs_ds_file_group *) g_ptr_array_index(trace->ds_file_groups, group_idx);
	281
	282	append_status = bt_value_array_append_empty_map_element(file_groups, &group_info);
	283	if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
	284	ret = -1;
	285	goto end;
	286	}
	287
	288	ret = populate_stream_info(group, group_info, &group_range);
	289	if (ret) {
	290	goto end;
	291	}
	292	}
97ade20b	293
97ade20b	294	end:
4164020e	295	return ret;
97ade20b JG	296	}
97ade20b JG	297
4164020e SM	298	bt_component_class_query_method_status
	299	trace_infos_query(bt_self_component_class_source self_comp_class_src, const bt_value params,
	300	bt_logging_level log_level, const bt_value **user_result)
97ade20b	301	{
4164020e SM	302	struct ctf_fs_component *ctf_fs = NULL;
	303	bt_component_class_query_method_status status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
	304	bt_self_component_class *self_comp_class =
	305	bt_self_component_class_source_as_self_component_class(self_comp_class_src);
	306	bt_value *result = NULL;
	307	const bt_value *inputs_value = NULL;
	308	const bt_value *trace_name_value;
	309	int ret = 0;
	310	bt_value *trace_info = NULL;
	311	bt_value_array_append_element_status append_status;
	312
	313	BT_ASSERT(params);
	314
	315	if (!bt_value_is_map(params)) {
	316	BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
	317	"Query parameters is not a map value object.");
	318	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	319	goto error;
	320	}
	321
	322	ctf_fs = ctf_fs_component_create(log_level, NULL);
	323	if (!ctf_fs) {
	324	goto error;
	325	}
	326
	327	if (!read_src_fs_parameters(params, &inputs_value, &trace_name_value, ctf_fs, NULL,
	328	self_comp_class)) {
	329	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	330	goto error;
	331	}
	332
	333	if (ctf_fs_component_create_ctf_fs_trace(ctf_fs, inputs_value, trace_name_value, NULL,
	334	self_comp_class)) {
	335	goto error;
	336	}
	337
	338	result = bt_value_array_create();
	339	if (!result) {
	340	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
	341	goto error;
	342	}
	343
	344	append_status = bt_value_array_append_empty_map_element(result, &trace_info);
	345	if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
	346	BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, "Failed to create trace info map.");
	347	goto error;
	348	}
	349
	350	ret = populate_trace_info(ctf_fs->trace, trace_info, log_level, self_comp_class);
	351	if (ret) {
	352	goto error;
	353	}
	354
	355	goto end;
97ade20b JG	356
97ade20b JG	357	error:
4164020e	358	BT_VALUE_PUT_REF_AND_RESET(result);
c7eee084	359
4164020e SM	360	if (status >= 0) {
	361	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	362	}
c7eee084	363
97ade20b	364	end:
4164020e SM	365	if (ctf_fs) {
	366	ctf_fs_destroy(ctf_fs);
	367	ctf_fs = NULL;
	368	}
d94d92ac	369
4164020e SM	370	*user_result = result;
4164020e SM	371	return status;
04c0ba87	372	}
73760435	373
4164020e SM	374	bt_component_class_query_method_status
	375	support_info_query(bt_self_component_class_source comp_class, const bt_value params,
	376	bt_logging_level log_level, const bt_value **user_result)
73760435	377	{
4164020e SM	378	const bt_value *input_type_value;
	379	const char *input_type;
	380	bt_component_class_query_method_status status;
	381	bt_value_map_insert_entry_status insert_entry_status;
	382	double weight = 0;
	383	gchar *metadata_path = NULL;
	384	bt_value *result = NULL;
	385	struct ctf_metadata_decoder *metadata_decoder = NULL;
	386	FILE *metadata_file = NULL;
	387	char uuid_str[BT_UUID_STR_LEN + 1];
	388	bool has_uuid = false;
	389	const bt_value *input_value;
	390	const char *input;
	391
	392	input_type_value = bt_value_map_borrow_entry_value_const(params, "type");
	393	BT_ASSERT(input_type_value);
	394	BT_ASSERT(bt_value_get_type(input_type_value) == BT_VALUE_TYPE_STRING);
	395	input_type = bt_value_string_get(input_type_value);
	396
	397	if (strcmp(input_type, "directory") != 0) {
	398	goto create_result;
	399	}
	400
	401	input_value = bt_value_map_borrow_entry_value_const(params, "input");
	402	BT_ASSERT(input_value);
	403	BT_ASSERT(bt_value_get_type(input_value) == BT_VALUE_TYPE_STRING);
	404	input = bt_value_string_get(input_value);
	405
	406	metadata_path = g_build_filename(input, CTF_FS_METADATA_FILENAME, NULL);
	407	if (!metadata_path) {
	408	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
	409	goto end;
	410	}
	411
	412	metadata_file = g_fopen(metadata_path, "rb");
	413	if (metadata_file) {
	414	ctf_metadata_decoder_config metadata_decoder_config {};
	415	enum ctf_metadata_decoder_status decoder_status;
	416	bt_uuid_t uuid;
	417
	418	metadata_decoder_config.log_level = log_level;
	419	metadata_decoder_config.self_comp_class =
	420	bt_self_component_class_source_as_self_component_class(comp_class);
	421
	422	metadata_decoder = ctf_metadata_decoder_create(&metadata_decoder_config);
	423	if (!metadata_decoder) {
	424	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	425	goto end;
	426	}
	427
	428	decoder_status = ctf_metadata_decoder_append_content(metadata_decoder, metadata_file);
	429	if (decoder_status != CTF_METADATA_DECODER_STATUS_OK) {
	430	BT_LOGW("cannot append metadata content: metadata-decoder-status=%d", decoder_status);
	431	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	432	goto end;
	433	}
	434
	435	/*
	436	* We were able to parse the metadata file, so we are
	437	* confident it's a CTF trace.
	438	*/
	439	weight = 0.75;
	440
	441	/* If the trace has a UUID, return the stringified UUID as the group. */
442	if (ctf_metadata_decoder_get_trace_class_uuid(metadata_decoder, uuid) == 0) {
443	bt_uuid_to_str(uuid, uuid_str);
444	has_uuid = true;
445	}
446	}
73760435	447
493917ba	448	create_result:
4164020e SM	449	result = bt_value_map_create();
	450	if (!result) {
	451	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
	452	goto end;
	453	}
	454
	455	insert_entry_status = bt_value_map_insert_real_entry(result, "weight", weight);
	456	if (insert_entry_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	457	status = (bt_component_class_query_method_status) insert_entry_status;
	458	goto end;
	459	}
	460
	461	/* We are not supposed to have weight == 0 and a UUID. */
	462	BT_ASSERT(weight > 0 \|\| !has_uuid);
	463
	464	if (weight > 0 && has_uuid) {
	465	insert_entry_status = bt_value_map_insert_string_entry(result, "group", uuid_str);
	466	if (insert_entry_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	467	status = (bt_component_class_query_method_status) insert_entry_status;
	468	goto end;
	469	}
	470	}
	471
	472	*user_result = result;
	473	result = NULL;
	474	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
73760435 SM	475
73760435 SM	476	end:
4164020e SM	477	g_free(metadata_path);
	478	bt_value_put_ref(result);
	479	ctf_metadata_decoder_destroy(metadata_decoder);
73760435	480
4164020e	481	return status;
73760435	482	}