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

/*
 * query.c
 *
 * Babeltrace CTF file system Reader Component queries
 *
 * Copyright 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

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

#include "query.h"
#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.h"
#include "../common/metadata/decoder.h"
#include "common/common.h"
#include "common/macros.h"
#include <babeltrace2/babeltrace.h>
#include "fs.h"
#include "logging/comp-logging.h"

#define METADATA_TEXT_SIG	"/* CTF 1.8"

struct range {
	int64_t begin_ns;
	int64_t end_ns;
	bool set;
};

BT_HIDDEN
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;
	struct ctf_metadata_decoder_config decoder_cfg = { 0 };
	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.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) {
		fclose(metadata_fp);
	}

	*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)
{
	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;
		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;
		struct range group_range = { .set = false };
		struct ctf_fs_ds_file_group *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_HIDDEN
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);
	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_HIDDEN
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) {
		struct ctf_metadata_decoder_config metadata_decoder_config = { 0 };
		enum ctf_metadata_decoder_status decoder_status;
		bt_uuid_t uuid;

		metadata_decoder_config.log_level = log_level;

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