[babeltrace.git] / formats / ctf / ir / stream-class.c

/*
 * stream-class.c
 *
 * Babeltrace CTF IR - Stream Class
 *
 * Copyright 2013, 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-writer/clock.h>
#include <babeltrace/ctf-ir/clock-internal.h>
#include <babeltrace/ctf-writer/event.h>
#include <babeltrace/ctf-ir/event-internal.h>
#include <babeltrace/ctf-ir/event-types-internal.h>
#include <babeltrace/ctf-ir/event-fields-internal.h>
#include <babeltrace/ctf-writer/stream.h>
#include <babeltrace/ctf-ir/stream-class-internal.h>
#include <babeltrace/ctf-writer/functor-internal.h>
#include <babeltrace/compiler.h>
#include <babeltrace/align.h>

static
void bt_ctf_stream_class_destroy(struct bt_ctf_ref *ref);
static
int init_event_header(struct bt_ctf_stream_class *stream_class,
		enum bt_ctf_byte_order byte_order);
static
int init_packet_context(struct bt_ctf_stream_class *stream_class,
		enum bt_ctf_byte_order byte_order);

struct bt_ctf_stream_class *bt_ctf_stream_class_create(const char *name)
{
	int ret;
	struct bt_ctf_stream_class *stream_class = NULL;

	if (!name || !strlen(name)) {
		goto error;
	}

	stream_class = g_new0(struct bt_ctf_stream_class, 1);
	if (!stream_class) {
		goto error;
	}

	stream_class->name = g_string_new(name);
	stream_class->event_classes = g_ptr_array_new_with_free_func(
		(GDestroyNotify)bt_ctf_event_class_put);
	if (!stream_class->event_classes) {
		goto error_destroy;
	}

	ret = init_packet_context(stream_class, BT_CTF_BYTE_ORDER_NATIVE);
	if (ret) {
		goto error_destroy;
	}

	bt_ctf_ref_init(&stream_class->ref_count);
	return stream_class;

error_destroy:
	bt_ctf_stream_class_destroy(&stream_class->ref_count);
	stream_class = NULL;
error:
	return stream_class;
}

const char *bt_ctf_stream_class_get_name(
		struct bt_ctf_stream_class *stream_class)
{
	const char *name = NULL;

	if (!stream_class) {
		goto end;
	}

	name = stream_class->name->str;
end:
	return name;
}

struct bt_ctf_clock *bt_ctf_stream_class_get_clock(
		struct bt_ctf_stream_class *stream_class)
{
	struct bt_ctf_clock *clock = NULL;

	if (!stream_class || !stream_class->clock) {
		goto end;
	}

	clock = stream_class->clock;
	bt_ctf_clock_get(clock);
end:
	return clock;
}

int bt_ctf_stream_class_set_clock(struct bt_ctf_stream_class *stream_class,
		struct bt_ctf_clock *clock)
{
	int ret = 0;

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

	if (stream_class->clock) {
		bt_ctf_clock_put(stream_class->clock);
	}

	stream_class->clock = clock;
	bt_ctf_clock_get(clock);
end:
	return ret;
}

int64_t bt_ctf_stream_class_get_id(struct bt_ctf_stream_class *stream_class)
{
	int64_t ret;

	if (!stream_class || !stream_class->id_set) {
		ret = -1;
		goto end;
	}

	ret = (int64_t) stream_class->id;
end:
	return ret;
}

int bt_ctf_stream_class_set_id(struct bt_ctf_stream_class *stream_class,
		uint32_t id)
{
	int ret = 0;

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

	stream_class->id = id;
	stream_class->id_set = 1;
end:
	return ret;
}

int bt_ctf_stream_class_add_event_class(
		struct bt_ctf_stream_class *stream_class,
		struct bt_ctf_event_class *event_class)
{
	int ret = 0;
	int64_t event_id;

	if (!stream_class || !event_class) {
		ret = -1;
		goto end;
	}

	/* Check for duplicate event classes */
	struct search_query query = { .value = event_class, .found = 0 };
	g_ptr_array_foreach(stream_class->event_classes, value_exists, &query);
	if (query.found) {
		ret = -1;
		goto end;
	}

	/* Only set an event id if none was explicitly set before */
	event_id = bt_ctf_event_class_get_id(event_class);
	if (event_id < 0) {
		if (bt_ctf_event_class_set_id(event_class,
			stream_class->next_event_id++)) {
			ret = -1;
			goto end;
		}
	}

	ret = bt_ctf_event_class_set_stream_class(event_class, stream_class);
	if (ret) {
		goto end;
	}

	bt_ctf_event_class_get(event_class);
	g_ptr_array_add(stream_class->event_classes, event_class);
end:
	return ret;
}

int bt_ctf_stream_class_get_event_class_count(
		struct bt_ctf_stream_class *stream_class)
{
	int ret;

	if (!stream_class) {
		ret = -1;
		goto end;
	}

	ret = (int) stream_class->event_classes->len;
end:
	return ret;
}

struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class(
		struct bt_ctf_stream_class *stream_class, int index)
{
	struct bt_ctf_event_class *event_class = NULL;

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

	event_class = g_ptr_array_index(stream_class->event_classes, index);
	bt_ctf_event_class_get(event_class);
end:
	return event_class;
}

struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class_by_name(
		struct bt_ctf_stream_class *stream_class, const char *name)
{
	size_t i;
	GQuark name_quark;
	struct bt_ctf_event_class *event_class = NULL;

	if (!stream_class || !name) {
		goto end;
	}

	name_quark = g_quark_try_string(name);
	if (!name_quark) {
		goto end;
	}

	for (i = 0; i < stream_class->event_classes->len; i++) {
		struct bt_ctf_event_class *current_event_class =
			g_ptr_array_index(stream_class->event_classes, i);

		if (name_quark == current_event_class->name) {
			event_class = current_event_class;
			bt_ctf_event_class_get(event_class);
			goto end;
		}
	}
end:
	return event_class;
}

struct bt_ctf_field_type *bt_ctf_stream_class_get_packet_context_type(
		struct bt_ctf_stream_class *stream_class)
{
	struct bt_ctf_field_type *ret = NULL;

	if (!stream_class) {
		goto end;
	}

	assert(stream_class->packet_context_type);
	bt_ctf_field_type_get(stream_class->packet_context_type);
	ret = stream_class->packet_context_type;
end:
	return ret;
}

int bt_ctf_stream_class_set_packet_context_type(
		struct bt_ctf_stream_class *stream_class,
		struct bt_ctf_field_type *packet_context_type)
{
	int ret = 0;

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

	assert(stream_class->packet_context_type);
	if (bt_ctf_field_type_get_type_id(packet_context_type) !=
		CTF_TYPE_STRUCT) {
		/* A packet context must be a structure */
		ret = -1;
		goto end;
	}

	bt_ctf_field_type_put(stream_class->packet_context_type);
	bt_ctf_field_type_get(packet_context_type);
	stream_class->packet_context_type = packet_context_type;
end:
	return ret;
}

struct bt_ctf_field_type *bt_ctf_stream_class_get_event_context_type(
		struct bt_ctf_stream_class *stream_class)
{
	struct bt_ctf_field_type *ret = NULL;

	if (!stream_class || !stream_class->event_context_type) {
		goto end;
	}

	assert(stream_class->event_context_type);
	bt_ctf_field_type_get(stream_class->event_context_type);
	ret = stream_class->event_context_type;
end:
	return ret;
}

int bt_ctf_stream_class_set_event_context_type(
		struct bt_ctf_stream_class *stream_class,
		struct bt_ctf_field_type *event_context_type)
{
	int ret = 0;

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

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

	bt_ctf_field_type_put(stream_class->event_context_type);
	bt_ctf_field_type_get(event_context_type);
	stream_class->event_context_type = event_context_type;
end:
	return ret;
}

void bt_ctf_stream_class_get(struct bt_ctf_stream_class *stream_class)
{
	if (!stream_class) {
		return;
	}

	bt_ctf_ref_get(&stream_class->ref_count);
}

void bt_ctf_stream_class_put(struct bt_ctf_stream_class *stream_class)
{
	if (!stream_class) {
		return;
	}

	bt_ctf_ref_put(&stream_class->ref_count, bt_ctf_stream_class_destroy);
}

BT_HIDDEN
void bt_ctf_stream_class_freeze(struct bt_ctf_stream_class *stream_class)
{
	if (!stream_class) {
		return;
	}

	stream_class->frozen = 1;
	bt_ctf_field_type_freeze(stream_class->packet_context_type);
	bt_ctf_field_type_freeze(stream_class->event_context_type);
	bt_ctf_clock_freeze(stream_class->clock);
	g_ptr_array_foreach(stream_class->event_classes,
		(GFunc)bt_ctf_event_class_freeze, NULL);
}

BT_HIDDEN
int bt_ctf_stream_class_set_byte_order(struct bt_ctf_stream_class *stream_class,
	enum bt_ctf_byte_order byte_order)
{
	int ret = 0;

	ret = init_event_header(stream_class, byte_order);
	if (ret) {
		goto end;
	}
end:
	return ret;
}

BT_HIDDEN
int bt_ctf_stream_class_serialize(struct bt_ctf_stream_class *stream_class,
		struct metadata_context *context)
{
	int64_t ret = 0;
	size_t i;

	g_string_assign(context->field_name, "");
	context->current_indentation_level = 1;
	if (!stream_class->id_set) {
		ret = -1;
		goto end;
	}

	g_string_append_printf(context->string,
		"stream {\n\tid = %" PRIu32 ";\n\tevent.header := ",
		stream_class->id);
	ret = bt_ctf_field_type_serialize(stream_class->event_header_type,
		context);
	if (ret) {
		goto end;
	}

	g_string_append(context->string, ";\n\n\tpacket.context := ");
	ret = bt_ctf_field_type_serialize(stream_class->packet_context_type,
		context);
	if (ret) {
		goto end;
	}

	if (stream_class->event_context_type) {
		g_string_append(context->string, ";\n\n\tevent.context := ");
		ret = bt_ctf_field_type_serialize(
			stream_class->event_context_type, context);
		if (ret) {
			goto end;
		}
	}

	g_string_append(context->string, ";\n};\n\n");
	for (i = 0; i < stream_class->event_classes->len; i++) {
		struct bt_ctf_event_class *event_class =
			stream_class->event_classes->pdata[i];

		ret = bt_ctf_event_class_serialize(event_class, context);
		if (ret) {
			goto end;
		}
	}
end:
	context->current_indentation_level = 0;
	return ret;
}

static
void bt_ctf_stream_class_destroy(struct bt_ctf_ref *ref)
{
	struct bt_ctf_stream_class *stream_class;

	if (!ref) {
		return;
	}

	stream_class = container_of(ref, struct bt_ctf_stream_class, ref_count);
	bt_ctf_clock_put(stream_class->clock);

	if (stream_class->event_classes) {
		size_t i;

		/* Unregister this stream class from the event classes */
		for (i = 0; i < stream_class->event_classes->len; i++) {
			struct bt_ctf_event_class *event_class =
				g_ptr_array_index(stream_class->event_classes,
				i);

			bt_ctf_event_class_set_stream_class(event_class, NULL);
		}

		g_ptr_array_free(stream_class->event_classes, TRUE);
	}

	if (stream_class->name) {
		g_string_free(stream_class->name, TRUE);
	}

	bt_ctf_field_type_put(stream_class->event_header_type);
	bt_ctf_field_put(stream_class->event_header);
	bt_ctf_field_type_put(stream_class->packet_context_type);
	if (stream_class->event_context_type) {
		bt_ctf_field_type_put(stream_class->event_context_type);
	}
	g_free(stream_class);
}

static
int init_event_header(struct bt_ctf_stream_class *stream_class,
		enum bt_ctf_byte_order byte_order)
{
	int ret = 0;
	struct bt_ctf_field_type *event_header_type =
		bt_ctf_field_type_structure_create();
	struct bt_ctf_field_type *_uint32_t =
		get_field_type(FIELD_TYPE_ALIAS_UINT32_T);
	struct bt_ctf_field_type *_uint64_t =
		get_field_type(FIELD_TYPE_ALIAS_UINT64_T);

	if (!event_header_type) {
		ret = -1;
		goto end;
	}

	ret = bt_ctf_field_type_set_byte_order(_uint32_t, byte_order);
	if (ret) {
		goto end;
	}

	ret = bt_ctf_field_type_set_byte_order(_uint64_t, byte_order);
	if (ret) {
		goto end;
	}

	ret = bt_ctf_field_type_structure_add_field(event_header_type,
		_uint32_t, "id");
	if (ret) {
		goto end;
	}

	ret = bt_ctf_field_type_structure_add_field(event_header_type,
		_uint64_t, "timestamp");
	if (ret) {
		goto end;
	}

	stream_class->event_header_type = event_header_type;
	stream_class->event_header = bt_ctf_field_create(
		stream_class->event_header_type);
	if (!stream_class->event_header) {
		ret = -1;
	}
end:
	if (ret) {
		bt_ctf_field_type_put(event_header_type);
	}

	bt_ctf_field_type_put(_uint32_t);
	bt_ctf_field_type_put(_uint64_t);
	return ret;
}

static
int init_packet_context(struct bt_ctf_stream_class *stream_class,
		enum bt_ctf_byte_order byte_order)
{
	int ret = 0;
	struct bt_ctf_field_type *packet_context_type =
		bt_ctf_field_type_structure_create();
	struct bt_ctf_field_type *_uint64_t =
		get_field_type(FIELD_TYPE_ALIAS_UINT64_T);

	if (!packet_context_type) {
		ret = -1;
		goto end;
	}

	/*
	 * We create a stream packet context as proposed in the CTF
	 * specification.
	 */
	ret = bt_ctf_field_type_set_byte_order(_uint64_t, byte_order);
	if (ret) {
		goto end;
	}

	ret = bt_ctf_field_type_structure_add_field(packet_context_type,
		_uint64_t, "timestamp_begin");
	if (ret) {
		goto end;
	}

	ret = bt_ctf_field_type_structure_add_field(packet_context_type,
		_uint64_t, "timestamp_end");
	if (ret) {
		goto end;
	}

	ret = bt_ctf_field_type_structure_add_field(packet_context_type,
		_uint64_t, "content_size");
	if (ret) {
		goto end;
	}

	ret = bt_ctf_field_type_structure_add_field(packet_context_type,
		_uint64_t, "packet_size");
	if (ret) {
		goto end;
	}

	ret = bt_ctf_field_type_structure_add_field(packet_context_type,
		_uint64_t, "events_discarded");
	if (ret) {
		goto end;
	}

	stream_class->packet_context_type = packet_context_type;
end:
	if (ret) {
		bt_ctf_field_type_put(packet_context_type);
		goto end;
	}

	bt_ctf_field_type_put(_uint64_t);
	return ret;
}
Commit	Line	Data
11b0cdc8	1	/*
3f043b05	2	* stream-class.c
11b0cdc8	3	*
d2dc44b6	4	* Babeltrace CTF IR - Stream Class
11b0cdc8	5	*
de9dd397	6	* Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
11b0cdc8 JG	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-writer/clock.h>
	30	#include <babeltrace/ctf-ir/clock-internal.h>
	31	#include <babeltrace/ctf-writer/event.h>
	32	#include <babeltrace/ctf-ir/event-internal.h>
	33	#include <babeltrace/ctf-ir/event-types-internal.h>
	34	#include <babeltrace/ctf-ir/event-fields-internal.h>
	35	#include <babeltrace/ctf-writer/stream.h>
	36	#include <babeltrace/ctf-ir/stream-class-internal.h>
	37	#include <babeltrace/ctf-writer/functor-internal.h>
	38	#include <babeltrace/compiler.h>
	39	#include <babeltrace/align.h>
	40
	41	static
	42	void bt_ctf_stream_class_destroy(struct bt_ctf_ref *ref);
	43	static
	44	int init_event_header(struct bt_ctf_stream_class *stream_class,
	45	enum bt_ctf_byte_order byte_order);
	46	static
	47	int init_packet_context(struct bt_ctf_stream_class *stream_class,
	48	enum bt_ctf_byte_order byte_order);
	49
	50	struct bt_ctf_stream_class bt_ctf_stream_class_create(const char name)
	51	{
12c8a1a3	52	int ret;
11b0cdc8 JG	53	struct bt_ctf_stream_class *stream_class = NULL;
	54
	55	if (!name \|\| !strlen(name)) {
	56	goto error;
	57	}
	58
	59	stream_class = g_new0(struct bt_ctf_stream_class, 1);
	60	if (!stream_class) {
	61	goto error;
	62	}
	63
	64	stream_class->name = g_string_new(name);
	65	stream_class->event_classes = g_ptr_array_new_with_free_func(
	66	(GDestroyNotify)bt_ctf_event_class_put);
	67	if (!stream_class->event_classes) {
	68	goto error_destroy;
	69	}
	70
12c8a1a3 JG	71	ret = init_packet_context(stream_class, BT_CTF_BYTE_ORDER_NATIVE);
	72	if (ret) {
	73	goto error_destroy;
	74	}
	75
11b0cdc8 JG	76	bt_ctf_ref_init(&stream_class->ref_count);
	77	return stream_class;
	78
	79	error_destroy:
	80	bt_ctf_stream_class_destroy(&stream_class->ref_count);
	81	stream_class = NULL;
	82	error:
	83	return stream_class;
	84	}
	85
69dc4535 JG	86	const char *bt_ctf_stream_class_get_name(
	87	struct bt_ctf_stream_class *stream_class)
	88	{
	89	const char *name = NULL;
	90
	91	if (!stream_class) {
	92	goto end;
	93	}
	94
	95	name = stream_class->name->str;
	96	end:
	97	return name;
	98	}
	99
2f100782 JG	100	struct bt_ctf_clock *bt_ctf_stream_class_get_clock(
	101	struct bt_ctf_stream_class *stream_class)
	102	{
	103	struct bt_ctf_clock *clock = NULL;
	104
	105	if (!stream_class \|\| !stream_class->clock) {
	106	goto end;
	107	}
	108
	109	clock = stream_class->clock;
	110	bt_ctf_clock_get(clock);
	111	end:
	112	return clock;
	113	}
	114
11b0cdc8 JG	115	int bt_ctf_stream_class_set_clock(struct bt_ctf_stream_class *stream_class,
	116	struct bt_ctf_clock *clock)
	117	{
	118	int ret = 0;
	119
	120	if (!stream_class \|\| !clock \|\| stream_class->frozen) {
	121	ret = -1;
	122	goto end;
	123	}
	124
	125	if (stream_class->clock) {
	126	bt_ctf_clock_put(stream_class->clock);
	127	}
	128
	129	stream_class->clock = clock;
	130	bt_ctf_clock_get(clock);
	131	end:
	132	return ret;
	133	}
	134
2f100782 JG	135	int64_t bt_ctf_stream_class_get_id(struct bt_ctf_stream_class *stream_class)
	136	{
	137	int64_t ret;
	138
	139	if (!stream_class \|\| !stream_class->id_set) {
	140	ret = -1;
	141	goto end;
	142	}
	143
	144	ret = (int64_t) stream_class->id;
	145	end:
	146	return ret;
	147	}
	148
	149	int bt_ctf_stream_class_set_id(struct bt_ctf_stream_class *stream_class,
	150	uint32_t id)
	151	{
	152	int ret = 0;
	153
739a93c7	154	if (!stream_class \|\| stream_class->frozen) {
2f100782 JG	155	ret = -1;
	156	goto end;
	157	}
	158
	159	stream_class->id = id;
	160	stream_class->id_set = 1;
	161	end:
	162	return ret;
	163	}
	164
11b0cdc8 JG	165	int bt_ctf_stream_class_add_event_class(
	166	struct bt_ctf_stream_class *stream_class,
	167	struct bt_ctf_event_class *event_class)
	168	{
	169	int ret = 0;
2f100782	170	int64_t event_id;
11b0cdc8 JG	171
	172	if (!stream_class \|\| !event_class) {
	173	ret = -1;
	174	goto end;
	175	}
	176
	177	/* Check for duplicate event classes */
	178	struct search_query query = { .value = event_class, .found = 0 };
	179	g_ptr_array_foreach(stream_class->event_classes, value_exists, &query);
	180	if (query.found) {
	181	ret = -1;
	182	goto end;
	183	}
	184
2f100782 JG	185	/* Only set an event id if none was explicitly set before */
	186	event_id = bt_ctf_event_class_get_id(event_class);
	187	if (event_id < 0) {
	188	if (bt_ctf_event_class_set_id(event_class,
	189	stream_class->next_event_id++)) {
	190	ret = -1;
	191	goto end;
	192	}
	193	}
	194
	195	ret = bt_ctf_event_class_set_stream_class(event_class, stream_class);
	196	if (ret) {
11b0cdc8 JG	197	goto end;
	198	}
	199
	200	bt_ctf_event_class_get(event_class);
	201	g_ptr_array_add(stream_class->event_classes, event_class);
	202	end:
	203	return ret;
	204	}
	205
074ee56d	206	int bt_ctf_stream_class_get_event_class_count(
69dc4535 JG	207	struct bt_ctf_stream_class *stream_class)
69dc4535 JG	208	{
074ee56d	209	int ret;
69dc4535 JG	210
	211	if (!stream_class) {
	212	ret = -1;
	213	goto end;
	214	}
	215
074ee56d	216	ret = (int) stream_class->event_classes->len;
69dc4535 JG	217	end:
	218	return ret;
	219	}
	220
	221	struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class(
074ee56d	222	struct bt_ctf_stream_class *stream_class, int index)
69dc4535 JG	223	{
	224	struct bt_ctf_event_class *event_class = NULL;
	225
074ee56d JG	226	if (!stream_class \|\| index < 0 \|\|
074ee56d JG	227	index >= stream_class->event_classes->len) {
69dc4535 JG	228	goto end;
	229	}
	230
	231	event_class = g_ptr_array_index(stream_class->event_classes, index);
	232	bt_ctf_event_class_get(event_class);
	233	end:
	234	return event_class;
	235	}
	236
	237	struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class_by_name(
	238	struct bt_ctf_stream_class stream_class, const char name)
	239	{
	240	size_t i;
	241	GQuark name_quark;
	242	struct bt_ctf_event_class *event_class = NULL;
	243
	244	if (!stream_class \|\| !name) {
	245	goto end;
	246	}
	247
	248	name_quark = g_quark_try_string(name);
	249	if (!name_quark) {
	250	goto end;
	251	}
	252
	253	for (i = 0; i < stream_class->event_classes->len; i++) {
	254	struct bt_ctf_event_class *current_event_class =
	255	g_ptr_array_index(stream_class->event_classes, i);
	256
	257	if (name_quark == current_event_class->name) {
	258	event_class = current_event_class;
	259	bt_ctf_event_class_get(event_class);
	260	goto end;
	261	}
	262	}
	263	end:
	264	return event_class;
	265	}
	266
12c8a1a3 JG	267	struct bt_ctf_field_type *bt_ctf_stream_class_get_packet_context_type(
	268	struct bt_ctf_stream_class *stream_class)
	269	{
	270	struct bt_ctf_field_type *ret = NULL;
	271
	272	if (!stream_class) {
	273	goto end;
	274	}
	275
	276	assert(stream_class->packet_context_type);
	277	bt_ctf_field_type_get(stream_class->packet_context_type);
	278	ret = stream_class->packet_context_type;
	279	end:
	280	return ret;
	281	}
	282
	283	int bt_ctf_stream_class_set_packet_context_type(
	284	struct bt_ctf_stream_class *stream_class,
	285	struct bt_ctf_field_type *packet_context_type)
	286	{
	287	int ret = 0;
	288
0a00bfa1	289	if (!stream_class \|\| !packet_context_type \|\| stream_class->frozen) {
12c8a1a3 JG	290	ret = -1;
	291	goto end;
	292	}
	293
	294	assert(stream_class->packet_context_type);
b34f4d90	295	if (bt_ctf_field_type_get_type_id(packet_context_type) !=
12c8a1a3 JG	296	CTF_TYPE_STRUCT) {
	297	/* A packet context must be a structure */
	298	ret = -1;
	299	goto end;
	300	}
	301
	302	bt_ctf_field_type_put(stream_class->packet_context_type);
	303	bt_ctf_field_type_get(packet_context_type);
	304	stream_class->packet_context_type = packet_context_type;
	305	end:
	306	return ret;
	307	}
	308
af181248 JG	309	struct bt_ctf_field_type *bt_ctf_stream_class_get_event_context_type(
	310	struct bt_ctf_stream_class *stream_class)
	311	{
	312	struct bt_ctf_field_type *ret = NULL;
	313
	314	if (!stream_class \|\| !stream_class->event_context_type) {
	315	goto end;
	316	}
	317
	318	assert(stream_class->event_context_type);
	319	bt_ctf_field_type_get(stream_class->event_context_type);
	320	ret = stream_class->event_context_type;
	321	end:
	322	return ret;
	323	}
	324
	325	int bt_ctf_stream_class_set_event_context_type(
	326	struct bt_ctf_stream_class *stream_class,
	327	struct bt_ctf_field_type *event_context_type)
	328	{
	329	int ret = 0;
	330
	331	if (!stream_class \|\| !event_context_type \|\| stream_class->frozen) {
	332	ret = -1;
	333	goto end;
	334	}
	335
	336	if (bt_ctf_field_type_get_type_id(event_context_type) !=
	337	CTF_TYPE_STRUCT) {
	338	/* A packet context must be a structure */
	339	ret = -1;
	340	goto end;
	341	}
	342
	343	bt_ctf_field_type_put(stream_class->event_context_type);
	344	bt_ctf_field_type_get(event_context_type);
	345	stream_class->event_context_type = event_context_type;
	346	end:
	347	return ret;
	348	}
	349
11b0cdc8 JG	350	void bt_ctf_stream_class_get(struct bt_ctf_stream_class *stream_class)
	351	{
	352	if (!stream_class) {
	353	return;
	354	}
	355
	356	bt_ctf_ref_get(&stream_class->ref_count);
	357	}
	358
	359	void bt_ctf_stream_class_put(struct bt_ctf_stream_class *stream_class)
	360	{
	361	if (!stream_class) {
	362	return;
	363	}
	364
	365	bt_ctf_ref_put(&stream_class->ref_count, bt_ctf_stream_class_destroy);
	366	}
	367
	368	BT_HIDDEN
	369	void bt_ctf_stream_class_freeze(struct bt_ctf_stream_class *stream_class)
	370	{
	371	if (!stream_class) {
	372	return;
	373	}
	374
	375	stream_class->frozen = 1;
12c8a1a3	376	bt_ctf_field_type_freeze(stream_class->packet_context_type);
af181248	377	bt_ctf_field_type_freeze(stream_class->event_context_type);
11b0cdc8 JG	378	bt_ctf_clock_freeze(stream_class->clock);
	379	g_ptr_array_foreach(stream_class->event_classes,
	380	(GFunc)bt_ctf_event_class_freeze, NULL);
	381	}
	382
11b0cdc8 JG	383	BT_HIDDEN
	384	int bt_ctf_stream_class_set_byte_order(struct bt_ctf_stream_class *stream_class,
	385	enum bt_ctf_byte_order byte_order)
	386	{
	387	int ret = 0;
	388
11b0cdc8 JG	389	ret = init_event_header(stream_class, byte_order);
	390	if (ret) {
	391	goto end;
	392	}
	393	end:
	394	return ret;
	395	}
	396
	397	BT_HIDDEN
	398	int bt_ctf_stream_class_serialize(struct bt_ctf_stream_class *stream_class,
	399	struct metadata_context *context)
	400	{
2f100782	401	int64_t ret = 0;
11b0cdc8 JG	402	size_t i;
	403
	404	g_string_assign(context->field_name, "");
	405	context->current_indentation_level = 1;
	406	if (!stream_class->id_set) {
	407	ret = -1;
	408	goto end;
	409	}
	410
	411	g_string_append_printf(context->string,
	412	"stream {\n\tid = %" PRIu32 ";\n\tevent.header := ",
	413	stream_class->id);
	414	ret = bt_ctf_field_type_serialize(stream_class->event_header_type,
	415	context);
	416	if (ret) {
	417	goto end;
	418	}
	419
	420	g_string_append(context->string, ";\n\n\tpacket.context := ");
	421	ret = bt_ctf_field_type_serialize(stream_class->packet_context_type,
	422	context);
	423	if (ret) {
	424	goto end;
	425	}
	426
	427	if (stream_class->event_context_type) {
	428	g_string_append(context->string, ";\n\n\tevent.context := ");
	429	ret = bt_ctf_field_type_serialize(
	430	stream_class->event_context_type, context);
	431	if (ret) {
	432	goto end;
	433	}
	434	}
	435
	436	g_string_append(context->string, ";\n};\n\n");
11b0cdc8 JG	437	for (i = 0; i < stream_class->event_classes->len; i++) {
	438	struct bt_ctf_event_class *event_class =
	439	stream_class->event_classes->pdata[i];
	440
11b0cdc8 JG	441	ret = bt_ctf_event_class_serialize(event_class, context);
	442	if (ret) {
	443	goto end;
	444	}
	445	}
	446	end:
	447	context->current_indentation_level = 0;
	448	return ret;
	449	}
	450
	451	static
	452	void bt_ctf_stream_class_destroy(struct bt_ctf_ref *ref)
	453	{
	454	struct bt_ctf_stream_class *stream_class;
	455
	456	if (!ref) {
	457	return;
	458	}
	459
	460	stream_class = container_of(ref, struct bt_ctf_stream_class, ref_count);
	461	bt_ctf_clock_put(stream_class->clock);
	462
	463	if (stream_class->event_classes) {
2f100782 JG	464	size_t i;
	465
	466	/* Unregister this stream class from the event classes */
	467	for (i = 0; i < stream_class->event_classes->len; i++) {
	468	struct bt_ctf_event_class *event_class =
	469	g_ptr_array_index(stream_class->event_classes,
	470	i);
	471
	472	bt_ctf_event_class_set_stream_class(event_class, NULL);
	473	}
	474
11b0cdc8 JG	475	g_ptr_array_free(stream_class->event_classes, TRUE);
	476	}
	477
	478	if (stream_class->name) {
	479	g_string_free(stream_class->name, TRUE);
	480	}
	481
	482	bt_ctf_field_type_put(stream_class->event_header_type);
	483	bt_ctf_field_put(stream_class->event_header);
	484	bt_ctf_field_type_put(stream_class->packet_context_type);
af181248 JG	485	if (stream_class->event_context_type) {
	486	bt_ctf_field_type_put(stream_class->event_context_type);
	487	}
11b0cdc8 JG	488	g_free(stream_class);
	489	}
	490
	491	static
	492	int init_event_header(struct bt_ctf_stream_class *stream_class,
	493	enum bt_ctf_byte_order byte_order)
	494	{
	495	int ret = 0;
	496	struct bt_ctf_field_type *event_header_type =
	497	bt_ctf_field_type_structure_create();
	498	struct bt_ctf_field_type *_uint32_t =
	499	get_field_type(FIELD_TYPE_ALIAS_UINT32_T);
	500	struct bt_ctf_field_type *_uint64_t =
	501	get_field_type(FIELD_TYPE_ALIAS_UINT64_T);
	502
	503	if (!event_header_type) {
	504	ret = -1;
	505	goto end;
	506	}
	507
	508	ret = bt_ctf_field_type_set_byte_order(_uint32_t, byte_order);
	509	if (ret) {
	510	goto end;
	511	}
	512
	513	ret = bt_ctf_field_type_set_byte_order(_uint64_t, byte_order);
	514	if (ret) {
	515	goto end;
	516	}
	517
	518	ret = bt_ctf_field_type_structure_add_field(event_header_type,
	519	_uint32_t, "id");
	520	if (ret) {
	521	goto end;
	522	}
	523
	524	ret = bt_ctf_field_type_structure_add_field(event_header_type,
	525	_uint64_t, "timestamp");
	526	if (ret) {
	527	goto end;
	528	}
	529
	530	stream_class->event_header_type = event_header_type;
	531	stream_class->event_header = bt_ctf_field_create(
	532	stream_class->event_header_type);
	533	if (!stream_class->event_header) {
	534	ret = -1;
	535	}
	536	end:
	537	if (ret) {
	538	bt_ctf_field_type_put(event_header_type);
	539	}
	540
	541	bt_ctf_field_type_put(_uint32_t);
	542	bt_ctf_field_type_put(_uint64_t);
	543	return ret;
	544	}
	545
	546	static
	547	int init_packet_context(struct bt_ctf_stream_class *stream_class,
	548	enum bt_ctf_byte_order byte_order)
	549	{
	550	int ret = 0;
	551	struct bt_ctf_field_type *packet_context_type =
552	bt_ctf_field_type_structure_create();
553	struct bt_ctf_field_type *_uint64_t =
554	get_field_type(FIELD_TYPE_ALIAS_UINT64_T);
555
556	if (!packet_context_type) {
557	ret = -1;
558	goto end;
559	}
560
561	/*
562	* We create a stream packet context as proposed in the CTF
563	* specification.
564	*/
565	ret = bt_ctf_field_type_set_byte_order(_uint64_t, byte_order);
566	if (ret) {
567	goto end;
568	}
569
570	ret = bt_ctf_field_type_structure_add_field(packet_context_type,
571	_uint64_t, "timestamp_begin");
572	if (ret) {
573	goto end;
574	}
575
576	ret = bt_ctf_field_type_structure_add_field(packet_context_type,
577	_uint64_t, "timestamp_end");
578	if (ret) {
579	goto end;
580	}
581
582	ret = bt_ctf_field_type_structure_add_field(packet_context_type,
583	_uint64_t, "content_size");
584	if (ret) {
585	goto end;
586	}
587
588	ret = bt_ctf_field_type_structure_add_field(packet_context_type,
589	_uint64_t, "packet_size");
590	if (ret) {
591	goto end;
592	}
593
594	ret = bt_ctf_field_type_structure_add_field(packet_context_type,
595	_uint64_t, "events_discarded");
596	if (ret) {
597	goto end;
598	}
599
600	stream_class->packet_context_type = packet_context_type;
11b0cdc8 JG	601	end:
	602	if (ret) {
	603	bt_ctf_field_type_put(packet_context_type);
	604	goto end;
	605	}
	606
	607	bt_ctf_field_type_put(_uint64_t);
	608	return ret;
	609	}