[babeltrace.git] / src / ctf-writer / clock-class.c

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * Babeltrace CTF writer - Clock class
 */

#define BT_LOG_TAG "CTF-WRITER/CLOCK-CLASS"
#include "logging.h"

#include "common/uuid.h"
#include <babeltrace2-ctf-writer/utils.h>
#include <babeltrace2-ctf-writer/object.h>
#include "compat/compiler.h"
#include "compat/string.h"
#include <stdbool.h>
#include <inttypes.h>
#include "common/assert.h"

#include "assert-pre.h"
#include "clock-class.h"
#include "object.h"

static
void bt_ctf_clock_class_destroy(struct bt_ctf_object *obj);

bt_ctf_bool bt_ctf_clock_class_is_valid(struct bt_ctf_clock_class *clock_class)
{
	return clock_class && clock_class->name;
}

int bt_ctf_clock_class_set_name(struct bt_ctf_clock_class *clock_class,
		const char *name)
{
	int ret = 0;

	if (!clock_class) {
		BT_LOGW_STR("Invalid parameter: clock class is NULL.");
		ret = -1;
		goto end;
	}

	if (clock_class->frozen) {
		BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
			clock_class, bt_ctf_clock_class_get_name(clock_class));
		ret = -1;
		goto end;
	}

	if (!bt_ctf_identifier_is_valid(name)) {
		BT_LOGW("Clock class's name is not a valid CTF identifier: "
			"addr=%p, name=\"%s\"",
			clock_class, name);
		ret = -1;
		goto end;
	}

	if (clock_class->name) {
		g_string_assign(clock_class->name, name);
	} else {
		clock_class->name = g_string_new(name);
		if (!clock_class->name) {
			BT_LOGE_STR("Failed to allocate a GString.");
			ret = -1;
			goto end;
		}
	}

	BT_LOGT("Set clock class's name: addr=%p, name=\"%s\"",
		clock_class, name);

end:
	return ret;
}

static
bool validate_freq(struct bt_ctf_clock_class *clock_class,
		const char *name, uint64_t freq)
{
	bool is_valid = true;

	if (freq == -1ULL || freq == 0) {
		BT_LOGW("Invalid parameter: frequency is invalid: "
			"addr=%p, name=\"%s\", freq=%" PRIu64,
			clock_class, name, freq);
		is_valid = false;
		goto end;
	}

end:
	return is_valid;
}

struct bt_ctf_clock_class *bt_ctf_clock_class_create(const char *name,
		uint64_t freq)
{
	int ret;
	struct bt_ctf_clock_class *clock_class = NULL;

	BT_LOGD("Creating default clock class object: name=\"%s\"",
		name);

	if (!validate_freq(NULL, name, freq)) {
		/* validate_freq() logs errors */
		goto error;
	}

	clock_class = g_new0(struct bt_ctf_clock_class, 1);
	if (!clock_class) {
		BT_LOGE_STR("Failed to allocate one clock class.");
		goto error;
	}

	clock_class->precision = 1;
	clock_class->frequency = freq;
	bt_ctf_object_init_shared(&clock_class->base, bt_ctf_clock_class_destroy);

	if (name) {
		ret = bt_ctf_clock_class_set_name(clock_class, name);
		if (ret) {
			/* bt_ctf_clock_class_set_name() logs errors */
			goto error;
		}
	}

	BT_LOGD("Created clock class object: addr=%p, name=\"%s\"",
		clock_class, name);
	return clock_class;
error:
	BT_CTF_OBJECT_PUT_REF_AND_RESET(clock_class);
	return clock_class;
}

const char *bt_ctf_clock_class_get_name(struct bt_ctf_clock_class *clock_class)
{
	const char *ret = NULL;

	if (!clock_class) {
		BT_LOGW_STR("Invalid parameter: clock class is NULL.");
		goto end;
	}

	if (clock_class->name) {
		ret = clock_class->name->str;
	}

end:
	return ret;
}

const char *bt_ctf_clock_class_get_description(
		struct bt_ctf_clock_class *clock_class)
{
	const char *ret = NULL;

	if (!clock_class) {
		BT_LOGW_STR("Invalid parameter: clock class is NULL.");
		goto end;
	}

	if (clock_class->description) {
		ret = clock_class->description->str;
	}
end:
	return ret;
}

int bt_ctf_clock_class_set_description(struct bt_ctf_clock_class *clock_class,
		const char *desc)
{
	int ret = 0;

	if (!clock_class || !desc) {
		BT_LOGW("Invalid parameter: clock class or description is NULL: "
			"clock-class-addr=%p, name=\"%s\", desc-addr=%p",
			clock_class, bt_ctf_clock_class_get_name(clock_class),
			desc);
		ret = -1;
		goto end;
	}

	if (clock_class->frozen) {
		BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
			clock_class, bt_ctf_clock_class_get_name(clock_class));
		ret = -1;
		goto end;
	}

	clock_class->description = g_string_new(desc);
	ret = clock_class->description ? 0 : -1;
	BT_LOGT("Set clock class's description: addr=%p, "
		"name=\"%s\", desc=\"%s\"",
		clock_class, bt_ctf_clock_class_get_name(clock_class), desc);
end:
	return ret;
}

uint64_t bt_ctf_clock_class_get_frequency(
		struct bt_ctf_clock_class *clock_class)
{
	uint64_t ret = -1ULL;

	if (!clock_class) {
		BT_LOGW_STR("Invalid parameter: clock class is NULL.");
		goto end;
	}

	ret = clock_class->frequency;
end:
	return ret;
}

int bt_ctf_clock_class_set_frequency(struct bt_ctf_clock_class *clock_class,
		uint64_t freq)
{
	int ret = 0;

	if (!clock_class) {
		BT_LOGW("Invalid parameter: clock class is NULL or frequency is invalid: "
			"addr=%p, name=\"%s\"",
			clock_class, bt_ctf_clock_class_get_name(clock_class));
		ret = -1;
		goto end;
	}

	if (!validate_freq(clock_class, bt_ctf_clock_class_get_name(clock_class),
			freq)) {
		/* validate_freq() logs errors */
		goto end;
	}

	if (clock_class->frozen) {
		BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
			clock_class, bt_ctf_clock_class_get_name(clock_class));
		ret = -1;
		goto end;
	}

	clock_class->frequency = freq;
	BT_LOGT("Set clock class's frequency: addr=%p, name=\"%s\", freq=%" PRIu64,
		clock_class, bt_ctf_clock_class_get_name(clock_class), freq);
end:
	return ret;
}

uint64_t bt_ctf_clock_class_get_precision(struct bt_ctf_clock_class *clock_class)
{
	uint64_t ret = -1ULL;

	if (!clock_class) {
		BT_LOGW_STR("Invalid parameter: clock class is NULL.");
		goto end;
	}

	ret = clock_class->precision;
end:
	return ret;
}

int bt_ctf_clock_class_set_precision(struct bt_ctf_clock_class *clock_class,
		uint64_t precision)
{
	int ret = 0;

	if (!clock_class || precision == -1ULL) {
		BT_LOGW("Invalid parameter: clock class is NULL or precision is invalid: "
			"addr=%p, name=\"%s\", precision=%" PRIu64,
			clock_class, bt_ctf_clock_class_get_name(clock_class),
			precision);
		ret = -1;
		goto end;
	}

	if (clock_class->frozen) {
		BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
			clock_class, bt_ctf_clock_class_get_name(clock_class));
		ret = -1;
		goto end;
	}

	clock_class->precision = precision;
	BT_LOGT("Set clock class's precision: addr=%p, name=\"%s\", precision=%" PRIu64,
		clock_class, bt_ctf_clock_class_get_name(clock_class),
		precision);
end:
	return ret;
}

int bt_ctf_clock_class_get_offset_s(struct bt_ctf_clock_class *clock_class,
		int64_t *offset_s)
{
	int ret = 0;

	if (!clock_class || !offset_s) {
		BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: "
			"clock-class-addr=%p, name=\"%s\", offset-addr=%p",
			clock_class, bt_ctf_clock_class_get_name(clock_class),
			offset_s);
		ret = -1;
		goto end;
	}

	*offset_s = clock_class->offset_s;
end:
	return ret;
}

int bt_ctf_clock_class_set_offset_s(struct bt_ctf_clock_class *clock_class,
		int64_t offset_s)
{
	int ret = 0;

	if (!clock_class) {
		BT_LOGW_STR("Invalid parameter: clock class is NULL.");
		ret = -1;
		goto end;
	}

	if (clock_class->frozen) {
		BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
			clock_class, bt_ctf_clock_class_get_name(clock_class));
		ret = -1;
		goto end;
	}

	clock_class->offset_s = offset_s;
	BT_LOGT("Set clock class's offset (seconds): "
		"addr=%p, name=\"%s\", offset-s=%" PRId64,
		clock_class, bt_ctf_clock_class_get_name(clock_class),
		offset_s);
end:
	return ret;
}

int bt_ctf_clock_class_get_offset_cycles(struct bt_ctf_clock_class *clock_class,
		int64_t *offset)
{
	int ret = 0;

	if (!clock_class || !offset) {
		BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: "
			"clock-class-addr=%p, name=\"%s\", offset-addr=%p",
			clock_class, bt_ctf_clock_class_get_name(clock_class),
			offset);
		ret = -1;
		goto end;
	}

	*offset = clock_class->offset;
end:
	return ret;
}

int bt_ctf_clock_class_set_offset_cycles(struct bt_ctf_clock_class *clock_class,
		int64_t offset)
{
	int ret = 0;

	if (!clock_class) {
		BT_LOGW_STR("Invalid parameter: clock class is NULL.");
		ret = -1;
		goto end;
	}

	if (clock_class->frozen) {
		BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
			clock_class, bt_ctf_clock_class_get_name(clock_class));
		ret = -1;
		goto end;
	}

	clock_class->offset = offset;
	BT_LOGT("Set clock class's offset (cycles): addr=%p, name=\"%s\", offset-cycles=%" PRId64,
		clock_class, bt_ctf_clock_class_get_name(clock_class), offset);
end:
	return ret;
}

bt_ctf_bool bt_ctf_clock_class_is_absolute(struct bt_ctf_clock_class *clock_class)
{
	int ret = -1;

	if (!clock_class) {
		BT_LOGW_STR("Invalid parameter: clock class is NULL.");
		goto end;
	}

	ret = clock_class->absolute;
end:
	return ret;
}

int bt_ctf_clock_class_set_is_absolute(struct bt_ctf_clock_class *clock_class,
		bt_ctf_bool is_absolute)
{
	int ret = 0;

	if (!clock_class) {
		BT_LOGW_STR("Invalid parameter: clock class is NULL.");
		ret = -1;
		goto end;
	}

	if (clock_class->frozen) {
		BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
			clock_class, bt_ctf_clock_class_get_name(clock_class));
		ret = -1;
		goto end;
	}

	clock_class->absolute = !!is_absolute;
	BT_LOGT("Set clock class's absolute flag: addr=%p, name=\"%s\", is-absolute=%d",
		clock_class, bt_ctf_clock_class_get_name(clock_class),
		is_absolute);
end:
	return ret;
}

const uint8_t *bt_ctf_clock_class_get_uuid(
		struct bt_ctf_clock_class *clock_class)
{
	const uint8_t *ret;

	if (!clock_class) {
		BT_LOGW_STR("Invalid parameter: clock class is NULL.");
		ret = NULL;
		goto end;
	}

	if (!clock_class->uuid_set) {
		BT_LOGT("Clock class's UUID is not set: addr=%p, name=\"%s\"",
			clock_class, bt_ctf_clock_class_get_name(clock_class));
		ret = NULL;
		goto end;
	}

	ret = clock_class->uuid;
end:
	return ret;
}

int bt_ctf_clock_class_set_uuid(struct bt_ctf_clock_class *clock_class,
		const uint8_t *uuid)
{
	int ret = 0;

	if (!clock_class || !uuid) {
		BT_LOGW("Invalid parameter: clock class or UUID is NULL: "
			"clock-class-addr=%p, name=\"%s\", uuid-addr=%p",
			clock_class, bt_ctf_clock_class_get_name(clock_class),
			uuid);
		ret = -1;
		goto end;
	}

	if (clock_class->frozen) {
		BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
			clock_class, bt_ctf_clock_class_get_name(clock_class));
		ret = -1;
		goto end;
	}

	bt_uuid_copy(clock_class->uuid, uuid);
	clock_class->uuid_set = 1;
	BT_LOGT("Set clock class's UUID: addr=%p, name=\"%s\", uuid=\"" BT_UUID_FMT "\"",
		clock_class, bt_ctf_clock_class_get_name(clock_class),
		BT_UUID_FMT_VALUES(uuid));
end:
	return ret;
}

void bt_ctf_clock_class_freeze(struct bt_ctf_clock_class *clock_class)
{
	if (!clock_class || clock_class->frozen) {
		return;
	}

	BT_LOGD("Freezing clock class: addr=%p, name=\"%s\"",
		clock_class, bt_ctf_clock_class_get_name(clock_class));
	clock_class->frozen = 1;
}

static
void bt_ctf_clock_class_destroy(struct bt_ctf_object *obj)
{
	struct bt_ctf_clock_class *clock_class;

	clock_class = container_of(obj, struct bt_ctf_clock_class, base);
	BT_LOGD("Destroying clock class: addr=%p, name=\"%s\"",
		obj, bt_ctf_clock_class_get_name(clock_class));

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

	if (clock_class->description) {
		g_string_free(clock_class->description, TRUE);
	}

	g_free(clock_class);
}

int bt_ctf_clock_class_compare(struct bt_ctf_clock_class *clock_class_a,
		struct bt_ctf_clock_class *clock_class_b)
{
	int ret = 1;
	BT_ASSERT_DBG(clock_class_a);
	BT_ASSERT_DBG(clock_class_b);

	/* Name */
	if (strcmp(clock_class_a->name->str, clock_class_b->name->str) != 0) {
		BT_LOGT("Clock classes differ: different names: "
			"cc-a-name=\"%s\", cc-b-name=\"%s\"",
			clock_class_a->name->str,
			clock_class_b->name->str);
		goto end;
	}

	/* Description */
	if (clock_class_a->description) {
		if (!clock_class_b->description) {
			BT_LOGT_STR("Clock classes differ: clock class A has a "
				"description, but clock class B does not.");
			goto end;
		}

		if (strcmp(clock_class_a->name->str, clock_class_b->name->str)
				!= 0) {
			BT_LOGT("Clock classes differ: different descriptions: "
				"cc-a-descr=\"%s\", cc-b-descr=\"%s\"",
				clock_class_a->description->str,
				clock_class_b->description->str);
			goto end;
		}
	} else {
		if (clock_class_b->description) {
			BT_LOGT_STR("Clock classes differ: clock class A has "
				"no description, but clock class B has one.");
			goto end;
		}
	}

	/* Frequency */
	if (clock_class_a->frequency != clock_class_b->frequency) {
		BT_LOGT("Clock classes differ: different frequencies: "
			"cc-a-freq=%" PRIu64 ", cc-b-freq=%" PRIu64,
			clock_class_a->frequency,
			clock_class_b->frequency);
		goto end;
	}

	/* Precision */
	if (clock_class_a->precision != clock_class_b->precision) {
		BT_LOGT("Clock classes differ: different precisions: "
			"cc-a-freq=%" PRIu64 ", cc-b-freq=%" PRIu64,
			clock_class_a->precision,
			clock_class_b->precision);
		goto end;
	}

	/* Offset (seconds) */
	if (clock_class_a->offset_s != clock_class_b->offset_s) {
		BT_LOGT("Clock classes differ: different offsets (seconds): "
			"cc-a-offset-s=%" PRId64 ", cc-b-offset-s=%" PRId64,
			clock_class_a->offset_s,
			clock_class_b->offset_s);
		goto end;
	}

	/* Offset (cycles) */
	if (clock_class_a->offset != clock_class_b->offset) {
		BT_LOGT("Clock classes differ: different offsets (cycles): "
			"cc-a-offset-s=%" PRId64 ", cc-b-offset-s=%" PRId64,
			clock_class_a->offset,
			clock_class_b->offset);
		goto end;
	}

	/* UUIDs */
	if (clock_class_a->uuid_set) {
		if (!clock_class_b->uuid_set) {
			BT_LOGT_STR("Clock classes differ: clock class A has a "
				"UUID, but clock class B does not.");
			goto end;
		}

		if (bt_uuid_compare(clock_class_a->uuid, clock_class_b->uuid) != 0) {
			BT_LOGT("Clock classes differ: different UUIDs: "
				"cc-a-uuid=\"" BT_UUID_FMT "\", "
				"cc-b-uuid=\"" BT_UUID_FMT "\"",
				BT_UUID_FMT_VALUES(clock_class_a->uuid),
				BT_UUID_FMT_VALUES(clock_class_b->uuid));
			goto end;
		}
	} else {
		if (clock_class_b->uuid_set) {
			BT_LOGT_STR("Clock classes differ: clock class A has "
				"no UUID, but clock class B has one.");
			goto end;
		}
	}

	/* Absolute */
	if (!!clock_class_a->absolute != !!clock_class_b->absolute) {
		BT_LOGT("Clock classes differ: one is absolute, the other "
			"is not: cc-a-is-absolute=%d, cc-b-is-absolute=%d",
			!!clock_class_a->absolute,
			!!clock_class_b->absolute);
		goto end;
	}

	/* Equal */
	ret = 0;

end:
	return ret;
}
Commit	Line	Data
16ca5ff0	1	/*
0235b0db	2	* SPDX-License-Identifier: MIT
16ca5ff0 PP	3	*
	4	* Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	5	*
0235b0db	6	* Babeltrace CTF writer - Clock class
16ca5ff0 PP	7	*/
16ca5ff0 PP	8
350ad6c1	9	#define BT_LOG_TAG "CTF-WRITER/CLOCK-CLASS"
67d2ce02	10	#include "logging.h"
16ca5ff0	11
6162e6b7	12	#include "common/uuid.h"
217cf9d3 PP	13	#include <babeltrace2-ctf-writer/utils.h>
217cf9d3 PP	14	#include <babeltrace2-ctf-writer/object.h>
578e048b	15	#include "compat/compiler.h"
578e048b	16	#include "compat/string.h"
c4f23e30	17	#include <stdbool.h>
16ca5ff0	18	#include <inttypes.h>
578e048b MJ	19	#include "common/assert.h"
	20
	21	#include "assert-pre.h"
	22	#include "clock-class.h"
	23	#include "object.h"
16ca5ff0 PP	24
16ca5ff0 PP	25	static
e1e02a22	26	void bt_ctf_clock_class_destroy(struct bt_ctf_object *obj);
16ca5ff0	27
00409097	28	bt_ctf_bool bt_ctf_clock_class_is_valid(struct bt_ctf_clock_class *clock_class)
16ca5ff0 PP	29	{
	30	return clock_class && clock_class->name;
	31	}
	32
16ca5ff0 PP	33	int bt_ctf_clock_class_set_name(struct bt_ctf_clock_class *clock_class,
	34	const char *name)
	35	{
	36	int ret = 0;
	37
	38	if (!clock_class) {
	39	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
	40	ret = -1;
	41	goto end;
	42	}
	43
	44	if (clock_class->frozen) {
	45	BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
	46	clock_class, bt_ctf_clock_class_get_name(clock_class));
	47	ret = -1;
	48	goto end;
	49	}
	50
	51	if (!bt_ctf_identifier_is_valid(name)) {
	52	BT_LOGW("Clock class's name is not a valid CTF identifier: "
	53	"addr=%p, name=\"%s\"",
	54	clock_class, name);
	55	ret = -1;
	56	goto end;
	57	}
	58
	59	if (clock_class->name) {
	60	g_string_assign(clock_class->name, name);
	61	} else {
	62	clock_class->name = g_string_new(name);
	63	if (!clock_class->name) {
	64	BT_LOGE_STR("Failed to allocate a GString.");
	65	ret = -1;
	66	goto end;
	67	}
	68	}
	69
ef267d12	70	BT_LOGT("Set clock class's name: addr=%p, name=\"%s\"",
16ca5ff0 PP	71	clock_class, name);
	72
	73	end:
	74	return ret;
	75	}
	76
	77	static
	78	bool validate_freq(struct bt_ctf_clock_class *clock_class,
	79	const char *name, uint64_t freq)
	80	{
	81	bool is_valid = true;
	82
	83	if (freq == -1ULL \|\| freq == 0) {
	84	BT_LOGW("Invalid parameter: frequency is invalid: "
	85	"addr=%p, name=\"%s\", freq=%" PRIu64,
	86	clock_class, name, freq);
	87	is_valid = false;
	88	goto end;
	89	}
	90
	91	end:
	92	return is_valid;
	93	}
	94
16ca5ff0 PP	95	struct bt_ctf_clock_class bt_ctf_clock_class_create(const char name,
	96	uint64_t freq)
	97	{
	98	int ret;
	99	struct bt_ctf_clock_class *clock_class = NULL;
	100
	101	BT_LOGD("Creating default clock class object: name=\"%s\"",
	102	name);
	103
	104	if (!validate_freq(NULL, name, freq)) {
	105	/* validate_freq() logs errors */
	106	goto error;
	107	}
	108
	109	clock_class = g_new0(struct bt_ctf_clock_class, 1);
	110	if (!clock_class) {
	111	BT_LOGE_STR("Failed to allocate one clock class.");
	112	goto error;
	113	}
	114
	115	clock_class->precision = 1;
	116	clock_class->frequency = freq;
e1e02a22	117	bt_ctf_object_init_shared(&clock_class->base, bt_ctf_clock_class_destroy);
16ca5ff0 PP	118
	119	if (name) {
	120	ret = bt_ctf_clock_class_set_name(clock_class, name);
	121	if (ret) {
	122	/* bt_ctf_clock_class_set_name() logs errors */
	123	goto error;
	124	}
	125	}
	126
	127	BT_LOGD("Created clock class object: addr=%p, name=\"%s\"",
	128	clock_class, name);
	129	return clock_class;
	130	error:
e1e02a22	131	BT_CTF_OBJECT_PUT_REF_AND_RESET(clock_class);
16ca5ff0 PP	132	return clock_class;
	133	}
	134
16ca5ff0 PP	135	const char bt_ctf_clock_class_get_name(struct bt_ctf_clock_class clock_class)
	136	{
	137	const char *ret = NULL;
	138
	139	if (!clock_class) {
	140	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
	141	goto end;
	142	}
	143
	144	if (clock_class->name) {
	145	ret = clock_class->name->str;
	146	}
	147
	148	end:
	149	return ret;
	150	}
	151
16ca5ff0 PP	152	const char *bt_ctf_clock_class_get_description(
	153	struct bt_ctf_clock_class *clock_class)
	154	{
	155	const char *ret = NULL;
	156
	157	if (!clock_class) {
	158	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
	159	goto end;
	160	}
	161
	162	if (clock_class->description) {
	163	ret = clock_class->description->str;
	164	}
	165	end:
	166	return ret;
	167	}
	168
16ca5ff0 PP	169	int bt_ctf_clock_class_set_description(struct bt_ctf_clock_class *clock_class,
	170	const char *desc)
	171	{
	172	int ret = 0;
	173
	174	if (!clock_class \|\| !desc) {
	175	BT_LOGW("Invalid parameter: clock class or description is NULL: "
	176	"clock-class-addr=%p, name=\"%s\", desc-addr=%p",
	177	clock_class, bt_ctf_clock_class_get_name(clock_class),
	178	desc);
	179	ret = -1;
	180	goto end;
	181	}
	182
	183	if (clock_class->frozen) {
	184	BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
	185	clock_class, bt_ctf_clock_class_get_name(clock_class));
	186	ret = -1;
	187	goto end;
	188	}
	189
	190	clock_class->description = g_string_new(desc);
	191	ret = clock_class->description ? 0 : -1;
ef267d12	192	BT_LOGT("Set clock class's description: addr=%p, "
16ca5ff0 PP	193	"name=\"%s\", desc=\"%s\"",
	194	clock_class, bt_ctf_clock_class_get_name(clock_class), desc);
	195	end:
	196	return ret;
	197	}
	198
16ca5ff0 PP	199	uint64_t bt_ctf_clock_class_get_frequency(
	200	struct bt_ctf_clock_class *clock_class)
	201	{
	202	uint64_t ret = -1ULL;
	203
	204	if (!clock_class) {
	205	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
	206	goto end;
	207	}
	208
	209	ret = clock_class->frequency;
	210	end:
	211	return ret;
	212	}
	213
16ca5ff0 PP	214	int bt_ctf_clock_class_set_frequency(struct bt_ctf_clock_class *clock_class,
	215	uint64_t freq)
	216	{
	217	int ret = 0;
	218
	219	if (!clock_class) {
	220	BT_LOGW("Invalid parameter: clock class is NULL or frequency is invalid: "
	221	"addr=%p, name=\"%s\"",
	222	clock_class, bt_ctf_clock_class_get_name(clock_class));
	223	ret = -1;
	224	goto end;
	225	}
	226
	227	if (!validate_freq(clock_class, bt_ctf_clock_class_get_name(clock_class),
	228	freq)) {
	229	/* validate_freq() logs errors */
	230	goto end;
	231	}
	232
	233	if (clock_class->frozen) {
	234	BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
	235	clock_class, bt_ctf_clock_class_get_name(clock_class));
	236	ret = -1;
	237	goto end;
	238	}
	239
	240	clock_class->frequency = freq;
ef267d12	241	BT_LOGT("Set clock class's frequency: addr=%p, name=\"%s\", freq=%" PRIu64,
16ca5ff0 PP	242	clock_class, bt_ctf_clock_class_get_name(clock_class), freq);
	243	end:
	244	return ret;
	245	}
	246
16ca5ff0 PP	247	uint64_t bt_ctf_clock_class_get_precision(struct bt_ctf_clock_class *clock_class)
	248	{
	249	uint64_t ret = -1ULL;
	250
	251	if (!clock_class) {
	252	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
	253	goto end;
	254	}
	255
	256	ret = clock_class->precision;
	257	end:
	258	return ret;
	259	}
	260
16ca5ff0 PP	261	int bt_ctf_clock_class_set_precision(struct bt_ctf_clock_class *clock_class,
	262	uint64_t precision)
	263	{
	264	int ret = 0;
	265
	266	if (!clock_class \|\| precision == -1ULL) {
	267	BT_LOGW("Invalid parameter: clock class is NULL or precision is invalid: "
	268	"addr=%p, name=\"%s\", precision=%" PRIu64,
	269	clock_class, bt_ctf_clock_class_get_name(clock_class),
	270	precision);
	271	ret = -1;
	272	goto end;
	273	}
	274
	275	if (clock_class->frozen) {
	276	BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
	277	clock_class, bt_ctf_clock_class_get_name(clock_class));
	278	ret = -1;
	279	goto end;
	280	}
	281
	282	clock_class->precision = precision;
ef267d12	283	BT_LOGT("Set clock class's precision: addr=%p, name=\"%s\", precision=%" PRIu64,
16ca5ff0 PP	284	clock_class, bt_ctf_clock_class_get_name(clock_class),
	285	precision);
	286	end:
	287	return ret;
	288	}
	289
16ca5ff0 PP	290	int bt_ctf_clock_class_get_offset_s(struct bt_ctf_clock_class *clock_class,
	291	int64_t *offset_s)
	292	{
	293	int ret = 0;
	294
	295	if (!clock_class \|\| !offset_s) {
	296	BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: "
	297	"clock-class-addr=%p, name=\"%s\", offset-addr=%p",
	298	clock_class, bt_ctf_clock_class_get_name(clock_class),
	299	offset_s);
	300	ret = -1;
	301	goto end;
	302	}
	303
	304	*offset_s = clock_class->offset_s;
	305	end:
	306	return ret;
	307	}
	308
16ca5ff0 PP	309	int bt_ctf_clock_class_set_offset_s(struct bt_ctf_clock_class *clock_class,
	310	int64_t offset_s)
	311	{
	312	int ret = 0;
	313
	314	if (!clock_class) {
	315	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
	316	ret = -1;
	317	goto end;
	318	}
	319
	320	if (clock_class->frozen) {
	321	BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
	322	clock_class, bt_ctf_clock_class_get_name(clock_class));
	323	ret = -1;
	324	goto end;
	325	}
	326
	327	clock_class->offset_s = offset_s;
ef267d12	328	BT_LOGT("Set clock class's offset (seconds): "
16ca5ff0 PP	329	"addr=%p, name=\"%s\", offset-s=%" PRId64,
	330	clock_class, bt_ctf_clock_class_get_name(clock_class),
	331	offset_s);
	332	end:
	333	return ret;
	334	}
	335
16ca5ff0 PP	336	int bt_ctf_clock_class_get_offset_cycles(struct bt_ctf_clock_class *clock_class,
	337	int64_t *offset)
	338	{
	339	int ret = 0;
	340
	341	if (!clock_class \|\| !offset) {
	342	BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: "
	343	"clock-class-addr=%p, name=\"%s\", offset-addr=%p",
	344	clock_class, bt_ctf_clock_class_get_name(clock_class),
	345	offset);
	346	ret = -1;
	347	goto end;
	348	}
	349
	350	*offset = clock_class->offset;
	351	end:
	352	return ret;
	353	}
	354
16ca5ff0 PP	355	int bt_ctf_clock_class_set_offset_cycles(struct bt_ctf_clock_class *clock_class,
	356	int64_t offset)
	357	{
	358	int ret = 0;
	359
	360	if (!clock_class) {
	361	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
	362	ret = -1;
	363	goto end;
	364	}
	365
	366	if (clock_class->frozen) {
	367	BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
	368	clock_class, bt_ctf_clock_class_get_name(clock_class));
	369	ret = -1;
	370	goto end;
	371	}
	372
	373	clock_class->offset = offset;
ef267d12	374	BT_LOGT("Set clock class's offset (cycles): addr=%p, name=\"%s\", offset-cycles=%" PRId64,
16ca5ff0 PP	375	clock_class, bt_ctf_clock_class_get_name(clock_class), offset);
	376	end:
	377	return ret;
	378	}
	379
00409097	380	bt_ctf_bool bt_ctf_clock_class_is_absolute(struct bt_ctf_clock_class *clock_class)
16ca5ff0 PP	381	{
	382	int ret = -1;
	383
	384	if (!clock_class) {
	385	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
	386	goto end;
	387	}
	388
	389	ret = clock_class->absolute;
	390	end:
	391	return ret;
	392	}
	393
16ca5ff0	394	int bt_ctf_clock_class_set_is_absolute(struct bt_ctf_clock_class *clock_class,
00409097	395	bt_ctf_bool is_absolute)
16ca5ff0 PP	396	{
	397	int ret = 0;
	398
	399	if (!clock_class) {
	400	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
	401	ret = -1;
	402	goto end;
	403	}
	404
	405	if (clock_class->frozen) {
	406	BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
	407	clock_class, bt_ctf_clock_class_get_name(clock_class));
	408	ret = -1;
	409	goto end;
	410	}
	411
	412	clock_class->absolute = !!is_absolute;
ef267d12	413	BT_LOGT("Set clock class's absolute flag: addr=%p, name=\"%s\", is-absolute=%d",
16ca5ff0 PP	414	clock_class, bt_ctf_clock_class_get_name(clock_class),
	415	is_absolute);
	416	end:
	417	return ret;
	418	}
	419
6162e6b7	420	const uint8_t *bt_ctf_clock_class_get_uuid(
16ca5ff0 PP	421	struct bt_ctf_clock_class *clock_class)
16ca5ff0 PP	422	{
6162e6b7	423	const uint8_t *ret;
16ca5ff0 PP	424
	425	if (!clock_class) {
	426	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
	427	ret = NULL;
	428	goto end;
	429	}
	430
	431	if (!clock_class->uuid_set) {
ef267d12	432	BT_LOGT("Clock class's UUID is not set: addr=%p, name=\"%s\"",
16ca5ff0 PP	433	clock_class, bt_ctf_clock_class_get_name(clock_class));
	434	ret = NULL;
	435	goto end;
	436	}
	437
	438	ret = clock_class->uuid;
	439	end:
	440	return ret;
	441	}
	442
16ca5ff0	443	int bt_ctf_clock_class_set_uuid(struct bt_ctf_clock_class *clock_class,
6162e6b7	444	const uint8_t *uuid)
16ca5ff0 PP	445	{
	446	int ret = 0;
	447
	448	if (!clock_class \|\| !uuid) {
	449	BT_LOGW("Invalid parameter: clock class or UUID is NULL: "
	450	"clock-class-addr=%p, name=\"%s\", uuid-addr=%p",
	451	clock_class, bt_ctf_clock_class_get_name(clock_class),
	452	uuid);
	453	ret = -1;
	454	goto end;
	455	}
	456
	457	if (clock_class->frozen) {
	458	BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"",
	459	clock_class, bt_ctf_clock_class_get_name(clock_class));
	460	ret = -1;
	461	goto end;
	462	}
	463
6162e6b7	464	bt_uuid_copy(clock_class->uuid, uuid);
16ca5ff0	465	clock_class->uuid_set = 1;
6162e6b7	466	BT_LOGT("Set clock class's UUID: addr=%p, name=\"%s\", uuid=\"" BT_UUID_FMT "\"",
16ca5ff0	467	clock_class, bt_ctf_clock_class_get_name(clock_class),
6162e6b7	468	BT_UUID_FMT_VALUES(uuid));
16ca5ff0 PP	469	end:
	470	return ret;
	471	}
	472
16ca5ff0 PP	473	void bt_ctf_clock_class_freeze(struct bt_ctf_clock_class *clock_class)
	474	{
	475	if (!clock_class \|\| clock_class->frozen) {
	476	return;
	477	}
	478
	479	BT_LOGD("Freezing clock class: addr=%p, name=\"%s\"",
	480	clock_class, bt_ctf_clock_class_get_name(clock_class));
	481	clock_class->frozen = 1;
	482	}
	483
	484	static
e1e02a22	485	void bt_ctf_clock_class_destroy(struct bt_ctf_object *obj)
16ca5ff0 PP	486	{
	487	struct bt_ctf_clock_class *clock_class;
	488
	489	clock_class = container_of(obj, struct bt_ctf_clock_class, base);
	490	BT_LOGD("Destroying clock class: addr=%p, name=\"%s\"",
	491	obj, bt_ctf_clock_class_get_name(clock_class));
	492
	493	if (clock_class->name) {
	494	g_string_free(clock_class->name, TRUE);
	495	}
	496
	497	if (clock_class->description) {
	498	g_string_free(clock_class->description, TRUE);
	499	}
	500
	501	g_free(clock_class);
	502	}
	503
16ca5ff0 PP	504	int bt_ctf_clock_class_compare(struct bt_ctf_clock_class *clock_class_a,
	505	struct bt_ctf_clock_class *clock_class_b)
	506	{
	507	int ret = 1;
98b15851 PP	508	BT_ASSERT_DBG(clock_class_a);
98b15851 PP	509	BT_ASSERT_DBG(clock_class_b);
16ca5ff0 PP	510
	511	/* Name */
	512	if (strcmp(clock_class_a->name->str, clock_class_b->name->str) != 0) {
ef267d12	513	BT_LOGT("Clock classes differ: different names: "
16ca5ff0 PP	514	"cc-a-name=\"%s\", cc-b-name=\"%s\"",
	515	clock_class_a->name->str,
	516	clock_class_b->name->str);
	517	goto end;
	518	}
	519
	520	/* Description */
	521	if (clock_class_a->description) {
	522	if (!clock_class_b->description) {
ef267d12	523	BT_LOGT_STR("Clock classes differ: clock class A has a "
16ca5ff0 PP	524	"description, but clock class B does not.");
	525	goto end;
	526	}
	527
	528	if (strcmp(clock_class_a->name->str, clock_class_b->name->str)
	529	!= 0) {
ef267d12	530	BT_LOGT("Clock classes differ: different descriptions: "
16ca5ff0 PP	531	"cc-a-descr=\"%s\", cc-b-descr=\"%s\"",
	532	clock_class_a->description->str,
	533	clock_class_b->description->str);
	534	goto end;
	535	}
	536	} else {
	537	if (clock_class_b->description) {
ef267d12	538	BT_LOGT_STR("Clock classes differ: clock class A has "
16ca5ff0 PP	539	"no description, but clock class B has one.");
	540	goto end;
	541	}
	542	}
	543
	544	/* Frequency */
	545	if (clock_class_a->frequency != clock_class_b->frequency) {
ef267d12	546	BT_LOGT("Clock classes differ: different frequencies: "
16ca5ff0 PP	547	"cc-a-freq=%" PRIu64 ", cc-b-freq=%" PRIu64,
	548	clock_class_a->frequency,
	549	clock_class_b->frequency);
	550	goto end;
	551	}
	552
	553	/* Precision */
	554	if (clock_class_a->precision != clock_class_b->precision) {
ef267d12	555	BT_LOGT("Clock classes differ: different precisions: "
16ca5ff0 PP	556	"cc-a-freq=%" PRIu64 ", cc-b-freq=%" PRIu64,
	557	clock_class_a->precision,
	558	clock_class_b->precision);
	559	goto end;
	560	}
	561
	562	/* Offset (seconds) */
	563	if (clock_class_a->offset_s != clock_class_b->offset_s) {
ef267d12	564	BT_LOGT("Clock classes differ: different offsets (seconds): "
16ca5ff0 PP	565	"cc-a-offset-s=%" PRId64 ", cc-b-offset-s=%" PRId64,
	566	clock_class_a->offset_s,
	567	clock_class_b->offset_s);
	568	goto end;
	569	}
	570
	571	/* Offset (cycles) */
	572	if (clock_class_a->offset != clock_class_b->offset) {
ef267d12	573	BT_LOGT("Clock classes differ: different offsets (cycles): "
16ca5ff0 PP	574	"cc-a-offset-s=%" PRId64 ", cc-b-offset-s=%" PRId64,
	575	clock_class_a->offset,
	576	clock_class_b->offset);
	577	goto end;
	578	}
	579
	580	/* UUIDs */
	581	if (clock_class_a->uuid_set) {
	582	if (!clock_class_b->uuid_set) {
ef267d12	583	BT_LOGT_STR("Clock classes differ: clock class A has a "
16ca5ff0 PP	584	"UUID, but clock class B does not.");
	585	goto end;
	586	}
	587
6162e6b7	588	if (bt_uuid_compare(clock_class_a->uuid, clock_class_b->uuid) != 0) {
ef267d12	589	BT_LOGT("Clock classes differ: different UUIDs: "
6162e6b7 MJ	590	"cc-a-uuid=\"" BT_UUID_FMT "\", "
	591	"cc-b-uuid=\"" BT_UUID_FMT "\"",
	592	BT_UUID_FMT_VALUES(clock_class_a->uuid),
	593	BT_UUID_FMT_VALUES(clock_class_b->uuid));
16ca5ff0 PP	594	goto end;
	595	}
	596	} else {
	597	if (clock_class_b->uuid_set) {
ef267d12	598	BT_LOGT_STR("Clock classes differ: clock class A has "
16ca5ff0 PP	599	"no UUID, but clock class B has one.");
	600	goto end;
	601	}
	602	}
	603
	604	/* Absolute */
	605	if (!!clock_class_a->absolute != !!clock_class_b->absolute) {
ef267d12	606	BT_LOGT("Clock classes differ: one is absolute, the other "
16ca5ff0 PP	607	"is not: cc-a-is-absolute=%d, cc-b-is-absolute=%d",
	608	!!clock_class_a->absolute,
	609	!!clock_class_b->absolute);
	610	goto end;
	611	}
	612
	613	/* Equal */
	614	ret = 0;
	615
	616	end:
	617	return ret;
	618	}