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

/*
 * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
 * Copyright 2013, 2014 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 "LIB/CLOCK-CLASS"
#include "lib/logging.h"

#include "lib/assert-pre.h"
#include "common/uuid.h"
#include <babeltrace2/trace-ir/clock-class-const.h>
#include <babeltrace2/trace-ir/clock-class.h>
#include "clock-class.h"
#include "clock-snapshot.h"
#include "utils.h"
#include "compat/compiler.h"
#include <babeltrace2/types.h>
#include "compat/string.h"
#include <inttypes.h>
#include "lib/object.h"
#include "common/assert.h"
#include "lib/func-status.h"
#include "lib/value.h"

#define BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(_cc) \
	BT_ASSERT_PRE_DEV_HOT((_cc), "Clock class", ": %!+K", (_cc))

static
void destroy_clock_class(struct bt_object *obj)
{
	struct bt_clock_class *clock_class = (void *) obj;

	BT_LIB_LOGD("Destroying clock class: %!+K", clock_class);
	BT_OBJECT_PUT_REF_AND_RESET(clock_class->user_attributes);

	if (clock_class->name.str) {
		g_string_free(clock_class->name.str, TRUE);
		clock_class->name.str = NULL;
		clock_class->name.value = NULL;
	}

	if (clock_class->description.str) {
		g_string_free(clock_class->description.str, TRUE);
		clock_class->description.str = NULL;
		clock_class->description.value = NULL;
	}

	bt_object_pool_finalize(&clock_class->cs_pool);
	g_free(clock_class);
}

static
void free_clock_snapshot(struct bt_clock_snapshot *clock_snapshot,
		struct bt_clock_class *clock_class)
{
	bt_clock_snapshot_destroy(clock_snapshot);
}

static inline
void set_base_offset(struct bt_clock_class *clock_class)
{
	clock_class->base_offset.overflows = bt_util_get_base_offset_ns(
		clock_class->offset_seconds, clock_class->offset_cycles,
		clock_class->frequency, &clock_class->base_offset.value_ns);
}

struct bt_clock_class *bt_clock_class_create(bt_self_component *self_comp)
{
	int ret;
	struct bt_clock_class *clock_class = NULL;

	BT_ASSERT_PRE_NON_NULL(self_comp, "Self component");
	BT_LOGD_STR("Creating default clock class object");

	clock_class = g_new0(struct bt_clock_class, 1);
	if (!clock_class) {
		BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one clock class.");
		goto error;
	}

	bt_object_init_shared(&clock_class->base, destroy_clock_class);

	clock_class->user_attributes = bt_value_map_create();
	if (!clock_class->user_attributes) {
		BT_LIB_LOGE_APPEND_CAUSE(
			"Failed to create a map value object.");
		goto error;
	}

	clock_class->name.str = g_string_new(NULL);
	if (!clock_class->name.str) {
		BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString.");
		goto error;
	}

	clock_class->description.str = g_string_new(NULL);
	if (!clock_class->description.str) {
		BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString.");
		goto error;
	}

	clock_class->frequency = UINT64_C(1000000000);
	clock_class->origin_is_unix_epoch = BT_TRUE;
	set_base_offset(clock_class);
	ret = bt_object_pool_initialize(&clock_class->cs_pool,
		(bt_object_pool_new_object_func) bt_clock_snapshot_new,
		(bt_object_pool_destroy_object_func)
			free_clock_snapshot,
		clock_class);
	if (ret) {
		BT_LIB_LOGE_APPEND_CAUSE(
			"Failed to initialize clock snapshot pool: ret=%d",
			ret);
		goto error;
	}

	BT_LIB_LOGD("Created clock class object: %!+K", clock_class);
	goto end;

error:
	BT_OBJECT_PUT_REF_AND_RESET(clock_class);

end:
	return clock_class;
}

const char *bt_clock_class_get_name(const struct bt_clock_class *clock_class)
{
	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	return clock_class->name.value;
}

enum bt_clock_class_set_name_status bt_clock_class_set_name(
		struct bt_clock_class *clock_class, const char *name)
{
	BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
	BT_ASSERT_PRE_NON_NULL(name, "Name");
	BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
	g_string_assign(clock_class->name.str, name);
	clock_class->name.value = clock_class->name.str->str;
	BT_LIB_LOGD("Set clock class's name: %!+K", clock_class);
	return BT_FUNC_STATUS_OK;
}

const char *bt_clock_class_get_description(
		const struct bt_clock_class *clock_class)
{
	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	return clock_class->description.value;
}

enum bt_clock_class_set_description_status bt_clock_class_set_description(
		struct bt_clock_class *clock_class, const char *descr)
{
	BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
	BT_ASSERT_PRE_NON_NULL(descr, "Description");
	BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
	g_string_assign(clock_class->description.str, descr);
	clock_class->description.value = clock_class->description.str->str;
	BT_LIB_LOGD("Set clock class's description: %!+K",
		clock_class);
	return BT_FUNC_STATUS_OK;
}

uint64_t bt_clock_class_get_frequency(const struct bt_clock_class *clock_class)
{
	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	return clock_class->frequency;
}

void bt_clock_class_set_frequency(struct bt_clock_class *clock_class,
		uint64_t frequency)
{
	BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
	BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
	BT_ASSERT_PRE(frequency != UINT64_C(-1) && frequency != 0,
		"Invalid frequency: %![cc-]+K, new-freq=%" PRIu64,
		clock_class, frequency);
	BT_ASSERT_PRE(clock_class->offset_cycles < frequency,
		"Offset (cycles) is greater than clock class's frequency: "
		"%![cc-]+K, new-freq=%" PRIu64, clock_class, frequency);
	clock_class->frequency = frequency;
	set_base_offset(clock_class);
	BT_LIB_LOGD("Set clock class's frequency: %!+K", clock_class);
}

uint64_t bt_clock_class_get_precision(const struct bt_clock_class *clock_class)
{
	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	return clock_class->precision;
}

void bt_clock_class_set_precision(struct bt_clock_class *clock_class,
		uint64_t precision)
{
	BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
	BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
	BT_ASSERT_PRE(precision != UINT64_C(-1),
		"Invalid precision: %![cc-]+K, new-precision=%" PRIu64,
		clock_class, precision);
	clock_class->precision = precision;
	BT_LIB_LOGD("Set clock class's precision: %!+K", clock_class);
}

void bt_clock_class_get_offset(const struct bt_clock_class *clock_class,
		int64_t *seconds, uint64_t *cycles)
{
	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	BT_ASSERT_PRE_DEV_NON_NULL(seconds, "Seconds (output)");
	BT_ASSERT_PRE_DEV_NON_NULL(cycles, "Cycles (output)");
	*seconds = clock_class->offset_seconds;
	*cycles = clock_class->offset_cycles;
}

void bt_clock_class_set_offset(struct bt_clock_class *clock_class,
		int64_t seconds, uint64_t cycles)
{
	BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
	BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
	BT_ASSERT_PRE(cycles < clock_class->frequency,
		"Offset (cycles) is greater than clock class's frequency: "
		"%![cc-]+K, new-offset-cycles=%" PRIu64, clock_class, cycles);
	clock_class->offset_seconds = seconds;
	clock_class->offset_cycles = cycles;
	set_base_offset(clock_class);
	BT_LIB_LOGD("Set clock class's offset: %!+K", clock_class);
}

bt_bool bt_clock_class_origin_is_unix_epoch(const struct bt_clock_class *clock_class)
{
	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	return (bool) clock_class->origin_is_unix_epoch;
}

void bt_clock_class_set_origin_is_unix_epoch(struct bt_clock_class *clock_class,
		bt_bool origin_is_unix_epoch)
{
	BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
	BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
	clock_class->origin_is_unix_epoch = (bool) origin_is_unix_epoch;
	BT_LIB_LOGD("Set clock class's origin is Unix epoch property: %!+K",
		clock_class);
}

bt_uuid bt_clock_class_get_uuid(const struct bt_clock_class *clock_class)
{
	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	return clock_class->uuid.value;
}

void bt_clock_class_set_uuid(struct bt_clock_class *clock_class,
		bt_uuid uuid)
{
	BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
	BT_ASSERT_PRE_NON_NULL(uuid, "UUID");
	BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
	bt_uuid_copy(clock_class->uuid.uuid, uuid);
	clock_class->uuid.value = clock_class->uuid.uuid;
	BT_LIB_LOGD("Set clock class's UUID: %!+K", clock_class);
}

BT_HIDDEN
void _bt_clock_class_freeze(const struct bt_clock_class *clock_class)
{
	BT_ASSERT(clock_class);

	if (clock_class->frozen) {
		return;
	}

	BT_LIB_LOGD("Freezing clock class's user attributes: %!+v",
		clock_class->user_attributes);
	bt_value_freeze(clock_class->user_attributes);
	BT_LIB_LOGD("Freezing clock class: %!+K", clock_class);
	((struct bt_clock_class *) clock_class)->frozen = 1;
}

enum bt_clock_class_cycles_to_ns_from_origin_status
bt_clock_class_cycles_to_ns_from_origin(
		const struct bt_clock_class *clock_class,
		uint64_t cycles, int64_t *ns)
{
	int ret;

	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	BT_ASSERT_PRE_DEV_NON_NULL(ns, "Nanoseconds (output)");
	ret = bt_util_ns_from_origin_clock_class(clock_class, cycles, ns);
	if (ret) {
		BT_LIB_LOGE_APPEND_CAUSE("Cannot convert cycles to nanoseconds "
			"from origin for given clock class: "
			"value overflows the signed 64-bit integer range: "
			"%![cc-]+K, cycles=%" PRIu64,
			clock_class, cycles);
		ret = BT_FUNC_STATUS_OVERFLOW_ERROR;
	}

	return ret;
}

const struct bt_value *bt_clock_class_borrow_user_attributes_const(
		const struct bt_clock_class *clock_class)
{
	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	return clock_class->user_attributes;
}

struct bt_value *bt_clock_class_borrow_user_attributes(
		struct bt_clock_class *clock_class)
{
	return (void *) bt_clock_class_borrow_user_attributes_const(
		(void *) clock_class);
}

void bt_clock_class_set_user_attributes(
		struct bt_clock_class *clock_class,
		const struct bt_value *user_attributes)
{
	BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
	BT_ASSERT_PRE_NON_NULL(user_attributes, "User attributes");
	BT_ASSERT_PRE(user_attributes->type == BT_VALUE_TYPE_MAP,
		"User attributes object is not a map value object.");
	BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
	bt_object_put_ref_no_null_check(clock_class->user_attributes);
	clock_class->user_attributes = (void *) user_attributes;
	bt_object_get_ref_no_null_check(clock_class->user_attributes);
}

void bt_clock_class_get_ref(const struct bt_clock_class *clock_class)
{
	bt_object_get_ref(clock_class);
}

void bt_clock_class_put_ref(const struct bt_clock_class *clock_class)
{
	bt_object_put_ref(clock_class);
}
Commit	Line	Data
	1	/*
	2	* Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
	3	* Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	4	*
	5	* Permission is hereby granted, free of charge, to any person obtaining a copy
	6	* of this software and associated documentation files (the "Software"), to deal
	7	* in the Software without restriction, including without limitation the rights
	8	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	9	* copies of the Software, and to permit persons to whom the Software is
	10	* furnished to do so, subject to the following conditions:
	11	*
	12	* The above copyright notice and this permission notice shall be included in
	13	* all copies or substantial portions of the Software.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	16	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	18	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	19	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	20	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	21	* SOFTWARE.
	22	*/
	23
	24	#define BT_LOG_TAG "LIB/CLOCK-CLASS"
	25	#include "lib/logging.h"
	26
	27	#include "lib/assert-pre.h"
	28	#include "common/uuid.h"
	29	#include <babeltrace2/trace-ir/clock-class-const.h>
	30	#include <babeltrace2/trace-ir/clock-class.h>
	31	#include "clock-class.h"
	32	#include "clock-snapshot.h"
	33	#include "utils.h"
	34	#include "compat/compiler.h"
	35	#include <babeltrace2/types.h>
	36	#include "compat/string.h"
	37	#include <inttypes.h>
	38	#include "lib/object.h"
	39	#include "common/assert.h"
	40	#include "lib/func-status.h"
	41	#include "lib/value.h"
	42
	43	#define BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(_cc) \
	44	BT_ASSERT_PRE_DEV_HOT((_cc), "Clock class", ": %!+K", (_cc))
	45
	46	static
	47	void destroy_clock_class(struct bt_object *obj)
	48	{
	49	struct bt_clock_class clock_class = (void ) obj;
	50
	51	BT_LIB_LOGD("Destroying clock class: %!+K", clock_class);
	52	BT_OBJECT_PUT_REF_AND_RESET(clock_class->user_attributes);
	53
	54	if (clock_class->name.str) {
	55	g_string_free(clock_class->name.str, TRUE);
	56	clock_class->name.str = NULL;
	57	clock_class->name.value = NULL;
	58	}
	59
	60	if (clock_class->description.str) {
	61	g_string_free(clock_class->description.str, TRUE);
	62	clock_class->description.str = NULL;
	63	clock_class->description.value = NULL;
	64	}
	65
	66	bt_object_pool_finalize(&clock_class->cs_pool);
	67	g_free(clock_class);
	68	}
	69
	70	static
	71	void free_clock_snapshot(struct bt_clock_snapshot *clock_snapshot,
	72	struct bt_clock_class *clock_class)
	73	{
	74	bt_clock_snapshot_destroy(clock_snapshot);
	75	}
	76
	77	static inline
	78	void set_base_offset(struct bt_clock_class *clock_class)
	79	{
	80	clock_class->base_offset.overflows = bt_util_get_base_offset_ns(
	81	clock_class->offset_seconds, clock_class->offset_cycles,
	82	clock_class->frequency, &clock_class->base_offset.value_ns);
	83	}
	84
	85	struct bt_clock_class bt_clock_class_create(bt_self_component self_comp)
	86	{
	87	int ret;
	88	struct bt_clock_class *clock_class = NULL;
	89
	90	BT_ASSERT_PRE_NON_NULL(self_comp, "Self component");
	91	BT_LOGD_STR("Creating default clock class object");
	92
	93	clock_class = g_new0(struct bt_clock_class, 1);
	94	if (!clock_class) {
	95	BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one clock class.");
	96	goto error;
	97	}
	98
	99	bt_object_init_shared(&clock_class->base, destroy_clock_class);
	100
	101	clock_class->user_attributes = bt_value_map_create();
	102	if (!clock_class->user_attributes) {
	103	BT_LIB_LOGE_APPEND_CAUSE(
	104	"Failed to create a map value object.");
	105	goto error;
	106	}
	107
	108	clock_class->name.str = g_string_new(NULL);
	109	if (!clock_class->name.str) {
	110	BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString.");
	111	goto error;
	112	}
	113
	114	clock_class->description.str = g_string_new(NULL);
	115	if (!clock_class->description.str) {
	116	BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString.");
	117	goto error;
	118	}
	119
	120	clock_class->frequency = UINT64_C(1000000000);
	121	clock_class->origin_is_unix_epoch = BT_TRUE;
	122	set_base_offset(clock_class);
	123	ret = bt_object_pool_initialize(&clock_class->cs_pool,
	124	(bt_object_pool_new_object_func) bt_clock_snapshot_new,
	125	(bt_object_pool_destroy_object_func)
	126	free_clock_snapshot,
	127	clock_class);
	128	if (ret) {
	129	BT_LIB_LOGE_APPEND_CAUSE(
	130	"Failed to initialize clock snapshot pool: ret=%d",
	131	ret);
	132	goto error;
	133	}
	134
	135	BT_LIB_LOGD("Created clock class object: %!+K", clock_class);
	136	goto end;
	137
	138	error:
	139	BT_OBJECT_PUT_REF_AND_RESET(clock_class);
	140
	141	end:
	142	return clock_class;
	143	}
	144
	145	const char bt_clock_class_get_name(const struct bt_clock_class clock_class)
	146	{
	147	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	148	return clock_class->name.value;
	149	}
	150
	151	enum bt_clock_class_set_name_status bt_clock_class_set_name(
	152	struct bt_clock_class clock_class, const char name)
	153	{
	154	BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
	155	BT_ASSERT_PRE_NON_NULL(name, "Name");
	156	BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
	157	g_string_assign(clock_class->name.str, name);
	158	clock_class->name.value = clock_class->name.str->str;
	159	BT_LIB_LOGD("Set clock class's name: %!+K", clock_class);
	160	return BT_FUNC_STATUS_OK;
	161	}
	162
	163	const char *bt_clock_class_get_description(
	164	const struct bt_clock_class *clock_class)
	165	{
	166	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	167	return clock_class->description.value;
	168	}
	169
	170	enum bt_clock_class_set_description_status bt_clock_class_set_description(
	171	struct bt_clock_class clock_class, const char descr)
	172	{
	173	BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
	174	BT_ASSERT_PRE_NON_NULL(descr, "Description");
	175	BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
	176	g_string_assign(clock_class->description.str, descr);
	177	clock_class->description.value = clock_class->description.str->str;
	178	BT_LIB_LOGD("Set clock class's description: %!+K",
	179	clock_class);
	180	return BT_FUNC_STATUS_OK;
	181	}
	182
	183	uint64_t bt_clock_class_get_frequency(const struct bt_clock_class *clock_class)
	184	{
	185	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	186	return clock_class->frequency;
	187	}
	188
	189	void bt_clock_class_set_frequency(struct bt_clock_class *clock_class,
	190	uint64_t frequency)
	191	{
	192	BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
	193	BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
	194	BT_ASSERT_PRE(frequency != UINT64_C(-1) && frequency != 0,
	195	"Invalid frequency: %![cc-]+K, new-freq=%" PRIu64,
	196	clock_class, frequency);
	197	BT_ASSERT_PRE(clock_class->offset_cycles < frequency,
	198	"Offset (cycles) is greater than clock class's frequency: "
	199	"%![cc-]+K, new-freq=%" PRIu64, clock_class, frequency);
	200	clock_class->frequency = frequency;
	201	set_base_offset(clock_class);
	202	BT_LIB_LOGD("Set clock class's frequency: %!+K", clock_class);
	203	}
	204
	205	uint64_t bt_clock_class_get_precision(const struct bt_clock_class *clock_class)
	206	{
	207	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	208	return clock_class->precision;
	209	}
	210
	211	void bt_clock_class_set_precision(struct bt_clock_class *clock_class,
	212	uint64_t precision)
	213	{
	214	BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
	215	BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
	216	BT_ASSERT_PRE(precision != UINT64_C(-1),
	217	"Invalid precision: %![cc-]+K, new-precision=%" PRIu64,
	218	clock_class, precision);
	219	clock_class->precision = precision;
	220	BT_LIB_LOGD("Set clock class's precision: %!+K", clock_class);
	221	}
	222
	223	void bt_clock_class_get_offset(const struct bt_clock_class *clock_class,
	224	int64_t seconds, uint64_t cycles)
	225	{
	226	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	227	BT_ASSERT_PRE_DEV_NON_NULL(seconds, "Seconds (output)");
	228	BT_ASSERT_PRE_DEV_NON_NULL(cycles, "Cycles (output)");
	229	*seconds = clock_class->offset_seconds;
	230	*cycles = clock_class->offset_cycles;
	231	}
	232
	233	void bt_clock_class_set_offset(struct bt_clock_class *clock_class,
	234	int64_t seconds, uint64_t cycles)
	235	{
	236	BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
	237	BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
	238	BT_ASSERT_PRE(cycles < clock_class->frequency,
	239	"Offset (cycles) is greater than clock class's frequency: "
	240	"%![cc-]+K, new-offset-cycles=%" PRIu64, clock_class, cycles);
	241	clock_class->offset_seconds = seconds;
	242	clock_class->offset_cycles = cycles;
	243	set_base_offset(clock_class);
	244	BT_LIB_LOGD("Set clock class's offset: %!+K", clock_class);
	245	}
	246
	247	bt_bool bt_clock_class_origin_is_unix_epoch(const struct bt_clock_class *clock_class)
	248	{
	249	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	250	return (bool) clock_class->origin_is_unix_epoch;
	251	}
	252
	253	void bt_clock_class_set_origin_is_unix_epoch(struct bt_clock_class *clock_class,
	254	bt_bool origin_is_unix_epoch)
	255	{
	256	BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
	257	BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
	258	clock_class->origin_is_unix_epoch = (bool) origin_is_unix_epoch;
	259	BT_LIB_LOGD("Set clock class's origin is Unix epoch property: %!+K",
	260	clock_class);
	261	}
	262
	263	bt_uuid bt_clock_class_get_uuid(const struct bt_clock_class *clock_class)
	264	{
	265	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	266	return clock_class->uuid.value;
	267	}
	268
	269	void bt_clock_class_set_uuid(struct bt_clock_class *clock_class,
	270	bt_uuid uuid)
	271	{
	272	BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
	273	BT_ASSERT_PRE_NON_NULL(uuid, "UUID");
	274	BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
	275	bt_uuid_copy(clock_class->uuid.uuid, uuid);
	276	clock_class->uuid.value = clock_class->uuid.uuid;
	277	BT_LIB_LOGD("Set clock class's UUID: %!+K", clock_class);
	278	}
	279
	280	BT_HIDDEN
	281	void _bt_clock_class_freeze(const struct bt_clock_class *clock_class)
	282	{
	283	BT_ASSERT(clock_class);
	284
	285	if (clock_class->frozen) {
	286	return;
	287	}
	288
	289	BT_LIB_LOGD("Freezing clock class's user attributes: %!+v",
	290	clock_class->user_attributes);
	291	bt_value_freeze(clock_class->user_attributes);
	292	BT_LIB_LOGD("Freezing clock class: %!+K", clock_class);
	293	((struct bt_clock_class *) clock_class)->frozen = 1;
	294	}
	295
	296	enum bt_clock_class_cycles_to_ns_from_origin_status
	297	bt_clock_class_cycles_to_ns_from_origin(
	298	const struct bt_clock_class *clock_class,
	299	uint64_t cycles, int64_t *ns)
	300	{
	301	int ret;
	302
	303	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	304	BT_ASSERT_PRE_DEV_NON_NULL(ns, "Nanoseconds (output)");
	305	ret = bt_util_ns_from_origin_clock_class(clock_class, cycles, ns);
	306	if (ret) {
	307	BT_LIB_LOGE_APPEND_CAUSE("Cannot convert cycles to nanoseconds "
	308	"from origin for given clock class: "
	309	"value overflows the signed 64-bit integer range: "
	310	"%![cc-]+K, cycles=%" PRIu64,
	311	clock_class, cycles);
	312	ret = BT_FUNC_STATUS_OVERFLOW_ERROR;
	313	}
	314
	315	return ret;
	316	}
	317
	318	const struct bt_value *bt_clock_class_borrow_user_attributes_const(
	319	const struct bt_clock_class *clock_class)
	320	{
	321	BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
	322	return clock_class->user_attributes;
	323	}
	324
	325	struct bt_value *bt_clock_class_borrow_user_attributes(
	326	struct bt_clock_class *clock_class)
	327	{
	328	return (void *) bt_clock_class_borrow_user_attributes_const(
	329	(void *) clock_class);
	330	}
	331
	332	void bt_clock_class_set_user_attributes(
	333	struct bt_clock_class *clock_class,
	334	const struct bt_value *user_attributes)
	335	{
	336	BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
	337	BT_ASSERT_PRE_NON_NULL(user_attributes, "User attributes");
	338	BT_ASSERT_PRE(user_attributes->type == BT_VALUE_TYPE_MAP,
	339	"User attributes object is not a map value object.");
	340	BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
	341	bt_object_put_ref_no_null_check(clock_class->user_attributes);
	342	clock_class->user_attributes = (void *) user_attributes;
	343	bt_object_get_ref_no_null_check(clock_class->user_attributes);
	344	}
	345
	346	void bt_clock_class_get_ref(const struct bt_clock_class *clock_class)
	347	{
	348	bt_object_get_ref(clock_class);
	349	}
	350
	351	void bt_clock_class_put_ref(const struct bt_clock_class *clock_class)
	352	{
	353	bt_object_put_ref(clock_class);
	354	}