[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"
#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;
	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_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;
	}

	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_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
				"Cannot decode packetized metadata file: path=\"%s\"",
				path);
			goto error;
		}
	} else {
		long filesize;

		ret = fseek(metadata_fp, 0, SEEK_END);
		if (ret) {
			BT_COMP_CLASS_LOGE_APPEND_CAUSE_ERRNO(self_comp_class,
				"Failed to seek to the end of the metadata file",
				": path=\"%s\"", path);
			goto error;
		}
		filesize = ftell(metadata_fp);
		if (filesize < 0) {
			BT_COMP_CLASS_LOGE_APPEND_CAUSE_ERRNO(self_comp_class,
				"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_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
				"Cannot allocate buffer for metadata text.");
			goto error;
		}

		if (fread(metadata_text, filesize, 1, metadata_fp) != 1) {
			BT_COMP_CLASS_LOGE_APPEND_CAUSE_ERRNO(self_comp_class,
				"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_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:
	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 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;
	}

	file_groups = bt_value_array_create();
	if (!file_groups) {
		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_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;
		}
	}

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

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