[babeltrace.git] / lib / 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 <babeltrace2/lib-logging-internal.h>

#include <babeltrace2/assert-pre-internal.h>
#include <babeltrace2/compat/uuid-internal.h>
#include <babeltrace2/ctf-writer/clock-class-internal.h>
#include <babeltrace2/ctf-writer/utils.h>
#include <babeltrace2/ctf-writer/object.h>
#include <babeltrace2/compiler-internal.h>
#include <babeltrace2/types.h>
#include <babeltrace2/compat/string-internal.h>
#include <inttypes.h>
#include <babeltrace2/ctf-writer/object-internal.h>
#include <babeltrace2/assert-internal.h>

static
void bt_ctf_clock_class_destroy(struct bt_ctf_object *obj);

BT_HIDDEN
bt_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_LOGV("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_LOGV("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_LOGV("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_LOGV("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_LOGV("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_LOGV("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_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_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_LOGV("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 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: 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 unsigned char *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;
	}

	memcpy(clock_class->uuid, uuid, BABELTRACE_UUID_LEN);
	clock_class->uuid_set = 1;
	BT_LOGV("Set clock class's UUID: addr=%p, name=\"%s\", "
		"uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\"",
		clock_class, bt_ctf_clock_class_get_name(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;
}

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(clock_class_a);
	BT_ASSERT(clock_class_b);

	/* Name */
	if (strcmp(clock_class_a->name->str, clock_class_b->name->str) != 0) {
		BT_LOGV("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_LOGV_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_LOGV("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_LOGV_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_LOGV("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_LOGV("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_LOGV("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_LOGV("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_LOGV_STR("Clock classes differ: clock class A has a "
				"UUID, but clock class B does not.");
			goto end;
		}

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