[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;
	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, 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, 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, "r");
	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;
97ade20b	342	int ret = 0;
a0cd55ad SM	343	bt_value *trace_info = NULL;
a0cd55ad SM	344	bt_value_array_append_element_status append_status;
97ade20b	345
f6ccaed9 PP	346	BT_ASSERT(params);
f6ccaed9 PP	347
97ade20b	348	if (!bt_value_is_map(params)) {
d23b766e SM	349	BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
d23b766e SM	350	"Query parameters is not a map value object.");
a635e507	351	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
97ade20b JG	352	goto error;
	353	}
	354
4c65a157	355	ctf_fs = ctf_fs_component_create(log_level, NULL);
d907165c	356	if (!ctf_fs) {
97ade20b JG	357	goto error;
97ade20b JG	358	}
97ade20b	359
d23b766e SM	360	if (!read_src_fs_parameters(params, &inputs_value, ctf_fs, NULL,
d23b766e SM	361	self_comp_class)) {
a635e507	362	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
97ade20b JG	363	goto error;
	364	}
	365
a0cd55ad	366	if (ctf_fs_component_create_ctf_fs_trace(ctf_fs, inputs_value, NULL,
d23b766e	367	self_comp_class)) {
97ade20b JG	368	goto error;
	369	}
	370
05e21286	371	result = bt_value_array_create();
da91b29a	372	if (!result) {
d24d5663	373	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
97ade20b JG	374	goto error;
	375	}
	376
a0cd55ad SM	377	append_status = bt_value_array_append_empty_map_element(result,
	378	&trace_info);
	379	if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
	380	BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
	381	"Failed to create trace info map.");
	382	goto error;
	383	}
97ade20b	384
a0cd55ad SM	385	ret = populate_trace_info(ctf_fs->trace, trace_info);
	386	if (ret) {
	387	goto error;
97ade20b JG	388	}
	389
	390	goto end;
	391
	392	error:
c5b9b441	393	BT_VALUE_PUT_REF_AND_RESET(result);
c7eee084	394
d94d92ac	395	if (status >= 0) {
d24d5663	396	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
c7eee084 PP	397	}
c7eee084 PP	398
97ade20b	399	end:
f280892e SM	400	if (ctf_fs) {
	401	ctf_fs_destroy(ctf_fs);
	402	ctf_fs = NULL;
97ade20b	403	}
d94d92ac	404
05e21286	405	*user_result = result;
d94d92ac	406	return status;
04c0ba87	407	}
73760435 SM	408
	409	BT_HIDDEN
	410	bt_component_class_query_method_status support_info_query(
	411	bt_self_component_class_source *comp_class,
	412	const bt_value *params, bt_logging_level log_level,
	413	const bt_value **user_result)
	414	{
	415	const bt_value *input_type_value;
	416	const char *input_type;
	417	bt_component_class_query_method_status status;
493917ba	418	bt_value_map_insert_entry_status insert_entry_status;
73760435 SM	419	double weight = 0;
	420	gchar *metadata_path = NULL;
	421	bt_value *result = NULL;
493917ba SM	422	struct ctf_metadata_decoder *metadata_decoder = NULL;
	423	FILE *metadata_file = NULL;
	424	char uuid_str[BT_UUID_STR_LEN + 1];
	425	bool has_uuid = false;
	426	const bt_value *input_value;
	427	const char *input;
73760435 SM	428
	429	input_type_value = bt_value_map_borrow_entry_value_const(params, "type");
	430	BT_ASSERT(input_type_value);
	431	BT_ASSERT(bt_value_get_type(input_type_value) == BT_VALUE_TYPE_STRING);
	432	input_type = bt_value_string_get(input_type_value);
	433
493917ba SM	434	if (strcmp(input_type, "directory") != 0) {
	435	goto create_result;
	436	}
	437
	438	input_value = bt_value_map_borrow_entry_value_const(params, "input");
	439	BT_ASSERT(input_value);
	440	BT_ASSERT(bt_value_get_type(input_value) == BT_VALUE_TYPE_STRING);
	441	input = bt_value_string_get(input_value);
	442
	443	metadata_path = g_build_filename(input, CTF_FS_METADATA_FILENAME, NULL);
	444	if (!metadata_path) {
73760435 SM	445	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
	446	goto end;
	447	}
	448
493917ba SM	449	metadata_file = g_fopen(metadata_path, "r");
	450	if (metadata_file) {
	451	struct ctf_metadata_decoder_config metadata_decoder_config = { 0 };
	452	enum ctf_metadata_decoder_status decoder_status;
	453	bt_uuid_t uuid;
73760435	454
493917ba	455	metadata_decoder_config.log_level = log_level;
73760435	456
493917ba SM	457	metadata_decoder = ctf_metadata_decoder_create(
	458	&metadata_decoder_config);
	459	if (!metadata_decoder) {
	460	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	461	goto end;
	462	}
	463
	464	decoder_status = ctf_metadata_decoder_append_content(
	465	metadata_decoder, metadata_file);
	466	if (decoder_status != CTF_METADATA_DECODER_STATUS_OK) {
	467	BT_LOGW("cannot append metadata content: metadata-decoder-status=%d",
	468	decoder_status);
	469	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
73760435 SM	470	goto end;
	471	}
	472
	473	/*
493917ba SM	474	* We were able to parse the metadata file, so we are
493917ba SM	475	* confident it's a CTF trace.
73760435	476	*/
493917ba SM	477	weight = 0.75;
	478
	479	/* If the trace has a UUID, return the stringified UUID as the group. */
	480	if (ctf_metadata_decoder_get_trace_class_uuid(metadata_decoder, uuid) == 0) {
	481	bt_uuid_to_str(uuid, uuid_str);
	482	has_uuid = true;
73760435 SM	483	}
	484	}
	485
493917ba SM	486	create_result:
	487	result = bt_value_map_create();
	488	if (!result) {
73760435 SM	489	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
	490	goto end;
	491	}
	492
493917ba SM	493	insert_entry_status = bt_value_map_insert_real_entry(result, "weight", weight);
	494	if (insert_entry_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	495	status = (int) insert_entry_status;
73760435 SM	496	goto end;
	497	}
	498
493917ba SM	499	/* We are not supposed to have weight == 0 and a UUID. */
	500	BT_ASSERT(weight > 0 \|\| !has_uuid);
	501
	502	if (weight > 0 && has_uuid) {
	503	insert_entry_status = bt_value_map_insert_string_entry(result, "group", uuid_str);
	504	if (insert_entry_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	505	status = (int) insert_entry_status;
	506	goto end;
	507	}
	508	}
	509
73760435 SM	510	*user_result = result;
	511	result = NULL;
	512	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
	513
	514	end:
	515	g_free(metadata_path);
	516	bt_value_put_ref(result);
493917ba	517	ctf_metadata_decoder_destroy(metadata_decoder);
73760435 SM	518
	519	return status;
	520	}