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

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

#include <babeltrace/ctf-ir/clock-class-internal.h>
#include <babeltrace/ctf-ir/utils.h>
#include <babeltrace/ref.h>
#include <babeltrace/object-internal.h>
#include <babeltrace/compiler-internal.h>
#include <inttypes.h>

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

static
void bt_ctf_clock_class_destroy(struct bt_object *obj);

BT_HIDDEN
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",
			clock_class);
		ret = -1;
		goto end;
	}

	if (bt_ctf_validate_identifier(name)) {
		BT_LOGE("Clock class's name is not a valid CTF identifier: "
			"clock-class-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_LOGV("Set clock class's name: clock-class-addr=%p, name=\"%s\"",
		clock_class, name);

end:
	return ret;
}

struct bt_ctf_clock_class *bt_ctf_clock_class_create(const char *name)
{
	int ret;
	struct bt_ctf_clock_class *clock_class;

	BT_LOGD("Creating default clock class object: name=\"%s\"",
		name);
	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 = 1000000000;
	bt_object_init(clock_class, bt_ctf_clock_class_destroy);

	if (name) {
		ret = bt_ctf_clock_class_set_name(clock_class, name);
		if (ret) {
			BT_LOGE("Cannot set clock class's name: "
				"clock-class-addr=%p, name=\"%s\"",
				clock_class, name);
			goto error;
		}
	}

	ret = bt_uuid_generate(clock_class->uuid);
	if (ret) {
		BT_LOGE_STR("Failed to generate a UUID.");
		goto error;
	}

	clock_class->uuid_set = 1;
	BT_LOGD("Created clock class object: addr=%p", clock_class);
	return clock_class;
error:
	BT_PUT(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, desc-addr=%p",
			clock_class, desc);
		ret = -1;
		goto end;
	}

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

	clock_class->description = g_string_new(desc);
	ret = clock_class->description ? 0 : -1;
	BT_LOGV("Set clock class's description: clock-class-addr=%p, desc=\"%s\"",
		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 || freq == -1ULL) {
		BT_LOGW("Invalid parameter: clock class is NULL or frequency is invalid: "
			"clock-class-addr=%p, freq=%" PRIu64,
			clock_class, freq);
		ret = -1;
		goto end;
	}

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

	clock_class->frequency = freq;
	BT_LOGV("Set clock class's frequency: clock-class-addr=%p, freq=%" PRIu64,
		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: "
			"clock-class-addr=%p, precision=%" PRIu64,
			clock_class, precision);
		ret = -1;
		goto end;
	}

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

	clock_class->precision = precision;
	BT_LOGV("Set clock class's precision: clock-class-addr=%p, precision=%" PRIu64,
		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, offset-addr=%p",
			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",
			clock_class);
		ret = -1;
		goto end;
	}

	clock_class->offset_s = offset_s;
	BT_LOGV("Set clock class's offset (seconds): clock-class-addr=%p, offset-s=%" PRId64,
		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, offset-addr=%p",
			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",
			clock_class);
		ret = -1;
		goto end;
	}

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

int 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,
		int 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",
			clock_class);
		ret = -1;
		goto end;
	}

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

const unsigned char *bt_ctf_clock_class_get_uuid(
		struct bt_ctf_clock_class *clock_class)
{
	const unsigned char *ret;

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

	if (!clock_class->uuid_set) {
		BT_LOGV("Clock class's UUID is not set: clock-class-addr=%p",
			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 unsigned char *uuid)
{
	int ret = 0;

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

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

	memcpy(clock_class->uuid, uuid, sizeof(uuid_t));
	clock_class->uuid_set = 1;
	BT_LOGV("Set clock class's UUID: clock-class-addr=%p, "
		"uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\"",
		clock_class,
		(unsigned int) uuid[0],
		(unsigned int) uuid[1],
		(unsigned int) uuid[2],
		(unsigned int) uuid[3],
		(unsigned int) uuid[4],
		(unsigned int) uuid[5],
		(unsigned int) uuid[6],
		(unsigned int) uuid[7],
		(unsigned int) uuid[8],
		(unsigned int) uuid[9],
		(unsigned int) uuid[10],
		(unsigned int) uuid[11],
		(unsigned int) uuid[12],
		(unsigned int) uuid[13],
		(unsigned int) uuid[14],
		(unsigned int) uuid[15]);
end:
	return ret;
}

static uint64_t ns_from_value(uint64_t frequency, uint64_t value)
{
	uint64_t ns;

	if (frequency == 1000000000) {
		ns = value;
	} else {
		ns = (uint64_t) ((1e9 * (double) value) / (double) frequency);
	}

	return ns;
}

BT_HIDDEN
void bt_ctf_clock_class_freeze(struct bt_ctf_clock_class *clock_class)
{
	if (!clock_class) {
		BT_LOGW_STR("Invalid parameter: clock class is NULL.");
		return;
	}

	if (!clock_class->frozen) {
		BT_LOGD("Freezing clock class: addr=%p", clock_class);
		clock_class->frozen = 1;
	}
}

BT_HIDDEN
void bt_ctf_clock_class_serialize(struct bt_ctf_clock_class *clock_class,
		struct metadata_context *context)
{
	unsigned char *uuid;

	BT_LOGD("Serializing clock class's metadata: clock-class-addr=%p, "
		"metadata-context-addr=%p", clock_class, context);

	if (!clock_class || !context) {
		BT_LOGW("Invalid parameter: clock class or metadata context is NULL: "
			"clock-class-addr=%p, metadata-context-addr=%p",
			clock_class, context);
		return;
	}

	uuid = clock_class->uuid;
	g_string_append(context->string, "clock {\n");
	g_string_append_printf(context->string, "\tname = %s;\n",
		clock_class->name->str);
	g_string_append_printf(context->string,
		"\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n",
		uuid[0], uuid[1], uuid[2], uuid[3],
		uuid[4], uuid[5], uuid[6], uuid[7],
		uuid[8], uuid[9], uuid[10], uuid[11],
		uuid[12], uuid[13], uuid[14], uuid[15]);
	if (clock_class->description) {
		g_string_append_printf(context->string, "\tdescription = \"%s\";\n",
			clock_class->description->str);
	}

	g_string_append_printf(context->string, "\tfreq = %" PRIu64 ";\n",
		clock_class->frequency);
	g_string_append_printf(context->string, "\tprecision = %" PRIu64 ";\n",
		clock_class->precision);
	g_string_append_printf(context->string, "\toffset_s = %" PRIu64 ";\n",
		clock_class->offset_s);
	g_string_append_printf(context->string, "\toffset = %" PRIu64 ";\n",
		clock_class->offset);
	g_string_append_printf(context->string, "\tabsolute = %s;\n",
		clock_class->absolute ? "TRUE" : "FALSE");
	g_string_append(context->string, "};\n\n");
}

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

	BT_LOGD("Destroying clock class: addr=%p", obj);
	clock_class = container_of(obj, struct bt_ctf_clock_class, base);
	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);
}

static
void bt_ctf_clock_value_destroy(struct bt_object *obj)
{
	struct bt_ctf_clock_value *value;

	BT_LOGD("Destroying clock value: addr=%p", obj);

	if (!obj) {
		return;
	}

	value = container_of(obj, struct bt_ctf_clock_value, base);
	bt_put(value->clock_class);
	g_free(value);
}

struct bt_ctf_clock_value *bt_ctf_clock_value_create(
		struct bt_ctf_clock_class *clock_class, uint64_t value)
{
	struct bt_ctf_clock_value *ret = NULL;

	BT_LOGD("Creating clock value object: clock-class-addr=%p, "
		"value=%" PRIu64, clock_class, value);

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

	ret = g_new0(struct bt_ctf_clock_value, 1);
	if (!ret) {
		BT_LOGE_STR("Failed to allocate one clock value.");
		goto end;
	}

	bt_object_init(ret, bt_ctf_clock_value_destroy);
	ret->clock_class = bt_get(clock_class);
	ret->value = value;
	BT_LOGD("Created clock value object: addr=%p", ret);
end:
	return ret;
}

int bt_ctf_clock_value_get_value(
		struct bt_ctf_clock_value *clock_value, uint64_t *raw_value)
{
	int ret = 0;

	if (!clock_value || !raw_value) {
		BT_LOGW("Invalid parameter: clock value or raw value is NULL: "
			"clock-value-addr=%p, raw-value-addr=%p",
			clock_value, raw_value);
		ret = -1;
		goto end;
	}

	*raw_value = clock_value->value;
end:
	return ret;
}

int bt_ctf_clock_value_get_value_ns_from_epoch(struct bt_ctf_clock_value *value,
		int64_t *ret_value_ns)
{
	int ret = 0;
	int64_t ns;

	if (!value || !ret_value_ns) {
		BT_LOGW("Invalid parameter: clock value or return value pointer is NULL: "
			"clock-value-addr=%p, ret-value-addr=%p",
			value, ret_value_ns);
		ret = -1;
		goto end;
	}

	/* Initialize nanosecond timestamp to clock's offset in seconds. */
	ns = value->clock_class->offset_s * (int64_t) 1000000000;

	/* Add offset in cycles, converted to nanoseconds. */
	ns += ns_from_value(value->clock_class->frequency,
			value->clock_class->offset);

	/* Add given value, converter to nanoseconds. */
	ns += ns_from_value(value->clock_class->frequency, value->value);

	*ret_value_ns = ns;
end:
	return ret;
}

struct bt_ctf_clock_class *bt_ctf_clock_value_get_class(
		struct bt_ctf_clock_value *clock_value)
{
	struct bt_ctf_clock_class *clock_class = NULL;

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

	clock_class = bt_get(clock_value->clock_class);

end:
	return clock_class;
}
Commit	Line	Data
273b65be	1	/*
ac0c6bdd	2	* clock-class.c
273b65be	3	*
ac0c6bdd	4	* Babeltrace CTF IR - Clock class
273b65be	5	*
de9dd397	6	* Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
273b65be JG	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
ac0c6bdd	29	#include <babeltrace/ctf-ir/clock-class-internal.h>
654c1444	30	#include <babeltrace/ctf-ir/utils.h>
83509119	31	#include <babeltrace/ref.h>
83509119	32	#include <babeltrace/object-internal.h>
3d9990ac	33	#include <babeltrace/compiler-internal.h>
273b65be JG	34	#include <inttypes.h>
273b65be JG	35
5134570b PP	36	#define BT_LOG_TAG "CLOCK-CLASS"
	37	#include <babeltrace/lib-logging-internal.h>
	38
273b65be	39	static
ac0c6bdd	40	void bt_ctf_clock_class_destroy(struct bt_object *obj);
273b65be	41
4c426c17	42	BT_HIDDEN
ac0c6bdd	43	bool bt_ctf_clock_class_is_valid(struct bt_ctf_clock_class *clock_class)
c06116f3	44	{
ac0c6bdd	45	return clock_class && clock_class->name;
c06116f3 PP	46	}
c06116f3 PP	47
ac0c6bdd	48	int bt_ctf_clock_class_set_name(struct bt_ctf_clock_class *clock_class,
4c426c17 JG	49	const char *name)
	50	{
	51	int ret = 0;
273b65be	52
5134570b PP	53	if (!clock_class) {
	54	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
	55	ret = -1;
	56	goto end;
	57	}
	58
	59	if (clock_class->frozen) {
	60	BT_LOGW("Invalid parameter: clock class is frozen: addr=%p",
	61	clock_class);
c06116f3 PP	62	ret = -1;
	63	goto end;
	64	}
	65
654c1444	66	if (bt_ctf_validate_identifier(name)) {
5134570b PP	67	BT_LOGE("Clock class's name is not a valid CTF identifier: "
	68	"clock-class-addr=%p, name=\"%s\"",
	69	clock_class, name);
4c426c17 JG	70	ret = -1;
4c426c17 JG	71	goto end;
273b65be JG	72	}
273b65be JG	73
ac0c6bdd PP	74	if (clock_class->name) {
ac0c6bdd PP	75	g_string_assign(clock_class->name, name);
e1ae7645	76	} else {
ac0c6bdd PP	77	clock_class->name = g_string_new(name);
ac0c6bdd PP	78	if (!clock_class->name) {
5134570b	79	BT_LOGE_STR("Failed to allocate a GString.");
e1ae7645 JG	80	ret = -1;
	81	goto end;
	82	}
273b65be JG	83	}
273b65be JG	84
5134570b PP	85	BT_LOGV("Set clock class's name: clock-class-addr=%p, name=\"%s\"",
	86	clock_class, name);
	87
4c426c17 JG	88	end:
	89	return ret;
	90	}
	91
ac0c6bdd	92	struct bt_ctf_clock_class bt_ctf_clock_class_create(const char name)
4c426c17 JG	93	{
4c426c17 JG	94	int ret;
5134570b	95	struct bt_ctf_clock_class *clock_class;
4c426c17	96
5134570b PP	97	BT_LOGD("Creating default clock class object: name=\"%s\"",
	98	name);
	99	clock_class = g_new0(struct bt_ctf_clock_class, 1);
ac0c6bdd	100	if (!clock_class) {
5134570b	101	BT_LOGE_STR("Failed to allocate one clock class.");
4c426c17 JG	102	goto error;
	103	}
	104
ac0c6bdd PP	105	clock_class->precision = 1;
	106	clock_class->frequency = 1000000000;
	107	bt_object_init(clock_class, bt_ctf_clock_class_destroy);
85380e99 JG	108
85380e99 JG	109	if (name) {
ac0c6bdd	110	ret = bt_ctf_clock_class_set_name(clock_class, name);
85380e99	111	if (ret) {
5134570b PP	112	BT_LOGE("Cannot set clock class's name: "
	113	"clock-class-addr=%p, name=\"%s\"",
	114	clock_class, name);
85380e99 JG	115	goto error;
85380e99 JG	116	}
273b65be JG	117	}
273b65be JG	118
ac0c6bdd	119	ret = bt_uuid_generate(clock_class->uuid);
be018f15	120	if (ret) {
5134570b	121	BT_LOGE_STR("Failed to generate a UUID.");
83509119	122	goto error;
be018f15 JG	123	}
be018f15 JG	124
ac0c6bdd	125	clock_class->uuid_set = 1;
5134570b	126	BT_LOGD("Created clock class object: addr=%p", clock_class);
ac0c6bdd	127	return clock_class;
273b65be	128	error:
ac0c6bdd PP	129	BT_PUT(clock_class);
ac0c6bdd PP	130	return clock_class;
87d76bb1 JG	131	}
87d76bb1 JG	132
ac0c6bdd	133	const char bt_ctf_clock_class_get_name(struct bt_ctf_clock_class clock_class)
87d76bb1 JG	134	{
	135	const char *ret = NULL;
	136
ac0c6bdd	137	if (!clock_class) {
5134570b	138	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
87d76bb1 JG	139	goto end;
	140	}
	141
ac0c6bdd PP	142	if (clock_class->name) {
ac0c6bdd PP	143	ret = clock_class->name->str;
87d76bb1 JG	144	}
	145
	146	end:
	147	return ret;
	148	}
	149
ac0c6bdd PP	150	const char *bt_ctf_clock_class_get_description(
ac0c6bdd PP	151	struct bt_ctf_clock_class *clock_class)
87d76bb1 JG	152	{
	153	const char *ret = NULL;
	154
ac0c6bdd	155	if (!clock_class) {
5134570b	156	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
87d76bb1 JG	157	goto end;
	158	}
	159
ac0c6bdd PP	160	if (clock_class->description) {
ac0c6bdd PP	161	ret = clock_class->description->str;
87d76bb1 JG	162	}
	163	end:
	164	return ret;
273b65be JG	165	}
273b65be JG	166
ac0c6bdd PP	167	int bt_ctf_clock_class_set_description(struct bt_ctf_clock_class *clock_class,
ac0c6bdd PP	168	const char *desc)
273b65be JG	169	{
	170	int ret = 0;
	171
5134570b PP	172	if (!clock_class \|\| !desc) {
	173	BT_LOGW("Invalid parameter: clock class or description is NULL: "
	174	"clock-class-addr=%p, desc-addr=%p",
	175	clock_class, desc);
	176	ret = -1;
	177	goto end;
	178	}
	179
	180	if (clock_class->frozen) {
	181	BT_LOGW("Invalid parameter: clock class is frozen: addr=%p",
	182	clock_class);
273b65be JG	183	ret = -1;
	184	goto end;
	185	}
	186
ac0c6bdd PP	187	clock_class->description = g_string_new(desc);
ac0c6bdd PP	188	ret = clock_class->description ? 0 : -1;
5134570b PP	189	BT_LOGV("Set clock class's description: clock-class-addr=%p, desc=\"%s\"",
5134570b PP	190	clock_class, desc);
273b65be JG	191	end:
	192	return ret;
	193	}
	194
ac0c6bdd PP	195	uint64_t bt_ctf_clock_class_get_frequency(
ac0c6bdd PP	196	struct bt_ctf_clock_class *clock_class)
87d76bb1 JG	197	{
	198	uint64_t ret = -1ULL;
	199
ac0c6bdd	200	if (!clock_class) {
5134570b	201	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
87d76bb1 JG	202	goto end;
	203	}
	204
ac0c6bdd	205	ret = clock_class->frequency;
87d76bb1 JG	206	end:
	207	return ret;
	208	}
	209
ac0c6bdd PP	210	int bt_ctf_clock_class_set_frequency(struct bt_ctf_clock_class *clock_class,
ac0c6bdd PP	211	uint64_t freq)
273b65be JG	212	{
	213	int ret = 0;
	214
5134570b PP	215	if (!clock_class \|\| freq == -1ULL) {
	216	BT_LOGW("Invalid parameter: clock class is NULL or frequency is invalid: "
	217	"clock-class-addr=%p, freq=%" PRIu64,
	218	clock_class, freq);
	219	ret = -1;
	220	goto end;
	221	}
	222
	223	if (clock_class->frozen) {
	224	BT_LOGW("Invalid parameter: clock class is frozen: addr=%p",
	225	clock_class);
273b65be JG	226	ret = -1;
	227	goto end;
	228	}
	229
ac0c6bdd	230	clock_class->frequency = freq;
5134570b PP	231	BT_LOGV("Set clock class's frequency: clock-class-addr=%p, freq=%" PRIu64,
5134570b PP	232	clock_class, freq);
273b65be JG	233	end:
	234	return ret;
	235	}
	236
ac0c6bdd	237	uint64_t bt_ctf_clock_class_get_precision(struct bt_ctf_clock_class *clock_class)
87d76bb1 JG	238	{
	239	uint64_t ret = -1ULL;
	240
ac0c6bdd	241	if (!clock_class) {
5134570b	242	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
87d76bb1 JG	243	goto end;
	244	}
	245
ac0c6bdd	246	ret = clock_class->precision;
87d76bb1 JG	247	end:
	248	return ret;
	249	}
	250
ac0c6bdd PP	251	int bt_ctf_clock_class_set_precision(struct bt_ctf_clock_class *clock_class,
ac0c6bdd PP	252	uint64_t precision)
273b65be JG	253	{
	254	int ret = 0;
	255
5134570b PP	256	if (!clock_class \|\| precision == -1ULL) {
	257	BT_LOGW("Invalid parameter: clock class is NULL or precision is invalid: "
	258	"clock-class-addr=%p, precision=%" PRIu64,
	259	clock_class, precision);
	260	ret = -1;
	261	goto end;
	262	}
	263
	264	if (clock_class->frozen) {
	265	BT_LOGW("Invalid parameter: clock class is frozen: addr=%p",
	266	clock_class);
273b65be JG	267	ret = -1;
	268	goto end;
	269	}
	270
ac0c6bdd	271	clock_class->precision = precision;
5134570b PP	272	BT_LOGV("Set clock class's precision: clock-class-addr=%p, precision=%" PRIu64,
5134570b PP	273	clock_class, precision);
273b65be JG	274	end:
	275	return ret;
	276	}
	277
ac0c6bdd PP	278	int bt_ctf_clock_class_get_offset_s(struct bt_ctf_clock_class *clock_class,
ac0c6bdd PP	279	int64_t *offset_s)
87d76bb1	280	{
61cf588b	281	int ret = 0;
87d76bb1	282
ac0c6bdd	283	if (!clock_class \|\| !offset_s) {
5134570b PP	284	BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: "
	285	"clock-class-addr=%p, offset-addr=%p",
	286	clock_class, offset_s);
61cf588b	287	ret = -1;
87d76bb1 JG	288	goto end;
	289	}
	290
ac0c6bdd	291	*offset_s = clock_class->offset_s;
87d76bb1 JG	292	end:
	293	return ret;
	294	}
	295
ac0c6bdd PP	296	int bt_ctf_clock_class_set_offset_s(struct bt_ctf_clock_class *clock_class,
ac0c6bdd PP	297	int64_t offset_s)
273b65be JG	298	{
	299	int ret = 0;
	300
5134570b PP	301	if (!clock_class) {
	302	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
	303	ret = -1;
	304	goto end;
	305	}
	306
	307	if (clock_class->frozen) {
	308	BT_LOGW("Invalid parameter: clock class is frozen: addr=%p",
	309	clock_class);
273b65be JG	310	ret = -1;
	311	goto end;
	312	}
	313
ac0c6bdd	314	clock_class->offset_s = offset_s;
5134570b PP	315	BT_LOGV("Set clock class's offset (seconds): clock-class-addr=%p, offset-s=%" PRId64,
5134570b PP	316	clock_class, offset_s);
273b65be JG	317	end:
	318	return ret;
	319	}
	320
ac0c6bdd PP	321	int bt_ctf_clock_class_get_offset_cycles(struct bt_ctf_clock_class *clock_class,
ac0c6bdd PP	322	int64_t *offset)
87d76bb1	323	{
61cf588b	324	int ret = 0;
87d76bb1	325
ac0c6bdd	326	if (!clock_class \|\| !offset) {
5134570b PP	327	BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: "
	328	"clock-class-addr=%p, offset-addr=%p",
	329	clock_class, offset);
61cf588b	330	ret = -1;
87d76bb1 JG	331	goto end;
	332	}
	333
ac0c6bdd	334	*offset = clock_class->offset;
87d76bb1 JG	335	end:
	336	return ret;
	337	}
	338
ac0c6bdd PP	339	int bt_ctf_clock_class_set_offset_cycles(struct bt_ctf_clock_class *clock_class,
ac0c6bdd PP	340	int64_t offset)
273b65be JG	341	{
	342	int ret = 0;
	343
5134570b PP	344	if (!clock_class) {
	345	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
	346	ret = -1;
	347	goto end;
	348	}
	349
	350	if (clock_class->frozen) {
	351	BT_LOGW("Invalid parameter: clock class is frozen: addr=%p",
	352	clock_class);
273b65be JG	353	ret = -1;
	354	goto end;
	355	}
	356
ac0c6bdd	357	clock_class->offset = offset;
5134570b PP	358	BT_LOGV("Set clock class's offset (cycles): clock-class-addr=%p, offset-cycles=%" PRId64,
5134570b PP	359	clock_class, offset);
273b65be JG	360	end:
	361	return ret;
	362	}
	363
acd6aeb1	364	int bt_ctf_clock_class_is_absolute(struct bt_ctf_clock_class *clock_class)
87d76bb1 JG	365	{
	366	int ret = -1;
	367
ac0c6bdd	368	if (!clock_class) {
5134570b	369	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
87d76bb1 JG	370	goto end;
	371	}
	372
ac0c6bdd	373	ret = clock_class->absolute;
87d76bb1 JG	374	end:
	375	return ret;
	376	}
	377
ac0c6bdd PP	378	int bt_ctf_clock_class_set_is_absolute(struct bt_ctf_clock_class *clock_class,
ac0c6bdd PP	379	int is_absolute)
273b65be JG	380	{
	381	int ret = 0;
	382
5134570b PP	383	if (!clock_class) {
	384	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
	385	ret = -1;
	386	goto end;
	387	}
	388
	389	if (clock_class->frozen) {
	390	BT_LOGW("Invalid parameter: clock class is frozen: addr=%p",
	391	clock_class);
273b65be JG	392	ret = -1;
	393	goto end;
	394	}
	395
ac0c6bdd	396	clock_class->absolute = !!is_absolute;
5134570b PP	397	BT_LOGV("Set clock class's absolute flag: clock-class-addr=%p, is-absolute=%d",
5134570b PP	398	clock_class, !!is_absolute);
273b65be JG	399	end:
	400	return ret;
	401	}
	402
ac0c6bdd PP	403	const unsigned char *bt_ctf_clock_class_get_uuid(
ac0c6bdd PP	404	struct bt_ctf_clock_class *clock_class)
85b743f4 JG	405	{
	406	const unsigned char *ret;
	407
5134570b PP	408	if (!clock_class) {
	409	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
	410	ret = NULL;
	411	goto end;
	412	}
	413
	414	if (!clock_class->uuid_set) {
	415	BT_LOGV("Clock class's UUID is not set: clock-class-addr=%p",
	416	clock_class);
85b743f4 JG	417	ret = NULL;
	418	goto end;
	419	}
	420
ac0c6bdd	421	ret = clock_class->uuid;
85b743f4 JG	422	end:
	423	return ret;
	424	}
	425
ac0c6bdd PP	426	int bt_ctf_clock_class_set_uuid(struct bt_ctf_clock_class *clock_class,
ac0c6bdd PP	427	const unsigned char *uuid)
85b743f4 JG	428	{
	429	int ret = 0;
	430
5134570b PP	431	if (!clock_class \|\| !uuid) {
	432	BT_LOGW("Invalid parameter: clock class or UUID is NULL: "
	433	"clock-class-addr=%p, uuid-addr=%p",
	434	clock_class, uuid);
	435	ret = -1;
	436	goto end;
	437	}
	438
	439	if (clock_class->frozen) {
	440	BT_LOGW("Invalid parameter: clock class is frozen: addr=%p",
	441	clock_class);
85b743f4 JG	442	ret = -1;
	443	goto end;
	444	}
	445
ac0c6bdd PP	446	memcpy(clock_class->uuid, uuid, sizeof(uuid_t));
ac0c6bdd PP	447	clock_class->uuid_set = 1;
5134570b PP	448	BT_LOGV("Set clock class's UUID: clock-class-addr=%p, "
	449	"uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\"",
	450	clock_class,
	451	(unsigned int) uuid[0],
	452	(unsigned int) uuid[1],
	453	(unsigned int) uuid[2],
	454	(unsigned int) uuid[3],
	455	(unsigned int) uuid[4],
	456	(unsigned int) uuid[5],
	457	(unsigned int) uuid[6],
	458	(unsigned int) uuid[7],
	459	(unsigned int) uuid[8],
	460	(unsigned int) uuid[9],
	461	(unsigned int) uuid[10],
	462	(unsigned int) uuid[11],
	463	(unsigned int) uuid[12],
	464	(unsigned int) uuid[13],
	465	(unsigned int) uuid[14],
	466	(unsigned int) uuid[15]);
85b743f4 JG	467	end:
	468	return ret;
	469	}
	470
ac0c6bdd	471	static uint64_t ns_from_value(uint64_t frequency, uint64_t value)
4ef18cab PP	472	{
	473	uint64_t ns;
	474
	475	if (frequency == 1000000000) {
	476	ns = value;
	477	} else {
	478	ns = (uint64_t) ((1e9 * (double) value) / (double) frequency);
	479	}
	480
	481	return ns;
	482	}
	483
273b65be	484	BT_HIDDEN
ac0c6bdd	485	void bt_ctf_clock_class_freeze(struct bt_ctf_clock_class *clock_class)
273b65be	486	{
ac0c6bdd	487	if (!clock_class) {
5134570b	488	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
273b65be JG	489	return;
	490	}
	491
5134570b PP	492	if (!clock_class->frozen) {
	493	BT_LOGD("Freezing clock class: addr=%p", clock_class);
	494	clock_class->frozen = 1;
	495	}
273b65be JG	496	}
	497
	498	BT_HIDDEN
ac0c6bdd	499	void bt_ctf_clock_class_serialize(struct bt_ctf_clock_class *clock_class,
273b65be JG	500	struct metadata_context *context)
	501	{
	502	unsigned char *uuid;
	503
5134570b PP	504	BT_LOGD("Serializing clock class's metadata: clock-class-addr=%p, "
	505	"metadata-context-addr=%p", clock_class, context);
	506
ac0c6bdd	507	if (!clock_class \|\| !context) {
5134570b PP	508	BT_LOGW("Invalid parameter: clock class or metadata context is NULL: "
	509	"clock-class-addr=%p, metadata-context-addr=%p",
	510	clock_class, context);
273b65be JG	511	return;
	512	}
	513
ac0c6bdd	514	uuid = clock_class->uuid;
273b65be JG	515	g_string_append(context->string, "clock {\n");
273b65be JG	516	g_string_append_printf(context->string, "\tname = %s;\n",
ac0c6bdd	517	clock_class->name->str);
273b65be JG	518	g_string_append_printf(context->string,
	519	"\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n",
	520	uuid[0], uuid[1], uuid[2], uuid[3],
	521	uuid[4], uuid[5], uuid[6], uuid[7],
	522	uuid[8], uuid[9], uuid[10], uuid[11],
	523	uuid[12], uuid[13], uuid[14], uuid[15]);
ac0c6bdd	524	if (clock_class->description) {
273b65be	525	g_string_append_printf(context->string, "\tdescription = \"%s\";\n",
ac0c6bdd	526	clock_class->description->str);
273b65be JG	527	}
	528
	529	g_string_append_printf(context->string, "\tfreq = %" PRIu64 ";\n",
ac0c6bdd	530	clock_class->frequency);
273b65be	531	g_string_append_printf(context->string, "\tprecision = %" PRIu64 ";\n",
ac0c6bdd	532	clock_class->precision);
273b65be	533	g_string_append_printf(context->string, "\toffset_s = %" PRIu64 ";\n",
ac0c6bdd	534	clock_class->offset_s);
273b65be	535	g_string_append_printf(context->string, "\toffset = %" PRIu64 ";\n",
ac0c6bdd	536	clock_class->offset);
273b65be	537	g_string_append_printf(context->string, "\tabsolute = %s;\n",
ac0c6bdd	538	clock_class->absolute ? "TRUE" : "FALSE");
273b65be JG	539	g_string_append(context->string, "};\n\n");
	540	}
	541
273b65be	542	static
ac0c6bdd	543	void bt_ctf_clock_class_destroy(struct bt_object *obj)
273b65be	544	{
ac0c6bdd	545	struct bt_ctf_clock_class *clock_class;
273b65be	546
5134570b	547	BT_LOGD("Destroying clock class: addr=%p", obj);
ac0c6bdd PP	548	clock_class = container_of(obj, struct bt_ctf_clock_class, base);
	549	if (clock_class->name) {
	550	g_string_free(clock_class->name, TRUE);
273b65be	551	}
ac0c6bdd PP	552	if (clock_class->description) {
ac0c6bdd PP	553	g_string_free(clock_class->description, TRUE);
273b65be JG	554	}
273b65be JG	555
ac0c6bdd	556	g_free(clock_class);
273b65be	557	}
4ef18cab	558
61ec14e6 JG	559	static
	560	void bt_ctf_clock_value_destroy(struct bt_object *obj)
	561	{
	562	struct bt_ctf_clock_value *value;
	563
5134570b PP	564	BT_LOGD("Destroying clock value: addr=%p", obj);
5134570b PP	565
61ec14e6 JG	566	if (!obj) {
	567	return;
	568	}
	569
	570	value = container_of(obj, struct bt_ctf_clock_value, base);
	571	bt_put(value->clock_class);
	572	g_free(value);
	573	}
	574
	575	struct bt_ctf_clock_value *bt_ctf_clock_value_create(
ac0c6bdd	576	struct bt_ctf_clock_class *clock_class, uint64_t value)
4ef18cab	577	{
61ec14e6	578	struct bt_ctf_clock_value *ret = NULL;
4ef18cab	579
5134570b PP	580	BT_LOGD("Creating clock value object: clock-class-addr=%p, "
	581	"value=%" PRIu64, clock_class, value);
	582
ac0c6bdd	583	if (!clock_class) {
5134570b	584	BT_LOGW_STR("Invalid parameter: clock class is NULL.");
4ef18cab PP	585	goto end;
	586	}
	587
61ec14e6 JG	588	ret = g_new0(struct bt_ctf_clock_value, 1);
61ec14e6 JG	589	if (!ret) {
5134570b	590	BT_LOGE_STR("Failed to allocate one clock value.");
61ec14e6 JG	591	goto end;
	592	}
	593
	594	bt_object_init(ret, bt_ctf_clock_value_destroy);
ac0c6bdd	595	ret->clock_class = bt_get(clock_class);
61ec14e6	596	ret->value = value;
5134570b	597	BT_LOGD("Created clock value object: addr=%p", ret);
61ec14e6 JG	598	end:
	599	return ret;
	600	}
4ef18cab	601
61ec14e6 JG	602	int bt_ctf_clock_value_get_value(
	603	struct bt_ctf_clock_value clock_value, uint64_t raw_value)
	604	{
	605	int ret = 0;
4ef18cab	606
61ec14e6	607	if (!clock_value \|\| !raw_value) {
5134570b PP	608	BT_LOGW("Invalid parameter: clock value or raw value is NULL: "
	609	"clock-value-addr=%p, raw-value-addr=%p",
	610	clock_value, raw_value);
61ec14e6 JG	611	ret = -1;
	612	goto end;
	613	}
4ef18cab	614
61ec14e6	615	*raw_value = clock_value->value;
4ef18cab	616	end:
61ec14e6 JG	617	return ret;
	618	}
	619
1556a1af	620	int bt_ctf_clock_value_get_value_ns_from_epoch(struct bt_ctf_clock_value *value,
61ec14e6 JG	621	int64_t *ret_value_ns)
	622	{
	623	int ret = 0;
	624	int64_t ns;
	625
	626	if (!value \|\| !ret_value_ns) {
5134570b PP	627	BT_LOGW("Invalid parameter: clock value or return value pointer is NULL: "
	628	"clock-value-addr=%p, ret-value-addr=%p",
	629	value, ret_value_ns);
61ec14e6 JG	630	ret = -1;
	631	goto end;
	632	}
	633
	634	/* Initialize nanosecond timestamp to clock's offset in seconds. */
9ac68eb1	635	ns = value->clock_class->offset_s * (int64_t) 1000000000;
61ec14e6 JG	636
	637	/* Add offset in cycles, converted to nanoseconds. */
	638	ns += ns_from_value(value->clock_class->frequency,
	639	value->clock_class->offset);
	640
	641	/* Add given value, converter to nanoseconds. */
	642	ns += ns_from_value(value->clock_class->frequency, value->value);
	643
	644	*ret_value_ns = ns;
	645	end:
	646	return ret;
4ef18cab	647	}
6f57e458 PP	648
	649	struct bt_ctf_clock_class *bt_ctf_clock_value_get_class(
	650	struct bt_ctf_clock_value *clock_value)
	651	{
	652	struct bt_ctf_clock_class *clock_class = NULL;
	653
	654	if (!clock_value) {
5134570b	655	BT_LOGW_STR("Invalid parameter: clock value is NULL.");
6f57e458 PP	656	goto end;
	657	}
	658
	659	clock_class = bt_get(clock_value->clock_class);
	660
	661	end:
	662	return clock_class;
	663	}