ctf.fs: bt_ctf_notif_iter_create(): assert() that all medops exist
[babeltrace.git] / formats / ctf / ir / fields.c
1 /*
2 * fields.c
3 *
4 * Babeltrace CTF IR - Event Fields
5 *
6 * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
7 *
8 * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
9 *
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:
16 *
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
19 *
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
26 * SOFTWARE.
27 */
28
29 #include <babeltrace/ctf-ir/fields-internal.h>
30 #include <babeltrace/ctf-ir/field-types-internal.h>
31 #include <babeltrace/object-internal.h>
32 #include <babeltrace/ref.h>
33 #include <babeltrace/compiler.h>
34 #include <babeltrace/compat/fcntl.h>
35
36 #define PACKET_LEN_INCREMENT (getpagesize() * 8 * CHAR_BIT)
37
38 static
39 struct bt_ctf_field *bt_ctf_field_integer_create(struct bt_ctf_field_type *);
40 static
41 struct bt_ctf_field *bt_ctf_field_enumeration_create(
42 struct bt_ctf_field_type *);
43 static
44 struct bt_ctf_field *bt_ctf_field_floating_point_create(
45 struct bt_ctf_field_type *);
46 static
47 struct bt_ctf_field *bt_ctf_field_structure_create(
48 struct bt_ctf_field_type *);
49 static
50 struct bt_ctf_field *bt_ctf_field_variant_create(
51 struct bt_ctf_field_type *);
52 static
53 struct bt_ctf_field *bt_ctf_field_array_create(
54 struct bt_ctf_field_type *);
55 static
56 struct bt_ctf_field *bt_ctf_field_sequence_create(
57 struct bt_ctf_field_type *);
58 static
59 struct bt_ctf_field *bt_ctf_field_string_create(struct bt_ctf_field_type *);
60
61 static
62 void bt_ctf_field_destroy(struct bt_object *);
63 static
64 void bt_ctf_field_integer_destroy(struct bt_ctf_field *);
65 static
66 void bt_ctf_field_enumeration_destroy(struct bt_ctf_field *);
67 static
68 void bt_ctf_field_floating_point_destroy(struct bt_ctf_field *);
69 static
70 void bt_ctf_field_structure_destroy(struct bt_ctf_field *);
71 static
72 void bt_ctf_field_variant_destroy(struct bt_ctf_field *);
73 static
74 void bt_ctf_field_array_destroy(struct bt_ctf_field *);
75 static
76 void bt_ctf_field_sequence_destroy(struct bt_ctf_field *);
77 static
78 void bt_ctf_field_string_destroy(struct bt_ctf_field *);
79
80 static
81 int bt_ctf_field_generic_validate(struct bt_ctf_field *);
82 static
83 int bt_ctf_field_structure_validate(struct bt_ctf_field *);
84 static
85 int bt_ctf_field_variant_validate(struct bt_ctf_field *);
86 static
87 int bt_ctf_field_enumeration_validate(struct bt_ctf_field *);
88 static
89 int bt_ctf_field_array_validate(struct bt_ctf_field *);
90 static
91 int bt_ctf_field_sequence_validate(struct bt_ctf_field *);
92
93 static
94 int bt_ctf_field_generic_reset(struct bt_ctf_field *);
95 static
96 int bt_ctf_field_structure_reset(struct bt_ctf_field *);
97 static
98 int bt_ctf_field_variant_reset(struct bt_ctf_field *);
99 static
100 int bt_ctf_field_enumeration_reset(struct bt_ctf_field *);
101 static
102 int bt_ctf_field_array_reset(struct bt_ctf_field *);
103 static
104 int bt_ctf_field_sequence_reset(struct bt_ctf_field *);
105 static
106 int bt_ctf_field_string_reset(struct bt_ctf_field *);
107
108 static
109 int bt_ctf_field_integer_serialize(struct bt_ctf_field *,
110 struct ctf_stream_pos *);
111 static
112 int bt_ctf_field_enumeration_serialize(struct bt_ctf_field *,
113 struct ctf_stream_pos *);
114 static
115 int bt_ctf_field_floating_point_serialize(struct bt_ctf_field *,
116 struct ctf_stream_pos *);
117 static
118 int bt_ctf_field_structure_serialize(struct bt_ctf_field *,
119 struct ctf_stream_pos *);
120 static
121 int bt_ctf_field_variant_serialize(struct bt_ctf_field *,
122 struct ctf_stream_pos *);
123 static
124 int bt_ctf_field_array_serialize(struct bt_ctf_field *,
125 struct ctf_stream_pos *);
126 static
127 int bt_ctf_field_sequence_serialize(struct bt_ctf_field *,
128 struct ctf_stream_pos *);
129 static
130 int bt_ctf_field_string_serialize(struct bt_ctf_field *,
131 struct ctf_stream_pos *);
132
133 static
134 int bt_ctf_field_integer_copy(struct bt_ctf_field *, struct bt_ctf_field *);
135 static
136 int bt_ctf_field_enumeration_copy(struct bt_ctf_field *, struct bt_ctf_field *);
137 static
138 int bt_ctf_field_floating_point_copy(struct bt_ctf_field *,
139 struct bt_ctf_field *);
140 static
141 int bt_ctf_field_structure_copy(struct bt_ctf_field *, struct bt_ctf_field *);
142 static
143 int bt_ctf_field_variant_copy(struct bt_ctf_field *, struct bt_ctf_field *);
144 static
145 int bt_ctf_field_array_copy(struct bt_ctf_field *, struct bt_ctf_field *);
146 static
147 int bt_ctf_field_sequence_copy(struct bt_ctf_field *, struct bt_ctf_field *);
148 static
149 int bt_ctf_field_string_copy(struct bt_ctf_field *, struct bt_ctf_field *);
150
151 static
152 void generic_field_freeze(struct bt_ctf_field *);
153 static
154 void bt_ctf_field_enumeration_freeze(struct bt_ctf_field *);
155 static
156 void bt_ctf_field_structure_freeze(struct bt_ctf_field *);
157 static
158 void bt_ctf_field_variant_freeze(struct bt_ctf_field *);
159 static
160 void bt_ctf_field_array_freeze(struct bt_ctf_field *);
161 static
162 void bt_ctf_field_sequence_freeze(struct bt_ctf_field *);
163
164 static
165 bool bt_ctf_field_generic_is_set(struct bt_ctf_field *);
166 static
167 bool bt_ctf_field_structure_is_set(struct bt_ctf_field *);
168 static
169 bool bt_ctf_field_variant_is_set(struct bt_ctf_field *);
170 static
171 bool bt_ctf_field_enumeration_is_set(struct bt_ctf_field *);
172 static
173 bool bt_ctf_field_array_is_set(struct bt_ctf_field *);
174 static
175 bool bt_ctf_field_sequence_is_set(struct bt_ctf_field *);
176
177 static
178 int increase_packet_size(struct ctf_stream_pos *pos);
179
180 static
181 struct bt_ctf_field *(* const field_create_funcs[])(
182 struct bt_ctf_field_type *) = {
183 [BT_CTF_TYPE_ID_INTEGER] = bt_ctf_field_integer_create,
184 [BT_CTF_TYPE_ID_ENUM] = bt_ctf_field_enumeration_create,
185 [BT_CTF_TYPE_ID_FLOAT] =
186 bt_ctf_field_floating_point_create,
187 [BT_CTF_TYPE_ID_STRUCT] = bt_ctf_field_structure_create,
188 [BT_CTF_TYPE_ID_VARIANT] = bt_ctf_field_variant_create,
189 [BT_CTF_TYPE_ID_ARRAY] = bt_ctf_field_array_create,
190 [BT_CTF_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_create,
191 [BT_CTF_TYPE_ID_STRING] = bt_ctf_field_string_create,
192 };
193
194 static
195 void (* const field_destroy_funcs[])(struct bt_ctf_field *) = {
196 [BT_CTF_TYPE_ID_INTEGER] = bt_ctf_field_integer_destroy,
197 [BT_CTF_TYPE_ID_ENUM] = bt_ctf_field_enumeration_destroy,
198 [BT_CTF_TYPE_ID_FLOAT] =
199 bt_ctf_field_floating_point_destroy,
200 [BT_CTF_TYPE_ID_STRUCT] = bt_ctf_field_structure_destroy,
201 [BT_CTF_TYPE_ID_VARIANT] = bt_ctf_field_variant_destroy,
202 [BT_CTF_TYPE_ID_ARRAY] = bt_ctf_field_array_destroy,
203 [BT_CTF_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_destroy,
204 [BT_CTF_TYPE_ID_STRING] = bt_ctf_field_string_destroy,
205 };
206
207 static
208 int (* const field_validate_funcs[])(struct bt_ctf_field *) = {
209 [BT_CTF_TYPE_ID_INTEGER] = bt_ctf_field_generic_validate,
210 [BT_CTF_TYPE_ID_ENUM] = bt_ctf_field_enumeration_validate,
211 [BT_CTF_TYPE_ID_FLOAT] = bt_ctf_field_generic_validate,
212 [BT_CTF_TYPE_ID_STRUCT] = bt_ctf_field_structure_validate,
213 [BT_CTF_TYPE_ID_VARIANT] = bt_ctf_field_variant_validate,
214 [BT_CTF_TYPE_ID_ARRAY] = bt_ctf_field_array_validate,
215 [BT_CTF_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_validate,
216 [BT_CTF_TYPE_ID_STRING] = bt_ctf_field_generic_validate,
217 };
218
219 static
220 int (* const field_reset_funcs[])(struct bt_ctf_field *) = {
221 [BT_CTF_TYPE_ID_INTEGER] = bt_ctf_field_generic_reset,
222 [BT_CTF_TYPE_ID_ENUM] = bt_ctf_field_enumeration_reset,
223 [BT_CTF_TYPE_ID_FLOAT] = bt_ctf_field_generic_reset,
224 [BT_CTF_TYPE_ID_STRUCT] = bt_ctf_field_structure_reset,
225 [BT_CTF_TYPE_ID_VARIANT] = bt_ctf_field_variant_reset,
226 [BT_CTF_TYPE_ID_ARRAY] = bt_ctf_field_array_reset,
227 [BT_CTF_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_reset,
228 [BT_CTF_TYPE_ID_STRING] = bt_ctf_field_string_reset,
229 };
230
231 static
232 int (* const field_serialize_funcs[])(struct bt_ctf_field *,
233 struct ctf_stream_pos *) = {
234 [BT_CTF_TYPE_ID_INTEGER] = bt_ctf_field_integer_serialize,
235 [BT_CTF_TYPE_ID_ENUM] = bt_ctf_field_enumeration_serialize,
236 [BT_CTF_TYPE_ID_FLOAT] =
237 bt_ctf_field_floating_point_serialize,
238 [BT_CTF_TYPE_ID_STRUCT] = bt_ctf_field_structure_serialize,
239 [BT_CTF_TYPE_ID_VARIANT] = bt_ctf_field_variant_serialize,
240 [BT_CTF_TYPE_ID_ARRAY] = bt_ctf_field_array_serialize,
241 [BT_CTF_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_serialize,
242 [BT_CTF_TYPE_ID_STRING] = bt_ctf_field_string_serialize,
243 };
244
245 static
246 int (* const field_copy_funcs[])(struct bt_ctf_field *,
247 struct bt_ctf_field *) = {
248 [BT_CTF_TYPE_ID_INTEGER] = bt_ctf_field_integer_copy,
249 [BT_CTF_TYPE_ID_ENUM] = bt_ctf_field_enumeration_copy,
250 [BT_CTF_TYPE_ID_FLOAT] = bt_ctf_field_floating_point_copy,
251 [BT_CTF_TYPE_ID_STRUCT] = bt_ctf_field_structure_copy,
252 [BT_CTF_TYPE_ID_VARIANT] = bt_ctf_field_variant_copy,
253 [BT_CTF_TYPE_ID_ARRAY] = bt_ctf_field_array_copy,
254 [BT_CTF_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_copy,
255 [BT_CTF_TYPE_ID_STRING] = bt_ctf_field_string_copy,
256 };
257
258 static
259 void (* const field_freeze_funcs[])(struct bt_ctf_field *) = {
260 [BT_CTF_TYPE_ID_INTEGER] = generic_field_freeze,
261 [BT_CTF_TYPE_ID_FLOAT] = generic_field_freeze,
262 [BT_CTF_TYPE_ID_STRING] = generic_field_freeze,
263 [BT_CTF_TYPE_ID_ENUM] = bt_ctf_field_enumeration_freeze,
264 [BT_CTF_TYPE_ID_STRUCT] = bt_ctf_field_structure_freeze,
265 [BT_CTF_TYPE_ID_VARIANT] = bt_ctf_field_variant_freeze,
266 [BT_CTF_TYPE_ID_ARRAY] = bt_ctf_field_array_freeze,
267 [BT_CTF_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_freeze,
268 };
269
270 static
271 bool (* const field_is_set_funcs[])(struct bt_ctf_field *) = {
272 [BT_CTF_TYPE_ID_INTEGER] = bt_ctf_field_generic_is_set,
273 [BT_CTF_TYPE_ID_ENUM] = bt_ctf_field_enumeration_is_set,
274 [BT_CTF_TYPE_ID_FLOAT] = bt_ctf_field_generic_is_set,
275 [BT_CTF_TYPE_ID_STRUCT] = bt_ctf_field_structure_is_set,
276 [BT_CTF_TYPE_ID_VARIANT] = bt_ctf_field_variant_is_set,
277 [BT_CTF_TYPE_ID_ARRAY] = bt_ctf_field_array_is_set,
278 [BT_CTF_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_is_set,
279 [BT_CTF_TYPE_ID_STRING] = bt_ctf_field_generic_is_set,
280 };
281
282 struct bt_ctf_field *bt_ctf_field_create(struct bt_ctf_field_type *type)
283 {
284 struct bt_ctf_field *field = NULL;
285 enum bt_ctf_type_id type_id;
286 int ret;
287
288 if (!type) {
289 goto error;
290 }
291
292 type_id = bt_ctf_field_type_get_type_id(type);
293 if (type_id <= BT_CTF_TYPE_ID_UNKNOWN ||
294 type_id >= BT_CTF_NR_TYPE_IDS) {
295 goto error;
296 }
297
298 /* Field class MUST be valid */
299 ret = bt_ctf_field_type_validate(type);
300
301 if (ret) {
302 /* Invalid */
303 goto error;
304 }
305
306 field = field_create_funcs[type_id](type);
307 if (!field) {
308 goto error;
309 }
310
311 /* The type's declaration can't change after this point */
312 bt_ctf_field_type_freeze(type);
313 bt_get(type);
314 bt_object_init(field, bt_ctf_field_destroy);
315 field->type = type;
316 error:
317 return field;
318 }
319
320 void bt_ctf_field_get(struct bt_ctf_field *field)
321 {
322 bt_get(field);
323 }
324
325 void bt_ctf_field_put(struct bt_ctf_field *field)
326 {
327 bt_put(field);
328 }
329
330 struct bt_ctf_field_type *bt_ctf_field_get_type(struct bt_ctf_field *field)
331 {
332 struct bt_ctf_field_type *ret = NULL;
333
334 if (!field) {
335 goto end;
336 }
337
338 ret = field->type;
339 bt_get(ret);
340 end:
341 return ret;
342 }
343
344 enum bt_ctf_type_id bt_ctf_field_get_type_id(struct bt_ctf_field *field)
345 {
346 enum bt_ctf_type_id ret = BT_CTF_TYPE_ID_UNKNOWN;
347
348 if (!field) {
349 goto end;
350 }
351
352 ret = bt_ctf_field_type_get_type_id(field->type);
353 end:
354 return ret;
355 }
356
357 int bt_ctf_field_is_integer(struct bt_ctf_field *field)
358 {
359 return bt_ctf_field_get_type_id(field) == BT_CTF_TYPE_ID_INTEGER;
360 }
361
362 int bt_ctf_field_is_floating_point(struct bt_ctf_field *field)
363 {
364 return bt_ctf_field_get_type_id(field) == BT_CTF_TYPE_ID_FLOAT;
365 }
366
367 int bt_ctf_field_is_enumeration(struct bt_ctf_field *field)
368 {
369 return bt_ctf_field_get_type_id(field) == BT_CTF_TYPE_ID_ENUM;
370 }
371
372 int bt_ctf_field_is_string(struct bt_ctf_field *field)
373 {
374 return bt_ctf_field_get_type_id(field) == BT_CTF_TYPE_ID_STRING;
375 }
376
377 int bt_ctf_field_is_structure(struct bt_ctf_field *field)
378 {
379 return bt_ctf_field_get_type_id(field) == BT_CTF_TYPE_ID_STRUCT;
380 }
381
382 int bt_ctf_field_is_array(struct bt_ctf_field *field)
383 {
384 return bt_ctf_field_get_type_id(field) == BT_CTF_TYPE_ID_ARRAY;
385 }
386
387 int bt_ctf_field_is_sequence(struct bt_ctf_field *field)
388 {
389 return bt_ctf_field_get_type_id(field) == BT_CTF_TYPE_ID_SEQUENCE;
390 }
391
392 int bt_ctf_field_is_variant(struct bt_ctf_field *field)
393 {
394 return bt_ctf_field_get_type_id(field) == BT_CTF_TYPE_ID_VARIANT;
395 }
396
397 struct bt_ctf_field *bt_ctf_field_sequence_get_length(
398 struct bt_ctf_field *field)
399 {
400 struct bt_ctf_field *ret = NULL;
401 struct bt_ctf_field_sequence *sequence;
402
403 if (!field) {
404 goto end;
405 }
406
407 if (bt_ctf_field_type_get_type_id(field->type) !=
408 BT_CTF_TYPE_ID_SEQUENCE) {
409 goto end;
410 }
411
412 sequence = container_of(field, struct bt_ctf_field_sequence, parent);
413 ret = sequence->length;
414 bt_get(ret);
415 end:
416 return ret;
417 }
418
419 int bt_ctf_field_sequence_set_length(struct bt_ctf_field *field,
420 struct bt_ctf_field *length_field)
421 {
422 int ret = 0;
423 struct bt_ctf_field_type_integer *length_type;
424 struct bt_ctf_field_integer *length;
425 struct bt_ctf_field_sequence *sequence;
426 uint64_t sequence_length;
427
428 if (!field || !length_field || field->frozen) {
429 ret = -1;
430 goto end;
431 }
432 if (bt_ctf_field_type_get_type_id(length_field->type) !=
433 BT_CTF_TYPE_ID_INTEGER) {
434 ret = -1;
435 goto end;
436 }
437
438 length_type = container_of(length_field->type,
439 struct bt_ctf_field_type_integer, parent);
440 /* The length field must be unsigned */
441 if (length_type->declaration.signedness) {
442 ret = -1;
443 goto end;
444 }
445
446 length = container_of(length_field, struct bt_ctf_field_integer,
447 parent);
448 sequence_length = length->definition.value._unsigned;
449 sequence = container_of(field, struct bt_ctf_field_sequence, parent);
450 if (sequence->elements) {
451 g_ptr_array_free(sequence->elements, TRUE);
452 bt_put(sequence->length);
453 }
454
455 sequence->elements = g_ptr_array_sized_new((size_t)sequence_length);
456 if (!sequence->elements) {
457 ret = -1;
458 goto end;
459 }
460
461 g_ptr_array_set_free_func(sequence->elements,
462 (GDestroyNotify) bt_put);
463 g_ptr_array_set_size(sequence->elements, (size_t) sequence_length);
464 bt_get(length_field);
465 sequence->length = length_field;
466 end:
467 return ret;
468 }
469
470 struct bt_ctf_field *bt_ctf_field_structure_get_field(
471 struct bt_ctf_field *field, const char *name)
472 {
473 struct bt_ctf_field *new_field = NULL;
474 GQuark field_quark;
475 struct bt_ctf_field_structure *structure;
476 struct bt_ctf_field_type *field_type = NULL;
477 size_t index;
478
479 if (!field || !name ||
480 bt_ctf_field_type_get_type_id(field->type) !=
481 BT_CTF_TYPE_ID_STRUCT) {
482 goto error;
483 }
484
485 field_quark = g_quark_from_string(name);
486 structure = container_of(field, struct bt_ctf_field_structure, parent);
487 field_type =
488 bt_ctf_field_type_structure_get_field_type_by_name(field->type,
489 name);
490 if (!g_hash_table_lookup_extended(structure->field_name_to_index,
491 GUINT_TO_POINTER(field_quark), NULL, (gpointer *)&index)) {
492 goto error;
493 }
494
495 if (structure->fields->pdata[index]) {
496 new_field = structure->fields->pdata[index];
497 goto end;
498 }
499
500 /* We don't want to modify this field if it's frozen */
501 if (field->frozen) {
502 goto end;
503 }
504
505 new_field = bt_ctf_field_create(field_type);
506 if (!new_field) {
507 goto error;
508 }
509
510 structure->fields->pdata[index] = new_field;
511 end:
512 bt_get(new_field);
513 error:
514 if (field_type) {
515 bt_put(field_type);
516 }
517 return new_field;
518 }
519
520 struct bt_ctf_field *bt_ctf_field_structure_get_field_by_index(
521 struct bt_ctf_field *field, int index)
522 {
523 int ret;
524 const char *field_name;
525 struct bt_ctf_field_structure *structure;
526 struct bt_ctf_field_type *structure_type;
527 struct bt_ctf_field_type *field_type = NULL;
528 struct bt_ctf_field *ret_field = NULL;
529
530 if (!field ||
531 bt_ctf_field_type_get_type_id(field->type) !=
532 BT_CTF_TYPE_ID_STRUCT) {
533 goto end;
534 }
535
536 structure = container_of(field, struct bt_ctf_field_structure, parent);
537 if (index >= structure->fields->len) {
538 goto error;
539 }
540
541 ret_field = structure->fields->pdata[index];
542 if (ret_field) {
543 goto end;
544 }
545
546 /* We don't want to modify this field if it's frozen */
547 if (field->frozen) {
548 goto end;
549 }
550
551 /* Field has not been instanciated yet, create it */
552 structure_type = bt_ctf_field_get_type(field);
553 if (!structure_type) {
554 goto error;
555 }
556
557 ret = bt_ctf_field_type_structure_get_field(structure_type,
558 &field_name, &field_type, index);
559 bt_put(structure_type);
560 if (ret) {
561 goto error;
562 }
563
564 ret_field = bt_ctf_field_create(field_type);
565 if (!ret_field) {
566 goto error;
567 }
568
569 structure->fields->pdata[index] = ret_field;
570 end:
571 bt_get(ret_field);
572 error:
573 bt_put(field_type);
574 return ret_field;
575 }
576
577 BT_HIDDEN
578 int bt_ctf_field_structure_set_field(struct bt_ctf_field *field,
579 const char *name, struct bt_ctf_field *value)
580 {
581 int ret = 0;
582 GQuark field_quark;
583 struct bt_ctf_field_structure *structure;
584 struct bt_ctf_field_type *expected_field_type = NULL;
585 size_t index;
586
587 if (!field || !name || !value || field->frozen ||
588 bt_ctf_field_type_get_type_id(field->type) !=
589 BT_CTF_TYPE_ID_STRUCT) {
590 ret = -1;
591 goto end;
592 }
593
594 field_quark = g_quark_from_string(name);
595 structure = container_of(field, struct bt_ctf_field_structure, parent);
596 expected_field_type =
597 bt_ctf_field_type_structure_get_field_type_by_name(field->type,
598 name);
599
600 if (bt_ctf_field_type_compare(expected_field_type, value->type)) {
601 ret = -1;
602 goto end;
603 }
604
605 if (!g_hash_table_lookup_extended(structure->field_name_to_index,
606 GUINT_TO_POINTER(field_quark), NULL, (gpointer *) &index)) {
607 goto end;
608 }
609
610 if (structure->fields->pdata[index]) {
611 bt_put(structure->fields->pdata[index]);
612 }
613
614 structure->fields->pdata[index] = value;
615 bt_get(value);
616 end:
617 if (expected_field_type) {
618 bt_put(expected_field_type);
619 }
620 return ret;
621 }
622
623 struct bt_ctf_field *bt_ctf_field_array_get_field(struct bt_ctf_field *field,
624 uint64_t index)
625 {
626 struct bt_ctf_field *new_field = NULL;
627 struct bt_ctf_field_type *field_type = NULL;
628 struct bt_ctf_field_array *array;
629
630 if (!field || bt_ctf_field_type_get_type_id(field->type) !=
631 BT_CTF_TYPE_ID_ARRAY) {
632 goto end;
633 }
634
635 array = container_of(field, struct bt_ctf_field_array, parent);
636 if (index >= array->elements->len) {
637 goto end;
638 }
639
640 field_type = bt_ctf_field_type_array_get_element_type(field->type);
641 if (array->elements->pdata[(size_t)index]) {
642 new_field = array->elements->pdata[(size_t)index];
643 goto end;
644 }
645
646 /* We don't want to modify this field if it's frozen */
647 if (field->frozen) {
648 goto end;
649 }
650
651 new_field = bt_ctf_field_create(field_type);
652 array->elements->pdata[(size_t)index] = new_field;
653 end:
654 if (field_type) {
655 bt_put(field_type);
656 }
657 if (new_field) {
658 bt_get(new_field);
659 }
660 return new_field;
661 }
662
663 struct bt_ctf_field *bt_ctf_field_sequence_get_field(struct bt_ctf_field *field,
664 uint64_t index)
665 {
666 struct bt_ctf_field *new_field = NULL;
667 struct bt_ctf_field_type *field_type = NULL;
668 struct bt_ctf_field_sequence *sequence;
669
670 if (!field || bt_ctf_field_type_get_type_id(field->type) !=
671 BT_CTF_TYPE_ID_SEQUENCE) {
672 goto end;
673 }
674
675 sequence = container_of(field, struct bt_ctf_field_sequence, parent);
676 if (!sequence->elements || sequence->elements->len <= index) {
677 goto end;
678 }
679
680 field_type = bt_ctf_field_type_sequence_get_element_type(field->type);
681 if (sequence->elements->pdata[(size_t) index]) {
682 new_field = sequence->elements->pdata[(size_t) index];
683 goto end;
684 }
685
686 /* We don't want to modify this field if it's frozen */
687 if (field->frozen) {
688 goto end;
689 }
690
691 new_field = bt_ctf_field_create(field_type);
692 sequence->elements->pdata[(size_t) index] = new_field;
693 end:
694 if (field_type) {
695 bt_put(field_type);
696 }
697 if (new_field) {
698 bt_get(new_field);
699 }
700 return new_field;
701 }
702
703 struct bt_ctf_field *bt_ctf_field_variant_get_field(struct bt_ctf_field *field,
704 struct bt_ctf_field *tag_field)
705 {
706 struct bt_ctf_field *new_field = NULL;
707 struct bt_ctf_field_variant *variant;
708 struct bt_ctf_field_type_variant *variant_type;
709 struct bt_ctf_field_type *field_type;
710 struct bt_ctf_field *tag_enum = NULL;
711 struct bt_ctf_field_integer *tag_enum_integer;
712 int64_t tag_enum_value;
713
714 if (!field || !tag_field ||
715 bt_ctf_field_type_get_type_id(field->type) !=
716 BT_CTF_TYPE_ID_VARIANT ||
717 bt_ctf_field_type_get_type_id(tag_field->type) !=
718 BT_CTF_TYPE_ID_ENUM) {
719 goto end;
720 }
721
722 variant = container_of(field, struct bt_ctf_field_variant, parent);
723 variant_type = container_of(field->type,
724 struct bt_ctf_field_type_variant, parent);
725 tag_enum = bt_ctf_field_enumeration_get_container(tag_field);
726 if (!tag_enum) {
727 goto end;
728 }
729
730 tag_enum_integer = container_of(tag_enum, struct bt_ctf_field_integer,
731 parent);
732
733 if (bt_ctf_field_validate(tag_field) < 0) {
734 goto end;
735 }
736
737 tag_enum_value = tag_enum_integer->definition.value._signed;
738
739 /*
740 * If the variant currently has a tag and a payload, and if the
741 * requested tag value is the same as the current one, return
742 * the current payload instead of creating a fresh one.
743 */
744 if (variant->tag && variant->payload) {
745 struct bt_ctf_field *cur_tag_container = NULL;
746 struct bt_ctf_field_integer *cur_tag_enum_integer;
747 int64_t cur_tag_value;
748
749 cur_tag_container =
750 bt_ctf_field_enumeration_get_container(variant->tag);
751 assert(cur_tag_container);
752 cur_tag_enum_integer = container_of(cur_tag_container,
753 struct bt_ctf_field_integer, parent);
754 bt_put(cur_tag_container);
755 cur_tag_value = cur_tag_enum_integer->definition.value._signed;
756
757 if (cur_tag_value == tag_enum_value) {
758 new_field = variant->payload;
759 bt_get(new_field);
760 goto end;
761 }
762 }
763
764 /* We don't want to modify this field if it's frozen */
765 if (field->frozen) {
766 goto end;
767 }
768
769 field_type = bt_ctf_field_type_variant_get_field_type_signed(
770 variant_type, tag_enum_value);
771 if (!field_type) {
772 goto end;
773 }
774
775 new_field = bt_ctf_field_create(field_type);
776 if (!new_field) {
777 goto end;
778 }
779
780 bt_put(variant->tag);
781 bt_put(variant->payload);
782 bt_get(new_field);
783 bt_get(tag_field);
784 variant->tag = tag_field;
785 variant->payload = new_field;
786 end:
787 bt_put(tag_enum);
788 return new_field;
789 }
790
791 struct bt_ctf_field *bt_ctf_field_variant_get_current_field(
792 struct bt_ctf_field *variant_field)
793 {
794 struct bt_ctf_field *current_field = NULL;
795 struct bt_ctf_field_variant *variant;
796
797 if (!variant_field ||
798 bt_ctf_field_type_get_type_id(variant_field->type) !=
799 BT_CTF_TYPE_ID_VARIANT) {
800 goto end;
801 }
802
803 variant = container_of(variant_field, struct bt_ctf_field_variant,
804 parent);
805
806 if (variant->payload) {
807 current_field = variant->payload;
808 bt_get(current_field);
809 goto end;
810 }
811
812 end:
813 return current_field;
814 }
815
816 struct bt_ctf_field *bt_ctf_field_variant_get_tag(
817 struct bt_ctf_field *variant_field)
818 {
819 struct bt_ctf_field *tag = NULL;
820 struct bt_ctf_field_variant *variant;
821
822 if (!variant_field ||
823 bt_ctf_field_type_get_type_id(variant_field->type) !=
824 BT_CTF_TYPE_ID_VARIANT) {
825 goto end;
826 }
827
828 variant = container_of(variant_field, struct bt_ctf_field_variant,
829 parent);
830 if (variant->tag) {
831 tag = bt_get(variant->tag);
832 }
833 end:
834 return tag;
835 }
836
837 struct bt_ctf_field *bt_ctf_field_enumeration_get_container(
838 struct bt_ctf_field *field)
839 {
840 struct bt_ctf_field *container = NULL;
841 struct bt_ctf_field_enumeration *enumeration;
842
843 if (!field || bt_ctf_field_type_get_type_id(field->type) !=
844 BT_CTF_TYPE_ID_ENUM) {
845 goto end;
846 }
847
848 enumeration = container_of(field, struct bt_ctf_field_enumeration,
849 parent);
850 if (!enumeration->payload) {
851 /* We don't want to modify this field if it's frozen */
852 if (field->frozen) {
853 goto end;
854 }
855
856 struct bt_ctf_field_type_enumeration *enumeration_type =
857 container_of(field->type,
858 struct bt_ctf_field_type_enumeration, parent);
859 enumeration->payload =
860 bt_ctf_field_create(enumeration_type->container);
861 }
862
863 container = enumeration->payload;
864 bt_get(container);
865 end:
866 return container;
867 }
868
869 struct bt_ctf_field_type_enumeration_mapping_iterator *
870 bt_ctf_field_enumeration_get_mappings(struct bt_ctf_field *field)
871 {
872 int ret;
873 struct bt_ctf_field *container = NULL;
874 struct bt_ctf_field_type *container_type = NULL;
875 struct bt_ctf_field_type_integer *integer_type = NULL;
876 struct bt_ctf_field_type_enumeration_mapping_iterator *iter = NULL;
877
878 container = bt_ctf_field_enumeration_get_container(field);
879 if (!container) {
880 goto end;
881 }
882
883 container_type = bt_ctf_field_get_type(container);
884 if (!container_type) {
885 goto error_put_container;
886 }
887
888 integer_type = container_of(container_type,
889 struct bt_ctf_field_type_integer, parent);
890
891 if (!integer_type->declaration.signedness) {
892 uint64_t value;
893
894 ret = bt_ctf_field_unsigned_integer_get_value(container,
895 &value);
896 if (ret) {
897 goto error_put_container_type;
898 }
899 iter = bt_ctf_field_type_enumeration_find_mappings_by_unsigned_value(
900 field->type, value);
901 } else {
902 int64_t value;
903
904 ret = bt_ctf_field_signed_integer_get_value(container,
905 &value);
906 if (ret) {
907 goto error_put_container_type;
908 }
909 iter = bt_ctf_field_type_enumeration_find_mappings_by_signed_value(
910 field->type, value);
911 }
912
913 error_put_container_type:
914 bt_put(container_type);
915 error_put_container:
916 bt_put(container);
917 end:
918 return iter;
919 }
920
921 int bt_ctf_field_signed_integer_get_value(struct bt_ctf_field *field,
922 int64_t *value)
923 {
924 int ret = 0;
925 struct bt_ctf_field_integer *integer;
926 struct bt_ctf_field_type_integer *integer_type;
927
928 if (!field || !value || !field->payload_set ||
929 bt_ctf_field_type_get_type_id(field->type) !=
930 BT_CTF_TYPE_ID_INTEGER) {
931 ret = -1;
932 goto end;
933 }
934
935 integer_type = container_of(field->type,
936 struct bt_ctf_field_type_integer, parent);
937 if (!integer_type->declaration.signedness) {
938 ret = -1;
939 goto end;
940 }
941
942 integer = container_of(field,
943 struct bt_ctf_field_integer, parent);
944 *value = integer->definition.value._signed;
945 end:
946 return ret;
947 }
948
949 int bt_ctf_field_signed_integer_set_value(struct bt_ctf_field *field,
950 int64_t value)
951 {
952 int ret = 0;
953 struct bt_ctf_field_integer *integer;
954 struct bt_ctf_field_type_integer *integer_type;
955 unsigned int size;
956 int64_t min_value, max_value;
957
958 if (!field || field->frozen ||
959 bt_ctf_field_type_get_type_id(field->type) !=
960 BT_CTF_TYPE_ID_INTEGER) {
961 ret = -1;
962 goto end;
963 }
964
965 integer = container_of(field, struct bt_ctf_field_integer, parent);
966 integer_type = container_of(field->type,
967 struct bt_ctf_field_type_integer, parent);
968 if (!integer_type->declaration.signedness) {
969 ret = -1;
970 goto end;
971 }
972
973 size = integer_type->declaration.len;
974 min_value = -(1ULL << (size - 1));
975 max_value = (1ULL << (size - 1)) - 1;
976 if (value < min_value || value > max_value) {
977 ret = -1;
978 goto end;
979 }
980
981 integer->definition.value._signed = value;
982 integer->parent.payload_set = 1;
983 end:
984 return ret;
985 }
986
987 int bt_ctf_field_unsigned_integer_get_value(struct bt_ctf_field *field,
988 uint64_t *value)
989 {
990 int ret = 0;
991 struct bt_ctf_field_integer *integer;
992 struct bt_ctf_field_type_integer *integer_type;
993
994 if (!field || !value || !field->payload_set ||
995 bt_ctf_field_type_get_type_id(field->type) !=
996 BT_CTF_TYPE_ID_INTEGER) {
997 ret = -1;
998 goto end;
999 }
1000
1001 integer_type = container_of(field->type,
1002 struct bt_ctf_field_type_integer, parent);
1003 if (integer_type->declaration.signedness) {
1004 ret = -1;
1005 goto end;
1006 }
1007
1008 integer = container_of(field,
1009 struct bt_ctf_field_integer, parent);
1010 *value = integer->definition.value._unsigned;
1011 end:
1012 return ret;
1013 }
1014
1015 int bt_ctf_field_unsigned_integer_set_value(struct bt_ctf_field *field,
1016 uint64_t value)
1017 {
1018 int ret = 0;
1019 struct bt_ctf_field_integer *integer;
1020 struct bt_ctf_field_type_integer *integer_type;
1021 unsigned int size;
1022 uint64_t max_value;
1023
1024 if (!field || field->frozen ||
1025 bt_ctf_field_type_get_type_id(field->type) !=
1026 BT_CTF_TYPE_ID_INTEGER) {
1027 ret = -1;
1028 goto end;
1029 }
1030
1031 integer = container_of(field, struct bt_ctf_field_integer, parent);
1032 integer_type = container_of(field->type,
1033 struct bt_ctf_field_type_integer, parent);
1034 if (integer_type->declaration.signedness) {
1035 ret = -1;
1036 goto end;
1037 }
1038
1039 size = integer_type->declaration.len;
1040 max_value = (size == 64) ? UINT64_MAX : ((uint64_t) 1 << size) - 1;
1041 if (value > max_value) {
1042 ret = -1;
1043 goto end;
1044 }
1045
1046 integer->definition.value._unsigned = value;
1047 integer->parent.payload_set = 1;
1048 end:
1049 return ret;
1050 }
1051
1052 int bt_ctf_field_floating_point_get_value(struct bt_ctf_field *field,
1053 double *value)
1054 {
1055 int ret = 0;
1056 struct bt_ctf_field_floating_point *floating_point;
1057
1058 if (!field || !value || !field->payload_set ||
1059 bt_ctf_field_type_get_type_id(field->type) !=
1060 BT_CTF_TYPE_ID_FLOAT) {
1061 ret = -1;
1062 goto end;
1063 }
1064
1065 floating_point = container_of(field,
1066 struct bt_ctf_field_floating_point, parent);
1067 *value = floating_point->definition.value;
1068 end:
1069 return ret;
1070 }
1071
1072 int bt_ctf_field_floating_point_set_value(struct bt_ctf_field *field,
1073 double value)
1074 {
1075 int ret = 0;
1076 struct bt_ctf_field_floating_point *floating_point;
1077
1078 if (!field || field->frozen ||
1079 bt_ctf_field_type_get_type_id(field->type) !=
1080 BT_CTF_TYPE_ID_FLOAT) {
1081 ret = -1;
1082 goto end;
1083 }
1084 floating_point = container_of(field, struct bt_ctf_field_floating_point,
1085 parent);
1086 floating_point->definition.value = value;
1087 floating_point->parent.payload_set = 1;
1088 end:
1089 return ret;
1090 }
1091
1092 const char *bt_ctf_field_string_get_value(struct bt_ctf_field *field)
1093 {
1094 const char *ret = NULL;
1095 struct bt_ctf_field_string *string;
1096
1097 if (!field || !field->payload_set ||
1098 bt_ctf_field_type_get_type_id(field->type) !=
1099 BT_CTF_TYPE_ID_STRING) {
1100 goto end;
1101 }
1102
1103 string = container_of(field,
1104 struct bt_ctf_field_string, parent);
1105 ret = string->payload->str;
1106 end:
1107 return ret;
1108 }
1109
1110 int bt_ctf_field_string_set_value(struct bt_ctf_field *field,
1111 const char *value)
1112 {
1113 int ret = 0;
1114 struct bt_ctf_field_string *string;
1115
1116 if (!field || !value || field->frozen ||
1117 bt_ctf_field_type_get_type_id(field->type) !=
1118 BT_CTF_TYPE_ID_STRING) {
1119 ret = -1;
1120 goto end;
1121 }
1122
1123 string = container_of(field, struct bt_ctf_field_string, parent);
1124 if (string->payload) {
1125 g_string_assign(string->payload, value);
1126 } else {
1127 string->payload = g_string_new(value);
1128 }
1129
1130 string->parent.payload_set = 1;
1131 end:
1132 return ret;
1133 }
1134
1135 int bt_ctf_field_string_append(struct bt_ctf_field *field,
1136 const char *value)
1137 {
1138 int ret = 0;
1139 struct bt_ctf_field_string *string_field;
1140
1141 if (!field || !value || field->frozen ||
1142 bt_ctf_field_type_get_type_id(field->type) !=
1143 BT_CTF_TYPE_ID_STRING) {
1144 ret = -1;
1145 goto end;
1146 }
1147
1148 string_field = container_of(field, struct bt_ctf_field_string, parent);
1149
1150 if (string_field->payload) {
1151 g_string_append(string_field->payload, value);
1152 } else {
1153 string_field->payload = g_string_new(value);
1154 }
1155
1156 string_field->parent.payload_set = 1;
1157
1158 end:
1159 return ret;
1160 }
1161
1162 int bt_ctf_field_string_append_len(struct bt_ctf_field *field,
1163 const char *value, unsigned int length)
1164 {
1165 int i;
1166 int ret = 0;
1167 unsigned int effective_length = length;
1168 struct bt_ctf_field_string *string_field;
1169
1170 if (!field || !value || field->frozen ||
1171 bt_ctf_field_type_get_type_id(field->type) !=
1172 BT_CTF_TYPE_ID_STRING) {
1173 ret = -1;
1174 goto end;
1175 }
1176
1177 string_field = container_of(field, struct bt_ctf_field_string, parent);
1178
1179 /* make sure no null bytes are appended */
1180 for (i = 0; i < length; ++i) {
1181 if (value[i] == '\0') {
1182 effective_length = i;
1183 break;
1184 }
1185 }
1186
1187 if (string_field->payload) {
1188 g_string_append_len(string_field->payload, value,
1189 effective_length);
1190 } else {
1191 string_field->payload = g_string_new_len(value,
1192 effective_length);
1193 }
1194
1195 string_field->parent.payload_set = 1;
1196
1197 end:
1198 return ret;
1199 }
1200
1201 BT_HIDDEN
1202 int bt_ctf_field_validate(struct bt_ctf_field *field)
1203 {
1204 int ret = 0;
1205 enum bt_ctf_type_id type_id;
1206
1207 if (!field) {
1208 ret = -1;
1209 goto end;
1210 }
1211
1212 type_id = bt_ctf_field_type_get_type_id(field->type);
1213 if (type_id <= BT_CTF_TYPE_ID_UNKNOWN || type_id >= BT_CTF_NR_TYPE_IDS) {
1214 ret = -1;
1215 goto end;
1216 }
1217
1218 ret = field_validate_funcs[type_id](field);
1219 end:
1220 return ret;
1221 }
1222
1223 BT_HIDDEN
1224 int bt_ctf_field_reset(struct bt_ctf_field *field)
1225 {
1226 int ret = 0;
1227 enum bt_ctf_type_id type_id;
1228
1229 if (!field) {
1230 ret = -1;
1231 goto end;
1232 }
1233
1234 type_id = bt_ctf_field_type_get_type_id(field->type);
1235 if (type_id <= BT_CTF_TYPE_ID_UNKNOWN || type_id >= BT_CTF_NR_TYPE_IDS) {
1236 ret = -1;
1237 goto end;
1238 }
1239
1240 ret = field_reset_funcs[type_id](field);
1241 end:
1242 return ret;
1243 }
1244
1245 BT_HIDDEN
1246 int bt_ctf_field_serialize(struct bt_ctf_field *field,
1247 struct ctf_stream_pos *pos)
1248 {
1249 int ret = 0;
1250 enum bt_ctf_type_id type_id;
1251
1252 if (!field || !pos) {
1253 ret = -1;
1254 goto end;
1255 }
1256
1257 type_id = bt_ctf_field_type_get_type_id(field->type);
1258 if (type_id <= BT_CTF_TYPE_ID_UNKNOWN || type_id >= BT_CTF_NR_TYPE_IDS) {
1259 ret = -1;
1260 goto end;
1261 }
1262
1263 ret = field_serialize_funcs[type_id](field, pos);
1264 end:
1265 return ret;
1266 }
1267
1268
1269 BT_HIDDEN
1270 bool bt_ctf_field_is_set(struct bt_ctf_field *field)
1271 {
1272 bool is_set = false;
1273 enum bt_ctf_type_id type_id;
1274
1275 if (!field) {
1276 goto end;
1277 }
1278
1279 type_id = bt_ctf_field_type_get_type_id(field->type);
1280 if (type_id <= BT_CTF_TYPE_ID_UNKNOWN || type_id >= BT_CTF_NR_TYPE_IDS) {
1281 goto end;
1282 }
1283
1284 is_set = field_is_set_funcs[type_id](field);
1285 end:
1286 return is_set;
1287 }
1288
1289 struct bt_ctf_field *bt_ctf_field_copy(struct bt_ctf_field *field)
1290 {
1291 int ret;
1292 struct bt_ctf_field *copy = NULL;
1293 enum bt_ctf_type_id type_id;
1294
1295 if (!field) {
1296 goto end;
1297 }
1298
1299 type_id = bt_ctf_field_type_get_type_id(field->type);
1300 if (type_id <= BT_CTF_TYPE_ID_UNKNOWN || type_id >= BT_CTF_NR_TYPE_IDS) {
1301 goto end;
1302 }
1303
1304 copy = bt_ctf_field_create(field->type);
1305 if (!copy) {
1306 goto end;
1307 }
1308
1309 copy->payload_set = field->payload_set;
1310 ret = field_copy_funcs[type_id](field, copy);
1311 if (ret) {
1312 bt_put(copy);
1313 copy = NULL;
1314 }
1315 end:
1316 return copy;
1317 }
1318
1319 static
1320 struct bt_ctf_field *bt_ctf_field_integer_create(struct bt_ctf_field_type *type)
1321 {
1322 struct bt_ctf_field_type_integer *integer_type = container_of(type,
1323 struct bt_ctf_field_type_integer, parent);
1324 struct bt_ctf_field_integer *integer = g_new0(
1325 struct bt_ctf_field_integer, 1);
1326
1327 if (integer) {
1328 integer->definition.declaration = &integer_type->declaration;
1329 }
1330
1331 return integer ? &integer->parent : NULL;
1332 }
1333
1334 static
1335 struct bt_ctf_field *bt_ctf_field_enumeration_create(
1336 struct bt_ctf_field_type *type)
1337 {
1338 struct bt_ctf_field_enumeration *enumeration = g_new0(
1339 struct bt_ctf_field_enumeration, 1);
1340
1341 return enumeration ? &enumeration->parent : NULL;
1342 }
1343
1344 static
1345 struct bt_ctf_field *bt_ctf_field_floating_point_create(
1346 struct bt_ctf_field_type *type)
1347 {
1348 struct bt_ctf_field_floating_point *floating_point;
1349 struct bt_ctf_field_type_floating_point *floating_point_type;
1350
1351 floating_point = g_new0(struct bt_ctf_field_floating_point, 1);
1352 if (!floating_point) {
1353 goto end;
1354 }
1355
1356 floating_point_type = container_of(type,
1357 struct bt_ctf_field_type_floating_point, parent);
1358 floating_point->definition.declaration = container_of(
1359 type->declaration, struct declaration_float, p);
1360
1361
1362 floating_point->definition.sign = &floating_point->sign;
1363 floating_point->sign.declaration = &floating_point_type->sign;
1364 floating_point->definition.sign->p.declaration =
1365 &floating_point_type->sign.p;
1366
1367 floating_point->definition.mantissa = &floating_point->mantissa;
1368 floating_point->mantissa.declaration = &floating_point_type->mantissa;
1369 floating_point->definition.mantissa->p.declaration =
1370 &floating_point_type->mantissa.p;
1371
1372 floating_point->definition.exp = &floating_point->exp;
1373 floating_point->exp.declaration = &floating_point_type->exp;
1374 floating_point->definition.exp->p.declaration =
1375 &floating_point_type->exp.p;
1376
1377 end:
1378 return floating_point ? &floating_point->parent : NULL;
1379 }
1380
1381 static
1382 struct bt_ctf_field *bt_ctf_field_structure_create(
1383 struct bt_ctf_field_type *type)
1384 {
1385 struct bt_ctf_field_type_structure *structure_type = container_of(type,
1386 struct bt_ctf_field_type_structure, parent);
1387 struct bt_ctf_field_structure *structure = g_new0(
1388 struct bt_ctf_field_structure, 1);
1389 struct bt_ctf_field *field = NULL;
1390
1391 if (!structure) {
1392 goto end;
1393 }
1394
1395 structure->field_name_to_index = structure_type->field_name_to_index;
1396 structure->fields = g_ptr_array_new_with_free_func(
1397 (GDestroyNotify)bt_ctf_field_put);
1398 g_ptr_array_set_size(structure->fields,
1399 g_hash_table_size(structure->field_name_to_index));
1400 field = &structure->parent;
1401 end:
1402 return field;
1403 }
1404
1405 static
1406 struct bt_ctf_field *bt_ctf_field_variant_create(struct bt_ctf_field_type *type)
1407 {
1408 struct bt_ctf_field_variant *variant = g_new0(
1409 struct bt_ctf_field_variant, 1);
1410 return variant ? &variant->parent : NULL;
1411 }
1412
1413 static
1414 struct bt_ctf_field *bt_ctf_field_array_create(struct bt_ctf_field_type *type)
1415 {
1416 struct bt_ctf_field_array *array = g_new0(struct bt_ctf_field_array, 1);
1417 struct bt_ctf_field_type_array *array_type;
1418 unsigned int array_length;
1419
1420 if (!array || !type) {
1421 goto error;
1422 }
1423
1424 array_type = container_of(type, struct bt_ctf_field_type_array, parent);
1425 array_length = array_type->length;
1426 array->elements = g_ptr_array_sized_new(array_length);
1427 if (!array->elements) {
1428 goto error;
1429 }
1430
1431 g_ptr_array_set_free_func(array->elements,
1432 (GDestroyNotify)bt_ctf_field_put);
1433 g_ptr_array_set_size(array->elements, array_length);
1434 return &array->parent;
1435 error:
1436 g_free(array);
1437 return NULL;
1438 }
1439
1440 static
1441 struct bt_ctf_field *bt_ctf_field_sequence_create(
1442 struct bt_ctf_field_type *type)
1443 {
1444 struct bt_ctf_field_sequence *sequence = g_new0(
1445 struct bt_ctf_field_sequence, 1);
1446 return sequence ? &sequence->parent : NULL;
1447 }
1448
1449 static
1450 struct bt_ctf_field *bt_ctf_field_string_create(struct bt_ctf_field_type *type)
1451 {
1452 struct bt_ctf_field_string *string = g_new0(
1453 struct bt_ctf_field_string, 1);
1454 return string ? &string->parent : NULL;
1455 }
1456
1457 static
1458 void bt_ctf_field_destroy(struct bt_object *obj)
1459 {
1460 struct bt_ctf_field *field;
1461 struct bt_ctf_field_type *type;
1462 enum bt_ctf_type_id type_id;
1463
1464 field = container_of(obj, struct bt_ctf_field, base);
1465 type = field->type;
1466 type_id = bt_ctf_field_type_get_type_id(type);
1467 if (type_id <= BT_CTF_TYPE_ID_UNKNOWN ||
1468 type_id >= BT_CTF_NR_TYPE_IDS) {
1469 return;
1470 }
1471
1472 field_destroy_funcs[type_id](field);
1473 bt_put(type);
1474 }
1475
1476 static
1477 void bt_ctf_field_integer_destroy(struct bt_ctf_field *field)
1478 {
1479 struct bt_ctf_field_integer *integer;
1480
1481 if (!field) {
1482 return;
1483 }
1484
1485 integer = container_of(field, struct bt_ctf_field_integer, parent);
1486 g_free(integer);
1487 }
1488
1489 static
1490 void bt_ctf_field_enumeration_destroy(struct bt_ctf_field *field)
1491 {
1492 struct bt_ctf_field_enumeration *enumeration;
1493
1494 if (!field) {
1495 return;
1496 }
1497
1498 enumeration = container_of(field, struct bt_ctf_field_enumeration,
1499 parent);
1500 bt_put(enumeration->payload);
1501 g_free(enumeration);
1502 }
1503
1504 static
1505 void bt_ctf_field_floating_point_destroy(struct bt_ctf_field *field)
1506 {
1507 struct bt_ctf_field_floating_point *floating_point;
1508
1509 if (!field) {
1510 return;
1511 }
1512
1513 floating_point = container_of(field, struct bt_ctf_field_floating_point,
1514 parent);
1515 g_free(floating_point);
1516 }
1517
1518 static
1519 void bt_ctf_field_structure_destroy(struct bt_ctf_field *field)
1520 {
1521 struct bt_ctf_field_structure *structure;
1522
1523 if (!field) {
1524 return;
1525 }
1526
1527 structure = container_of(field, struct bt_ctf_field_structure, parent);
1528 g_ptr_array_free(structure->fields, TRUE);
1529 g_free(structure);
1530 }
1531
1532 static
1533 void bt_ctf_field_variant_destroy(struct bt_ctf_field *field)
1534 {
1535 struct bt_ctf_field_variant *variant;
1536
1537 if (!field) {
1538 return;
1539 }
1540
1541 variant = container_of(field, struct bt_ctf_field_variant, parent);
1542 bt_put(variant->tag);
1543 bt_put(variant->payload);
1544 g_free(variant);
1545 }
1546
1547 static
1548 void bt_ctf_field_array_destroy(struct bt_ctf_field *field)
1549 {
1550 struct bt_ctf_field_array *array;
1551
1552 if (!field) {
1553 return;
1554 }
1555
1556 array = container_of(field, struct bt_ctf_field_array, parent);
1557 g_ptr_array_free(array->elements, TRUE);
1558 g_free(array);
1559 }
1560
1561 static
1562 void bt_ctf_field_sequence_destroy(struct bt_ctf_field *field)
1563 {
1564 struct bt_ctf_field_sequence *sequence;
1565
1566 if (!field) {
1567 return;
1568 }
1569
1570 sequence = container_of(field, struct bt_ctf_field_sequence, parent);
1571 if (sequence->elements) {
1572 g_ptr_array_free(sequence->elements, TRUE);
1573 }
1574 bt_put(sequence->length);
1575 g_free(sequence);
1576 }
1577
1578 static
1579 void bt_ctf_field_string_destroy(struct bt_ctf_field *field)
1580 {
1581 struct bt_ctf_field_string *string;
1582 if (!field) {
1583 return;
1584 }
1585
1586 string = container_of(field, struct bt_ctf_field_string, parent);
1587 if (string->payload) {
1588 g_string_free(string->payload, TRUE);
1589 }
1590 g_free(string);
1591 }
1592
1593 static
1594 int bt_ctf_field_generic_validate(struct bt_ctf_field *field)
1595 {
1596 return (field && field->payload_set) ? 0 : -1;
1597 }
1598
1599 static
1600 int bt_ctf_field_enumeration_validate(struct bt_ctf_field *field)
1601 {
1602 int ret;
1603 struct bt_ctf_field_enumeration *enumeration;
1604
1605 if (!field) {
1606 ret = -1;
1607 goto end;
1608 }
1609
1610 enumeration = container_of(field, struct bt_ctf_field_enumeration,
1611 parent);
1612 if (!enumeration->payload) {
1613 ret = -1;
1614 goto end;
1615 }
1616
1617 ret = bt_ctf_field_validate(enumeration->payload);
1618 end:
1619 return ret;
1620 }
1621
1622 static
1623 int bt_ctf_field_structure_validate(struct bt_ctf_field *field)
1624 {
1625 size_t i;
1626 int ret = 0;
1627 struct bt_ctf_field_structure *structure;
1628
1629 if (!field) {
1630 ret = -1;
1631 goto end;
1632 }
1633
1634 structure = container_of(field, struct bt_ctf_field_structure, parent);
1635 for (i = 0; i < structure->fields->len; i++) {
1636 ret = bt_ctf_field_validate(structure->fields->pdata[i]);
1637 if (ret) {
1638 const char *name;
1639 struct bt_ctf_field_type *field_type =
1640 bt_ctf_field_get_type(field);
1641
1642 (void) bt_ctf_field_type_structure_get_field(field_type,
1643 &name, NULL, i);
1644 fprintf(stderr, "Field %s failed validation\n",
1645 name ? name : "NULL");
1646 bt_put(field_type);
1647 goto end;
1648 }
1649 }
1650 end:
1651 return ret;
1652 }
1653
1654 static
1655 int bt_ctf_field_variant_validate(struct bt_ctf_field *field)
1656 {
1657 int ret = 0;
1658 struct bt_ctf_field_variant *variant;
1659
1660 if (!field) {
1661 ret = -1;
1662 goto end;
1663 }
1664
1665 variant = container_of(field, struct bt_ctf_field_variant, parent);
1666 ret = bt_ctf_field_validate(variant->payload);
1667 end:
1668 return ret;
1669 }
1670
1671 static
1672 int bt_ctf_field_array_validate(struct bt_ctf_field *field)
1673 {
1674 size_t i;
1675 int ret = 0;
1676 struct bt_ctf_field_array *array;
1677
1678 if (!field) {
1679 ret = -1;
1680 goto end;
1681 }
1682
1683 array = container_of(field, struct bt_ctf_field_array, parent);
1684 for (i = 0; i < array->elements->len; i++) {
1685 ret = bt_ctf_field_validate(array->elements->pdata[i]);
1686 if (ret) {
1687 fprintf(stderr, "Failed to validate array field #%zu\n", i);
1688 goto end;
1689 }
1690 }
1691 end:
1692 return ret;
1693 }
1694
1695 static
1696 int bt_ctf_field_sequence_validate(struct bt_ctf_field *field)
1697 {
1698 size_t i;
1699 int ret = 0;
1700 struct bt_ctf_field_sequence *sequence;
1701
1702 if (!field) {
1703 ret = -1;
1704 goto end;
1705 }
1706
1707 sequence = container_of(field, struct bt_ctf_field_sequence, parent);
1708 for (i = 0; i < sequence->elements->len; i++) {
1709 ret = bt_ctf_field_validate(sequence->elements->pdata[i]);
1710 if (ret) {
1711 fprintf(stderr, "Failed to validate sequence field #%zu\n", i);
1712 goto end;
1713 }
1714 }
1715 end:
1716 return ret;
1717 }
1718
1719 static
1720 int bt_ctf_field_generic_reset(struct bt_ctf_field *field)
1721 {
1722 int ret = 0;
1723
1724 if (!field) {
1725 ret = -1;
1726 goto end;
1727 }
1728
1729 field->payload_set = 0;
1730 end:
1731 return ret;
1732 }
1733
1734 static
1735 int bt_ctf_field_enumeration_reset(struct bt_ctf_field *field)
1736 {
1737 int ret = 0;
1738 struct bt_ctf_field_enumeration *enumeration;
1739
1740 if (!field) {
1741 ret = -1;
1742 goto end;
1743 }
1744
1745 enumeration = container_of(field, struct bt_ctf_field_enumeration,
1746 parent);
1747 if (!enumeration->payload) {
1748 goto end;
1749 }
1750
1751 ret = bt_ctf_field_reset(enumeration->payload);
1752 end:
1753 return ret;
1754 }
1755
1756 static
1757 int bt_ctf_field_structure_reset(struct bt_ctf_field *field)
1758 {
1759 size_t i;
1760 int ret = 0;
1761 struct bt_ctf_field_structure *structure;
1762
1763 if (!field) {
1764 ret = -1;
1765 goto end;
1766 }
1767
1768 structure = container_of(field, struct bt_ctf_field_structure, parent);
1769 for (i = 0; i < structure->fields->len; i++) {
1770 struct bt_ctf_field *member = structure->fields->pdata[i];
1771
1772 if (!member) {
1773 /*
1774 * Structure members are lazily initialized; skip if
1775 * this member has not been allocated yet.
1776 */
1777 continue;
1778 }
1779
1780 ret = bt_ctf_field_reset(member);
1781 if (ret) {
1782 goto end;
1783 }
1784 }
1785 end:
1786 return ret;
1787 }
1788
1789 static
1790 int bt_ctf_field_variant_reset(struct bt_ctf_field *field)
1791 {
1792 int ret = 0;
1793 struct bt_ctf_field_variant *variant;
1794
1795 if (!field) {
1796 ret = -1;
1797 goto end;
1798 }
1799
1800 variant = container_of(field, struct bt_ctf_field_variant, parent);
1801 if (variant->payload) {
1802 ret = bt_ctf_field_reset(variant->payload);
1803 }
1804 end:
1805 return ret;
1806 }
1807
1808 static
1809 int bt_ctf_field_array_reset(struct bt_ctf_field *field)
1810 {
1811 size_t i;
1812 int ret = 0;
1813 struct bt_ctf_field_array *array;
1814
1815 if (!field) {
1816 ret = -1;
1817 goto end;
1818 }
1819
1820 array = container_of(field, struct bt_ctf_field_array, parent);
1821 for (i = 0; i < array->elements->len; i++) {
1822 struct bt_ctf_field *member = array->elements->pdata[i];
1823
1824 if (!member) {
1825 /*
1826 * Array elements are lazily initialized; skip if
1827 * this member has not been allocated yet.
1828 */
1829 continue;
1830 }
1831
1832 ret = bt_ctf_field_reset(member);
1833 if (ret) {
1834 goto end;
1835 }
1836 }
1837 end:
1838 return ret;
1839 }
1840
1841 static
1842 int bt_ctf_field_sequence_reset(struct bt_ctf_field *field)
1843 {
1844 size_t i;
1845 int ret = 0;
1846 struct bt_ctf_field_sequence *sequence;
1847
1848 if (!field) {
1849 ret = -1;
1850 goto end;
1851 }
1852
1853 sequence = container_of(field, struct bt_ctf_field_sequence, parent);
1854 for (i = 0; i < sequence->elements->len; i++) {
1855 struct bt_ctf_field *member = sequence->elements->pdata[i];
1856
1857 if (!member) {
1858 /*
1859 * Sequence elements are lazily initialized; skip if
1860 * this member has not been allocated yet.
1861 */
1862 continue;
1863 }
1864
1865 ret = bt_ctf_field_reset(member);
1866 if (ret) {
1867 goto end;
1868 }
1869 }
1870 end:
1871 return ret;
1872 }
1873
1874 static
1875 int bt_ctf_field_string_reset(struct bt_ctf_field *field)
1876 {
1877 int ret = 0;
1878 struct bt_ctf_field_string *string;
1879
1880 if (!field) {
1881 ret = -1;
1882 goto end;
1883 }
1884
1885 ret = bt_ctf_field_generic_reset(field);
1886 if (ret) {
1887 goto end;
1888 }
1889
1890 string = container_of(field, struct bt_ctf_field_string, parent);
1891 if (string->payload) {
1892 g_string_truncate(string->payload, 0);
1893 }
1894 end:
1895 return ret;
1896 }
1897
1898 static
1899 int bt_ctf_field_integer_serialize(struct bt_ctf_field *field,
1900 struct ctf_stream_pos *pos)
1901 {
1902 int ret = 0;
1903 struct bt_ctf_field_integer *integer = container_of(field,
1904 struct bt_ctf_field_integer, parent);
1905
1906 if (!bt_ctf_field_generic_is_set(field)) {
1907 ret = -1;
1908 goto end;
1909 }
1910 retry:
1911 ret = ctf_integer_write(&pos->parent, &integer->definition.p);
1912 if (ret == -EFAULT) {
1913 /*
1914 * The field is too large to fit in the current packet's
1915 * remaining space. Bump the packet size and retry.
1916 */
1917 ret = increase_packet_size(pos);
1918 if (ret) {
1919 goto end;
1920 }
1921 goto retry;
1922 }
1923 end:
1924 return ret;
1925 }
1926
1927 static
1928 int bt_ctf_field_enumeration_serialize(struct bt_ctf_field *field,
1929 struct ctf_stream_pos *pos)
1930 {
1931 struct bt_ctf_field_enumeration *enumeration = container_of(
1932 field, struct bt_ctf_field_enumeration, parent);
1933
1934 return bt_ctf_field_serialize(enumeration->payload, pos);
1935 }
1936
1937 static
1938 int bt_ctf_field_floating_point_serialize(struct bt_ctf_field *field,
1939 struct ctf_stream_pos *pos)
1940 {
1941 int ret = 0;
1942 struct bt_ctf_field_floating_point *floating_point = container_of(field,
1943 struct bt_ctf_field_floating_point, parent);
1944
1945 if (!bt_ctf_field_generic_is_set(field)) {
1946 ret = -1;
1947 goto end;
1948 }
1949 retry:
1950 ret = ctf_float_write(&pos->parent, &floating_point->definition.p);
1951 if (ret == -EFAULT) {
1952 /*
1953 * The field is too large to fit in the current packet's
1954 * remaining space. Bump the packet size and retry.
1955 */
1956 ret = increase_packet_size(pos);
1957 if (ret) {
1958 goto end;
1959 }
1960 goto retry;
1961 }
1962 end:
1963 return ret;
1964 }
1965
1966 static
1967 int bt_ctf_field_structure_serialize(struct bt_ctf_field *field,
1968 struct ctf_stream_pos *pos)
1969 {
1970 size_t i;
1971 int ret = 0;
1972 struct bt_ctf_field_structure *structure = container_of(
1973 field, struct bt_ctf_field_structure, parent);
1974
1975 while (!ctf_pos_access_ok(pos,
1976 offset_align(pos->offset,
1977 field->type->declaration->alignment))) {
1978 ret = increase_packet_size(pos);
1979 if (ret) {
1980 goto end;
1981 }
1982 }
1983
1984 if (!ctf_align_pos(pos, field->type->declaration->alignment)) {
1985 ret = -1;
1986 goto end;
1987 }
1988
1989 for (i = 0; i < structure->fields->len; i++) {
1990 struct bt_ctf_field *member = g_ptr_array_index(
1991 structure->fields, i);
1992
1993 ret = bt_ctf_field_serialize(member, pos);
1994 if (ret) {
1995 const char *name;
1996 struct bt_ctf_field_type *structure_type =
1997 bt_ctf_field_get_type(field);
1998
1999 (void) bt_ctf_field_type_structure_get_field(
2000 structure_type, &name, NULL, i);
2001 fprintf(stderr, "Field %s failed to serialize\n",
2002 name ? name : "NULL");
2003 bt_put(structure_type);
2004 break;
2005 }
2006 }
2007 end:
2008 return ret;
2009 }
2010
2011 static
2012 int bt_ctf_field_variant_serialize(struct bt_ctf_field *field,
2013 struct ctf_stream_pos *pos)
2014 {
2015 struct bt_ctf_field_variant *variant = container_of(
2016 field, struct bt_ctf_field_variant, parent);
2017
2018 return bt_ctf_field_serialize(variant->payload, pos);
2019 }
2020
2021 static
2022 int bt_ctf_field_array_serialize(struct bt_ctf_field *field,
2023 struct ctf_stream_pos *pos)
2024 {
2025 size_t i;
2026 int ret = 0;
2027 struct bt_ctf_field_array *array = container_of(
2028 field, struct bt_ctf_field_array, parent);
2029
2030 for (i = 0; i < array->elements->len; i++) {
2031 ret = bt_ctf_field_serialize(
2032 g_ptr_array_index(array->elements, i), pos);
2033 if (ret) {
2034 fprintf(stderr, "Failed to serialize array element #%zu\n", i);
2035 goto end;
2036 }
2037 }
2038 end:
2039 return ret;
2040 }
2041
2042 static
2043 int bt_ctf_field_sequence_serialize(struct bt_ctf_field *field,
2044 struct ctf_stream_pos *pos)
2045 {
2046 size_t i;
2047 int ret = 0;
2048 struct bt_ctf_field_sequence *sequence = container_of(
2049 field, struct bt_ctf_field_sequence, parent);
2050
2051 for (i = 0; i < sequence->elements->len; i++) {
2052 ret = bt_ctf_field_serialize(
2053 g_ptr_array_index(sequence->elements, i), pos);
2054 if (ret) {
2055 fprintf(stderr, "Failed to serialize sequence element #%zu\n", i);
2056 goto end;
2057 }
2058 }
2059 end:
2060 return ret;
2061 }
2062
2063 static
2064 int bt_ctf_field_string_serialize(struct bt_ctf_field *field,
2065 struct ctf_stream_pos *pos)
2066 {
2067 size_t i;
2068 int ret = 0;
2069 struct bt_ctf_field_string *string = container_of(field,
2070 struct bt_ctf_field_string, parent);
2071 struct bt_ctf_field_type *character_type =
2072 get_field_type(FIELD_TYPE_ALIAS_UINT8_T);
2073 struct bt_ctf_field *character = bt_ctf_field_create(character_type);
2074
2075 for (i = 0; i < string->payload->len + 1; i++) {
2076 ret = bt_ctf_field_unsigned_integer_set_value(character,
2077 (uint64_t) string->payload->str[i]);
2078 if (ret) {
2079 goto end;
2080 }
2081
2082 ret = bt_ctf_field_integer_serialize(character, pos);
2083 if (ret) {
2084 goto end;
2085 }
2086 }
2087 end:
2088 bt_put(character);
2089 bt_put(character_type);
2090 return ret;
2091 }
2092
2093 static
2094 int bt_ctf_field_integer_copy(struct bt_ctf_field *src,
2095 struct bt_ctf_field *dst)
2096 {
2097 struct bt_ctf_field_integer *integer_src, *integer_dst;
2098
2099 integer_src = container_of(src, struct bt_ctf_field_integer, parent);
2100 integer_dst = container_of(dst, struct bt_ctf_field_integer, parent);
2101
2102 memcpy(&integer_dst->definition, &integer_src->definition,
2103 sizeof(struct definition_integer));
2104 return 0;
2105 }
2106
2107 static
2108 int bt_ctf_field_enumeration_copy(struct bt_ctf_field *src,
2109 struct bt_ctf_field *dst)
2110 {
2111 int ret = 0;
2112 struct bt_ctf_field_enumeration *enum_src, *enum_dst;
2113
2114 enum_src = container_of(src, struct bt_ctf_field_enumeration, parent);
2115 enum_dst = container_of(dst, struct bt_ctf_field_enumeration, parent);
2116
2117 if (enum_src->payload) {
2118 enum_dst->payload = bt_ctf_field_copy(enum_src->payload);
2119 if (!enum_dst->payload) {
2120 ret = -1;
2121 goto end;
2122 }
2123 }
2124 end:
2125 return ret;
2126 }
2127
2128 static
2129 int bt_ctf_field_floating_point_copy(
2130 struct bt_ctf_field *src, struct bt_ctf_field *dst)
2131 {
2132 struct bt_ctf_field_floating_point *float_src, *float_dst;
2133
2134 float_src = container_of(src, struct bt_ctf_field_floating_point,
2135 parent);
2136 float_dst = container_of(dst, struct bt_ctf_field_floating_point,
2137 parent);
2138
2139 memcpy(&float_dst->definition, &float_src->definition,
2140 sizeof(struct definition_float));
2141 memcpy(&float_dst->sign, &float_src->sign,
2142 sizeof(struct definition_integer));
2143 memcpy(&float_dst->mantissa, &float_src->mantissa,
2144 sizeof(struct definition_integer));
2145 memcpy(&float_dst->exp, &float_src->exp,
2146 sizeof(struct definition_integer));
2147 return 0;
2148 }
2149
2150 static
2151 int bt_ctf_field_structure_copy(struct bt_ctf_field *src,
2152 struct bt_ctf_field *dst)
2153 {
2154 int ret = 0, i;
2155 struct bt_ctf_field_structure *struct_src, *struct_dst;
2156
2157 struct_src = container_of(src, struct bt_ctf_field_structure, parent);
2158 struct_dst = container_of(dst, struct bt_ctf_field_structure, parent);
2159
2160 /* This field_name_to_index HT is owned by the structure field type */
2161 struct_dst->field_name_to_index = struct_src->field_name_to_index;
2162 g_ptr_array_set_size(struct_dst->fields, struct_src->fields->len);
2163
2164 for (i = 0; i < struct_src->fields->len; i++) {
2165 struct bt_ctf_field *field =
2166 g_ptr_array_index(struct_src->fields, i);
2167 struct bt_ctf_field *field_copy = NULL;
2168
2169 if (field) {
2170 field_copy = bt_ctf_field_copy(field);
2171
2172 if (!field_copy) {
2173 ret = -1;
2174 goto end;
2175 }
2176 }
2177
2178 g_ptr_array_index(struct_dst->fields, i) = field_copy;
2179 }
2180 end:
2181 return ret;
2182 }
2183
2184 static
2185 int bt_ctf_field_variant_copy(struct bt_ctf_field *src,
2186 struct bt_ctf_field *dst)
2187 {
2188 int ret = 0;
2189 struct bt_ctf_field_variant *variant_src, *variant_dst;
2190
2191 variant_src = container_of(src, struct bt_ctf_field_variant, parent);
2192 variant_dst = container_of(dst, struct bt_ctf_field_variant, parent);
2193
2194 if (variant_src->tag) {
2195 variant_dst->tag = bt_ctf_field_copy(variant_src->tag);
2196 if (!variant_dst->tag) {
2197 ret = -1;
2198 goto end;
2199 }
2200 }
2201 if (variant_src->payload) {
2202 variant_dst->payload = bt_ctf_field_copy(variant_src->payload);
2203 if (!variant_dst->payload) {
2204 ret = -1;
2205 goto end;
2206 }
2207 }
2208 end:
2209 return ret;
2210 }
2211
2212 static
2213 int bt_ctf_field_array_copy(struct bt_ctf_field *src,
2214 struct bt_ctf_field *dst)
2215 {
2216 int ret = 0, i;
2217 struct bt_ctf_field_array *array_src, *array_dst;
2218
2219 array_src = container_of(src, struct bt_ctf_field_array, parent);
2220 array_dst = container_of(dst, struct bt_ctf_field_array, parent);
2221
2222 g_ptr_array_set_size(array_dst->elements, array_src->elements->len);
2223 for (i = 0; i < array_src->elements->len; i++) {
2224 struct bt_ctf_field *field =
2225 g_ptr_array_index(array_src->elements, i);
2226 struct bt_ctf_field *field_copy = NULL;
2227
2228 if (field) {
2229 field_copy = bt_ctf_field_copy(field);
2230
2231 if (!field_copy) {
2232 ret = -1;
2233 goto end;
2234 }
2235 }
2236
2237 g_ptr_array_index(array_dst->elements, i) = field_copy;
2238 }
2239 end:
2240 return ret;
2241 }
2242
2243 static
2244 int bt_ctf_field_sequence_copy(struct bt_ctf_field *src,
2245 struct bt_ctf_field *dst)
2246 {
2247 int ret = 0, i;
2248 struct bt_ctf_field_sequence *sequence_src, *sequence_dst;
2249 struct bt_ctf_field *src_length;
2250 struct bt_ctf_field *dst_length;
2251
2252 sequence_src = container_of(src, struct bt_ctf_field_sequence, parent);
2253 sequence_dst = container_of(dst, struct bt_ctf_field_sequence, parent);
2254
2255 src_length = bt_ctf_field_sequence_get_length(src);
2256
2257 if (!src_length) {
2258 /* no length set yet: keep destination sequence empty */
2259 goto end;
2260 }
2261
2262 /* copy source length */
2263 dst_length = bt_ctf_field_copy(src_length);
2264 bt_put(src_length);
2265
2266 if (!dst_length) {
2267 ret = -1;
2268 goto end;
2269 }
2270
2271 /* this will initialize the destination sequence's internal array */
2272 ret = bt_ctf_field_sequence_set_length(dst, dst_length);
2273 bt_put(dst_length);
2274
2275 if (ret) {
2276 goto end;
2277 }
2278
2279 assert(sequence_dst->elements->len == sequence_src->elements->len);
2280
2281 for (i = 0; i < sequence_src->elements->len; i++) {
2282 struct bt_ctf_field *field =
2283 g_ptr_array_index(sequence_src->elements, i);
2284 struct bt_ctf_field *field_copy = NULL;
2285
2286 if (field) {
2287 field_copy = bt_ctf_field_copy(field);
2288
2289 if (!field_copy) {
2290 ret = -1;
2291 goto end;
2292 }
2293 }
2294
2295 g_ptr_array_index(sequence_dst->elements, i) = field_copy;
2296 }
2297 end:
2298 return ret;
2299 }
2300
2301 static
2302 int bt_ctf_field_string_copy(struct bt_ctf_field *src,
2303 struct bt_ctf_field *dst)
2304 {
2305 int ret = 0;
2306 struct bt_ctf_field_string *string_src, *string_dst;
2307
2308 string_src = container_of(src, struct bt_ctf_field_string, parent);
2309 string_dst = container_of(dst, struct bt_ctf_field_string, parent);
2310
2311 if (string_src->payload) {
2312 string_dst->payload = g_string_new(string_src->payload->str);
2313 if (!string_dst->payload) {
2314 ret = -1;
2315 goto end;
2316 }
2317 }
2318 end:
2319 return ret;
2320 }
2321
2322 static
2323 int increase_packet_size(struct ctf_stream_pos *pos)
2324 {
2325 int ret;
2326
2327 assert(pos);
2328 ret = munmap_align(pos->base_mma);
2329 if (ret) {
2330 goto end;
2331 }
2332
2333 pos->packet_size += PACKET_LEN_INCREMENT;
2334 do {
2335 ret = bt_posix_fallocate(pos->fd, pos->mmap_offset,
2336 pos->packet_size / CHAR_BIT);
2337 } while (ret == EINTR);
2338 if (ret) {
2339 errno = EINTR;
2340 ret = -1;
2341 goto end;
2342 }
2343
2344 pos->base_mma = mmap_align(pos->packet_size / CHAR_BIT, pos->prot,
2345 pos->flags, pos->fd, pos->mmap_offset);
2346 if (pos->base_mma == MAP_FAILED) {
2347 ret = -1;
2348 }
2349 end:
2350 return ret;
2351 }
2352
2353 static
2354 void generic_field_freeze(struct bt_ctf_field *field)
2355 {
2356 field->frozen = 1;
2357 }
2358
2359 static
2360 void bt_ctf_field_enumeration_freeze(struct bt_ctf_field *field)
2361 {
2362 struct bt_ctf_field_enumeration *enum_field =
2363 container_of(field, struct bt_ctf_field_enumeration, parent);
2364
2365 bt_ctf_field_freeze(enum_field->payload);
2366 generic_field_freeze(field);
2367 }
2368
2369 static
2370 void bt_ctf_field_structure_freeze(struct bt_ctf_field *field)
2371 {
2372 int i;
2373 struct bt_ctf_field_structure *structure_field =
2374 container_of(field, struct bt_ctf_field_structure, parent);
2375
2376 for (i = 0; i < structure_field->fields->len; i++) {
2377 struct bt_ctf_field *field =
2378 g_ptr_array_index(structure_field->fields, i);
2379
2380 bt_ctf_field_freeze(field);
2381 }
2382
2383 generic_field_freeze(field);
2384 }
2385
2386 static
2387 void bt_ctf_field_variant_freeze(struct bt_ctf_field *field)
2388 {
2389 struct bt_ctf_field_variant *variant_field =
2390 container_of(field, struct bt_ctf_field_variant, parent);
2391
2392 bt_ctf_field_freeze(variant_field->tag);
2393 bt_ctf_field_freeze(variant_field->payload);
2394 generic_field_freeze(field);
2395 }
2396
2397 static
2398 void bt_ctf_field_array_freeze(struct bt_ctf_field *field)
2399 {
2400 int i;
2401 struct bt_ctf_field_array *array_field =
2402 container_of(field, struct bt_ctf_field_array, parent);
2403
2404 for (i = 0; i < array_field->elements->len; i++) {
2405 struct bt_ctf_field *field =
2406 g_ptr_array_index(array_field->elements, i);
2407
2408 bt_ctf_field_freeze(field);
2409 }
2410
2411 generic_field_freeze(field);
2412 }
2413
2414 static
2415 void bt_ctf_field_sequence_freeze(struct bt_ctf_field *field)
2416 {
2417 int i;
2418 struct bt_ctf_field_sequence *sequence_field =
2419 container_of(field, struct bt_ctf_field_sequence, parent);
2420
2421 bt_ctf_field_freeze(sequence_field->length);
2422
2423 for (i = 0; i < sequence_field->elements->len; i++) {
2424 struct bt_ctf_field *field =
2425 g_ptr_array_index(sequence_field->elements, i);
2426
2427 bt_ctf_field_freeze(field);
2428 }
2429
2430 generic_field_freeze(field);
2431 }
2432
2433 BT_HIDDEN
2434 void bt_ctf_field_freeze(struct bt_ctf_field *field)
2435 {
2436 enum bt_ctf_type_id type_id;
2437
2438 if (!field) {
2439 goto end;
2440 }
2441
2442 type_id = bt_ctf_field_get_type_id(field);
2443 if (type_id <= BT_CTF_TYPE_ID_UNKNOWN ||
2444 type_id >= BT_CTF_NR_TYPE_IDS) {
2445 goto end;
2446 }
2447
2448 field_freeze_funcs[type_id](field);
2449 end:
2450 return;
2451 }
2452
2453 static
2454 bool bt_ctf_field_generic_is_set(struct bt_ctf_field *field)
2455 {
2456 return field && field->payload_set;
2457 }
2458
2459 static
2460 bool bt_ctf_field_enumeration_is_set(struct bt_ctf_field *field)
2461 {
2462 bool is_set = false;
2463 struct bt_ctf_field_enumeration *enumeration;
2464
2465 if (!field) {
2466 goto end;
2467 }
2468
2469 enumeration = container_of(field, struct bt_ctf_field_enumeration,
2470 parent);
2471 if (!enumeration->payload) {
2472 goto end;
2473 }
2474
2475 is_set = bt_ctf_field_is_set(enumeration->payload);
2476 end:
2477 return is_set;
2478 }
2479
2480 static
2481 bool bt_ctf_field_structure_is_set(struct bt_ctf_field *field)
2482 {
2483 bool is_set = false;
2484 size_t i;
2485 struct bt_ctf_field_structure *structure;
2486
2487 if (!field) {
2488 goto end;
2489 }
2490
2491 structure = container_of(field, struct bt_ctf_field_structure, parent);
2492 for (i = 0; i < structure->fields->len; i++) {
2493 is_set = bt_ctf_field_is_set(structure->fields->pdata[i]);
2494 if (!is_set) {
2495 goto end;
2496 }
2497 }
2498 end:
2499 return is_set;
2500 }
2501
2502 static
2503 bool bt_ctf_field_variant_is_set(struct bt_ctf_field *field)
2504 {
2505 bool is_set = false;
2506 struct bt_ctf_field_variant *variant;
2507
2508 if (!field) {
2509 goto end;
2510 }
2511
2512 variant = container_of(field, struct bt_ctf_field_variant, parent);
2513 is_set = bt_ctf_field_is_set(variant->payload);
2514 end:
2515 return is_set;
2516 }
2517
2518 static
2519 bool bt_ctf_field_array_is_set(struct bt_ctf_field *field)
2520 {
2521 size_t i;
2522 bool is_set = false;
2523 struct bt_ctf_field_array *array;
2524
2525 if (!field) {
2526 goto end;
2527 }
2528
2529 array = container_of(field, struct bt_ctf_field_array, parent);
2530 for (i = 0; i < array->elements->len; i++) {
2531 is_set = bt_ctf_field_is_set(array->elements->pdata[i]);
2532 if (!is_set) {
2533 goto end;
2534 }
2535 }
2536 end:
2537 return is_set;
2538 }
2539
2540 static
2541 bool bt_ctf_field_sequence_is_set(struct bt_ctf_field *field)
2542 {
2543 size_t i;
2544 bool is_set = false;
2545 struct bt_ctf_field_sequence *sequence;
2546
2547 if (!field) {
2548 goto end;
2549 }
2550
2551 sequence = container_of(field, struct bt_ctf_field_sequence, parent);
2552 for (i = 0; i < sequence->elements->len; i++) {
2553 is_set = bt_ctf_field_validate(sequence->elements->pdata[i]);
2554 if (!is_set) {
2555 goto end;
2556 }
2557 }
2558 end:
2559 return is_set;
2560 }
This page took 0.10616 seconds and 4 git commands to generate.