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