[babeltrace.git] / formats / ctf / ir / clock.c

/*
 * clock.c
 *
 * Babeltrace CTF IR - Clock
 *
 * 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-internal.h>
#include <babeltrace/ctf-ir/utils.h>
#include <babeltrace/ref.h>
#include <babeltrace/ctf-writer/writer-internal.h>
#include <babeltrace/object-internal.h>
#include <babeltrace/compiler.h>
#include <inttypes.h>

static
void bt_ctf_clock_destroy(struct bt_object *obj);

BT_HIDDEN
bool bt_ctf_clock_is_valid(struct bt_ctf_clock *clock)
{
	return clock && clock->name;
}

int bt_ctf_clock_set_name(struct bt_ctf_clock *clock,
		const char *name)
{
	int ret = 0;

	if (!clock || clock->frozen) {
		ret = -1;
		goto end;
	}

	if (bt_ctf_validate_identifier(name)) {
		ret = -1;
		goto end;
	}

	if (clock->name) {
		g_string_assign(clock->name, name);
	} else {
		clock->name = g_string_new(name);
		if (!clock->name) {
			ret = -1;
			goto end;
		}
	}

end:
	return ret;
}

struct bt_ctf_clock *bt_ctf_clock_create(const char *name)
{
	int ret;
	struct bt_ctf_clock *clock = g_new0(struct bt_ctf_clock, 1);

	if (!clock) {
		goto error;
	}

	clock->precision = 1;
	clock->frequency = 1000000000;
	bt_object_init(clock, bt_ctf_clock_destroy);

	if (name) {
		ret = bt_ctf_clock_set_name(clock, name);
		if (ret) {
			goto error;
		}
	}

	ret = bt_uuid_generate(clock->uuid);
	if (ret) {
		goto error;
	}

	/*
	 * For backward compatibility reasons, a fresh clock can have
	 * a value because it could be added to a trace created by a
	 * CTF writer. As soon as this clock is added to a non-writer
	 * trace, then its value/time functions will be disabled.
	 */
	clock->has_value = 1;
	clock->uuid_set = 1;
	return clock;
error:
	BT_PUT(clock);
	return clock;
}

const char *bt_ctf_clock_get_name(struct bt_ctf_clock *clock)
{
	const char *ret = NULL;

	if (!clock) {
		goto end;
	}

	if (clock->name) {
		ret = clock->name->str;
	}

end:
	return ret;
}

const char *bt_ctf_clock_get_description(struct bt_ctf_clock *clock)
{
	const char *ret = NULL;

	if (!clock) {
		goto end;
	}

	if (clock->description) {
		ret = clock->description->str;
	}
end:
	return ret;
}

int bt_ctf_clock_set_description(struct bt_ctf_clock *clock, const char *desc)
{
	int ret = 0;

	if (!clock || !desc || clock->frozen) {
		ret = -1;
		goto end;
	}

	clock->description = g_string_new(desc);
	ret = clock->description ? 0 : -1;
end:
	return ret;
}

uint64_t bt_ctf_clock_get_frequency(struct bt_ctf_clock *clock)
{
	uint64_t ret = -1ULL;

	if (!clock) {
		goto end;
	}

	ret = clock->frequency;
end:
	return ret;
}

int bt_ctf_clock_set_frequency(struct bt_ctf_clock *clock, uint64_t freq)
{
	int ret = 0;

	if (!clock || clock->frozen) {
		ret = -1;
		goto end;
	}

	clock->frequency = freq;
end:
	return ret;
}

uint64_t bt_ctf_clock_get_precision(struct bt_ctf_clock *clock)
{
	uint64_t ret = -1ULL;

	if (!clock) {
		goto end;
	}

	ret = clock->precision;
end:
	return ret;
}

int bt_ctf_clock_set_precision(struct bt_ctf_clock *clock, uint64_t precision)
{
	int ret = 0;

	if (!clock || clock->frozen) {
		ret = -1;
		goto end;
	}

	clock->precision = precision;
end:
	return ret;
}

int bt_ctf_clock_get_offset_s(struct bt_ctf_clock *clock, int64_t *offset_s)
{
	int ret = 0;

	if (!clock || !offset_s) {
		ret = -1;
		goto end;
	}

	*offset_s = clock->offset_s;
end:
	return ret;
}

int bt_ctf_clock_set_offset_s(struct bt_ctf_clock *clock, int64_t offset_s)
{
	int ret = 0;

	if (!clock || clock->frozen) {
		ret = -1;
		goto end;
	}

	clock->offset_s = offset_s;
end:
	return ret;
}

int bt_ctf_clock_get_offset(struct bt_ctf_clock *clock, int64_t *offset)
{
	int ret = 0;

	if (!clock || !offset) {
		ret = -1;
		goto end;
	}

	*offset = clock->offset;
end:
	return ret;
}

int bt_ctf_clock_set_offset(struct bt_ctf_clock *clock, int64_t offset)
{
	int ret = 0;

	if (!clock || clock->frozen) {
		ret = -1;
		goto end;
	}

	clock->offset = offset;
end:
	return ret;
}

int bt_ctf_clock_get_is_absolute(struct bt_ctf_clock *clock)
{
	int ret = -1;

	if (!clock) {
		goto end;
	}

	ret = clock->absolute;
end:
	return ret;
}

int bt_ctf_clock_set_is_absolute(struct bt_ctf_clock *clock, int is_absolute)
{
	int ret = 0;

	if (!clock || clock->frozen) {
		ret = -1;
		goto end;
	}

	clock->absolute = !!is_absolute;
end:
	return ret;
}

const unsigned char *bt_ctf_clock_get_uuid(struct bt_ctf_clock *clock)
{
	const unsigned char *ret;

	if (!clock || !clock->uuid_set) {
		ret = NULL;
		goto end;
	}

	ret = clock->uuid;
end:
	return ret;
}

int bt_ctf_clock_set_uuid(struct bt_ctf_clock *clock, const unsigned char *uuid)
{
	int ret = 0;

	if (!clock || !uuid || clock->frozen) {
		ret = -1;
		goto end;
	}

	memcpy(clock->uuid, uuid, sizeof(uuid_t));
	clock->uuid_set = 1;
end:
	return ret;
}

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

int bt_ctf_clock_set_time(struct bt_ctf_clock *clock, int64_t time)
{
	int ret = 0;
	int64_t value;

	/* Timestamps are strictly monotonic */
	if (!clock) {
		ret = -1;
		goto end;
	}


	if (!clock->has_value) {
		/*
		 * Clock belongs to a non-writer mode trace and thus
		 * this function is disabled.
		 */
		ret = -1;
		goto end;
	}

	/* Common case where cycles are actually nanoseconds */
	if (clock->frequency == 1000000000) {
		value = time;
	} else {
		value = (uint64_t) (((double) time *
		        (double) clock->frequency) / 1e9);
	}

	if (clock->value > value) {
		/* Timestamps must be strictly monotonic. */
		ret = -1;
		goto end;
	}

	clock->value = value;
end:
	return ret;
}

void bt_ctf_clock_get(struct bt_ctf_clock *clock)
{
	bt_get(clock);
}

void bt_ctf_clock_put(struct bt_ctf_clock *clock)
{
	bt_put(clock);
}

BT_HIDDEN
void bt_ctf_clock_freeze(struct bt_ctf_clock *clock)
{
	if (!clock) {
		return;
	}

	clock->frozen = 1;
}

BT_HIDDEN
void bt_ctf_clock_serialize(struct bt_ctf_clock *clock,
		struct metadata_context *context)
{
	unsigned char *uuid;

	if (!clock || !context) {
		return;
	}

	uuid = clock->uuid;
	g_string_append(context->string, "clock {\n");
	g_string_append_printf(context->string, "\tname = %s;\n",
		clock->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->description) {
		g_string_append_printf(context->string, "\tdescription = \"%s\";\n",
			clock->description->str);
	}

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

BT_HIDDEN
int bt_ctf_clock_get_value(struct bt_ctf_clock *clock, uint64_t *value)
{
	int ret = 0;

	if (!clock || !value) {
		ret = -1;
		goto end;
	}

	*value = clock->value;
end:
	return ret;
}

static
void bt_ctf_clock_destroy(struct bt_object *obj)
{
	struct bt_ctf_clock *clock;

	clock = container_of(obj, struct bt_ctf_clock, base);
	if (clock->name) {
		g_string_free(clock->name, TRUE);
	}

	if (clock->description) {
		g_string_free(clock->description, TRUE);
	}

	g_free(clock);
}

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

	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 *clock, uint64_t value)
{
	struct bt_ctf_clock_value *ret = NULL;

	if (!clock) {
		goto end;
	}

	ret = g_new0(struct bt_ctf_clock_value, 1);
	if (!ret) {
		goto end;
	}

	bt_object_init(ret, bt_ctf_clock_value_destroy);
	ret->clock_class = bt_get(clock);
	ret->value = value;
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) {
		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) {
		ret = -1;
		goto end;
	}

	/* Initialize nanosecond timestamp to clock's offset in seconds. */
	ns = value->clock_class->offset_s * 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;
}
Commit	Line	Data
273b65be JG	1	/*
	2	* clock.c
	3	*
d2dc44b6	4	* Babeltrace CTF IR - Clock
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
adc315b8	29	#include <babeltrace/ctf-ir/clock-internal.h>
654c1444	30	#include <babeltrace/ctf-ir/utils.h>
83509119	31	#include <babeltrace/ref.h>
273b65be	32	#include <babeltrace/ctf-writer/writer-internal.h>
83509119	33	#include <babeltrace/object-internal.h>
273b65be JG	34	#include <babeltrace/compiler.h>
	35	#include <inttypes.h>
	36
	37	static
83509119	38	void bt_ctf_clock_destroy(struct bt_object *obj);
273b65be	39
4c426c17	40	BT_HIDDEN
c06116f3 PP	41	bool bt_ctf_clock_is_valid(struct bt_ctf_clock *clock)
	42	{
	43	return clock && clock->name;
	44	}
	45
4c426c17 JG	46	int bt_ctf_clock_set_name(struct bt_ctf_clock *clock,
	47	const char *name)
	48	{
	49	int ret = 0;
273b65be	50
c06116f3 PP	51	if (!clock \|\| clock->frozen) {
	52	ret = -1;
	53	goto end;
	54	}
	55
654c1444	56	if (bt_ctf_validate_identifier(name)) {
4c426c17 JG	57	ret = -1;
4c426c17 JG	58	goto end;
273b65be JG	59	}
273b65be JG	60
4c426c17	61	if (clock->name) {
e1ae7645 JG	62	g_string_assign(clock->name, name);
	63	} else {
	64	clock->name = g_string_new(name);
	65	if (!clock->name) {
	66	ret = -1;
	67	goto end;
	68	}
273b65be JG	69	}
273b65be JG	70
4c426c17 JG	71	end:
	72	return ret;
	73	}
	74
	75	struct bt_ctf_clock bt_ctf_clock_create(const char name)
	76	{
	77	int ret;
85380e99	78	struct bt_ctf_clock *clock = g_new0(struct bt_ctf_clock, 1);
4c426c17	79
4c426c17 JG	80	if (!clock) {
	81	goto error;
	82	}
	83
85380e99 JG	84	clock->precision = 1;
	85	clock->frequency = 1000000000;
	86	bt_object_init(clock, bt_ctf_clock_destroy);
	87
	88	if (name) {
	89	ret = bt_ctf_clock_set_name(clock, name);
	90	if (ret) {
	91	goto error;
	92	}
273b65be JG	93	}
273b65be JG	94
19dd40db	95	ret = bt_uuid_generate(clock->uuid);
be018f15	96	if (ret) {
83509119	97	goto error;
be018f15 JG	98	}
be018f15 JG	99
cfeb617e PP	100	/*
	101	* For backward compatibility reasons, a fresh clock can have
	102	* a value because it could be added to a trace created by a
	103	* CTF writer. As soon as this clock is added to a non-writer
	104	* trace, then its value/time functions will be disabled.
	105	*/
	106	clock->has_value = 1;
be018f15	107	clock->uuid_set = 1;
273b65be	108	return clock;
273b65be	109	error:
83509119 JG	110	BT_PUT(clock);
83509119 JG	111	return clock;
87d76bb1 JG	112	}
	113
	114	const char bt_ctf_clock_get_name(struct bt_ctf_clock clock)
	115	{
	116	const char *ret = NULL;
	117
	118	if (!clock) {
	119	goto end;
	120	}
	121
	122	if (clock->name) {
	123	ret = clock->name->str;
	124	}
	125
	126	end:
	127	return ret;
	128	}
	129
	130	const char bt_ctf_clock_get_description(struct bt_ctf_clock clock)
	131	{
	132	const char *ret = NULL;
	133
	134	if (!clock) {
	135	goto end;
	136	}
	137
	138	if (clock->description) {
	139	ret = clock->description->str;
	140	}
	141	end:
	142	return ret;
273b65be JG	143	}
	144
	145	int bt_ctf_clock_set_description(struct bt_ctf_clock clock, const char desc)
	146	{
	147	int ret = 0;
	148
	149	if (!clock \|\| !desc \|\| clock->frozen) {
	150	ret = -1;
	151	goto end;
	152	}
	153
87d76bb1	154	clock->description = g_string_new(desc);
273b65be JG	155	ret = clock->description ? 0 : -1;
	156	end:
	157	return ret;
	158	}
	159
87d76bb1 JG	160	uint64_t bt_ctf_clock_get_frequency(struct bt_ctf_clock *clock)
	161	{
	162	uint64_t ret = -1ULL;
	163
	164	if (!clock) {
	165	goto end;
	166	}
	167
	168	ret = clock->frequency;
	169	end:
	170	return ret;
	171	}
	172
273b65be JG	173	int bt_ctf_clock_set_frequency(struct bt_ctf_clock *clock, uint64_t freq)
	174	{
	175	int ret = 0;
	176
	177	if (!clock \|\| clock->frozen) {
	178	ret = -1;
	179	goto end;
	180	}
	181
	182	clock->frequency = freq;
	183	end:
	184	return ret;
	185	}
	186
87d76bb1 JG	187	uint64_t bt_ctf_clock_get_precision(struct bt_ctf_clock *clock)
	188	{
	189	uint64_t ret = -1ULL;
	190
	191	if (!clock) {
	192	goto end;
	193	}
	194
	195	ret = clock->precision;
	196	end:
	197	return ret;
	198	}
	199
273b65be JG	200	int bt_ctf_clock_set_precision(struct bt_ctf_clock *clock, uint64_t precision)
	201	{
	202	int ret = 0;
	203
	204	if (!clock \|\| clock->frozen) {
	205	ret = -1;
	206	goto end;
	207	}
	208
	209	clock->precision = precision;
	210	end:
	211	return ret;
	212	}
	213
61cf588b	214	int bt_ctf_clock_get_offset_s(struct bt_ctf_clock clock, int64_t offset_s)
87d76bb1	215	{
61cf588b	216	int ret = 0;
87d76bb1	217
61cf588b MD	218	if (!clock \|\| !offset_s) {
61cf588b MD	219	ret = -1;
87d76bb1 JG	220	goto end;
	221	}
	222
61cf588b	223	*offset_s = clock->offset_s;
87d76bb1 JG	224	end:
	225	return ret;
	226	}
	227
61cf588b	228	int bt_ctf_clock_set_offset_s(struct bt_ctf_clock *clock, int64_t offset_s)
273b65be JG	229	{
	230	int ret = 0;
	231
	232	if (!clock \|\| clock->frozen) {
	233	ret = -1;
	234	goto end;
	235	}
	236
	237	clock->offset_s = offset_s;
	238	end:
	239	return ret;
	240	}
	241
61cf588b	242	int bt_ctf_clock_get_offset(struct bt_ctf_clock clock, int64_t offset)
87d76bb1	243	{
61cf588b	244	int ret = 0;
87d76bb1	245
61cf588b MD	246	if (!clock \|\| !offset) {
61cf588b MD	247	ret = -1;
87d76bb1 JG	248	goto end;
	249	}
	250
61cf588b	251	*offset = clock->offset;
87d76bb1 JG	252	end:
	253	return ret;
	254	}
	255
61cf588b	256	int bt_ctf_clock_set_offset(struct bt_ctf_clock *clock, int64_t offset)
273b65be JG	257	{
	258	int ret = 0;
	259
	260	if (!clock \|\| clock->frozen) {
	261	ret = -1;
	262	goto end;
	263	}
	264
	265	clock->offset = offset;
	266	end:
	267	return ret;
	268	}
	269
87d76bb1 JG	270	int bt_ctf_clock_get_is_absolute(struct bt_ctf_clock *clock)
	271	{
	272	int ret = -1;
	273
	274	if (!clock) {
	275	goto end;
	276	}
	277
	278	ret = clock->absolute;
	279	end:
	280	return ret;
	281	}
	282
273b65be JG	283	int bt_ctf_clock_set_is_absolute(struct bt_ctf_clock *clock, int is_absolute)
	284	{
	285	int ret = 0;
	286
	287	if (!clock \|\| clock->frozen) {
	288	ret = -1;
	289	goto end;
	290	}
	291
	292	clock->absolute = !!is_absolute;
	293	end:
	294	return ret;
	295	}
	296
85b743f4 JG	297	const unsigned char bt_ctf_clock_get_uuid(struct bt_ctf_clock clock)
	298	{
	299	const unsigned char *ret;
	300
be018f15	301	if (!clock \|\| !clock->uuid_set) {
85b743f4 JG	302	ret = NULL;
	303	goto end;
	304	}
	305
	306	ret = clock->uuid;
	307	end:
	308	return ret;
	309	}
	310
	311	int bt_ctf_clock_set_uuid(struct bt_ctf_clock clock, const unsigned char uuid)
	312	{
	313	int ret = 0;
	314
be018f15	315	if (!clock \|\| !uuid \|\| clock->frozen) {
85b743f4 JG	316	ret = -1;
	317	goto end;
	318	}
	319
	320	memcpy(clock->uuid, uuid, sizeof(uuid_t));
be018f15	321	clock->uuid_set = 1;
85b743f4 JG	322	end:
	323	return ret;
	324	}
	325
4ef18cab PP	326	uint64_t ns_from_value(uint64_t frequency, uint64_t value)
	327	{
	328	uint64_t ns;
	329
	330	if (frequency == 1000000000) {
	331	ns = value;
	332	} else {
	333	ns = (uint64_t) ((1e9 * (double) value) / (double) frequency);
	334	}
	335
	336	return ns;
	337	}
	338
61cf588b	339	int bt_ctf_clock_set_time(struct bt_ctf_clock *clock, int64_t time)
273b65be JG	340	{
273b65be JG	341	int ret = 0;
49e545f5	342	int64_t value;
273b65be JG	343
273b65be JG	344	/* Timestamps are strictly monotonic */
e1e30a8c PP	345	if (!clock) {
	346	ret = -1;
	347	goto end;
	348	}
	349
cfeb617e PP	350
	351	if (!clock->has_value) {
	352	/*
	353	* Clock belongs to a non-writer mode trace and thus
	354	* this function is disabled.
	355	*/
	356	ret = -1;
	357	goto end;
	358	}
	359
e1e30a8c PP	360	/* Common case where cycles are actually nanoseconds */
e1e30a8c PP	361	if (clock->frequency == 1000000000) {
49e545f5 JG	362	value = time;
	363	} else {
	364	value = (uint64_t) (((double) time *
	365	(double) clock->frequency) / 1e9);
e1e30a8c PP	366	}
e1e30a8c PP	367
61ec14e6 JG	368	if (clock->value > value) {
61ec14e6 JG	369	/* Timestamps must be strictly monotonic. */
273b65be JG	370	ret = -1;
	371	goto end;
	372	}
	373
e1e30a8c	374	clock->value = value;
273b65be JG	375	end:
	376	return ret;
	377	}
	378
	379	void bt_ctf_clock_get(struct bt_ctf_clock *clock)
	380	{
83509119	381	bt_get(clock);
273b65be JG	382	}
	383
	384	void bt_ctf_clock_put(struct bt_ctf_clock *clock)
	385	{
83509119	386	bt_put(clock);
273b65be JG	387	}
	388
	389	BT_HIDDEN
	390	void bt_ctf_clock_freeze(struct bt_ctf_clock *clock)
	391	{
	392	if (!clock) {
	393	return;
	394	}
	395
	396	clock->frozen = 1;
	397	}
	398
	399	BT_HIDDEN
	400	void bt_ctf_clock_serialize(struct bt_ctf_clock *clock,
	401	struct metadata_context *context)
	402	{
	403	unsigned char *uuid;
	404
	405	if (!clock \|\| !context) {
	406	return;
	407	}
	408
	409	uuid = clock->uuid;
	410	g_string_append(context->string, "clock {\n");
	411	g_string_append_printf(context->string, "\tname = %s;\n",
	412	clock->name->str);
	413	g_string_append_printf(context->string,
	414	"\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n",
	415	uuid[0], uuid[1], uuid[2], uuid[3],
	416	uuid[4], uuid[5], uuid[6], uuid[7],
	417	uuid[8], uuid[9], uuid[10], uuid[11],
	418	uuid[12], uuid[13], uuid[14], uuid[15]);
7a69f348	419	if (clock->description) {
273b65be JG	420	g_string_append_printf(context->string, "\tdescription = \"%s\";\n",
	421	clock->description->str);
	422	}
	423
	424	g_string_append_printf(context->string, "\tfreq = %" PRIu64 ";\n",
	425	clock->frequency);
	426	g_string_append_printf(context->string, "\tprecision = %" PRIu64 ";\n",
	427	clock->precision);
	428	g_string_append_printf(context->string, "\toffset_s = %" PRIu64 ";\n",
	429	clock->offset_s);
	430	g_string_append_printf(context->string, "\toffset = %" PRIu64 ";\n",
	431	clock->offset);
	432	g_string_append_printf(context->string, "\tabsolute = %s;\n",
	433	clock->absolute ? "TRUE" : "FALSE");
	434	g_string_append(context->string, "};\n\n");
	435	}
	436
24626e8b JG	437	BT_HIDDEN
	438	int bt_ctf_clock_get_value(struct bt_ctf_clock clock, uint64_t value)
	439	{
	440	int ret = 0;
	441
	442	if (!clock \|\| !value) {
	443	ret = -1;
	444	goto end;
	445	}
	446
	447	*value = clock->value;
	448	end:
	449	return ret;
	450	}
	451
273b65be	452	static
83509119	453	void bt_ctf_clock_destroy(struct bt_object *obj)
273b65be JG	454	{
273b65be JG	455	struct bt_ctf_clock *clock;
273b65be	456
83509119	457	clock = container_of(obj, struct bt_ctf_clock, base);
273b65be JG	458	if (clock->name) {
	459	g_string_free(clock->name, TRUE);
	460	}
	461
	462	if (clock->description) {
	463	g_string_free(clock->description, TRUE);
	464	}
	465
	466	g_free(clock);
	467	}
4ef18cab	468
61ec14e6 JG	469	static
	470	void bt_ctf_clock_value_destroy(struct bt_object *obj)
	471	{
	472	struct bt_ctf_clock_value *value;
	473
	474	if (!obj) {
	475	return;
	476	}
	477
	478	value = container_of(obj, struct bt_ctf_clock_value, base);
	479	bt_put(value->clock_class);
	480	g_free(value);
	481	}
	482
	483	struct bt_ctf_clock_value *bt_ctf_clock_value_create(
	484	struct bt_ctf_clock *clock, uint64_t value)
4ef18cab	485	{
61ec14e6	486	struct bt_ctf_clock_value *ret = NULL;
4ef18cab PP	487
	488	if (!clock) {
	489	goto end;
	490	}
	491
61ec14e6 JG	492	ret = g_new0(struct bt_ctf_clock_value, 1);
	493	if (!ret) {
	494	goto end;
	495	}
	496
	497	bt_object_init(ret, bt_ctf_clock_value_destroy);
	498	ret->clock_class = bt_get(clock);
	499	ret->value = value;
	500	end:
	501	return ret;
	502	}
4ef18cab	503
61ec14e6 JG	504	int bt_ctf_clock_value_get_value(
	505	struct bt_ctf_clock_value clock_value, uint64_t raw_value)
	506	{
	507	int ret = 0;
4ef18cab	508
61ec14e6 JG	509	if (!clock_value \|\| !raw_value) {
	510	ret = -1;
	511	goto end;
	512	}
4ef18cab	513
61ec14e6	514	*raw_value = clock_value->value;
4ef18cab	515	end:
61ec14e6 JG	516	return ret;
	517	}
	518
1556a1af	519	int bt_ctf_clock_value_get_value_ns_from_epoch(struct bt_ctf_clock_value *value,
61ec14e6 JG	520	int64_t *ret_value_ns)
	521	{
	522	int ret = 0;
	523	int64_t ns;
	524
	525	if (!value \|\| !ret_value_ns) {
	526	ret = -1;
	527	goto end;
	528	}
	529
	530	/* Initialize nanosecond timestamp to clock's offset in seconds. */
	531	ns = value->clock_class->offset_s * 1000000000;
	532
	533	/* Add offset in cycles, converted to nanoseconds. */
	534	ns += ns_from_value(value->clock_class->frequency,
	535	value->clock_class->offset);
	536
	537	/* Add given value, converter to nanoseconds. */
	538	ns += ns_from_value(value->clock_class->frequency, value->value);
	539
	540	*ret_value_ns = ns;
	541	end:
	542	return ret;
4ef18cab	543	}