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

/*
 * Copyright 2016-2017 - Philippe Proulx <pproulx@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.
 */

#define BT_COMP_LOG_SELF_COMP (mdec->config.self_comp)
#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"

#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;
	bool has_checked_plaintext_signature;
};

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_packetized_file_stream_to_buf(FILE *fp,
		char **buf, int byte_order, bool *is_uuid_set,
		uint8_t *uuid, bt_logging_level log_level,
		bt_self_component *self_comp);

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->scanner = ctf_scanner_alloc();
	if (!mdec->scanner) {
		BT_COMP_LOGE("Cannot allocate a metadata lexical scanner: "
			"mdec-addr=%p", mdec);
		goto error;
	}

	mdec->text = g_string_new(NULL);
	if (!mdec->text) {
		BT_COMP_LOGE("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_LOGE("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);
		if (ret) {
			BT_COMP_LOGE("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_LOGE("Cannot memory-open metadata buffer: %s: "
				"mdec-addr=%p", strerror(errno), mdec);
			status = CTF_METADATA_DECODER_STATUS_ERROR;
			goto end;
		}
	} else if (!mdec->has_checked_plaintext_signature) {
		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_ERRNO("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_LOGE("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_LOGE("Cannot seek metadata file stream to initial position: %s: "
				"mdec-addr=%p", strerror(errno), mdec);
			status = CTF_METADATA_DECODER_STATUS_ERROR;
			goto end;
		}

		mdec->has_checked_plaintext_signature = true;
	}

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