4 * Babeltrace CTF IR - Event Fields
6 * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
8 * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
23 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
29 #define BT_LOG_TAG "FIELDS"
30 #include <babeltrace/lib-logging-internal.h>
32 #include <babeltrace/ctf-ir/fields-internal.h>
33 #include <babeltrace/ctf-ir/field-types-internal.h>
34 #include <babeltrace/ctf-writer/serialize-internal.h>
35 #include <babeltrace/object-internal.h>
36 #include <babeltrace/ref.h>
37 #include <babeltrace/compiler-internal.h>
38 #include <babeltrace/compat/fcntl-internal.h>
39 #include <babeltrace/align-internal.h>
43 struct bt_ctf_field
*bt_ctf_field_integer_create(struct bt_ctf_field_type
*);
45 struct bt_ctf_field
*bt_ctf_field_enumeration_create(
46 struct bt_ctf_field_type
*);
48 struct bt_ctf_field
*bt_ctf_field_floating_point_create(
49 struct bt_ctf_field_type
*);
51 struct bt_ctf_field
*bt_ctf_field_structure_create(
52 struct bt_ctf_field_type
*);
54 struct bt_ctf_field
*bt_ctf_field_variant_create(
55 struct bt_ctf_field_type
*);
57 struct bt_ctf_field
*bt_ctf_field_array_create(
58 struct bt_ctf_field_type
*);
60 struct bt_ctf_field
*bt_ctf_field_sequence_create(
61 struct bt_ctf_field_type
*);
63 struct bt_ctf_field
*bt_ctf_field_string_create(struct bt_ctf_field_type
*);
66 void bt_ctf_field_destroy(struct bt_object
*);
68 void bt_ctf_field_integer_destroy(struct bt_ctf_field
*);
70 void bt_ctf_field_enumeration_destroy(struct bt_ctf_field
*);
72 void bt_ctf_field_floating_point_destroy(struct bt_ctf_field
*);
74 void bt_ctf_field_structure_destroy(struct bt_ctf_field
*);
76 void bt_ctf_field_variant_destroy(struct bt_ctf_field
*);
78 void bt_ctf_field_array_destroy(struct bt_ctf_field
*);
80 void bt_ctf_field_sequence_destroy(struct bt_ctf_field
*);
82 void bt_ctf_field_string_destroy(struct bt_ctf_field
*);
85 int bt_ctf_field_generic_validate(struct bt_ctf_field
*);
87 int bt_ctf_field_structure_validate(struct bt_ctf_field
*);
89 int bt_ctf_field_variant_validate(struct bt_ctf_field
*);
91 int bt_ctf_field_enumeration_validate(struct bt_ctf_field
*);
93 int bt_ctf_field_array_validate(struct bt_ctf_field
*);
95 int bt_ctf_field_sequence_validate(struct bt_ctf_field
*);
98 int bt_ctf_field_generic_reset(struct bt_ctf_field
*);
100 int bt_ctf_field_structure_reset(struct bt_ctf_field
*);
102 int bt_ctf_field_variant_reset(struct bt_ctf_field
*);
104 int bt_ctf_field_enumeration_reset(struct bt_ctf_field
*);
106 int bt_ctf_field_array_reset(struct bt_ctf_field
*);
108 int bt_ctf_field_sequence_reset(struct bt_ctf_field
*);
110 int bt_ctf_field_string_reset(struct bt_ctf_field
*);
113 int bt_ctf_field_integer_serialize(struct bt_ctf_field
*,
114 struct bt_ctf_stream_pos
*, enum bt_ctf_byte_order
);
116 int bt_ctf_field_enumeration_serialize(struct bt_ctf_field
*,
117 struct bt_ctf_stream_pos
*, enum bt_ctf_byte_order
);
119 int bt_ctf_field_floating_point_serialize(struct bt_ctf_field
*,
120 struct bt_ctf_stream_pos
*, enum bt_ctf_byte_order
);
122 int bt_ctf_field_structure_serialize(struct bt_ctf_field
*,
123 struct bt_ctf_stream_pos
*, enum bt_ctf_byte_order
);
125 int bt_ctf_field_variant_serialize(struct bt_ctf_field
*,
126 struct bt_ctf_stream_pos
*, enum bt_ctf_byte_order
);
128 int bt_ctf_field_array_serialize(struct bt_ctf_field
*,
129 struct bt_ctf_stream_pos
*, enum bt_ctf_byte_order
);
131 int bt_ctf_field_sequence_serialize(struct bt_ctf_field
*,
132 struct bt_ctf_stream_pos
*, enum bt_ctf_byte_order
);
134 int bt_ctf_field_string_serialize(struct bt_ctf_field
*,
135 struct bt_ctf_stream_pos
*, enum bt_ctf_byte_order
);
138 int bt_ctf_field_integer_copy(struct bt_ctf_field
*, struct bt_ctf_field
*);
140 int bt_ctf_field_enumeration_copy(struct bt_ctf_field
*, struct bt_ctf_field
*);
142 int bt_ctf_field_floating_point_copy(struct bt_ctf_field
*,
143 struct bt_ctf_field
*);
145 int bt_ctf_field_structure_copy(struct bt_ctf_field
*, struct bt_ctf_field
*);
147 int bt_ctf_field_variant_copy(struct bt_ctf_field
*, struct bt_ctf_field
*);
149 int bt_ctf_field_array_copy(struct bt_ctf_field
*, struct bt_ctf_field
*);
151 int bt_ctf_field_sequence_copy(struct bt_ctf_field
*, struct bt_ctf_field
*);
153 int bt_ctf_field_string_copy(struct bt_ctf_field
*, struct bt_ctf_field
*);
156 void generic_field_freeze(struct bt_ctf_field
*);
158 void bt_ctf_field_enumeration_freeze(struct bt_ctf_field
*);
160 void bt_ctf_field_structure_freeze(struct bt_ctf_field
*);
162 void bt_ctf_field_variant_freeze(struct bt_ctf_field
*);
164 void bt_ctf_field_array_freeze(struct bt_ctf_field
*);
166 void bt_ctf_field_sequence_freeze(struct bt_ctf_field
*);
169 bt_bool
bt_ctf_field_generic_is_set(struct bt_ctf_field
*);
171 bt_bool
bt_ctf_field_structure_is_set(struct bt_ctf_field
*);
173 bt_bool
bt_ctf_field_variant_is_set(struct bt_ctf_field
*);
175 bt_bool
bt_ctf_field_enumeration_is_set(struct bt_ctf_field
*);
177 bt_bool
bt_ctf_field_array_is_set(struct bt_ctf_field
*);
179 bt_bool
bt_ctf_field_sequence_is_set(struct bt_ctf_field
*);
182 int increase_packet_size(struct bt_ctf_stream_pos
*pos
);
185 struct bt_ctf_field
*(* const field_create_funcs
[])(
186 struct bt_ctf_field_type
*) = {
187 [BT_CTF_FIELD_TYPE_ID_INTEGER
] = bt_ctf_field_integer_create
,
188 [BT_CTF_FIELD_TYPE_ID_ENUM
] = bt_ctf_field_enumeration_create
,
189 [BT_CTF_FIELD_TYPE_ID_FLOAT
] =
190 bt_ctf_field_floating_point_create
,
191 [BT_CTF_FIELD_TYPE_ID_STRUCT
] = bt_ctf_field_structure_create
,
192 [BT_CTF_FIELD_TYPE_ID_VARIANT
] = bt_ctf_field_variant_create
,
193 [BT_CTF_FIELD_TYPE_ID_ARRAY
] = bt_ctf_field_array_create
,
194 [BT_CTF_FIELD_TYPE_ID_SEQUENCE
] = bt_ctf_field_sequence_create
,
195 [BT_CTF_FIELD_TYPE_ID_STRING
] = bt_ctf_field_string_create
,
199 void (* const field_destroy_funcs
[])(struct bt_ctf_field
*) = {
200 [BT_CTF_FIELD_TYPE_ID_INTEGER
] = bt_ctf_field_integer_destroy
,
201 [BT_CTF_FIELD_TYPE_ID_ENUM
] = bt_ctf_field_enumeration_destroy
,
202 [BT_CTF_FIELD_TYPE_ID_FLOAT
] =
203 bt_ctf_field_floating_point_destroy
,
204 [BT_CTF_FIELD_TYPE_ID_STRUCT
] = bt_ctf_field_structure_destroy
,
205 [BT_CTF_FIELD_TYPE_ID_VARIANT
] = bt_ctf_field_variant_destroy
,
206 [BT_CTF_FIELD_TYPE_ID_ARRAY
] = bt_ctf_field_array_destroy
,
207 [BT_CTF_FIELD_TYPE_ID_SEQUENCE
] = bt_ctf_field_sequence_destroy
,
208 [BT_CTF_FIELD_TYPE_ID_STRING
] = bt_ctf_field_string_destroy
,
212 int (* const field_validate_funcs
[])(struct bt_ctf_field
*) = {
213 [BT_CTF_FIELD_TYPE_ID_INTEGER
] = bt_ctf_field_generic_validate
,
214 [BT_CTF_FIELD_TYPE_ID_ENUM
] = bt_ctf_field_enumeration_validate
,
215 [BT_CTF_FIELD_TYPE_ID_FLOAT
] = bt_ctf_field_generic_validate
,
216 [BT_CTF_FIELD_TYPE_ID_STRUCT
] = bt_ctf_field_structure_validate
,
217 [BT_CTF_FIELD_TYPE_ID_VARIANT
] = bt_ctf_field_variant_validate
,
218 [BT_CTF_FIELD_TYPE_ID_ARRAY
] = bt_ctf_field_array_validate
,
219 [BT_CTF_FIELD_TYPE_ID_SEQUENCE
] = bt_ctf_field_sequence_validate
,
220 [BT_CTF_FIELD_TYPE_ID_STRING
] = bt_ctf_field_generic_validate
,
224 int (* const field_reset_funcs
[])(struct bt_ctf_field
*) = {
225 [BT_CTF_FIELD_TYPE_ID_INTEGER
] = bt_ctf_field_generic_reset
,
226 [BT_CTF_FIELD_TYPE_ID_ENUM
] = bt_ctf_field_enumeration_reset
,
227 [BT_CTF_FIELD_TYPE_ID_FLOAT
] = bt_ctf_field_generic_reset
,
228 [BT_CTF_FIELD_TYPE_ID_STRUCT
] = bt_ctf_field_structure_reset
,
229 [BT_CTF_FIELD_TYPE_ID_VARIANT
] = bt_ctf_field_variant_reset
,
230 [BT_CTF_FIELD_TYPE_ID_ARRAY
] = bt_ctf_field_array_reset
,
231 [BT_CTF_FIELD_TYPE_ID_SEQUENCE
] = bt_ctf_field_sequence_reset
,
232 [BT_CTF_FIELD_TYPE_ID_STRING
] = bt_ctf_field_string_reset
,
236 int (* const field_serialize_funcs
[])(struct bt_ctf_field
*,
237 struct bt_ctf_stream_pos
*, enum bt_ctf_byte_order
) = {
238 [BT_CTF_FIELD_TYPE_ID_INTEGER
] = bt_ctf_field_integer_serialize
,
239 [BT_CTF_FIELD_TYPE_ID_ENUM
] = bt_ctf_field_enumeration_serialize
,
240 [BT_CTF_FIELD_TYPE_ID_FLOAT
] =
241 bt_ctf_field_floating_point_serialize
,
242 [BT_CTF_FIELD_TYPE_ID_STRUCT
] = bt_ctf_field_structure_serialize
,
243 [BT_CTF_FIELD_TYPE_ID_VARIANT
] = bt_ctf_field_variant_serialize
,
244 [BT_CTF_FIELD_TYPE_ID_ARRAY
] = bt_ctf_field_array_serialize
,
245 [BT_CTF_FIELD_TYPE_ID_SEQUENCE
] = bt_ctf_field_sequence_serialize
,
246 [BT_CTF_FIELD_TYPE_ID_STRING
] = bt_ctf_field_string_serialize
,
250 int (* const field_copy_funcs
[])(struct bt_ctf_field
*,
251 struct bt_ctf_field
*) = {
252 [BT_CTF_FIELD_TYPE_ID_INTEGER
] = bt_ctf_field_integer_copy
,
253 [BT_CTF_FIELD_TYPE_ID_ENUM
] = bt_ctf_field_enumeration_copy
,
254 [BT_CTF_FIELD_TYPE_ID_FLOAT
] = bt_ctf_field_floating_point_copy
,
255 [BT_CTF_FIELD_TYPE_ID_STRUCT
] = bt_ctf_field_structure_copy
,
256 [BT_CTF_FIELD_TYPE_ID_VARIANT
] = bt_ctf_field_variant_copy
,
257 [BT_CTF_FIELD_TYPE_ID_ARRAY
] = bt_ctf_field_array_copy
,
258 [BT_CTF_FIELD_TYPE_ID_SEQUENCE
] = bt_ctf_field_sequence_copy
,
259 [BT_CTF_FIELD_TYPE_ID_STRING
] = bt_ctf_field_string_copy
,
263 void (* const field_freeze_funcs
[])(struct bt_ctf_field
*) = {
264 [BT_CTF_FIELD_TYPE_ID_INTEGER
] = generic_field_freeze
,
265 [BT_CTF_FIELD_TYPE_ID_FLOAT
] = generic_field_freeze
,
266 [BT_CTF_FIELD_TYPE_ID_STRING
] = generic_field_freeze
,
267 [BT_CTF_FIELD_TYPE_ID_ENUM
] = bt_ctf_field_enumeration_freeze
,
268 [BT_CTF_FIELD_TYPE_ID_STRUCT
] = bt_ctf_field_structure_freeze
,
269 [BT_CTF_FIELD_TYPE_ID_VARIANT
] = bt_ctf_field_variant_freeze
,
270 [BT_CTF_FIELD_TYPE_ID_ARRAY
] = bt_ctf_field_array_freeze
,
271 [BT_CTF_FIELD_TYPE_ID_SEQUENCE
] = bt_ctf_field_sequence_freeze
,
275 bt_bool (* const field_is_set_funcs
[])(struct bt_ctf_field
*) = {
276 [BT_CTF_FIELD_TYPE_ID_INTEGER
] = bt_ctf_field_generic_is_set
,
277 [BT_CTF_FIELD_TYPE_ID_ENUM
] = bt_ctf_field_enumeration_is_set
,
278 [BT_CTF_FIELD_TYPE_ID_FLOAT
] = bt_ctf_field_generic_is_set
,
279 [BT_CTF_FIELD_TYPE_ID_STRUCT
] = bt_ctf_field_structure_is_set
,
280 [BT_CTF_FIELD_TYPE_ID_VARIANT
] = bt_ctf_field_variant_is_set
,
281 [BT_CTF_FIELD_TYPE_ID_ARRAY
] = bt_ctf_field_array_is_set
,
282 [BT_CTF_FIELD_TYPE_ID_SEQUENCE
] = bt_ctf_field_sequence_is_set
,
283 [BT_CTF_FIELD_TYPE_ID_STRING
] = bt_ctf_field_generic_is_set
,
286 struct bt_ctf_field
*bt_ctf_field_create(struct bt_ctf_field_type
*type
)
288 struct bt_ctf_field
*field
= NULL
;
289 enum bt_ctf_field_type_id type_id
;
293 BT_LOGW_STR("Invalid parameter: field type is NULL.");
297 type_id
= bt_ctf_field_type_get_type_id(type
);
298 if (type_id
<= BT_CTF_FIELD_TYPE_ID_UNKNOWN
||
299 type_id
>= BT_CTF_NR_TYPE_IDS
) {
300 BT_LOGW("Invalid parameter: unknown field type ID: "
301 "ft-addr=%p, ft-id=%d", type
, type_id
);
305 /* Field class MUST be valid */
306 ret
= bt_ctf_field_type_validate(type
);
309 BT_LOGW("Invalid parameter: field type is invalid: "
314 field
= field_create_funcs
[type_id
](type
);
319 /* The type's declaration can't change after this point */
320 bt_ctf_field_type_freeze(type
);
322 bt_object_init(field
, bt_ctf_field_destroy
);
328 /* Pre-2.0 CTF writer backward compatibility */
329 void bt_ctf_field_get(struct bt_ctf_field
*field
)
334 /* Pre-2.0 CTF writer backward compatibility */
335 void bt_ctf_field_put(struct bt_ctf_field
*field
)
340 struct bt_ctf_field_type
*bt_ctf_field_get_type(struct bt_ctf_field
*field
)
342 struct bt_ctf_field_type
*ret
= NULL
;
345 BT_LOGW_STR("Invalid parameter: field is NULL.");
355 enum bt_ctf_field_type_id
bt_ctf_field_get_type_id(struct bt_ctf_field
*field
)
357 enum bt_ctf_field_type_id ret
= BT_CTF_FIELD_TYPE_ID_UNKNOWN
;
360 BT_LOGW_STR("Invalid parameter: field is NULL.");
364 ret
= bt_ctf_field_type_get_type_id(field
->type
);
369 bt_bool
bt_ctf_field_is_integer(struct bt_ctf_field
*field
)
371 return bt_ctf_field_get_type_id(field
) == BT_CTF_FIELD_TYPE_ID_INTEGER
;
374 bt_bool
bt_ctf_field_is_floating_point(struct bt_ctf_field
*field
)
376 return bt_ctf_field_get_type_id(field
) == BT_CTF_FIELD_TYPE_ID_FLOAT
;
379 bt_bool
bt_ctf_field_is_enumeration(struct bt_ctf_field
*field
)
381 return bt_ctf_field_get_type_id(field
) == BT_CTF_FIELD_TYPE_ID_ENUM
;
384 bt_bool
bt_ctf_field_is_string(struct bt_ctf_field
*field
)
386 return bt_ctf_field_get_type_id(field
) == BT_CTF_FIELD_TYPE_ID_STRING
;
389 bt_bool
bt_ctf_field_is_structure(struct bt_ctf_field
*field
)
391 return bt_ctf_field_get_type_id(field
) == BT_CTF_FIELD_TYPE_ID_STRUCT
;
394 bt_bool
bt_ctf_field_is_array(struct bt_ctf_field
*field
)
396 return bt_ctf_field_get_type_id(field
) == BT_CTF_FIELD_TYPE_ID_ARRAY
;
399 bt_bool
bt_ctf_field_is_sequence(struct bt_ctf_field
*field
)
401 return bt_ctf_field_get_type_id(field
) == BT_CTF_FIELD_TYPE_ID_SEQUENCE
;
404 bt_bool
bt_ctf_field_is_variant(struct bt_ctf_field
*field
)
406 return bt_ctf_field_get_type_id(field
) == BT_CTF_FIELD_TYPE_ID_VARIANT
;
409 struct bt_ctf_field
*bt_ctf_field_sequence_get_length(
410 struct bt_ctf_field
*field
)
412 struct bt_ctf_field
*ret
= NULL
;
413 struct bt_ctf_field_sequence
*sequence
;
416 BT_LOGW_STR("Invalid parameter: field is NULL.");
420 if (bt_ctf_field_type_get_type_id(field
->type
) !=
421 BT_CTF_FIELD_TYPE_ID_SEQUENCE
) {
422 BT_LOGW("Invalid parameter: field's type is not a sequence field type: "
423 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
425 bt_ctf_field_type_id_string(field
->type
->id
));
429 sequence
= container_of(field
, struct bt_ctf_field_sequence
, parent
);
430 ret
= sequence
->length
;
436 int bt_ctf_field_sequence_set_length(struct bt_ctf_field
*field
,
437 struct bt_ctf_field
*length_field
)
440 struct bt_ctf_field_type_integer
*length_type
;
441 struct bt_ctf_field_integer
*length
;
442 struct bt_ctf_field_sequence
*sequence
;
443 uint64_t sequence_length
;
446 BT_LOGW_STR("Invalid parameter: field is NULL.");
452 BT_LOGW_STR("Invalid parameter: length field is NULL.");
458 BT_LOGW("Invalid parameter: field is frozen: addr=%p",
464 if (bt_ctf_field_type_get_type_id(length_field
->type
) !=
465 BT_CTF_FIELD_TYPE_ID_INTEGER
) {
466 BT_LOGW("Invalid parameter: length field's type is not an integer field type: "
467 "field-addr=%p, length-field-addr=%p, length-ft-addr=%p, length-ft-id=%s",
468 field
, length_field
, length_field
->type
,
469 bt_ctf_field_type_id_string(length_field
->type
->id
));
474 length_type
= container_of(length_field
->type
,
475 struct bt_ctf_field_type_integer
, parent
);
476 /* The length field must be unsigned */
477 if (length_type
->is_signed
) {
478 BT_LOGW("Invalid parameter: length field's type is signed: "
479 "field-addr=%p, length-field-addr=%p, "
480 "length-field-ft-addr=%p", field
, length_field
,
486 length
= container_of(length_field
, struct bt_ctf_field_integer
,
488 sequence_length
= length
->payload
.unsignd
;
489 sequence
= container_of(field
, struct bt_ctf_field_sequence
, parent
);
490 if (sequence
->elements
) {
491 g_ptr_array_free(sequence
->elements
, TRUE
);
492 bt_put(sequence
->length
);
495 sequence
->elements
= g_ptr_array_sized_new((size_t)sequence_length
);
496 if (!sequence
->elements
) {
497 BT_LOGE_STR("Failed to allocate a GPtrArray.");
502 g_ptr_array_set_free_func(sequence
->elements
,
503 (GDestroyNotify
) bt_put
);
504 g_ptr_array_set_size(sequence
->elements
, (size_t) sequence_length
);
505 bt_get(length_field
);
506 sequence
->length
= length_field
;
511 struct bt_ctf_field
*bt_ctf_field_structure_get_field_by_name(
512 struct bt_ctf_field
*field
, const char *name
)
514 struct bt_ctf_field
*ret
= NULL
;
516 struct bt_ctf_field_structure
*structure
;
518 GHashTable
*field_name_to_index
;
521 BT_LOGW_STR("Invalid parameter: field is NULL.");
526 BT_LOGW_STR("Invalid parameter: field name is NULL.");
530 if (bt_ctf_field_type_get_type_id(field
->type
) !=
531 BT_CTF_FIELD_TYPE_ID_STRUCT
) {
532 BT_LOGW("Invalid parameter: field's type is not a structure field type: "
533 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
535 bt_ctf_field_type_id_string(field
->type
->id
));
539 field_name_to_index
=
540 container_of(field
->type
, struct bt_ctf_field_type_structure
,
541 parent
)->field_name_to_index
;
542 field_quark
= g_quark_from_string(name
);
543 structure
= container_of(field
, struct bt_ctf_field_structure
, parent
);
544 if (!g_hash_table_lookup_extended(field_name_to_index
,
545 GUINT_TO_POINTER(field_quark
),
546 NULL
, (gpointer
*)&index
)) {
547 BT_LOGV("Invalid parameter: no such field in structure field's type: "
548 "struct-field-addr=%p, struct-ft-addr=%p, name=\"%s\"",
549 field
, field
->type
, name
);
553 ret
= bt_get(structure
->fields
->pdata
[index
]);
559 struct bt_ctf_field
*bt_ctf_field_structure_get_field_by_index(
560 struct bt_ctf_field
*field
, uint64_t index
)
562 struct bt_ctf_field_structure
*structure
;
563 struct bt_ctf_field
*ret
= NULL
;
566 BT_LOGW_STR("Invalid parameter: field is NULL.");
570 if (bt_ctf_field_type_get_type_id(field
->type
) !=
571 BT_CTF_FIELD_TYPE_ID_STRUCT
) {
572 BT_LOGW("Invalid parameter: field's type is not a structure field type: "
573 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
575 bt_ctf_field_type_id_string(field
->type
->id
));
579 structure
= container_of(field
, struct bt_ctf_field_structure
, parent
);
580 if (index
>= structure
->fields
->len
) {
581 BT_LOGW("Invalid parameter: index is out of bounds: "
582 "addr=%p, index=%" PRIu64
", count=%u",
583 field
, index
, structure
->fields
->len
);
587 ret
= bt_get(structure
->fields
->pdata
[index
]);
592 int bt_ctf_field_structure_set_field_by_name(struct bt_ctf_field
*field
,
593 const char *name
, struct bt_ctf_field
*value
)
597 struct bt_ctf_field_structure
*structure
;
598 struct bt_ctf_field_type
*expected_field_type
= NULL
;
600 GHashTable
*field_name_to_index
;
603 BT_LOGW_STR("Invalid parameter: structure field is NULL.");
609 BT_LOGW_STR("Invalid parameter: field name is NULL.");
615 BT_LOGW_STR("Invalid parameter: field is NULL.");
620 if (bt_ctf_field_type_get_type_id(field
->type
) !=
621 BT_CTF_FIELD_TYPE_ID_STRUCT
) {
622 BT_LOGW("Invalid parameter: field's type is not a structure field type: "
623 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
625 bt_ctf_field_type_id_string(field
->type
->id
));
630 field_quark
= g_quark_from_string(name
);
631 structure
= container_of(field
, struct bt_ctf_field_structure
, parent
);
632 expected_field_type
=
633 bt_ctf_field_type_structure_get_field_type_by_name(field
->type
,
636 if (bt_ctf_field_type_compare(expected_field_type
, value
->type
)) {
637 BT_LOGW("Invalid parameter: field type of field to set is different from the expected field type: "
638 "struct-field-addr=%p, field-addr=%p, "
639 "field-ft-addr=%p, expected-ft-addr=%p",
640 field
, value
, value
->type
, expected_field_type
);
645 field_name_to_index
=
646 container_of(field
->type
, struct bt_ctf_field_type_structure
,
647 parent
)->field_name_to_index
;
648 if (!g_hash_table_lookup_extended(field_name_to_index
,
649 GUINT_TO_POINTER(field_quark
), NULL
,
650 (gpointer
*) &index
)) {
651 BT_LOGV("Invalid parameter: no such field in structure field's type: "
652 "struct-field-addr=%p, struct-ft-addr=%p, "
653 "field-ft-addr=%p, name=\"%s\"",
654 field
, field
->type
, value
->type
, name
);
659 BT_MOVE(structure
->fields
->pdata
[index
], value
);
661 if (expected_field_type
) {
662 bt_put(expected_field_type
);
667 struct bt_ctf_field
*bt_ctf_field_array_get_field(struct bt_ctf_field
*field
,
670 struct bt_ctf_field
*new_field
= NULL
;
671 struct bt_ctf_field_type
*field_type
= NULL
;
672 struct bt_ctf_field_array
*array
;
675 BT_LOGW_STR("Invalid parameter: field is NULL.");
679 if (bt_ctf_field_type_get_type_id(field
->type
) !=
680 BT_CTF_FIELD_TYPE_ID_ARRAY
) {
681 BT_LOGW("Invalid parameter: field's type is not an array field type: "
682 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
684 bt_ctf_field_type_id_string(field
->type
->id
));
688 array
= container_of(field
, struct bt_ctf_field_array
, parent
);
689 if (index
>= array
->elements
->len
) {
690 BT_LOGW("Invalid parameter: index is out of bounds: "
691 "addr=%p, index=%" PRIu64
", count=%u",
692 field
, index
, array
->elements
->len
);
696 field_type
= bt_ctf_field_type_array_get_element_type(field
->type
);
697 if (array
->elements
->pdata
[(size_t)index
]) {
698 new_field
= array
->elements
->pdata
[(size_t)index
];
702 /* We don't want to modify this field if it's frozen */
705 * Not logging a warning here because the user could
706 * legitimately check if a array field is set with
707 * this function: if the preconditions are satisfied,
708 * a NULL return value means this.
710 BT_LOGV("Not creating a field because array field is frozen: "
711 "array-field-addr=%p, index=%" PRIu64
, field
, index
);
715 new_field
= bt_ctf_field_create(field_type
);
716 array
->elements
->pdata
[(size_t)index
] = new_field
;
727 struct bt_ctf_field
*bt_ctf_field_sequence_get_field(struct bt_ctf_field
*field
,
730 struct bt_ctf_field
*new_field
= NULL
;
731 struct bt_ctf_field_type
*field_type
= NULL
;
732 struct bt_ctf_field_sequence
*sequence
;
735 BT_LOGW_STR("Invalid parameter: field is NULL.");
739 if (bt_ctf_field_type_get_type_id(field
->type
) !=
740 BT_CTF_FIELD_TYPE_ID_SEQUENCE
) {
741 BT_LOGW("Invalid parameter: field's type is not a sequence field type: "
742 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
744 bt_ctf_field_type_id_string(field
->type
->id
));
748 sequence
= container_of(field
, struct bt_ctf_field_sequence
, parent
);
749 if (!sequence
->elements
) {
750 BT_LOGV("Sequence field's elements do not exist: addr=%p",
755 if (index
>= sequence
->elements
->len
) {
756 BT_LOGW("Invalid parameter: index is out of bounds: "
757 "addr=%p, index=%" PRIu64
", count=%u",
758 field
, index
, sequence
->elements
->len
);
762 field_type
= bt_ctf_field_type_sequence_get_element_type(field
->type
);
763 if (sequence
->elements
->pdata
[(size_t) index
]) {
764 new_field
= sequence
->elements
->pdata
[(size_t) index
];
768 /* We don't want to modify this field if it's frozen */
771 * Not logging a warning here because the user could
772 * legitimately check if a sequence field is set with
773 * this function: if the preconditions are satisfied,
774 * a NULL return value means this.
776 BT_LOGV("Not creating a field because sequence field is frozen: "
777 "sequence-field-addr=%p, index=%" PRIu64
, field
, index
);
781 new_field
= bt_ctf_field_create(field_type
);
782 sequence
->elements
->pdata
[(size_t) index
] = new_field
;
793 struct bt_ctf_field
*bt_ctf_field_variant_get_field(struct bt_ctf_field
*field
,
794 struct bt_ctf_field
*tag_field
)
796 struct bt_ctf_field
*new_field
= NULL
;
797 struct bt_ctf_field_variant
*variant
;
798 struct bt_ctf_field_type_variant
*variant_type
;
799 struct bt_ctf_field_type
*field_type
;
800 struct bt_ctf_field
*tag_enum
= NULL
;
801 struct bt_ctf_field_integer
*tag_enum_integer
;
802 int64_t tag_enum_value
;
805 BT_LOGW_STR("Invalid parameter: field is NULL.");
810 BT_LOGW_STR("Invalid parameter: tag field is NULL.");
814 if (bt_ctf_field_type_get_type_id(field
->type
) !=
815 BT_CTF_FIELD_TYPE_ID_VARIANT
) {
816 BT_LOGW("Invalid parameter: field's type is not a variant field type: "
817 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
819 bt_ctf_field_type_id_string(field
->type
->id
));
823 if (bt_ctf_field_type_get_type_id(tag_field
->type
) !=
824 BT_CTF_FIELD_TYPE_ID_ENUM
) {
825 BT_LOGW("Invalid parameter: tag field's type is not an enumeration field type: "
826 "field-addr=%p, ft-addr=%p, ft-id=%s", tag_field
,
828 bt_ctf_field_type_id_string(tag_field
->type
->id
));
832 variant
= container_of(field
, struct bt_ctf_field_variant
, parent
);
833 variant_type
= container_of(field
->type
,
834 struct bt_ctf_field_type_variant
, parent
);
835 tag_enum
= bt_ctf_field_enumeration_get_container(tag_field
);
840 tag_enum_integer
= container_of(tag_enum
, struct bt_ctf_field_integer
,
843 if (bt_ctf_field_validate(tag_field
) < 0) {
844 BT_LOGW("Invalid parameter: tag field is invalid: "
845 "variant-field-addr=%p, tag-field-addr=%p",
850 tag_enum_value
= tag_enum_integer
->payload
.signd
;
853 * If the variant currently has a tag and a payload, and if the
854 * requested tag value is the same as the current one, return
855 * the current payload instead of creating a fresh one.
857 if (variant
->tag
&& variant
->payload
) {
858 struct bt_ctf_field
*cur_tag_container
= NULL
;
859 struct bt_ctf_field_integer
*cur_tag_enum_integer
;
860 int64_t cur_tag_value
;
863 bt_ctf_field_enumeration_get_container(variant
->tag
);
864 assert(cur_tag_container
);
865 cur_tag_enum_integer
= container_of(cur_tag_container
,
866 struct bt_ctf_field_integer
, parent
);
867 bt_put(cur_tag_container
);
868 cur_tag_value
= cur_tag_enum_integer
->payload
.signd
;
870 if (cur_tag_value
== tag_enum_value
) {
871 new_field
= variant
->payload
;
877 /* We don't want to modify this field if it's frozen */
880 * Not logging a warning here because the user could
881 * legitimately check if a variant field is set with
882 * this function: if the preconditions are satisfied,
883 * a NULL return value means this.
885 BT_LOGV("Not creating a field because variant field is frozen: "
886 "variant-field-addr=%p, tag-field-addr=%p",
891 field_type
= bt_ctf_field_type_variant_get_field_type_signed(
892 variant_type
, tag_enum_value
);
894 BT_LOGW("Cannot get variant field type's field: "
895 "variant-field-addr=%p, variant-ft-addr=%p, "
896 "tag-value-signed=%" PRId64
,
897 field
, variant_type
, tag_enum_value
);
901 new_field
= bt_ctf_field_create(field_type
);
903 BT_LOGW("Cannot create field: "
904 "variant-field-addr=%p, variant-ft-addr=%p, "
905 "field-ft-addr=%p", field
, field
->type
, field_type
);
909 bt_put(variant
->tag
);
910 bt_put(variant
->payload
);
913 variant
->tag
= tag_field
;
914 variant
->payload
= new_field
;
920 struct bt_ctf_field
*bt_ctf_field_variant_get_current_field(
921 struct bt_ctf_field
*variant_field
)
923 struct bt_ctf_field
*current_field
= NULL
;
924 struct bt_ctf_field_variant
*variant
;
926 if (!variant_field
) {
927 BT_LOGW_STR("Invalid parameter: field is NULL.");
931 if (bt_ctf_field_type_get_type_id(variant_field
->type
) !=
932 BT_CTF_FIELD_TYPE_ID_VARIANT
) {
933 BT_LOGW("Invalid parameter: field's type is not a variant field type: "
934 "field-addr=%p, ft-addr=%p, ft-id=%s", variant_field
,
936 bt_ctf_field_type_id_string(variant_field
->type
->id
));
940 variant
= container_of(variant_field
, struct bt_ctf_field_variant
,
943 if (variant
->payload
) {
944 current_field
= variant
->payload
;
945 bt_get(current_field
);
950 return current_field
;
953 struct bt_ctf_field
*bt_ctf_field_variant_get_tag(
954 struct bt_ctf_field
*variant_field
)
956 struct bt_ctf_field
*tag
= NULL
;
957 struct bt_ctf_field_variant
*variant
;
959 if (!variant_field
) {
960 BT_LOGW_STR("Invalid parameter: field is NULL.");
964 if (bt_ctf_field_type_get_type_id(variant_field
->type
) !=
965 BT_CTF_FIELD_TYPE_ID_VARIANT
) {
966 BT_LOGW("Invalid parameter: field's type is not a variant field type: "
967 "field-addr=%p, ft-addr=%p, ft-id=%s", variant_field
,
969 bt_ctf_field_type_id_string(variant_field
->type
->id
));
973 variant
= container_of(variant_field
, struct bt_ctf_field_variant
,
976 tag
= bt_get(variant
->tag
);
982 struct bt_ctf_field
*bt_ctf_field_enumeration_get_container(
983 struct bt_ctf_field
*field
)
985 struct bt_ctf_field
*container
= NULL
;
986 struct bt_ctf_field_enumeration
*enumeration
;
989 BT_LOGW_STR("Invalid parameter: field is NULL.");
993 if (bt_ctf_field_type_get_type_id(field
->type
) !=
994 BT_CTF_FIELD_TYPE_ID_ENUM
) {
995 BT_LOGW("Invalid parameter: field's type is not an enumeration field type: "
996 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
998 bt_ctf_field_type_id_string(field
->type
->id
));
1002 enumeration
= container_of(field
, struct bt_ctf_field_enumeration
,
1004 if (!enumeration
->payload
) {
1005 /* We don't want to modify this field if it's frozen */
1006 if (field
->frozen
) {
1008 * Not logging a warning here because the user
1009 * could legitimately check if an enumeration's
1010 * container field is set with this function: if
1011 * the preconditions are satisfied, a NULL
1012 * return value means this.
1014 BT_LOGV("Not creating a field because enumeration field is frozen: "
1015 "enum-field-addr=%p", field
);
1019 struct bt_ctf_field_type_enumeration
*enumeration_type
=
1020 container_of(field
->type
,
1021 struct bt_ctf_field_type_enumeration
, parent
);
1022 enumeration
->payload
=
1023 bt_ctf_field_create(enumeration_type
->container
);
1026 container
= enumeration
->payload
;
1032 struct bt_ctf_field_type_enumeration_mapping_iterator
*
1033 bt_ctf_field_enumeration_get_mappings(struct bt_ctf_field
*field
)
1036 struct bt_ctf_field
*container
= NULL
;
1037 struct bt_ctf_field_type
*container_type
= NULL
;
1038 struct bt_ctf_field_type_integer
*integer_type
= NULL
;
1039 struct bt_ctf_field_type_enumeration_mapping_iterator
*iter
= NULL
;
1041 container
= bt_ctf_field_enumeration_get_container(field
);
1043 BT_LOGW("Invalid parameter: enumeration field has no container field: "
1048 container_type
= bt_ctf_field_get_type(container
);
1049 assert(container_type
);
1050 integer_type
= container_of(container_type
,
1051 struct bt_ctf_field_type_integer
, parent
);
1053 if (!integer_type
->is_signed
) {
1056 ret
= bt_ctf_field_unsigned_integer_get_value(container
,
1059 BT_LOGW("Cannot get value from signed enumeration field's payload field: "
1060 "enum-field-addr=%p, payload-field-addr=%p",
1062 goto error_put_container_type
;
1064 iter
= bt_ctf_field_type_enumeration_find_mappings_by_unsigned_value(
1065 field
->type
, value
);
1069 ret
= bt_ctf_field_signed_integer_get_value(container
,
1072 BT_LOGW("Cannot get value from unsigned enumeration field's payload field: "
1073 "enum-field-addr=%p, payload-field-addr=%p",
1075 goto error_put_container_type
;
1077 iter
= bt_ctf_field_type_enumeration_find_mappings_by_signed_value(
1078 field
->type
, value
);
1081 error_put_container_type
:
1082 bt_put(container_type
);
1088 int bt_ctf_field_signed_integer_get_value(struct bt_ctf_field
*field
,
1092 struct bt_ctf_field_integer
*integer
;
1093 struct bt_ctf_field_type_integer
*integer_type
;
1096 BT_LOGW_STR("Invalid parameter: field is NULL.");
1102 BT_LOGW_STR("Invalid parameter: value is NULL.");
1107 if (!field
->payload_set
) {
1108 BT_LOGV("Field's payload is not set: addr=%p", field
);
1113 if (bt_ctf_field_type_get_type_id(field
->type
) !=
1114 BT_CTF_FIELD_TYPE_ID_INTEGER
) {
1115 BT_LOGW("Invalid parameter: field's type is not an integer field type: "
1116 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
1118 bt_ctf_field_type_id_string(field
->type
->id
));
1123 integer_type
= container_of(field
->type
,
1124 struct bt_ctf_field_type_integer
, parent
);
1125 if (!integer_type
->is_signed
) {
1126 BT_LOGW("Invalid parameter: integer field's type is not signed: "
1127 "field-addr=%p, ft-addr=%p", field
, field
->type
);
1132 integer
= container_of(field
,
1133 struct bt_ctf_field_integer
, parent
);
1134 *value
= integer
->payload
.signd
;
1139 int bt_ctf_field_signed_integer_set_value(struct bt_ctf_field
*field
,
1143 struct bt_ctf_field_integer
*integer
;
1144 struct bt_ctf_field_type_integer
*integer_type
;
1146 int64_t min_value
, max_value
;
1149 BT_LOGW_STR("Invalid parameter: field is NULL.");
1154 if (field
->frozen
) {
1155 BT_LOGW("Invalid parameter: field is frozen: addr=%p",
1161 if (bt_ctf_field_type_get_type_id(field
->type
) !=
1162 BT_CTF_FIELD_TYPE_ID_INTEGER
) {
1163 BT_LOGW("Invalid parameter: field's type is not an integer field type: "
1164 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
1166 bt_ctf_field_type_id_string(field
->type
->id
));
1171 integer
= container_of(field
, struct bt_ctf_field_integer
, parent
);
1172 integer_type
= container_of(field
->type
,
1173 struct bt_ctf_field_type_integer
, parent
);
1174 if (!integer_type
->is_signed
) {
1175 BT_LOGW("Invalid parameter: integer field's type is not signed: "
1176 "field-addr=%p, ft-addr=%p", field
, field
->type
);
1181 size
= integer_type
->size
;
1182 min_value
= -(1ULL << (size
- 1));
1183 max_value
= (1ULL << (size
- 1)) - 1;
1184 if (value
< min_value
|| value
> max_value
) {
1185 BT_LOGW("Invalid parameter: value is out of bounds: "
1186 "addr=%p, value=%" PRId64
", "
1187 "min-value=%" PRId64
", max-value=%" PRId64
,
1188 field
, value
, min_value
, max_value
);
1193 integer
->payload
.signd
= value
;
1194 integer
->parent
.payload_set
= true;
1199 int bt_ctf_field_unsigned_integer_get_value(struct bt_ctf_field
*field
,
1203 struct bt_ctf_field_integer
*integer
;
1204 struct bt_ctf_field_type_integer
*integer_type
;
1207 BT_LOGW_STR("Invalid parameter: field is NULL.");
1213 BT_LOGW_STR("Invalid parameter: value is NULL.");
1218 if (!field
->payload_set
) {
1219 BT_LOGV("Field's payload is not set: addr=%p", field
);
1224 if (bt_ctf_field_type_get_type_id(field
->type
) !=
1225 BT_CTF_FIELD_TYPE_ID_INTEGER
) {
1226 BT_LOGW("Invalid parameter: field's type is not an integer field type: "
1227 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
1229 bt_ctf_field_type_id_string(field
->type
->id
));
1234 integer_type
= container_of(field
->type
,
1235 struct bt_ctf_field_type_integer
, parent
);
1236 if (integer_type
->is_signed
) {
1237 BT_LOGW("Invalid parameter: integer field's type is signed: "
1238 "field-addr=%p, ft-addr=%p", field
, field
->type
);
1243 integer
= container_of(field
,
1244 struct bt_ctf_field_integer
, parent
);
1245 *value
= integer
->payload
.unsignd
;
1250 int bt_ctf_field_unsigned_integer_set_value(struct bt_ctf_field
*field
,
1254 struct bt_ctf_field_integer
*integer
;
1255 struct bt_ctf_field_type_integer
*integer_type
;
1260 BT_LOGW_STR("Invalid parameter: field is NULL.");
1265 if (field
->frozen
) {
1266 BT_LOGW("Invalid parameter: field is frozen: addr=%p",
1272 if (bt_ctf_field_type_get_type_id(field
->type
) !=
1273 BT_CTF_FIELD_TYPE_ID_INTEGER
) {
1274 BT_LOGW("Invalid parameter: field's type is not an integer field type: "
1275 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
1277 bt_ctf_field_type_id_string(field
->type
->id
));
1282 integer
= container_of(field
, struct bt_ctf_field_integer
, parent
);
1283 integer_type
= container_of(field
->type
,
1284 struct bt_ctf_field_type_integer
, parent
);
1285 if (integer_type
->is_signed
) {
1286 BT_LOGW("Invalid parameter: integer field's type is signed: "
1287 "field-addr=%p, ft-addr=%p", field
, field
->type
);
1292 size
= integer_type
->size
;
1293 max_value
= (size
== 64) ? UINT64_MAX
: ((uint64_t) 1 << size
) - 1;
1294 if (value
> max_value
) {
1295 BT_LOGW("Invalid parameter: value is out of bounds: "
1296 "addr=%p, value=%" PRIu64
", "
1297 "min-value=%" PRIu64
", max-value=%" PRIu64
,
1298 field
, value
, (uint64_t) 0, max_value
);
1303 integer
->payload
.unsignd
= value
;
1304 integer
->parent
.payload_set
= true;
1309 int bt_ctf_field_floating_point_get_value(struct bt_ctf_field
*field
,
1313 struct bt_ctf_field_floating_point
*floating_point
;
1316 BT_LOGW_STR("Invalid parameter: field is NULL.");
1322 BT_LOGW_STR("Invalid parameter: value is NULL.");
1327 if (!field
->payload_set
) {
1328 BT_LOGV("Field's payload is not set: addr=%p", field
);
1333 if (bt_ctf_field_type_get_type_id(field
->type
) !=
1334 BT_CTF_FIELD_TYPE_ID_FLOAT
) {
1335 BT_LOGW("Invalid parameter: field's type is not a floating point number field type: "
1336 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
1338 bt_ctf_field_type_id_string(field
->type
->id
));
1343 floating_point
= container_of(field
,
1344 struct bt_ctf_field_floating_point
, parent
);
1345 *value
= floating_point
->payload
;
1350 int bt_ctf_field_floating_point_set_value(struct bt_ctf_field
*field
,
1354 struct bt_ctf_field_floating_point
*floating_point
;
1357 BT_LOGW_STR("Invalid parameter: field is NULL.");
1362 if (field
->frozen
) {
1363 BT_LOGW("Invalid parameter: field is frozen: addr=%p",
1369 if (bt_ctf_field_type_get_type_id(field
->type
) !=
1370 BT_CTF_FIELD_TYPE_ID_FLOAT
) {
1371 BT_LOGW("Invalid parameter: field's type is not a floating point number field type: "
1372 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
1374 bt_ctf_field_type_id_string(field
->type
->id
));
1379 floating_point
= container_of(field
, struct bt_ctf_field_floating_point
,
1381 floating_point
->payload
= value
;
1382 floating_point
->parent
.payload_set
= true;
1387 const char *bt_ctf_field_string_get_value(struct bt_ctf_field
*field
)
1389 const char *ret
= NULL
;
1390 struct bt_ctf_field_string
*string
;
1393 BT_LOGW_STR("Invalid parameter: field is NULL.");
1397 if (!field
->payload_set
) {
1398 BT_LOGV("Field's payload is not set: addr=%p", field
);
1402 if (bt_ctf_field_type_get_type_id(field
->type
) !=
1403 BT_CTF_FIELD_TYPE_ID_STRING
) {
1404 BT_LOGW("Invalid parameter: field's type is not a string field type: "
1405 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
1407 bt_ctf_field_type_id_string(field
->type
->id
));
1411 string
= container_of(field
,
1412 struct bt_ctf_field_string
, parent
);
1413 ret
= string
->payload
->str
;
1418 int bt_ctf_field_string_set_value(struct bt_ctf_field
*field
,
1422 struct bt_ctf_field_string
*string
;
1425 BT_LOGW_STR("Invalid parameter: field is NULL.");
1431 BT_LOGW_STR("Invalid parameter: value is NULL.");
1436 if (field
->frozen
) {
1437 BT_LOGW("Invalid parameter: field is frozen: addr=%p",
1443 if (bt_ctf_field_type_get_type_id(field
->type
) !=
1444 BT_CTF_FIELD_TYPE_ID_STRING
) {
1445 BT_LOGW("Invalid parameter: field's type is not a string field type: "
1446 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
1448 bt_ctf_field_type_id_string(field
->type
->id
));
1453 string
= container_of(field
, struct bt_ctf_field_string
, parent
);
1454 if (string
->payload
) {
1455 g_string_assign(string
->payload
, value
);
1457 string
->payload
= g_string_new(value
);
1460 string
->parent
.payload_set
= true;
1465 int bt_ctf_field_string_append(struct bt_ctf_field
*field
,
1469 struct bt_ctf_field_string
*string_field
;
1472 BT_LOGW_STR("Invalid parameter: field is NULL.");
1478 BT_LOGW_STR("Invalid parameter: value is NULL.");
1483 if (field
->frozen
) {
1484 BT_LOGW("Invalid parameter: field is frozen: addr=%p",
1490 if (bt_ctf_field_type_get_type_id(field
->type
) !=
1491 BT_CTF_FIELD_TYPE_ID_STRING
) {
1492 BT_LOGW("Invalid parameter: field's type is not a string field type: "
1493 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
1495 bt_ctf_field_type_id_string(field
->type
->id
));
1500 string_field
= container_of(field
, struct bt_ctf_field_string
, parent
);
1502 if (string_field
->payload
) {
1503 g_string_append(string_field
->payload
, value
);
1505 string_field
->payload
= g_string_new(value
);
1508 string_field
->parent
.payload_set
= true;
1514 int bt_ctf_field_string_append_len(struct bt_ctf_field
*field
,
1515 const char *value
, unsigned int length
)
1519 unsigned int effective_length
= length
;
1520 struct bt_ctf_field_string
*string_field
;
1523 BT_LOGW_STR("Invalid parameter: field is NULL.");
1529 BT_LOGW_STR("Invalid parameter: value is NULL.");
1534 if (field
->frozen
) {
1535 BT_LOGW("Invalid parameter: field is frozen: addr=%p",
1541 if (bt_ctf_field_type_get_type_id(field
->type
) !=
1542 BT_CTF_FIELD_TYPE_ID_STRING
) {
1543 BT_LOGW("Invalid parameter: field's type is not a string field type: "
1544 "field-addr=%p, ft-addr=%p, ft-id=%s", field
,
1546 bt_ctf_field_type_id_string(field
->type
->id
));
1551 string_field
= container_of(field
, struct bt_ctf_field_string
, parent
);
1553 /* make sure no null bytes are appended */
1554 for (i
= 0; i
< length
; ++i
) {
1555 if (value
[i
] == '\0') {
1556 effective_length
= i
;
1561 if (string_field
->payload
) {
1562 g_string_append_len(string_field
->payload
, value
,
1565 string_field
->payload
= g_string_new_len(value
,
1569 string_field
->parent
.payload_set
= true;
1576 int bt_ctf_field_validate(struct bt_ctf_field
*field
)
1579 enum bt_ctf_field_type_id type_id
;
1582 BT_LOGD_STR("Invalid parameter: field is NULL.");
1587 type_id
= bt_ctf_field_type_get_type_id(field
->type
);
1588 if (type_id
<= BT_CTF_FIELD_TYPE_ID_UNKNOWN
|| type_id
>= BT_CTF_NR_TYPE_IDS
) {
1589 BT_LOGW("Invalid parameter: unknown field type ID: "
1590 "addr=%p, ft-addr=%p, ft-id=%d",
1591 field
, field
->type
, type_id
);
1596 ret
= field_validate_funcs
[type_id
](field
);
1602 int bt_ctf_field_reset(struct bt_ctf_field
*field
)
1605 enum bt_ctf_field_type_id type_id
;
1608 BT_LOGD_STR("Invalid parameter: field is NULL.");
1613 type_id
= bt_ctf_field_type_get_type_id(field
->type
);
1614 if (type_id
<= BT_CTF_FIELD_TYPE_ID_UNKNOWN
|| type_id
>= BT_CTF_NR_TYPE_IDS
) {
1615 BT_LOGW("Invalid parameter: unknown field type ID: "
1616 "addr=%p, ft-addr=%p, ft-id=%d",
1617 field
, field
->type
, type_id
);
1622 ret
= field_reset_funcs
[type_id
](field
);
1628 int bt_ctf_field_serialize(struct bt_ctf_field
*field
,
1629 struct bt_ctf_stream_pos
*pos
,
1630 enum bt_ctf_byte_order native_byte_order
)
1633 enum bt_ctf_field_type_id type_id
;
1638 BT_LOGD_STR("Invalid parameter: field is NULL.");
1643 type_id
= bt_ctf_field_type_get_type_id(field
->type
);
1644 if (type_id
<= BT_CTF_FIELD_TYPE_ID_UNKNOWN
|| type_id
>= BT_CTF_NR_TYPE_IDS
) {
1645 BT_LOGW("Invalid parameter: unknown field type ID: "
1646 "addr=%p, ft-addr=%p, ft-id=%d",
1647 field
, field
->type
, type_id
);
1652 ret
= field_serialize_funcs
[type_id
](field
, pos
, native_byte_order
);
1659 bt_bool
bt_ctf_field_is_set(struct bt_ctf_field
*field
)
1661 bt_bool is_set
= BT_FALSE
;
1662 enum bt_ctf_field_type_id type_id
;
1668 type_id
= bt_ctf_field_type_get_type_id(field
->type
);
1669 if (type_id
<= BT_CTF_FIELD_TYPE_ID_UNKNOWN
|| type_id
>= BT_CTF_NR_TYPE_IDS
) {
1670 BT_LOGW("Invalid parameter: unknown field type ID: "
1671 "field-addr=%p, ft-addr=%p, ft-id=%d",
1672 field
, field
->type
, type_id
);
1676 is_set
= field_is_set_funcs
[type_id
](field
);
1681 struct bt_ctf_field
*bt_ctf_field_copy(struct bt_ctf_field
*field
)
1684 struct bt_ctf_field
*copy
= NULL
;
1685 enum bt_ctf_field_type_id type_id
;
1688 BT_LOGW_STR("Invalid parameter: field is NULL.");
1692 type_id
= bt_ctf_field_type_get_type_id(field
->type
);
1693 if (type_id
<= BT_CTF_FIELD_TYPE_ID_UNKNOWN
|| type_id
>= BT_CTF_NR_TYPE_IDS
) {
1694 BT_LOGW("Invalid parameter: unknown field type ID: "
1695 "field-addr=%p, ft-addr=%p, ft-id=%d",
1696 field
, field
->type
, type_id
);
1700 copy
= bt_ctf_field_create(field
->type
);
1702 BT_LOGW("Cannot create field: ft-addr=%p", field
->type
);
1706 copy
->payload_set
= field
->payload_set
;
1707 ret
= field_copy_funcs
[type_id
](field
, copy
);
1717 struct bt_ctf_field
*bt_ctf_field_integer_create(struct bt_ctf_field_type
*type
)
1719 struct bt_ctf_field_integer
*integer
= g_new0(
1720 struct bt_ctf_field_integer
, 1);
1722 BT_LOGD("Creating integer field object: ft-addr=%p", type
);
1725 BT_LOGD("Created integer field object: addr=%p, ft-addr=%p",
1726 &integer
->parent
, type
);
1728 BT_LOGE_STR("Failed to allocate one integer field.");
1731 return integer
? &integer
->parent
: NULL
;
1735 struct bt_ctf_field
*bt_ctf_field_enumeration_create(
1736 struct bt_ctf_field_type
*type
)
1738 struct bt_ctf_field_enumeration
*enumeration
= g_new0(
1739 struct bt_ctf_field_enumeration
, 1);
1741 BT_LOGD("Creating enumeration field object: ft-addr=%p", type
);
1744 BT_LOGD("Created enumeration field object: addr=%p, ft-addr=%p",
1745 &enumeration
->parent
, type
);
1747 BT_LOGE_STR("Failed to allocate one enumeration field.");
1750 return enumeration
? &enumeration
->parent
: NULL
;
1754 struct bt_ctf_field
*bt_ctf_field_floating_point_create(
1755 struct bt_ctf_field_type
*type
)
1757 struct bt_ctf_field_floating_point
*floating_point
;
1759 BT_LOGD("Creating floating point number field object: ft-addr=%p", type
);
1760 floating_point
= g_new0(struct bt_ctf_field_floating_point
, 1);
1762 if (floating_point
) {
1763 BT_LOGD("Created floating point number field object: addr=%p, ft-addr=%p",
1764 &floating_point
->parent
, type
);
1766 BT_LOGE_STR("Failed to allocate one floating point number field.");
1769 return floating_point
? &floating_point
->parent
: NULL
;
1773 struct bt_ctf_field
*bt_ctf_field_structure_create(
1774 struct bt_ctf_field_type
*type
)
1776 struct bt_ctf_field_type_structure
*structure_type
= container_of(type
,
1777 struct bt_ctf_field_type_structure
, parent
);
1778 struct bt_ctf_field_structure
*structure
= g_new0(
1779 struct bt_ctf_field_structure
, 1);
1780 struct bt_ctf_field
*ret
= NULL
;
1783 BT_LOGD("Creating structure field object: ft-addr=%p", type
);
1786 BT_LOGE_STR("Failed to allocate one structure field.");
1790 structure
->fields
= g_ptr_array_new_with_free_func(
1791 (GDestroyNotify
) bt_ctf_field_put
);
1792 g_ptr_array_set_size(structure
->fields
,
1793 structure_type
->fields
->len
);
1795 /* Create all fields contained by the structure field. */
1796 for (i
= 0; i
< structure_type
->fields
->len
; i
++) {
1797 struct bt_ctf_field
*field
;
1798 struct structure_field
*field_type
=
1799 g_ptr_array_index(structure_type
->fields
, i
);
1801 field
= bt_ctf_field_create(field_type
->type
);
1803 BT_LOGE("Failed to create structure field's member: name=\"%s\", index=%zu",
1804 g_quark_to_string(field_type
->name
), i
);
1805 bt_ctf_field_structure_destroy(&structure
->parent
);
1809 g_ptr_array_index(structure
->fields
, i
) = field
;
1812 ret
= &structure
->parent
;
1813 BT_LOGD("Created structure field object: addr=%p, ft-addr=%p", ret
,
1820 struct bt_ctf_field
*bt_ctf_field_variant_create(struct bt_ctf_field_type
*type
)
1822 struct bt_ctf_field_variant
*variant
= g_new0(
1823 struct bt_ctf_field_variant
, 1);
1825 BT_LOGD("Creating variant field object: ft-addr=%p", type
);
1828 BT_LOGD("Created variant field object: addr=%p, ft-addr=%p",
1829 &variant
->parent
, type
);
1831 BT_LOGE_STR("Failed to allocate one variant field.");
1834 return variant
? &variant
->parent
: NULL
;
1838 struct bt_ctf_field
*bt_ctf_field_array_create(struct bt_ctf_field_type
*type
)
1840 struct bt_ctf_field_array
*array
= g_new0(struct bt_ctf_field_array
, 1);
1841 struct bt_ctf_field_type_array
*array_type
;
1842 unsigned int array_length
;
1844 BT_LOGD("Creating array field object: ft-addr=%p", type
);
1848 BT_LOGE_STR("Failed to allocate one array field.");
1852 array_type
= container_of(type
, struct bt_ctf_field_type_array
, parent
);
1853 array_length
= array_type
->length
;
1854 array
->elements
= g_ptr_array_sized_new(array_length
);
1855 if (!array
->elements
) {
1859 g_ptr_array_set_free_func(array
->elements
,
1860 (GDestroyNotify
)bt_ctf_field_put
);
1861 g_ptr_array_set_size(array
->elements
, array_length
);
1862 BT_LOGD("Created array field object: addr=%p, ft-addr=%p",
1863 &array
->parent
, type
);
1864 return &array
->parent
;
1871 struct bt_ctf_field
*bt_ctf_field_sequence_create(
1872 struct bt_ctf_field_type
*type
)
1874 struct bt_ctf_field_sequence
*sequence
= g_new0(
1875 struct bt_ctf_field_sequence
, 1);
1877 BT_LOGD("Creating sequence field object: ft-addr=%p", type
);
1880 BT_LOGD("Created sequence field object: addr=%p, ft-addr=%p",
1881 &sequence
->parent
, type
);
1883 BT_LOGE_STR("Failed to allocate one sequence field.");
1886 return sequence
? &sequence
->parent
: NULL
;
1890 struct bt_ctf_field
*bt_ctf_field_string_create(struct bt_ctf_field_type
*type
)
1892 struct bt_ctf_field_string
*string
= g_new0(
1893 struct bt_ctf_field_string
, 1);
1895 BT_LOGD("Creating string field object: ft-addr=%p", type
);
1898 BT_LOGD("Created string field object: addr=%p, ft-addr=%p",
1899 &string
->parent
, type
);
1901 BT_LOGE_STR("Failed to allocate one string field.");
1904 return string
? &string
->parent
: NULL
;
1908 void bt_ctf_field_destroy(struct bt_object
*obj
)
1910 struct bt_ctf_field
*field
;
1911 struct bt_ctf_field_type
*type
;
1912 enum bt_ctf_field_type_id type_id
;
1914 field
= container_of(obj
, struct bt_ctf_field
, base
);
1916 type_id
= bt_ctf_field_type_get_type_id(type
);
1917 assert(type_id
> BT_CTF_FIELD_TYPE_ID_UNKNOWN
&&
1918 type_id
< BT_CTF_NR_TYPE_IDS
);
1919 field_destroy_funcs
[type_id
](field
);
1920 BT_LOGD_STR("Putting field's type.");
1925 void bt_ctf_field_integer_destroy(struct bt_ctf_field
*field
)
1927 struct bt_ctf_field_integer
*integer
;
1933 BT_LOGD("Destroying integer field object: addr=%p", field
);
1934 integer
= container_of(field
, struct bt_ctf_field_integer
, parent
);
1939 void bt_ctf_field_enumeration_destroy(struct bt_ctf_field
*field
)
1941 struct bt_ctf_field_enumeration
*enumeration
;
1947 BT_LOGD("Destroying enumeration field object: addr=%p", field
);
1948 enumeration
= container_of(field
, struct bt_ctf_field_enumeration
,
1950 BT_LOGD_STR("Putting payload field.");
1951 bt_put(enumeration
->payload
);
1952 g_free(enumeration
);
1956 void bt_ctf_field_floating_point_destroy(struct bt_ctf_field
*field
)
1958 struct bt_ctf_field_floating_point
*floating_point
;
1964 BT_LOGD("Destroying floating point number field object: addr=%p", field
);
1965 floating_point
= container_of(field
, struct bt_ctf_field_floating_point
,
1967 g_free(floating_point
);
1971 void bt_ctf_field_structure_destroy(struct bt_ctf_field
*field
)
1973 struct bt_ctf_field_structure
*structure
;
1979 BT_LOGD("Destroying structure field object: addr=%p", field
);
1980 structure
= container_of(field
, struct bt_ctf_field_structure
, parent
);
1981 g_ptr_array_free(structure
->fields
, TRUE
);
1986 void bt_ctf_field_variant_destroy(struct bt_ctf_field
*field
)
1988 struct bt_ctf_field_variant
*variant
;
1994 BT_LOGD("Destroying variant field object: addr=%p", field
);
1995 variant
= container_of(field
, struct bt_ctf_field_variant
, parent
);
1996 BT_LOGD_STR("Putting tag field.");
1997 bt_put(variant
->tag
);
1998 BT_LOGD_STR("Putting payload field.");
1999 bt_put(variant
->payload
);
2004 void bt_ctf_field_array_destroy(struct bt_ctf_field
*field
)
2006 struct bt_ctf_field_array
*array
;
2012 BT_LOGD("Destroying array field object: addr=%p", field
);
2013 array
= container_of(field
, struct bt_ctf_field_array
, parent
);
2014 g_ptr_array_free(array
->elements
, TRUE
);
2019 void bt_ctf_field_sequence_destroy(struct bt_ctf_field
*field
)
2021 struct bt_ctf_field_sequence
*sequence
;
2027 BT_LOGD("Destroying sequence field object: addr=%p", field
);
2028 sequence
= container_of(field
, struct bt_ctf_field_sequence
, parent
);
2029 if (sequence
->elements
) {
2030 g_ptr_array_free(sequence
->elements
, TRUE
);
2032 BT_LOGD_STR("Putting length field.");
2033 bt_put(sequence
->length
);
2038 void bt_ctf_field_string_destroy(struct bt_ctf_field
*field
)
2040 struct bt_ctf_field_string
*string
;
2046 BT_LOGD("Destroying string field object: addr=%p", field
);
2047 string
= container_of(field
, struct bt_ctf_field_string
, parent
);
2048 if (string
->payload
) {
2049 g_string_free(string
->payload
, TRUE
);
2055 int bt_ctf_field_generic_validate(struct bt_ctf_field
*field
)
2057 return (field
&& field
->payload_set
) ? 0 : -1;
2061 int bt_ctf_field_enumeration_validate(struct bt_ctf_field
*field
)
2064 struct bt_ctf_field_enumeration
*enumeration
;
2067 BT_LOGD_STR("Invalid parameter: field is NULL.");
2072 enumeration
= container_of(field
, struct bt_ctf_field_enumeration
,
2074 if (!enumeration
->payload
) {
2075 BT_LOGW("Invalid enumeration field: payload is not set: "
2081 ret
= bt_ctf_field_validate(enumeration
->payload
);
2087 int bt_ctf_field_structure_validate(struct bt_ctf_field
*field
)
2091 struct bt_ctf_field_structure
*structure
;
2094 BT_LOGD_STR("Invalid parameter: field is NULL.");
2099 structure
= container_of(field
, struct bt_ctf_field_structure
, parent
);
2100 for (i
= 0; i
< structure
->fields
->len
; i
++) {
2101 struct bt_ctf_field
*entry_field
= structure
->fields
->pdata
[i
];
2102 ret
= bt_ctf_field_validate(entry_field
);
2107 struct bt_ctf_field_type
*field_type
=
2108 bt_ctf_field_get_type(field
);
2110 this_ret
= bt_ctf_field_type_structure_get_field(
2111 field_type
, &name
, NULL
, i
);
2112 assert(this_ret
== 0);
2113 BT_LOGW("Invalid structure field's field: "
2114 "struct-field-addr=%p, field-addr=%p, "
2115 "field-name=\"%s\", index=%" PRId64
,
2116 field
, entry_field
, name
, i
);
2126 int bt_ctf_field_variant_validate(struct bt_ctf_field
*field
)
2129 struct bt_ctf_field_variant
*variant
;
2132 BT_LOGD_STR("Invalid parameter: field is NULL.");
2137 variant
= container_of(field
, struct bt_ctf_field_variant
, parent
);
2138 ret
= bt_ctf_field_validate(variant
->payload
);
2140 BT_LOGW("Invalid variant field's payload field: "
2141 "variant-field-addr=%p, variant-payload-field-addr=%p",
2142 field
, variant
->payload
);
2149 int bt_ctf_field_array_validate(struct bt_ctf_field
*field
)
2153 struct bt_ctf_field_array
*array
;
2156 BT_LOGD_STR("Invalid parameter: field is NULL.");
2161 array
= container_of(field
, struct bt_ctf_field_array
, parent
);
2162 for (i
= 0; i
< array
->elements
->len
; i
++) {
2163 struct bt_ctf_field
*elem_field
= array
->elements
->pdata
[i
];
2165 ret
= bt_ctf_field_validate(elem_field
);
2167 BT_LOGW("Invalid array field's element field: "
2168 "array-field-addr=%p, field-addr=%p, "
2169 "index=%" PRId64
, field
, elem_field
, i
);
2178 int bt_ctf_field_sequence_validate(struct bt_ctf_field
*field
)
2182 struct bt_ctf_field_sequence
*sequence
;
2185 BT_LOGD_STR("Invalid parameter: field is NULL.");
2190 sequence
= container_of(field
, struct bt_ctf_field_sequence
, parent
);
2191 for (i
= 0; i
< sequence
->elements
->len
; i
++) {
2192 struct bt_ctf_field
*elem_field
= sequence
->elements
->pdata
[i
];
2194 ret
= bt_ctf_field_validate(elem_field
);
2196 BT_LOGW("Invalid sequence field's element field: "
2197 "sequence-field-addr=%p, field-addr=%p, "
2198 "index=%zu", field
, elem_field
, i
);
2207 int bt_ctf_field_generic_reset(struct bt_ctf_field
*field
)
2212 BT_LOGD_STR("Invalid parameter: field is NULL.");
2217 field
->payload_set
= false;
2223 int bt_ctf_field_enumeration_reset(struct bt_ctf_field
*field
)
2226 struct bt_ctf_field_enumeration
*enumeration
;
2229 BT_LOGD_STR("Invalid parameter: field is NULL.");
2234 enumeration
= container_of(field
, struct bt_ctf_field_enumeration
,
2236 if (!enumeration
->payload
) {
2240 ret
= bt_ctf_field_reset(enumeration
->payload
);
2246 int bt_ctf_field_structure_reset(struct bt_ctf_field
*field
)
2250 struct bt_ctf_field_structure
*structure
;
2253 BT_LOGD_STR("Invalid parameter: field is NULL.");
2258 structure
= container_of(field
, struct bt_ctf_field_structure
, parent
);
2259 for (i
= 0; i
< structure
->fields
->len
; i
++) {
2260 struct bt_ctf_field
*member
= structure
->fields
->pdata
[i
];
2264 * Structure members are lazily initialized; skip if
2265 * this member has not been allocated yet.
2270 ret
= bt_ctf_field_reset(member
);
2272 BT_LOGE("Failed to reset structure field's field: "
2273 "struct-field-addr=%p, field-addr=%p, "
2274 "index=%" PRId64
, field
, member
, i
);
2283 int bt_ctf_field_variant_reset(struct bt_ctf_field
*field
)
2286 struct bt_ctf_field_variant
*variant
;
2289 BT_LOGD_STR("Invalid parameter: field is NULL.");
2294 variant
= container_of(field
, struct bt_ctf_field_variant
, parent
);
2295 if (variant
->payload
) {
2296 ret
= bt_ctf_field_reset(variant
->payload
);
2298 BT_LOGW("Failed to reset variant field's payload field: "
2299 "variant-field-addr=%p, payload-field-addr=%p",
2300 field
, variant
->payload
);
2308 int bt_ctf_field_array_reset(struct bt_ctf_field
*field
)
2312 struct bt_ctf_field_array
*array
;
2315 BT_LOGD_STR("Invalid parameter: field is NULL.");
2320 array
= container_of(field
, struct bt_ctf_field_array
, parent
);
2321 for (i
= 0; i
< array
->elements
->len
; i
++) {
2322 struct bt_ctf_field
*member
= array
->elements
->pdata
[i
];
2326 * Array elements are lazily initialized; skip if
2327 * this member has not been allocated yet.
2332 ret
= bt_ctf_field_reset(member
);
2334 BT_LOGE("Failed to reset array field's field: "
2335 "array-field-addr=%p, field-addr=%p, "
2336 "index=%zu", field
, member
, i
);
2345 int bt_ctf_field_sequence_reset(struct bt_ctf_field
*field
)
2349 struct bt_ctf_field_sequence
*sequence
;
2352 BT_LOGD_STR("Invalid parameter: field is NULL.");
2357 sequence
= container_of(field
, struct bt_ctf_field_sequence
, parent
);
2358 for (i
= 0; i
< sequence
->elements
->len
; i
++) {
2359 struct bt_ctf_field
*member
= sequence
->elements
->pdata
[i
];
2363 * Sequence elements are lazily initialized; skip if
2364 * this member has not been allocated yet.
2369 ret
= bt_ctf_field_reset(member
);
2371 BT_LOGE("Failed to reset sequence field's field: "
2372 "sequence-field-addr=%p, field-addr=%p, "
2373 "index=%zu", field
, member
, i
);
2382 int bt_ctf_field_string_reset(struct bt_ctf_field
*field
)
2385 struct bt_ctf_field_string
*string
;
2388 BT_LOGD_STR("Invalid parameter: field is NULL.");
2393 ret
= bt_ctf_field_generic_reset(field
);
2398 string
= container_of(field
, struct bt_ctf_field_string
, parent
);
2399 if (string
->payload
) {
2400 g_string_truncate(string
->payload
, 0);
2407 int bt_ctf_field_integer_serialize(struct bt_ctf_field
*field
,
2408 struct bt_ctf_stream_pos
*pos
,
2409 enum bt_ctf_byte_order native_byte_order
)
2412 struct bt_ctf_field_integer
*integer
= container_of(field
,
2413 struct bt_ctf_field_integer
, parent
);
2415 BT_LOGV("Serializing integer field: addr=%p, pos-offset=%" PRId64
", "
2416 "native-bo=%s", field
, pos
->offset
,
2417 bt_ctf_byte_order_string(native_byte_order
));
2419 if (!bt_ctf_field_generic_is_set(field
)) {
2420 BT_LOGW_STR("Field's payload is not set.");
2425 ret
= bt_ctf_field_integer_write(integer
, pos
, native_byte_order
);
2426 if (ret
== -EFAULT
) {
2428 * The field is too large to fit in the current packet's
2429 * remaining space. Bump the packet size and retry.
2431 ret
= increase_packet_size(pos
);
2433 BT_LOGE("Cannot increase packet size: ret=%d", ret
);
2443 int bt_ctf_field_enumeration_serialize(struct bt_ctf_field
*field
,
2444 struct bt_ctf_stream_pos
*pos
,
2445 enum bt_ctf_byte_order native_byte_order
)
2447 struct bt_ctf_field_enumeration
*enumeration
= container_of(
2448 field
, struct bt_ctf_field_enumeration
, parent
);
2450 BT_LOGV("Serializing enumeration field: addr=%p, pos-offset=%" PRId64
", "
2451 "native-bo=%s", field
, pos
->offset
,
2452 bt_ctf_byte_order_string(native_byte_order
));
2453 BT_LOGV_STR("Serializing enumeration field's payload field.");
2454 return bt_ctf_field_serialize(enumeration
->payload
, pos
,
2459 int bt_ctf_field_floating_point_serialize(struct bt_ctf_field
*field
,
2460 struct bt_ctf_stream_pos
*pos
,
2461 enum bt_ctf_byte_order native_byte_order
)
2464 struct bt_ctf_field_floating_point
*floating_point
= container_of(field
,
2465 struct bt_ctf_field_floating_point
, parent
);
2467 BT_LOGV("Serializing floating point number field: addr=%p, pos-offset=%" PRId64
", "
2468 "native-bo=%s", field
, pos
->offset
,
2469 bt_ctf_byte_order_string(native_byte_order
));
2471 if (!bt_ctf_field_generic_is_set(field
)) {
2472 BT_LOGW_STR("Field's payload is not set.");
2477 ret
= bt_ctf_field_floating_point_write(floating_point
, pos
,
2479 if (ret
== -EFAULT
) {
2481 * The field is too large to fit in the current packet's
2482 * remaining space. Bump the packet size and retry.
2484 ret
= increase_packet_size(pos
);
2486 BT_LOGE("Cannot increase packet size: ret=%d", ret
);
2496 int bt_ctf_field_structure_serialize(struct bt_ctf_field
*field
,
2497 struct bt_ctf_stream_pos
*pos
,
2498 enum bt_ctf_byte_order native_byte_order
)
2502 struct bt_ctf_field_structure
*structure
= container_of(
2503 field
, struct bt_ctf_field_structure
, parent
);
2505 BT_LOGV("Serializing structure field: addr=%p, pos-offset=%" PRId64
", "
2506 "native-bo=%s", field
, pos
->offset
,
2507 bt_ctf_byte_order_string(native_byte_order
));
2509 while (!bt_ctf_stream_pos_access_ok(pos
,
2510 offset_align(pos
->offset
, field
->type
->alignment
))) {
2511 ret
= increase_packet_size(pos
);
2513 BT_LOGE("Cannot increase packet size: ret=%d", ret
);
2518 if (!bt_ctf_stream_pos_align(pos
, field
->type
->alignment
)) {
2519 BT_LOGE("Cannot align packet's position: pos-offset=%" PRId64
", "
2520 "align=%u", pos
->offset
, field
->type
->alignment
);
2525 for (i
= 0; i
< structure
->fields
->len
; i
++) {
2526 struct bt_ctf_field
*member
= g_ptr_array_index(
2527 structure
->fields
, i
);
2528 const char *field_name
= NULL
;
2530 if (BT_LOG_ON_WARN
) {
2531 ret
= bt_ctf_field_type_structure_get_field(
2532 field
->type
, &field_name
, NULL
, i
);
2536 BT_LOGV("Serializing structure field's field: pos-offset=%" PRId64
", "
2537 "field-addr=%p, index=%" PRId64
,
2538 pos
->offset
, member
, i
);
2541 BT_LOGW("Cannot serialize structure field's field: field is not set: "
2542 "struct-field-addr=%p, "
2543 "field-name=\"%s\", index=%" PRId64
,
2544 field
, field_name
, i
);
2549 ret
= bt_ctf_field_serialize(member
, pos
, native_byte_order
);
2551 BT_LOGW("Cannot serialize structure field's field: "
2552 "struct-field-addr=%p, field-addr=%p, "
2553 "field-name=\"%s\", index=%" PRId64
,
2554 field
->type
, member
, field_name
, i
);
2563 int bt_ctf_field_variant_serialize(struct bt_ctf_field
*field
,
2564 struct bt_ctf_stream_pos
*pos
,
2565 enum bt_ctf_byte_order native_byte_order
)
2567 struct bt_ctf_field_variant
*variant
= container_of(
2568 field
, struct bt_ctf_field_variant
, parent
);
2570 BT_LOGV("Serializing variant field: addr=%p, pos-offset=%" PRId64
", "
2571 "native-bo=%s", field
, pos
->offset
,
2572 bt_ctf_byte_order_string(native_byte_order
));
2573 BT_LOGV_STR("Serializing variant field's payload field.");
2574 return bt_ctf_field_serialize(variant
->payload
, pos
,
2579 int bt_ctf_field_array_serialize(struct bt_ctf_field
*field
,
2580 struct bt_ctf_stream_pos
*pos
,
2581 enum bt_ctf_byte_order native_byte_order
)
2585 struct bt_ctf_field_array
*array
= container_of(
2586 field
, struct bt_ctf_field_array
, parent
);
2588 BT_LOGV("Serializing array field: addr=%p, pos-offset=%" PRId64
", "
2589 "native-bo=%s", field
, pos
->offset
,
2590 bt_ctf_byte_order_string(native_byte_order
));
2592 for (i
= 0; i
< array
->elements
->len
; i
++) {
2593 struct bt_ctf_field
*elem_field
=
2594 g_ptr_array_index(array
->elements
, i
);
2596 BT_LOGV("Serializing array field's element field: "
2597 "pos-offset=%" PRId64
", field-addr=%p, index=%" PRId64
,
2598 pos
->offset
, elem_field
, i
);
2599 ret
= bt_ctf_field_serialize(elem_field
, pos
,
2602 BT_LOGW("Cannot serialize array field's element field: "
2603 "array-field-addr=%p, field-addr=%p, "
2604 "index=%" PRId64
, field
, elem_field
, i
);
2613 int bt_ctf_field_sequence_serialize(struct bt_ctf_field
*field
,
2614 struct bt_ctf_stream_pos
*pos
,
2615 enum bt_ctf_byte_order native_byte_order
)
2619 struct bt_ctf_field_sequence
*sequence
= container_of(
2620 field
, struct bt_ctf_field_sequence
, parent
);
2622 BT_LOGV("Serializing sequence field: addr=%p, pos-offset=%" PRId64
", "
2623 "native-bo=%s", field
, pos
->offset
,
2624 bt_ctf_byte_order_string(native_byte_order
));
2626 for (i
= 0; i
< sequence
->elements
->len
; i
++) {
2627 struct bt_ctf_field
*elem_field
=
2628 g_ptr_array_index(sequence
->elements
, i
);
2630 BT_LOGV("Serializing sequence field's element field: "
2631 "pos-offset=%" PRId64
", field-addr=%p, index=%" PRId64
,
2632 pos
->offset
, elem_field
, i
);
2633 ret
= bt_ctf_field_serialize(elem_field
, pos
,
2636 BT_LOGW("Cannot serialize sequence field's element field: "
2637 "sequence-field-addr=%p, field-addr=%p, "
2638 "index=%" PRId64
, field
, elem_field
, i
);
2647 int bt_ctf_field_string_serialize(struct bt_ctf_field
*field
,
2648 struct bt_ctf_stream_pos
*pos
,
2649 enum bt_ctf_byte_order native_byte_order
)
2653 struct bt_ctf_field_string
*string
= container_of(field
,
2654 struct bt_ctf_field_string
, parent
);
2655 struct bt_ctf_field_type
*character_type
=
2656 get_field_type(FIELD_TYPE_ALIAS_UINT8_T
);
2657 struct bt_ctf_field
*character
;
2659 BT_LOGV("Serializing string field: addr=%p, pos-offset=%" PRId64
", "
2660 "native-bo=%s", field
, pos
->offset
,
2661 bt_ctf_byte_order_string(native_byte_order
));
2663 BT_LOGV_STR("Creating character field from string field's character field type.");
2664 character
= bt_ctf_field_create(character_type
);
2666 for (i
= 0; i
< string
->payload
->len
+ 1; i
++) {
2667 const uint64_t chr
= (uint64_t) string
->payload
->str
[i
];
2669 ret
= bt_ctf_field_unsigned_integer_set_value(character
, chr
);
2671 BT_LOGW("Cannot set character field's value: "
2672 "pos-offset=%" PRId64
", field-addr=%p, "
2673 "index=%" PRId64
", char-int=%" PRIu64
,
2674 pos
->offset
, character
, i
, chr
);
2678 BT_LOGV("Serializing string field's character field: "
2679 "pos-offset=%" PRId64
", field-addr=%p, "
2680 "index=%" PRId64
", char-int=%" PRIu64
,
2681 pos
->offset
, character
, i
, chr
);
2682 ret
= bt_ctf_field_integer_serialize(character
, pos
,
2685 BT_LOGW_STR("Cannot serialize character field.");
2691 bt_put(character_type
);
2696 int bt_ctf_field_integer_copy(struct bt_ctf_field
*src
,
2697 struct bt_ctf_field
*dst
)
2699 struct bt_ctf_field_integer
*integer_src
, *integer_dst
;
2701 BT_LOGD("Copying integer field: src-field-addr=%p, dst-field-addr=%p",
2703 integer_src
= container_of(src
, struct bt_ctf_field_integer
, parent
);
2704 integer_dst
= container_of(dst
, struct bt_ctf_field_integer
, parent
);
2705 integer_dst
->payload
= integer_src
->payload
;
2706 BT_LOGD_STR("Copied integer field.");
2711 int bt_ctf_field_enumeration_copy(struct bt_ctf_field
*src
,
2712 struct bt_ctf_field
*dst
)
2715 struct bt_ctf_field_enumeration
*enum_src
, *enum_dst
;
2717 BT_LOGD("Copying enumeration field: src-field-addr=%p, dst-field-addr=%p",
2719 enum_src
= container_of(src
, struct bt_ctf_field_enumeration
, parent
);
2720 enum_dst
= container_of(dst
, struct bt_ctf_field_enumeration
, parent
);
2722 if (enum_src
->payload
) {
2723 BT_LOGD_STR("Copying enumeration field's payload field.");
2724 enum_dst
->payload
= bt_ctf_field_copy(enum_src
->payload
);
2725 if (!enum_dst
->payload
) {
2726 BT_LOGE_STR("Cannot copy enumeration field's payload field.");
2732 BT_LOGD_STR("Copied enumeration field.");
2738 int bt_ctf_field_floating_point_copy(
2739 struct bt_ctf_field
*src
, struct bt_ctf_field
*dst
)
2741 struct bt_ctf_field_floating_point
*float_src
, *float_dst
;
2743 BT_LOGD("Copying floating point number field: src-field-addr=%p, dst-field-addr=%p",
2745 float_src
= container_of(src
, struct bt_ctf_field_floating_point
,
2747 float_dst
= container_of(dst
, struct bt_ctf_field_floating_point
,
2749 float_dst
->payload
= float_src
->payload
;
2750 BT_LOGD_STR("Copied floating point number field.");
2755 int bt_ctf_field_structure_copy(struct bt_ctf_field
*src
,
2756 struct bt_ctf_field
*dst
)
2760 struct bt_ctf_field_structure
*struct_src
, *struct_dst
;
2762 BT_LOGD("Copying structure field: src-field-addr=%p, dst-field-addr=%p",
2764 struct_src
= container_of(src
, struct bt_ctf_field_structure
, parent
);
2765 struct_dst
= container_of(dst
, struct bt_ctf_field_structure
, parent
);
2767 g_ptr_array_set_size(struct_dst
->fields
, struct_src
->fields
->len
);
2769 for (i
= 0; i
< struct_src
->fields
->len
; i
++) {
2770 struct bt_ctf_field
*field
=
2771 g_ptr_array_index(struct_src
->fields
, i
);
2772 struct bt_ctf_field
*field_copy
= NULL
;
2775 BT_LOGD("Copying structure field's field: src-field-addr=%p"
2776 "index=%" PRId64
, field
, i
);
2777 field_copy
= bt_ctf_field_copy(field
);
2779 BT_LOGE("Cannot copy structure field's field: "
2780 "src-field-addr=%p, index=%" PRId64
,
2787 BT_MOVE(g_ptr_array_index(struct_dst
->fields
, i
), field_copy
);
2790 BT_LOGD_STR("Copied structure field.");
2797 int bt_ctf_field_variant_copy(struct bt_ctf_field
*src
,
2798 struct bt_ctf_field
*dst
)
2801 struct bt_ctf_field_variant
*variant_src
, *variant_dst
;
2803 BT_LOGD("Copying variant field: src-field-addr=%p, dst-field-addr=%p",
2805 variant_src
= container_of(src
, struct bt_ctf_field_variant
, parent
);
2806 variant_dst
= container_of(dst
, struct bt_ctf_field_variant
, parent
);
2808 if (variant_src
->tag
) {
2809 BT_LOGD_STR("Copying variant field's tag field.");
2810 variant_dst
->tag
= bt_ctf_field_copy(variant_src
->tag
);
2811 if (!variant_dst
->tag
) {
2812 BT_LOGE_STR("Cannot copy variant field's tag field.");
2817 if (variant_src
->payload
) {
2818 BT_LOGD_STR("Copying variant field's payload field.");
2819 variant_dst
->payload
= bt_ctf_field_copy(variant_src
->payload
);
2820 if (!variant_dst
->payload
) {
2821 BT_LOGE_STR("Cannot copy variant field's payload field.");
2827 BT_LOGD_STR("Copied variant field.");
2834 int bt_ctf_field_array_copy(struct bt_ctf_field
*src
,
2835 struct bt_ctf_field
*dst
)
2839 struct bt_ctf_field_array
*array_src
, *array_dst
;
2841 BT_LOGD("Copying array field: src-field-addr=%p, dst-field-addr=%p",
2843 array_src
= container_of(src
, struct bt_ctf_field_array
, parent
);
2844 array_dst
= container_of(dst
, struct bt_ctf_field_array
, parent
);
2846 g_ptr_array_set_size(array_dst
->elements
, array_src
->elements
->len
);
2847 for (i
= 0; i
< array_src
->elements
->len
; i
++) {
2848 struct bt_ctf_field
*field
=
2849 g_ptr_array_index(array_src
->elements
, i
);
2850 struct bt_ctf_field
*field_copy
= NULL
;
2853 BT_LOGD("Copying array field's element field: field-addr=%p, "
2854 "index=%" PRId64
, field
, i
);
2855 field_copy
= bt_ctf_field_copy(field
);
2857 BT_LOGE("Cannot copy array field's element field: "
2858 "src-field-addr=%p, index=%" PRId64
,
2865 g_ptr_array_index(array_dst
->elements
, i
) = field_copy
;
2868 BT_LOGD_STR("Copied array field.");
2875 int bt_ctf_field_sequence_copy(struct bt_ctf_field
*src
,
2876 struct bt_ctf_field
*dst
)
2880 struct bt_ctf_field_sequence
*sequence_src
, *sequence_dst
;
2881 struct bt_ctf_field
*src_length
;
2882 struct bt_ctf_field
*dst_length
;
2884 BT_LOGD("Copying sequence field: src-field-addr=%p, dst-field-addr=%p",
2886 sequence_src
= container_of(src
, struct bt_ctf_field_sequence
, parent
);
2887 sequence_dst
= container_of(dst
, struct bt_ctf_field_sequence
, parent
);
2889 src_length
= bt_ctf_field_sequence_get_length(src
);
2891 /* no length set yet: keep destination sequence empty */
2895 /* copy source length */
2896 BT_LOGD_STR("Copying sequence field's length field.");
2897 dst_length
= bt_ctf_field_copy(src_length
);
2900 BT_LOGE_STR("Cannot copy sequence field's length field.");
2905 /* this will initialize the destination sequence's internal array */
2906 ret
= bt_ctf_field_sequence_set_length(dst
, dst_length
);
2909 BT_LOGE("Cannot set sequence field copy's length field: "
2910 "dst-length-field-addr=%p", dst_length
);
2915 assert(sequence_dst
->elements
->len
== sequence_src
->elements
->len
);
2917 for (i
= 0; i
< sequence_src
->elements
->len
; i
++) {
2918 struct bt_ctf_field
*field
=
2919 g_ptr_array_index(sequence_src
->elements
, i
);
2920 struct bt_ctf_field
*field_copy
= NULL
;
2923 BT_LOGD("Copying sequence field's element field: field-addr=%p, "
2924 "index=%" PRId64
, field
, i
);
2925 field_copy
= bt_ctf_field_copy(field
);
2927 BT_LOGE("Cannot copy sequence field's element field: "
2928 "src-field-addr=%p, index=%" PRId64
,
2935 g_ptr_array_index(sequence_dst
->elements
, i
) = field_copy
;
2938 BT_LOGD_STR("Copied sequence field.");
2945 int bt_ctf_field_string_copy(struct bt_ctf_field
*src
,
2946 struct bt_ctf_field
*dst
)
2949 struct bt_ctf_field_string
*string_src
, *string_dst
;
2951 BT_LOGD("Copying string field: src-field-addr=%p, dst-field-addr=%p",
2953 string_src
= container_of(src
, struct bt_ctf_field_string
, parent
);
2954 string_dst
= container_of(dst
, struct bt_ctf_field_string
, parent
);
2956 if (string_src
->payload
) {
2957 string_dst
->payload
= g_string_new(string_src
->payload
->str
);
2958 if (!string_dst
->payload
) {
2959 BT_LOGE_STR("Failed to allocate a GString.");
2965 BT_LOGD_STR("Copied string field.");
2972 int increase_packet_size(struct bt_ctf_stream_pos
*pos
)
2977 BT_LOGV("Increasing packet size: pos-offset=%" PRId64
", "
2978 "cur-packet-size=%" PRIu64
,
2979 pos
->offset
, pos
->packet_size
);
2980 ret
= munmap_align(pos
->base_mma
);
2982 BT_LOGE_ERRNO("Failed to perform an aligned memory unmapping",
2987 pos
->packet_size
+= PACKET_LEN_INCREMENT
;
2989 ret
= bt_posix_fallocate(pos
->fd
, pos
->mmap_offset
,
2990 pos
->packet_size
/ CHAR_BIT
);
2991 } while (ret
== EINTR
);
2993 BT_LOGE_ERRNO("Failed to preallocate memory space",
3000 pos
->base_mma
= mmap_align(pos
->packet_size
/ CHAR_BIT
, pos
->prot
,
3001 pos
->flags
, pos
->fd
, pos
->mmap_offset
);
3002 if (pos
->base_mma
== MAP_FAILED
) {
3003 BT_LOGE_ERRNO("Failed to perform an aligned memory mapping",
3008 BT_LOGV("Increased packet size: pos-offset=%" PRId64
", "
3009 "new-packet-size=%" PRIu64
,
3010 pos
->offset
, pos
->packet_size
);
3011 assert(pos
->packet_size
% 8 == 0);
3018 void generic_field_freeze(struct bt_ctf_field
*field
)
3020 field
->frozen
= true;
3024 void bt_ctf_field_enumeration_freeze(struct bt_ctf_field
*field
)
3026 struct bt_ctf_field_enumeration
*enum_field
=
3027 container_of(field
, struct bt_ctf_field_enumeration
, parent
);
3029 BT_LOGD("Freezing enumeration field object: addr=%p", field
);
3030 BT_LOGD("Freezing enumeration field object's contained payload field: payload-field-addr=%p", enum_field
->payload
);
3031 bt_ctf_field_freeze(enum_field
->payload
);
3032 generic_field_freeze(field
);
3036 void bt_ctf_field_structure_freeze(struct bt_ctf_field
*field
)
3039 struct bt_ctf_field_structure
*structure_field
=
3040 container_of(field
, struct bt_ctf_field_structure
, parent
);
3042 BT_LOGD("Freezing structure field object: addr=%p", field
);
3044 for (i
= 0; i
< structure_field
->fields
->len
; i
++) {
3045 struct bt_ctf_field
*field
=
3046 g_ptr_array_index(structure_field
->fields
, i
);
3048 BT_LOGD("Freezing structure field's field: field-addr=%p, index=%" PRId64
,
3050 bt_ctf_field_freeze(field
);
3053 generic_field_freeze(field
);
3057 void bt_ctf_field_variant_freeze(struct bt_ctf_field
*field
)
3059 struct bt_ctf_field_variant
*variant_field
=
3060 container_of(field
, struct bt_ctf_field_variant
, parent
);
3062 BT_LOGD("Freezing variant field object: addr=%p", field
);
3063 BT_LOGD("Freezing variant field object's tag field: tag-field-addr=%p", variant_field
->tag
);
3064 bt_ctf_field_freeze(variant_field
->tag
);
3065 BT_LOGD("Freezing variant field object's payload field: payload-field-addr=%p", variant_field
->payload
);
3066 bt_ctf_field_freeze(variant_field
->payload
);
3067 generic_field_freeze(field
);
3071 void bt_ctf_field_array_freeze(struct bt_ctf_field
*field
)
3074 struct bt_ctf_field_array
*array_field
=
3075 container_of(field
, struct bt_ctf_field_array
, parent
);
3077 BT_LOGD("Freezing array field object: addr=%p", field
);
3079 for (i
= 0; i
< array_field
->elements
->len
; i
++) {
3080 struct bt_ctf_field
*elem_field
=
3081 g_ptr_array_index(array_field
->elements
, i
);
3083 BT_LOGD("Freezing array field object's element field: "
3084 "element-field-addr=%p, index=%" PRId64
,
3086 bt_ctf_field_freeze(elem_field
);
3089 generic_field_freeze(field
);
3093 void bt_ctf_field_sequence_freeze(struct bt_ctf_field
*field
)
3096 struct bt_ctf_field_sequence
*sequence_field
=
3097 container_of(field
, struct bt_ctf_field_sequence
, parent
);
3099 BT_LOGD("Freezing sequence field object: addr=%p", field
);
3100 BT_LOGD("Freezing sequence field object's length field: length-field-addr=%p",
3101 sequence_field
->length
);
3102 bt_ctf_field_freeze(sequence_field
->length
);
3104 for (i
= 0; i
< sequence_field
->elements
->len
; i
++) {
3105 struct bt_ctf_field
*elem_field
=
3106 g_ptr_array_index(sequence_field
->elements
, i
);
3108 BT_LOGD("Freezing sequence field object's element field: "
3109 "element-field-addr=%p, index=%" PRId64
,
3111 bt_ctf_field_freeze(elem_field
);
3114 generic_field_freeze(field
);
3118 void bt_ctf_field_freeze(struct bt_ctf_field
*field
)
3120 enum bt_ctf_field_type_id type_id
;
3126 if (field
->frozen
) {
3130 BT_LOGD("Freezing field object: addr=%p", field
);
3131 type_id
= bt_ctf_field_get_type_id(field
);
3132 assert(type_id
> BT_CTF_FIELD_TYPE_ID_UNKNOWN
&&
3133 type_id
< BT_CTF_NR_TYPE_IDS
);
3134 field_freeze_funcs
[type_id
](field
);
3140 bt_bool
bt_ctf_field_generic_is_set(struct bt_ctf_field
*field
)
3142 return field
&& field
->payload_set
;
3146 bt_bool
bt_ctf_field_enumeration_is_set(struct bt_ctf_field
*field
)
3148 bt_bool is_set
= BT_FALSE
;
3149 struct bt_ctf_field_enumeration
*enumeration
;
3155 enumeration
= container_of(field
, struct bt_ctf_field_enumeration
,
3157 if (!enumeration
->payload
) {
3161 is_set
= bt_ctf_field_is_set(enumeration
->payload
);
3167 bt_bool
bt_ctf_field_structure_is_set(struct bt_ctf_field
*field
)
3169 bt_bool is_set
= BT_FALSE
;
3171 struct bt_ctf_field_structure
*structure
;
3177 structure
= container_of(field
, struct bt_ctf_field_structure
, parent
);
3178 for (i
= 0; i
< structure
->fields
->len
; i
++) {
3179 is_set
= bt_ctf_field_is_set(structure
->fields
->pdata
[i
]);
3189 bt_bool
bt_ctf_field_variant_is_set(struct bt_ctf_field
*field
)
3191 bt_bool is_set
= BT_FALSE
;
3192 struct bt_ctf_field_variant
*variant
;
3198 variant
= container_of(field
, struct bt_ctf_field_variant
, parent
);
3199 is_set
= bt_ctf_field_is_set(variant
->payload
);
3205 bt_bool
bt_ctf_field_array_is_set(struct bt_ctf_field
*field
)
3208 bt_bool is_set
= BT_FALSE
;
3209 struct bt_ctf_field_array
*array
;
3215 array
= container_of(field
, struct bt_ctf_field_array
, parent
);
3216 for (i
= 0; i
< array
->elements
->len
; i
++) {
3217 is_set
= bt_ctf_field_is_set(array
->elements
->pdata
[i
]);
3227 bt_bool
bt_ctf_field_sequence_is_set(struct bt_ctf_field
*field
)
3230 bt_bool is_set
= BT_FALSE
;
3231 struct bt_ctf_field_sequence
*sequence
;
3237 sequence
= container_of(field
, struct bt_ctf_field_sequence
, parent
);
3238 for (i
= 0; i
< sequence
->elements
->len
; i
++) {
3239 is_set
= bt_ctf_field_validate(sequence
->elements
->pdata
[i
]);