2 * Copyright (C) 2022 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 * SPDX-License-Identifier: GPL-2.0-only
8 #include "ust-field-convert.hpp"
10 #include <common/exception.hpp>
11 #include <common/make-unique.hpp>
13 #include <unordered_map>
15 namespace lst
= lttng::sessiond::trace
;
16 namespace lsu
= lttng::sessiond::ust
;
20 * Type enclosing the session information that may be required during the decoding
21 * of the lttng_ust_ctl_field array provided by applications on registration of
24 class session_attributes
{
26 using registry_enum_getter_fn
=
27 std::function
<lsu::registry_enum::const_rcu_protected_reference(
28 const char *name
, uint64_t id
)>;
30 session_attributes(registry_enum_getter_fn reg_enum_getter
,
31 lst::byte_order native_trace_byte_order
) :
32 get_registry_enum
{reg_enum_getter
}, _native_trace_byte_order
{native_trace_byte_order
}
36 const registry_enum_getter_fn get_registry_enum
;
37 const lst::byte_order _native_trace_byte_order
;
40 /* Used to publish fields on which a field being decoded has an implicit dependency. */
41 using publish_field_fn
= std::function
<void(lst::field::cuptr
)>;
43 /* Look-up field from a field location. */
44 using lookup_field_fn
= std::function
<const lst::field
&(const lst::field_location
&)>;
46 lst::type::cuptr
create_type_from_ust_ctl_fields(const lttng_ust_ctl_field
*current
,
47 const lttng_ust_ctl_field
*end
,
48 const session_attributes
& session_attributes
,
49 const lttng_ust_ctl_field
**next_ust_ctl_field
,
50 publish_field_fn publish_field
,
51 lookup_field_fn lookup_field
,
52 lst::field_location::root lookup_root
,
53 lst::field_location::elements
& current_field_location_elements
);
55 void create_field_from_ust_ctl_fields(const lttng_ust_ctl_field
*current
,
56 const lttng_ust_ctl_field
*end
,
57 const session_attributes
& session_attributes
,
58 const lttng_ust_ctl_field
**next_ust_ctl_field
,
59 publish_field_fn publish_field
,
60 lookup_field_fn lookup_field
,
61 lst::field_location::root lookup_root
,
62 lst::field_location::elements
& current_field_location_elements
);
64 template <class UstCtlEncodingType
>
65 enum lst::null_terminated_string_type::encoding
ust_ctl_encoding_to_string_field_encoding(UstCtlEncodingType encoding
)
67 static const std::unordered_map
<UstCtlEncodingType
, enum lst::null_terminated_string_type::encoding
>
68 encoding_conversion_map
= {
69 {(UstCtlEncodingType
) lttng_ust_ctl_encode_ASCII
,
70 lst::null_terminated_string_type::encoding::ASCII
},
71 {(UstCtlEncodingType
) lttng_ust_ctl_encode_UTF8
,
72 lst::null_terminated_string_type::encoding::UTF8
},
75 const auto encoding_it
= encoding_conversion_map
.find(encoding
);
76 if (encoding_it
== encoding_conversion_map
.end()) {
77 LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
78 "Unknown lttng_ust_ctl_string_encodings value `{}` encountered when decoding integer field",
82 return encoding_it
->second
;
85 template <class UstCtlBaseType
>
86 enum lst::integer_type::base
ust_ctl_base_to_integer_field_base(UstCtlBaseType base
)
88 static const std::unordered_map
<UstCtlBaseType
, enum lst::integer_type::base
>
89 base_conversion_map
= {{2, lst::integer_type::base::BINARY
},
90 {8, lst::integer_type::base::OCTAL
},
91 {10, lst::integer_type::base::DECIMAL
},
92 {16, lst::integer_type::base::HEXADECIMAL
}};
94 const auto base_it
= base_conversion_map
.find(base
);
95 if (base_it
== base_conversion_map
.end()) {
96 LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
97 "Unknown integer base value `{}` encountered when decoding integer field",
101 return base_it
->second
;
104 lst::type::cuptr
create_integer_type_from_ust_ctl_fields(const lttng_ust_ctl_field
*current
,
105 const lttng_ust_ctl_field
*end
,
106 const session_attributes
& session_attributes
,
107 const lttng_ust_ctl_field
**next_ust_ctl_field
)
109 if (current
>= end
) {
110 LTTNG_THROW_PROTOCOL_ERROR(
111 fmt::format("End of {} array reached unexpectedly during decoding",
115 const auto base
= ust_ctl_base_to_integer_field_base(current
->type
.u
.integer
.base
);
116 const auto signedness
= current
->type
.u
.integer
.signedness
?
117 lst::integer_type::signedness::SIGNED
:
118 lst::integer_type::signedness::UNSIGNED
;
119 const auto byte_order
= current
->type
.u
.integer
.reverse_byte_order
?
120 lst::type::reverse_byte_order(session_attributes
._native_trace_byte_order
) :
121 session_attributes
._native_trace_byte_order
;
123 *next_ust_ctl_field
= current
+ 1;
125 return lttng::make_unique
<const lst::integer_type
>(current
->type
.u
.integer
.alignment
,
126 byte_order
, current
->type
.u
.integer
.size
, signedness
, base
);
129 lst::type::cuptr
create_floating_point_type_from_ust_ctl_fields(const lttng_ust_ctl_field
*current
,
130 const lttng_ust_ctl_field
*end
,
131 const session_attributes
& session_attributes
,
132 const lttng_ust_ctl_field
**next_ust_ctl_field
)
134 if (current
>= end
) {
135 LTTNG_THROW_PROTOCOL_ERROR(
136 fmt::format("End of {} array reached unexpectedly during decoding",
140 *next_ust_ctl_field
= current
+ 1;
142 const auto byte_order
= current
->type
.u
._float
.reverse_byte_order
?
143 lst::type::reverse_byte_order(session_attributes
._native_trace_byte_order
) :
144 session_attributes
._native_trace_byte_order
;
147 return lttng::make_unique
<const lst::floating_point_type
>(
148 current
->type
.u
._float
.alignment
, byte_order
,
149 current
->type
.u
._float
.exp_dig
, current
->type
.u
._float
.mant_dig
);
150 } catch (lttng::invalid_argument_error
& ex
) {
151 LTTNG_THROW_PROTOCOL_ERROR(fmt::format("Invalid floating point attribute in {}: {}",
152 typeid(*current
), ex
.what()));
156 lst::type::cuptr
create_enumeration_type_from_ust_ctl_fields(const lttng_ust_ctl_field
*current
,
157 const lttng_ust_ctl_field
*end
,
158 const session_attributes
& session_attributes
,
159 const lttng_ust_ctl_field
**next_ust_ctl_field
)
161 if (current
>= end
) {
162 LTTNG_THROW_PROTOCOL_ERROR(
163 fmt::format("End of {} array reached unexpectedly during decoding",
167 uint64_t enumeration_id
;
168 const auto& enum_uctl_field
= *current
;
169 const char *enumeration_name
;
170 const auto *enum_container_uctl_type
=
171 ¤t
->type
.u
.legacy
.basic
.enumeration
.container_type
;
173 if (enum_uctl_field
.type
.atype
== lttng_ust_ctl_atype_enum_nestable
) {
174 /* Nestable enumeration fields are followed by their container type. */
176 if (current
>= end
) {
177 LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
178 "Array of {} is too short to contain nestable enumeration's container",
182 if (current
->type
.atype
!= lttng_ust_ctl_atype_integer
) {
183 LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
184 "Invalid type of nestable enum container: type id = {}",
185 current
->type
.atype
));
188 enum_container_uctl_type
= ¤t
->type
.u
.integer
;
189 enumeration_id
= enum_uctl_field
.type
.u
.enum_nestable
.id
;
190 enumeration_name
= enum_uctl_field
.type
.u
.enum_nestable
.name
;
192 enumeration_id
= enum_uctl_field
.type
.u
.legacy
.basic
.enumeration
.id
;
193 enumeration_name
= enum_uctl_field
.type
.u
.legacy
.basic
.enumeration
.name
;
196 *next_ust_ctl_field
= current
+ 1;
198 const auto base
= ust_ctl_base_to_integer_field_base(enum_container_uctl_type
->base
);
199 const auto byte_order
= enum_container_uctl_type
->reverse_byte_order
?
200 lst::integer_type::reverse_byte_order(
201 session_attributes
._native_trace_byte_order
) :
202 session_attributes
._native_trace_byte_order
;
203 const auto signedness
= enum_container_uctl_type
->signedness
?
204 lst::integer_type::signedness::SIGNED
:
205 lst::integer_type::signedness::UNSIGNED
;
207 if (signedness
== lst::integer_type::signedness::SIGNED
) {
208 const auto& enum_registry
= static_cast<const lsu::registry_signed_enum
&>(
209 *session_attributes
.get_registry_enum(
210 enumeration_name
, enumeration_id
));
212 return lttng::make_unique
<const lst::signed_enumeration_type
>(
213 enum_container_uctl_type
->alignment
, byte_order
,
214 enum_container_uctl_type
->size
, base
,
215 enum_registry
._mappings
);
217 const auto& enum_registry
= static_cast<const lsu::registry_unsigned_enum
&>(
218 *session_attributes
.get_registry_enum(
219 enumeration_name
, enumeration_id
));
221 return lttng::make_unique
<const lst::unsigned_enumeration_type
>(
222 enum_container_uctl_type
->alignment
, byte_order
,
223 enum_container_uctl_type
->size
, base
,
224 enum_registry
._mappings
);
228 lst::type::cuptr
create_string_type_from_ust_ctl_fields(const lttng_ust_ctl_field
*current
,
229 const lttng_ust_ctl_field
*end
,
230 const session_attributes
& session_attributes
__attribute__((unused
)),
231 const lttng_ust_ctl_field
**next_ust_ctl_field
)
233 if (current
>= end
) {
234 LTTNG_THROW_PROTOCOL_ERROR(
235 fmt::format("End of {} array reached unexpectedly during decoding",
239 const auto& string_uctl_field
= *current
;
240 *next_ust_ctl_field
= current
+ 1;
242 const auto encoding
= ust_ctl_encoding_to_string_field_encoding(
243 string_uctl_field
.type
.u
.string
.encoding
);
245 return lttng::make_unique
<const lst::null_terminated_string_type
>(1, encoding
);
248 lst::type::cuptr
create_integer_type_from_ust_ctl_basic_type(
249 const lttng_ust_ctl_basic_type
& type
, const session_attributes
& session_attributes
)
251 /* Checked by caller. */
252 LTTNG_ASSERT(type
.atype
== lttng_ust_ctl_atype_integer
);
254 const auto byte_order
= type
.u
.basic
.integer
.reverse_byte_order
?
255 lst::integer_type::reverse_byte_order(
256 session_attributes
._native_trace_byte_order
) :
257 session_attributes
._native_trace_byte_order
;
258 const auto signedness
= type
.u
.basic
.integer
.signedness
?
259 lst::integer_type::signedness::SIGNED
:
260 lst::integer_type::signedness::UNSIGNED
;
261 const auto base
= ust_ctl_base_to_integer_field_base(type
.u
.basic
.integer
.base
);
262 const auto size
= type
.u
.basic
.integer
.size
;
263 const auto alignment
= type
.u
.basic
.integer
.alignment
;
265 return lttng::make_unique
<const lst::integer_type
>(
266 alignment
, byte_order
, size
, signedness
, base
);
269 lst::type::cuptr
create_array_type_from_ust_ctl_fields(const lttng_ust_ctl_field
*current
,
270 const lttng_ust_ctl_field
*end
,
271 const session_attributes
& session_attributes
,
272 const lttng_ust_ctl_field
**next_ust_ctl_field
)
274 if (current
>= end
) {
275 LTTNG_THROW_PROTOCOL_ERROR(
276 fmt::format("End of {} array reached unexpectedly during decoding",
280 const auto& array_uctl_field
= *current
;
281 uint32_t array_alignment
, array_length
;
282 lst::type::cuptr element_type
;
283 nonstd::optional
<enum lst::string_type::encoding
> element_encoding
;
285 array_length
= array_uctl_field
.type
.u
.legacy
.array
.length
;
288 const auto& element_uctl_type
= array_uctl_field
.type
.u
.legacy
.array
.elem_type
;
289 if (element_uctl_type
.atype
!= lttng_ust_ctl_atype_integer
) {
290 LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
291 "Unexpected legacy array element type: atype = {}, expected atype = lttng_ust_ctl_atype_integer ({})",
292 element_uctl_type
.atype
, lttng_ust_ctl_atype_integer
));
295 element_type
= create_integer_type_from_ust_ctl_basic_type(
296 element_uctl_type
, session_attributes
);
297 if (element_uctl_type
.atype
== lttng_ust_ctl_atype_integer
&&
298 element_uctl_type
.u
.basic
.integer
.encoding
!= lttng_ust_ctl_encode_none
) {
299 /* Element represents a text character. */
300 element_encoding
= ust_ctl_encoding_to_string_field_encoding(
301 element_uctl_type
.u
.basic
.integer
.encoding
);
304 *next_ust_ctl_field
= current
+ 1;
306 if (element_encoding
) {
307 const auto integer_element_size
=
308 static_cast<const lst::integer_type
&>(*element_type
).size
;
310 if (integer_element_size
!= 8) {
311 LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
312 "Unexpected legacy array element type: integer has encoding but size is not 8: size = {}",
313 integer_element_size
));
316 /* Array is a static-length string. */
317 return lttng::make_unique
<lst::static_length_string_type
>(
318 array_alignment
, *element_encoding
, array_length
);
321 return lttng::make_unique
<lst::static_length_array_type
>(
322 array_alignment
, std::move(element_type
), array_length
);
325 lst::type::cuptr
create_array_nestable_type_from_ust_ctl_fields(const lttng_ust_ctl_field
*current
,
326 const lttng_ust_ctl_field
*end
,
327 const session_attributes
& session_attributes
,
328 const lttng_ust_ctl_field
**next_ust_ctl_field
,
329 publish_field_fn publish_field
,
330 lookup_field_fn lookup_field
,
331 lst::field_location::root lookup_root
,
332 lst::field_location::elements
¤t_field_location_elements
)
334 if (current
>= end
) {
335 LTTNG_THROW_PROTOCOL_ERROR(
336 fmt::format("End of {} array reached unexpectedly during decoding",
340 const auto& array_uctl_field
= *current
;
341 uint32_t array_alignment
, array_length
;
342 lst::type::cuptr element_type
;
343 nonstd::optional
<enum lst::string_type::encoding
> element_encoding
;
345 array_length
= array_uctl_field
.type
.u
.array_nestable
.length
;
346 array_alignment
= array_uctl_field
.type
.u
.array_nestable
.alignment
;
348 /* Nestable array fields are followed by their element type. */
349 const auto& element_uctl_field
= *(current
+ 1);
351 /* next_ust_ctl_field is updated as needed. */
352 element_type
= create_type_from_ust_ctl_fields(&element_uctl_field
, end
, session_attributes
,
353 next_ust_ctl_field
, publish_field
, lookup_field
, lookup_root
,
354 current_field_location_elements
);
355 if (element_uctl_field
.type
.atype
== lttng_ust_ctl_atype_integer
&&
356 element_uctl_field
.type
.u
.integer
.encoding
!= lttng_ust_ctl_encode_none
) {
357 /* Element represents a text character. */
358 element_encoding
= ust_ctl_encoding_to_string_field_encoding(
359 element_uctl_field
.type
.u
.integer
.encoding
);
362 if (element_encoding
) {
363 const auto integer_element_size
=
364 static_cast<const lst::integer_type
&>(*element_type
).size
;
366 if (integer_element_size
!= 8) {
367 LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
368 "Unexpected array element type: integer has encoding but size is not 8: size = {}",
369 integer_element_size
));
372 /* Array is a static-length string. */
373 return lttng::make_unique
<lst::static_length_string_type
>(
374 array_alignment
, *element_encoding
, array_length
);
377 return lttng::make_unique
<lst::static_length_array_type
>(
378 array_alignment
, std::move(element_type
), array_length
);
382 * For legacy sequence types, LTTng-UST expresses both the sequence and sequence
383 * length as part of the same lttng_ust_ctl_field entry.
385 lst::type::cuptr
create_sequence_type_from_ust_ctl_fields(const lttng_ust_ctl_field
*current
,
386 const lttng_ust_ctl_field
*end
,
387 const session_attributes
& session_attributes
,
388 const lttng_ust_ctl_field
**next_ust_ctl_field
,
389 publish_field_fn publish_field
,
390 lst::field_location::root lookup_root
,
391 lst::field_location::elements
¤t_field_location_elements
)
393 if (current
>= end
) {
394 LTTNG_THROW_PROTOCOL_ERROR(
395 fmt::format("End of {} array reached unexpectedly during decoding",
399 const auto& sequence_uctl_field
= *current
;
400 const auto& element_uctl_type
= sequence_uctl_field
.type
.u
.legacy
.sequence
.elem_type
;
401 const auto& length_uctl_type
= sequence_uctl_field
.type
.u
.legacy
.sequence
.length_type
;
402 const auto sequence_alignment
= 0U;
404 if (element_uctl_type
.atype
!= lttng_ust_ctl_atype_integer
) {
405 LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
406 "Unexpected legacy sequence element type: atype = {}, expected atype = lttng_ust_ctl_atype_integer ({})",
407 element_uctl_type
.atype
, lttng_ust_ctl_atype_integer
));
410 if (length_uctl_type
.atype
!= lttng_ust_ctl_atype_integer
) {
411 LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
412 "Unexpected legacy sequence length field type: atype = {}, expected atype = lttng_ust_ctl_atype_integer ({})",
413 length_uctl_type
.atype
, lttng_ust_ctl_atype_integer
));
416 nonstd::optional
<enum lst::string_type::encoding
> element_encoding
;
417 if (element_uctl_type
.atype
== lttng_ust_ctl_atype_integer
&&
418 element_uctl_type
.u
.basic
.integer
.encoding
!= lttng_ust_ctl_encode_none
) {
419 /* Element represents a text character. */
420 element_encoding
= ust_ctl_encoding_to_string_field_encoding(
421 element_uctl_type
.u
.basic
.integer
.encoding
);
424 const auto length_field_name
= fmt::format("_{}_length", sequence_uctl_field
.name
);
425 auto element_type
= create_integer_type_from_ust_ctl_basic_type(
426 element_uctl_type
, session_attributes
);
427 auto length_type
= create_integer_type_from_ust_ctl_basic_type(
428 length_uctl_type
, session_attributes
);
430 lst::field_location::elements length_field_location_elements
=
431 current_field_location_elements
;
432 length_field_location_elements
.emplace_back(length_field_name
);
434 const lst::field_location length_field_location
{
435 lookup_root
, std::move(length_field_location_elements
)};
437 /* Publish an implicit length field _before_ the sequence field. */
438 publish_field(lttng::make_unique
<lst::field
>(std::move(length_field_name
), std::move(length_type
)));
440 *next_ust_ctl_field
= current
+ 1;
442 if (element_encoding
) {
443 const auto integer_element_size
=
444 static_cast<const lst::integer_type
&>(*element_type
).size
;
446 if (integer_element_size
!= 8) {
447 LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
448 "Unexpected legacy array element type: integer has encoding but size is not 8: size = {}",
449 integer_element_size
));
452 /* Sequence is a dynamic-length string. */
453 return lttng::make_unique
<lst::dynamic_length_string_type
>(sequence_alignment
,
454 *element_encoding
, std::move(length_field_location
));
457 return lttng::make_unique
<lst::dynamic_length_array_type
>(sequence_alignment
,
458 std::move(element_type
), std::move(length_field_location
));
461 lst::type::cuptr
create_sequence_nestable_type_from_ust_ctl_fields(
462 const lttng_ust_ctl_field
*current
,
463 const lttng_ust_ctl_field
*end
,
464 const session_attributes
& session_attributes
,
465 const lttng_ust_ctl_field
**next_ust_ctl_field
,
466 publish_field_fn publish_field
,
467 lookup_field_fn lookup_field
,
468 lst::field_location::root lookup_root
,
469 lst::field_location::elements
¤t_field_location_elements
)
471 if (current
>= end
) {
472 LTTNG_THROW_PROTOCOL_ERROR(
473 fmt::format("End of {} array reached unexpectedly during decoding",
477 const auto& sequence_uctl_field
= *current
;
478 const auto sequence_alignment
= sequence_uctl_field
.type
.u
.sequence_nestable
.alignment
;
479 const auto *length_field_name
= sequence_uctl_field
.type
.u
.sequence_nestable
.length_name
;
481 /* Nestable sequence fields are followed by their element type. */
482 const auto& element_uctl_field
= *(current
+ 1);
484 nonstd::optional
<enum lst::string_type::encoding
> element_encoding
;
485 if (element_uctl_field
.type
.atype
== lttng_ust_ctl_atype_integer
&&
486 element_uctl_field
.type
.u
.integer
.encoding
!= lttng_ust_ctl_encode_none
) {
487 /* Element represents a text character. */
488 element_encoding
= ust_ctl_encoding_to_string_field_encoding(
489 element_uctl_field
.type
.u
.integer
.encoding
);
492 /* next_ust_ctl_field is updated as needed. */
493 auto element_type
= create_type_from_ust_ctl_fields(&element_uctl_field
, end
,
494 session_attributes
, next_ust_ctl_field
, publish_field
, lookup_field
,
495 lookup_root
, current_field_location_elements
);
497 if (lttng_strnlen(sequence_uctl_field
.type
.u
.sequence_nestable
.length_name
,
498 sizeof(sequence_uctl_field
.type
.u
.sequence_nestable
.length_name
)) ==
499 sizeof(sequence_uctl_field
.type
.u
.sequence_nestable
.length_name
)) {
500 LTTNG_THROW_PROTOCOL_ERROR("Sequence length field name is not null terminated");
503 lst::field_location::elements length_field_location_elements
=
504 current_field_location_elements
;
505 length_field_location_elements
.emplace_back(std::move(length_field_name
));
507 const lst::field_location length_field_location
{
508 lookup_root
, std::move(length_field_location_elements
)};
510 /* Validate existence of length field (throws if not found). */
511 const auto &length_field
= lookup_field(length_field_location
);
512 const auto *integer_selector_field
=
513 dynamic_cast<const lst::integer_type
*>(length_field
._type
.get());
514 if (!integer_selector_field
) {
515 LTTNG_THROW_PROTOCOL_ERROR("Invalid selector field type referenced from sequence: expected integer or enumeration");
518 if (element_encoding
) {
519 const auto integer_element_size
=
520 static_cast<const lst::integer_type
&>(*element_type
).size
;
522 if (integer_element_size
!= 8) {
523 LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
524 "Unexpected array element type: integer has encoding but size is not 8: size = {}",
525 integer_element_size
));
528 /* Sqeuence is a dynamic-length string. */
529 return lttng::make_unique
<lst::dynamic_length_string_type
>(sequence_alignment
,
530 *element_encoding
, std::move(length_field_location
));
533 return lttng::make_unique
<lst::dynamic_length_array_type
>(sequence_alignment
,
534 std::move(element_type
), std::move(length_field_location
));
537 lst::type::cuptr
create_structure_field_from_ust_ctl_fields(const lttng_ust_ctl_field
*current
,
538 const lttng_ust_ctl_field
*end
,
539 const session_attributes
& session_attributes
__attribute__((unused
)),
540 const lttng_ust_ctl_field
**next_ust_ctl_field
)
542 if (current
>= end
) {
543 LTTNG_THROW_PROTOCOL_ERROR(
544 fmt::format("End of {} array reached unexpectedly during decoding",
548 uint32_t field_count
;
550 const auto& structure_uctl_field
= *current
;
552 if (structure_uctl_field
.type
.atype
== lttng_ust_ctl_atype_struct
) {
553 field_count
= structure_uctl_field
.type
.u
.legacy
._struct
.nr_fields
;
556 field_count
= structure_uctl_field
.type
.u
.struct_nestable
.nr_fields
;
557 alignment
= structure_uctl_field
.type
.u
.struct_nestable
.alignment
;
560 if (field_count
!= 0) {
561 LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
562 "Only empty structures are supported by LTTng-UST: nr_fields = {}",
566 *next_ust_ctl_field
= current
+ 1;
567 return lttng::make_unique
<lst::structure_type
>(alignment
, lst::structure_type::fields());
570 lst::type::cuptr
create_variant_field_from_ust_ctl_fields(const lttng_ust_ctl_field
*current
,
571 const lttng_ust_ctl_field
*end
,
572 const session_attributes
& session_attributes
,
573 const lttng_ust_ctl_field
**next_ust_ctl_field
,
574 lookup_field_fn lookup_field
,
575 lst::field_location::root lookup_root
,
576 lst::field_location::elements
¤t_field_location_elements
)
578 if (current
>= end
) {
579 LTTNG_THROW_PROTOCOL_ERROR(
580 fmt::format("End of {} array reached unexpectedly during decoding",
584 const auto& variant_uctl_field
= *current
;
588 uint32_t choice_count
;
589 const char *tag_name
;
591 if (variant_uctl_field
.type
.atype
== lttng_ust_ctl_atype_variant
) {
593 choice_count
= variant_uctl_field
.type
.u
.legacy
.variant
.nr_choices
;
594 tag_name
= variant_uctl_field
.type
.u
.legacy
.variant
.tag_name
;
596 alignment
= variant_uctl_field
.type
.u
.variant_nestable
.alignment
;
597 choice_count
= variant_uctl_field
.type
.u
.variant_nestable
.nr_choices
;
598 tag_name
= variant_uctl_field
.type
.u
.variant_nestable
.tag_name
;
601 lst::field_location::elements selector_field_location_elements
=
602 current_field_location_elements
;
603 selector_field_location_elements
.emplace_back(tag_name
);
605 const lst::field_location selector_field_location
{
606 lookup_root
, std::move(selector_field_location_elements
)};
608 /* Validate existence of selector field (throws if not found). */
609 const auto &selector_field
= lookup_field(selector_field_location
);
610 const auto *integer_selector_field
= dynamic_cast<const lst::integer_type
*>(selector_field
._type
.get());
611 if (!integer_selector_field
) {
612 LTTNG_THROW_PROTOCOL_ERROR("Invalid selector field type referenced from variant: expected integer or enumeration");
615 /* Choices follow. next_ust_ctl_field is updated as needed. */
616 lst::variant_type::choices choices
;
617 for (unsigned int i
= 0; i
< choice_count
; i
++) {
618 create_field_from_ust_ctl_fields(
619 current
, end
, session_attributes
, next_ust_ctl_field
,
620 [&choices
](lst::field::cuptr field
) {
621 choices
.emplace_back(std::move(field
));
624 lookup_root
, current_field_location_elements
);
626 current
= *next_ust_ctl_field
;
629 return lttng::make_unique
<lst::variant_type
>(
630 alignment
, std::move(selector_field_location
), std::move(choices
));
633 lst::type::cuptr
create_type_from_ust_ctl_fields(const lttng_ust_ctl_field
*current
,
634 const lttng_ust_ctl_field
*end
,
635 const session_attributes
& session_attributes
,
636 const lttng_ust_ctl_field
**next_ust_ctl_field
,
637 publish_field_fn publish_field
,
638 lookup_field_fn lookup_field
,
639 lst::field_location::root lookup_root
,
640 lst::field_location::elements
¤t_field_location_elements
)
642 switch (current
->type
.atype
) {
643 case lttng_ust_ctl_atype_integer
:
644 return create_integer_type_from_ust_ctl_fields(
645 current
, end
, session_attributes
, next_ust_ctl_field
);
646 case lttng_ust_ctl_atype_enum
:
647 case lttng_ust_ctl_atype_enum_nestable
:
648 return create_enumeration_type_from_ust_ctl_fields(
649 current
, end
, session_attributes
, next_ust_ctl_field
);
650 case lttng_ust_ctl_atype_float
:
651 return create_floating_point_type_from_ust_ctl_fields(
652 current
, end
, session_attributes
, next_ust_ctl_field
);
653 case lttng_ust_ctl_atype_string
:
654 return create_string_type_from_ust_ctl_fields(
655 current
, end
, session_attributes
, next_ust_ctl_field
);
656 case lttng_ust_ctl_atype_array
:
657 return create_array_type_from_ust_ctl_fields(current
, end
, session_attributes
,
659 case lttng_ust_ctl_atype_array_nestable
:
660 return create_array_nestable_type_from_ust_ctl_fields(current
, end
,
661 session_attributes
, next_ust_ctl_field
, publish_field
, lookup_field
,
662 lookup_root
, current_field_location_elements
);
663 case lttng_ust_ctl_atype_sequence
:
664 return create_sequence_type_from_ust_ctl_fields(current
, end
, session_attributes
,
665 next_ust_ctl_field
, publish_field
, lookup_root
,
666 current_field_location_elements
);
667 case lttng_ust_ctl_atype_sequence_nestable
:
668 return create_sequence_nestable_type_from_ust_ctl_fields(current
, end
,
669 session_attributes
, next_ust_ctl_field
, publish_field
, lookup_field
,
670 lookup_root
, current_field_location_elements
);
671 case lttng_ust_ctl_atype_struct
:
672 case lttng_ust_ctl_atype_struct_nestable
:
673 return create_structure_field_from_ust_ctl_fields(
674 current
, end
, session_attributes
, next_ust_ctl_field
);
675 case lttng_ust_ctl_atype_variant
:
676 case lttng_ust_ctl_atype_variant_nestable
:
677 return create_variant_field_from_ust_ctl_fields(current
, end
, session_attributes
,
678 next_ust_ctl_field
, lookup_field
, lookup_root
,
679 current_field_location_elements
);
681 LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
682 "Unknown {} value `{}` encountered while converting {} to {}",
683 typeid(current
->type
.atype
), current
->type
.atype
, typeid(*current
),
684 typeid(lst::type::cuptr::element_type
)));
688 void create_field_from_ust_ctl_fields(const lttng_ust_ctl_field
*current
,
689 const lttng_ust_ctl_field
*end
,
690 const session_attributes
& session_attributes
,
691 const lttng_ust_ctl_field
**next_ust_ctl_field
,
692 publish_field_fn publish_field
,
693 lookup_field_fn lookup_field
,
694 lst::field_location::root lookup_root
,
695 lst::field_location::elements
& current_field_location_elements
)
697 LTTNG_ASSERT(current
< end
);
699 if (lttng_strnlen(current
->name
, sizeof(current
->name
)) == sizeof(current
->name
)) {
700 LTTNG_THROW_PROTOCOL_ERROR(
701 fmt::format("Name of {} is not null-terminated", typeid(*current
)));
704 publish_field(lttng::make_unique
<lst::field
>(current
->name
,
705 create_type_from_ust_ctl_fields(current
, end
, session_attributes
,
706 next_ust_ctl_field
, publish_field
, lookup_field
,
707 lookup_root
, current_field_location_elements
)));
711 * `lttng_ust_ctl_field`s can be nested, in which case creating a field will consume
712 * more than one lttng_ust_ctl_field. create_field_from_ust_ctl_fields returns the
713 * position of the next lttng_ust_ctl_field to consume or `end` when the last field
716 * Always returns a new field, throws on error.
718 std::vector
<lst::field::cuptr
> create_fields_from_ust_ctl_fields(
719 const lsu::registry_session
& session
,
720 const lttng_ust_ctl_field
*current
,
721 const lttng_ust_ctl_field
*end
,
722 lst::field_location::root lookup_root
)
724 std::vector
<lst::field::cuptr
> fields
;
725 const auto trace_native_byte_order
= session
.abi
.byte_order
;
726 const session_attributes session_attributes
{
727 [&session
](const char *enum_name
, uint64_t enum_id
) {
728 return session
.get_enumeration(enum_name
, enum_id
);
730 trace_native_byte_order
};
731 /* Location of field being created. */
732 lst::field_location::elements current_field_location_elements
;
734 while (current
< end
) {
735 auto *next_field
= current
;
738 * create_field_from_ust_ctl_fields will consume one field at a time.
739 * However, some fields expressed by LTTng-UST's protocol are expended
740 * to multiple event fields (legacy sequence fields implicitly define
741 * their length field).
743 * The lambda allows the factory functions to push as many fields as
744 * needed depending on the decoded field's type.
746 create_field_from_ust_ctl_fields(
747 current
, end
, session_attributes
, &next_field
,
748 [&fields
](lst::field::cuptr field
) {
749 /* Publishing a field simply adds it to the converted fields. */
750 fields
.emplace_back(std::move(field
));
752 [&fields
](const lst::field_location
& location
)
753 -> lookup_field_fn::result_type
{
754 if (location
.elements_
.size() != 1) {
755 LTTNG_THROW_ERROR(fmt::format(
756 "Unexpected field location received during field look-up: location = {}",
761 * In the context of fields received from LTTng-UST, field
762 * look-up is extremely naive as the protocol can only
763 * express empty structures. It is safe to assume that
764 * location has a depth of 1 and directly refers to a field
765 * in the 'fields' vector.
767 const auto field_it
= std::find_if(fields
.begin(),
769 [&location
](decltype(fields
)::value_type
&
771 return field
->name
==
772 location
.elements_
[0];
775 if (field_it
== fields
.end()) {
776 LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
777 "Failed to look-up field: location = {}",
783 lookup_root
, current_field_location_elements
);
785 current
= next_field
;
792 std::vector
<lst::field::cuptr
> lsu::create_trace_fields_from_ust_ctl_fields(
793 const lsu::registry_session
& session
,
794 const lttng_ust_ctl_field
*fields
,
795 std::size_t field_count
,
796 lst::field_location::root lookup_root
)
798 return create_fields_from_ust_ctl_fields(session
, fields
, fields
+ field_count
, lookup_root
);