sessiond: express field references as locations instead of names

CTF2 requires type references (a sequence's length, a variant's
selector) to be expressed as absolute field locations.

The `field` API currently expresses these references as names directly
since those are provided by the tracer.

This change introduces the notion of a field location and adapts
the tsdl visitor to serialize those as expected.

Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>
Change-Id: I56f603062d6748051adf3fa31bc08422c47c144d

diff --git a/src/bin/lttng-sessiond/field.cpp b/src/bin/lttng-sessiond/field.cpp
index d81cf02c736ccb9f061fdacdf1dcf33cc2ebd66b..df51df488498589f9f4524f6025cce8a4f2366a4 100644 (file)
--- a/src/bin/lttng-sessiond/field.cpp
+++ b/src/bin/lttng-sessiond/field.cpp
@@ -30,6 +30,18 @@ bool fields_are_equal(const FieldTypeSet& a, const FieldTypeSet& b)
 }
 } /* namespace */
 
+lst::field_location::field_location(lst::field_location::root in_lookup_root,
+               lst::field_location::elements in_elements) :
+       root_{in_lookup_root}, elements_{std::move(in_elements)}
+{
+}
+
+bool lst::field_location::operator==(const lst::field_location& other) const noexcept
+{
+       return root_ == other.root_ &&
+                       elements_ == other.elements_;
+}
+
 lst::type::type(unsigned int in_alignment) : alignment{in_alignment}
 {
 }
@@ -214,9 +226,9 @@ void lst::static_length_array_type::accept(type_visitor& visitor) const
 
 lst::dynamic_length_array_type::dynamic_length_array_type(unsigned int in_alignment,
                type::cuptr in_element_type,
-               std::string in_length_field_name) :
+               lst::field_location in_length_field_location) :
        array_type(in_alignment, std::move(in_element_type)),
-       length_field_name{std::move(in_length_field_name)}
+       length_field_location{std::move(in_length_field_location)}
 {
 }
 
@@ -225,7 +237,7 @@ bool lst::dynamic_length_array_type::_is_equal(const type& base_other) const noe
        const auto& other = static_cast<decltype(*this)&>(base_other);
 
        return array_type::_is_equal(base_other) &&
-                       this->length_field_name == other.length_field_name;
+                       this->length_field_location == other.length_field_location;
 }
 
 void lst::dynamic_length_array_type::accept(type_visitor& visitor) const
@@ -252,8 +264,8 @@ void lst::static_length_blob_type::accept(type_visitor& visitor) const
 }
 
 lst::dynamic_length_blob_type::dynamic_length_blob_type(
-               unsigned int in_alignment, std::string in_length_field_name) :
-       type(in_alignment), length_field_name{std::move(in_length_field_name)}
+               unsigned int in_alignment, lst::field_location in_length_field_location) :
+       type(in_alignment), length_field_location{std::move(in_length_field_location)}
 {
 }
 
@@ -261,7 +273,7 @@ bool lst::dynamic_length_blob_type::_is_equal(const type& base_other) const noex
 {
        const auto& other = dynamic_cast<decltype(*this)&>(base_other);
 
-       return length_field_name == other.length_field_name;
+       return length_field_location == other.length_field_location;
 }
 
 void lst::dynamic_length_blob_type::accept(type_visitor& visitor) const
@@ -301,8 +313,9 @@ void lst::static_length_string_type::accept(type_visitor& visitor) const
 
 lst::dynamic_length_string_type::dynamic_length_string_type(unsigned int in_alignment,
                enum encoding in_encoding,
-               std::string in_length_field_name) :
-       string_type(in_alignment, in_encoding), length_field_name{std::move(in_length_field_name)}
+               field_location in_length_field_location) :
+       string_type(in_alignment, in_encoding),
+       length_field_location{std::move(in_length_field_location)}
 {
 }
 
@@ -311,7 +324,7 @@ bool lst::dynamic_length_string_type::_is_equal(const type& base_other) const no
        const auto& other = static_cast<decltype(*this)&>(base_other);
 
        return string_type::_is_equal(base_other) &&
-                       this->length_field_name == other.length_field_name;
+                       this->length_field_location == other.length_field_location;
 }
 
 void lst::dynamic_length_string_type::accept(type_visitor& visitor) const
@@ -348,11 +361,12 @@ void lst::structure_type::accept(type_visitor& visitor) const
 }
 
 lst::variant_type::variant_type(unsigned int in_alignment,
-               std::string in_tag_name,
+               field_location in_selector_field_location,
                choices in_choices) :
        type(in_alignment),
-       tag_name{std::move(in_tag_name)},
-       _choices{std::move(in_choices)}
+       selector_field_location{std::move(in_selector_field_location)},
+       _choices
+{std::move(in_choices)}
 {
 }
 
@@ -360,8 +374,10 @@ bool lst::variant_type::_is_equal(const type& base_other) const noexcept
 {
        const auto &other = static_cast<decltype(*this)&>(base_other);
 
-       return this->tag_name == other.tag_name &&
-                       fields_are_equal(this->_choices, other._choices);
+       return this->selector_field_location == other.selector_field_location &&
+                       fields_are_equal(this->_choices
+, other._choices
+);
 }
 
 void lst::variant_type::accept(type_visitor& visitor) const

diff --git a/src/bin/lttng-sessiond/field.hpp b/src/bin/lttng-sessiond/field.hpp
index f353adafbcc7d04e04e056144d53bb3c269b1b73..2a1bcf35bf8002d5eec1a447fbe48b611d8eb345 100644 (file)
--- a/src/bin/lttng-sessiond/field.hpp
+++ b/src/bin/lttng-sessiond/field.hpp
@@ -27,6 +27,26 @@ enum class byte_order {
        LITTLE_ENDIAN_,
 };
 
+class field_location {
+public:
+       enum class root {
+               PACKET_HEADER,
+               PACKET_CONTEXT,
+               EVENT_RECORD_HEADER,
+               EVENT_RECORD_COMMON_CONTEXT,
+               EVENT_RECORD_SPECIFIC_CONTEXT,
+               EVENT_RECORD_PAYLOAD,
+       };
+
+       using elements = std::vector<std::string>;
+
+       field_location(root lookup_root, elements elements);
+       bool operator==(const field_location& other) const noexcept;
+
+       const root root_;
+       const elements elements_;
+};
+
 /*
  * Field, and the various field types, represents fields as exposed by the
  * LTTng tracers. These classes do not attempt to describe the complete spectrum of the CTF
@@ -277,11 +297,11 @@ class dynamic_length_array_type : public array_type {
 public:
        dynamic_length_array_type(unsigned int alignment,
                        type::cuptr element_type,
-                       std::string length_field_name);
+                       field_location length_field_location);
 
        virtual void accept(type_visitor& visitor) const override final;
 
-       const std::string length_field_name;
+       const field_location length_field_location;
 
 private:
        virtual bool _is_equal(const type& base_other) const noexcept override final;
@@ -309,11 +329,11 @@ private:
 
 class dynamic_length_blob_type : public type {
 public:
-       dynamic_length_blob_type(unsigned int alignment, std::string length_field_name);
+       dynamic_length_blob_type(unsigned int alignment, field_location length_field_location);
 
        virtual void accept(type_visitor& visitor) const override final;
 
-       const std::string length_field_name;
+       const field_location length_field_location;
 
 private:
        virtual bool _is_equal(const type& base_other) const noexcept override final;
@@ -355,10 +375,10 @@ class dynamic_length_string_type : public string_type {
 public:
        dynamic_length_string_type(unsigned int alignment,
                        enum encoding in_encoding,
-                       std::string length_field_name);
+                       field_location length_field_location);
        virtual void accept(type_visitor& visitor) const override final;
 
-       const std::string length_field_name;
+       const field_location length_field_location;
 
 private:
        virtual bool _is_equal(const type& base_other) const noexcept override final;
@@ -388,12 +408,15 @@ class variant_type : public type {
 public:
        using choices = std::vector<field::cuptr>;
 
-       variant_type(unsigned int alignment, std::string tag_name, choices in_choices);
+       variant_type(unsigned int alignment,
+                       field_location selector_field_location,
+                       choices in_choices);
 
        virtual void accept(type_visitor& visitor) const override final;
 
-       const std::string tag_name;
+       const field_location selector_field_location;
        const choices _choices;
+;
 
 private:
        virtual bool _is_equal(const type& base_other) const noexcept override final;

diff --git a/src/bin/lttng-sessiond/tsdl-trace-class-visitor.cpp b/src/bin/lttng-sessiond/tsdl-trace-class-visitor.cpp
index 17c4f92c4b8817c55746ae8a4ec3e66e47ccfe82..bccd62737b01374284464c17213e991cc63f56fe 100644 (file)
--- a/src/bin/lttng-sessiond/tsdl-trace-class-visitor.cpp
+++ b/src/bin/lttng-sessiond/tsdl-trace-class-visitor.cpp
@@ -349,8 +349,8 @@ private:
                type.element_type->accept(*this);
                _type_suffixes.emplace(fmt::format("[{}]",
                                _bypass_identifier_escape ?
-                                               type.length_field_name :
-                                                     escape_tsdl_identifier(type.length_field_name)));
+                                               *(type.length_field_location.elements_.end() - 1) :
+                                                       escape_tsdl_identifier(*(type.length_field_location.elements_.end() - 1))));
        }
 
        virtual void visit(const lst::static_length_blob_type& type) override final
@@ -372,7 +372,7 @@ private:
                                _trace_abi.byte_order, 8, lst::integer_type::signedness::UNSIGNED,
                                lst::integer_type::base::HEXADECIMAL);
                const auto array = lttng::make_unique<lst::dynamic_length_array_type>(
-                               type.alignment, std::move(uint8_element), type.length_field_name);
+                               type.alignment, std::move(uint8_element), type.length_field_location);
 
                visit(*array);
        }
@@ -425,8 +425,8 @@ private:
                _indentation_level++;
                _description += fmt::format("variant <{}> {{\n",
                                _bypass_identifier_escape ?
-                                               type.tag_name :
-                                                     escape_tsdl_identifier(type.tag_name));
+                                               *(type.selector_field_location.elements_.end() - 1) :
+                                                       escape_tsdl_identifier(*(type.selector_field_location.elements_.end() - 1)));
 
                /*
                 * The CTF 1.8 specification only recommends that implementations ignore
@@ -477,7 +477,7 @@ private:
                 */
                const auto char_sequence = lttng::make_unique<lst::dynamic_length_array_type>(
                                type.alignment, create_character_type(type.encoding_),
-                               type.length_field_name);
+                               type.length_field_location);
 
                visit(*char_sequence);
        }

diff --git a/src/bin/lttng-sessiond/ust-app.cpp b/src/bin/lttng-sessiond/ust-app.cpp
index 3f39b02e4d9ee3d0e6faf65fa1d243ddf242f2e0..9690115d66c56ca83b06f6adb6e92e888249ec00 100644 (file)
--- a/src/bin/lttng-sessiond/ust-app.cpp
+++ b/src/bin/lttng-sessiond/ust-app.cpp
@@ -6429,7 +6429,8 @@ static int handle_app_register_channel_notification(int sock,
        try {
                auto app_context_fields = lsu::create_trace_fields_from_ust_ctl_fields(
                                *locked_registry_session, ust_ctl_context_fields.get(),
-                               context_field_count);
+                               context_field_count,
+                               lst::field_location::root::EVENT_RECORD_COMMON_CONTEXT);
 
                if (!ust_reg_chan.is_registered()) {
                        lst::type::cuptr event_context = app_context_fields.size() ?
@@ -6563,12 +6564,14 @@ static int add_event_ust_registry(int sock, int sobjd, int cobjd, const char *na
                                channel.add_event(sobjd, cobjd, name, signature.get(),
                                                lsu::create_trace_fields_from_ust_ctl_fields(
                                                                *locked_registry, fields.get(),
-                                                               nr_fields),
+                                                               nr_fields,
+                                                               lst::field_location::root::
+                                                                               EVENT_RECORD_PAYLOAD),
                                                loglevel_value,
                                                model_emf_uri.get() ?
                                                                nonstd::optional<std::string>(
                                                                                model_emf_uri.get()) :
-                                                                     nonstd::nullopt,
+                                                               nonstd::nullopt,
                                                ua_sess->buffer_type, *app, event_id);
                                ret_code = 0;
                        } catch (const std::exception& ex) {

diff --git a/src/bin/lttng-sessiond/ust-field-convert.cpp b/src/bin/lttng-sessiond/ust-field-convert.cpp
index 9a07b38c46d3b054482e40f9044ec148ed2f7a9d..6864440d6881174adbdd5fa5dba49e60abe435c9 100644 (file)
--- a/src/bin/lttng-sessiond/ust-field-convert.cpp
+++ b/src/bin/lttng-sessiond/ust-field-convert.cpp
@@ -43,13 +43,17 @@ lst::type::cuptr create_type_from_ust_ctl_fields(const lttng_ust_ctl_field *curr
                const lttng_ust_ctl_field *end,
                const session_attributes& session_attributes,
                const lttng_ust_ctl_field **next_ust_ctl_field,
-               publish_field_fn publish_field);
+               publish_field_fn publish_field,
+               lst::field_location::root lookup_root,
+               lst::field_location::elements& current_field_location_elements);
 
 void create_field_from_ust_ctl_fields(const lttng_ust_ctl_field *current,
                const lttng_ust_ctl_field *end,
                const session_attributes& session_attributes,
                const lttng_ust_ctl_field **next_ust_ctl_field,
-               publish_field_fn publish_field);
+               publish_field_fn publish_field,
+               lst::field_location::root lookup_root,
+               lst::field_location::elements& current_field_location_elements);
 
 template <class UstCtlEncodingType>
 enum lst::null_terminated_string_type::encoding ust_ctl_encoding_to_string_field_encoding(UstCtlEncodingType encoding)
@@ -316,7 +320,9 @@ lst::type::cuptr create_array_nestable_type_from_ust_ctl_fields(const lttng_ust_
                const lttng_ust_ctl_field *end,
                const session_attributes& session_attributes,
                const lttng_ust_ctl_field **next_ust_ctl_field,
-               publish_field_fn publish_field)
+               publish_field_fn publish_field,
+               lst::field_location::root lookup_root,
+               lst::field_location::elements &current_field_location_elements)
 {
        if (current >= end) {
                LTTNG_THROW_PROTOCOL_ERROR(
@@ -337,7 +343,8 @@ lst::type::cuptr create_array_nestable_type_from_ust_ctl_fields(const lttng_ust_
 
        /* next_ust_ctl_field is updated as needed. */
        element_type = create_type_from_ust_ctl_fields(&element_uctl_field, end, session_attributes,
-                       next_ust_ctl_field, publish_field);
+                       next_ust_ctl_field, publish_field, lookup_root,
+                       current_field_location_elements);
        if (element_uctl_field.type.atype == lttng_ust_ctl_atype_integer &&
                        element_uctl_field.type.u.integer.encoding != lttng_ust_ctl_encode_none) {
                /* Element represents a text character. */
@@ -372,7 +379,9 @@ lst::type::cuptr create_sequence_type_from_ust_ctl_fields(const lttng_ust_ctl_fi
                const lttng_ust_ctl_field *end,
                const session_attributes& session_attributes,
                const lttng_ust_ctl_field **next_ust_ctl_field,
-               publish_field_fn publish_field)
+               publish_field_fn publish_field,
+               lst::field_location::root lookup_root,
+               lst::field_location::elements &current_field_location_elements)
 {
        if (current >= end) {
                LTTNG_THROW_PROTOCOL_ERROR(
@@ -411,8 +420,15 @@ lst::type::cuptr create_sequence_type_from_ust_ctl_fields(const lttng_ust_ctl_fi
        auto length_type = create_integer_type_from_ust_ctl_basic_type(
                        length_uctl_type, session_attributes);
 
+       lst::field_location::elements length_field_location_elements =
+                       current_field_location_elements;
+       length_field_location_elements.emplace_back(length_field_name);
+
+       const lst::field_location length_field_location{
+                       lookup_root, std::move(length_field_location_elements)};
+
        /* Publish an implicit length field _before_ the sequence field. */
-       publish_field(lttng::make_unique<lst::field>(length_field_name, std::move(length_type)));
+       publish_field(lttng::make_unique<lst::field>(std::move(length_field_name), std::move(length_type)));
 
        *next_ust_ctl_field = current + 1;
 
@@ -428,11 +444,11 @@ lst::type::cuptr create_sequence_type_from_ust_ctl_fields(const lttng_ust_ctl_fi
 
                /* Sequence is a dynamic-length string. */
                return lttng::make_unique<lst::dynamic_length_string_type>(sequence_alignment,
-                               *element_encoding, std::move(length_field_name));
+                               *element_encoding, std::move(length_field_location));
        }
 
-       return lttng::make_unique<lst::dynamic_length_array_type>(
-                       sequence_alignment, std::move(element_type), std::move(length_field_name));
+       return lttng::make_unique<lst::dynamic_length_array_type>(sequence_alignment,
+                       std::move(element_type), std::move(length_field_location));
 }
 
 lst::type::cuptr create_sequence_nestable_type_from_ust_ctl_fields(
@@ -440,7 +456,9 @@ lst::type::cuptr create_sequence_nestable_type_from_ust_ctl_fields(
                const lttng_ust_ctl_field *end,
                const session_attributes& session_attributes,
                const lttng_ust_ctl_field **next_ust_ctl_field,
-               publish_field_fn publish_field)
+               publish_field_fn publish_field,
+               lst::field_location::root lookup_root,
+               lst::field_location::elements &current_field_location_elements)
 {
        if (current >= end) {
                LTTNG_THROW_PROTOCOL_ERROR(
@@ -465,7 +483,8 @@ lst::type::cuptr create_sequence_nestable_type_from_ust_ctl_fields(
 
        /* next_ust_ctl_field is updated as needed. */
        auto element_type = create_type_from_ust_ctl_fields(&element_uctl_field, end,
-                       session_attributes, next_ust_ctl_field, publish_field);
+                       session_attributes, next_ust_ctl_field, publish_field, lookup_root,
+                       current_field_location_elements);
 
        if (lttng_strnlen(sequence_uctl_field.type.u.sequence_nestable.length_name,
                            sizeof(sequence_uctl_field.type.u.sequence_nestable.length_name)) ==
@@ -473,6 +492,14 @@ lst::type::cuptr create_sequence_nestable_type_from_ust_ctl_fields(
                LTTNG_THROW_PROTOCOL_ERROR("Sequence length field name is not null terminated");
        }
 
+
+       lst::field_location::elements length_field_location_elements =
+                       current_field_location_elements;
+       length_field_location_elements.emplace_back(std::move(length_field_name));
+
+       const lst::field_location length_field_location{
+                       lookup_root, std::move(length_field_location_elements)};
+
        if (element_encoding) {
                const auto integer_element_size =
                                static_cast<const lst::integer_type&>(*element_type).size;
@@ -485,11 +512,11 @@ lst::type::cuptr create_sequence_nestable_type_from_ust_ctl_fields(
 
                /* Sqeuence is a dynamic-length string. */
                return lttng::make_unique<lst::dynamic_length_string_type>(sequence_alignment,
-                               *element_encoding, std::move(length_field_name));
+                               *element_encoding, std::move(length_field_location));
        }
 
-       return lttng::make_unique<lst::dynamic_length_array_type>(
-                       sequence_alignment, std::move(element_type), std::move(length_field_name));
+       return lttng::make_unique<lst::dynamic_length_array_type>(sequence_alignment,
+                       std::move(element_type), std::move(length_field_location));
 }
 
 lst::type::cuptr create_structure_field_from_ust_ctl_fields(const lttng_ust_ctl_field *current,
@@ -528,7 +555,9 @@ lst::type::cuptr create_structure_field_from_ust_ctl_fields(const lttng_ust_ctl_
 lst::type::cuptr create_variant_field_from_ust_ctl_fields(const lttng_ust_ctl_field *current,
                const lttng_ust_ctl_field *end,
                const session_attributes& session_attributes,
-               const lttng_ust_ctl_field **next_ust_ctl_field)
+               const lttng_ust_ctl_field **next_ust_ctl_field,
+               lst::field_location::root lookup_root,
+               lst::field_location::elements &current_field_location_elements)
 {
        if (current >= end) {
                LTTNG_THROW_PROTOCOL_ERROR(
@@ -553,25 +582,37 @@ lst::type::cuptr create_variant_field_from_ust_ctl_fields(const lttng_ust_ctl_fi
                tag_name = variant_uctl_field.type.u.variant_nestable.tag_name;
        }
 
+       lst::field_location::elements selector_field_location_elements =
+                       current_field_location_elements;
+       selector_field_location_elements.emplace_back(tag_name);
+
+       const lst::field_location selector_field_location{
+                       lookup_root, std::move(selector_field_location_elements)};
+
        /* Choices follow. next_ust_ctl_field is updated as needed. */
        lst::variant_type::choices choices;
        for (unsigned int i = 0; i < choice_count; i++) {
-               create_field_from_ust_ctl_fields(current, end, session_attributes,
-                               next_ust_ctl_field, [&choices](lst::field::cuptr field) {
+               create_field_from_ust_ctl_fields(
+                               current, end, session_attributes, next_ust_ctl_field,
+                               [&choices](lst::field::cuptr field) {
                                        choices.emplace_back(std::move(field));
-                               });
+                               },
+                               lookup_root, current_field_location_elements);
 
                current = *next_ust_ctl_field;
        }
 
-       return lttng::make_unique<lst::variant_type>(alignment, tag_name, std::move(choices));
+       return lttng::make_unique<lst::variant_type>(
+                       alignment, std::move(selector_field_location), std::move(choices));
 }
 
 lst::type::cuptr create_type_from_ust_ctl_fields(const lttng_ust_ctl_field *current,
                const lttng_ust_ctl_field *end,
                const session_attributes& session_attributes,
                const lttng_ust_ctl_field **next_ust_ctl_field,
-               publish_field_fn publish_field)
+               publish_field_fn publish_field,
+               lst::field_location::root lookup_root,
+               lst::field_location::elements &current_field_location_elements)
 {
        switch (current->type.atype) {
        case lttng_ust_ctl_atype_integer:
@@ -592,21 +633,24 @@ lst::type::cuptr create_type_from_ust_ctl_fields(const lttng_ust_ctl_field *curr
                                next_ust_ctl_field);
        case lttng_ust_ctl_atype_array_nestable:
                return create_array_nestable_type_from_ust_ctl_fields(current, end,
-                               session_attributes, next_ust_ctl_field, publish_field);
+                               session_attributes, next_ust_ctl_field, publish_field, lookup_root,
+                               current_field_location_elements);
        case lttng_ust_ctl_atype_sequence:
                return create_sequence_type_from_ust_ctl_fields(current, end, session_attributes,
-                               next_ust_ctl_field, publish_field);
+                               next_ust_ctl_field, publish_field, lookup_root,
+                               current_field_location_elements);
        case lttng_ust_ctl_atype_sequence_nestable:
                return create_sequence_nestable_type_from_ust_ctl_fields(current, end,
-                               session_attributes, next_ust_ctl_field, publish_field);
+                               session_attributes, next_ust_ctl_field, publish_field, lookup_root,
+                               current_field_location_elements);
        case lttng_ust_ctl_atype_struct:
        case lttng_ust_ctl_atype_struct_nestable:
                return create_structure_field_from_ust_ctl_fields(
                                current, end, session_attributes, next_ust_ctl_field);
        case lttng_ust_ctl_atype_variant:
        case lttng_ust_ctl_atype_variant_nestable:
-               return create_variant_field_from_ust_ctl_fields(
-                               current, end, session_attributes, next_ust_ctl_field);
+               return create_variant_field_from_ust_ctl_fields(current, end, session_attributes,
+                               next_ust_ctl_field, lookup_root, current_field_location_elements);
        default:
                LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
                                "Unknown {} value `{}` encountered while converting {} to {}",
@@ -619,7 +663,9 @@ void create_field_from_ust_ctl_fields(const lttng_ust_ctl_field *current,
                const lttng_ust_ctl_field *end,
                const session_attributes& session_attributes,
                const lttng_ust_ctl_field **next_ust_ctl_field,
-               publish_field_fn publish_field)
+               publish_field_fn publish_field,
+               lst::field_location::root lookup_root,
+               lst::field_location::elements& current_field_location_elements)
 {
        LTTNG_ASSERT(current < end);
 
@@ -630,7 +676,9 @@ void create_field_from_ust_ctl_fields(const lttng_ust_ctl_field *current,
 
        publish_field(lttng::make_unique<lst::field>(current->name,
                        create_type_from_ust_ctl_fields(current, end, session_attributes,
-                                       next_ust_ctl_field, publish_field)));
+                                       next_ust_ctl_field, publish_field,
+                                       lookup_root,
+                                       current_field_location_elements)));
 }
 
 /*
@@ -644,7 +692,8 @@ void create_field_from_ust_ctl_fields(const lttng_ust_ctl_field *current,
 std::vector<lst::field::cuptr> create_fields_from_ust_ctl_fields(
                const lsu::registry_session& session,
                const lttng_ust_ctl_field *current,
-               const lttng_ust_ctl_field *end)
+               const lttng_ust_ctl_field *end,
+               lst::field_location::root lookup_root)
 {
        std::vector<lst::field::cuptr> fields;
        const auto trace_native_byte_order = session.abi.byte_order;
@@ -653,6 +702,8 @@ std::vector<lst::field::cuptr> create_fields_from_ust_ctl_fields(
                                return session.get_enumeration(enum_name, enum_id);
                        },
                        trace_native_byte_order};
+       /* Location of field being created. */
+       lst::field_location::elements current_field_location_elements;
 
        while (current < end) {
                auto *next_field = current;
@@ -669,7 +720,9 @@ std::vector<lst::field::cuptr> create_fields_from_ust_ctl_fields(
                create_field_from_ust_ctl_fields(current, end, session_attributes, &next_field,
                                [&fields](lst::field::cuptr field) {
                                        fields.emplace_back(std::move(field));
-                               });
+                               },
+                               lookup_root,
+                               current_field_location_elements);
 
                current = next_field;
        }
@@ -681,7 +734,8 @@ std::vector<lst::field::cuptr> create_fields_from_ust_ctl_fields(
 std::vector<lst::field::cuptr> lsu::create_trace_fields_from_ust_ctl_fields(
                const lsu::registry_session& session,
                const lttng_ust_ctl_field *fields,
-               std::size_t field_count)
+               std::size_t field_count,
+               lst::field_location::root lookup_root)
 {
-       return create_fields_from_ust_ctl_fields(session, fields, fields + field_count);
+       return create_fields_from_ust_ctl_fields(session, fields, fields + field_count, lookup_root);
 }

diff --git a/src/bin/lttng-sessiond/ust-field-convert.hpp b/src/bin/lttng-sessiond/ust-field-convert.hpp
index 0faf65db1b87d42f9d7b24c99df9ffb15be8f6ed..e165cdf1d6e07047af40939c28aad2f41a6d9a34 100644 (file)
--- a/src/bin/lttng-sessiond/ust-field-convert.hpp
+++ b/src/bin/lttng-sessiond/ust-field-convert.hpp
@@ -22,7 +22,8 @@ namespace ust {
 std::vector<trace::field::cuptr> create_trace_fields_from_ust_ctl_fields(
                const lttng::sessiond::ust::registry_session& session,
                const lttng_ust_ctl_field *fields,
-               std::size_t field_count);
+               std::size_t field_count,
+               trace::field_location::root lookup_root);
 
 } /* namespace ust */
 } /* namespace sessiond */

diff --git a/src/bin/lttng-sessiond/ust-registry-channel.cpp b/src/bin/lttng-sessiond/ust-registry-channel.cpp
index ed8a60daf2509fd191ec273fc3b0be866df6a4f4..b039d3c2fd274c02624e86a873a0877086b100d5 100644 (file)
--- a/src/bin/lttng-sessiond/ust-registry-channel.cpp
+++ b/src/bin/lttng-sessiond/ust-registry-channel.cpp
@@ -131,8 +131,10 @@ lst::type::cuptr create_event_header(const lst::abi& trace_abi, lst::stream_clas
                lst::type::cuptr extended = lttng::make_unique<lst::structure_type>(0, std::move(extended_fields));
                variant_choices.emplace_back(lttng::make_unique<lst::field>("extended", std::move(extended)));
 
-               lst::type::cuptr variant = lttng::make_unique<lst::variant_type>(
-                               0, "id", std::move(variant_choices));
+               lst::type::cuptr variant = lttng::make_unique<lst::variant_type>(0,
+                               lst::field_location(lst::field_location::root::EVENT_RECORD_HEADER,
+                                               {"id"}),
+                               std::move(variant_choices));
 
                event_header_fields.emplace_back(lttng::make_unique<lst::field>("id", std::move(choice_enum)));
                event_header_fields.emplace_back(
@@ -187,8 +189,10 @@ lst::type::cuptr create_event_header(const lst::abi& trace_abi, lst::stream_clas
                lst::type::cuptr extended = lttng::make_unique<lst::structure_type>(0, std::move(extended_fields));
                variant_choices.emplace_back(lttng::make_unique<lst::field>("extended", std::move(extended)));
 
-               lst::type::cuptr variant = lttng::make_unique<lst::variant_type>(
-                               0, "id", std::move(variant_choices));
+               lst::type::cuptr variant = lttng::make_unique<lst::variant_type>(0,
+                               lst::field_location(lst::field_location::root::EVENT_RECORD_HEADER,
+                                               {"id"}),
+                               std::move(variant_choices));
 
                event_header_fields.emplace_back(lttng::make_unique<lst::field>("id", std::move(choice_enum)));
                event_header_fields.emplace_back(