[deliverable/lttng-tools.git] / src / bin / lttng-sessiond / ust-metadata.cpp

/*
 * Copyright (C) 2010-2013 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 */

#include "common/bytecode/bytecode.hpp"
#include "common/macros.hpp"
#include "common/uuid.hpp"
#include <endian.h>
#define _LGPL_SOURCE
#include <stdint.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <limits.h>
#include <unistd.h>
#include <inttypes.h>
#include <common/common.hpp>
#include <common/time.hpp>
#include <vector>
#include <vendor/nlohmann/json.hpp>

#include "ust-registry.hpp"
#include "ust-clock.hpp"
#include "ust-app.hpp"

#define NR_CLOCK_OFFSET_SAMPLES		10

using json = nlohmann::json;

struct offset_sample {
	int64_t offset;			/* correlation offset */
	uint64_t measure_delta;		/* lower is better */
};

enum class byte_order
{
	BIG,
	LITTLE,
};

enum class display_base
{
	BINARY,
	OCTAL,
	DECIMAL,
	HEXADECIMAL,
};

struct metadata_generation_exception : public std::runtime_error
{
	metadata_generation_exception(const char *what)
		: std::runtime_error(what)
	{}
};

struct lttng_ust_ctl_field_iterator
{
	lttng_ust_ctl_field_iterator(const lttng_ust_ctl_field *array,
			size_t len)
		: _array(array), _len(len)
	{}

	/* Make sure we don't pass it by value, by mistake. */
	lttng_ust_ctl_field_iterator(const lttng_ust_ctl_field_iterator &) = delete;
	void operator=(const lttng_ust_ctl_field_iterator &) = delete;

	const lttng_ust_ctl_field &get_next()
	{
		if (done()) {
			throw metadata_generation_exception(
				"Field iterator overflow");
		};

		return _array[_cur++];
	}

	bool done() const
	{
		return _cur >= _len;
	}

private:
	const lttng_ust_ctl_field *_array;
	size_t _cur = 0;
	size_t _len;
};

static
byte_order get_byte_order(const ust_registry_session &session, bool reverse)
{
	if (session.byte_order == BIG_ENDIAN) {
		return reverse ? byte_order::LITTLE : byte_order::BIG;
	} else {
		return reverse ? byte_order::BIG : byte_order::LITTLE;
	}
}

struct bits
{
	using underlying_type = uint64_t;
	explicit bits(uint64_t val)
		: _val(val)
	{}

	underlying_type to_underlying() const
	{
		return static_cast<underlying_type>(_val);
	}

	bool operator==(bits other)
	{
		return to_underlying() == other.to_underlying();
	}

	bool operator!=(bits other)
	{
		return to_underlying() != other.to_underlying();
	}

private:
	const uint64_t _val;
};

static
bits operator"" _bits(unsigned long long val)
{
	return bits(val);
}

static
json make_fragment(const char *type)
{
	return {
		{ "type", type }
	};
}

static
json make_field_class(const char *type, const char *role)
{
	json fc {
		{ "type", type },
	};

	if (role) {
		fc["roles"] = {role};
	}

	return fc;
}

static
const char *make_byte_order(byte_order byte_order)
{
	switch (byte_order) {
	case byte_order::BIG:
		return "big-endian";
	case byte_order::LITTLE:
		return "little-endian";
	default:
		abort();
	}
}

static
json make_fixed_length_bit_array_field_class(const char *type, bits length,
		byte_order byte_order, bits alignment, const char *role)
{
	json fc = make_field_class(type, role);

	fc.update ({
		{ "length", length.to_underlying() },
		{ "byte-order", make_byte_order(byte_order) },
	});

	if (alignment != 0_bits) {
		fc["alignment"] = alignment.to_underlying();
	}

	return fc;
}

static
json make_display_base(display_base display_base)
{
	switch (display_base) {
		case display_base::BINARY:
			return 2;
		case display_base::OCTAL:
			return 8;
		case display_base::DECIMAL:
			return 10;
		case display_base::HEXADECIMAL:
			return 16;
		default:
			abort();
	}
}

static
json make_abstract_integer_field_class(display_base preferred_display_base)
{
	json base = json::object();
	if (preferred_display_base != display_base::DECIMAL) {
		base = {
			{ "preferred-display-base",
			make_display_base(preferred_display_base)},

		};
	}
	return base;
}

static
json make_fixed_length_unsigned_integer_field_class(const char *type,
		bits length, byte_order byte_order, bits alignment,
		display_base preferred_display_base, const char *role)
{
	json fc = make_fixed_length_bit_array_field_class(type, length,
		byte_order, alignment, role);
	fc.update(make_abstract_integer_field_class(preferred_display_base));
	return fc;
}

static
json make_fixed_length_signed_integer_field_class(const char *type,
		bits length, byte_order byte_order, bits alignment,
		display_base preferred_display_base, const char *role)
{
	json fc = make_fixed_length_bit_array_field_class(type, length,
		byte_order, alignment, role);
	fc.update(make_abstract_integer_field_class(preferred_display_base));
	return fc;
}

static
json make_fixed_length_unsigned_integer_field_class(bits length,
		byte_order byte_order, bits alignment,
		display_base preferred_display_base, const char *role)
{
	return make_fixed_length_unsigned_integer_field_class(
		"fixed-length-unsigned-integer", length, byte_order,
		alignment, preferred_display_base, role);
}

static
json make_fixed_length_signed_integer_field_class(bits length,
		byte_order byte_order, bits alignment,
		display_base preferred_display_base, const char *role)
{
	return make_fixed_length_signed_integer_field_class(
		"fixed-length-signed-integer", length, byte_order,
		alignment, preferred_display_base, role);
}

static
json make_fixed_length_floating_point_number_field_class(
		bits length, byte_order byte_order, bits alignment) {
	return make_fixed_length_bit_array_field_class(
		"fixed-length-floating-point-number",
		length, byte_order, alignment, nullptr);
}

struct integer_range
{
	integer_range(int64_t lower_bound_, int64_t upper_bound_)
		: is_signed(true), lower_bound(lower_bound_), upper_bound(upper_bound_)
	{}

	integer_range(uint64_t lower_bound_, uint64_t upper_bound_)
		: is_signed(false), lower_bound(lower_bound_), upper_bound(upper_bound_)
	{}

	const bool is_signed;
	const int64_t lower_bound, upper_bound;
};

struct integer_range_set
{
	using vec_type = std::vector<integer_range>;
	using const_iterator = vec_type::const_iterator;

	integer_range_set() = default;
	DISABLE_COPY_AND_ASSIGN(integer_range_set);
	integer_range_set(integer_range_set &&) = default;

	void add_range(int64_t lower_bound, int64_t upper_bound)
	{
		_ranges.emplace_back(lower_bound, upper_bound);
	}

	void add_range(uint64_t lower_bound, uint64_t upper_bound)
	{
		_ranges.emplace_back(lower_bound, upper_bound);
	}

	const_iterator begin() const
	{ return _ranges.begin(); }

	const_iterator end() const
	{ return _ranges.end(); }

private:
	vec_type _ranges;
};

struct enumeration_mapping
{
	enumeration_mapping(const char *name_, json ranges_)
		: name(name_), ranges(std::move(ranges_))
	{}

	const char *const name;
	json ranges;
};

struct enumeration_mappings
{
	using vec_type = std::vector<enumeration_mapping>;
	using const_iterator = vec_type::const_iterator;

	enumeration_mappings() = default;
	DISABLE_COPY_AND_ASSIGN(enumeration_mappings);
	enumeration_mappings(enumeration_mappings &&) = default;

	void add_mapping(const char *name_, json ranges_)
	{
		_mappings.emplace_back(name_, std::move(ranges_));
	}

	const_iterator begin() const
	{ return _mappings.begin(); }

	const_iterator end() const
	{ return _mappings.end(); }

private:
	vec_type _mappings;
};

static
json make_integer_range_set(const integer_range_set &ranges)
{
	json rs = json::array();

	for (const integer_range &range : ranges) {
		rs.push_back({ range.lower_bound, range.upper_bound });
	}

	return rs;
}

static json
make_enumeration_mappings(enumeration_mappings mappings)
{
	json mappings_obj = json::object();

	for (const enumeration_mapping &mapping : mappings) {
		mappings_obj[mapping.name] = std::move(mapping.ranges);
	}

	return mappings_obj;
}

static
json make_abstract_enumeration_field_class(display_base preferred_display_base,
		enumeration_mappings mappings)
{
	json fc = make_abstract_integer_field_class(preferred_display_base);
	fc["mappings"] = make_enumeration_mappings(std::move(mappings));
	return fc;
}


static
json make_fixed_length_unsigned_enumeration_field_class(bits length,
		byte_order byte_order, bits alignment,
		display_base preferred_display_base, const char *role,
		enumeration_mappings mappings)
{
	json fc = make_fixed_length_unsigned_integer_field_class(
		"fixed-length-unsigned-enumeration", length, byte_order,
		alignment, preferred_display_base, role);
	fc.update(make_abstract_enumeration_field_class(preferred_display_base,
		std::move(mappings)));
	return fc;
}

static
json make_fixed_length_signed_enumeration_field_class(bits length,
		byte_order byte_order, bits alignment,
		display_base preferred_display_base, const char *role,
		enumeration_mappings mappings)
{
	json fc = make_fixed_length_signed_integer_field_class(
		"fixed-length-signed-enumeration", length, byte_order,
		alignment, preferred_display_base, role);
	fc.update(make_abstract_enumeration_field_class(preferred_display_base,
		std::move(mappings)));
	return fc;
}

static
json make_fixed_length_enumeration_field_class(bool signedness,
		bits length, byte_order byte_order, bits alignment,
		display_base preferred_display_base,
		enumeration_mappings mappings)
{
	if (signedness) {
		return make_fixed_length_signed_enumeration_field_class(
			length, byte_order, alignment, preferred_display_base,
			nullptr, std::move(mappings));
	} else {
		return make_fixed_length_unsigned_enumeration_field_class(
			length, byte_order, alignment, preferred_display_base,
			nullptr, std::move(mappings));
	}
}

static
json make_static_length_blob_field_class(uint64_t length, const char *role)
{
	json fc = make_field_class("static-length-blob", role);

	fc.update({
		{ "length", length },
	});

	return fc;
}

static
json make_uuid_field_class(const char *role)
{
	return make_static_length_blob_field_class(16, role);
}

struct structure_member
{
	structure_member(const char *name_, json field_class_)
		: name(name_), field_class(std::move(field_class_))
	{}

	DISABLE_COPY_AND_ASSIGN(structure_member);
	structure_member(structure_member &&) = default;

	const char *const name;
	json field_class;
};

struct structure_members
{
	using vec_type = std::vector<structure_member>;

	structure_members() = default;
	structure_members(const structure_members &) = delete;
	structure_members(structure_members &&) = default;
	structure_members &operator=(const structure_members &) = delete;

	void add_member(const char *name, json field_class)
	{
		_members.emplace_back(structure_member(
			name, std::move(field_class)
		));
	}

	vec_type::iterator begin()
	{ return _members.begin (); }

	vec_type::iterator end()
	{ return _members.end (); }

private:
	vec_type _members;
};

static
json make_struct_member(structure_member member)
{
	return {
		{ "name", member.name },
		{ "field-class", std::move(member.field_class) },
	};
}

static
json make_structure_members(structure_members members)
{
	json members_obj = json::array();

	for (structure_member &member : members) {
		members_obj.push_back(make_struct_member(std::move(member)));
	}

	return members_obj;
}

static
json make_structure_field_class(bits minimum_alignment,
		structure_members members)
{
	json fc = make_field_class("structure", nullptr);

	fc["member-classes"] = make_structure_members(std::move(members));

	if (minimum_alignment != 0_bits) {
		fc["minimum-alignment"] = minimum_alignment.to_underlying();
	}

	return fc;
}


struct variant_option
{
	variant_option(const char *name_,
			json selector_field_ranges_,
			json field_class_)
		: name(name_),
			selector_field_ranges(std::move(selector_field_ranges_)),
			field_class(std::move(field_class_))
	{}

	variant_option(std::string name_,
			json selector_field_ranges_,
			json field_class_)
		: _name_buf(std::move(name_)),
			name(_name_buf.c_str()),
			selector_field_ranges(std::move(selector_field_ranges_)),
			field_class(std::move(field_class_))
	{}

	DISABLE_COPY_AND_ASSIGN(variant_option);

	variant_option(variant_option &&other)
		: _name_buf(std::move(other._name_buf)),
			/*
			 * If `_name_buf` is empty, `name` is not managed by us,
			 * just copy the pointer.  If `_name_buf` is not empty,
			 * make `name` point to our local copy.
			 */
			name(_name_buf.empty() ? other.name : _name_buf.c_str()),
			selector_field_ranges(other.selector_field_ranges),
			field_class(other.field_class)

	{}

private:
	/*
	 * Buffer for `name`, if it is dynamically allocated andmanaged by us.
	 */
	const std::string _name_buf;

public:
	const char *name;
	json selector_field_ranges;
	json field_class;
};

struct variant_options
{
	using vec_type = std::vector<variant_option>;
	using iterator = vec_type::iterator;
	using const_iterator = vec_type::const_iterator;

	variant_options() = default;
	DISABLE_COPY_AND_ASSIGN(variant_options);
	variant_options(variant_options &&) = default;

	void add_option(const char *name, json selector_field_ranges,
			json field_class)
	{
		_options.emplace_back(variant_option(
			name, std::move(selector_field_ranges),
			std::move(field_class)
		));
	}

	void add_option(std::string name, json selector_field_ranges,
			json field_class)
	{
		_options.emplace_back(variant_option(
			std::move(name), std::move(selector_field_ranges),
			std::move(field_class)
		));
	}

	iterator begin()
	{ return _options.begin(); }

	iterator end()
	{ return _options.end(); }

	const_iterator begin() const
	{ return _options.begin(); }

	const_iterator end() const
	{ return _options.end(); }

private:
	vec_type _options;
};

struct field_path
{
	using vec_type = std::vector<const char *>;

	struct popper
	{
		popper(struct field_path &path)
			: _path(path)
		{}

		popper(const popper &) = delete;
		popper(popper &&) = default;
		void operator=(const popper &) = delete;

		~popper()
		{
			_path._path.pop_back();

		}

	private:
		field_path &_path;
	};

	field_path(const char *root)
		: _path({root})
	{}

	field_path(std::initializer_list<const char *> list)
		: _path(list)
	{}

	const vec_type &path() const
	{
		return _path;
	}

	popper push(const char *element)
	{
		_path.push_back(element);
		return popper(*this);
	}

private:
	vec_type _path;
};

static
json make_variant_option(variant_option option)
{
	return {
		{ "name", option.name },
		{ "selector-field-ranges", std::move(option.selector_field_ranges) },
		{ "field-class", std::move(option.field_class ) },
	};
}

static
json make_variant_options(variant_options options)
{
	json options_obj = json::array();

	for (variant_option &option : options) {
		options_obj.push_back(make_variant_option(std::move(option)));
	}

	return options_obj;
}

static
json make_field_location(const field_path &field_location)
{
	return field_location.path();
}

static
json make_variant_field_class(variant_options options,
		const field_path &selector_field_location)
{
	json fc = make_field_class("variant", nullptr);

	fc["options"] = make_variant_options(std::move(options));
	fc["selector-field-location"] =
		make_field_location(selector_field_location);

	return fc;
}

static
json make_array_field_class(const char *type, json element_field_class,
		bits minimum_alignment)
{
	json fc = make_field_class(type, nullptr);

	fc["element-field-class"] = std::move(element_field_class);

	if (minimum_alignment != 0_bits) {
		fc["minimum-alignment"] = minimum_alignment.to_underlying();
	}

	return fc;
}

static
json make_static_length_array_field_class(json element_field_class,
		uint64_t length, bits minimum_alignment)
{
	json fc = make_array_field_class("static-length-array",
		element_field_class, minimum_alignment);

	fc["length"] = length;

	return fc;
}

static
json make_dynamic_length_array_field_class(json element_field_class,
	const field_path &length_field_location, bits minimum_alignment)
{
	json fc = make_array_field_class("dynamic-length-array",
		element_field_class, minimum_alignment);

	fc["length-field-location"] =
		make_field_location(length_field_location);

	return fc;
}

static
json make_string_field_class()
{
	return make_field_class("null-terminated-string", nullptr);
}

static
json make_packet_header_field_class(const ust_registry_session &session)
{
	byte_order bo = get_byte_order(session, false);

	structure_members members;

	members.add_member("magic",
		make_fixed_length_unsigned_integer_field_class(
			32_bits, bo, 8_bits, display_base::HEXADECIMAL,
			"packet-magic-number"));
	members.add_member("uuid",
		make_uuid_field_class("trace-class-uuid"));
	members.add_member("stream_id",
		make_fixed_length_unsigned_integer_field_class(
			32_bits, bo, 8_bits, display_base::DECIMAL,
			"data-stream-class-id"));
	members.add_member("stream_instance_id",
		make_fixed_length_unsigned_integer_field_class(
			64_bits, bo, 8_bits, display_base::DECIMAL,
			"data-stream-id"));

	return make_structure_field_class(0_bits, std::move(members));
}

static
json make_uuid(uint8_t uuid_bytes[LTTNG_UUID_LEN])
{
	json uuid = json::array();

	for (size_t i = 0; i < LTTNG_UUID_LEN; ++i) {
		uuid.push_back(uuid_bytes[i]);
	}

	return uuid;
}

static
json make_clock_offset(int64_t offset_cycles, uint64_t freq)
{
	// FIXME: not tested at all, especially not for negative values of offset

	/* Whole seconds. */
	int64_t s = offset_cycles / freq;

	/* Remaining cycles. */
	int64_t cycles = offset_cycles % freq;

	return {
		{ "seconds", s },
		{ "cycles", cycles },
	};
}

static inline
int get_count_order(unsigned int count)
{
	int order;

	order = lttng_fls(count) - 1;
	if (count & (count - 1)) {
		order++;
	}
	LTTNG_ASSERT(order >= 0);
	return order;
}

/*
 * Returns offset where to write in metadata array, or negative error value on error.
 */
static
ssize_t metadata_reserve(ust_registry_session &session, size_t len)
{
	size_t new_len = session.metadata_len + len;
	size_t new_alloc_len = new_len;
	size_t old_alloc_len = session.metadata_alloc_len;
	ssize_t ret;

	if (new_alloc_len > (UINT32_MAX >> 1))
		return -EINVAL;
	if ((old_alloc_len << 1) > (UINT32_MAX >> 1))
		return -EINVAL;

	if (new_alloc_len > old_alloc_len) {
		char *newptr;

		new_alloc_len =
			std::max<size_t>(1U << get_count_order(new_alloc_len), old_alloc_len << 1);
		newptr = (char *) realloc(session.metadata, new_alloc_len);
		if (!newptr)
			return -ENOMEM;
		session.metadata = newptr;
		/* We zero directly the memory from start of allocation. */
		memset(&session.metadata[old_alloc_len], 0, new_alloc_len - old_alloc_len);
		session.metadata_alloc_len = new_alloc_len;
	}
	ret = session.metadata_len;
	session.metadata_len += len;
	return ret;
}

static
int metadata_file_append(ust_registry_session &session,
		const char *str, size_t len)
{
	ssize_t written;

	if (session.metadata_fd < 0) {
		return 0;
	}
	/* Write to metadata file */
	written = lttng_write(session.metadata_fd, str, len);
	if (written != len) {
		return -1;
	}
	return 0;
}

/*
 * We have exclusive access to our metadata buffer (protected by the
 * ust_lock), so we can do racy operations such as looking for
 * remaining space left in packet and write, since mutual exclusion
 * protects us from concurrent writes.
 */
static ATTR_FORMAT_PRINTF(2, 3)
int lttng_metadata_printf(ust_registry_session &session,
		const char *fmt, ...)
{
	char *str = NULL;
	size_t len;
	va_list ap;
	ssize_t offset;
	int ret;

	va_start(ap, fmt);
	ret = vasprintf(&str, fmt, ap);
	va_end(ap);
	if (ret < 0)
		return -ENOMEM;

	len = strlen(str);
	offset = metadata_reserve(session, len);
	if (offset < 0) {
		ret = offset;
		goto end;
	}
	memcpy(&session.metadata[offset], str, len);
	ret = metadata_file_append(session, str, len);
	if (ret) {
		PERROR("Error appending to metadata file");
		goto end;
	}
	DBG3("Append to metadata: \"%s\"", str);
	ret = 0;

end:
	free(str);
	return ret;
}


static
void lttng_metadata_print_fragment(ust_registry_session &session,
		const json &fragment)
{
	lttng_metadata_printf(session, "\x1e%s", fragment.dump(2).c_str());
}

static
display_base int_to_display_base(int base)
{
	/* If we ever get an invalid value, default to 10. */
	switch (base) {
	case 2:
		return display_base::BINARY;
	case 8:
		return display_base::OCTAL;
	default:
	case 10:
		return display_base::DECIMAL;
	case 16:
		return display_base::HEXADECIMAL;
	}
}

static
json make_ust_integer_field_class(const ust_registry_session &session,
	const lttng_ust_ctl_integer_type &type)
{
	if (type.signedness) {
		return make_fixed_length_signed_integer_field_class(
			bits(type.size), get_byte_order(session, type.reverse_byte_order),
			bits(type.alignment), int_to_display_base(type.base),
			nullptr);
	} else {
		return make_fixed_length_unsigned_integer_field_class(
			bits(type.size), get_byte_order(session, type.reverse_byte_order),
			bits(type.alignment), int_to_display_base(type.base),
			nullptr);
	}
}

/* Called with session registry mutex held. */
static
json make_ust_enum_field_class(const ust_registry_session &session,
		const char *name, uint64_t id,
		const lttng_ust_ctl_integer_type &container)
{
	rcu_read_lock();
	const ust_registry_enum *reg_enum = ust_registry_lookup_enum_by_id(
		session, name, id);
	rcu_read_unlock();

	/* reg_enum can still be used because session registry mutex is held. */
	if (!reg_enum) {
		return -ENOENT;
	}

	bool is_signed = container.signedness;
	enumeration_mappings mappings;

	const lttng_ust_ctl_enum_entry *entries = reg_enum->entries;

	union {
		int64_t sign;
		uint64_t nosign;
	} next_auto_low_bound;

	if (is_signed) {
		next_auto_low_bound.sign = 0;
	} else {
		next_auto_low_bound.nosign = 0;
	}

	for (size_t i = 0; i < reg_enum->nr_entries; ++i) {
		const lttng_ust_ctl_enum_entry &entry = entries[i];

		//len = strlen(entry->string);

		if (entry.u.extra.options &
				LTTNG_UST_CTL_UST_ENUM_ENTRY_OPTION_IS_AUTO) {
			if (is_signed) {
				integer_range_set rs;
				rs.add_range(next_auto_low_bound.sign, next_auto_low_bound.sign);
				mappings.add_mapping(entry.string, make_integer_range_set(rs));
				++next_auto_low_bound.sign;
			} else {
				integer_range_set rs;
				rs.add_range(next_auto_low_bound.nosign, next_auto_low_bound.nosign);
				mappings.add_mapping(entry.string, make_integer_range_set(rs));
				++next_auto_low_bound.nosign;
			}
		} else {
			if (is_signed) {
				integer_range_set rs;
				// FIXME: not sure if those casts work as intended.
				rs.add_range((int64_t) entry.start.value, (int64_t) entry.end.value);
				mappings.add_mapping(entry.string, make_integer_range_set(rs));
			} else {
				integer_range_set rs;
				rs.add_range(entry.start.value, entry.end.value);
				mappings.add_mapping(entry.string, make_integer_range_set(rs));
			}
		}
	}

	return make_fixed_length_enumeration_field_class(
		is_signed, bits(container.size),
		get_byte_order(session, container.reverse_byte_order),
		bits(container.alignment), int_to_display_base(container.base),
		std::move(mappings));
}

static
void make_ust_field_class(const ust_registry_session &session,
		lttng_ust_ctl_field_iterator &field_iterator,
		field_path &current_field_path,
		std::function<void(const char *, json)> add_field,
		std::function<const json &(const char *)> get_last_field);

static
void make_ust_variant_field_class(
		const ust_registry_session &session,
		lttng_ust_ctl_field_iterator &field_iterator,
		field_path &current_field_path,
		const char *field_name,
		uint32_t nr_options,
		const char *selector_name,
		std::function<void(const char *, json)> add_field,
		std::function<const json &(const char *)> lookup_field)
{
	variant_options options;
	const json &selector_field = lookup_field (selector_name);
	const json &mappings = selector_field["mappings"];

	auto this_add_field = [&options, &mappings] (const char *option_name, json option_fc) {
		/* UST prefixes the enumerators with and underscore.  */
		std::string option_name_prefixed = std::string("_") + option_name;
		const json &ranges = mappings[option_name_prefixed];
		/*
		 * In CTF 1.8, the variant options were prefixed with an
		 * underscore to match the enumerator names.  It is not
		 * necessary to do it in CTF 2, as variant options don't rely
		 * on their names matchin an enumerator name.  But do it anyway
		 * to keep the old names, which may help readers migrating from
		 * 1.8 to 2.
		 */
		options.add_option(std::move(option_name_prefixed), ranges, option_fc);
	};

	{
		auto field_location_popper = current_field_path.push(field_name);

		for (uint32_t i = 0; i < nr_options; i++) {
			make_ust_field_class(session, field_iterator,
				current_field_path, this_add_field, lookup_field);
		}
	}

	auto field_location_popper = current_field_path.push(selector_name);
	add_field(field_name,
		make_variant_field_class(std::move(options), current_field_path));
}

static
void make_ust_field_class(const ust_registry_session &session,
		lttng_ust_ctl_field_iterator &field_iterator,
		field_path &current_field_path,
		std::function<void(const char *, json)> add_field,
		std::function<const json &(const char *)> lookup_field)
{
	const lttng_ust_ctl_field &field = field_iterator.get_next();

	switch (field.type.atype) {
	case lttng_ust_ctl_atype_integer:
		add_field(field.name,
			make_ust_integer_field_class(session,
				field.type.u.integer));
		break;

	case lttng_ust_ctl_atype_enum:
	{
		const auto &enumeration = field.type.u.legacy.basic.enumeration;
		add_field(field.name,
			make_ust_enum_field_class(session,
				enumeration.name, enumeration.id,
				enumeration.container_type));
		break;
	}

	case lttng_ust_ctl_atype_float:
	{
		const lttng_ust_ctl_float_type &t = field.type.u._float;

		add_field(field.name,
			make_fixed_length_floating_point_number_field_class(
			bits(t.exp_dig + t.mant_dig),
			get_byte_order(session, t.reverse_byte_order), bits(t.alignment)));

		break;
	}

	case lttng_ust_ctl_atype_array:
	{
		const auto &array_type = field.type.u.legacy.array;

		/* Only integers are currently supported in arrays. */
		if (array_type.elem_type.atype != lttng_ust_ctl_atype_integer) {
			throw metadata_generation_exception(
				"array element type not supported");
		}

		add_field(field.name, make_static_length_array_field_class(
			make_ust_integer_field_class(
				session, array_type.elem_type.u.basic.integer),
			array_type.length, 0_bits));

		break;
	}

	case lttng_ust_ctl_atype_array_nestable:
	{
		const struct lttng_ust_ctl_type &element_type =
			field_iterator.get_next().type;

		/* Only integers are currently supported in arrays. */
		if (element_type.atype != lttng_ust_ctl_atype_integer) {
			throw metadata_generation_exception(
				"array element type not supported");
		}

		const auto &array_type = field.type.u.array_nestable;

		/* The array alignment value we receive is in bytes.  */
		add_field(field.name,
			make_static_length_array_field_class(
				make_ust_integer_field_class(
					session, element_type.u.integer),
				array_type.length, bits(array_type.alignment * 8)));
		break;
	}

	case lttng_ust_ctl_atype_sequence:
	{
		const auto &t = field.type.u.legacy.sequence;

		/* Only integers are currently supported in sequences. */
		if (t.elem_type.atype != lttng_ust_ctl_atype_integer) {
			throw metadata_generation_exception(
				"sequence element type not supported");
		}

		const lttng_ust_ctl_integer_type &length_type
			= t.length_type.u.basic.integer;

		std::stringstream sstream;
		sstream << "__" << field.name << "_length";
		add_field(sstream.str().c_str(),
			make_ust_integer_field_class(session, length_type));

		auto popper = current_field_path.push(sstream.str().c_str());
		add_field(field.name,
			make_dynamic_length_array_field_class(
				make_ust_integer_field_class(
					session, t.elem_type.u.basic.integer),
				current_field_path, 0_bits));
		break;
	}
	case lttng_ust_ctl_atype_sequence_nestable:
	{
		const struct lttng_ust_ctl_type &element_type =
			field_iterator.get_next().type;

		/* Only integers are currently supported in sequences. */
		if (element_type.atype != lttng_ust_ctl_atype_integer) {
			throw metadata_generation_exception(
				"sequence element type not supported");
		}

		const auto &array_type = field.type.u.sequence_nestable;
		auto popper = current_field_path.push(
			array_type.length_name);

		/* The array alignment value we receive is in bytes.  */
		add_field(field.name,
			make_dynamic_length_array_field_class(
				make_ust_integer_field_class(
					session, element_type.u.integer),
				current_field_path,
				bits(array_type.alignment * 8)));
		break;
	}

	case lttng_ust_ctl_atype_string:
		add_field(field.name, make_string_field_class());
		break;

	case lttng_ust_ctl_atype_variant:
	{
		const decltype(field.type.u.legacy.variant) &variant_type =
			field.type.u.legacy.variant;

		make_ust_variant_field_class(session, field_iterator,
			current_field_path, field.name, variant_type.nr_choices,
			variant_type.tag_name, add_field, lookup_field);
		break;
	}

	case lttng_ust_ctl_atype_variant_nestable:
	{
		const decltype(field.type.u.variant_nestable) &variant_type =
			field.type.u.variant_nestable;

		make_ust_variant_field_class(session, field_iterator,
			current_field_path, field.name, variant_type.nr_choices,
			variant_type.tag_name, add_field, lookup_field);
		break;
	}

	case lttng_ust_ctl_atype_struct:
		if (field.type.u.legacy._struct.nr_fields != 0) {
			/* Currently only 0-length structures are supported. */
			throw metadata_generation_exception("Only 0-length structures are supported");
		}

		/* Don't emit anything */
		break;

	case lttng_ust_ctl_atype_struct_nestable:
		if (field.type.u.struct_nestable.nr_fields != 0) {
			/* Currently only 0-length structures are supported. */
			throw metadata_generation_exception("Only 0-length structures are supported");
		}

		/* Don't emit anything */
		break;

	case lttng_ust_ctl_atype_enum_nestable:
	{
		const lttng_ust_ctl_field &container =
			field_iterator.get_next();

		/* Only integers are supported as container types. */
		if (container.type.atype != lttng_ust_ctl_atype_integer) {
			throw metadata_generation_exception(
				"Enumeration container type not an integer");
		}

		const auto &enumeration = field.type.u.enum_nestable;
		add_field(field.name,
			make_ust_enum_field_class(session,
				enumeration.name, enumeration.id,
				container.type.u.integer));
		break;
	}
	default:
		throw metadata_generation_exception(
			"Unhandled lttng-ust field type");
	}
}

static
json make_record_common_context_field_class(
	const ust_registry_session &session,
	const ust_registry_channel &chan)
{
	lttng_ust_ctl_field_iterator iter(chan.ctx_fields, chan.nr_ctx_fields);
	field_path fp("event-record-common-context");
	structure_members members;

	auto add_field = [&members] (const char *name, json field_class) {
		members.add_member(name, field_class);
	};

	auto lookup_field = [&members] (const char *name) -> const json & {
		for (const structure_member &member : members) {
			if (strcmp(member.name, name) == 0) {
				return member.field_class;
			}
		}

		throw metadata_generation_exception("failed to look up field");
	};

	while (!iter.done()) {
		make_ust_field_class(session, iter, fp, add_field,
			lookup_field);
	}

	return make_structure_field_class(0_bits, std::move(members));
}

static
json make_event_record_class_payload_field_class(
		const ust_registry_session &session,
		const ust_registry_event &event)
{
	lttng_ust_ctl_field_iterator iter(event.fields, event.nr_fields);
	field_path fp("event-record-payload");
	structure_members members;

	auto add_field = [&members] (const char *name, json field_class) {
		members.add_member(name, field_class);
	};

	auto lookup_field = [&members] (const char *name) {
		for (const structure_member &member : members) {
			if (strcmp(member.name, name) == 0) {
				return member.field_class;
			}
		}

		throw metadata_generation_exception("failed to look up field");
	};

	while (!iter.done()) {
		make_ust_field_class(session, iter, fp, add_field,
			lookup_field);
	}

	return make_structure_field_class(0_bits, std::move(members));
}

static
json make_user_attributes(json attributes)
{
	return {
		{ "lttng.org,2009", attributes }
	};
}

static
json make_event_record_class_user_attributes(const ust_registry_event &event)
{
	json user_attributes = make_user_attributes({
		{ "log-level", event.loglevel_value },
	});

	if (event.model_emf_uri) {
		user_attributes["emf-uri"] = event.model_emf_uri;
	}

	return user_attributes;
}

/*
 * Should be called with session registry mutex held.
 */
int ust_metadata_event_statedump(struct ust_registry_session *session,
		struct ust_registry_channel *chan,
		struct ust_registry_event *event)
{
	/* Don't dump metadata events */
	if (chan->chan_id == -1U)
		return 0;

	/*
	 * We don't want to output an event's metadata before its parent
	 * stream's metadata.  If the stream's metadata hasn't been output yet,
	 * skip this event.  Its metadata will be output when we output the
	 * stream's metadata.
	 */
	if (!chan->metadata_dumped) {
		return 0;
	}

	LTTNG_ASSERT(!event->metadata_dumped);

	try {
		json event_record_class = make_fragment("event-record-class");
		event_record_class.update({
			{ "name", event->name },
			{ "id", event->id },
			{ "data-stream-class-id", chan->chan_id },
			{ "user-attributes", make_event_record_class_user_attributes(*event) },
		});

		if (event->nr_fields) {
			event_record_class["payload-field-class"] =
					make_event_record_class_payload_field_class(*session, *event);
		}

		lttng_metadata_print_fragment(*session, event_record_class);

		event->metadata_dumped = 1;

		return 0;
	} catch (const std::exception &error) {
		ERR("%s", error.what());
		return  -LTTNG_ERR_UNK;
	} catch (...) {
		return -LTTNG_ERR_UNK;
	}
}

static
json make_packet_context_field_class(const ust_registry_session &session)
{
	byte_order bo = get_byte_order(session, false);
	structure_members members;

	members.add_member("timestamp_begin",
		make_fixed_length_unsigned_integer_field_class(
			64_bits, bo, 8_bits, display_base::DECIMAL,
			"packet-beginning-default-clock-timestamp"));
	members.add_member("timestamp_end",
		make_fixed_length_unsigned_integer_field_class(
			64_bits, bo, 8_bits, display_base::DECIMAL,
			"packet-end-default-clock-timestamp"));
	members.add_member("content_size",
		make_fixed_length_unsigned_integer_field_class(
			64_bits, bo, 8_bits, display_base::DECIMAL,
			"packet-content-size"));
	members.add_member("packet_size",
		make_fixed_length_unsigned_integer_field_class(
			64_bits, bo, 8_bits, display_base::DECIMAL,
			"packet-total-size"));
	members.add_member("packet_seq_num",
		make_fixed_length_unsigned_integer_field_class(
			64_bits, bo, 8_bits, display_base::DECIMAL,
			"packet-sequence-number"));
	members.add_member("events_discarded",
		make_fixed_length_unsigned_integer_field_class(
			bits(session.bits_per_long), bo,
			bits(session.long_alignment),
			display_base::DECIMAL,
			"discarded-event-record-counter-snapshot"));
	members.add_member("cpu_id",
		make_fixed_length_unsigned_integer_field_class(
			32_bits, bo, 8_bits, display_base::DECIMAL, nullptr));

	return make_structure_field_class(0_bits, std::move(members));
}

static
json make_record_header_compact_field_class(const ust_registry_session &session)
{
	byte_order bo = get_byte_order(session, false);

	structure_members compact_members;
	compact_members.add_member("timestamp",
		make_fixed_length_unsigned_integer_field_class(
			27_bits, bo, 1_bits, display_base::DECIMAL,
			"default-clock-timestamp"));

	structure_members extended_members;
	extended_members.add_member("id",
		make_fixed_length_unsigned_integer_field_class(
			32_bits, bo, 8_bits, display_base::DECIMAL,
			"event-record-class-id"));
	extended_members.add_member("timestamp",
		make_fixed_length_unsigned_integer_field_class(
			64_bits, bo, 8_bits, display_base::DECIMAL,
			"default-clock-timestamp"));

	integer_range_set compact_ranges, extended_ranges;
	compact_ranges.add_range(UINT64_C(0), 30);
	extended_ranges.add_range(UINT64_C(31), 31);

	variant_options options;
	options.add_option("compact",
		make_integer_range_set(compact_ranges),
		make_structure_field_class(0_bits, std::move(compact_members)));
	options.add_option("extended",
		make_integer_range_set(extended_ranges),
		make_structure_field_class(0_bits, std::move(extended_members)));

	enumeration_mappings id_mappings;
	id_mappings.add_mapping("compact",
		make_integer_range_set(compact_ranges));
	id_mappings.add_mapping("extended",
		make_integer_range_set(extended_ranges));

	structure_members members;
	members.add_member("id",
		make_fixed_length_unsigned_enumeration_field_class(
			5_bits, bo, 8_bits, display_base::DECIMAL,
			"event-record-class-id", std::move(id_mappings)));
	members.add_member("v",
		make_variant_field_class(std::move(options),
			{"event-record-header", "id"}));

	return make_structure_field_class(8_bits, std::move(members));
}

static
json make_record_header_large_field_class(const ust_registry_session &session)
{
	byte_order bo = get_byte_order(session, false);

	structure_members compact_members;
	compact_members.add_member("timestamp",
		make_fixed_length_unsigned_integer_field_class(
			32_bits, bo, 8_bits, display_base::DECIMAL,
			"default-clock-timestamp"));

	structure_members extended_members;
	extended_members.add_member("id",
		make_fixed_length_unsigned_integer_field_class(
			32_bits, bo, 8_bits, display_base::DECIMAL,
			"event-record-class-id"));
	extended_members.add_member("timestamp",
		make_fixed_length_unsigned_integer_field_class(
			64_bits, bo, 8_bits, display_base::DECIMAL,
			"default-clock-timestamp"));

	integer_range_set compact_ranges, extended_ranges;
	compact_ranges.add_range(UINT64_C(0), 65534);
	extended_ranges.add_range(UINT64_C(65535), 65535);

	variant_options options;
	options.add_option("compact",
		make_integer_range_set(compact_ranges),
		make_structure_field_class(0_bits, std::move(compact_members)));
	options.add_option("extended",
		make_integer_range_set(extended_ranges),
		make_structure_field_class(0_bits, std::move(extended_members)));

	enumeration_mappings id_mappings;
	id_mappings.add_mapping("compact",
		make_integer_range_set(compact_ranges));
	id_mappings.add_mapping("extended",
		make_integer_range_set(extended_ranges));

	structure_members members;
	members.add_member("id",
		make_fixed_length_unsigned_enumeration_field_class(
			16_bits, bo, 8_bits, display_base::DECIMAL,
			"event-record-class-id", std::move(id_mappings)));
	members.add_member("v",
		make_variant_field_class(std::move(options),
			{ "event-record-header", "id" }));

	return make_structure_field_class(8_bits, std::move(members));
}

static
json make_record_header_field_class(const ust_registry_session &session,
		const ust_registry_channel &chan)
{
	if (chan.header_type == LTTNG_UST_CTL_CHANNEL_HEADER_COMPACT) {
		return make_record_header_compact_field_class(session);
	} else {
		return make_record_header_large_field_class(session);
	}
}

/*
 * Should be called with session registry mutex held.
 */
int ust_metadata_channel_statedump(struct ust_registry_session *session,
		struct ust_registry_channel *chan)
{
	/* Don't dump metadata events */
	if (chan->chan_id == -1U)
		return 0;

	if (!chan->header_type)
		return -EINVAL;

	try {
		json data_stream_class = make_fragment("data-stream-class");
		data_stream_class.update({
			{ "id", chan->chan_id },
			{ "packet-context-field-class",
				make_packet_context_field_class(*session) },
			{ "event-record-header-field-class",
				make_record_header_field_class(*session, *chan) },
		});

		if (chan->ctx_fields) {
			data_stream_class.update({
				{ "event-record-common-context-field-class",
					make_record_common_context_field_class(*session, *chan) }
			});
		}

		lttng_metadata_print_fragment(*session, data_stream_class);

		/* Flag success of metadata dump. */
		chan->metadata_dumped = 1;

		/*
		 * Output the metadata of any existing event.
		 *
		 * Sort the events by id.  This is not necessary, but it's nice to have
		 * a more predictable order in the metadata file.
		 */
		std::vector<ust_registry_event *> events;
		{
			cds_lfht_iter event_iter;
			ust_registry_event *event;
			cds_lfht_for_each_entry(chan->events->ht, &event_iter, event,
					node.node) {
				events.push_back(event);
			}
		}

		std::sort(events.begin(), events.end(),
			[] (ust_registry_event *a, ust_registry_event *b) {
				return a->id < b->id;
			});

		for (ust_registry_event *event : events) {
			ust_metadata_event_statedump(session, chan, event);
		}

		return 0;
	} catch (const std::exception &error) {
		ERR("%s", error.what());
		return  -LTTNG_ERR_UNK;
	} catch (...) {
		return -LTTNG_ERR_UNK;
	}
}

/*
 * The offset between monotonic and realtime clock can be negative if
 * the system sets the REALTIME clock to 0 after boot.
 */
static
int measure_single_clock_offset(struct offset_sample *sample)
{
	uint64_t monotonic_avg, monotonic[2], measure_delta, realtime;
	uint64_t tcf = trace_clock_freq();
	struct timespec rts = { 0, 0 };
	int ret;

	monotonic[0] = trace_clock_read64();
	ret = lttng_clock_gettime(CLOCK_REALTIME, &rts);
	if (ret < 0) {
		return ret;
	}
	monotonic[1] = trace_clock_read64();
	measure_delta = monotonic[1] - monotonic[0];
	if (measure_delta > sample->measure_delta) {
		/*
		 * Discard value if it took longer to read than the best
		 * sample so far.
		 */
		return 0;
	}
	monotonic_avg = (monotonic[0] + monotonic[1]) >> 1;
	realtime = (uint64_t) rts.tv_sec * tcf;
	if (tcf == NSEC_PER_SEC) {
		realtime += rts.tv_nsec;
	} else {
		realtime += (uint64_t) rts.tv_nsec * tcf / NSEC_PER_SEC;
	}
	sample->offset = (int64_t) realtime - monotonic_avg;
	sample->measure_delta = measure_delta;
	return 0;
}

/*
 * Approximation of NTP time of day to clock monotonic correlation,
 * taken at start of trace. Keep the measurement that took the less time
 * to complete, thus removing imprecision caused by preemption.
 * May return a negative offset.
 */
static
int64_t measure_clock_offset(void)
{
	int i;
	struct offset_sample offset_best_sample = {
		.offset = 0,
		.measure_delta = UINT64_MAX,
	};

	for (i = 0; i < NR_CLOCK_OFFSET_SAMPLES; i++) {
		if (measure_single_clock_offset(&offset_best_sample)) {
			return 0;
		}
	}
	return offset_best_sample.offset;
}

/*
 * Should be called with session registry mutex held.
 */
int ust_metadata_session_statedump(struct ust_registry_session *session,
		struct ust_app *app,
		uint32_t major,
		uint32_t minor)
{
	LTTNG_ASSERT(session);

	try {
		json preamble = make_fragment("preamble");
		preamble.update({
			{ "version", 2 },
		});
		lttng_metadata_print_fragment(*session, preamble);

		json trace_class = make_fragment("trace-class");
		trace_class.update({
			{ "packet-header-field-class",
				make_packet_header_field_class(*session) },
			{ "uuid", make_uuid (session->uuid) }
		});
		lttng_metadata_print_fragment(*session, trace_class);

		uint64_t clock_freq = trace_clock_freq();
		json clock_class = make_fragment("clock-class");
		clock_class.update({
			{ "name", trace_clock_name() },
			{ "description", trace_clock_description() },
			{ "frequency", clock_freq },
			{ "offset", make_clock_offset(measure_clock_offset(), clock_freq) },
		});

		char clock_uuid_str[LTTNG_UUID_STR_LEN];
		int ret = trace_clock_uuid(clock_uuid_str);
		if (ret == 0) {
			uint8_t clock_uuid[LTTNG_UUID_LEN];
			ret = lttng_uuid_from_str(clock_uuid_str, clock_uuid);
			if (ret == 0) {
				clock_class["uuid"] = make_uuid(clock_uuid);
			} else {
				// FIXME: warn?
			}
		} else {
			// FIXME: warn?
		}

		lttng_metadata_print_fragment(*session, clock_class);

		return 0;
	} catch (const std::exception &error) {
		ERR("%s", error.what());
		return  -LTTNG_ERR_UNK;
	} catch (...) {
		return -LTTNG_ERR_UNK;
	}
}