Common Trace Format 2 generation

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