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

/*
 * clock-class.c
 *
 * Babeltrace CTF writer - Clock class
 *
 * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

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