[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;
	struct range trace_intersection = {
		.begin_ns = 0,
		.end_ns = INT64_MAX,
		.set = false,
	};

	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,
		"streams", &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;
		}

		if (group_range.set) {
			trace_intersection.begin_ns = MAX(trace_intersection.begin_ns,
					group_range.begin_ns);
			trace_intersection.end_ns = MIN(trace_intersection.end_ns,
					group_range.end_ns);
			trace_intersection.set = true;
		}
	}

	if (trace_intersection.begin_ns < trace_intersection.end_ns) {
		ret = add_range(trace_info, &trace_intersection,
				"intersection-range-ns");
		if (ret) {
			goto end;
		}
	}

end:
	return ret;
}

BT_HIDDEN
bt_component_class_query_method_status trace_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)
{
	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;
	guint i;

	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_traces(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;
	}

	for (i = 0; i < ctf_fs->traces->len; i++) {
		struct ctf_fs_trace *trace;
		bt_value *trace_info;
		bt_value_array_append_element_status append_status;

		trace = g_ptr_array_index(ctf_fs->traces, i);
		BT_ASSERT(trace);

		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(trace, trace_info);
		if (ret) {
			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:
	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 JG	288	struct range trace_intersection = {
	289	.begin_ns = 0,
	290	.end_ns = INT64_MAX,
	291	.set = false,
	292	};
	293
f280892e SM	294	BT_ASSERT(trace->ds_file_groups);
	295	/* Add trace range info only if it contains streams. */
	296	if (trace->ds_file_groups->len == 0) {
	297	ret = -1;
	298	goto end;
	299	}
	300
760b266c SM	301	insert_status = bt_value_map_insert_empty_array_entry(trace_info,
	302	"streams", &file_groups);
	303	if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	304	ret = -1;
97ade20b JG	305	goto end;
	306	}
	307
97ade20b JG	308	/* Find range of all stream groups, and of the trace. */
	309	for (group_idx = 0; group_idx < trace->ds_file_groups->len;
	310	group_idx++) {
b19ff26f	311	bt_value *group_info;
97ade20b JG	312	struct range group_range = { .set = false };
	313	struct ctf_fs_ds_file_group *group = g_ptr_array_index(
	314	trace->ds_file_groups, group_idx);
	315
760b266c SM	316	append_status = bt_value_array_append_empty_map_element(
	317	file_groups, &group_info);
	318	if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
97ade20b JG	319	ret = -1;
	320	goto end;
	321	}
	322
	323	ret = populate_stream_info(group, group_info, &group_range);
	324	if (ret) {
7233204d FD	325	goto end;
	326	}
	327
97ade20b	328	if (group_range.set) {
91d81473	329	trace_intersection.begin_ns = MAX(trace_intersection.begin_ns,
97ade20b	330	group_range.begin_ns);
91d81473	331	trace_intersection.end_ns = MIN(trace_intersection.end_ns,
97ade20b JG	332	group_range.end_ns);
97ade20b JG	333	trace_intersection.set = true;
97ade20b JG	334	}
	335	}
	336
c6daf8b2 PP	337	if (trace_intersection.begin_ns < trace_intersection.end_ns) {
	338	ret = add_range(trace_info, &trace_intersection,
	339	"intersection-range-ns");
	340	if (ret) {
	341	goto end;
	342	}
97ade20b JG	343	}
97ade20b JG	344
97ade20b	345	end:
97ade20b JG	346	return ret;
	347	}
	348
	349	BT_HIDDEN
d24d5663	350	bt_component_class_query_method_status trace_info_query(
d23b766e	351	bt_self_component_class_source *self_comp_class_src,
98903a3e	352	const bt_value *params, bt_logging_level log_level,
b19ff26f	353	const bt_value **user_result)
97ade20b	354	{
f280892e	355	struct ctf_fs_component *ctf_fs = NULL;
d24d5663 PP	356	bt_component_class_query_method_status status =
d24d5663 PP	357	BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
d23b766e SM	358	bt_self_component_class *self_comp_class =
	359	bt_self_component_class_source_as_self_component_class(
	360	self_comp_class_src);
b19ff26f	361	bt_value *result = NULL;
73760435	362	const bt_value *inputs_value = NULL;
97ade20b	363	int ret = 0;
f280892e	364	guint i;
97ade20b	365
f6ccaed9 PP	366	BT_ASSERT(params);
f6ccaed9 PP	367
97ade20b	368	if (!bt_value_is_map(params)) {
d23b766e SM	369	BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
d23b766e SM	370	"Query parameters is not a map value object.");
a635e507	371	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
97ade20b JG	372	goto error;
	373	}
	374
4c65a157	375	ctf_fs = ctf_fs_component_create(log_level, NULL);
d907165c	376	if (!ctf_fs) {
97ade20b JG	377	goto error;
97ade20b JG	378	}
97ade20b	379
d23b766e SM	380	if (!read_src_fs_parameters(params, &inputs_value, ctf_fs, NULL,
d23b766e SM	381	self_comp_class)) {
a635e507	382	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
97ade20b JG	383	goto error;
	384	}
	385
d23b766e SM	386	if (ctf_fs_component_create_ctf_fs_traces(ctf_fs, inputs_value, NULL,
d23b766e SM	387	self_comp_class)) {
97ade20b JG	388	goto error;
	389	}
	390
05e21286	391	result = bt_value_array_create();
da91b29a	392	if (!result) {
d24d5663	393	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
97ade20b JG	394	goto error;
	395	}
	396
f280892e SM	397	for (i = 0; i < ctf_fs->traces->len; i++) {
f280892e SM	398	struct ctf_fs_trace *trace;
b19ff26f	399	bt_value *trace_info;
d24d5663	400	bt_value_array_append_element_status append_status;
f280892e SM	401
	402	trace = g_ptr_array_index(ctf_fs->traces, i);
	403	BT_ASSERT(trace);
97ade20b	404
760b266c SM	405	append_status = bt_value_array_append_empty_map_element(result,
	406	&trace_info);
	407	if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
d23b766e SM	408	BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
d23b766e SM	409	"Failed to create trace info map.");
97ade20b JG	410	goto error;
	411	}
	412
f280892e	413	ret = populate_trace_info(trace, trace_info);
97ade20b	414	if (ret) {
97ade20b JG	415	goto error;
	416	}
	417	}
	418
	419	goto end;
	420
	421	error:
c5b9b441	422	BT_VALUE_PUT_REF_AND_RESET(result);
d94d92ac	423	result = NULL;
c7eee084	424
d94d92ac	425	if (status >= 0) {
d24d5663	426	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
c7eee084 PP	427	}
c7eee084 PP	428
97ade20b	429	end:
f280892e SM	430	if (ctf_fs) {
	431	ctf_fs_destroy(ctf_fs);
	432	ctf_fs = NULL;
97ade20b	433	}
d94d92ac	434
05e21286	435	*user_result = result;
d94d92ac	436	return status;
04c0ba87	437	}
73760435 SM	438
	439	BT_HIDDEN
	440	bt_component_class_query_method_status support_info_query(
	441	bt_self_component_class_source *comp_class,
	442	const bt_value *params, bt_logging_level log_level,
	443	const bt_value **user_result)
	444	{
	445	const bt_value *input_type_value;
	446	const char *input_type;
	447	bt_component_class_query_method_status status;
493917ba	448	bt_value_map_insert_entry_status insert_entry_status;
73760435 SM	449	double weight = 0;
	450	gchar *metadata_path = NULL;
	451	bt_value *result = NULL;
493917ba SM	452	struct ctf_metadata_decoder *metadata_decoder = NULL;
	453	FILE *metadata_file = NULL;
	454	char uuid_str[BT_UUID_STR_LEN + 1];
	455	bool has_uuid = false;
	456	const bt_value *input_value;
	457	const char *input;
73760435 SM	458
	459	input_type_value = bt_value_map_borrow_entry_value_const(params, "type");
	460	BT_ASSERT(input_type_value);
	461	BT_ASSERT(bt_value_get_type(input_type_value) == BT_VALUE_TYPE_STRING);
	462	input_type = bt_value_string_get(input_type_value);
	463
493917ba SM	464	if (strcmp(input_type, "directory") != 0) {
	465	goto create_result;
	466	}
	467
	468	input_value = bt_value_map_borrow_entry_value_const(params, "input");
	469	BT_ASSERT(input_value);
	470	BT_ASSERT(bt_value_get_type(input_value) == BT_VALUE_TYPE_STRING);
	471	input = bt_value_string_get(input_value);
	472
	473	metadata_path = g_build_filename(input, CTF_FS_METADATA_FILENAME, NULL);
	474	if (!metadata_path) {
73760435 SM	475	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
	476	goto end;
	477	}
	478
493917ba SM	479	metadata_file = g_fopen(metadata_path, "r");
	480	if (metadata_file) {
	481	struct ctf_metadata_decoder_config metadata_decoder_config = { 0 };
	482	enum ctf_metadata_decoder_status decoder_status;
	483	bt_uuid_t uuid;
73760435	484
493917ba	485	metadata_decoder_config.log_level = log_level;
73760435	486
493917ba SM	487	metadata_decoder = ctf_metadata_decoder_create(
	488	&metadata_decoder_config);
	489	if (!metadata_decoder) {
	490	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	491	goto end;
	492	}
	493
	494	decoder_status = ctf_metadata_decoder_append_content(
	495	metadata_decoder, metadata_file);
	496	if (decoder_status != CTF_METADATA_DECODER_STATUS_OK) {
	497	BT_LOGW("cannot append metadata content: metadata-decoder-status=%d",
	498	decoder_status);
	499	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
73760435 SM	500	goto end;
	501	}
	502
	503	/*
493917ba SM	504	* We were able to parse the metadata file, so we are
493917ba SM	505	* confident it's a CTF trace.
73760435	506	*/
493917ba SM	507	weight = 0.75;
	508
	509	/* If the trace has a UUID, return the stringified UUID as the group. */
	510	if (ctf_metadata_decoder_get_trace_class_uuid(metadata_decoder, uuid) == 0) {
	511	bt_uuid_to_str(uuid, uuid_str);
	512	has_uuid = true;
73760435 SM	513	}
	514	}
	515
493917ba SM	516	create_result:
	517	result = bt_value_map_create();
	518	if (!result) {
73760435 SM	519	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
	520	goto end;
	521	}
	522
493917ba SM	523	insert_entry_status = bt_value_map_insert_real_entry(result, "weight", weight);
	524	if (insert_entry_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	525	status = (int) insert_entry_status;
73760435 SM	526	goto end;
	527	}
	528
493917ba SM	529	/* We are not supposed to have weight == 0 and a UUID. */
	530	BT_ASSERT(weight > 0 \|\| !has_uuid);
	531
	532	if (weight > 0 && has_uuid) {
	533	insert_entry_status = bt_value_map_insert_string_entry(result, "group", uuid_str);
	534	if (insert_entry_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	535	status = (int) insert_entry_status;
	536	goto end;
	537	}
	538	}
	539
73760435 SM	540	*user_result = result;
	541	result = NULL;
	542	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
	543
	544	end:
	545	g_free(metadata_path);
	546	bt_value_put_ref(result);
493917ba	547	ctf_metadata_decoder_destroy(metadata_decoder);
73760435 SM	548
	549	return status;
	550	}