[babeltrace.git] / lib / ctf-ir / event-class.c

/*
 * event-class.c
 *
 * Babeltrace CTF IR - Event 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.
 */

#define BT_LOG_TAG "EVENT-CLASS"
#include <babeltrace/lib-logging-internal.h>

#include <babeltrace/assert-pre-internal.h>
#include <babeltrace/ctf-ir/clock-value-internal.h>
#include <babeltrace/ctf-ir/fields-internal.h>
#include <babeltrace/ctf-ir/field-types-internal.h>
#include <babeltrace/ctf-ir/event-class.h>
#include <babeltrace/ctf-ir/event-class-internal.h>
#include <babeltrace/ctf-ir/event-internal.h>
#include <babeltrace/ctf-ir/stream-class.h>
#include <babeltrace/ctf-ir/stream-class-internal.h>
#include <babeltrace/ctf-ir/trace-internal.h>
#include <babeltrace/ctf-ir/validation-internal.h>
#include <babeltrace/ctf-ir/utils.h>
#include <babeltrace/ctf-ir/utils-internal.h>
#include <babeltrace/ref.h>
#include <babeltrace/ctf-ir/attributes-internal.h>
#include <babeltrace/compiler-internal.h>
#include <babeltrace/endian-internal.h>
#include <babeltrace/types.h>
#include <babeltrace/values-internal.h>
#include <babeltrace/assert-internal.h>
#include <inttypes.h>
#include <stdlib.h>

BT_HIDDEN
void bt_event_class_common_finalize(struct bt_object *obj)
{
	struct bt_event_class_common *event_class;

	event_class = container_of(obj, struct bt_event_class_common, base);
	BT_LOGD("Finalizing common event class: addr=%p, name=\"%s\", id=%" PRId64,
		event_class, bt_event_class_common_get_name(event_class),
		bt_event_class_common_get_id(event_class));

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

	if (event_class->emf_uri) {
		g_string_free(event_class->emf_uri, TRUE);
	}

	BT_LOGD_STR("Putting context field type.");
	bt_put(event_class->context_field_type);
	BT_LOGD_STR("Putting payload field type.");
	bt_put(event_class->payload_field_type);
}

BT_HIDDEN
int bt_event_class_common_initialize(struct bt_event_class_common *event_class,
		const char *name, bt_object_release_func release_func,
		bt_field_type_structure_create_func ft_struct_create_func)
{
	int ret = 0;

	BT_LOGD("Initializing common event class object: name=\"%s\"",
		name);
	bt_object_init(event_class, release_func);
	event_class->payload_field_type = ft_struct_create_func();
	if (!event_class->payload_field_type) {
		BT_LOGE_STR("Cannot create event class's initial payload field type object.");
		goto error;
	}

	event_class->id = -1;
	event_class->name = g_string_new(name);
	if (!event_class->name) {
		BT_LOGE_STR("Failed to allocate a GString.");
		goto error;
	}

	event_class->emf_uri = g_string_new(NULL);
	if (!event_class->emf_uri) {
		BT_LOGE_STR("Failed to allocate a GString.");
		goto error;
	}

	event_class->log_level = BT_EVENT_CLASS_LOG_LEVEL_UNSPECIFIED;
	BT_LOGD("Initialized common event class object: addr=%p, name=\"%s\"",
		event_class, bt_event_class_common_get_name(event_class));
	return ret;

error:
	ret = -1;
	return ret;
}

static
void bt_event_class_destroy(struct bt_object *obj)
{
	struct bt_event_class *event_class = (void *) obj;

	BT_LOGD("Destroying event class: addr=%p", obj);
	bt_event_class_common_finalize(obj);
	bt_object_pool_finalize(&event_class->event_pool);
	g_free(obj);
}

static
void free_event(struct bt_event *event,
		struct bt_event_class *event_class)
{
	bt_event_destroy(event);
}

struct bt_event_class *bt_event_class_create(const char *name)
{
	int ret;
	struct bt_event_class *event_class = NULL;

	if (!name) {
		BT_LOGW_STR("Invalid parameter: name is NULL.");
		goto error;
	}

	BT_LOGD("Creating event class object: name=\"%s\"",
		name);
	event_class = g_new0(struct bt_event_class, 1);
	if (!event_class) {
		BT_LOGE_STR("Failed to allocate one event class.");
		goto error;
	}

	ret = bt_event_class_common_initialize(BT_TO_COMMON(event_class),
		name, bt_event_class_destroy,
		(bt_field_type_structure_create_func)
			bt_field_type_structure_create);
	if (ret) {
		goto error;
	}

	ret = bt_object_pool_initialize(&event_class->event_pool,
		(bt_object_pool_new_object_func) bt_event_new,
		(bt_object_pool_destroy_object_func) free_event,
		event_class);
	if (ret) {
		BT_LOGE("Failed to initialize event pool: ret=%d",
			ret);
		goto error;
	}

	BT_LOGD("Created event class object: addr=%p, name=\"%s\"",
		event_class, bt_event_class_get_name(event_class));
	goto end;

error:
	bt_put(event_class);

end:
	return event_class;
}

const char *bt_event_class_get_name(struct bt_event_class *event_class)
{
	return bt_event_class_common_get_name(BT_TO_COMMON(event_class));
}

int64_t bt_event_class_get_id(struct bt_event_class *event_class)
{
	return bt_event_class_common_get_id(BT_TO_COMMON(event_class));
}

int bt_event_class_set_id(struct bt_event_class *event_class, uint64_t id)
{
	return bt_event_class_common_set_id(BT_TO_COMMON(event_class), id);
}

enum bt_event_class_log_level bt_event_class_get_log_level(
		struct bt_event_class *event_class)
{
	return bt_event_class_common_get_log_level(BT_TO_COMMON(event_class));
}

int bt_event_class_set_log_level(struct bt_event_class *event_class,
		enum bt_event_class_log_level log_level)
{
	return bt_event_class_common_set_log_level(BT_TO_COMMON(event_class),
		log_level);
}

const char *bt_event_class_get_emf_uri(struct bt_event_class *event_class)
{
	return bt_event_class_common_get_emf_uri(BT_TO_COMMON(event_class));
}

int bt_event_class_set_emf_uri(struct bt_event_class *event_class,
		const char *emf_uri)
{
	return bt_event_class_common_set_emf_uri(BT_TO_COMMON(event_class),
		emf_uri);
}

struct bt_stream_class *bt_event_class_borrow_stream_class(
		struct bt_event_class *event_class)
{
	BT_ASSERT_PRE_NON_NULL(event_class, "Event class");
	return BT_FROM_COMMON(
		bt_event_class_common_borrow_stream_class(BT_TO_COMMON(
			event_class)));
}

struct bt_field_type *bt_event_class_borrow_payload_field_type(
		struct bt_event_class *event_class)
{
	return BT_FROM_COMMON(bt_event_class_common_borrow_payload_field_type(
		BT_TO_COMMON(event_class)));
}

int bt_event_class_set_payload_field_type(struct bt_event_class *event_class,
		struct bt_field_type *field_type)
{
	return bt_event_class_common_set_payload_field_type(
		BT_TO_COMMON(event_class), (void *) field_type);
}

struct bt_field_type *bt_event_class_borrow_context_field_type(
		struct bt_event_class *event_class)
{
	return BT_FROM_COMMON(bt_event_class_common_borrow_context_field_type(
		BT_TO_COMMON(event_class)));
}

int bt_event_class_set_context_field_type(
		struct bt_event_class *event_class,
		struct bt_field_type *field_type)
{
	return bt_event_class_common_set_context_field_type(
		BT_TO_COMMON(event_class), (void *) field_type);
}

BT_HIDDEN
void bt_event_class_common_freeze(struct bt_event_class_common *event_class)
{
	BT_ASSERT(event_class);

	if (event_class->frozen) {
		return;
	}

	BT_LOGD("Freezing event class: addr=%p, name=\"%s\", id=%" PRId64,
		event_class, bt_event_class_common_get_name(event_class),
		bt_event_class_common_get_id(event_class));
	event_class->frozen = 1;
	BT_LOGD_STR("Freezing event class's context field type.");
	bt_field_type_common_freeze(event_class->context_field_type);
	BT_LOGD_STR("Freezing event class's payload field type.");
	bt_field_type_common_freeze(event_class->payload_field_type);
}

BT_HIDDEN
int bt_event_class_common_validate_single_clock_class(
		struct bt_event_class_common *event_class,
		struct bt_clock_class **expected_clock_class)
{
	int ret = 0;

	BT_ASSERT(event_class);
	BT_ASSERT(expected_clock_class);
	ret = bt_field_type_common_validate_single_clock_class(
		event_class->context_field_type,
		expected_clock_class);
	if (ret) {
		BT_LOGW("Event class's context field type "
			"is not recursively mapped to the "
			"expected clock class: "
			"event-class-addr=%p, "
			"event-class-name=\"%s\", "
			"event-class-id=%" PRId64 ", "
			"ft-addr=%p",
			event_class,
			bt_event_class_common_get_name(event_class),
			event_class->id,
			event_class->context_field_type);
		goto end;
	}

	ret = bt_field_type_common_validate_single_clock_class(
		event_class->payload_field_type,
		expected_clock_class);
	if (ret) {
		BT_LOGW("Event class's payload field type "
			"is not recursively mapped to the "
			"expected clock class: "
			"event-class-addr=%p, "
			"event-class-name=\"%s\", "
			"event-class-id=%" PRId64 ", "
			"ft-addr=%p",
			event_class,
			bt_event_class_common_get_name(event_class),
			event_class->id,
			event_class->payload_field_type);
		goto end;
	}

end:
	return ret;
}

BT_HIDDEN
int bt_event_class_update_event_pool_clock_values(
		struct bt_event_class *event_class)
{
	int ret = 0;
	uint64_t i;
	struct bt_stream_class *stream_class =
		bt_event_class_borrow_stream_class(event_class);

	BT_ASSERT(stream_class->common.clock_class);

	for (i = 0; i < event_class->event_pool.size; i++) {
		struct bt_clock_value *cv;
		struct bt_event *event =
			event_class->event_pool.objects->pdata[i];

		BT_ASSERT(event);

		cv = g_hash_table_lookup(event->clock_values,
			stream_class->common.clock_class);
		if (cv) {
			continue;
		}

		cv = bt_clock_value_create(stream_class->common.clock_class);
		if (!cv) {
			BT_LIB_LOGE("Cannot create clock value from clock class: "
				"%![cc-]+K", stream_class->common.clock_class);
			ret = -1;
			goto end;
		}

		g_hash_table_insert(event->clock_values,
			stream_class->common.clock_class, cv);
	}

end:
	return ret;
}
Commit	Line	Data
272df73e PP	1	/*
	2	* event-class.c
	3	*
	4	* Babeltrace CTF IR - Event class
	5	*
	6	* Copyright 2013, 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
f8b979f9 PP	29	#define BT_LOG_TAG "EVENT-CLASS"
	30	#include <babeltrace/lib-logging-internal.h>
	31
3dca2276	32	#include <babeltrace/assert-pre-internal.h>
312c056a	33	#include <babeltrace/ctf-ir/clock-value-internal.h>
272df73e PP	34	#include <babeltrace/ctf-ir/fields-internal.h>
	35	#include <babeltrace/ctf-ir/field-types-internal.h>
	36	#include <babeltrace/ctf-ir/event-class.h>
	37	#include <babeltrace/ctf-ir/event-class-internal.h>
312c056a	38	#include <babeltrace/ctf-ir/event-internal.h>
272df73e PP	39	#include <babeltrace/ctf-ir/stream-class.h>
	40	#include <babeltrace/ctf-ir/stream-class-internal.h>
	41	#include <babeltrace/ctf-ir/trace-internal.h>
	42	#include <babeltrace/ctf-ir/validation-internal.h>
	43	#include <babeltrace/ctf-ir/utils.h>
2a3ced3c	44	#include <babeltrace/ctf-ir/utils-internal.h>
272df73e PP	45	#include <babeltrace/ref.h>
272df73e PP	46	#include <babeltrace/ctf-ir/attributes-internal.h>
3d9990ac PP	47	#include <babeltrace/compiler-internal.h>
3d9990ac PP	48	#include <babeltrace/endian-internal.h>
c55a9f58	49	#include <babeltrace/types.h>
f8b979f9	50	#include <babeltrace/values-internal.h>
f6ccaed9	51	#include <babeltrace/assert-internal.h>
dc3fffef	52	#include <inttypes.h>
0fbb9a9f	53	#include <stdlib.h>
272df73e	54
3dca2276 PP	55	BT_HIDDEN
3dca2276 PP	56	void bt_event_class_common_finalize(struct bt_object *obj)
272df73e	57	{
3dca2276	58	struct bt_event_class_common *event_class;
272df73e	59
3dca2276 PP	60	event_class = container_of(obj, struct bt_event_class_common, base);
	61	BT_LOGD("Finalizing common event class: addr=%p, name=\"%s\", id=%" PRId64,
	62	event_class, bt_event_class_common_get_name(event_class),
	63	bt_event_class_common_get_id(event_class));
f8b979f9	64
3dca2276 PP	65	if (event_class->name) {
3dca2276 PP	66	g_string_free(event_class->name, TRUE);
cf76ce92 PP	67	}
cf76ce92 PP	68
3dca2276 PP	69	if (event_class->emf_uri) {
3dca2276 PP	70	g_string_free(event_class->emf_uri, TRUE);
272df73e PP	71	}
272df73e PP	72
3dca2276 PP	73	BT_LOGD_STR("Putting context field type.");
	74	bt_put(event_class->context_field_type);
	75	BT_LOGD_STR("Putting payload field type.");
	76	bt_put(event_class->payload_field_type);
	77	}
	78
	79	BT_HIDDEN
	80	int bt_event_class_common_initialize(struct bt_event_class_common *event_class,
	81	const char *name, bt_object_release_func release_func,
	82	bt_field_type_structure_create_func ft_struct_create_func)
	83	{
	84	int ret = 0;
	85
	86	BT_LOGD("Initializing common event class object: name=\"%s\"",
	87	name);
	88	bt_object_init(event_class, release_func);
	89	event_class->payload_field_type = ft_struct_create_func();
	90	if (!event_class->payload_field_type) {
f8b979f9	91	BT_LOGE_STR("Cannot create event class's initial payload field type object.");
272df73e PP	92	goto error;
	93	}
	94
cf76ce92 PP	95	event_class->id = -1;
	96	event_class->name = g_string_new(name);
	97	if (!event_class->name) {
	98	BT_LOGE_STR("Failed to allocate a GString.");
272df73e PP	99	goto error;
	100	}
	101
cf76ce92 PP	102	event_class->emf_uri = g_string_new(NULL);
	103	if (!event_class->emf_uri) {
	104	BT_LOGE_STR("Failed to allocate a GString.");
272df73e PP	105	goto error;
	106	}
	107
50842bdc	108	event_class->log_level = BT_EVENT_CLASS_LOG_LEVEL_UNSPECIFIED;
3dca2276 PP	109	BT_LOGD("Initialized common event class object: addr=%p, name=\"%s\"",
	110	event_class, bt_event_class_common_get_name(event_class));
	111	return ret;
272df73e PP	112
272df73e PP	113	error:
3dca2276	114	ret = -1;
272df73e PP	115	return ret;
	116	}
	117
3dca2276 PP	118	static
3dca2276 PP	119	void bt_event_class_destroy(struct bt_object *obj)
272df73e	120	{
312c056a PP	121	struct bt_event_class event_class = (void ) obj;
312c056a PP	122
3dca2276 PP	123	BT_LOGD("Destroying event class: addr=%p", obj);
3dca2276 PP	124	bt_event_class_common_finalize(obj);
312c056a	125	bt_object_pool_finalize(&event_class->event_pool);
3dca2276	126	g_free(obj);
272df73e PP	127	}
272df73e PP	128
312c056a PP	129	static
	130	void free_event(struct bt_event *event,
	131	struct bt_event_class *event_class)
	132	{
	133	bt_event_destroy(event);
	134	}
	135
3dca2276	136	struct bt_event_class bt_event_class_create(const char name)
272df73e	137	{
3dca2276 PP	138	int ret;
3dca2276 PP	139	struct bt_event_class *event_class = NULL;
272df73e	140
3dca2276 PP	141	if (!name) {
	142	BT_LOGW_STR("Invalid parameter: name is NULL.");
	143	goto error;
cf76ce92	144	}
272df73e	145
3dca2276 PP	146	BT_LOGD("Creating event class object: name=\"%s\"",
	147	name);
	148	event_class = g_new0(struct bt_event_class, 1);
272df73e	149	if (!event_class) {
3dca2276 PP	150	BT_LOGE_STR("Failed to allocate one event class.");
3dca2276 PP	151	goto error;
272df73e PP	152	}
272df73e PP	153
3dca2276 PP	154	ret = bt_event_class_common_initialize(BT_TO_COMMON(event_class),
	155	name, bt_event_class_destroy,
	156	(bt_field_type_structure_create_func)
	157	bt_field_type_structure_create);
	158	if (ret) {
	159	goto error;
272df73e PP	160	}
272df73e PP	161
312c056a PP	162	ret = bt_object_pool_initialize(&event_class->event_pool,
	163	(bt_object_pool_new_object_func) bt_event_new,
	164	(bt_object_pool_destroy_object_func) free_event,
	165	event_class);
	166	if (ret) {
	167	BT_LOGE("Failed to initialize event pool: ret=%d",
	168	ret);
	169	goto error;
	170	}
	171
3dca2276 PP	172	BT_LOGD("Created event class object: addr=%p, name=\"%s\"",
	173	event_class, bt_event_class_get_name(event_class));
	174	goto end;
272df73e	175
3dca2276 PP	176	error:
3dca2276 PP	177	bt_put(event_class);
272df73e PP	178
272df73e PP	179	end:
3dca2276	180	return event_class;
272df73e PP	181	}
272df73e PP	182
3dca2276	183	const char bt_event_class_get_name(struct bt_event_class event_class)
272df73e	184	{
3dca2276	185	return bt_event_class_common_get_name(BT_TO_COMMON(event_class));
272df73e PP	186	}
272df73e PP	187
3dca2276	188	int64_t bt_event_class_get_id(struct bt_event_class *event_class)
272df73e	189	{
3dca2276	190	return bt_event_class_common_get_id(BT_TO_COMMON(event_class));
272df73e PP	191	}
272df73e PP	192
3dca2276	193	int bt_event_class_set_id(struct bt_event_class *event_class, uint64_t id)
272df73e	194	{
3dca2276	195	return bt_event_class_common_set_id(BT_TO_COMMON(event_class), id);
272df73e PP	196	}
272df73e PP	197
3dca2276 PP	198	enum bt_event_class_log_level bt_event_class_get_log_level(
3dca2276 PP	199	struct bt_event_class *event_class)
272df73e	200	{
3dca2276	201	return bt_event_class_common_get_log_level(BT_TO_COMMON(event_class));
272df73e PP	202	}
272df73e PP	203
3dca2276 PP	204	int bt_event_class_set_log_level(struct bt_event_class *event_class,
3dca2276 PP	205	enum bt_event_class_log_level log_level)
272df73e	206	{
3dca2276 PP	207	return bt_event_class_common_set_log_level(BT_TO_COMMON(event_class),
3dca2276 PP	208	log_level);
272df73e PP	209	}
272df73e PP	210
3dca2276	211	const char bt_event_class_get_emf_uri(struct bt_event_class event_class)
272df73e	212	{
3dca2276	213	return bt_event_class_common_get_emf_uri(BT_TO_COMMON(event_class));
272df73e PP	214	}
272df73e PP	215
3dca2276 PP	216	int bt_event_class_set_emf_uri(struct bt_event_class *event_class,
3dca2276 PP	217	const char *emf_uri)
272df73e	218	{
3dca2276 PP	219	return bt_event_class_common_set_emf_uri(BT_TO_COMMON(event_class),
3dca2276 PP	220	emf_uri);
272df73e PP	221	}
272df73e PP	222
094ff7c0	223	struct bt_stream_class *bt_event_class_borrow_stream_class(
50842bdc	224	struct bt_event_class *event_class)
272df73e	225	{
d975f66c	226	BT_ASSERT_PRE_NON_NULL(event_class, "Event class");
094ff7c0 PP	227	return BT_FROM_COMMON(
	228	bt_event_class_common_borrow_stream_class(BT_TO_COMMON(
	229	event_class)));
272df73e PP	230	}
272df73e PP	231
094ff7c0	232	struct bt_field_type *bt_event_class_borrow_payload_field_type(
3dca2276	233	struct bt_event_class *event_class)
272df73e	234	{
094ff7c0	235	return BT_FROM_COMMON(bt_event_class_common_borrow_payload_field_type(
3dca2276	236	BT_TO_COMMON(event_class)));
272df73e PP	237	}
272df73e PP	238
3dca2276 PP	239	int bt_event_class_set_payload_field_type(struct bt_event_class *event_class,
3dca2276 PP	240	struct bt_field_type *field_type)
272df73e	241	{
3dca2276 PP	242	return bt_event_class_common_set_payload_field_type(
3dca2276 PP	243	BT_TO_COMMON(event_class), (void *) field_type);
272df73e PP	244	}
272df73e PP	245
094ff7c0	246	struct bt_field_type *bt_event_class_borrow_context_field_type(
3dca2276	247	struct bt_event_class *event_class)
272df73e	248	{
094ff7c0	249	return BT_FROM_COMMON(bt_event_class_common_borrow_context_field_type(
3dca2276	250	BT_TO_COMMON(event_class)));
272df73e PP	251	}
272df73e PP	252
3dca2276 PP	253	int bt_event_class_set_context_field_type(
	254	struct bt_event_class *event_class,
	255	struct bt_field_type *field_type)
272df73e	256	{
3dca2276 PP	257	return bt_event_class_common_set_context_field_type(
3dca2276 PP	258	BT_TO_COMMON(event_class), (void *) field_type);
272df73e PP	259	}
	260
	261	BT_HIDDEN
3dca2276	262	void bt_event_class_common_freeze(struct bt_event_class_common *event_class)
272df73e	263	{
f6ccaed9	264	BT_ASSERT(event_class);
f8b979f9 PP	265
	266	if (event_class->frozen) {
	267	return;
	268	}
	269
	270	BT_LOGD("Freezing event class: addr=%p, name=\"%s\", id=%" PRId64,
3dca2276 PP	271	event_class, bt_event_class_common_get_name(event_class),
3dca2276 PP	272	bt_event_class_common_get_id(event_class));
272df73e	273	event_class->frozen = 1;
0352f8fa	274	BT_LOGD_STR("Freezing event class's context field type.");
3dca2276	275	bt_field_type_common_freeze(event_class->context_field_type);
0352f8fa	276	BT_LOGD_STR("Freezing event class's payload field type.");
3dca2276	277	bt_field_type_common_freeze(event_class->payload_field_type);
272df73e	278	}
2a3ced3c PP	279
2a3ced3c PP	280	BT_HIDDEN
3dca2276 PP	281	int bt_event_class_common_validate_single_clock_class(
3dca2276 PP	282	struct bt_event_class_common *event_class,
2a3ced3c PP	283	struct bt_clock_class **expected_clock_class)
	284	{
	285	int ret = 0;
	286
f6ccaed9 PP	287	BT_ASSERT(event_class);
f6ccaed9 PP	288	BT_ASSERT(expected_clock_class);
3dca2276 PP	289	ret = bt_field_type_common_validate_single_clock_class(
3dca2276 PP	290	event_class->context_field_type,
2a3ced3c PP	291	expected_clock_class);
	292	if (ret) {
	293	BT_LOGW("Event class's context field type "
	294	"is not recursively mapped to the "
	295	"expected clock class: "
	296	"event-class-addr=%p, "
	297	"event-class-name=\"%s\", "
	298	"event-class-id=%" PRId64 ", "
	299	"ft-addr=%p",
	300	event_class,
3dca2276	301	bt_event_class_common_get_name(event_class),
2a3ced3c	302	event_class->id,
3dca2276	303	event_class->context_field_type);
2a3ced3c PP	304	goto end;
	305	}
	306
3dca2276 PP	307	ret = bt_field_type_common_validate_single_clock_class(
3dca2276 PP	308	event_class->payload_field_type,
2a3ced3c PP	309	expected_clock_class);
	310	if (ret) {
	311	BT_LOGW("Event class's payload field type "
	312	"is not recursively mapped to the "
	313	"expected clock class: "
	314	"event-class-addr=%p, "
	315	"event-class-name=\"%s\", "
	316	"event-class-id=%" PRId64 ", "
	317	"ft-addr=%p",
	318	event_class,
3dca2276	319	bt_event_class_common_get_name(event_class),
2a3ced3c	320	event_class->id,
3dca2276	321	event_class->payload_field_type);
2a3ced3c PP	322	goto end;
	323	}
	324
	325	end:
	326	return ret;
	327	}
312c056a PP	328
	329	BT_HIDDEN
	330	int bt_event_class_update_event_pool_clock_values(
	331	struct bt_event_class *event_class)
	332	{
	333	int ret = 0;
	334	uint64_t i;
	335	struct bt_stream_class *stream_class =
	336	bt_event_class_borrow_stream_class(event_class);
	337
	338	BT_ASSERT(stream_class->common.clock_class);
	339
	340	for (i = 0; i < event_class->event_pool.size; i++) {
	341	struct bt_clock_value *cv;
	342	struct bt_event *event =
	343	event_class->event_pool.objects->pdata[i];
	344
	345	BT_ASSERT(event);
	346
	347	cv = g_hash_table_lookup(event->clock_values,
	348	stream_class->common.clock_class);
	349	if (cv) {
	350	continue;
	351	}
	352
	353	cv = bt_clock_value_create(stream_class->common.clock_class);
	354	if (!cv) {
	355	BT_LIB_LOGE("Cannot create clock value from clock class: "
	356	"%![cc-]+K", stream_class->common.clock_class);
	357	ret = -1;
	358	goto end;
	359	}
	360
	361	g_hash_table_insert(event->clock_values,
	362	stream_class->common.clock_class, cv);
	363	}
	364
	365	end:
	366	return ret;
	367	}