[babeltrace.git] / formats / ctf / ctf.c

/*
 * BabelTrace - Common Trace Format (CTF)
 *
 * Format registration.
 *
 * Copyright 2010, 2011 - Mathieu Desnoyers <mathieu.desnoyers@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 <babeltrace/format.h>
#include <babeltrace/ctf/types.h>
#include <babeltrace/ctf/metadata.h>
#include <babeltrace/babeltrace.h>
#include <inttypes.h>
#include <uuid/uuid.h>
#include <sys/mman.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <dirent.h>
#include <glib.h>
#include <unistd.h>
#include <stdlib.h>

#include "metadata/ctf-scanner.h"
#include "metadata/ctf-parser.h"
#include "metadata/ctf-ast.h"

/*
 * We currently simply map a page to read the packet header and packet
 * context to get the packet length and content length.
 */
#define MAX_PACKET_HEADER_LEN	getpagesize()
#define UUID_LEN 16	/* uuid by value len */

extern int yydebug;

struct trace_descriptor {
	struct ctf_trace ctf_trace;
};

struct trace_descriptor *ctf_open_trace(const char *path, int flags);
void ctf_close_trace(struct trace_descriptor *descriptor);

static struct format ctf_format = {
	.uint_read = ctf_uint_read,
	.int_read = ctf_int_read,
	.uint_write = ctf_uint_write,
	.int_write = ctf_int_write,
	.double_read = ctf_double_read,
	.double_write = ctf_double_write,
	.ldouble_read = ctf_ldouble_read,
	.ldouble_write = ctf_ldouble_write,
	.float_copy = ctf_float_copy,
	.string_copy = ctf_string_copy,
	.string_read = ctf_string_read,
	.string_write = ctf_string_write,
	.string_free_temp = ctf_string_free_temp,
	.enum_read = ctf_enum_read,
	.enum_write = ctf_enum_write,
	.struct_begin = ctf_struct_begin,
	.struct_end = ctf_struct_end,
	.variant_begin = ctf_variant_begin,
	.variant_end = ctf_variant_end,
	.array_begin = ctf_array_begin,
	.array_end = ctf_array_end,
	.sequence_begin = ctf_sequence_begin,
	.sequence_end = ctf_sequence_end,
	.open_trace = ctf_open_trace,
	.close_trace = ctf_close_trace,
};

void move_pos_slow(struct stream_pos *pos, size_t offset)
{
	int ret;

	/*
	 * The caller should never ask for move_pos across packets,
	 * except to get exactly at the beginning of the next packet.
	 */
	assert(pos->offset + offset == pos->content_size);

	if (pos->base) {
		/* unmap old base */
		ret = munmap(pos->base, pos->packet_size);
		if (ret) {
			fprintf(stdout, "Unable to unmap old base: %s.\n",
				strerror(errno));
			assert(0);
		}
	}

	pos->mmap_offset += pos->packet_size / CHAR_BIT;
	/* map new base. Need mapping length from header. */
	pos->base = mmap(NULL, MAX_PACKET_HEADER_LEN, PROT_READ,
			 MAP_PRIVATE, pos->fd, pos->mmap_offset);
	pos->content_size = 0;	/* Unknown at this point */
	pos->packet_size = 0;	/* Unknown at this point */

}

/*
 * TODO: for now, we treat the metadata file as a simple text file
 * (without any header nor packets nor padding).
 */
static
int ctf_open_trace_metadata_read(struct trace_descriptor *td)
{
	struct ctf_scanner *scanner;
	FILE *fp;
	int ret = 0;

	td->ctf_trace.metadata.pos.fd = openat(td->ctf_trace.dirfd,
			"metadata", O_RDONLY);
	if (td->ctf_trace.metadata.pos.fd < 0) {
		fprintf(stdout, "Unable to open metadata.\n");
		return td->ctf_trace.metadata.pos.fd;
	}

	if (babeltrace_debug)
		yydebug = 1;

	fp = fdopen(td->ctf_trace.metadata.pos.fd, "r");
	if (!fp) {
		fprintf(stdout, "Unable to open metadata stream.\n");
		ret = -errno;
		goto end_stream;
	}

	scanner = ctf_scanner_alloc(fp);
	if (!scanner) {
		fprintf(stdout, "Error allocating scanner\n");
		ret = -ENOMEM;
		goto end_scanner_alloc;
	}
	ret = ctf_scanner_append_ast(scanner);
	if (ret) {
		fprintf(stdout, "Error creating AST\n");
		goto end;
	}

	if (babeltrace_debug) {
		ret = ctf_visitor_print_xml(stdout, 0, &scanner->ast->root);
		if (ret) {
			fprintf(stdout, "Error visiting AST for XML output\n");
			goto end;
		}
	}

	ret = ctf_visitor_semantic_check(stdout, 0, &scanner->ast->root);
	if (ret) {
		fprintf(stdout, "Error in CTF semantic validation %d\n", ret);
		goto end;
	}
	ret = ctf_visitor_construct_metadata(stdout, 0, &scanner->ast->root,
			&td->ctf_trace, BYTE_ORDER);
	if (ret) {
		fprintf(stdout, "Error in CTF metadata constructor %d\n", ret);
		goto end;
	}
end:
	ctf_scanner_free(scanner);
end_scanner_alloc:
	fclose(fp);
end_stream:
	close(td->ctf_trace.metadata.pos.fd);
	return ret;
}


static
int create_stream_packet_index(struct trace_descriptor *td,
			       struct ctf_file_stream *file_stream)
{
	struct ctf_stream *stream;
	int len_index;
	struct stream_pos *pos;
	struct stat filestats;
	struct packet_index packet_index;
	int first_packet = 1;
	int ret;

	pos = &file_stream->pos;

	ret = fstat(pos->fd, &filestats);
	if (ret < 0)
		return ret;

	for (pos->mmap_offset = 0; pos->mmap_offset < filestats.st_size; ) {
		uint64_t stream_id = 0;

		if (pos->base) {
			/* unmap old base */
			ret = munmap(pos->base, pos->packet_size);
			if (ret) {
				fprintf(stdout, "Unable to unmap old base: %s.\n",
					strerror(errno));
				return ret;
			}
		}
		/* map new base. Need mapping length from header. */
		pos->base = mmap(NULL, MAX_PACKET_HEADER_LEN, PROT_READ,
				 MAP_PRIVATE, pos->fd, pos->mmap_offset);
		pos->content_size = MAX_PACKET_HEADER_LEN;	/* Unknown at this point */
		pos->packet_size = MAX_PACKET_HEADER_LEN;	/* Unknown at this point */
		pos->offset = 0;	/* Position of the packet header */

		/* read and check header, set stream id (and check) */
		if (td->ctf_trace.packet_header) {
			/* Read packet header */
			td->ctf_trace.packet_header->p.declaration->copy(NULL, NULL,
				pos, &ctf_format, &td->ctf_trace.packet_header->p);

			len_index = struct_declaration_lookup_field_index(td->ctf_trace.packet_header->declaration, g_quark_from_static_string("magic"));
			if (len_index >= 0) {
				struct definition_integer *defint;
				struct field *field;

				field = struct_definition_get_field_from_index(td->ctf_trace.packet_header, len_index);
				assert(field->definition->declaration->id == CTF_TYPE_INTEGER);
				defint = container_of(field->definition, struct definition_integer, p);
				assert(defint->declaration->signedness == FALSE);
				if (defint->value._unsigned != CTF_MAGIC) {
					fprintf(stdout, "[error] Invalid magic number %" PRIX64 ".\n",
							defint->value._unsigned);
					return -EINVAL;
				}
			}

			/* check uuid */
			len_index = struct_declaration_lookup_field_index(td->ctf_trace.packet_header->declaration, g_quark_from_static_string("trace_uuid"));
			if (len_index >= 0) {
				struct definition_array *defarray;
				struct field *field;
				uint64_t i;
				uint8_t uuidval[UUID_LEN];


				field = struct_definition_get_field_from_index(td->ctf_trace.packet_header, len_index);
				assert(field->definition->declaration->id == CTF_TYPE_ARRAY);
				defarray = container_of(field->definition, struct definition_array, p);
				assert(array_len(defarray) == UUID_LEN);
				assert(defarray->declaration->elem->id == CTF_TYPE_INTEGER);

				for (i = 0; i < UUID_LEN; i++) {
					struct definition *elem;
					struct definition_integer *defint;

					elem = array_index(defarray, i);
					assert(elem);
					defint = container_of(elem, struct definition_integer, p);
					uuidval[i] = defint->value._unsigned;
				}
				ret = uuid_compare(td->ctf_trace.uuid, uuidval);
				if (ret) {
					fprintf(stdout, "[error] Unique Universal Identifiers do not match.\n");
					return -EINVAL;
				}
			}


			len_index = struct_declaration_lookup_field_index(td->ctf_trace.packet_header->declaration, g_quark_from_static_string("stream_id"));
			if (len_index >= 0) {
				struct definition_integer *defint;
				struct field *field;

				field = struct_definition_get_field_from_index(td->ctf_trace.packet_header, len_index);
				assert(field->definition->declaration->id == CTF_TYPE_INTEGER);
				defint = container_of(field->definition, struct definition_integer, p);
				assert(defint->declaration->signedness == FALSE);
				stream_id = defint->value._unsigned;
			}
		}

		if (!first_packet && file_stream->stream_id != stream_id) {
			fprintf(stdout, "[error] Stream ID is changing within a stream.\n");
			return -EINVAL;
		}
		if (first_packet) {
			file_stream->stream_id = stream_id;
			if (stream_id >= td->ctf_trace.streams->len) {
				fprintf(stdout, "[error] Stream %" PRIu64 " is not declared in metadata.\n", stream_id);
				return -EINVAL;
			}
			stream = g_ptr_array_index(td->ctf_trace.streams, stream_id);
			if (!stream) {
				fprintf(stdout, "[error] Stream %" PRIu64 " is not declared in metadata.\n", stream_id);
				return -EINVAL;
			}
			file_stream->stream = stream;
		}
		first_packet = 0;

		if (stream->packet_context) {
			/* Read packet context */
			stream->packet_context->p.declaration->copy(NULL, NULL,
					pos, &ctf_format, &stream->packet_context->p);

			/* read content size from header */
			len_index = struct_declaration_lookup_field_index(stream->packet_context->declaration, g_quark_from_static_string("content_size"));
			if (len_index >= 0) {
				struct definition_integer *defint;
				struct field *field;

				field = struct_definition_get_field_from_index(stream->packet_context, len_index);
				assert(field->definition->declaration->id == CTF_TYPE_INTEGER);
				defint = container_of(field->definition, struct definition_integer, p);
				assert(defint->declaration->signedness == FALSE);
				pos->content_size = defint->value._unsigned;
			} else {
				/* Use file size for packet size */
				pos->content_size = filestats.st_size * CHAR_BIT;
			}

			/* read packet size from header */
			len_index = struct_declaration_lookup_field_index(stream->packet_context->declaration, g_quark_from_static_string("packet_size"));
			if (len_index >= 0) {
				struct definition_integer *defint;
				struct field *field;

				field = struct_definition_get_field_from_index(stream->packet_context, len_index);
				assert(field->definition->declaration->id == CTF_TYPE_INTEGER);
				defint = container_of(field->definition, struct definition_integer, p);
				assert(defint->declaration->signedness == FALSE);
				pos->packet_size = defint->value._unsigned;
			} else {
				/* Use content size if non-zero, else file size */
				pos->packet_size = pos->content_size ? : filestats.st_size * CHAR_BIT;
			}
		} else {
			/* Use file size for packet size */
			pos->content_size = filestats.st_size * CHAR_BIT;
			/* Use content size if non-zero, else file size */
			pos->packet_size = pos->content_size ? : filestats.st_size * CHAR_BIT;
		}

		packet_index.offset = pos->mmap_offset;
		packet_index.content_size = pos->content_size;
		packet_index.packet_size = pos->packet_size;
		/* add index to packet array */
		g_array_append_val(file_stream->pos.packet_index, packet_index);

		pos->mmap_offset += pos->packet_size / CHAR_BIT;
	}

	return 0;
}

/*
 * Note: many file streams can inherit from the same stream class
 * description (metadata).
 */
static
int ctf_open_file_stream_read(struct trace_descriptor *td, const char *path, int flags)
{
	int ret;
	struct ctf_file_stream *file_stream;

	ret = openat(td->ctf_trace.dirfd, path, flags);
	if (ret < 0)
		goto error;
	file_stream = g_new0(struct ctf_file_stream, 1);
	file_stream->pos.fd = ret;
	file_stream->pos.packet_index = g_array_new(FALSE, TRUE,
						sizeof(struct packet_index));
	ret = create_stream_packet_index(td, file_stream);
	if (ret)
		goto error_index;
	/* Add stream file to stream class */
	g_ptr_array_add(file_stream->stream->files, file_stream);
	return 0;

error_index:
	(void) g_array_free(file_stream->pos.packet_index, TRUE);
	close(file_stream->pos.fd);
	g_free(file_stream);
error:
	return ret;
}

static
int ctf_open_trace_read(struct trace_descriptor *td, const char *path, int flags)
{
	int ret;
	struct dirent *dirent;
	struct dirent *diriter;
	size_t dirent_len;

	td->ctf_trace.flags = flags;

	/* Open trace directory */
	td->ctf_trace.dir = opendir(path);
	if (!td->ctf_trace.dir) {
		fprintf(stdout, "[error] Unable to open trace directory.\n");
		ret = -ENOENT;
		goto error;
	}

	td->ctf_trace.dirfd = open(path, 0);
	if (td->ctf_trace.dirfd < 0) {
		fprintf(stdout, "[error] Unable to open trace directory file descriptor.\n");
		ret = -ENOENT;
		goto error_dirfd;
	}

	td->ctf_trace.streams = g_ptr_array_new();

	/*
	 * Keep the metadata file separate.
	 */

	ret = ctf_open_trace_metadata_read(td);
	if (ret) {
		goto error_metadata;
	}

	/*
	 * Open each stream: for each file, try to open, check magic
	 * number, and get the stream ID to add to the right location in
	 * the stream array.
	 */

	dirent_len = offsetof(struct dirent, d_name) +
			fpathconf(td->ctf_trace.dirfd, _PC_NAME_MAX) + 1;

	dirent = malloc(dirent_len);

	for (;;) {
		ret = readdir_r(td->ctf_trace.dir, dirent, &diriter);
		if (ret) {
			fprintf(stdout, "[error] Readdir error.\n");
			goto readdir_error;
		}
		if (!diriter)
			break;
		if (!strcmp(diriter->d_name, ".")
				|| !strcmp(diriter->d_name, "..")
				|| !strcmp(diriter->d_name, "metadata"))
			continue;
		ret = ctf_open_file_stream_read(td, diriter->d_name, flags);
		if (ret) {
			fprintf(stdout, "[error] Open file stream error.\n");
			goto readdir_error;
		}
	}

	free(dirent);
	return 0;

readdir_error:
	free(dirent);
error_metadata:
	g_ptr_array_free(td->ctf_trace.streams, TRUE);
	close(td->ctf_trace.dirfd);
error_dirfd:
	closedir(td->ctf_trace.dir);
error:
	return ret;
}

static
int ctf_open_trace_write(struct trace_descriptor *td, const char *path, int flags)
{
	int ret;

	ret = mkdir(path, S_IRWXU|S_IRWXG);
	if (ret)
		return ret;

	/* Open trace directory */
	td->ctf_trace.dir = opendir(path);
	if (!td->ctf_trace.dir) {
		fprintf(stdout, "Unable to open trace directory.\n");
		ret = -ENOENT;
		goto error;
	}
	

	return 0;

error:
	return ret;
}

struct trace_descriptor *ctf_open_trace(const char *path, int flags)
{
	struct trace_descriptor *td;
	int ret;

	td = g_new0(struct trace_descriptor, 1);

	switch (flags) {
	case O_RDONLY:
		ret = ctf_open_trace_read(td, path, flags);
		if (ret)
			goto error;
		break;
	case O_WRONLY:
		ret = ctf_open_trace_write(td, path, flags);
		if (ret)
			goto error;
		break;
	default:
		fprintf(stdout, "Incorrect open flags.\n");
		goto error;
	}

	return td;
error:
	g_free(td);
	return NULL;
}

static
void ctf_close_file_stream(struct ctf_file_stream *file_stream)
{
	(void) g_array_free(file_stream->pos.packet_index, TRUE);
	close(file_stream->pos.fd);
}

void ctf_close_trace(struct trace_descriptor *td)
{
	int i;

	if (td->ctf_trace.streams) {
		for (i = 0; i < td->ctf_trace.streams->len; i++) {
			struct ctf_stream *stream;
			int j;

			stream = g_ptr_array_index(td->ctf_trace.streams, i);
			for (j = 0; j < stream->files->len; j++) {
				struct ctf_file_stream *file_stream;
				file_stream = g_ptr_array_index(td->ctf_trace.streams, j);
				ctf_close_file_stream(file_stream);
			}

		}
		g_ptr_array_free(td->ctf_trace.streams, TRUE);
	}
	closedir(td->ctf_trace.dir);
	g_free(td);
}

void __attribute__((constructor)) ctf_init(void)
{
	int ret;

	ctf_format.name = g_quark_from_static_string("ctf");
	ret = bt_register_format(&ctf_format);
	assert(!ret);
}

/* TODO: finalize */
Commit	Line	Data
fc93b2bd MD	1	/*
	2	* BabelTrace - Common Trace Format (CTF)
	3	*
	4	* Format registration.
	5	*
c054553d	6	* Copyright 2010, 2011 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
fc93b2bd	7	*
ccd7e1c8 MD	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:
fc93b2bd	14	*
ccd7e1c8 MD	15	* The above copyright notice and this permission notice shall be included in
ccd7e1c8 MD	16	* all copies or substantial portions of the Software.
fc93b2bd MD	17	*/
	18
	19	#include <babeltrace/format.h>
	20	#include <babeltrace/ctf/types.h>
bbefb8dd	21	#include <babeltrace/ctf/metadata.h>
65102a8c	22	#include <babeltrace/babeltrace.h>
0f980a35 MD	23	#include <inttypes.h>
	24	#include <uuid/uuid.h>
	25	#include <sys/mman.h>
bbefb8dd	26	#include <errno.h>
bbefb8dd	27	#include <sys/types.h>
65102a8c	28	#include <sys/stat.h>
bbefb8dd	29	#include <fcntl.h>
65102a8c	30	#include <dirent.h>
bbefb8dd	31	#include <glib.h>
65102a8c MD	32	#include <unistd.h>
	33	#include <stdlib.h>
	34
65102a8c MD	35	#include "metadata/ctf-scanner.h"
	36	#include "metadata/ctf-parser.h"
	37	#include "metadata/ctf-ast.h"
	38
0f980a35 MD	39	/*
	40	* We currently simply map a page to read the packet header and packet
	41	* context to get the packet length and content length.
	42	*/
	43	#define MAX_PACKET_HEADER_LEN getpagesize()
	44	#define UUID_LEN 16 /* uuid by value len */
	45
65102a8c	46	extern int yydebug;
bbefb8dd MD	47
	48	struct trace_descriptor {
	49	struct ctf_trace ctf_trace;
	50	};
	51
	52	struct trace_descriptor ctf_open_trace(const char path, int flags);
	53	void ctf_close_trace(struct trace_descriptor *descriptor);
fc93b2bd	54
4c8bfb7e	55	static struct format ctf_format = {
fc93b2bd MD	56	.uint_read = ctf_uint_read,
	57	.int_read = ctf_int_read,
	58	.uint_write = ctf_uint_write,
	59	.int_write = ctf_int_write,
0a46062b MD	60	.double_read = ctf_double_read,
0a46062b MD	61	.double_write = ctf_double_write,
dc48ecad MD	62	.ldouble_read = ctf_ldouble_read,
dc48ecad MD	63	.ldouble_write = ctf_ldouble_write,
fc93b2bd MD	64	.float_copy = ctf_float_copy,
fc93b2bd MD	65	.string_copy = ctf_string_copy,
a52d7f6a MD	66	.string_read = ctf_string_read,
	67	.string_write = ctf_string_write,
	68	.string_free_temp = ctf_string_free_temp,
448d3cc7 MD	69	.enum_read = ctf_enum_read,
448d3cc7 MD	70	.enum_write = ctf_enum_write,
11796b96 MD	71	.struct_begin = ctf_struct_begin,
11796b96 MD	72	.struct_end = ctf_struct_end,
c054553d MD	73	.variant_begin = ctf_variant_begin,
c054553d MD	74	.variant_end = ctf_variant_end,
d06d03db MD	75	.array_begin = ctf_array_begin,
	76	.array_end = ctf_array_end,
	77	.sequence_begin = ctf_sequence_begin,
	78	.sequence_end = ctf_sequence_end,
bbefb8dd MD	79	.open_trace = ctf_open_trace,
bbefb8dd MD	80	.close_trace = ctf_close_trace,
fc93b2bd MD	81	};
fc93b2bd MD	82
0f980a35 MD	83	void move_pos_slow(struct stream_pos *pos, size_t offset)
	84	{
	85	int ret;
	86
	87	/*
	88	* The caller should never ask for move_pos across packets,
	89	* except to get exactly at the beginning of the next packet.
	90	*/
	91	assert(pos->offset + offset == pos->content_size);
	92
	93	if (pos->base) {
	94	/* unmap old base */
	95	ret = munmap(pos->base, pos->packet_size);
	96	if (ret) {
	97	fprintf(stdout, "Unable to unmap old base: %s.\n",
	98	strerror(errno));
	99	assert(0);
	100	}
	101	}
	102
	103	pos->mmap_offset += pos->packet_size / CHAR_BIT;
	104	/* map new base. Need mapping length from header. */
	105	pos->base = mmap(NULL, MAX_PACKET_HEADER_LEN, PROT_READ,
	106	MAP_PRIVATE, pos->fd, pos->mmap_offset);
	107	pos->content_size = 0; /* Unknown at this point */
	108	pos->packet_size = 0; /* Unknown at this point */
	109
	110	}
	111
65102a8c MD	112	/*
	113	* TODO: for now, we treat the metadata file as a simple text file
	114	* (without any header nor packets nor padding).
	115	*/
	116	static
	117	int ctf_open_trace_metadata_read(struct trace_descriptor *td)
	118	{
	119	struct ctf_scanner *scanner;
	120	FILE *fp;
	121	int ret = 0;
	122
0f980a35	123	td->ctf_trace.metadata.pos.fd = openat(td->ctf_trace.dirfd,
65102a8c	124	"metadata", O_RDONLY);
0f980a35	125	if (td->ctf_trace.metadata.pos.fd < 0) {
65102a8c	126	fprintf(stdout, "Unable to open metadata.\n");
0f980a35	127	return td->ctf_trace.metadata.pos.fd;
65102a8c MD	128	}
	129
	130	if (babeltrace_debug)
	131	yydebug = 1;
	132
0f980a35	133	fp = fdopen(td->ctf_trace.metadata.pos.fd, "r");
65102a8c MD	134	if (!fp) {
	135	fprintf(stdout, "Unable to open metadata stream.\n");
	136	ret = -errno;
	137	goto end_stream;
	138	}
	139
	140	scanner = ctf_scanner_alloc(fp);
	141	if (!scanner) {
	142	fprintf(stdout, "Error allocating scanner\n");
	143	ret = -ENOMEM;
	144	goto end_scanner_alloc;
	145	}
	146	ret = ctf_scanner_append_ast(scanner);
	147	if (ret) {
	148	fprintf(stdout, "Error creating AST\n");
	149	goto end;
	150	}
	151
	152	if (babeltrace_debug) {
	153	ret = ctf_visitor_print_xml(stdout, 0, &scanner->ast->root);
	154	if (ret) {
	155	fprintf(stdout, "Error visiting AST for XML output\n");
	156	goto end;
	157	}
	158	}
	159
	160	ret = ctf_visitor_semantic_check(stdout, 0, &scanner->ast->root);
	161	if (ret) {
	162	fprintf(stdout, "Error in CTF semantic validation %d\n", ret);
	163	goto end;
	164	}
	165	ret = ctf_visitor_construct_metadata(stdout, 0, &scanner->ast->root,
	166	&td->ctf_trace, BYTE_ORDER);
	167	if (ret) {
	168	fprintf(stdout, "Error in CTF metadata constructor %d\n", ret);
	169	goto end;
	170	}
	171	end:
	172	ctf_scanner_free(scanner);
	173	end_scanner_alloc:
	174	fclose(fp);
	175	end_stream:
0f980a35 MD	176	close(td->ctf_trace.metadata.pos.fd);
	177	return ret;
	178	}
	179
	180
	181	static
	182	int create_stream_packet_index(struct trace_descriptor *td,
	183	struct ctf_file_stream *file_stream)
	184	{
	185	struct ctf_stream *stream;
	186	int len_index;
	187	struct stream_pos *pos;
	188	struct stat filestats;
	189	struct packet_index packet_index;
	190	int first_packet = 1;
	191	int ret;
	192
	193	pos = &file_stream->pos;
	194
	195	ret = fstat(pos->fd, &filestats);
	196	if (ret < 0)
	197	return ret;
	198
	199	for (pos->mmap_offset = 0; pos->mmap_offset < filestats.st_size; ) {
	200	uint64_t stream_id = 0;
	201
	202	if (pos->base) {
	203	/* unmap old base */
	204	ret = munmap(pos->base, pos->packet_size);
	205	if (ret) {
	206	fprintf(stdout, "Unable to unmap old base: %s.\n",
	207	strerror(errno));
	208	return ret;
	209	}
	210	}
	211	/* map new base. Need mapping length from header. */
	212	pos->base = mmap(NULL, MAX_PACKET_HEADER_LEN, PROT_READ,
	213	MAP_PRIVATE, pos->fd, pos->mmap_offset);
dc48ecad MD	214	pos->content_size = MAX_PACKET_HEADER_LEN; /* Unknown at this point */
dc48ecad MD	215	pos->packet_size = MAX_PACKET_HEADER_LEN; /* Unknown at this point */
0f980a35 MD	216	pos->offset = 0; /* Position of the packet header */
	217
	218	/* read and check header, set stream id (and check) */
	219	if (td->ctf_trace.packet_header) {
	220	/* Read packet header */
	221	td->ctf_trace.packet_header->p.declaration->copy(NULL, NULL,
	222	pos, &ctf_format, &td->ctf_trace.packet_header->p);
	223
	224	len_index = struct_declaration_lookup_field_index(td->ctf_trace.packet_header->declaration, g_quark_from_static_string("magic"));
	225	if (len_index >= 0) {
	226	struct definition_integer *defint;
	227	struct field *field;
	228
	229	field = struct_definition_get_field_from_index(td->ctf_trace.packet_header, len_index);
	230	assert(field->definition->declaration->id == CTF_TYPE_INTEGER);
	231	defint = container_of(field->definition, struct definition_integer, p);
	232	assert(defint->declaration->signedness == FALSE);
	233	if (defint->value._unsigned != CTF_MAGIC) {
	234	fprintf(stdout, "[error] Invalid magic number %" PRIX64 ".\n",
	235	defint->value._unsigned);
	236	return -EINVAL;
	237	}
	238	}
	239
	240	/* check uuid */
	241	len_index = struct_declaration_lookup_field_index(td->ctf_trace.packet_header->declaration, g_quark_from_static_string("trace_uuid"));
	242	if (len_index >= 0) {
	243	struct definition_array *defarray;
	244	struct field *field;
	245	uint64_t i;
	246	uint8_t uuidval[UUID_LEN];
	247
	248
	249	field = struct_definition_get_field_from_index(td->ctf_trace.packet_header, len_index);
	250	assert(field->definition->declaration->id == CTF_TYPE_ARRAY);
	251	defarray = container_of(field->definition, struct definition_array, p);
3838df27	252	assert(array_len(defarray) == UUID_LEN);
0f980a35 MD	253	assert(defarray->declaration->elem->id == CTF_TYPE_INTEGER);
	254
	255	for (i = 0; i < UUID_LEN; i++) {
	256	struct definition *elem;
	257	struct definition_integer *defint;
	258
	259	elem = array_index(defarray, i);
	260	assert(elem);
	261	defint = container_of(elem, struct definition_integer, p);
	262	uuidval[i] = defint->value._unsigned;
	263	}
	264	ret = uuid_compare(td->ctf_trace.uuid, uuidval);
	265	if (ret) {
	266	fprintf(stdout, "[error] Unique Universal Identifiers do not match.\n");
	267	return -EINVAL;
	268	}
	269	}
	270
	271
	272	len_index = struct_declaration_lookup_field_index(td->ctf_trace.packet_header->declaration, g_quark_from_static_string("stream_id"));
	273	if (len_index >= 0) {
	274	struct definition_integer *defint;
	275	struct field *field;
	276
	277	field = struct_definition_get_field_from_index(td->ctf_trace.packet_header, len_index);
	278	assert(field->definition->declaration->id == CTF_TYPE_INTEGER);
	279	defint = container_of(field->definition, struct definition_integer, p);
	280	assert(defint->declaration->signedness == FALSE);
	281	stream_id = defint->value._unsigned;
	282	}
	283	}
	284
	285	if (!first_packet && file_stream->stream_id != stream_id) {
	286	fprintf(stdout, "[error] Stream ID is changing within a stream.\n");
	287	return -EINVAL;
	288	}
	289	if (first_packet) {
	290	file_stream->stream_id = stream_id;
	291	if (stream_id >= td->ctf_trace.streams->len) {
	292	fprintf(stdout, "[error] Stream %" PRIu64 " is not declared in metadata.\n", stream_id);
	293	return -EINVAL;
	294	}
	295	stream = g_ptr_array_index(td->ctf_trace.streams, stream_id);
	296	if (!stream) {
	297	fprintf(stdout, "[error] Stream %" PRIu64 " is not declared in metadata.\n", stream_id);
	298	return -EINVAL;
	299	}
	300	file_stream->stream = stream;
	301	}
	302	first_packet = 0;
	303
dc48ecad MD	304	if (stream->packet_context) {
	305	/* Read packet context */
	306	stream->packet_context->p.declaration->copy(NULL, NULL,
	307	pos, &ctf_format, &stream->packet_context->p);
	308
	309	/* read content size from header */
	310	len_index = struct_declaration_lookup_field_index(stream->packet_context->declaration, g_quark_from_static_string("content_size"));
	311	if (len_index >= 0) {
	312	struct definition_integer *defint;
	313	struct field *field;
	314
	315	field = struct_definition_get_field_from_index(stream->packet_context, len_index);
	316	assert(field->definition->declaration->id == CTF_TYPE_INTEGER);
	317	defint = container_of(field->definition, struct definition_integer, p);
	318	assert(defint->declaration->signedness == FALSE);
	319	pos->content_size = defint->value._unsigned;
	320	} else {
	321	/* Use file size for packet size */
	322	pos->content_size = filestats.st_size * CHAR_BIT;
	323	}
	324
	325	/* read packet size from header */
	326	len_index = struct_declaration_lookup_field_index(stream->packet_context->declaration, g_quark_from_static_string("packet_size"));
	327	if (len_index >= 0) {
	328	struct definition_integer *defint;
	329	struct field *field;
	330
	331	field = struct_definition_get_field_from_index(stream->packet_context, len_index);
	332	assert(field->definition->declaration->id == CTF_TYPE_INTEGER);
	333	defint = container_of(field->definition, struct definition_integer, p);
	334	assert(defint->declaration->signedness == FALSE);
	335	pos->packet_size = defint->value._unsigned;
	336	} else {
	337	/* Use content size if non-zero, else file size */
	338	pos->packet_size = pos->content_size ? : filestats.st_size * CHAR_BIT;
	339	}
0f980a35 MD	340	} else {
	341	/* Use file size for packet size */
	342	pos->content_size = filestats.st_size * CHAR_BIT;
0f980a35 MD	343	/* Use content size if non-zero, else file size */
	344	pos->packet_size = pos->content_size ? : filestats.st_size * CHAR_BIT;
	345	}
	346
	347	packet_index.offset = pos->mmap_offset;
	348	packet_index.content_size = pos->content_size;
	349	packet_index.packet_size = pos->packet_size;
	350	/* add index to packet array */
	351	g_array_append_val(file_stream->pos.packet_index, packet_index);
	352
	353	pos->mmap_offset += pos->packet_size / CHAR_BIT;
	354	}
	355
	356	return 0;
	357	}
	358
	359	/*
	360	* Note: many file streams can inherit from the same stream class
	361	* description (metadata).
	362	*/
	363	static
	364	int ctf_open_file_stream_read(struct trace_descriptor td, const char path, int flags)
	365	{
	366	int ret;
	367	struct ctf_file_stream *file_stream;
	368
	369	ret = openat(td->ctf_trace.dirfd, path, flags);
	370	if (ret < 0)
	371	goto error;
	372	file_stream = g_new0(struct ctf_file_stream, 1);
	373	file_stream->pos.fd = ret;
	374	file_stream->pos.packet_index = g_array_new(FALSE, TRUE,
	375	sizeof(struct packet_index));
	376	ret = create_stream_packet_index(td, file_stream);
	377	if (ret)
	378	goto error_index;
	379	/* Add stream file to stream class */
	380	g_ptr_array_add(file_stream->stream->files, file_stream);
	381	return 0;
	382
	383	error_index:
	384	(void) g_array_free(file_stream->pos.packet_index, TRUE);
	385	close(file_stream->pos.fd);
	386	g_free(file_stream);
	387	error:
65102a8c MD	388	return ret;
	389	}
	390
bbefb8dd MD	391	static
	392	int ctf_open_trace_read(struct trace_descriptor td, const char path, int flags)
	393	{
	394	int ret;
65102a8c MD	395	struct dirent *dirent;
	396	struct dirent *diriter;
	397	size_t dirent_len;
bbefb8dd MD	398
	399	td->ctf_trace.flags = flags;
	400
	401	/* Open trace directory */
	402	td->ctf_trace.dir = opendir(path);
	403	if (!td->ctf_trace.dir) {
dc48ecad	404	fprintf(stdout, "[error] Unable to open trace directory.\n");
bbefb8dd MD	405	ret = -ENOENT;
	406	goto error;
	407	}
	408
65102a8c MD	409	td->ctf_trace.dirfd = open(path, 0);
65102a8c MD	410	if (td->ctf_trace.dirfd < 0) {
dc48ecad	411	fprintf(stdout, "[error] Unable to open trace directory file descriptor.\n");
65102a8c MD	412	ret = -ENOENT;
	413	goto error_dirfd;
	414	}
0f980a35 MD	415
	416	td->ctf_trace.streams = g_ptr_array_new();
	417
65102a8c MD	418	/*
	419	* Keep the metadata file separate.
	420	*/
bbefb8dd	421
65102a8c MD	422	ret = ctf_open_trace_metadata_read(td);
	423	if (ret) {
	424	goto error_metadata;
	425	}
bbefb8dd MD	426
	427	/*
	428	* Open each stream: for each file, try to open, check magic
	429	* number, and get the stream ID to add to the right location in
	430	* the stream array.
bbefb8dd MD	431	*/
bbefb8dd MD	432
65102a8c MD	433	dirent_len = offsetof(struct dirent, d_name) +
65102a8c MD	434	fpathconf(td->ctf_trace.dirfd, _PC_NAME_MAX) + 1;
bbefb8dd	435
65102a8c	436	dirent = malloc(dirent_len);
bbefb8dd	437
65102a8c MD	438	for (;;) {
	439	ret = readdir_r(td->ctf_trace.dir, dirent, &diriter);
	440	if (ret) {
dc48ecad	441	fprintf(stdout, "[error] Readdir error.\n");
65102a8c	442	goto readdir_error;
65102a8c MD	443	}
	444	if (!diriter)
	445	break;
	446	if (!strcmp(diriter->d_name, ".")
	447	\|\| !strcmp(diriter->d_name, "..")
	448	\|\| !strcmp(diriter->d_name, "metadata"))
	449	continue;
dc48ecad MD	450	ret = ctf_open_file_stream_read(td, diriter->d_name, flags);
	451	if (ret) {
	452	fprintf(stdout, "[error] Open file stream error.\n");
	453	goto readdir_error;
	454	}
65102a8c	455	}
bbefb8dd	456
65102a8c	457	free(dirent);
bbefb8dd	458	return 0;
65102a8c MD	459
	460	readdir_error:
	461	free(dirent);
	462	error_metadata:
0f980a35	463	g_ptr_array_free(td->ctf_trace.streams, TRUE);
65102a8c MD	464	close(td->ctf_trace.dirfd);
	465	error_dirfd:
	466	closedir(td->ctf_trace.dir);
bbefb8dd MD	467	error:
	468	return ret;
	469	}
	470
	471	static
	472	int ctf_open_trace_write(struct trace_descriptor td, const char path, int flags)
	473	{
	474	int ret;
	475
	476	ret = mkdir(path, S_IRWXU\|S_IRWXG);
	477	if (ret)
	478	return ret;
	479
65102a8c MD	480	/* Open trace directory */
	481	td->ctf_trace.dir = opendir(path);
	482	if (!td->ctf_trace.dir) {
	483	fprintf(stdout, "Unable to open trace directory.\n");
	484	ret = -ENOENT;
	485	goto error;
	486	}
	487
	488
bbefb8dd	489	return 0;
65102a8c MD	490
	491	error:
	492	return ret;
bbefb8dd MD	493	}
	494
	495	struct trace_descriptor ctf_open_trace(const char path, int flags)
	496	{
	497	struct trace_descriptor *td;
	498	int ret;
	499
65102a8c	500	td = g_new0(struct trace_descriptor, 1);
bbefb8dd MD	501
	502	switch (flags) {
	503	case O_RDONLY:
	504	ret = ctf_open_trace_read(td, path, flags);
	505	if (ret)
	506	goto error;
	507	break;
	508	case O_WRONLY:
	509	ret = ctf_open_trace_write(td, path, flags);
	510	if (ret)
	511	goto error;
	512	break;
	513	default:
	514	fprintf(stdout, "Incorrect open flags.\n");
	515	goto error;
	516	}
	517
	518	return td;
	519	error:
	520	g_free(td);
	521	return NULL;
	522	}
	523
0f980a35 MD	524	static
	525	void ctf_close_file_stream(struct ctf_file_stream *file_stream)
	526	{
	527	(void) g_array_free(file_stream->pos.packet_index, TRUE);
	528	close(file_stream->pos.fd);
	529	}
	530
bbefb8dd MD	531	void ctf_close_trace(struct trace_descriptor *td)
bbefb8dd MD	532	{
0f980a35 MD	533	int i;
	534
	535	if (td->ctf_trace.streams) {
	536	for (i = 0; i < td->ctf_trace.streams->len; i++) {
	537	struct ctf_stream *stream;
	538	int j;
	539
	540	stream = g_ptr_array_index(td->ctf_trace.streams, i);
	541	for (j = 0; j < stream->files->len; j++) {
	542	struct ctf_file_stream *file_stream;
	543	file_stream = g_ptr_array_index(td->ctf_trace.streams, j);
	544	ctf_close_file_stream(file_stream);
	545	}
	546
	547	}
	548	g_ptr_array_free(td->ctf_trace.streams, TRUE);
	549	}
bbefb8dd MD	550	closedir(td->ctf_trace.dir);
	551	g_free(td);
	552	}
	553
7fb21036	554	void __attribute__((constructor)) ctf_init(void)
fc93b2bd MD	555	{
	556	int ret;
	557
4c8bfb7e	558	ctf_format.name = g_quark_from_static_string("ctf");
fc93b2bd MD	559	ret = bt_register_format(&ctf_format);
	560	assert(!ret);
	561	}
698f0fe4 MD	562
698f0fe4 MD	563	/* TODO: finalize */