[babeltrace.git] / 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.
 */

#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <assert.h>
#include <babeltrace/compat/uuid.h>
#include <babeltrace/compat/memstream.h>
#include <babeltrace/ctf-ir/trace.h>
#include <glib.h>

#include "ast.h"
#include "decoder.h"
#include "scanner.h"

#define PRINT_ERR_STREAM	mdec->err_stream
#define PRINT_PREFIX		"metadata-decoder"
#include "../print.h"

#define TSDL_MAGIC	0x75d11d57

struct ctf_metadata_decoder {
	struct ctf_visitor_generate_ir *visitor;
	FILE *err_stream;
	uint8_t uuid[16];
	bool is_uuid_set;
	int bo;
};

struct packet_header {
	uint32_t magic;
	uint8_t  uuid[16];
	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
bool ctf_metadata_decoder_is_packetized(FILE *fp, int *byte_order)
{
	uint32_t magic;
	size_t len;
	int ret = 0;

	len = fread(&magic, sizeof(magic), 1, fp);
	if (len != 1) {
		goto end;
	}

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

end:
	rewind(fp);

	return ret;
}

static
bool is_version_valid(unsigned int major, unsigned int minor)
{
	return major == 1 && minor == 8;
}

static
int decode_packet(struct ctf_metadata_decoder *mdec, FILE *in_fp, FILE *out_fp,
		int byte_order)
{
	struct packet_header header;
	size_t readlen, writelen, toread;
	uint8_t buf[512 + 1];	/* + 1 for debug-mode \0 */
	int ret = 0;

	readlen = fread(&header, sizeof(header), 1, in_fp);
	if (feof(in_fp) != 0) {
		goto end;
	}
	if (readlen < 1) {
		goto error;
	}

	if (byte_order != BYTE_ORDER) {
		header.magic = GUINT32_SWAP_LE_BE(header.magic);
		header.checksum = GUINT32_SWAP_LE_BE(header.checksum);
		header.content_size = GUINT32_SWAP_LE_BE(header.content_size);
		header.packet_size = GUINT32_SWAP_LE_BE(header.packet_size);
	}

	if (header.compression_scheme) {
		PERR("Metadata packet compression not supported yet\n");
		goto error;
	}

	if (header.encryption_scheme) {
		PERR("Metadata packet encryption not supported yet\n");
		goto error;
	}

	if (header.checksum || header.checksum_scheme) {
		PERR("Metadata packet checksum verification not supported yet\n");
		goto error;
	}

	if (!is_version_valid(header.major, header.minor)) {
		PERR("Invalid metadata version: %u.%u\n", header.major,
			header.minor);
		goto error;
	}

	/* Set expected trace UUID if not set; otherwise validate it */
	if (mdec) {
		if (!mdec->is_uuid_set) {
			memcpy(mdec->uuid, header.uuid, sizeof(header.uuid));
			mdec->is_uuid_set = true;
		} else if (bt_uuid_compare(header.uuid, mdec->uuid)) {
			PERR("Metadata UUID mismatch between packets of the same stream\n");
			goto error;
		}
	}

	if ((header.content_size / CHAR_BIT) < sizeof(header)) {
		PERR("Bad metadata packet content size: %u\n",
			header.content_size);
		goto error;
	}

	toread = header.content_size / CHAR_BIT - sizeof(header);

	for (;;) {
		readlen = fread(buf, sizeof(uint8_t),
			MIN(sizeof(buf) - 1, toread), in_fp);
		if (ferror(in_fp)) {
			PERR("Cannot read metadata packet buffer (at position %ld)\n",
				ftell(in_fp));
			goto error;
		}

		writelen = fwrite(buf, sizeof(uint8_t), readlen, out_fp);
		if (writelen < readlen || ferror(out_fp)) {
			PERR("Cannot write decoded metadata text to buffer\n");
			goto error;
		}

		toread -= readlen;
		if (toread == 0) {
			int fseek_ret;

			/* Read leftover padding */
			toread = (header.packet_size - header.content_size) /
				CHAR_BIT;
			fseek_ret = fseek(in_fp, toread, SEEK_CUR);
			if (fseek_ret < 0) {
				PWARN("Missing padding at the end of the metadata file\n");
			}

			break;
		}
	}

	goto end;

error:
	ret = -1;

end:
	return ret;
}

static
int ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
		struct ctf_metadata_decoder *mdec, FILE *fp,
		char **buf, int byte_order)
{
	FILE *out_fp;
	size_t size;
	int ret = 0;
	int tret;
	size_t packet_index = 0;

	out_fp = bt_open_memstream(buf, &size);
	if (out_fp == NULL) {
		PERR("Cannot open memory stream: %s\n", strerror(errno));
		goto error;
	}

	for (;;) {
		if (feof(fp) != 0) {
			break;
		}

		tret = decode_packet(mdec, fp, out_fp, byte_order);
		if (tret) {
			PERR("Cannot decode packet #%zu\n", packet_index);
			goto error;
		}

		packet_index++;
	}

	/* Make sure the whole string ends with a null character */
	tret = fputc('\0', out_fp);
	if (tret == EOF) {
		PERR("Cannot append '\\0' to the decoded metadata buffer\n");
		goto error;
	}

	/* Close stream, which also flushes the buffer */
	ret = bt_close_memstream(buf, &size, out_fp);
	if (ret < 0) {
		PERR("Cannot close memory stream: %s\n", strerror(errno));
		goto error;
	}

	goto end;

error:
	ret = -1;

	if (out_fp) {
		bt_close_memstream(buf, &size, out_fp);
	}

	if (*buf) {
		free(*buf);
	}

end:
	return ret;
}

BT_HIDDEN
int ctf_metadata_decoder_packetized_file_stream_to_buf(
		FILE *fp, char **buf, int byte_order)
{
	return ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
		NULL, fp, buf, byte_order);
}

BT_HIDDEN
struct ctf_metadata_decoder *ctf_metadata_decoder_create(FILE *err,
		uint64_t clock_class_offset_ns)
{
	struct ctf_metadata_decoder *mdec =
		g_new0(struct ctf_metadata_decoder, 1);

	if (!mdec) {
		goto end;
	}

	mdec->err_stream = err;
	mdec->visitor = ctf_visitor_generate_ir_create(err,
		clock_class_offset_ns);
	if (!mdec->visitor) {
		ctf_metadata_decoder_destroy(mdec);
		mdec = NULL;
		goto end;
	}

end:
	return mdec;
}

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

	ctf_visitor_generate_ir_destroy(mdec->visitor);
	g_free(mdec);
}

BT_HIDDEN
enum ctf_metadata_decoder_status ctf_metadata_decoder_decode(
		struct ctf_metadata_decoder *mdec, FILE *fp)
{
	enum ctf_metadata_decoder_status status =
		CTF_METADATA_DECODER_STATUS_OK;
	int ret;
	struct ctf_scanner *scanner = NULL;
	char *buf = NULL;
	bool close_fp = false;

	assert(mdec);

	if (ctf_metadata_decoder_is_packetized(fp, &mdec->bo)) {
		PDBG("Metadata stream is packetized\n");
		ret = ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
			mdec, fp, &buf, mdec->bo);
		if (ret) {
			// log: details
			status = CTF_METADATA_DECODER_STATUS_ERROR;
			goto end;
		}

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

		PDBG("Metadata stream is plain text\n");

		/* Check text-only metadata header and version */
		nr_items = fscanf(fp, "/* CTF %10u.%10u", &major, &minor);
		if (nr_items < 2) {
			PWARN("Ill-shapen or missing \"/* CTF major.minor\" header in plain text metadata file stream\n");
		}

		PDBG("Metadata version: %u.%u\n", major, minor);

		if (!is_version_valid(major, minor)) {
			PERR("Invalid metadata version: %u.%u\n", major, minor);
			status = CTF_METADATA_DECODER_STATUS_INVAL_VERSION;
			goto end;
		}

		if (fseek(fp, init_pos, SEEK_SET)) {
			PERR("Cannot seek metadata file stream to initial position: %s\n",
				strerror(errno));
			status = CTF_METADATA_DECODER_STATUS_ERROR;
			goto end;
		}
	}

	/* Allocate a scanner and append the metadata text content */
	scanner = ctf_scanner_alloc();
	if (!scanner) {
		PERR("Cannot allocate a metadata lexical scanner\n");
		status = CTF_METADATA_DECODER_STATUS_ERROR;
		goto end;
	}

	assert(fp);
	ret = ctf_scanner_append_ast(scanner, fp);
	if (ret) {
		PERR("Cannot create the metadata AST\n");
		status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
		goto end;
	}

	ret = ctf_visitor_semantic_check(stderr, 0, &scanner->ast->root);
	if (ret) {
		PERR("Metadata semantic validation failed\n");
		status = CTF_METADATA_DECODER_STATUS_ERROR;
		goto end;
	}

	ret = ctf_visitor_generate_ir_visit_node(mdec->visitor,
		&scanner->ast->root);
	switch (ret) {
	case 0:
		/* Success */
		break;
	case -EINCOMPLETE:
		PDBG("While visiting AST: incomplete data\n");
		status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
		goto end;
	default:
		PERR("Cannot visit AST node to create CTF IR objects\n");
		status = CTF_METADATA_DECODER_STATUS_IR_VISITOR_ERROR;
		goto end;
	}

end:
	if (scanner) {
		ctf_scanner_free(scanner);
	}

	if (fp && close_fp) {
		if (fclose(fp)) {
			PERR("Cannot close metadata file stream\n");
		}
	}

	if (buf) {
		free(buf);
	}

	return status;
}

BT_HIDDEN
struct bt_ctf_trace *ctf_metadata_decoder_get_trace(
		struct ctf_metadata_decoder *mdec)
{
	return ctf_visitor_generate_ir_get_trace(mdec->visitor);
}
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
	15	#include <stdio.h>
	16	#include <stdbool.h>
	17	#include <stdint.h>
	18	#include <stdlib.h>
	19	#include <assert.h>
	20	#include <babeltrace/compat/uuid.h>
	21	#include <babeltrace/compat/memstream.h>
	22	#include <babeltrace/ctf-ir/trace.h>
	23	#include <glib.h>
	24
	25	#include "ast.h"
	26	#include "decoder.h"
	27	#include "scanner.h"
	28
	29	#define PRINT_ERR_STREAM mdec->err_stream
	30	#define PRINT_PREFIX "metadata-decoder"
	31	#include "../print.h"
	32
	33	#define TSDL_MAGIC 0x75d11d57
	34
	35	struct ctf_metadata_decoder {
	36	struct ctf_visitor_generate_ir *visitor;
	37	FILE *err_stream;
	38	uint8_t uuid[16];
	39	bool is_uuid_set;
	40	int bo;
	41	};
	42
	43	struct packet_header {
	44	uint32_t magic;
	45	uint8_t uuid[16];
	46	uint32_t checksum;
	47	uint32_t content_size;
	48	uint32_t packet_size;
	49	uint8_t compression_scheme;
	50	uint8_t encryption_scheme;
	51	uint8_t checksum_scheme;
	52	uint8_t major;
	53	uint8_t minor;
	54	} __attribute__((__packed__));
	55
	56	BT_HIDDEN
	57	bool ctf_metadata_decoder_is_packetized(FILE fp, int byte_order)
	58	{
	59	uint32_t magic;
	60	size_t len;
	61	int ret = 0;
	62
	63	len = fread(&magic, sizeof(magic), 1, fp);
	64	if (len != 1) {
65	goto end;
66	}
67
68	if (byte_order) {
69	if (magic == TSDL_MAGIC) {
70	ret = 1;
71	*byte_order = BYTE_ORDER;
72	} else if (magic == GUINT32_SWAP_LE_BE(TSDL_MAGIC)) {
73	ret = 1;
74	*byte_order = BYTE_ORDER == BIG_ENDIAN ?
75	LITTLE_ENDIAN : BIG_ENDIAN;
76	}
77	}
78
79	end:
80	rewind(fp);
81
82	return ret;
83	}
84
85	static
86	bool is_version_valid(unsigned int major, unsigned int minor)
87	{
88	return major == 1 && minor == 8;
89	}
90
91	static
92	int decode_packet(struct ctf_metadata_decoder mdec, FILE in_fp, FILE *out_fp,
93	int byte_order)
94	{
95	struct packet_header header;
96	size_t readlen, writelen, toread;
97	uint8_t buf[512 + 1]; /* + 1 for debug-mode \0 */
98	int ret = 0;
99
100	readlen = fread(&header, sizeof(header), 1, in_fp);
101	if (feof(in_fp) != 0) {
102	goto end;
103	}
104	if (readlen < 1) {
105	goto error;
106	}
107
108	if (byte_order != BYTE_ORDER) {
109	header.magic = GUINT32_SWAP_LE_BE(header.magic);
110	header.checksum = GUINT32_SWAP_LE_BE(header.checksum);
111	header.content_size = GUINT32_SWAP_LE_BE(header.content_size);
112	header.packet_size = GUINT32_SWAP_LE_BE(header.packet_size);
113	}
114
115	if (header.compression_scheme) {
116	PERR("Metadata packet compression not supported yet\n");
117	goto error;
118	}
119
120	if (header.encryption_scheme) {
121	PERR("Metadata packet encryption not supported yet\n");
122	goto error;
123	}
124
125	if (header.checksum \|\| header.checksum_scheme) {
126	PERR("Metadata packet checksum verification not supported yet\n");
127	goto error;
128	}
129
130	if (!is_version_valid(header.major, header.minor)) {
131	PERR("Invalid metadata version: %u.%u\n", header.major,
132	header.minor);
133	goto error;
134	}
135
136	/* Set expected trace UUID if not set; otherwise validate it */
137	if (mdec) {
138	if (!mdec->is_uuid_set) {
139	memcpy(mdec->uuid, header.uuid, sizeof(header.uuid));
140	mdec->is_uuid_set = true;
141	} else if (bt_uuid_compare(header.uuid, mdec->uuid)) {
142	PERR("Metadata UUID mismatch between packets of the same stream\n");
143	goto error;
144	}
145	}
146
147	if ((header.content_size / CHAR_BIT) < sizeof(header)) {
148	PERR("Bad metadata packet content size: %u\n",
149	header.content_size);
150	goto error;
151	}
152
153	toread = header.content_size / CHAR_BIT - sizeof(header);
154
155	for (;;) {
156	readlen = fread(buf, sizeof(uint8_t),
157	MIN(sizeof(buf) - 1, toread), in_fp);
158	if (ferror(in_fp)) {
159	PERR("Cannot read metadata packet buffer (at position %ld)\n",
160	ftell(in_fp));
161	goto error;
162	}
163
164	writelen = fwrite(buf, sizeof(uint8_t), readlen, out_fp);
165	if (writelen < readlen \|\| ferror(out_fp)) {
166	PERR("Cannot write decoded metadata text to buffer\n");
167	goto error;
168	}
169
170	toread -= readlen;
171	if (toread == 0) {
172	int fseek_ret;
173
174	/* Read leftover padding */
175	toread = (header.packet_size - header.content_size) /
176	CHAR_BIT;
177	fseek_ret = fseek(in_fp, toread, SEEK_CUR);
178	if (fseek_ret < 0) {
179	PWARN("Missing padding at the end of the metadata file\n");
180	}
181
182	break;
183	}
184	}
185
186	goto end;
187
188	error:
189	ret = -1;
190
191	end:
192	return ret;
193	}
194
195	static
196	int ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
197	struct ctf_metadata_decoder mdec, FILE fp,
198	char **buf, int byte_order)
199	{
200	FILE *out_fp;
201	size_t size;
202	int ret = 0;
203	int tret;
204	size_t packet_index = 0;
205
206	out_fp = bt_open_memstream(buf, &size);
207	if (out_fp == NULL) {
208	PERR("Cannot open memory stream: %s\n", strerror(errno));
209	goto error;
210	}
211
212	for (;;) {
213	if (feof(fp) != 0) {
214	break;
215	}
216
217	tret = decode_packet(mdec, fp, out_fp, byte_order);
218	if (tret) {
219	PERR("Cannot decode packet #%zu\n", packet_index);
220	goto error;
221	}
222
223	packet_index++;
224	}
225
226	/* Make sure the whole string ends with a null character */
227	tret = fputc('\0', out_fp);
228	if (tret == EOF) {
229	PERR("Cannot append '\\0' to the decoded metadata buffer\n");
230	goto error;
231	}
232
233	/* Close stream, which also flushes the buffer */
234	ret = bt_close_memstream(buf, &size, out_fp);
235	if (ret < 0) {
236	PERR("Cannot close memory stream: %s\n", strerror(errno));
237	goto error;
238	}
239
240	goto end;
241
242	error:
243	ret = -1;
244
245	if (out_fp) {
246	bt_close_memstream(buf, &size, out_fp);
247	}
248
249	if (*buf) {
250	free(*buf);
251	}
252
253	end:
254	return ret;
255	}
256
257	BT_HIDDEN
258	int ctf_metadata_decoder_packetized_file_stream_to_buf(
259	FILE fp, char *buf, int byte_order)
260	{
261	return ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
262	NULL, fp, buf, byte_order);
263	}
264
265	BT_HIDDEN
266	struct ctf_metadata_decoder ctf_metadata_decoder_create(FILE err,
267	uint64_t clock_class_offset_ns)
268	{
269	struct ctf_metadata_decoder *mdec =
270	g_new0(struct ctf_metadata_decoder, 1);
271
272	if (!mdec) {
273	goto end;
274	}
275
276	mdec->err_stream = err;
277	mdec->visitor = ctf_visitor_generate_ir_create(err,
278	clock_class_offset_ns);
279	if (!mdec->visitor) {
280	ctf_metadata_decoder_destroy(mdec);
281	mdec = NULL;
282	goto end;
283	}
284
285	end:
286	return mdec;
287	}
288
289	BT_HIDDEN
290	void ctf_metadata_decoder_destroy(struct ctf_metadata_decoder *mdec)
291	{
292	if (!mdec) {
293	return;
294	}
295
296	ctf_visitor_generate_ir_destroy(mdec->visitor);
297	g_free(mdec);
298	}
299
300	BT_HIDDEN
301	enum ctf_metadata_decoder_status ctf_metadata_decoder_decode(
302	struct ctf_metadata_decoder mdec, FILE fp)
303	{
304	enum ctf_metadata_decoder_status status =
305	CTF_METADATA_DECODER_STATUS_OK;
306	int ret;
307	struct ctf_scanner *scanner = NULL;
308	char *buf = NULL;
309	bool close_fp = false;
310
311	assert(mdec);
312
313	if (ctf_metadata_decoder_is_packetized(fp, &mdec->bo)) {
314	PDBG("Metadata stream is packetized\n");
315	ret = ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
316	mdec, fp, &buf, mdec->bo);
317	if (ret) {
318	// log: details
319	status = CTF_METADATA_DECODER_STATUS_ERROR;
320	goto end;
321	}
322
323	/* Convert the real file pointer to a memory file pointer */
324	fp = bt_fmemopen(buf, strlen(buf), "rb");
325	close_fp = true;
326	if (!fp) {
327	PERR("Cannot memory-open metadata buffer: %s\n",
328	strerror(errno));
329	status = CTF_METADATA_DECODER_STATUS_ERROR;
330	goto end;
331	}
332	} else {
333	unsigned int major, minor;
334	ssize_t nr_items;
335	const long init_pos = ftell(fp);
336
337	PDBG("Metadata stream is plain text\n");
338
339	/* Check text-only metadata header and version */
340	nr_items = fscanf(fp, "/* CTF %10u.%10u", &major, &minor);
341	if (nr_items < 2) {
342	PWARN("Ill-shapen or missing \"/* CTF major.minor\" header in plain text metadata file stream\n");
343	}
344
345	PDBG("Metadata version: %u.%u\n", major, minor);
346
347	if (!is_version_valid(major, minor)) {
348	PERR("Invalid metadata version: %u.%u\n", major, minor);
349	status = CTF_METADATA_DECODER_STATUS_INVAL_VERSION;
350	goto end;
351	}
352
353	if (fseek(fp, init_pos, SEEK_SET)) {
354	PERR("Cannot seek metadata file stream to initial position: %s\n",
355	strerror(errno));
356	status = CTF_METADATA_DECODER_STATUS_ERROR;
357	goto end;
358	}
359	}
360
361	/* Allocate a scanner and append the metadata text content */
362	scanner = ctf_scanner_alloc();
363	if (!scanner) {
364	PERR("Cannot allocate a metadata lexical scanner\n");
365	status = CTF_METADATA_DECODER_STATUS_ERROR;
366	goto end;
367	}
368
369	assert(fp);
370	ret = ctf_scanner_append_ast(scanner, fp);
371	if (ret) {
372	PERR("Cannot create the metadata AST\n");
373	status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
374	goto end;
375	}
376
377	ret = ctf_visitor_semantic_check(stderr, 0, &scanner->ast->root);
378	if (ret) {
379	PERR("Metadata semantic validation failed\n");
380	status = CTF_METADATA_DECODER_STATUS_ERROR;
381	goto end;
382	}
383
384	ret = ctf_visitor_generate_ir_visit_node(mdec->visitor,
385	&scanner->ast->root);
386	switch (ret) {
387	case 0:
388	/* Success */
389	break;
390	case -EINCOMPLETE:
391	PDBG("While visiting AST: incomplete data\n");
392	status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
393	goto end;
394	default:
395	PERR("Cannot visit AST node to create CTF IR objects\n");
396	status = CTF_METADATA_DECODER_STATUS_IR_VISITOR_ERROR;
397	goto end;
398	}
399
400	end:
401	if (scanner) {
402	ctf_scanner_free(scanner);
403	}
404
405	if (fp && close_fp) {
406	if (fclose(fp)) {
407	PERR("Cannot close metadata file stream\n");
408	}
409	}
410
411	if (buf) {
412	free(buf);
413	}
414
415	return status;
416	}
417
418	BT_HIDDEN
419	struct bt_ctf_trace *ctf_metadata_decoder_get_trace(
420	struct ctf_metadata_decoder *mdec)
421	{
422	return ctf_visitor_generate_ir_get_trace(mdec->visitor);
423	}