[babeltrace.git] / src / plugins / ctf / common / metadata / decoder.c

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright 2016-2017 Philippe Proulx <pproulx@efficios.com>
 */

#define BT_COMP_LOG_SELF_COMP (mdec->config.self_comp)
#define BT_COMP_LOG_SELF_COMP_CLASS (mdec->config.self_comp_class)
#define BT_LOG_OUTPUT_LEVEL (mdec->config.log_level)
#define BT_LOG_TAG "PLUGIN/CTF/META/DECODER"
#include "logging/comp-logging.h"

#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <inttypes.h>
#include "common/assert.h"
#include "common/uuid.h"
#include "compat/memstream.h"
#include <babeltrace2/babeltrace.h>
#include <glib.h>
#include <string.h>

#include "ast.h"
#include "decoder.h"
#include "scanner.h"
#include "logging.h"
#include "parser-wrap.h"
#include "decoder-packetized-file-stream-to-buf.h"

#define TSDL_MAGIC	0x75d11d57

struct ctf_metadata_decoder {
	struct ctf_scanner *scanner;
	GString *text;
	struct ctf_visitor_generate_ir *visitor;
	bt_uuid_t uuid;
	bool is_uuid_set;
	int bo;
	struct ctf_metadata_decoder_config config;
	struct meta_log_config log_cfg;
};

struct packet_header {
	uint32_t magic;
	bt_uuid_t  uuid;
	uint32_t checksum;
	uint32_t content_size;
	uint32_t packet_size;
	uint8_t  compression_scheme;
	uint8_t  encryption_scheme;
	uint8_t  checksum_scheme;
	uint8_t  major;
	uint8_t  minor;
} __attribute__((__packed__));

BT_HIDDEN
int ctf_metadata_decoder_is_packetized(FILE *fp, bool *is_packetized,
		int *byte_order, bt_logging_level log_level,
		bt_self_component *self_comp)
{
	uint32_t magic;
	size_t len;
	int ret = 0;

	*is_packetized = false;
	len = fread(&magic, sizeof(magic), 1, fp);
	if (len != 1) {
		BT_COMP_LOG_CUR_LVL(BT_LOG_INFO, log_level, self_comp,
			"Cannot read first metadata packet header: assuming the stream is not packetized.");
		ret = -1;
		goto end;
	}

	if (byte_order) {
		if (magic == TSDL_MAGIC) {
			*is_packetized = true;
			*byte_order = BYTE_ORDER;
		} else if (magic == GUINT32_SWAP_LE_BE(TSDL_MAGIC)) {
			*is_packetized = true;
			*byte_order = BYTE_ORDER == BIG_ENDIAN ?
				LITTLE_ENDIAN : BIG_ENDIAN;
		}
	}

end:
	rewind(fp);

	return ret;
}

BT_HIDDEN
struct ctf_metadata_decoder *ctf_metadata_decoder_create(
		const struct ctf_metadata_decoder_config *config)
{
	struct ctf_metadata_decoder *mdec =
		g_new0(struct ctf_metadata_decoder, 1);

	BT_ASSERT(config);
	BT_COMP_LOG_CUR_LVL(BT_LOG_DEBUG, config->log_level, config->self_comp,
		"Creating CTF metadata decoder: "
		"clock-class-offset-s=%" PRId64 ", "
		"clock-class-offset-ns=%" PRId64,
		config->clock_class_offset_s, config->clock_class_offset_ns);

	if (!mdec) {
		BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, config->log_level,
			config->self_comp,
			"Failed to allocate one CTF metadata decoder.");
		goto end;
	}

	mdec->log_cfg.log_level = config->log_level;
	mdec->log_cfg.self_comp = config->self_comp;
	mdec->log_cfg.self_comp_class = config->self_comp_class;
	mdec->scanner = ctf_scanner_alloc();
	if (!mdec->scanner) {
		_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot allocate a metadata lexical scanner: "
			"mdec-addr=%p", mdec);
		goto error;
	}

	mdec->text = g_string_new(NULL);
	if (!mdec->text) {
		_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to allocate one GString: "
			"mdec-addr=%p", mdec);
		goto error;
	}

	mdec->bo = -1;
	mdec->config = *config;
	mdec->visitor = ctf_visitor_generate_ir_create(config);
	if (!mdec->visitor) {
		_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to create a CTF IR metadata AST visitor: "
			"mdec-addr=%p", mdec);
		goto error;
	}

	BT_COMP_LOGD("Creating CTF metadata decoder: "
		"clock-class-offset-s=%" PRId64 ", "
		"clock-class-offset-ns=%" PRId64 ", addr=%p",
		config->clock_class_offset_s, config->clock_class_offset_ns,
		mdec);
	goto end;

error:
	ctf_metadata_decoder_destroy(mdec);
	mdec = NULL;

end:
	return mdec;
}

BT_HIDDEN
void ctf_metadata_decoder_destroy(struct ctf_metadata_decoder *mdec)
{
	if (!mdec) {
		return;
	}

	if (mdec->scanner) {
		ctf_scanner_free(mdec->scanner);
	}

	if (mdec->text) {
		g_string_free(mdec->text, TRUE);
	}

	BT_COMP_LOGD("Destroying CTF metadata decoder: addr=%p", mdec);
	ctf_visitor_generate_ir_destroy(mdec->visitor);
	g_free(mdec);
}

BT_HIDDEN
enum ctf_metadata_decoder_status ctf_metadata_decoder_append_content(
		struct ctf_metadata_decoder *mdec, FILE *fp)
{
	enum ctf_metadata_decoder_status status =
		CTF_METADATA_DECODER_STATUS_OK;
	int ret;
	char *buf = NULL;
	bool close_fp = false;
	long start_pos = -1;
	bool is_packetized;

	BT_ASSERT(mdec);
	ret = ctf_metadata_decoder_is_packetized(fp, &is_packetized, &mdec->bo,
			mdec->config.log_level, mdec->config.self_comp);
	if (ret) {
		status = CTF_METADATA_DECODER_STATUS_ERROR;
		goto end;
	}

	if (is_packetized) {
		BT_COMP_LOGI("Metadata stream is packetized: mdec-addr=%p", mdec);
		ret = ctf_metadata_decoder_packetized_file_stream_to_buf(fp,
			&buf, mdec->bo, &mdec->is_uuid_set,
			mdec->uuid, mdec->config.log_level,
			mdec->config.self_comp,
			mdec->config.self_comp_class);
		if (ret) {
			_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot decode packetized metadata packets to metadata text: "
				"mdec-addr=%p, ret=%d", mdec, ret);
			status = CTF_METADATA_DECODER_STATUS_ERROR;
			goto end;
		}

		if (strlen(buf) == 0) {
			/* An empty metadata packet is OK. */
			goto end;
		}

		/* Convert the real file pointer to a memory file pointer */
		fp = bt_fmemopen(buf, strlen(buf), "rb");
		close_fp = true;
		if (!fp) {
			_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot memory-open metadata buffer: %s: "
				"mdec-addr=%p", strerror(errno), mdec);
			status = CTF_METADATA_DECODER_STATUS_ERROR;
			goto end;
		}
	} else {
		unsigned int major, minor;
		ssize_t nr_items;
		const long init_pos = ftell(fp);

		BT_COMP_LOGI("Metadata stream is plain text: mdec-addr=%p", mdec);

		if (init_pos < 0) {
			BT_COMP_LOGE_APPEND_CAUSE_ERRNO(BT_COMP_LOG_SELF_COMP,
				"Failed to get current file position", ".");
			status = CTF_METADATA_DECODER_STATUS_ERROR;
			goto end;
		}

		/* Check text-only metadata header and version */
		nr_items = fscanf(fp, "/* CTF %10u.%10u", &major, &minor);
		if (nr_items < 2) {
			BT_COMP_LOGW("Missing \"/* CTF major.minor\" signature in plain text metadata file stream: "
				"mdec-addr=%p", mdec);
		}

		BT_COMP_LOGI("Found metadata stream version in signature: version=%u.%u", major, minor);

		if (!ctf_metadata_decoder_is_packet_version_valid(major,
				minor)) {
			_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Invalid metadata version found in plain text signature: "
				"version=%u.%u, mdec-addr=%p", major, minor,
				mdec);
			status = CTF_METADATA_DECODER_STATUS_INVAL_VERSION;
			goto end;
		}

		if (fseek(fp, init_pos, SEEK_SET)) {
			_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot seek metadata file stream to initial position: %s: "
				"mdec-addr=%p", strerror(errno), mdec);
			status = CTF_METADATA_DECODER_STATUS_ERROR;
			goto end;
		}
	}

#if YYDEBUG
	if (BT_LOG_ON_TRACE) {
		yydebug = 1;
	}
#endif

	/* Save the file's position: we'll seek back to append the plain text */
	BT_ASSERT(fp);

	if (mdec->config.keep_plain_text) {
		start_pos = ftell(fp);
	}

	/* Append the metadata text content */
	ret = ctf_scanner_append_ast(mdec->scanner, fp);
	if (ret) {
		_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot create the metadata AST out of the metadata text: "
			"mdec-addr=%p", mdec);
		status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
		goto end;
	}

	/* We know it's complete: append plain text */
	if (mdec->config.keep_plain_text) {
		BT_ASSERT(start_pos != -1);
		ret = fseek(fp, start_pos, SEEK_SET);
		if (ret) {
			_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to seek file: ret=%d, mdec-addr=%p",
				ret, mdec);
			status = CTF_METADATA_DECODER_STATUS_ERROR;
			goto end;
		}

		ret = bt_common_append_file_content_to_g_string(mdec->text, fp);
		if (ret) {
			_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to append to current plain text: "
				"ret=%d, mdec-addr=%p", ret, mdec);
			status = CTF_METADATA_DECODER_STATUS_ERROR;
			goto end;
		}
	}

	ret = ctf_visitor_semantic_check(0, &mdec->scanner->ast->root,
		&mdec->log_cfg);
	if (ret) {
		_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Validation of the metadata semantics failed: "
			"mdec-addr=%p", mdec);
		status = CTF_METADATA_DECODER_STATUS_ERROR;
		goto end;
	}

	if (mdec->config.create_trace_class) {
		ret = ctf_visitor_generate_ir_visit_node(mdec->visitor,
			&mdec->scanner->ast->root);
		switch (ret) {
		case 0:
			/* Success */
			break;
		case -EINCOMPLETE:
			BT_COMP_LOGD("While visiting metadata AST: incomplete data: "
				"mdec-addr=%p", mdec);
			status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
			goto end;
		default:
			_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to visit AST node to create CTF IR objects: "
				"mdec-addr=%p, ret=%d", mdec, ret);
			status = CTF_METADATA_DECODER_STATUS_IR_VISITOR_ERROR;
			goto end;
		}
	}

end:
#if YYDEBUG
	yydebug = 0;
#endif

	if (fp && close_fp) {
		if (fclose(fp)) {
			BT_COMP_LOGE("Cannot close metadata file stream: "
				"mdec-addr=%p", mdec);
		}
	}

	free(buf);

	return status;
}

BT_HIDDEN
bt_trace_class *ctf_metadata_decoder_get_ir_trace_class(
		struct ctf_metadata_decoder *mdec)
{
	BT_ASSERT_DBG(mdec);
	BT_ASSERT_DBG(mdec->config.create_trace_class);
	return ctf_visitor_generate_ir_get_ir_trace_class(mdec->visitor);
}

BT_HIDDEN
struct ctf_trace_class *ctf_metadata_decoder_borrow_ctf_trace_class(
		struct ctf_metadata_decoder *mdec)
{
	BT_ASSERT_DBG(mdec);
	BT_ASSERT_DBG(mdec->config.create_trace_class);
	return ctf_visitor_generate_ir_borrow_ctf_trace_class(mdec->visitor);
}

BT_HIDDEN
const char *ctf_metadata_decoder_get_text(struct ctf_metadata_decoder *mdec)
{
	BT_ASSERT_DBG(mdec);
	BT_ASSERT_DBG(mdec->config.keep_plain_text);
	return mdec->text->str;
}

BT_HIDDEN
int ctf_metadata_decoder_get_byte_order(struct ctf_metadata_decoder *mdec)
{
	BT_ASSERT_DBG(mdec);
	return mdec->bo;
}

BT_HIDDEN
int ctf_metadata_decoder_get_uuid(struct ctf_metadata_decoder *mdec,
		bt_uuid_t uuid)
{
	int ret = 0;

	BT_ASSERT_DBG(mdec);

	if (!mdec->is_uuid_set) {
		ret = -1;
		goto end;
	}

	bt_uuid_copy(uuid, mdec->uuid);

end:
	return ret;
}

static
enum ctf_metadata_decoder_status find_uuid_in_trace_decl(
		struct ctf_metadata_decoder *mdec, struct ctf_node *trace_node,
		bt_uuid_t uuid)
{
	enum ctf_metadata_decoder_status status =
		CTF_METADATA_DECODER_STATUS_OK;
	struct ctf_node *entry_node;
	struct bt_list_head *decl_list = &trace_node->u.trace.declaration_list;
	char *left = NULL;

	bt_list_for_each_entry(entry_node, decl_list, siblings) {
		if (entry_node->type == NODE_CTF_EXPRESSION) {
			int ret;

			left = ctf_ast_concatenate_unary_strings(
				&entry_node->u.ctf_expression.left);
			if (!left) {
				_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot concatenate unary strings.");
				status = CTF_METADATA_DECODER_STATUS_ERROR;
				goto end;
			}

			if (strcmp(left, "uuid") == 0) {
				ret = ctf_ast_get_unary_uuid(
					&entry_node->u.ctf_expression.right,
					uuid, mdec->config.log_level,
					mdec->config.self_comp);
				if (ret) {
					_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Invalid trace's `uuid` attribute.");
					status = CTF_METADATA_DECODER_STATUS_ERROR;
					goto end;
				}

				goto end;
			}

			g_free(left);
			left = NULL;
		}
	}

	status = CTF_METADATA_DECODER_STATUS_NONE;

end:
	g_free(left);
	return status;
}

BT_HIDDEN
enum ctf_metadata_decoder_status ctf_metadata_decoder_get_trace_class_uuid(
		struct ctf_metadata_decoder *mdec, bt_uuid_t uuid)
{
	enum ctf_metadata_decoder_status status =
		CTF_METADATA_DECODER_STATUS_INCOMPLETE;
	struct ctf_node *root_node = &mdec->scanner->ast->root;
	struct ctf_node *trace_node;

	if (!root_node) {
		status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
		goto end;
	}

	trace_node =
		bt_list_entry(root_node->u.root.trace.next,
			struct ctf_node, siblings);
	if (!trace_node) {
		status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
		goto end;
	}

	status = find_uuid_in_trace_decl(mdec, trace_node, uuid);

end:
	return status;
}
Commit	Line	Data
1e649dff	1	/*
0235b0db	2	* SPDX-License-Identifier: MIT
1e649dff	3	*
0235b0db	4	* Copyright 2016-2017 Philippe Proulx <pproulx@efficios.com>
1e649dff PP	5	*/
1e649dff PP	6
f7b785ac	7	#define BT_COMP_LOG_SELF_COMP (mdec->config.self_comp)
50f6fce8	8	#define BT_COMP_LOG_SELF_COMP_CLASS (mdec->config.self_comp_class)
0746848c	9	#define BT_LOG_OUTPUT_LEVEL (mdec->config.log_level)
350ad6c1	10	#define BT_LOG_TAG "PLUGIN/CTF/META/DECODER"
d9c39b0a	11	#include "logging/comp-logging.h"
d6e20753	12
1e649dff PP	13	#include <stdio.h>
	14	#include <stdbool.h>
	15	#include <stdint.h>
	16	#include <stdlib.h>
d6e20753	17	#include <inttypes.h>
578e048b	18	#include "common/assert.h"
6162e6b7	19	#include "common/uuid.h"
578e048b	20	#include "compat/memstream.h"
3fadfbc0	21	#include <babeltrace2/babeltrace.h>
1e649dff	22	#include <glib.h>
e9383dfd	23	#include <string.h>
1e649dff PP	24
	25	#include "ast.h"
	26	#include "decoder.h"
	27	#include "scanner.h"
f7b785ac	28	#include "logging.h"
9103e903	29	#include "parser-wrap.h"
50f6fce8	30	#include "decoder-packetized-file-stream-to-buf.h"
1e649dff	31
1e649dff PP	32	#define TSDL_MAGIC 0x75d11d57
	33
	34	struct ctf_metadata_decoder {
06be9946 PP	35	struct ctf_scanner *scanner;
06be9946 PP	36	GString *text;
1e649dff	37	struct ctf_visitor_generate_ir *visitor;
6162e6b7	38	bt_uuid_t uuid;
1e649dff PP	39	bool is_uuid_set;
1e649dff PP	40	int bo;
a2a54545	41	struct ctf_metadata_decoder_config config;
06be9946	42	struct meta_log_config log_cfg;
1e649dff PP	43	};
	44
	45	struct packet_header {
	46	uint32_t magic;
6162e6b7	47	bt_uuid_t uuid;
1e649dff PP	48	uint32_t checksum;
	49	uint32_t content_size;
	50	uint32_t packet_size;
	51	uint8_t compression_scheme;
	52	uint8_t encryption_scheme;
	53	uint8_t checksum_scheme;
	54	uint8_t major;
	55	uint8_t minor;
	56	} __attribute__((__packed__));
	57
06be9946 PP	58	BT_HIDDEN
	59	int ctf_metadata_decoder_is_packetized(FILE fp, bool is_packetized,
	60	int *byte_order, bt_logging_level log_level,
	61	bt_self_component *self_comp)
1e649dff PP	62	{
	63	uint32_t magic;
	64	size_t len;
	65	int ret = 0;
	66
06be9946	67	*is_packetized = false;
1e649dff PP	68	len = fread(&magic, sizeof(magic), 1, fp);
1e649dff PP	69	if (len != 1) {
f7b785ac	70	BT_COMP_LOG_CUR_LVL(BT_LOG_INFO, log_level, self_comp,
0746848c	71	"Cannot read first metadata packet header: assuming the stream is not packetized.");
06be9946	72	ret = -1;
1e649dff PP	73	goto end;
	74	}
	75
	76	if (byte_order) {
	77	if (magic == TSDL_MAGIC) {
06be9946	78	*is_packetized = true;
1e649dff PP	79	*byte_order = BYTE_ORDER;
1e649dff PP	80	} else if (magic == GUINT32_SWAP_LE_BE(TSDL_MAGIC)) {
06be9946	81	*is_packetized = true;
1e649dff PP	82	*byte_order = BYTE_ORDER == BIG_ENDIAN ?
	83	LITTLE_ENDIAN : BIG_ENDIAN;
	84	}
	85	}
	86
	87	end:
	88	rewind(fp);
	89
	90	return ret;
	91	}
	92
1e649dff	93	BT_HIDDEN
55314f2a	94	struct ctf_metadata_decoder *ctf_metadata_decoder_create(
862ca4ed	95	const struct ctf_metadata_decoder_config *config)
1e649dff PP	96	{
	97	struct ctf_metadata_decoder *mdec =
	98	g_new0(struct ctf_metadata_decoder, 1);
a2a54545	99
f7b785ac PP	100	BT_ASSERT(config);
	101	BT_COMP_LOG_CUR_LVL(BT_LOG_DEBUG, config->log_level, config->self_comp,
	102	"Creating CTF metadata decoder: "
a2a54545	103	"clock-class-offset-s=%" PRId64 ", "
862ca4ed PP	104	"clock-class-offset-ns=%" PRId64,
862ca4ed PP	105	config->clock_class_offset_s, config->clock_class_offset_ns);
d6e20753	106
1e649dff	107	if (!mdec) {
f7b785ac PP	108	BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, config->log_level,
	109	config->self_comp,
	110	"Failed to allocate one CTF metadata decoder.");
1e649dff PP	111	goto end;
	112	}
	113
06be9946 PP	114	mdec->log_cfg.log_level = config->log_level;
06be9946 PP	115	mdec->log_cfg.self_comp = config->self_comp;
50f6fce8	116	mdec->log_cfg.self_comp_class = config->self_comp_class;
06be9946 PP	117	mdec->scanner = ctf_scanner_alloc();
06be9946 PP	118	if (!mdec->scanner) {
50f6fce8	119	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot allocate a metadata lexical scanner: "
06be9946 PP	120	"mdec-addr=%p", mdec);
	121	goto error;
	122	}
	123
	124	mdec->text = g_string_new(NULL);
	125	if (!mdec->text) {
50f6fce8	126	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to allocate one GString: "
06be9946 PP	127	"mdec-addr=%p", mdec);
	128	goto error;
	129	}
	130
	131	mdec->bo = -1;
a2a54545	132	mdec->config = *config;
f7b785ac	133	mdec->visitor = ctf_visitor_generate_ir_create(config);
1e649dff	134	if (!mdec->visitor) {
50f6fce8	135	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to create a CTF IR metadata AST visitor: "
d6e20753	136	"mdec-addr=%p", mdec);
06be9946	137	goto error;
1e649dff PP	138	}
1e649dff PP	139
f7b785ac	140	BT_COMP_LOGD("Creating CTF metadata decoder: "
a2a54545	141	"clock-class-offset-s=%" PRId64 ", "
862ca4ed	142	"clock-class-offset-ns=%" PRId64 ", addr=%p",
a2a54545	143	config->clock_class_offset_s, config->clock_class_offset_ns,
862ca4ed	144	mdec);
06be9946 PP	145	goto end;
	146
	147	error:
	148	ctf_metadata_decoder_destroy(mdec);
	149	mdec = NULL;
d6e20753	150
1e649dff PP	151	end:
	152	return mdec;
	153	}
	154
	155	BT_HIDDEN
	156	void ctf_metadata_decoder_destroy(struct ctf_metadata_decoder *mdec)
	157	{
	158	if (!mdec) {
	159	return;
	160	}
	161
06be9946 PP	162	if (mdec->scanner) {
	163	ctf_scanner_free(mdec->scanner);
	164	}
	165
	166	if (mdec->text) {
	167	g_string_free(mdec->text, TRUE);
	168	}
	169
f7b785ac	170	BT_COMP_LOGD("Destroying CTF metadata decoder: addr=%p", mdec);
1e649dff PP	171	ctf_visitor_generate_ir_destroy(mdec->visitor);
	172	g_free(mdec);
	173	}
	174
	175	BT_HIDDEN
06be9946	176	enum ctf_metadata_decoder_status ctf_metadata_decoder_append_content(
1e649dff PP	177	struct ctf_metadata_decoder mdec, FILE fp)
	178	{
	179	enum ctf_metadata_decoder_status status =
	180	CTF_METADATA_DECODER_STATUS_OK;
	181	int ret;
1e649dff PP	182	char *buf = NULL;
1e649dff PP	183	bool close_fp = false;
06be9946 PP	184	long start_pos = -1;
06be9946 PP	185	bool is_packetized;
1e649dff	186
f6ccaed9	187	BT_ASSERT(mdec);
06be9946 PP	188	ret = ctf_metadata_decoder_is_packetized(fp, &is_packetized, &mdec->bo,
	189	mdec->config.log_level, mdec->config.self_comp);
	190	if (ret) {
	191	status = CTF_METADATA_DECODER_STATUS_ERROR;
	192	goto end;
	193	}
1e649dff	194
06be9946	195	if (is_packetized) {
f7b785ac	196	BT_COMP_LOGI("Metadata stream is packetized: mdec-addr=%p", mdec);
3c8252a5 PP	197	ret = ctf_metadata_decoder_packetized_file_stream_to_buf(fp,
	198	&buf, mdec->bo, &mdec->is_uuid_set,
	199	mdec->uuid, mdec->config.log_level,
50f6fce8 SM	200	mdec->config.self_comp,
50f6fce8 SM	201	mdec->config.self_comp_class);
1e649dff	202	if (ret) {
50f6fce8	203	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot decode packetized metadata packets to metadata text: "
d6e20753	204	"mdec-addr=%p, ret=%d", mdec, ret);
1e649dff PP	205	status = CTF_METADATA_DECODER_STATUS_ERROR;
	206	goto end;
	207	}
	208
7cdc2bab MD	209	if (strlen(buf) == 0) {
	210	/* An empty metadata packet is OK. */
	211	goto end;
	212	}
	213
1e649dff PP	214	/* Convert the real file pointer to a memory file pointer */
	215	fp = bt_fmemopen(buf, strlen(buf), "rb");
	216	close_fp = true;
	217	if (!fp) {
50f6fce8	218	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot memory-open metadata buffer: %s: "
d6e20753	219	"mdec-addr=%p", strerror(errno), mdec);
1e649dff PP	220	status = CTF_METADATA_DECODER_STATUS_ERROR;
	221	goto end;
	222	}
	223	} else {
	224	unsigned int major, minor;
	225	ssize_t nr_items;
	226	const long init_pos = ftell(fp);
	227
f7b785ac	228	BT_COMP_LOGI("Metadata stream is plain text: mdec-addr=%p", mdec);
1e649dff	229
1e95e5e8	230	if (init_pos < 0) {
50f6fce8 SM	231	BT_COMP_LOGE_APPEND_CAUSE_ERRNO(BT_COMP_LOG_SELF_COMP,
50f6fce8 SM	232	"Failed to get current file position", ".");
1e95e5e8 MD	233	status = CTF_METADATA_DECODER_STATUS_ERROR;
	234	goto end;
	235	}
	236
1e649dff PP	237	/* Check text-only metadata header and version */
	238	nr_items = fscanf(fp, "/* CTF %10u.%10u", &major, &minor);
	239	if (nr_items < 2) {
f7b785ac	240	BT_COMP_LOGW("Missing \"/* CTF major.minor\" signature in plain text metadata file stream: "
d6e20753	241	"mdec-addr=%p", mdec);
1e649dff PP	242	}
1e649dff PP	243
f7b785ac	244	BT_COMP_LOGI("Found metadata stream version in signature: version=%u.%u", major, minor);
1e649dff	245
3c8252a5 PP	246	if (!ctf_metadata_decoder_is_packet_version_valid(major,
3c8252a5 PP	247	minor)) {
50f6fce8	248	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Invalid metadata version found in plain text signature: "
d6e20753 PP	249	"version=%u.%u, mdec-addr=%p", major, minor,
d6e20753 PP	250	mdec);
1e649dff PP	251	status = CTF_METADATA_DECODER_STATUS_INVAL_VERSION;
	252	goto end;
	253	}
	254
	255	if (fseek(fp, init_pos, SEEK_SET)) {
50f6fce8	256	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot seek metadata file stream to initial position: %s: "
d6e20753	257	"mdec-addr=%p", strerror(errno), mdec);
1e649dff PP	258	status = CTF_METADATA_DECODER_STATUS_ERROR;
	259	goto end;
	260	}
	261	}
	262
9103e903	263	#if YYDEBUG
ef267d12	264	if (BT_LOG_ON_TRACE) {
f73367f8 PP	265	yydebug = 1;
f73367f8 PP	266	}
9103e903	267	#endif
f73367f8	268
06be9946 PP	269	/* Save the file's position: we'll seek back to append the plain text */
	270	BT_ASSERT(fp);
	271
	272	if (mdec->config.keep_plain_text) {
	273	start_pos = ftell(fp);
1e649dff PP	274	}
1e649dff PP	275
06be9946 PP	276	/* Append the metadata text content */
06be9946 PP	277	ret = ctf_scanner_append_ast(mdec->scanner, fp);
1e649dff	278	if (ret) {
50f6fce8	279	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot create the metadata AST out of the metadata text: "
d6e20753	280	"mdec-addr=%p", mdec);
1e649dff PP	281	status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
	282	goto end;
	283	}
	284
06be9946 PP	285	/* We know it's complete: append plain text */
	286	if (mdec->config.keep_plain_text) {
	287	BT_ASSERT(start_pos != -1);
	288	ret = fseek(fp, start_pos, SEEK_SET);
	289	if (ret) {
50f6fce8	290	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to seek file: ret=%d, mdec-addr=%p",
06be9946 PP	291	ret, mdec);
	292	status = CTF_METADATA_DECODER_STATUS_ERROR;
	293	goto end;
	294	}
	295
	296	ret = bt_common_append_file_content_to_g_string(mdec->text, fp);
	297	if (ret) {
50f6fce8	298	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to append to current plain text: "
06be9946 PP	299	"ret=%d, mdec-addr=%p", ret, mdec);
	300	status = CTF_METADATA_DECODER_STATUS_ERROR;
	301	goto end;
	302	}
	303	}
	304
	305	ret = ctf_visitor_semantic_check(0, &mdec->scanner->ast->root,
	306	&mdec->log_cfg);
1e649dff	307	if (ret) {
50f6fce8	308	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Validation of the metadata semantics failed: "
d6e20753	309	"mdec-addr=%p", mdec);
1e649dff PP	310	status = CTF_METADATA_DECODER_STATUS_ERROR;
	311	goto end;
	312	}
	313
06be9946 PP	314	if (mdec->config.create_trace_class) {
	315	ret = ctf_visitor_generate_ir_visit_node(mdec->visitor,
	316	&mdec->scanner->ast->root);
	317	switch (ret) {
	318	case 0:
	319	/* Success */
	320	break;
	321	case -EINCOMPLETE:
	322	BT_COMP_LOGD("While visiting metadata AST: incomplete data: "
	323	"mdec-addr=%p", mdec);
	324	status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
	325	goto end;
	326	default:
50f6fce8	327	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to visit AST node to create CTF IR objects: "
06be9946 PP	328	"mdec-addr=%p, ret=%d", mdec, ret);
	329	status = CTF_METADATA_DECODER_STATUS_IR_VISITOR_ERROR;
	330	goto end;
	331	}
1e649dff PP	332	}
	333
	334	end:
9103e903	335	#if YYDEBUG
f73367f8	336	yydebug = 0;
9103e903	337	#endif
f73367f8	338
1e649dff PP	339	if (fp && close_fp) {
1e649dff PP	340	if (fclose(fp)) {
f7b785ac	341	BT_COMP_LOGE("Cannot close metadata file stream: "
d6e20753	342	"mdec-addr=%p", mdec);
1e649dff PP	343	}
	344	}
	345
6b934a94	346	free(buf);
1e649dff PP	347
	348	return status;
	349	}
	350
	351	BT_HIDDEN
b19ff26f	352	bt_trace_class *ctf_metadata_decoder_get_ir_trace_class(
44c440bc PP	353	struct ctf_metadata_decoder *mdec)
44c440bc PP	354	{
98b15851 PP	355	BT_ASSERT_DBG(mdec);
98b15851 PP	356	BT_ASSERT_DBG(mdec->config.create_trace_class);
862ca4ed	357	return ctf_visitor_generate_ir_get_ir_trace_class(mdec->visitor);
44c440bc PP	358	}
	359
	360	BT_HIDDEN
	361	struct ctf_trace_class *ctf_metadata_decoder_borrow_ctf_trace_class(
1e649dff PP	362	struct ctf_metadata_decoder *mdec)
1e649dff PP	363	{
98b15851 PP	364	BT_ASSERT_DBG(mdec);
98b15851 PP	365	BT_ASSERT_DBG(mdec->config.create_trace_class);
44c440bc	366	return ctf_visitor_generate_ir_borrow_ctf_trace_class(mdec->visitor);
1e649dff	367	}
06be9946 PP	368
	369	BT_HIDDEN
	370	const char ctf_metadata_decoder_get_text(struct ctf_metadata_decoder mdec)
	371	{
98b15851 PP	372	BT_ASSERT_DBG(mdec);
98b15851 PP	373	BT_ASSERT_DBG(mdec->config.keep_plain_text);
06be9946 PP	374	return mdec->text->str;
	375	}
	376
	377	BT_HIDDEN
	378	int ctf_metadata_decoder_get_byte_order(struct ctf_metadata_decoder *mdec)
	379	{
98b15851	380	BT_ASSERT_DBG(mdec);
06be9946 PP	381	return mdec->bo;
	382	}
	383
	384	BT_HIDDEN
	385	int ctf_metadata_decoder_get_uuid(struct ctf_metadata_decoder *mdec,
	386	bt_uuid_t uuid)
	387	{
	388	int ret = 0;
	389
98b15851	390	BT_ASSERT_DBG(mdec);
06be9946 PP	391
	392	if (!mdec->is_uuid_set) {
	393	ret = -1;
	394	goto end;
	395	}
	396
	397	bt_uuid_copy(uuid, mdec->uuid);
	398
	399	end:
	400	return ret;
	401	}
1a6da3f9 PP	402
	403	static
	404	enum ctf_metadata_decoder_status find_uuid_in_trace_decl(
	405	struct ctf_metadata_decoder mdec, struct ctf_node trace_node,
	406	bt_uuid_t uuid)
	407	{
	408	enum ctf_metadata_decoder_status status =
	409	CTF_METADATA_DECODER_STATUS_OK;
	410	struct ctf_node *entry_node;
	411	struct bt_list_head *decl_list = &trace_node->u.trace.declaration_list;
	412	char *left = NULL;
	413
	414	bt_list_for_each_entry(entry_node, decl_list, siblings) {
	415	if (entry_node->type == NODE_CTF_EXPRESSION) {
	416	int ret;
	417
	418	left = ctf_ast_concatenate_unary_strings(
	419	&entry_node->u.ctf_expression.left);
	420	if (!left) {
50f6fce8	421	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot concatenate unary strings.");
1a6da3f9 PP	422	status = CTF_METADATA_DECODER_STATUS_ERROR;
	423	goto end;
	424	}
	425
	426	if (strcmp(left, "uuid") == 0) {
	427	ret = ctf_ast_get_unary_uuid(
	428	&entry_node->u.ctf_expression.right,
	429	uuid, mdec->config.log_level,
	430	mdec->config.self_comp);
	431	if (ret) {
50f6fce8	432	_BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Invalid trace's `uuid` attribute.");
1a6da3f9 PP	433	status = CTF_METADATA_DECODER_STATUS_ERROR;
	434	goto end;
	435	}
	436
	437	goto end;
	438	}
	439
	440	g_free(left);
	441	left = NULL;
	442	}
	443	}
	444
	445	status = CTF_METADATA_DECODER_STATUS_NONE;
	446
	447	end:
	448	g_free(left);
	449	return status;
	450	}
	451
	452	BT_HIDDEN
	453	enum ctf_metadata_decoder_status ctf_metadata_decoder_get_trace_class_uuid(
	454	struct ctf_metadata_decoder *mdec, bt_uuid_t uuid)
	455	{
	456	enum ctf_metadata_decoder_status status =
	457	CTF_METADATA_DECODER_STATUS_INCOMPLETE;
	458	struct ctf_node *root_node = &mdec->scanner->ast->root;
	459	struct ctf_node *trace_node;
	460
	461	if (!root_node) {
	462	status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
	463	goto end;
	464	}
	465
	466	trace_node =
	467	bt_list_entry(root_node->u.root.trace.next,
	468	struct ctf_node, siblings);
	469	if (!trace_node) {
	470	status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
	471	goto end;
	472	}
	473
	474	status = find_uuid_in_trace_decl(mdec, trace_node, uuid);
	475
	476	end:
	477	return status;
	478	}