2 * Copyright (C) 2022 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 * SPDX-License-Identifier: GPL-2.0-only
11 #include <common/format.hpp>
13 #include <vendor/optional.hpp>
18 #include <type_traits>
28 enum class byte_order {
33 class field_location {
39 EVENT_RECORD_COMMON_CONTEXT,
40 EVENT_RECORD_SPECIFIC_CONTEXT,
44 using elements = std::vector<std::string>;
46 field_location(root lookup_root, elements elements);
47 bool operator==(const field_location& other) const noexcept;
50 const elements elements_;
54 * Field, and the various field types, represents fields as exposed by the
55 * LTTng tracers. These classes do not attempt to describe the complete spectrum of the CTF
61 using cuptr = std::unique_ptr<const type>;
63 static byte_order reverse_byte_order(byte_order byte_order) noexcept;
65 bool operator==(const type& other) const noexcept;
66 bool operator!=(const type& other) const noexcept;
68 virtual void accept(type_visitor& visitor) const = 0;
70 const unsigned int alignment;
73 type(unsigned int alignment);
76 virtual bool _is_equal(const type& rhs) const noexcept = 0;
81 using uptr = std::unique_ptr<field>;
82 using cuptr = std::unique_ptr<const field>;
84 field(std::string name, type::cuptr type);
85 void accept(field_visitor& visitor) const;
86 bool operator==(const field& other) const noexcept;
88 const type& get_type() const;
89 type::cuptr move_type() noexcept;
91 const std::string name;
97 class integer_type : public type {
99 enum class signedness {
112 DEFAULT_CLOCK_TIMESTAMP,
113 /* Packet header field class specific roles. */
114 DATA_STREAM_CLASS_ID,
117 /* Packet context field class specific roles. */
118 DISCARDED_EVENT_RECORD_COUNTER_SNAPSHOT,
119 PACKET_CONTENT_LENGTH,
120 PACKET_END_DEFAULT_CLOCK_TIMESTAMP,
121 PACKET_SEQUENCE_NUMBER,
123 /* Event record field class roles. */
124 EVENT_RECORD_CLASS_ID,
127 using roles = std::vector<role>;
129 integer_type(unsigned int alignment,
130 byte_order byte_order,
132 signedness signedness,
136 virtual void accept(type_visitor& visitor) const override;
138 const enum byte_order byte_order;
139 const unsigned int size;
141 * signedness and base are suffixed with '_' to work-around a bug in older
142 * GCCs (before 6) that do not recognize hidden/shadowed enumeration as valid
143 * nested-name-specifiers.
145 const signedness signedness_;
150 virtual bool _is_equal(const type& other) const noexcept override;
153 class floating_point_type : public type {
155 floating_point_type(unsigned int alignment,
156 byte_order byte_order,
157 unsigned int exponent_digits,
158 unsigned int mantissa_digits);
160 virtual void accept(type_visitor& visitor) const override final;
162 const enum byte_order byte_order;
163 const unsigned int exponent_digits;
164 const unsigned int mantissa_digits;
167 virtual bool _is_equal(const type& other) const noexcept override final;
170 class enumeration_type : public integer_type {
172 enumeration_type(unsigned int alignment,
173 enum byte_order byte_order,
175 enum signedness signedness,
177 integer_type::roles roles = {});
179 virtual void accept(type_visitor& visitor) const = 0;
183 template <class MappingIntegerType>
184 class enumeration_mapping_range {
186 using range_integer_t = MappingIntegerType;
188 enumeration_mapping_range(MappingIntegerType in_begin, MappingIntegerType in_end) :
189 begin{in_begin}, end{in_end}
193 const range_integer_t begin, end;
196 template <class MappingIntegerType>
197 bool operator==(const enumeration_mapping_range<MappingIntegerType>& lhs,
198 const enumeration_mapping_range<MappingIntegerType>& rhs) noexcept
200 return lhs.begin == rhs.begin && lhs.end == rhs.end;
203 template <class MappingIntegerType>
204 class enumeration_mapping {
206 using range_t = enumeration_mapping_range<MappingIntegerType>;
208 enumeration_mapping(const enumeration_mapping<MappingIntegerType>& other) = default;
209 enumeration_mapping(const enumeration_mapping<MappingIntegerType>&& other) :
210 name{std::move(other.name)}, range{other.range}
214 enumeration_mapping(std::string in_name, MappingIntegerType value) : name{std::move(in_name)}, range{value, value}
218 enumeration_mapping(std::string in_name, range_t in_range) : name{std::move(in_name)}, range{in_range}
222 const std::string name;
224 * Only one range per mapping is supported for the moment as
225 * the tracers (and CTF 1.8) can't express multiple ranges per
226 * mapping, which is allowed by CTF 2.
231 template <class MappingIntegerType>
232 bool operator==(const enumeration_mapping<MappingIntegerType>& lhs,
233 const enumeration_mapping<MappingIntegerType>& rhs) noexcept
235 return lhs.name == rhs.name && lhs.range == rhs.range;
237 } /* namespace details */
239 template <class MappingIntegerType>
240 class typed_enumeration_type : public enumeration_type {
242 using mapping = details::enumeration_mapping<MappingIntegerType>;
243 using mappings = std::vector<mapping>;
245 static_assert(std::is_integral<MappingIntegerType>::value &&
246 sizeof(MappingIntegerType) == 8,
247 "MappingIntegerType must be either int64_t or uint64_t");
249 typed_enumeration_type(unsigned int in_alignment,
250 enum byte_order in_byte_order,
251 unsigned int in_size,
253 const std::shared_ptr<const mappings>& in_mappings,
254 integer_type::roles in_roles = {}) :
255 enumeration_type(in_alignment,
258 std::is_signed<MappingIntegerType>::value ?
259 integer_type::signedness::SIGNED :
260 integer_type::signedness::UNSIGNED,
262 std::move(in_roles)),
263 mappings_{std::move(in_mappings)}
267 virtual void accept(type_visitor& visitor) const override final;
269 const std::shared_ptr<const mappings> mappings_;
272 virtual bool _is_equal(const type& base_other) const noexcept override final
274 const auto& other = static_cast<const typed_enumeration_type<MappingIntegerType>&>(
277 return integer_type::_is_equal(base_other) && *this->mappings_ == *other.mappings_;
281 /* Aliases for all allowed enumeration mapping types. */
282 using signed_enumeration_type = typed_enumeration_type<int64_t>;
283 using unsigned_enumeration_type = typed_enumeration_type<uint64_t>;
285 class array_type : public type {
287 array_type(unsigned int alignment, type::cuptr element_type);
289 const type::cuptr element_type;
292 virtual bool _is_equal(const type& base_other) const noexcept override;
295 class static_length_array_type : public array_type {
297 static_length_array_type(unsigned int alignment,
298 type::cuptr element_type,
301 virtual void accept(type_visitor& visitor) const override final;
303 const uint64_t length;
306 virtual bool _is_equal(const type& base_other) const noexcept override final;
309 class dynamic_length_array_type : public array_type {
311 dynamic_length_array_type(unsigned int alignment,
312 type::cuptr element_type,
313 field_location length_field_location);
315 virtual void accept(type_visitor& visitor) const override final;
317 const field_location length_field_location;
320 virtual bool _is_equal(const type& base_other) const noexcept override final;
323 class static_length_blob_type : public type {
326 /* Packet header field class specific role. */
327 METADATA_STREAM_UUID,
330 using roles = std::vector<role>;
332 static_length_blob_type(unsigned int alignment, uint64_t in_length_bytes, roles roles = {});
334 virtual void accept(type_visitor& visitor) const override final;
336 const uint64_t length_bytes;
340 virtual bool _is_equal(const type& base_other) const noexcept override final;
343 class dynamic_length_blob_type : public type {
345 dynamic_length_blob_type(unsigned int alignment, field_location length_field_location);
347 virtual void accept(type_visitor& visitor) const override final;
349 const field_location length_field_location;
352 virtual bool _is_equal(const type& base_other) const noexcept override final;
355 class string_type : public type {
357 enum class encoding {
362 string_type(unsigned int alignment, enum encoding encoding);
365 * encoding is suffixed with '_' to work-around a bug in older
366 * GCCs (before 6) that do not recognize hidden/shadowed enumeration as valid
367 * nested-name-specifiers.
369 const encoding encoding_;
372 virtual bool _is_equal(const type& base_other) const noexcept override;
375 class static_length_string_type : public string_type {
377 static_length_string_type(
378 unsigned int alignment, enum encoding in_encoding, uint64_t length);
379 virtual void accept(type_visitor& visitor) const override final;
381 const uint64_t length;
384 virtual bool _is_equal(const type& base_other) const noexcept override final;
387 class dynamic_length_string_type : public string_type {
389 dynamic_length_string_type(unsigned int alignment,
390 enum encoding in_encoding,
391 field_location length_field_location);
392 virtual void accept(type_visitor& visitor) const override final;
394 const field_location length_field_location;
397 virtual bool _is_equal(const type& base_other) const noexcept override final;
400 class null_terminated_string_type : public string_type {
402 null_terminated_string_type(unsigned int alignment, enum encoding in_encoding);
403 virtual void accept(type_visitor& visitor) const override final;
406 class structure_type : public type {
408 using fields = std::vector<field::cuptr>;
410 structure_type(unsigned int alignment, fields in_fields);
412 virtual void accept(type_visitor& visitor) const override final;
414 const fields fields_;
417 virtual bool _is_equal(const type& base_other) const noexcept override final;
420 template <class MappingIntegerType>
421 class variant_type : public type {
422 static_assert(std::is_same<MappingIntegerType,
423 unsigned_enumeration_type::mapping::range_t::
424 range_integer_t>::value ||
425 std::is_same<MappingIntegerType,
426 signed_enumeration_type::mapping::range_t::
427 range_integer_t>::value,
428 "Variant mapping integer type must be one of those allowed by typed_enumeration_type");
431 using choice = std::pair<const details::enumeration_mapping<MappingIntegerType>, type::cuptr>;
432 using choices = std::vector<choice>;
434 variant_type(unsigned int in_alignment,
435 field_location in_selector_field_location,
436 choices in_choices) :
438 selector_field_location{std::move(in_selector_field_location)},
439 choices_{std::move(in_choices)}
443 virtual void accept(type_visitor& visitor) const override final;
445 const field_location selector_field_location;
446 const choices choices_;
450 static bool _choices_are_equal(const choices& a, const choices& b)
452 if (a.size() != b.size()) {
458 return std::equal(a.cbegin(), a.cend(), b.cbegin(),
459 [](const choice& choice_a, const choice& choice_b) {
460 return choice_a.first == choice_b.first &&
461 *choice_a.second == *choice_b.second;
465 virtual bool _is_equal(const type& base_other) const noexcept override final
467 const auto& other = static_cast<decltype(*this)&>(base_other);
469 return selector_field_location == other.selector_field_location &&
470 _choices_are_equal(choices_, other.choices_);
474 class field_visitor {
476 virtual ~field_visitor() = default;
477 virtual void visit(const field& field) = 0;
480 field_visitor() = default;
485 virtual ~type_visitor() = default;
486 virtual void visit(const integer_type& type) = 0;
487 virtual void visit(const floating_point_type& type) = 0;
488 virtual void visit(const signed_enumeration_type& type) = 0;
489 virtual void visit(const unsigned_enumeration_type& type) = 0;
490 virtual void visit(const static_length_array_type& type) = 0;
491 virtual void visit(const dynamic_length_array_type& type) = 0;
492 virtual void visit(const static_length_blob_type& type) = 0;
493 virtual void visit(const dynamic_length_blob_type& type) = 0;
494 virtual void visit(const null_terminated_string_type& type) = 0;
495 virtual void visit(const static_length_string_type& type) = 0;
496 virtual void visit(const dynamic_length_string_type& type) = 0;
497 virtual void visit(const structure_type& type) = 0;
498 virtual void visit(const variant_type<signed_enumeration_type::mapping::range_t::range_integer_t>& type) = 0;
499 virtual void visit(const variant_type<unsigned_enumeration_type::mapping::range_t::range_integer_t>& type) = 0;
502 type_visitor() = default;
505 } /* namespace trace */
506 } /* namespace sessiond */
507 } /* namespace lttng */
510 * Due to a bug in g++ < 7.1, this specialization must be enclosed in the fmt namespace,
511 * see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480.
515 struct formatter<lttng::sessiond::trace::field_location> : formatter<std::string> {
516 template <typename FormatCtx>
517 typename FormatCtx::iterator format(
518 const lttng::sessiond::trace::field_location& location, FormatCtx& ctx)
520 std::string location_str{"["};
522 switch (location.root_) {
523 case lttng::sessiond::trace::field_location::root::PACKET_HEADER:
524 location_str += "\"packet-header\"";
526 case lttng::sessiond::trace::field_location::root::PACKET_CONTEXT:
527 location_str += "\"packet-context\"";
529 case lttng::sessiond::trace::field_location::root::EVENT_RECORD_HEADER:
530 location_str += "\"event-record-header\"";
532 case lttng::sessiond::trace::field_location::root::EVENT_RECORD_COMMON_CONTEXT:
533 location_str += "\"event-record-common-context\"";
535 case lttng::sessiond::trace::field_location::root::EVENT_RECORD_SPECIFIC_CONTEXT:
536 location_str += "\"event-record-specific-context\"";
538 case lttng::sessiond::trace::field_location::root::EVENT_RECORD_PAYLOAD:
539 location_str += "\"event-record-payload\"";
543 for (const auto &name : location.elements_) {
544 location_str += ", \"" + name + "\"";
548 return format_to(ctx.out(), location_str);
551 } /* namespace fmt */
553 #endif /* LTTNG_FIELD_H */