[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_HIDDEN
bt_ctf_bool bt_ctf_clock_class_is_valid(struct bt_ctf_clock_class *clock_class)
{
	return clock_class && clock_class->name;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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_HIDDEN
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;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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);
}

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