[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 "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"

#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 *comp_class,
		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_value *result = NULL;
	const bt_value *path_value = NULL;
	char *metadata_text = NULL;
	FILE *metadata_fp = NULL;
	GString *g_metadata_text = NULL;
	int ret;
	int bo;
	const char *path;
	bool is_packetized;

	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_LOGE_STR("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_LOGE_STR("Mandatory `path` parameter missing");
		status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
		goto error;
	}

	if (!bt_value_is_string(path_value)) {
		BT_LOGE_STR("`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_LOGE("Cannot open trace metadata: path=\"%s\".", path);
		goto error;
	}

	is_packetized = ctf_metadata_decoder_is_packetized(metadata_fp,
		&bo, log_level, NULL);

	if (is_packetized) {
		ret = ctf_metadata_decoder_packetized_file_stream_to_buf(
			metadata_fp, &metadata_text, bo, NULL, NULL,
			log_level, NULL);
		if (ret) {
			BT_LOGE("Cannot decode packetized metadata file: path=\"%s\"",
				path);
			goto error;
		}
	} else {
		long filesize;

		ret = fseek(metadata_fp, 0, SEEK_END);
		if (ret) {
			BT_LOGE_ERRNO("Failed to seek to the end of the metadata file",
				": path=\"%s\"", path);
			goto error;
		}
		filesize = ftell(metadata_fp);
		if (filesize < 0) {
			BT_LOGE_ERRNO("Failed to get the current position in the metadata file",
				": path=\"%s\"", path);
			goto error;
		}
		rewind(metadata_fp);
		metadata_text = malloc(filesize + 1);
		if (!metadata_text) {
			BT_LOGE_STR("Cannot allocate buffer for metadata text.");
			goto error;
		}

		if (fread(metadata_text, filesize, 1, metadata_fp) != 1) {
			BT_LOGE_ERRNO("Cannot read metadata file", ": path=\"%s\"",
				path);
			goto error;
		}

		metadata_text[filesize] = '\0';
	}

	g_metadata_text = g_string_new(NULL);
	if (!g_metadata_text) {
		goto error;
	}

	if (strncmp(metadata_text, METADATA_TEXT_SIG,
			sizeof(METADATA_TEXT_SIG) - 1) != 0) {
		g_string_assign(g_metadata_text, METADATA_TEXT_SIG);
		g_string_append(g_metadata_text, " */\n\n");
	}

	g_string_append(g_metadata_text, metadata_text);

	ret = bt_value_map_insert_string_entry(result, "text",
		g_metadata_text->str);
	if (ret) {
		BT_LOGE_STR("Cannot insert metadata text into query result.");
		goto error;
	}

	ret = bt_value_map_insert_bool_entry(result, "is-packetized",
		is_packetized);
	if (ret) {
		BT_LOGE_STR("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:
	free(metadata_text);

	if (g_metadata_text) {
		g_string_free(g_metadata_text, TRUE);
	}

	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 = NULL;

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

	range_map = bt_value_map_create();
	if (!range_map) {
		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;
	}

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

end:
	bt_value_put_ref(range_map);
	return ret;
}

static
int add_stream_ids(bt_value *info, struct ctf_fs_ds_file_group *ds_file_group)
{
	int ret = 0;
	bt_value_map_insert_entry_status status;

	if (ds_file_group->stream_id != UINT64_C(-1)) {
		status = bt_value_map_insert_unsigned_integer_entry(info, "id",
			ds_file_group->stream_id);
		if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
			ret = -1;
			goto end;
		}
	}

	status = bt_value_map_insert_unsigned_integer_entry(info, "class-id",
		ds_file_group->sc->id);
	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;
	size_t file_idx;
	bt_value_map_insert_entry_status insert_status;
	bt_value_array_append_element_status append_status;
	bt_value *file_paths;
	struct ctf_fs_ds_index_entry *first_ds_index_entry, *last_ds_index_entry;
	gchar *port_name = NULL;

	file_paths = bt_value_array_create();
	if (!file_paths) {
		ret = -1;
		goto end;
	}

	for (file_idx = 0; file_idx < group->ds_file_infos->len; file_idx++) {
		struct ctf_fs_ds_file_info *info =
			g_ptr_array_index(group->ds_file_infos,
				file_idx);

		append_status = bt_value_array_append_string_element(file_paths,
				info->path->str);
		if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
			ret = -1;
			goto end;
		}
	}

	/*
	 * 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;
	}

	insert_status = bt_value_map_insert_entry(group_info, "paths",
		file_paths);
	if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
		ret = -1;
		goto end;
	}

	ret = add_stream_ids(group_info, group);
	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);
	bt_value_put_ref(file_paths);
	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_range = {
		.begin_ns = INT64_MAX,
		.end_ns = 0,
		.set = false,
	};
	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;
	}

	file_groups = bt_value_array_create();
	if (!file_groups) {
		goto end;
	}

	insert_status = bt_value_map_insert_string_entry(trace_info, "name",
		trace->name->str);
	if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
		ret = -1;
		goto end;
	}
	insert_status = bt_value_map_insert_string_entry(trace_info, "path",
		trace->path->str);
	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);

		group_info = bt_value_map_create();
		if (!group_info) {
			ret = -1;
			goto end;
		}

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

		append_status = bt_value_array_append_element(file_groups,
			group_info);
		bt_value_put_ref(group_info);
		if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
			goto end;
		}

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

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

	ret = add_range(trace_info, &trace_range, "range-ns");
	if (ret) {
		goto end;
	}

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

	insert_status = bt_value_map_insert_entry(trace_info, "streams",
		file_groups);
	BT_VALUE_PUT_REF_AND_RESET(file_groups);
	if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
		ret = -1;
		goto end;
	}

end:
	bt_value_put_ref(file_groups);
	return ret;
}

BT_HIDDEN
bt_component_class_query_method_status trace_info_query(
		bt_self_component_class_source *comp_class,
		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_value *result = NULL;
	const bt_value *inputs_value = NULL;
	int ret = 0;
	guint i;

	BT_ASSERT(params);

	if (!bt_value_is_map(params)) {
		BT_LOGE("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)) {
		status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
		goto error;
	}

	if (ctf_fs_component_create_ctf_fs_traces(NULL, ctf_fs, inputs_value)) {
		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);

		trace_info = bt_value_map_create();
		if (!trace_info) {
			BT_LOGE("Failed to create trace info map.");
			goto error;
		}

		ret = populate_trace_info(trace, trace_info);
		if (ret) {
			bt_value_put_ref(trace_info);
			goto error;
		}

		append_status = bt_value_array_append_element(result,
			trace_info);
		bt_value_put_ref(trace_info);
		if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
			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;
	double weight = 0;
	gchar *metadata_path = NULL;
	bt_value *result = NULL;

	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);

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

	if (strcmp(input_type, "directory") == 0) {
		const bt_value *input_value;
		const char *path;

		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);
		path = bt_value_string_get(input_value);

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

		/*
		 * If the metadata file exists in this directory, consider it to
		 * be a CTF trace.
		 */
		if (g_file_test(metadata_path, G_FILE_TEST_EXISTS)) {
			weight = 0.5;
		}
	}

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

	/*
	 * Use the arbitrary constant string "ctf" as the group, such that all
	 * found ctf traces are passed to the same instance of src.ctf.fs.
	 */
	if (bt_value_map_insert_string_entry(result, "group", "ctf") != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
		status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
		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);

	return status;
}
Commit	Line	Data
	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
	27	#define BT_LOG_OUTPUT_LEVEL log_level
	28	#define BT_LOG_TAG "PLUGIN/SRC.CTF.FS/QUERY"
	29	#include "logging/log.h"
	30
	31	#include "query.h"
	32	#include <stdbool.h>
	33	#include "common/assert.h"
	34	#include "metadata.h"
	35	#include "../common/metadata/decoder.h"
	36	#include "common/common.h"
	37	#include "common/macros.h"
	38	#include <babeltrace2/babeltrace.h>
	39	#include "fs.h"
	40
	41	#define METADATA_TEXT_SIG "/* CTF 1.8"
	42
	43	struct range {
	44	int64_t begin_ns;
	45	int64_t end_ns;
	46	bool set;
	47	};
	48
	49	BT_HIDDEN
	50	bt_component_class_query_method_status metadata_info_query(
	51	bt_self_component_class_source *comp_class,
	52	const bt_value *params, bt_logging_level log_level,
	53	const bt_value **user_result)
	54	{
	55	bt_component_class_query_method_status status =
	56	BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
	57	bt_value *result = NULL;
	58	const bt_value *path_value = NULL;
	59	char *metadata_text = NULL;
	60	FILE *metadata_fp = NULL;
	61	GString *g_metadata_text = NULL;
	62	int ret;
	63	int bo;
	64	const char *path;
	65	bool is_packetized;
	66
	67	result = bt_value_map_create();
	68	if (!result) {
	69	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
	70	goto error;
	71	}
	72
	73	BT_ASSERT(params);
	74
	75	if (!bt_value_is_map(params)) {
	76	BT_LOGE_STR("Query parameters is not a map value object.");
	77	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	78	goto error;
	79	}
	80
	81	path_value = bt_value_map_borrow_entry_value_const(params, "path");
	82	if (!path_value) {
	83	BT_LOGE_STR("Mandatory `path` parameter missing");
	84	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	85	goto error;
	86	}
	87
	88	if (!bt_value_is_string(path_value)) {
	89	BT_LOGE_STR("`path` parameter is required to be a string value");
	90	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	91	goto error;
	92	}
	93
	94	path = bt_value_string_get(path_value);
	95
	96	BT_ASSERT(path);
	97	metadata_fp = ctf_fs_metadata_open_file(path);
	98	if (!metadata_fp) {
	99	BT_LOGE("Cannot open trace metadata: path=\"%s\".", path);
	100	goto error;
	101	}
	102
	103	is_packetized = ctf_metadata_decoder_is_packetized(metadata_fp,
	104	&bo, log_level, NULL);
	105
	106	if (is_packetized) {
	107	ret = ctf_metadata_decoder_packetized_file_stream_to_buf(
	108	metadata_fp, &metadata_text, bo, NULL, NULL,
	109	log_level, NULL);
	110	if (ret) {
	111	BT_LOGE("Cannot decode packetized metadata file: path=\"%s\"",
	112	path);
	113	goto error;
	114	}
	115	} else {
	116	long filesize;
	117
	118	ret = fseek(metadata_fp, 0, SEEK_END);
	119	if (ret) {
	120	BT_LOGE_ERRNO("Failed to seek to the end of the metadata file",
	121	": path=\"%s\"", path);
	122	goto error;
	123	}
	124	filesize = ftell(metadata_fp);
	125	if (filesize < 0) {
	126	BT_LOGE_ERRNO("Failed to get the current position in the metadata file",
	127	": path=\"%s\"", path);
	128	goto error;
	129	}
	130	rewind(metadata_fp);
	131	metadata_text = malloc(filesize + 1);
	132	if (!metadata_text) {
	133	BT_LOGE_STR("Cannot allocate buffer for metadata text.");
	134	goto error;
	135	}
	136
	137	if (fread(metadata_text, filesize, 1, metadata_fp) != 1) {
	138	BT_LOGE_ERRNO("Cannot read metadata file", ": path=\"%s\"",
	139	path);
	140	goto error;
	141	}
	142
	143	metadata_text[filesize] = '\0';
	144	}
	145
	146	g_metadata_text = g_string_new(NULL);
	147	if (!g_metadata_text) {
	148	goto error;
	149	}
	150
	151	if (strncmp(metadata_text, METADATA_TEXT_SIG,
	152	sizeof(METADATA_TEXT_SIG) - 1) != 0) {
	153	g_string_assign(g_metadata_text, METADATA_TEXT_SIG);
	154	g_string_append(g_metadata_text, " */\n\n");
	155	}
	156
	157	g_string_append(g_metadata_text, metadata_text);
	158
	159	ret = bt_value_map_insert_string_entry(result, "text",
	160	g_metadata_text->str);
	161	if (ret) {
	162	BT_LOGE_STR("Cannot insert metadata text into query result.");
	163	goto error;
	164	}
	165
	166	ret = bt_value_map_insert_bool_entry(result, "is-packetized",
	167	is_packetized);
	168	if (ret) {
	169	BT_LOGE_STR("Cannot insert \"is-packetized\" attribute into query result.");
	170	goto error;
	171	}
	172
	173	goto end;
	174
	175	error:
	176	BT_VALUE_PUT_REF_AND_RESET(result);
	177	result = NULL;
	178
	179	if (status >= 0) {
	180	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	181	}
	182
	183	end:
	184	free(metadata_text);
	185
	186	if (g_metadata_text) {
	187	g_string_free(g_metadata_text, TRUE);
	188	}
	189
	190	if (metadata_fp) {
	191	fclose(metadata_fp);
	192	}
	193
	194	*user_result = result;
	195	return status;
	196	}
	197
	198	static
	199	int add_range(bt_value info, struct range range,
	200	const char *range_name)
	201	{
	202	int ret = 0;
	203	bt_value_map_insert_entry_status status;
	204	bt_value *range_map = NULL;
	205
	206	if (!range->set) {
	207	/* Not an error. */
	208	goto end;
	209	}
	210
	211	range_map = bt_value_map_create();
	212	if (!range_map) {
	213	ret = -1;
	214	goto end;
	215	}
	216
	217	status = bt_value_map_insert_signed_integer_entry(range_map, "begin",
	218	range->begin_ns);
	219	if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	220	ret = -1;
	221	goto end;
	222	}
	223
	224	status = bt_value_map_insert_signed_integer_entry(range_map, "end",
	225	range->end_ns);
	226	if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	227	ret = -1;
	228	goto end;
	229	}
	230
	231	status = bt_value_map_insert_entry(info, range_name,
	232	range_map);
	233	if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	234	ret = -1;
	235	goto end;
	236	}
	237
	238	end:
	239	bt_value_put_ref(range_map);
	240	return ret;
	241	}
	242
	243	static
	244	int add_stream_ids(bt_value info, struct ctf_fs_ds_file_group ds_file_group)
	245	{
	246	int ret = 0;
	247	bt_value_map_insert_entry_status status;
	248
	249	if (ds_file_group->stream_id != UINT64_C(-1)) {
	250	status = bt_value_map_insert_unsigned_integer_entry(info, "id",
	251	ds_file_group->stream_id);
	252	if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	253	ret = -1;
	254	goto end;
	255	}
	256	}
	257
	258	status = bt_value_map_insert_unsigned_integer_entry(info, "class-id",
	259	ds_file_group->sc->id);
	260	if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	261	ret = -1;
	262	goto end;
	263	}
	264
	265	end:
	266	return ret;
	267	}
	268
	269	static
	270	int populate_stream_info(struct ctf_fs_ds_file_group *group,
	271	bt_value group_info, struct range stream_range)
	272	{
	273	int ret = 0;
	274	size_t file_idx;
	275	bt_value_map_insert_entry_status insert_status;
	276	bt_value_array_append_element_status append_status;
	277	bt_value *file_paths;
	278	struct ctf_fs_ds_index_entry first_ds_index_entry, last_ds_index_entry;
	279	gchar *port_name = NULL;
	280
	281	file_paths = bt_value_array_create();
	282	if (!file_paths) {
	283	ret = -1;
	284	goto end;
	285	}
	286
	287	for (file_idx = 0; file_idx < group->ds_file_infos->len; file_idx++) {
	288	struct ctf_fs_ds_file_info *info =
	289	g_ptr_array_index(group->ds_file_infos,
	290	file_idx);
	291
	292	append_status = bt_value_array_append_string_element(file_paths,
	293	info->path->str);
	294	if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
	295	ret = -1;
	296	goto end;
	297	}
	298	}
	299
	300	/*
	301	* Since each `struct ctf_fs_ds_file_group` has a sorted array of
	302	* `struct ctf_fs_ds_index_entry`, we can compute the stream range from
	303	* the timestamp_begin of the first index entry and the timestamp_end
	304	* of the last index entry.
	305	*/
	306	BT_ASSERT(group->index);
	307	BT_ASSERT(group->index->entries);
	308	BT_ASSERT(group->index->entries->len > 0);
	309
	310	/* First entry. */
	311	first_ds_index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
	312	group->index->entries, 0);
	313
	314	/* Last entry. */
	315	last_ds_index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
	316	group->index->entries, group->index->entries->len - 1);
	317
	318	stream_range->begin_ns = first_ds_index_entry->timestamp_begin_ns;
	319	stream_range->end_ns = last_ds_index_entry->timestamp_end_ns;
	320
	321	/*
	322	* If any of the begin and end timestamps is not set it means that
	323	* packets don't include `timestamp_begin` _and_ `timestamp_end` fields
	324	* in their packet context so we can't set the range.
	325	*/
	326	stream_range->set = stream_range->begin_ns != UINT64_C(-1) &&
	327	stream_range->end_ns != UINT64_C(-1);
	328
	329	ret = add_range(group_info, stream_range, "range-ns");
	330	if (ret) {
	331	goto end;
	332	}
	333
	334	insert_status = bt_value_map_insert_entry(group_info, "paths",
	335	file_paths);
	336	if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	337	ret = -1;
	338	goto end;
	339	}
	340
	341	ret = add_stream_ids(group_info, group);
	342	if (ret) {
	343	goto end;
	344	}
	345
	346	port_name = ctf_fs_make_port_name(group);
	347	if (!port_name) {
	348	ret = -1;
	349	goto end;
	350	}
	351
	352	insert_status = bt_value_map_insert_string_entry(group_info,
	353	"port-name", port_name);
	354	if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	355	ret = -1;
	356	goto end;
	357	}
	358
	359	end:
	360	g_free(port_name);
	361	bt_value_put_ref(file_paths);
	362	return ret;
	363	}
	364
	365	static
	366	int populate_trace_info(const struct ctf_fs_trace trace, bt_value trace_info)
	367	{
	368	int ret = 0;
	369	size_t group_idx;
	370	bt_value_map_insert_entry_status insert_status;
	371	bt_value_array_append_element_status append_status;
	372	bt_value *file_groups = NULL;
	373	struct range trace_range = {
	374	.begin_ns = INT64_MAX,
	375	.end_ns = 0,
	376	.set = false,
	377	};
	378	struct range trace_intersection = {
	379	.begin_ns = 0,
	380	.end_ns = INT64_MAX,
	381	.set = false,
	382	};
	383
	384	BT_ASSERT(trace->ds_file_groups);
	385	/* Add trace range info only if it contains streams. */
	386	if (trace->ds_file_groups->len == 0) {
	387	ret = -1;
	388	goto end;
	389	}
	390
	391	file_groups = bt_value_array_create();
	392	if (!file_groups) {
	393	goto end;
	394	}
	395
	396	insert_status = bt_value_map_insert_string_entry(trace_info, "name",
	397	trace->name->str);
	398	if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	399	ret = -1;
	400	goto end;
	401	}
	402	insert_status = bt_value_map_insert_string_entry(trace_info, "path",
	403	trace->path->str);
	404	if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	405	ret = -1;
	406	goto end;
	407	}
	408
	409	/* Find range of all stream groups, and of the trace. */
	410	for (group_idx = 0; group_idx < trace->ds_file_groups->len;
	411	group_idx++) {
	412	bt_value *group_info;
	413	struct range group_range = { .set = false };
	414	struct ctf_fs_ds_file_group *group = g_ptr_array_index(
	415	trace->ds_file_groups, group_idx);
	416
	417	group_info = bt_value_map_create();
	418	if (!group_info) {
	419	ret = -1;
	420	goto end;
	421	}
	422
	423	ret = populate_stream_info(group, group_info, &group_range);
	424	if (ret) {
	425	bt_value_put_ref(group_info);
	426	goto end;
	427	}
	428
	429	append_status = bt_value_array_append_element(file_groups,
	430	group_info);
	431	bt_value_put_ref(group_info);
	432	if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
	433	goto end;
	434	}
	435
	436	if (group_range.set) {
	437	trace_range.begin_ns = MIN(trace_range.begin_ns,
	438	group_range.begin_ns);
	439	trace_range.end_ns = MAX(trace_range.end_ns,
	440	group_range.end_ns);
	441	trace_range.set = true;
	442
	443	trace_intersection.begin_ns = MAX(trace_intersection.begin_ns,
	444	group_range.begin_ns);
	445	trace_intersection.end_ns = MIN(trace_intersection.end_ns,
	446	group_range.end_ns);
	447	trace_intersection.set = true;
	448	}
	449	}
	450
	451	ret = add_range(trace_info, &trace_range, "range-ns");
	452	if (ret) {
	453	goto end;
	454	}
	455
	456	if (trace_intersection.begin_ns < trace_intersection.end_ns) {
	457	ret = add_range(trace_info, &trace_intersection,
	458	"intersection-range-ns");
	459	if (ret) {
	460	goto end;
	461	}
	462	}
	463
	464	insert_status = bt_value_map_insert_entry(trace_info, "streams",
	465	file_groups);
	466	BT_VALUE_PUT_REF_AND_RESET(file_groups);
	467	if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	468	ret = -1;
	469	goto end;
	470	}
	471
	472	end:
	473	bt_value_put_ref(file_groups);
	474	return ret;
	475	}
	476
	477	BT_HIDDEN
	478	bt_component_class_query_method_status trace_info_query(
	479	bt_self_component_class_source *comp_class,
	480	const bt_value *params, bt_logging_level log_level,
	481	const bt_value **user_result)
	482	{
	483	struct ctf_fs_component *ctf_fs = NULL;
	484	bt_component_class_query_method_status status =
	485	BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
	486	bt_value *result = NULL;
	487	const bt_value *inputs_value = NULL;
	488	int ret = 0;
	489	guint i;
	490
	491	BT_ASSERT(params);
	492
	493	if (!bt_value_is_map(params)) {
	494	BT_LOGE("Query parameters is not a map value object.");
	495	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	496	goto error;
	497	}
	498
	499	ctf_fs = ctf_fs_component_create(log_level, NULL);
	500	if (!ctf_fs) {
	501	goto error;
	502	}
	503
	504	if (!read_src_fs_parameters(params, &inputs_value, ctf_fs)) {
	505	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	506	goto error;
	507	}
	508
	509	if (ctf_fs_component_create_ctf_fs_traces(NULL, ctf_fs, inputs_value)) {
	510	goto error;
	511	}
	512
	513	result = bt_value_array_create();
	514	if (!result) {
	515	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
	516	goto error;
	517	}
	518
	519	for (i = 0; i < ctf_fs->traces->len; i++) {
	520	struct ctf_fs_trace *trace;
	521	bt_value *trace_info;
	522	bt_value_array_append_element_status append_status;
	523
	524	trace = g_ptr_array_index(ctf_fs->traces, i);
	525	BT_ASSERT(trace);
	526
	527	trace_info = bt_value_map_create();
	528	if (!trace_info) {
	529	BT_LOGE("Failed to create trace info map.");
	530	goto error;
	531	}
	532
	533	ret = populate_trace_info(trace, trace_info);
	534	if (ret) {
	535	bt_value_put_ref(trace_info);
	536	goto error;
	537	}
	538
	539	append_status = bt_value_array_append_element(result,
	540	trace_info);
	541	bt_value_put_ref(trace_info);
	542	if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
	543	goto error;
	544	}
	545	}
	546
	547	goto end;
	548
	549	error:
	550	BT_VALUE_PUT_REF_AND_RESET(result);
	551	result = NULL;
	552
	553	if (status >= 0) {
	554	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
	555	}
	556
	557	end:
	558	if (ctf_fs) {
	559	ctf_fs_destroy(ctf_fs);
	560	ctf_fs = NULL;
	561	}
	562
	563	*user_result = result;
	564	return status;
	565	}
	566
	567	BT_HIDDEN
	568	bt_component_class_query_method_status support_info_query(
	569	bt_self_component_class_source *comp_class,
	570	const bt_value *params, bt_logging_level log_level,
	571	const bt_value **user_result)
	572	{
	573	const bt_value *input_type_value;
	574	const char *input_type;
	575	bt_component_class_query_method_status status;
	576	double weight = 0;
	577	gchar *metadata_path = NULL;
	578	bt_value *result = NULL;
	579
	580	input_type_value = bt_value_map_borrow_entry_value_const(params, "type");
	581	BT_ASSERT(input_type_value);
	582	BT_ASSERT(bt_value_get_type(input_type_value) == BT_VALUE_TYPE_STRING);
	583	input_type = bt_value_string_get(input_type_value);
	584
	585	result = bt_value_map_create();
	586	if (!result) {
	587	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
	588	goto end;
	589	}
	590
	591	if (strcmp(input_type, "directory") == 0) {
	592	const bt_value *input_value;
	593	const char *path;
	594
	595	input_value = bt_value_map_borrow_entry_value_const(params, "input");
	596	BT_ASSERT(input_value);
	597	BT_ASSERT(bt_value_get_type(input_value) == BT_VALUE_TYPE_STRING);
	598	path = bt_value_string_get(input_value);
	599
	600	metadata_path = g_build_filename(path, CTF_FS_METADATA_FILENAME, NULL);
	601	if (!metadata_path) {
	602	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
	603	goto end;
	604	}
	605
	606	/*
	607	* If the metadata file exists in this directory, consider it to
	608	* be a CTF trace.
	609	*/
	610	if (g_file_test(metadata_path, G_FILE_TEST_EXISTS)) {
	611	weight = 0.5;
	612	}
	613	}
	614
	615	if (bt_value_map_insert_real_entry(result, "weight", weight) != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	616	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
	617	goto end;
	618	}
	619
	620	/*
	621	* Use the arbitrary constant string "ctf" as the group, such that all
	622	* found ctf traces are passed to the same instance of src.ctf.fs.
	623	*/
	624	if (bt_value_map_insert_string_entry(result, "group", "ctf") != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
	625	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
	626	goto end;
	627	}
	628
	629	*user_result = result;
	630	result = NULL;
	631	status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
	632
	633	end:
	634	g_free(metadata_path);
	635	bt_value_put_ref(result);
	636
	637	return status;
	638	}