[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) {
		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) {
		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;
}

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_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);
	bt_ctf_field_type_put(stream_class->event_context_type);
	bt_ctf_field_put(stream_class->event_context);
	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
	154	if (!stream_class) {
	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
	289	if (!stream_class \|\| !packet_context_type) {
	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
11b0cdc8 JG	309	void bt_ctf_stream_class_get(struct bt_ctf_stream_class *stream_class)
	310	{
	311	if (!stream_class) {
	312	return;
	313	}
	314
	315	bt_ctf_ref_get(&stream_class->ref_count);
	316	}
	317
	318	void bt_ctf_stream_class_put(struct bt_ctf_stream_class *stream_class)
	319	{
	320	if (!stream_class) {
	321	return;
	322	}
	323
	324	bt_ctf_ref_put(&stream_class->ref_count, bt_ctf_stream_class_destroy);
	325	}
	326
	327	BT_HIDDEN
	328	void bt_ctf_stream_class_freeze(struct bt_ctf_stream_class *stream_class)
	329	{
	330	if (!stream_class) {
	331	return;
	332	}
	333
	334	stream_class->frozen = 1;
12c8a1a3	335	bt_ctf_field_type_freeze(stream_class->packet_context_type);
11b0cdc8 JG	336	bt_ctf_clock_freeze(stream_class->clock);
	337	g_ptr_array_foreach(stream_class->event_classes,
	338	(GFunc)bt_ctf_event_class_freeze, NULL);
	339	}
	340
11b0cdc8 JG	341	BT_HIDDEN
	342	int bt_ctf_stream_class_set_byte_order(struct bt_ctf_stream_class *stream_class,
	343	enum bt_ctf_byte_order byte_order)
	344	{
	345	int ret = 0;
	346
11b0cdc8 JG	347	ret = init_event_header(stream_class, byte_order);
	348	if (ret) {
	349	goto end;
	350	}
	351	end:
	352	return ret;
	353	}
	354
	355	BT_HIDDEN
	356	int bt_ctf_stream_class_serialize(struct bt_ctf_stream_class *stream_class,
	357	struct metadata_context *context)
	358	{
2f100782	359	int64_t ret = 0;
11b0cdc8 JG	360	size_t i;
	361
	362	g_string_assign(context->field_name, "");
	363	context->current_indentation_level = 1;
	364	if (!stream_class->id_set) {
	365	ret = -1;
	366	goto end;
	367	}
	368
	369	g_string_append_printf(context->string,
	370	"stream {\n\tid = %" PRIu32 ";\n\tevent.header := ",
	371	stream_class->id);
	372	ret = bt_ctf_field_type_serialize(stream_class->event_header_type,
	373	context);
	374	if (ret) {
	375	goto end;
	376	}
	377
	378	g_string_append(context->string, ";\n\n\tpacket.context := ");
	379	ret = bt_ctf_field_type_serialize(stream_class->packet_context_type,
	380	context);
	381	if (ret) {
	382	goto end;
	383	}
	384
	385	if (stream_class->event_context_type) {
	386	g_string_append(context->string, ";\n\n\tevent.context := ");
	387	ret = bt_ctf_field_type_serialize(
	388	stream_class->event_context_type, context);
	389	if (ret) {
	390	goto end;
	391	}
	392	}
	393
	394	g_string_append(context->string, ";\n};\n\n");
11b0cdc8 JG	395	for (i = 0; i < stream_class->event_classes->len; i++) {
	396	struct bt_ctf_event_class *event_class =
	397	stream_class->event_classes->pdata[i];
	398
11b0cdc8 JG	399	ret = bt_ctf_event_class_serialize(event_class, context);
	400	if (ret) {
	401	goto end;
	402	}
	403	}
	404	end:
	405	context->current_indentation_level = 0;
	406	return ret;
	407	}
	408
	409	static
	410	void bt_ctf_stream_class_destroy(struct bt_ctf_ref *ref)
	411	{
	412	struct bt_ctf_stream_class *stream_class;
	413
	414	if (!ref) {
	415	return;
	416	}
	417
	418	stream_class = container_of(ref, struct bt_ctf_stream_class, ref_count);
	419	bt_ctf_clock_put(stream_class->clock);
	420
	421	if (stream_class->event_classes) {
2f100782 JG	422	size_t i;
	423
	424	/* Unregister this stream class from the event classes */
	425	for (i = 0; i < stream_class->event_classes->len; i++) {
	426	struct bt_ctf_event_class *event_class =
	427	g_ptr_array_index(stream_class->event_classes,
	428	i);
	429
	430	bt_ctf_event_class_set_stream_class(event_class, NULL);
	431	}
	432
11b0cdc8 JG	433	g_ptr_array_free(stream_class->event_classes, TRUE);
	434	}
	435
	436	if (stream_class->name) {
	437	g_string_free(stream_class->name, TRUE);
	438	}
	439
	440	bt_ctf_field_type_put(stream_class->event_header_type);
	441	bt_ctf_field_put(stream_class->event_header);
	442	bt_ctf_field_type_put(stream_class->packet_context_type);
11b0cdc8 JG	443	bt_ctf_field_type_put(stream_class->event_context_type);
	444	bt_ctf_field_put(stream_class->event_context);
	445	g_free(stream_class);
	446	}
	447
	448	static
	449	int init_event_header(struct bt_ctf_stream_class *stream_class,
	450	enum bt_ctf_byte_order byte_order)
	451	{
	452	int ret = 0;
	453	struct bt_ctf_field_type *event_header_type =
	454	bt_ctf_field_type_structure_create();
	455	struct bt_ctf_field_type *_uint32_t =
	456	get_field_type(FIELD_TYPE_ALIAS_UINT32_T);
	457	struct bt_ctf_field_type *_uint64_t =
	458	get_field_type(FIELD_TYPE_ALIAS_UINT64_T);
	459
	460	if (!event_header_type) {
	461	ret = -1;
	462	goto end;
	463	}
	464
	465	ret = bt_ctf_field_type_set_byte_order(_uint32_t, byte_order);
	466	if (ret) {
	467	goto end;
	468	}
	469
	470	ret = bt_ctf_field_type_set_byte_order(_uint64_t, byte_order);
	471	if (ret) {
	472	goto end;
	473	}
	474
	475	ret = bt_ctf_field_type_structure_add_field(event_header_type,
	476	_uint32_t, "id");
	477	if (ret) {
	478	goto end;
	479	}
	480
	481	ret = bt_ctf_field_type_structure_add_field(event_header_type,
	482	_uint64_t, "timestamp");
	483	if (ret) {
	484	goto end;
	485	}
	486
	487	stream_class->event_header_type = event_header_type;
	488	stream_class->event_header = bt_ctf_field_create(
	489	stream_class->event_header_type);
	490	if (!stream_class->event_header) {
	491	ret = -1;
	492	}
	493	end:
	494	if (ret) {
	495	bt_ctf_field_type_put(event_header_type);
	496	}
	497
	498	bt_ctf_field_type_put(_uint32_t);
	499	bt_ctf_field_type_put(_uint64_t);
	500	return ret;
	501	}
	502
	503	static
	504	int init_packet_context(struct bt_ctf_stream_class *stream_class,
	505	enum bt_ctf_byte_order byte_order)
	506	{
507	int ret = 0;
508	struct bt_ctf_field_type *packet_context_type =
509	bt_ctf_field_type_structure_create();
510	struct bt_ctf_field_type *_uint64_t =
511	get_field_type(FIELD_TYPE_ALIAS_UINT64_T);
512
513	if (!packet_context_type) {
514	ret = -1;
515	goto end;
516	}
517
518	/*
519	* We create a stream packet context as proposed in the CTF
520	* specification.
521	*/
522	ret = bt_ctf_field_type_set_byte_order(_uint64_t, byte_order);
523	if (ret) {
524	goto end;
525	}
526
527	ret = bt_ctf_field_type_structure_add_field(packet_context_type,
528	_uint64_t, "timestamp_begin");
529	if (ret) {
530	goto end;
531	}
532
533	ret = bt_ctf_field_type_structure_add_field(packet_context_type,
534	_uint64_t, "timestamp_end");
535	if (ret) {
536	goto end;
537	}
538
539	ret = bt_ctf_field_type_structure_add_field(packet_context_type,
540	_uint64_t, "content_size");
541	if (ret) {
542	goto end;
543	}
544
545	ret = bt_ctf_field_type_structure_add_field(packet_context_type,
546	_uint64_t, "packet_size");
547	if (ret) {
548	goto end;
549	}
550
551	ret = bt_ctf_field_type_structure_add_field(packet_context_type,
552	_uint64_t, "events_discarded");
553	if (ret) {
554	goto end;
555	}
556
557	stream_class->packet_context_type = packet_context_type;
11b0cdc8 JG	558	end:
	559	if (ret) {
	560	bt_ctf_field_type_put(packet_context_type);
	561	goto end;
	562	}
	563
	564	bt_ctf_field_type_put(_uint64_t);
	565	return ret;
	566	}