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

/*
 * trace.c
 *
 * Babeltrace CTF IR - Trace
 *
 * Copyright 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <babeltrace/ctf-ir/trace-internal.h>
#include <babeltrace/ctf-ir/clock-internal.h>
#include <babeltrace/ctf-ir/stream-internal.h>
#include <babeltrace/ctf-ir/stream-class-internal.h>
#include <babeltrace/ctf-writer/functor-internal.h>
#include <babeltrace/ctf-ir/event-types-internal.h>
#include <babeltrace/ctf-ir/utils.h>
#include <babeltrace/compiler.h>

#define DEFAULT_IDENTIFIER_SIZE 128
#define DEFAULT_METADATA_STRING_SIZE 4096

static
void environment_variable_destroy(struct environment_variable *var);
static
void bt_ctf_trace_destroy(struct bt_ctf_ref *ref);
static
int init_trace_packet_header(struct bt_ctf_trace *trace);

static
const unsigned int field_type_aliases_alignments[] = {
	[FIELD_TYPE_ALIAS_UINT5_T] = 1,
	[FIELD_TYPE_ALIAS_UINT8_T ... FIELD_TYPE_ALIAS_UINT16_T] = 8,
	[FIELD_TYPE_ALIAS_UINT27_T] = 1,
	[FIELD_TYPE_ALIAS_UINT32_T ... FIELD_TYPE_ALIAS_UINT64_T] = 8,
};

static
const unsigned int field_type_aliases_sizes[] = {
	[FIELD_TYPE_ALIAS_UINT5_T] = 5,
	[FIELD_TYPE_ALIAS_UINT8_T] = 8,
	[FIELD_TYPE_ALIAS_UINT16_T] = 16,
	[FIELD_TYPE_ALIAS_UINT27_T] = 27,
	[FIELD_TYPE_ALIAS_UINT32_T] = 32,
	[FIELD_TYPE_ALIAS_UINT64_T] = 64,
};

struct bt_ctf_trace *bt_ctf_trace_create(void)
{
	struct bt_ctf_trace *trace = NULL;

	trace = g_new0(struct bt_ctf_trace, 1);
	if (!trace) {
		goto error;
	}

	bt_ctf_trace_set_byte_order(trace, BT_CTF_BYTE_ORDER_NATIVE);
	bt_ctf_ref_init(&trace->ref_count);
	trace->environment = g_ptr_array_new_with_free_func(
		(GDestroyNotify)environment_variable_destroy);
	trace->clocks = g_ptr_array_new_with_free_func(
		(GDestroyNotify)bt_ctf_clock_put);
	trace->streams = g_ptr_array_new_with_free_func(
		(GDestroyNotify)bt_ctf_stream_put);
	trace->stream_classes = g_ptr_array_new_with_free_func(
		(GDestroyNotify)bt_ctf_stream_class_put);
	if (!trace->environment || !trace->clocks ||
		!trace->stream_classes || !trace->streams) {
		goto error_destroy;
	}

	/* Generate a trace UUID */
	uuid_generate(trace->uuid);
	if (init_trace_packet_header(trace)) {
		goto error_destroy;
	}

	return trace;

error_destroy:
	bt_ctf_trace_destroy(&trace->ref_count);
	trace = NULL;
error:
	return trace;
}

void bt_ctf_trace_destroy(struct bt_ctf_ref *ref)
{
	struct bt_ctf_trace *trace;

	if (!ref) {
		return;
	}

	trace = container_of(ref, struct bt_ctf_trace, ref_count);
	if (trace->environment) {
		g_ptr_array_free(trace->environment, TRUE);
	}

	if (trace->clocks) {
		g_ptr_array_free(trace->clocks, TRUE);
	}

	if (trace->streams) {
		g_ptr_array_free(trace->streams, TRUE);
	}

	if (trace->stream_classes) {
		g_ptr_array_free(trace->stream_classes, TRUE);
	}

	bt_ctf_field_type_put(trace->packet_header_type);
	g_free(trace);
}

struct bt_ctf_stream *bt_ctf_trace_create_stream(struct bt_ctf_trace *trace,
		struct bt_ctf_stream_class *stream_class)
{
	int ret;
	int stream_class_found = 0;
	size_t i;
	struct bt_ctf_stream *stream = NULL;

	if (!trace || !stream_class) {
		goto error;
	}

	stream = bt_ctf_stream_create(stream_class, trace);
	if (!stream) {
		goto error;
	}

	for (i = 0; i < trace->stream_classes->len; i++) {
		if (trace->stream_classes->pdata[i] == stream_class) {
			stream_class_found = 1;
		}
	}

	if (!stream_class_found) {
		int64_t stream_id = bt_ctf_stream_class_get_id(stream_class);

		if (stream_id < 0) {
			/* Try to assign a new stream id */
			if (bt_ctf_stream_class_set_id(stream->stream_class,
				trace->next_stream_id++)) {
				goto error;
			}
		}

		for (i = 0; i < trace->stream_classes->len; i++) {
			if (stream_id == bt_ctf_stream_class_get_id(
				    trace->stream_classes->pdata[i])) {
				/* Duplicate stream id found */
				goto error;
			}
		}
		bt_ctf_stream_class_get(stream->stream_class);
		g_ptr_array_add(trace->stream_classes, stream->stream_class);
	}

	bt_ctf_stream_get(stream);
	g_ptr_array_add(trace->streams, stream);

	/*
	 * Freeze the trace and its packet header.
	 *
	 * All field type byte orders set as "native" byte ordering can now be
	 * safely set to trace's own endianness, including the stream class'.
	 */
	bt_ctf_field_type_set_native_byte_order(trace->packet_header_type,
		trace->byte_order);
	ret = bt_ctf_stream_class_set_byte_order(stream_class,
		trace->byte_order == LITTLE_ENDIAN ?
		BT_CTF_BYTE_ORDER_LITTLE_ENDIAN : BT_CTF_BYTE_ORDER_BIG_ENDIAN);
	if (ret) {
		goto error;
	}

	bt_ctf_stream_class_freeze(stream_class);
	trace->frozen = 1;
	return stream;
error:
	bt_ctf_stream_put(stream);
	return NULL;
}

int bt_ctf_trace_add_environment_field(struct bt_ctf_trace *trace,
		const char *name,
		const char *value)
{
	struct environment_variable *var = NULL;
	char *escaped_value = NULL;
	int ret = 0;

	if (!trace || !name || !value || bt_ctf_validate_identifier(name)) {
		ret = -1;
		goto error;
	}

	if (strchr(name, ' ')) {
		ret = -1;
		goto error;
	}

	var = g_new0(struct environment_variable, 1);
	if (!var) {
		ret = -1;
		goto error;
	}

	var->type = BT_ENVIRONMENT_FIELD_TYPE_STRING;
	escaped_value = g_strescape(value, NULL);
	if (!escaped_value) {
		ret = -1;
		goto error;
	}

	var->name = g_string_new(name);
	var->value.string = g_string_new(escaped_value);
	g_free(escaped_value);
	if (!var->name || !var->value.string) {
		ret = -1;
		goto error;
	}

	g_ptr_array_add(trace->environment, var);
	return ret;

error:
	if (var && var->name) {
		g_string_free(var->name, TRUE);
	}

	if (var && var->value.string) {
		g_string_free(var->value.string, TRUE);
	}

	g_free(var);
	return ret;
}

int bt_ctf_trace_add_environment_field_integer(struct bt_ctf_trace *trace,
		const char *name,
	        int64_t value)
{
	struct environment_variable *var = NULL;
	int ret = 0;

	if (!trace || !name) {
		ret = -1;
		goto error;
	}

	var = g_new0(struct environment_variable, 1);
	if (!var) {
		ret = -1;
		goto error;
	}

	var->type = BT_ENVIRONMENT_FIELD_TYPE_INTEGER;
	var->name = g_string_new(name);
	var->value.integer = value;
	if (!var->name) {
		ret = -1;
		goto error;
	}

	g_ptr_array_add(trace->environment, var);
	return ret;

error:
	if (var && var->name) {
		g_string_free(var->name, TRUE);
	}

	g_free(var);
	return ret;
}

int bt_ctf_trace_add_clock(struct bt_ctf_trace *trace,
		struct bt_ctf_clock *clock)
{
	int ret = 0;
	struct search_query query = { .value = clock, .found = 0 };

	if (!trace || !clock) {
		ret = -1;
		goto end;
	}

	/* Check for duplicate clocks */
	g_ptr_array_foreach(trace->clocks, value_exists, &query);
	if (query.found) {
		ret = -1;
		goto end;
	}

	bt_ctf_clock_get(clock);
	g_ptr_array_add(trace->clocks, clock);
end:
	return ret;
}

int bt_ctf_trace_get_clock_count(struct bt_ctf_trace *trace)
{
	int ret = -1;

	if (!trace) {
		goto end;
	}

	ret = trace->clocks->len;
end:
	return ret;
}

struct bt_ctf_clock *bt_ctf_trace_get_clock(struct bt_ctf_trace *trace,
		int index)
{
	struct bt_ctf_clock *clock = NULL;

	if (!trace || index < 0 || index >= trace->clocks->len) {
		goto end;
	}

	clock = g_ptr_array_index(trace->clocks, index);
	bt_ctf_clock_get(clock);
end:
	return clock;
}

BT_HIDDEN
const char *get_byte_order_string(int byte_order)
{
	const char *string;

	switch (byte_order) {
	case LITTLE_ENDIAN:
		string = "le";
		break;
	case BIG_ENDIAN:
		string = "be";
		break;
	default:
		string = "unknown";
		break;
	}

	return string;
}

static
int append_trace_metadata(struct bt_ctf_trace *trace,
		struct metadata_context *context)
{
	unsigned char *uuid = trace->uuid;
	int ret;

	g_string_append(context->string, "trace {\n");

	g_string_append(context->string, "\tmajor = 1;\n");
	g_string_append(context->string, "\tminor = 8;\n");

	g_string_append_printf(context->string,
		"\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n",
		uuid[0], uuid[1], uuid[2], uuid[3],
		uuid[4], uuid[5], uuid[6], uuid[7],
		uuid[8], uuid[9], uuid[10], uuid[11],
		uuid[12], uuid[13], uuid[14], uuid[15]);
	g_string_append_printf(context->string, "\tbyte_order = %s;\n",
		get_byte_order_string(trace->byte_order));

	g_string_append(context->string, "\tpacket.header := ");
	context->current_indentation_level++;
	g_string_assign(context->field_name, "");
	ret = bt_ctf_field_type_serialize(trace->packet_header_type,
		context);
	if (ret) {
		goto end;
	}
	context->current_indentation_level--;

	g_string_append(context->string, ";\n};\n\n");
end:
	return ret;
}

static
void append_env_field_metadata(struct environment_variable *var,
		struct metadata_context *context)
{
	switch (var->type) {
	case BT_ENVIRONMENT_FIELD_TYPE_STRING:
		g_string_append_printf(context->string, "\t%s = \"%s\";\n",
			var->name->str, var->value.string->str);
		break;
	case BT_ENVIRONMENT_FIELD_TYPE_INTEGER:
		g_string_append_printf(context->string, "\t%s = %" PRId64 ";\n",
			var->name->str, var->value.integer);
		break;
	default:
		assert(0);
	}
}

static
void append_env_metadata(struct bt_ctf_trace *trace,
		struct metadata_context *context)
{
	if (trace->environment->len == 0) {
		return;
	}

	g_string_append(context->string, "env {\n");
	g_ptr_array_foreach(trace->environment,
		(GFunc)append_env_field_metadata, context);
	g_string_append(context->string, "};\n\n");
}

char *bt_ctf_trace_get_metadata_string(struct bt_ctf_trace *trace)
{
	char *metadata = NULL;
	struct metadata_context *context = NULL;
	int err = 0;
	size_t i;

	if (!trace) {
		goto end;
	}

	context = g_new0(struct metadata_context, 1);
	if (!context) {
		goto end;
	}

	context->field_name = g_string_sized_new(DEFAULT_IDENTIFIER_SIZE);
	context->string = g_string_sized_new(DEFAULT_METADATA_STRING_SIZE);
	g_string_append(context->string, "/* CTF 1.8 */\n\n");
	if (append_trace_metadata(trace, context)) {
		goto error;
	}
	append_env_metadata(trace, context);
	g_ptr_array_foreach(trace->clocks,
		(GFunc)bt_ctf_clock_serialize, context);

	for (i = 0; i < trace->stream_classes->len; i++) {
		err = bt_ctf_stream_class_serialize(
			trace->stream_classes->pdata[i], context);
		if (err) {
			goto error;
		}
	}

	metadata = context->string->str;
error:
	g_string_free(context->string, err ? TRUE : FALSE);
	g_string_free(context->field_name, TRUE);
	g_free(context);
end:
	return metadata;
}

int bt_ctf_trace_set_byte_order(struct bt_ctf_trace *trace,
		enum bt_ctf_byte_order byte_order)
{
	int ret = 0;
	int internal_byte_order;

	if (!trace || trace->frozen) {
		ret = -1;
		goto end;
	}

	switch (byte_order) {
	case BT_CTF_BYTE_ORDER_NATIVE:
		/*
		 * This doesn't make sense since the CTF specification defines
		 * the "native" byte order as "the byte order described in the
		 * trace description". However, this behavior had been
		 * implemented as part of v1.2 and is kept to maintain
		 * compatibility.
		 *
		 * This may be changed on a major version bump only.
		 */
		internal_byte_order = (G_BYTE_ORDER == G_LITTLE_ENDIAN) ?
			LITTLE_ENDIAN : BIG_ENDIAN;
		break;
	case BT_CTF_BYTE_ORDER_LITTLE_ENDIAN:
		internal_byte_order = LITTLE_ENDIAN;
		break;
	case BT_CTF_BYTE_ORDER_BIG_ENDIAN:
	case BT_CTF_BYTE_ORDER_NETWORK:
		internal_byte_order = BIG_ENDIAN;
		break;
	default:
		ret = -1;
		goto end;
	}

	trace->byte_order = internal_byte_order;
end:
	return ret;
}

struct bt_ctf_field_type *bt_ctf_trace_get_packet_header_type(
		struct bt_ctf_trace *trace)
{
	struct bt_ctf_field_type *field_type = NULL;

	if (!trace) {
		goto end;
	}

	bt_ctf_field_type_get(trace->packet_header_type);
	field_type = trace->packet_header_type;
end:
	return field_type;
}

int bt_ctf_trace_set_packet_header_type(struct bt_ctf_trace *trace,
		struct bt_ctf_field_type *packet_header_type)
{
	int ret = 0;

	if (!trace || !packet_header_type || trace->frozen) {
		ret = -1;
		goto end;
	}

	/* packet_header_type must be a structure */
	if (bt_ctf_field_type_get_type_id(packet_header_type) !=
		CTF_TYPE_STRUCT) {
		ret = -1;
		goto end;
	}

	bt_ctf_field_type_get(packet_header_type);
	bt_ctf_field_type_put(trace->packet_header_type);
	trace->packet_header_type = packet_header_type;
end:
	return ret;
}

void bt_ctf_trace_get(struct bt_ctf_trace *trace)
{
	if (!trace) {
		return;
	}

	bt_ctf_ref_get(&trace->ref_count);
}

void bt_ctf_trace_put(struct bt_ctf_trace *trace)
{
	if (!trace) {
		return;
	}

	bt_ctf_ref_put(&trace->ref_count, bt_ctf_trace_destroy);
}

BT_HIDDEN
struct bt_ctf_field_type *get_field_type(enum field_type_alias alias)
{
	unsigned int alignment, size;
	struct bt_ctf_field_type *field_type;

	if (alias >= NR_FIELD_TYPE_ALIAS) {
		return NULL;
	}

	alignment = field_type_aliases_alignments[alias];
	size = field_type_aliases_sizes[alias];
	field_type = bt_ctf_field_type_integer_create(size);
	bt_ctf_field_type_set_alignment(field_type, alignment);
	return field_type;
}

static
int init_trace_packet_header(struct bt_ctf_trace *trace)
{
	int ret = 0;
	struct bt_ctf_field *magic = NULL, *uuid_array = NULL;
	struct bt_ctf_field_type *_uint32_t =
		get_field_type(FIELD_TYPE_ALIAS_UINT32_T);
	struct bt_ctf_field_type *_uint8_t =
		get_field_type(FIELD_TYPE_ALIAS_UINT8_T);
	struct bt_ctf_field_type *trace_packet_header_type =
		bt_ctf_field_type_structure_create();
	struct bt_ctf_field_type *uuid_array_type =
		bt_ctf_field_type_array_create(_uint8_t, 16);

	if (!trace_packet_header_type || !uuid_array_type) {
		ret = -1;
		goto end;
	}

	ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
		_uint32_t, "magic");
	if (ret) {
		goto end;
	}

	ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
		uuid_array_type, "uuid");
	if (ret) {
		goto end;
	}

	ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
		_uint32_t, "stream_id");
	if (ret) {
		goto end;
	}

	ret = bt_ctf_trace_set_packet_header_type(trace,
		trace_packet_header_type);
	if (ret) {
		goto end;
	}
end:
	bt_ctf_field_type_put(uuid_array_type);
	bt_ctf_field_type_put(_uint32_t);
	bt_ctf_field_type_put(_uint8_t);
	bt_ctf_field_put(magic);
	bt_ctf_field_put(uuid_array);
	bt_ctf_field_type_put(trace_packet_header_type);

	return ret;
}

static
void environment_variable_destroy(struct environment_variable *var)
{
	g_string_free(var->name, TRUE);
	if (var->type == BT_ENVIRONMENT_FIELD_TYPE_STRING) {
		g_string_free(var->value.string, TRUE);
	}
	g_free(var);
}
Commit	Line	Data
bc37ae52 JG	1	/*
	2	* trace.c
	3	*
	4	* Babeltrace CTF IR - Trace
	5	*
	6	* Copyright 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	7	*
	8	* Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
	9	*
	10	* Permission is hereby granted, free of charge, to any person obtaining a copy
	11	* of this software and associated documentation files (the "Software"), to deal
	12	* in the Software without restriction, including without limitation the rights
	13	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	14	* copies of the Software, and to permit persons to whom the Software is
	15	* furnished to do so, subject to the following conditions:
	16	*
	17	* The above copyright notice and this permission notice shall be included in
	18	* all copies or substantial portions of the Software.
	19	*
	20	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	21	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	23	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	24	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	25	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	26	* SOFTWARE.
	27	*/
	28
	29	#include <babeltrace/ctf-ir/trace-internal.h>
	30	#include <babeltrace/ctf-ir/clock-internal.h>
	31	#include <babeltrace/ctf-ir/stream-internal.h>
	32	#include <babeltrace/ctf-ir/stream-class-internal.h>
	33	#include <babeltrace/ctf-writer/functor-internal.h>
	34	#include <babeltrace/ctf-ir/event-types-internal.h>
654c1444	35	#include <babeltrace/ctf-ir/utils.h>
bc37ae52 JG	36	#include <babeltrace/compiler.h>
	37
	38	#define DEFAULT_IDENTIFIER_SIZE 128
	39	#define DEFAULT_METADATA_STRING_SIZE 4096
	40
	41	static
	42	void environment_variable_destroy(struct environment_variable *var);
	43	static
	44	void bt_ctf_trace_destroy(struct bt_ctf_ref *ref);
	45	static
	46	int init_trace_packet_header(struct bt_ctf_trace *trace);
	47
bc37ae52 JG	48	static
	49	const unsigned int field_type_aliases_alignments[] = {
	50	[FIELD_TYPE_ALIAS_UINT5_T] = 1,
	51	[FIELD_TYPE_ALIAS_UINT8_T ... FIELD_TYPE_ALIAS_UINT16_T] = 8,
	52	[FIELD_TYPE_ALIAS_UINT27_T] = 1,
	53	[FIELD_TYPE_ALIAS_UINT32_T ... FIELD_TYPE_ALIAS_UINT64_T] = 8,
	54	};
	55
	56	static
	57	const unsigned int field_type_aliases_sizes[] = {
	58	[FIELD_TYPE_ALIAS_UINT5_T] = 5,
	59	[FIELD_TYPE_ALIAS_UINT8_T] = 8,
	60	[FIELD_TYPE_ALIAS_UINT16_T] = 16,
	61	[FIELD_TYPE_ALIAS_UINT27_T] = 27,
	62	[FIELD_TYPE_ALIAS_UINT32_T] = 32,
	63	[FIELD_TYPE_ALIAS_UINT64_T] = 64,
	64	};
	65
bc37ae52 JG	66	struct bt_ctf_trace *bt_ctf_trace_create(void)
	67	{
	68	struct bt_ctf_trace *trace = NULL;
	69
	70	trace = g_new0(struct bt_ctf_trace, 1);
	71	if (!trace) {
	72	goto error;
	73	}
	74
	75	bt_ctf_trace_set_byte_order(trace, BT_CTF_BYTE_ORDER_NATIVE);
	76	bt_ctf_ref_init(&trace->ref_count);
	77	trace->environment = g_ptr_array_new_with_free_func(
	78	(GDestroyNotify)environment_variable_destroy);
	79	trace->clocks = g_ptr_array_new_with_free_func(
	80	(GDestroyNotify)bt_ctf_clock_put);
	81	trace->streams = g_ptr_array_new_with_free_func(
	82	(GDestroyNotify)bt_ctf_stream_put);
	83	trace->stream_classes = g_ptr_array_new_with_free_func(
	84	(GDestroyNotify)bt_ctf_stream_class_put);
	85	if (!trace->environment \|\| !trace->clocks \|\|
	86	!trace->stream_classes \|\| !trace->streams) {
	87	goto error_destroy;
	88	}
	89
	90	/* Generate a trace UUID */
	91	uuid_generate(trace->uuid);
	92	if (init_trace_packet_header(trace)) {
	93	goto error_destroy;
	94	}
	95
	96	return trace;
	97
	98	error_destroy:
	99	bt_ctf_trace_destroy(&trace->ref_count);
	100	trace = NULL;
	101	error:
	102	return trace;
	103	}
	104
	105	void bt_ctf_trace_destroy(struct bt_ctf_ref *ref)
	106	{
	107	struct bt_ctf_trace *trace;
	108
	109	if (!ref) {
	110	return;
	111	}
	112
	113	trace = container_of(ref, struct bt_ctf_trace, ref_count);
	114	if (trace->environment) {
	115	g_ptr_array_free(trace->environment, TRUE);
	116	}
	117
	118	if (trace->clocks) {
	119	g_ptr_array_free(trace->clocks, TRUE);
	120	}
	121
	122	if (trace->streams) {
	123	g_ptr_array_free(trace->streams, TRUE);
	124	}
	125
	126	if (trace->stream_classes) {
	127	g_ptr_array_free(trace->stream_classes, TRUE);
	128	}
	129
d246b111	130	bt_ctf_field_type_put(trace->packet_header_type);
bc37ae52 JG	131	g_free(trace);
	132	}
	133
	134	struct bt_ctf_stream bt_ctf_trace_create_stream(struct bt_ctf_trace trace,
	135	struct bt_ctf_stream_class *stream_class)
	136	{
	137	int ret;
	138	int stream_class_found = 0;
	139	size_t i;
	140	struct bt_ctf_stream *stream = NULL;
	141
	142	if (!trace \|\| !stream_class) {
	143	goto error;
	144	}
	145
d246b111	146	stream = bt_ctf_stream_create(stream_class, trace);
bc37ae52 JG	147	if (!stream) {
	148	goto error;
	149	}
	150
	151	for (i = 0; i < trace->stream_classes->len; i++) {
	152	if (trace->stream_classes->pdata[i] == stream_class) {
	153	stream_class_found = 1;
	154	}
	155	}
	156
	157	if (!stream_class_found) {
	158	int64_t stream_id = bt_ctf_stream_class_get_id(stream_class);
	159
	160	if (stream_id < 0) {
	161	/* Try to assign a new stream id */
	162	if (bt_ctf_stream_class_set_id(stream->stream_class,
	163	trace->next_stream_id++)) {
	164	goto error;
	165	}
	166	}
	167
	168	for (i = 0; i < trace->stream_classes->len; i++) {
	169	if (stream_id == bt_ctf_stream_class_get_id(
	170	trace->stream_classes->pdata[i])) {
	171	/* Duplicate stream id found */
	172	goto error;
	173	}
	174	}
	175	bt_ctf_stream_class_get(stream->stream_class);
	176	g_ptr_array_add(trace->stream_classes, stream->stream_class);
	177	}
	178
	179	bt_ctf_stream_get(stream);
	180	g_ptr_array_add(trace->streams, stream);
c35a1669 JG	181
	182	/*
	183	* Freeze the trace and its packet header.
	184	*
	185	* All field type byte orders set as "native" byte ordering can now be
	186	* safely set to trace's own endianness, including the stream class'.
	187	*/
	188	bt_ctf_field_type_set_native_byte_order(trace->packet_header_type,
	189	trace->byte_order);
	190	ret = bt_ctf_stream_class_set_byte_order(stream_class,
	191	trace->byte_order == LITTLE_ENDIAN ?
	192	BT_CTF_BYTE_ORDER_LITTLE_ENDIAN : BT_CTF_BYTE_ORDER_BIG_ENDIAN);
	193	if (ret) {
	194	goto error;
	195	}
	196
29d9d76c	197	bt_ctf_stream_class_freeze(stream_class);
bc37ae52 JG	198	trace->frozen = 1;
bc37ae52 JG	199	return stream;
bc37ae52 JG	200	error:
	201	bt_ctf_stream_put(stream);
	202	return NULL;
	203	}
	204
	205	int bt_ctf_trace_add_environment_field(struct bt_ctf_trace *trace,
	206	const char *name,
	207	const char *value)
	208	{
	209	struct environment_variable *var = NULL;
	210	char *escaped_value = NULL;
	211	int ret = 0;
	212
654c1444	213	if (!trace \|\| !name \|\| !value \|\| bt_ctf_validate_identifier(name)) {
bc37ae52 JG	214	ret = -1;
	215	goto error;
	216	}
	217
	218	if (strchr(name, ' ')) {
	219	ret = -1;
	220	goto error;
	221	}
	222
	223	var = g_new0(struct environment_variable, 1);
	224	if (!var) {
	225	ret = -1;
	226	goto error;
	227	}
	228
3487c9f3	229	var->type = BT_ENVIRONMENT_FIELD_TYPE_STRING;
bc37ae52 JG	230	escaped_value = g_strescape(value, NULL);
	231	if (!escaped_value) {
	232	ret = -1;
	233	goto error;
	234	}
	235
	236	var->name = g_string_new(name);
3487c9f3	237	var->value.string = g_string_new(escaped_value);
bc37ae52	238	g_free(escaped_value);
3487c9f3	239	if (!var->name \|\| !var->value.string) {
bc37ae52 JG	240	ret = -1;
	241	goto error;
	242	}
	243
	244	g_ptr_array_add(trace->environment, var);
	245	return ret;
	246
	247	error:
	248	if (var && var->name) {
	249	g_string_free(var->name, TRUE);
	250	}
	251
3487c9f3 JG	252	if (var && var->value.string) {
	253	g_string_free(var->value.string, TRUE);
	254	}
	255
	256	g_free(var);
	257	return ret;
	258	}
	259
	260	int bt_ctf_trace_add_environment_field_integer(struct bt_ctf_trace *trace,
	261	const char *name,
	262	int64_t value)
	263	{
	264	struct environment_variable *var = NULL;
	265	int ret = 0;
	266
	267	if (!trace \|\| !name) {
	268	ret = -1;
	269	goto error;
	270	}
	271
	272	var = g_new0(struct environment_variable, 1);
	273	if (!var) {
	274	ret = -1;
	275	goto error;
	276	}
	277
	278	var->type = BT_ENVIRONMENT_FIELD_TYPE_INTEGER;
	279	var->name = g_string_new(name);
	280	var->value.integer = value;
	281	if (!var->name) {
	282	ret = -1;
	283	goto error;
	284	}
	285
	286	g_ptr_array_add(trace->environment, var);
	287	return ret;
	288
	289	error:
	290	if (var && var->name) {
	291	g_string_free(var->name, TRUE);
bc37ae52 JG	292	}
	293
	294	g_free(var);
	295	return ret;
	296	}
	297
	298	int bt_ctf_trace_add_clock(struct bt_ctf_trace *trace,
	299	struct bt_ctf_clock *clock)
	300	{
	301	int ret = 0;
	302	struct search_query query = { .value = clock, .found = 0 };
	303
	304	if (!trace \|\| !clock) {
	305	ret = -1;
	306	goto end;
	307	}
	308
	309	/* Check for duplicate clocks */
	310	g_ptr_array_foreach(trace->clocks, value_exists, &query);
	311	if (query.found) {
	312	ret = -1;
	313	goto end;
	314	}
	315
	316	bt_ctf_clock_get(clock);
	317	g_ptr_array_add(trace->clocks, clock);
	318	end:
	319	return ret;
	320	}
	321
884cd6c3 JG	322	int bt_ctf_trace_get_clock_count(struct bt_ctf_trace *trace)
	323	{
	324	int ret = -1;
	325
	326	if (!trace) {
	327	goto end;
	328	}
	329
	330	ret = trace->clocks->len;
	331	end:
	332	return ret;
	333	}
	334
	335	struct bt_ctf_clock bt_ctf_trace_get_clock(struct bt_ctf_trace trace,
	336	int index)
	337	{
	338	struct bt_ctf_clock *clock = NULL;
	339
	340	if (!trace \|\| index < 0 \|\| index >= trace->clocks->len) {
	341	goto end;
	342	}
	343
	344	clock = g_ptr_array_index(trace->clocks, index);
	345	bt_ctf_clock_get(clock);
	346	end:
	347	return clock;
	348	}
	349
bc37ae52 JG	350	BT_HIDDEN
	351	const char *get_byte_order_string(int byte_order)
	352	{
	353	const char *string;
	354
	355	switch (byte_order) {
	356	case LITTLE_ENDIAN:
	357	string = "le";
	358	break;
	359	case BIG_ENDIAN:
	360	string = "be";
	361	break;
	362	default:
	363	string = "unknown";
	364	break;
	365	}
	366
	367	return string;
	368	}
	369
	370	static
	371	int append_trace_metadata(struct bt_ctf_trace *trace,
	372	struct metadata_context *context)
	373	{
	374	unsigned char *uuid = trace->uuid;
	375	int ret;
	376
	377	g_string_append(context->string, "trace {\n");
	378
	379	g_string_append(context->string, "\tmajor = 1;\n");
	380	g_string_append(context->string, "\tminor = 8;\n");
	381
	382	g_string_append_printf(context->string,
	383	"\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n",
	384	uuid[0], uuid[1], uuid[2], uuid[3],
	385	uuid[4], uuid[5], uuid[6], uuid[7],
	386	uuid[8], uuid[9], uuid[10], uuid[11],
	387	uuid[12], uuid[13], uuid[14], uuid[15]);
	388	g_string_append_printf(context->string, "\tbyte_order = %s;\n",
	389	get_byte_order_string(trace->byte_order));
	390
	391	g_string_append(context->string, "\tpacket.header := ");
	392	context->current_indentation_level++;
	393	g_string_assign(context->field_name, "");
d246b111	394	ret = bt_ctf_field_type_serialize(trace->packet_header_type,
bc37ae52 JG	395	context);
	396	if (ret) {
	397	goto end;
	398	}
	399	context->current_indentation_level--;
	400
	401	g_string_append(context->string, ";\n};\n\n");
	402	end:
	403	return ret;
	404	}
	405
	406	static
	407	void append_env_field_metadata(struct environment_variable *var,
	408	struct metadata_context *context)
	409	{
3487c9f3 JG	410	switch (var->type) {
	411	case BT_ENVIRONMENT_FIELD_TYPE_STRING:
	412	g_string_append_printf(context->string, "\t%s = \"%s\";\n",
	413	var->name->str, var->value.string->str);
	414	break;
	415	case BT_ENVIRONMENT_FIELD_TYPE_INTEGER:
	416	g_string_append_printf(context->string, "\t%s = %" PRId64 ";\n",
	417	var->name->str, var->value.integer);
	418	break;
	419	default:
	420	assert(0);
	421	}
bc37ae52 JG	422	}
	423
	424	static
	425	void append_env_metadata(struct bt_ctf_trace *trace,
	426	struct metadata_context *context)
	427	{
	428	if (trace->environment->len == 0) {
	429	return;
	430	}
	431
	432	g_string_append(context->string, "env {\n");
	433	g_ptr_array_foreach(trace->environment,
	434	(GFunc)append_env_field_metadata, context);
	435	g_string_append(context->string, "};\n\n");
	436	}
	437
	438	char bt_ctf_trace_get_metadata_string(struct bt_ctf_trace trace)
	439	{
	440	char *metadata = NULL;
	441	struct metadata_context *context = NULL;
	442	int err = 0;
	443	size_t i;
	444
	445	if (!trace) {
	446	goto end;
	447	}
	448
	449	context = g_new0(struct metadata_context, 1);
	450	if (!context) {
	451	goto end;
	452	}
	453
	454	context->field_name = g_string_sized_new(DEFAULT_IDENTIFIER_SIZE);
	455	context->string = g_string_sized_new(DEFAULT_METADATA_STRING_SIZE);
	456	g_string_append(context->string, "/* CTF 1.8 */\n\n");
	457	if (append_trace_metadata(trace, context)) {
	458	goto error;
	459	}
	460	append_env_metadata(trace, context);
	461	g_ptr_array_foreach(trace->clocks,
	462	(GFunc)bt_ctf_clock_serialize, context);
	463
	464	for (i = 0; i < trace->stream_classes->len; i++) {
	465	err = bt_ctf_stream_class_serialize(
	466	trace->stream_classes->pdata[i], context);
	467	if (err) {
	468	goto error;
	469	}
	470	}
	471
	472	metadata = context->string->str;
	473	error:
	474	g_string_free(context->string, err ? TRUE : FALSE);
	475	g_string_free(context->field_name, TRUE);
	476	g_free(context);
	477	end:
	478	return metadata;
	479	}
	480
	481	int bt_ctf_trace_set_byte_order(struct bt_ctf_trace *trace,
	482	enum bt_ctf_byte_order byte_order)
	483	{
	484	int ret = 0;
	485	int internal_byte_order;
486
487	if (!trace \|\| trace->frozen) {
488	ret = -1;
489	goto end;
490	}
491
492	switch (byte_order) {
493	case BT_CTF_BYTE_ORDER_NATIVE:
c35a1669 JG	494	/*
	495	* This doesn't make sense since the CTF specification defines
	496	* the "native" byte order as "the byte order described in the
	497	* trace description". However, this behavior had been
	498	* implemented as part of v1.2 and is kept to maintain
	499	* compatibility.
	500	*
	501	* This may be changed on a major version bump only.
	502	*/
	503	internal_byte_order = (G_BYTE_ORDER == G_LITTLE_ENDIAN) ?
bc37ae52 JG	504	LITTLE_ENDIAN : BIG_ENDIAN;
	505	break;
	506	case BT_CTF_BYTE_ORDER_LITTLE_ENDIAN:
	507	internal_byte_order = LITTLE_ENDIAN;
	508	break;
	509	case BT_CTF_BYTE_ORDER_BIG_ENDIAN:
	510	case BT_CTF_BYTE_ORDER_NETWORK:
	511	internal_byte_order = BIG_ENDIAN;
	512	break;
	513	default:
	514	ret = -1;
	515	goto end;
	516	}
	517
	518	trace->byte_order = internal_byte_order;
bc37ae52 JG	519	end:
	520	return ret;
	521	}
	522
d246b111 JG	523	struct bt_ctf_field_type *bt_ctf_trace_get_packet_header_type(
	524	struct bt_ctf_trace *trace)
	525	{
	526	struct bt_ctf_field_type *field_type = NULL;
	527
	528	if (!trace) {
	529	goto end;
	530	}
	531
	532	bt_ctf_field_type_get(trace->packet_header_type);
	533	field_type = trace->packet_header_type;
	534	end:
	535	return field_type;
	536	}
	537
	538	int bt_ctf_trace_set_packet_header_type(struct bt_ctf_trace *trace,
	539	struct bt_ctf_field_type *packet_header_type)
	540	{
	541	int ret = 0;
	542
	543	if (!trace \|\| !packet_header_type \|\| trace->frozen) {
	544	ret = -1;
	545	goto end;
	546	}
	547
	548	/* packet_header_type must be a structure */
	549	if (bt_ctf_field_type_get_type_id(packet_header_type) !=
	550	CTF_TYPE_STRUCT) {
	551	ret = -1;
	552	goto end;
	553	}
	554
	555	bt_ctf_field_type_get(packet_header_type);
	556	bt_ctf_field_type_put(trace->packet_header_type);
	557	trace->packet_header_type = packet_header_type;
	558	end:
	559	return ret;
	560	}
	561
bc37ae52 JG	562	void bt_ctf_trace_get(struct bt_ctf_trace *trace)
	563	{
	564	if (!trace) {
	565	return;
	566	}
	567
	568	bt_ctf_ref_get(&trace->ref_count);
	569	}
	570
	571	void bt_ctf_trace_put(struct bt_ctf_trace *trace)
	572	{
	573	if (!trace) {
	574	return;
	575	}
	576
	577	bt_ctf_ref_put(&trace->ref_count, bt_ctf_trace_destroy);
	578	}
	579
bc37ae52 JG	580	BT_HIDDEN
	581	struct bt_ctf_field_type *get_field_type(enum field_type_alias alias)
	582	{
	583	unsigned int alignment, size;
	584	struct bt_ctf_field_type *field_type;
	585
	586	if (alias >= NR_FIELD_TYPE_ALIAS) {
	587	return NULL;
	588	}
	589
	590	alignment = field_type_aliases_alignments[alias];
	591	size = field_type_aliases_sizes[alias];
	592	field_type = bt_ctf_field_type_integer_create(size);
	593	bt_ctf_field_type_set_alignment(field_type, alignment);
	594	return field_type;
	595	}
	596
	597	static
	598	int init_trace_packet_header(struct bt_ctf_trace *trace)
	599	{
bc37ae52	600	int ret = 0;
d246b111	601	struct bt_ctf_field magic = NULL, uuid_array = NULL;
bc37ae52 JG	602	struct bt_ctf_field_type *_uint32_t =
	603	get_field_type(FIELD_TYPE_ALIAS_UINT32_T);
	604	struct bt_ctf_field_type *_uint8_t =
	605	get_field_type(FIELD_TYPE_ALIAS_UINT8_T);
	606	struct bt_ctf_field_type *trace_packet_header_type =
	607	bt_ctf_field_type_structure_create();
	608	struct bt_ctf_field_type *uuid_array_type =
	609	bt_ctf_field_type_array_create(_uint8_t, 16);
	610
	611	if (!trace_packet_header_type \|\| !uuid_array_type) {
	612	ret = -1;
	613	goto end;
	614	}
	615
bc37ae52 JG	616	ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
	617	_uint32_t, "magic");
	618	if (ret) {
	619	goto end;
	620	}
	621
	622	ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
	623	uuid_array_type, "uuid");
	624	if (ret) {
	625	goto end;
	626	}
	627
	628	ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
	629	_uint32_t, "stream_id");
	630	if (ret) {
	631	goto end;
	632	}
	633
662e778c JG	634	ret = bt_ctf_trace_set_packet_header_type(trace,
	635	trace_packet_header_type);
	636	if (ret) {
	637	goto end;
	638	}
bc37ae52 JG	639	end:
	640	bt_ctf_field_type_put(uuid_array_type);
	641	bt_ctf_field_type_put(_uint32_t);
	642	bt_ctf_field_type_put(_uint8_t);
	643	bt_ctf_field_put(magic);
	644	bt_ctf_field_put(uuid_array);
662e778c	645	bt_ctf_field_type_put(trace_packet_header_type);
bc37ae52 JG	646
	647	return ret;
	648	}
	649
	650	static
	651	void environment_variable_destroy(struct environment_variable *var)
	652	{
	653	g_string_free(var->name, TRUE);
3487c9f3 JG	654	if (var->type == BT_ENVIRONMENT_FIELD_TYPE_STRING) {
	655	g_string_free(var->value.string, TRUE);
	656	}
bc37ae52 JG	657	g_free(var);
bc37ae52 JG	658	}