projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add tests for bt_ctf_field_string_append()
[babeltrace.git] / formats / ctf / ir / event-fields.c
CommitLineData
273b65be
JG		 1/*
2 * event-fields.c
3 *
d2dc44b6 4 * Babeltrace CTF IR - Event Fields
273b65be 5 *
de9dd397 6 * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
273b65be
JG		 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-writer/event-fields.h>
adc315b8
JG		 30#include <babeltrace/ctf-ir/event-fields-internal.h>
31#include <babeltrace/ctf-ir/event-types-internal.h>
273b65be
JG		 32#include <babeltrace/compiler.h>
33
34#define PACKET_LEN_INCREMENT (getpagesize() * 8 * CHAR_BIT)
35
36static
37struct bt_ctf_field *bt_ctf_field_integer_create(struct bt_ctf_field_type *);
38static
39struct bt_ctf_field *bt_ctf_field_enumeration_create(
40 struct bt_ctf_field_type *);
41static
42struct bt_ctf_field *bt_ctf_field_floating_point_create(
43 struct bt_ctf_field_type *);
44static
45struct bt_ctf_field *bt_ctf_field_structure_create(
46 struct bt_ctf_field_type *);
47static
48struct bt_ctf_field *bt_ctf_field_variant_create(
49 struct bt_ctf_field_type *);
50static
51struct bt_ctf_field *bt_ctf_field_array_create(
52 struct bt_ctf_field_type *);
53static
54struct bt_ctf_field *bt_ctf_field_sequence_create(
55 struct bt_ctf_field_type *);
56static
57struct bt_ctf_field *bt_ctf_field_string_create(struct bt_ctf_field_type *);
58
59static
60void bt_ctf_field_destroy(struct bt_ctf_ref *);
61static
62void bt_ctf_field_integer_destroy(struct bt_ctf_field *);
63static
64void bt_ctf_field_enumeration_destroy(struct bt_ctf_field *);
65static
66void bt_ctf_field_floating_point_destroy(struct bt_ctf_field *);
67static
68void bt_ctf_field_structure_destroy(struct bt_ctf_field *);
69static
70void bt_ctf_field_variant_destroy(struct bt_ctf_field *);
71static
72void bt_ctf_field_array_destroy(struct bt_ctf_field *);
73static
74void bt_ctf_field_sequence_destroy(struct bt_ctf_field *);
75static
76void bt_ctf_field_string_destroy(struct bt_ctf_field *);
77
78static
ca116246 79int bt_ctf_field_generic_validate(struct bt_ctf_field *);
273b65be 80static
ca116246 81int bt_ctf_field_structure_validate(struct bt_ctf_field *);
273b65be 82static
ca116246 83int bt_ctf_field_variant_validate(struct bt_ctf_field *);
273b65be 84static
ca116246 85int bt_ctf_field_enumeration_validate(struct bt_ctf_field *);
273b65be 86static
ca116246 87int bt_ctf_field_array_validate(struct bt_ctf_field *);
273b65be 88static
ca116246 89int bt_ctf_field_sequence_validate(struct bt_ctf_field *);
273b65be 90
12c8a1a3 91static
ca116246 92int bt_ctf_field_generic_reset(struct bt_ctf_field *);
12c8a1a3 93static
ca116246 94int bt_ctf_field_structure_reset(struct bt_ctf_field *);
12c8a1a3 95static
ca116246 96int bt_ctf_field_variant_reset(struct bt_ctf_field *);
12c8a1a3 97static
ca116246 98int bt_ctf_field_enumeration_reset(struct bt_ctf_field *);
12c8a1a3 99static
ca116246 100int bt_ctf_field_array_reset(struct bt_ctf_field *);
12c8a1a3 101static
ca116246 102int bt_ctf_field_sequence_reset(struct bt_ctf_field *);
12c8a1a3 103static
ca116246 104int bt_ctf_field_string_reset(struct bt_ctf_field *);
12c8a1a3 105
273b65be
JG		 106static
107int bt_ctf_field_integer_serialize(struct bt_ctf_field *,
108 struct ctf_stream_pos *);
109static
110int bt_ctf_field_enumeration_serialize(struct bt_ctf_field *,
111 struct ctf_stream_pos *);
112static
113int bt_ctf_field_floating_point_serialize(struct bt_ctf_field *,
114 struct ctf_stream_pos *);
115static
116int bt_ctf_field_structure_serialize(struct bt_ctf_field *,
117 struct ctf_stream_pos *);
118static
119int bt_ctf_field_variant_serialize(struct bt_ctf_field *,
120 struct ctf_stream_pos *);
121static
122int bt_ctf_field_array_serialize(struct bt_ctf_field *,
123 struct ctf_stream_pos *);
124static
125int bt_ctf_field_sequence_serialize(struct bt_ctf_field *,
126 struct ctf_stream_pos *);
127static
128int bt_ctf_field_string_serialize(struct bt_ctf_field *,
129 struct ctf_stream_pos *);
130
87d43dc1
JG		 131static
132int bt_ctf_field_integer_copy(struct bt_ctf_field *, struct bt_ctf_field *);
133static
134int bt_ctf_field_enumeration_copy(struct bt_ctf_field *, struct bt_ctf_field *);
135static
136int bt_ctf_field_floating_point_copy(struct bt_ctf_field *,
137 struct bt_ctf_field *);
138static
139int bt_ctf_field_structure_copy(struct bt_ctf_field *, struct bt_ctf_field *);
140static
141int bt_ctf_field_variant_copy(struct bt_ctf_field *, struct bt_ctf_field *);
142static
143int bt_ctf_field_array_copy(struct bt_ctf_field *, struct bt_ctf_field *);
144static
145int bt_ctf_field_sequence_copy(struct bt_ctf_field *, struct bt_ctf_field *);
146static
147int bt_ctf_field_string_copy(struct bt_ctf_field *, struct bt_ctf_field *);
148
273b65be
JG		 149static
150int increase_packet_size(struct ctf_stream_pos *pos);
151
152static
ce6da4fd 153struct bt_ctf_field *(* const field_create_funcs[])(
273b65be
JG		 154 struct bt_ctf_field_type *) = {
155 [CTF_TYPE_INTEGER] = bt_ctf_field_integer_create,
156 [CTF_TYPE_ENUM] = bt_ctf_field_enumeration_create,
157 [CTF_TYPE_FLOAT] =
158 bt_ctf_field_floating_point_create,
159 [CTF_TYPE_STRUCT] = bt_ctf_field_structure_create,
160 [CTF_TYPE_VARIANT] = bt_ctf_field_variant_create,
161 [CTF_TYPE_ARRAY] = bt_ctf_field_array_create,
162 [CTF_TYPE_SEQUENCE] = bt_ctf_field_sequence_create,
163 [CTF_TYPE_STRING] = bt_ctf_field_string_create,
164};
165
166static
ce6da4fd 167void (* const field_destroy_funcs[])(struct bt_ctf_field *) = {
273b65be
JG		 168 [CTF_TYPE_INTEGER] = bt_ctf_field_integer_destroy,
169 [CTF_TYPE_ENUM] = bt_ctf_field_enumeration_destroy,
170 [CTF_TYPE_FLOAT] =
171 bt_ctf_field_floating_point_destroy,
172 [CTF_TYPE_STRUCT] = bt_ctf_field_structure_destroy,
173 [CTF_TYPE_VARIANT] = bt_ctf_field_variant_destroy,
174 [CTF_TYPE_ARRAY] = bt_ctf_field_array_destroy,
175 [CTF_TYPE_SEQUENCE] = bt_ctf_field_sequence_destroy,
176 [CTF_TYPE_STRING] = bt_ctf_field_string_destroy,
177};
178
179static
ce6da4fd 180int (* const field_validate_funcs[])(struct bt_ctf_field *) = {
273b65be
JG		 181 [CTF_TYPE_INTEGER] = bt_ctf_field_generic_validate,
182 [CTF_TYPE_ENUM] = bt_ctf_field_enumeration_validate,
183 [CTF_TYPE_FLOAT] = bt_ctf_field_generic_validate,
184 [CTF_TYPE_STRUCT] = bt_ctf_field_structure_validate,
185 [CTF_TYPE_VARIANT] = bt_ctf_field_variant_validate,
186 [CTF_TYPE_ARRAY] = bt_ctf_field_array_validate,
187 [CTF_TYPE_SEQUENCE] = bt_ctf_field_sequence_validate,
188 [CTF_TYPE_STRING] = bt_ctf_field_generic_validate,
189};
190
12c8a1a3 191static
ce6da4fd 192int (* const field_reset_funcs[])(struct bt_ctf_field *) = {
12c8a1a3
JG		 193 [CTF_TYPE_INTEGER] = bt_ctf_field_generic_reset,
194 [CTF_TYPE_ENUM] = bt_ctf_field_enumeration_reset,
195 [CTF_TYPE_FLOAT] = bt_ctf_field_generic_reset,
196 [CTF_TYPE_STRUCT] = bt_ctf_field_structure_reset,
197 [CTF_TYPE_VARIANT] = bt_ctf_field_variant_reset,
198 [CTF_TYPE_ARRAY] = bt_ctf_field_array_reset,
199 [CTF_TYPE_SEQUENCE] = bt_ctf_field_sequence_reset,
200 [CTF_TYPE_STRING] = bt_ctf_field_string_reset,
201};
202
273b65be 203static
ce6da4fd 204int (* const field_serialize_funcs[])(struct bt_ctf_field *,
273b65be
JG		 205 struct ctf_stream_pos *) = {
206 [CTF_TYPE_INTEGER] = bt_ctf_field_integer_serialize,
207 [CTF_TYPE_ENUM] = bt_ctf_field_enumeration_serialize,
208 [CTF_TYPE_FLOAT] =
209 bt_ctf_field_floating_point_serialize,
210 [CTF_TYPE_STRUCT] = bt_ctf_field_structure_serialize,
211 [CTF_TYPE_VARIANT] = bt_ctf_field_variant_serialize,
212 [CTF_TYPE_ARRAY] = bt_ctf_field_array_serialize,
213 [CTF_TYPE_SEQUENCE] = bt_ctf_field_sequence_serialize,
214 [CTF_TYPE_STRING] = bt_ctf_field_string_serialize,
215};
216
87d43dc1 217static
ce6da4fd
JG		 218int (* const field_copy_funcs[])(struct bt_ctf_field *,
219 struct bt_ctf_field *) = {
87d43dc1
JG		 220 [CTF_TYPE_INTEGER] = bt_ctf_field_integer_copy,
221 [CTF_TYPE_ENUM] = bt_ctf_field_enumeration_copy,
222 [CTF_TYPE_FLOAT] = bt_ctf_field_floating_point_copy,
223 [CTF_TYPE_STRUCT] = bt_ctf_field_structure_copy,
224 [CTF_TYPE_VARIANT] = bt_ctf_field_variant_copy,
225 [CTF_TYPE_ARRAY] = bt_ctf_field_array_copy,
226 [CTF_TYPE_SEQUENCE] = bt_ctf_field_sequence_copy,
227 [CTF_TYPE_STRING] = bt_ctf_field_string_copy,
228};
229
273b65be
JG		 230struct bt_ctf_field *bt_ctf_field_create(struct bt_ctf_field_type *type)
231{
232 struct bt_ctf_field *field = NULL;
233 enum ctf_type_id type_id;
234
235 if (!type) {
236 goto error;
237 }
238
239 type_id = bt_ctf_field_type_get_type_id(type);
9ce21c30
JG		 240 if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES ||
241 bt_ctf_field_type_validate(type)) {
273b65be
JG		 242 goto error;
243 }
244
245 field = field_create_funcs[type_id](type);
246 if (!field) {
247 goto error;
248 }
249
250 /* The type's declaration can't change after this point */
251 bt_ctf_field_type_freeze(type);
252 bt_ctf_field_type_get(type);
253 bt_ctf_ref_init(&field->ref_count);
254 field->type = type;
255error:
256 return field;
257}
258
259void bt_ctf_field_get(struct bt_ctf_field *field)
260{
261 if (field) {
262 bt_ctf_ref_get(&field->ref_count);
263 }
264}
265
266void bt_ctf_field_put(struct bt_ctf_field *field)
267{
268 if (field) {
269 bt_ctf_ref_put(&field->ref_count, bt_ctf_field_destroy);
270 }
271}
272
cd95e351
JG		 273struct bt_ctf_field_type *bt_ctf_field_get_type(struct bt_ctf_field *field)
274{
275 struct bt_ctf_field_type *ret = NULL;
276
277 if (!field) {
278 goto end;
279 }
280
281 ret = field->type;
282 bt_ctf_field_type_get(ret);
283end:
284 return ret;
285}
286
287struct bt_ctf_field *bt_ctf_field_sequence_get_length(
288 struct bt_ctf_field *field)
289{
290 struct bt_ctf_field *ret = NULL;
291 struct bt_ctf_field_sequence *sequence;
292
293 if (!field) {
294 goto end;
295 }
296
297 if (bt_ctf_field_type_get_type_id(field->type) !=
298 CTF_TYPE_SEQUENCE) {
299 goto end;
300 }
301
302 sequence = container_of(field, struct bt_ctf_field_sequence, parent);
303 ret = sequence->length;
304 bt_ctf_field_get(ret);
305end:
306 return ret;
307}
308
273b65be
JG		 309int bt_ctf_field_sequence_set_length(struct bt_ctf_field *field,
310 struct bt_ctf_field *length_field)
311{
312 int ret = 0;
313 struct bt_ctf_field_type_integer *length_type;
314 struct bt_ctf_field_integer *length;
315 struct bt_ctf_field_sequence *sequence;
316 uint64_t sequence_length;
317
318 if (!field || !length_field) {
319 ret = -1;
320 goto end;
321 }
322 if (bt_ctf_field_type_get_type_id(length_field->type) !=
323 CTF_TYPE_INTEGER) {
324 ret = -1;
325 goto end;
326 }
327
328 length_type = container_of(length_field->type,
329 struct bt_ctf_field_type_integer, parent);
152e7331 330 /* The length field must be unsigned */
273b65be
JG		 331 if (length_type->declaration.signedness) {
332 ret = -1;
333 goto end;
334 }
335
336 length = container_of(length_field, struct bt_ctf_field_integer,
337 parent);
338 sequence_length = length->definition.value._unsigned;
339 sequence = container_of(field, struct bt_ctf_field_sequence, parent);
340 if (sequence->elements) {
341 g_ptr_array_free(sequence->elements, TRUE);
342 bt_ctf_field_put(sequence->length);
343 }
344
fe0fe95c 345 sequence->elements = g_ptr_array_sized_new((size_t)sequence_length);
273b65be
JG		 346 if (!sequence->elements) {
347 ret = -1;
348 goto end;
349 }
350
fe0fe95c
JG		 351 g_ptr_array_set_free_func(sequence->elements,
352 (GDestroyNotify)bt_ctf_field_put);
273b65be
JG		 353 g_ptr_array_set_size(sequence->elements, (size_t)sequence_length);
354 bt_ctf_field_get(length_field);
355 sequence->length = length_field;
356end:
357 return ret;
358}
359
360struct bt_ctf_field *bt_ctf_field_structure_get_field(
361 struct bt_ctf_field *field, const char *name)
362{
363 struct bt_ctf_field *new_field = NULL;
364 GQuark field_quark;
365 struct bt_ctf_field_structure *structure;
b92ddaaa 366 struct bt_ctf_field_type *field_type = NULL;
273b65be
JG		 367 size_t index;
368
369 if (!field || !name ||
370 bt_ctf_field_type_get_type_id(field->type) !=
371 CTF_TYPE_STRUCT) {
372 goto error;
373 }
374
375 field_quark = g_quark_from_string(name);
376 structure = container_of(field, struct bt_ctf_field_structure, parent);
b92ddaaa
JG		 377 field_type =
378 bt_ctf_field_type_structure_get_field_type_by_name(field->type,
379 name);
273b65be
JG		 380 if (!g_hash_table_lookup_extended(structure->field_name_to_index,
381 GUINT_TO_POINTER(field_quark), NULL, (gpointer *)&index)) {
382 goto error;
383 }
384
385 if (structure->fields->pdata[index]) {
386 new_field = structure->fields->pdata[index];
387 goto end;
388 }
389
390 new_field = bt_ctf_field_create(field_type);
391 if (!new_field) {
392 goto error;
393 }
394
395 structure->fields->pdata[index] = new_field;
396end:
397 bt_ctf_field_get(new_field);
398error:
b92ddaaa
JG		 399 if (field_type) {
400 bt_ctf_field_type_put(field_type);
401 }
273b65be
JG		 402 return new_field;
403}
404
cd95e351 405struct bt_ctf_field *bt_ctf_field_structure_get_field_by_index(
074ee56d 406 struct bt_ctf_field *field, int index)
cd95e351
JG		 407{
408 int ret;
409 const char *field_name;
410 struct bt_ctf_field_structure *structure;
411 struct bt_ctf_field_type *structure_type;
412 struct bt_ctf_field_type *field_type = NULL;
413 struct bt_ctf_field *ret_field = NULL;
414
415 if (!field ||
416 bt_ctf_field_type_get_type_id(field->type) != CTF_TYPE_STRUCT) {
417 goto end;
418 }
419
420 structure = container_of(field, struct bt_ctf_field_structure, parent);
421 if (index >= structure->fields->len) {
422 goto error;
423 }
424
425 ret_field = structure->fields->pdata[index];
426 if (ret_field) {
427 goto end;
428 }
429
430 /* Field has not been instanciated yet, create it */
431 structure_type = bt_ctf_field_get_type(field);
432 if (!structure_type) {
433 goto error;
434 }
435
436 ret = bt_ctf_field_type_structure_get_field(structure_type,
437 &field_name, &field_type, index);
438 bt_ctf_field_type_put(structure_type);
439 if (ret) {
440 goto error;
441 }
442
443 ret_field = bt_ctf_field_create(field_type);
444 if (!ret_field) {
445 goto error;
446 }
447
448 structure->fields->pdata[index] = ret_field;
449end:
450 bt_ctf_field_get(ret_field);
451error:
452 if (field_type) {
453 bt_ctf_field_type_put(field_type);
454 }
455 return ret_field;
456}
457
273b65be
JG		 458BT_HIDDEN
459int bt_ctf_field_structure_set_field(struct bt_ctf_field *field,
460 const char *name, struct bt_ctf_field *value)
461{
462 int ret = 0;
463 GQuark field_quark;
464 struct bt_ctf_field_structure *structure;
b92ddaaa 465 struct bt_ctf_field_type *expected_field_type = NULL;
273b65be
JG		 466 size_t index;
467
468 if (!field || !name || !value ||
469 bt_ctf_field_type_get_type_id(field->type) !=
470 CTF_TYPE_STRUCT) {
471 ret = -1;
472 goto end;
473 }
474
475 field_quark = g_quark_from_string(name);
476 structure = container_of(field, struct bt_ctf_field_structure, parent);
b92ddaaa
JG		 477 expected_field_type =
478 bt_ctf_field_type_structure_get_field_type_by_name(field->type,
479 name);
273b65be
JG		 480 if (expected_field_type != value->type) {
481 ret = -1;
482 goto end;
483 }
484
485 if (!g_hash_table_lookup_extended(structure->field_name_to_index,
486 GUINT_TO_POINTER(field_quark), NULL, (gpointer *) &index)) {
487 goto end;
488 }
489
490 if (structure->fields->pdata[index]) {
491 bt_ctf_field_put(structure->fields->pdata[index]);
492 }
493
494 structure->fields->pdata[index] = value;
495 bt_ctf_field_get(value);
496end:
b92ddaaa
JG		 497 if (expected_field_type) {
498 bt_ctf_field_type_put(expected_field_type);
499 }
273b65be
JG		 500 return ret;
501}
502
503struct bt_ctf_field *bt_ctf_field_array_get_field(struct bt_ctf_field *field,
504 uint64_t index)
505{
506 struct bt_ctf_field *new_field = NULL;
b92ddaaa 507 struct bt_ctf_field_type *field_type = NULL;
273b65be 508 struct bt_ctf_field_array *array;
273b65be
JG		 509
510 if (!field || bt_ctf_field_type_get_type_id(field->type) !=
511 CTF_TYPE_ARRAY) {
512 goto end;
513 }
514
515 array = container_of(field, struct bt_ctf_field_array, parent);
516 if (index >= array->elements->len) {
517 goto end;
518 }
519
b92ddaaa 520 field_type = bt_ctf_field_type_array_get_element_type(field->type);
273b65be
JG		 521 if (array->elements->pdata[(size_t)index]) {
522 new_field = array->elements->pdata[(size_t)index];
523 goto end;
524 }
525
526 new_field = bt_ctf_field_create(field_type);
527 bt_ctf_field_get(new_field);
528 array->elements->pdata[(size_t)index] = new_field;
529end:
b92ddaaa
JG		 530 if (field_type) {
531 bt_ctf_field_type_put(field_type);
532 }
273b65be
JG		 533 return new_field;
534}
535
536struct bt_ctf_field *bt_ctf_field_sequence_get_field(struct bt_ctf_field *field,
537 uint64_t index)
538{
539 struct bt_ctf_field *new_field = NULL;
b92ddaaa 540 struct bt_ctf_field_type *field_type = NULL;
273b65be 541 struct bt_ctf_field_sequence *sequence;
273b65be
JG		 542
543 if (!field || bt_ctf_field_type_get_type_id(field->type) !=
544 CTF_TYPE_SEQUENCE) {
545 goto end;
546 }
547
548 sequence = container_of(field, struct bt_ctf_field_sequence, parent);
549 if (!sequence->elements || sequence->elements->len <= index) {
550 goto end;
551 }
552
b92ddaaa 553 field_type = bt_ctf_field_type_sequence_get_element_type(field->type);
273b65be
JG		 554 if (sequence->elements->pdata[(size_t)index]) {
555 new_field = sequence->elements->pdata[(size_t)index];
556 goto end;
557 }
558
559 new_field = bt_ctf_field_create(field_type);
560 bt_ctf_field_get(new_field);
561 sequence->elements->pdata[(size_t)index] = new_field;
562end:
b92ddaaa
JG		 563 if (field_type) {
564 bt_ctf_field_type_put(field_type);
565 }
273b65be
JG		 566 return new_field;
567}
568
569struct bt_ctf_field *bt_ctf_field_variant_get_field(struct bt_ctf_field *field,
570 struct bt_ctf_field *tag_field)
571{
572 struct bt_ctf_field *new_field = NULL;
573 struct bt_ctf_field_variant *variant;
574 struct bt_ctf_field_type_variant *variant_type;
575 struct bt_ctf_field_type *field_type;
576 struct bt_ctf_field *tag_enum = NULL;
577 struct bt_ctf_field_integer *tag_enum_integer;
578 int64_t tag_enum_value;
579
580 if (!field || !tag_field ||
581 bt_ctf_field_type_get_type_id(field->type) !=
582 CTF_TYPE_VARIANT ||
583 bt_ctf_field_type_get_type_id(tag_field->type) !=
584 CTF_TYPE_ENUM) {
585 goto end;
586 }
587
588 variant = container_of(field, struct bt_ctf_field_variant, parent);
589 variant_type = container_of(field->type,
590 struct bt_ctf_field_type_variant, parent);
591 tag_enum = bt_ctf_field_enumeration_get_container(tag_field);
592 if (!tag_enum) {
593 goto end;
594 }
595
596 tag_enum_integer = container_of(tag_enum, struct bt_ctf_field_integer,
597 parent);
598
2c661a4d 599 if (bt_ctf_field_validate(tag_field) < 0) {
273b65be
JG		 600 goto end;
601 }
602
603 tag_enum_value = tag_enum_integer->definition.value._signed;
b92ddaaa
JG		 604 field_type = bt_ctf_field_type_variant_get_field_type_signed(
605 variant_type, tag_enum_value);
273b65be
JG		 606 if (!field_type) {
607 goto end;
608 }
609
610 new_field = bt_ctf_field_create(field_type);
611 if (!new_field) {
612 goto end;
613 }
614
615 bt_ctf_field_put(variant->tag);
616 bt_ctf_field_put(variant->payload);
617 bt_ctf_field_get(new_field);
618 bt_ctf_field_get(tag_field);
619 variant->tag = tag_field;
620 variant->payload = new_field;
621end:
622 bt_ctf_field_put(tag_enum);
623 return new_field;
624}
625
626struct bt_ctf_field *bt_ctf_field_enumeration_get_container(
627 struct bt_ctf_field *field)
628{
629 struct bt_ctf_field *container = NULL;
630 struct bt_ctf_field_enumeration *enumeration;
631
b92ddaaa
JG		 632 if (!field || bt_ctf_field_type_get_type_id(field->type) !=
633 CTF_TYPE_ENUM) {
273b65be
JG		 634 goto end;
635 }
636
637 enumeration = container_of(field, struct bt_ctf_field_enumeration,
638 parent);
639 if (!enumeration->payload) {
640 struct bt_ctf_field_type_enumeration *enumeration_type =
641 container_of(field->type,
642 struct bt_ctf_field_type_enumeration, parent);
643 enumeration->payload =
644 bt_ctf_field_create(enumeration_type->container);
645 }
646
647 container = enumeration->payload;
648 bt_ctf_field_get(container);
649end:
650 return container;
651}
652
cd95e351
JG		 653const char *bt_ctf_field_enumeration_get_mapping_name(
654 struct bt_ctf_field *field)
655{
656 int ret;
657 const char *name = NULL;
658 struct bt_ctf_field *container = NULL;
659 struct bt_ctf_field_type *container_type = NULL;
660 struct bt_ctf_field_type_integer *integer_type = NULL;
661 struct bt_ctf_field_type_enumeration *enumeration_type = NULL;
662
663 container = bt_ctf_field_enumeration_get_container(field);
664 if (!container) {
665 goto end;
666 }
667
668 container_type = bt_ctf_field_get_type(container);
669 if (!container_type) {
670 goto error_put_container;
671 }
672
673 integer_type = container_of(container_type,
674 struct bt_ctf_field_type_integer, parent);
675 enumeration_type = container_of(field->type,
676 struct bt_ctf_field_type_enumeration, parent);
677
10817e06 678 if (!integer_type->declaration.signedness) {
cd95e351
JG		 679 uint64_t value;
680 ret = bt_ctf_field_unsigned_integer_get_value(container,
681 &value);
682 if (ret) {
683 goto error_put_container_type;
684 }
685
686 name = bt_ctf_field_type_enumeration_get_mapping_name_unsigned(
687 enumeration_type, value);
688 } else {
689 int64_t value;
690 ret = bt_ctf_field_signed_integer_get_value(container,
691 &value);
692 if (ret) {
693 goto error_put_container_type;
694 }
695
696 name = bt_ctf_field_type_enumeration_get_mapping_name_signed(
697 enumeration_type, value);
698 }
699
700error_put_container_type:
701 bt_ctf_field_type_put(container_type);
702error_put_container:
703 bt_ctf_field_put(container);
704end:
705 return name;
706}
707
708int bt_ctf_field_signed_integer_get_value(struct bt_ctf_field *field,
709 int64_t *value)
710{
711 int ret = 0;
712 struct bt_ctf_field_integer *integer;
713 struct bt_ctf_field_type_integer *integer_type;
714
715 if (!field || !value || !field->payload_set ||
716 bt_ctf_field_type_get_type_id(field->type) !=
717 CTF_TYPE_INTEGER) {
718 ret = -1;
719 goto end;
720 }
721
722 integer_type = container_of(field->type,
723 struct bt_ctf_field_type_integer, parent);
724 if (!integer_type->declaration.signedness) {
725 ret = -1;
726 goto end;
727 }
728
729 integer = container_of(field,
730 struct bt_ctf_field_integer, parent);
731 *value = integer->definition.value._signed;
732end:
733 return ret;
734}
735
273b65be
JG		 736int bt_ctf_field_signed_integer_set_value(struct bt_ctf_field *field,
737 int64_t value)
738{
739 int ret = 0;
740 struct bt_ctf_field_integer *integer;
741 struct bt_ctf_field_type_integer *integer_type;
742 unsigned int size;
743 int64_t min_value, max_value;
744
745 if (!field ||
746 bt_ctf_field_type_get_type_id(field->type) !=
747 CTF_TYPE_INTEGER) {
748 ret = -1;
749 goto end;
750 }
751
752 integer = container_of(field, struct bt_ctf_field_integer, parent);
753 integer_type = container_of(field->type,
754 struct bt_ctf_field_type_integer, parent);
755 if (!integer_type->declaration.signedness) {
756 ret = -1;
757 goto end;
758 }
759
760 size = integer_type->declaration.len;
761 min_value = -((int64_t)1 << (size - 1));
762 max_value = ((int64_t)1 << (size - 1)) - 1;
763 if (value < min_value || value > max_value) {
764 ret = -1;
765 goto end;
766 }
767
768 integer->definition.value._signed = value;
769 integer->parent.payload_set = 1;
770end:
771 return ret;
772}
773
cd95e351
JG		 774int bt_ctf_field_unsigned_integer_get_value(struct bt_ctf_field *field,
775 uint64_t *value)
776{
777 int ret = 0;
778 struct bt_ctf_field_integer *integer;
779 struct bt_ctf_field_type_integer *integer_type;
780
781 if (!field || !value || !field->payload_set ||
782 bt_ctf_field_type_get_type_id(field->type) !=
783 CTF_TYPE_INTEGER) {
784 ret = -1;
785 goto end;
786 }
787
788 integer_type = container_of(field->type,
789 struct bt_ctf_field_type_integer, parent);
790 if (integer_type->declaration.signedness) {
791 ret = -1;
792 goto end;
793 }
794
795 integer = container_of(field,
796 struct bt_ctf_field_integer, parent);
797 *value = integer->definition.value._unsigned;
798end:
799 return ret;
800}
801
273b65be
JG		 802int bt_ctf_field_unsigned_integer_set_value(struct bt_ctf_field *field,
803 uint64_t value)
804{
805 int ret = 0;
806 struct bt_ctf_field_integer *integer;
807 struct bt_ctf_field_type_integer *integer_type;
808 unsigned int size;
809 uint64_t max_value;
810
811 if (!field ||
812 bt_ctf_field_type_get_type_id(field->type) !=
813 CTF_TYPE_INTEGER) {
814 ret = -1;
815 goto end;
816 }
817
818 integer = container_of(field, struct bt_ctf_field_integer, parent);
819 integer_type = container_of(field->type,
820 struct bt_ctf_field_type_integer, parent);
821 if (integer_type->declaration.signedness) {
822 ret = -1;
823 goto end;
824 }
825
826 size = integer_type->declaration.len;
827 max_value = (size == 64) ? UINT64_MAX : ((uint64_t)1 << size) - 1;
828 if (value > max_value) {
829 ret = -1;
830 goto end;
831 }
832
833 integer->definition.value._unsigned = value;
834 integer->parent.payload_set = 1;
835end:
836 return ret;
837}
838
cd95e351
JG		 839int bt_ctf_field_floating_point_get_value(struct bt_ctf_field *field,
840 double *value)
841{
842 int ret = 0;
843 struct bt_ctf_field_floating_point *floating_point;
844
845 if (!field || !value || !field->payload_set ||
846 bt_ctf_field_type_get_type_id(field->type) !=
847 CTF_TYPE_FLOAT) {
848 ret = -1;
849 goto end;
850 }
851
852 floating_point = container_of(field,
853 struct bt_ctf_field_floating_point, parent);
854 *value = floating_point->definition.value;
855end:
856 return ret;
857}
858
273b65be
JG		 859int bt_ctf_field_floating_point_set_value(struct bt_ctf_field *field,
860 double value)
861{
862 int ret = 0;
863 struct bt_ctf_field_floating_point *floating_point;
864
865 if (!field ||
866 bt_ctf_field_type_get_type_id(field->type) !=
867 CTF_TYPE_FLOAT) {
868 ret = -1;
869 goto end;
870 }
871 floating_point = container_of(field, struct bt_ctf_field_floating_point,
872 parent);
873 floating_point->definition.value = value;
874 floating_point->parent.payload_set = 1;
875end:
876 return ret;
877}
878
cd95e351
JG		 879const char *bt_ctf_field_string_get_value(struct bt_ctf_field *field)
880{
881 const char *ret = NULL;
882 struct bt_ctf_field_string *string;
883
884 if (!field || !field->payload_set ||
885 bt_ctf_field_type_get_type_id(field->type) !=
886 CTF_TYPE_STRING) {
887 goto end;
888 }
889
890 string = container_of(field,
891 struct bt_ctf_field_string, parent);
892 ret = string->payload->str;
893end:
894 return ret;
895}
896
273b65be
JG		 897int bt_ctf_field_string_set_value(struct bt_ctf_field *field,
898 const char *value)
899{
900 int ret = 0;
901 struct bt_ctf_field_string *string;
902
903 if (!field || !value ||
904 bt_ctf_field_type_get_type_id(field->type) !=
905 CTF_TYPE_STRING) {
906 ret = -1;
907 goto end;
908 }
909
910 string = container_of(field, struct bt_ctf_field_string, parent);
911 if (string->payload) {
97736814
JG		 912 g_string_assign(string->payload, value);
913 } else {
914 string->payload = g_string_new(value);
273b65be
JG		 915 }
916
273b65be
JG		 917 string->parent.payload_set = 1;
918end:
919 return ret;
920}
921
c6f9c5a3
PP		 922int bt_ctf_field_string_append(struct bt_ctf_field *field,
923 const char *value)
924{
925 int ret = 0;
926 struct bt_ctf_field_string *string_field;
927
928 if (!field || !value ||
929 bt_ctf_field_type_get_type_id(field->type) !=
930 CTF_TYPE_STRING) {
931 ret = -1;
932 goto end;
933 }
934
935 string_field = container_of(field, struct bt_ctf_field_string, parent);
936
937 if (string_field->payload) {
938 g_string_append(string_field->payload, value);
939 } else {
940 string_field->payload = g_string_new(value);
941 }
942
943 string_field->parent.payload_set = 1;
944
945end:
946 return ret;
947}
948
273b65be
JG		 949BT_HIDDEN
950int bt_ctf_field_validate(struct bt_ctf_field *field)
951{
952 int ret = 0;
953 enum ctf_type_id type_id;
954
955 if (!field) {
956 ret = -1;
957 goto end;
958 }
959
960 type_id = bt_ctf_field_type_get_type_id(field->type);
961 if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
962 ret = -1;
963 goto end;
964 }
965
966 ret = field_validate_funcs[type_id](field);
967end:
968 return ret;
969}
970
12c8a1a3
JG		 971BT_HIDDEN
972int bt_ctf_field_reset(struct bt_ctf_field *field)
973{
974 int ret = 0;
975 enum ctf_type_id type_id;
976
977 if (!field) {
978 ret = -1;
979 goto end;
980 }
981
982 type_id = bt_ctf_field_type_get_type_id(field->type);
983 if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
984 ret = -1;
985 goto end;
986 }
987
988 ret = field_reset_funcs[type_id](field);
989end:
990 return ret;
991}
992
273b65be
JG		 993BT_HIDDEN
994int bt_ctf_field_serialize(struct bt_ctf_field *field,
995 struct ctf_stream_pos *pos)
996{
997 int ret = 0;
998 enum ctf_type_id type_id;
999
1000 if (!field || !pos) {
1001 ret = -1;
1002 goto end;
1003 }
1004
1005 type_id = bt_ctf_field_type_get_type_id(field->type);
1006 if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
1007 ret = -1;
1008 goto end;
1009 }
1010
1011 ret = field_serialize_funcs[type_id](field, pos);
1012end:
1013 return ret;
1014}
1015
87d43dc1
JG		 1016BT_HIDDEN
1017struct bt_ctf_field *bt_ctf_field_copy(struct bt_ctf_field *field)
1018{
1019 int ret;
1020 struct bt_ctf_field *copy = NULL;
1021 enum ctf_type_id type_id;
1022
1023 if (!field) {
87d43dc1
JG		 1024 goto end;
1025 }
1026
1027 type_id = bt_ctf_field_type_get_type_id(field->type);
1028 if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
87d43dc1
JG		 1029 goto end;
1030 }
1031
1032 copy = bt_ctf_field_create(field->type);
1033 if (!copy) {
1034 goto end;
1035 }
1036
87d43dc1
JG		 1037 ret = field_copy_funcs[type_id](field, copy);
1038 if (ret) {
1039 bt_ctf_field_put(copy);
1040 copy = NULL;
1041 }
1042end:
1043 return copy;
1044}
1045
273b65be
JG		 1046static
1047struct bt_ctf_field *bt_ctf_field_integer_create(struct bt_ctf_field_type *type)
1048{
1049 struct bt_ctf_field_type_integer *integer_type = container_of(type,
1050 struct bt_ctf_field_type_integer, parent);
1051 struct bt_ctf_field_integer *integer = g_new0(
1052 struct bt_ctf_field_integer, 1);
1053
1054 if (integer) {
1055 integer->definition.declaration = &integer_type->declaration;
1056 }
1057
1058 return integer ? &integer->parent : NULL;
1059}
1060
1061static
1062struct bt_ctf_field *bt_ctf_field_enumeration_create(
1063 struct bt_ctf_field_type *type)
1064{
1065 struct bt_ctf_field_enumeration *enumeration = g_new0(
1066 struct bt_ctf_field_enumeration, 1);
1067
1068 return enumeration ? &enumeration->parent : NULL;
1069}
1070
1071static
1072struct bt_ctf_field *bt_ctf_field_floating_point_create(
1073 struct bt_ctf_field_type *type)
1074{
1075 struct bt_ctf_field_floating_point *floating_point;
1076 struct bt_ctf_field_type_floating_point *floating_point_type;
1077
1078 floating_point = g_new0(struct bt_ctf_field_floating_point, 1);
1079 if (!floating_point) {
1080 goto end;
1081 }
1082
1083 floating_point_type = container_of(type,
1084 struct bt_ctf_field_type_floating_point, parent);
1085 floating_point->definition.declaration = container_of(
1086 type->declaration, struct declaration_float, p);
1087
1088
1089 floating_point->definition.sign = &floating_point->sign;
1090 floating_point->sign.declaration = &floating_point_type->sign;
1091 floating_point->definition.sign->p.declaration =
1092 &floating_point_type->sign.p;
1093
1094 floating_point->definition.mantissa = &floating_point->mantissa;
1095 floating_point->mantissa.declaration = &floating_point_type->mantissa;
1096 floating_point->definition.mantissa->p.declaration =
1097 &floating_point_type->mantissa.p;
1098
1099 floating_point->definition.exp = &floating_point->exp;
1100 floating_point->exp.declaration = &floating_point_type->exp;
1101 floating_point->definition.exp->p.declaration =
1102 &floating_point_type->exp.p;
1103
1104end:
1105 return floating_point ? &floating_point->parent : NULL;
1106}
1107
1108static
1109struct bt_ctf_field *bt_ctf_field_structure_create(
1110 struct bt_ctf_field_type *type)
1111{
1112 struct bt_ctf_field_type_structure *structure_type = container_of(type,
1113 struct bt_ctf_field_type_structure, parent);
1114 struct bt_ctf_field_structure *structure = g_new0(
1115 struct bt_ctf_field_structure, 1);
1116 struct bt_ctf_field *field = NULL;
1117
1118 if (!structure || !structure_type->fields->len) {
1119 goto end;
1120 }
1121
1122 structure->field_name_to_index = structure_type->field_name_to_index;
1123 structure->fields = g_ptr_array_new_with_free_func(
1124 (GDestroyNotify)bt_ctf_field_put);
1125 g_ptr_array_set_size(structure->fields,
1126 g_hash_table_size(structure->field_name_to_index));
1127 field = &structure->parent;
1128end:
1129 return field;
1130}
1131
1132static
1133struct bt_ctf_field *bt_ctf_field_variant_create(struct bt_ctf_field_type *type)
1134{
1135 struct bt_ctf_field_variant *variant = g_new0(
1136 struct bt_ctf_field_variant, 1);
1137 return variant ? &variant->parent : NULL;
1138}
1139
1140static
1141struct bt_ctf_field *bt_ctf_field_array_create(struct bt_ctf_field_type *type)
1142{
1143 struct bt_ctf_field_array *array = g_new0(struct bt_ctf_field_array, 1);
1144 struct bt_ctf_field_type_array *array_type;
1145 unsigned int array_length;
1146
1147 if (!array || !type) {
1148 goto error;
1149 }
1150
1151 array_type = container_of(type, struct bt_ctf_field_type_array, parent);
1152 array_length = array_type->length;
fe0fe95c 1153 array->elements = g_ptr_array_sized_new(array_length);
273b65be
JG		 1154 if (!array->elements) {
1155 goto error;
1156 }
1157
fe0fe95c
JG		 1158 g_ptr_array_set_free_func(array->elements,
1159 (GDestroyNotify)bt_ctf_field_put);
273b65be
JG		 1160 g_ptr_array_set_size(array->elements, array_length);
1161 return &array->parent;
1162error:
1163 g_free(array);
1164 return NULL;
1165}
1166
1167static
1168struct bt_ctf_field *bt_ctf_field_sequence_create(
1169 struct bt_ctf_field_type *type)
1170{
1171 struct bt_ctf_field_sequence *sequence = g_new0(
1172 struct bt_ctf_field_sequence, 1);
1173 return sequence ? &sequence->parent : NULL;
1174}
1175
1176static
1177struct bt_ctf_field *bt_ctf_field_string_create(struct bt_ctf_field_type *type)
1178{
1179 struct bt_ctf_field_string *string = g_new0(
1180 struct bt_ctf_field_string, 1);
1181 return string ? &string->parent : NULL;
1182}
1183
1184static
1185void bt_ctf_field_destroy(struct bt_ctf_ref *ref)
1186{
1187 struct bt_ctf_field *field;
1188 struct bt_ctf_field_type *type;
1189 enum ctf_type_id type_id;
1190
1191 if (!ref) {
1192 return;
1193 }
1194
1195 field = container_of(ref, struct bt_ctf_field, ref_count);
1196 type = field->type;
1197 type_id = bt_ctf_field_type_get_type_id(type);
1198 if (type_id <= CTF_TYPE_UNKNOWN ||
1199 type_id >= NR_CTF_TYPES) {
1200 return;
1201 }
1202
1203 field_destroy_funcs[type_id](field);
1204 if (type) {
1205 bt_ctf_field_type_put(type);
1206 }
1207}
1208
1209static
1210void bt_ctf_field_integer_destroy(struct bt_ctf_field *field)
1211{
1212 struct bt_ctf_field_integer *integer;
1213
1214 if (!field) {
1215 return;
1216 }
1217
1218 integer = container_of(field, struct bt_ctf_field_integer, parent);
1219 g_free(integer);
1220}
1221
1222static
1223void bt_ctf_field_enumeration_destroy(struct bt_ctf_field *field)
1224{
1225 struct bt_ctf_field_enumeration *enumeration;
1226
1227 if (!field) {
1228 return;
1229 }
1230
1231 enumeration = container_of(field, struct bt_ctf_field_enumeration,
1232 parent);
1233 bt_ctf_field_put(enumeration->payload);
1234 g_free(enumeration);
1235}
1236
1237static
1238void bt_ctf_field_floating_point_destroy(struct bt_ctf_field *field)
1239{
1240 struct bt_ctf_field_floating_point *floating_point;
1241
1242 if (!field) {
1243 return;
1244 }
1245
1246 floating_point = container_of(field, struct bt_ctf_field_floating_point,
1247 parent);
1248 g_free(floating_point);
1249}
1250
1251static
1252void bt_ctf_field_structure_destroy(struct bt_ctf_field *field)
1253{
1254 struct bt_ctf_field_structure *structure;
1255
1256 if (!field) {
1257 return;
1258 }
1259
1260 structure = container_of(field, struct bt_ctf_field_structure, parent);
1261 g_ptr_array_free(structure->fields, TRUE);
1262 g_free(structure);
1263}
1264
1265static
1266void bt_ctf_field_variant_destroy(struct bt_ctf_field *field)
1267{
1268 struct bt_ctf_field_variant *variant;
1269
1270 if (!field) {
1271 return;
1272 }
1273
1274 variant = container_of(field, struct bt_ctf_field_variant, parent);
1275 bt_ctf_field_put(variant->tag);
1276 bt_ctf_field_put(variant->payload);
1277 g_free(variant);
1278}
1279
1280static
1281void bt_ctf_field_array_destroy(struct bt_ctf_field *field)
1282{
1283 struct bt_ctf_field_array *array;
1284
1285 if (!field) {
1286 return;
1287 }
1288
1289 array = container_of(field, struct bt_ctf_field_array, parent);
1290 g_ptr_array_free(array->elements, TRUE);
1291 g_free(array);
1292}
1293
1294static
1295void bt_ctf_field_sequence_destroy(struct bt_ctf_field *field)
1296{
1297 struct bt_ctf_field_sequence *sequence;
1298
1299 if (!field) {
1300 return;
1301 }
1302
1303 sequence = container_of(field, struct bt_ctf_field_sequence, parent);
1304 g_ptr_array_free(sequence->elements, TRUE);
1305 bt_ctf_field_put(sequence->length);
1306 g_free(sequence);
1307}
1308
1309static
1310void bt_ctf_field_string_destroy(struct bt_ctf_field *field)
1311{
1312 struct bt_ctf_field_string *string;
1313 if (!field) {
1314 return;
1315 }
1316
1317 string = container_of(field, struct bt_ctf_field_string, parent);
9b2b7163
JG		 1318 if (string->payload) {
1319 g_string_free(string->payload, TRUE);
1320 }
273b65be
JG		 1321 g_free(string);
1322}
1323
1324static
1325int bt_ctf_field_generic_validate(struct bt_ctf_field *field)
1326{
da2f6971 1327 return (field && field->payload_set) ? 0 : -1;
273b65be
JG		 1328}
1329
1330static
1331int bt_ctf_field_enumeration_validate(struct bt_ctf_field *field)
1332{
1333 int ret;
1334 struct bt_ctf_field_enumeration *enumeration;
1335
1336 if (!field) {
1337 ret = -1;
1338 goto end;
1339 }
1340
1341 enumeration = container_of(field, struct bt_ctf_field_enumeration,
1342 parent);
1343 if (!enumeration->payload) {
1344 ret = -1;
1345 goto end;
1346 }
1347
1348 ret = bt_ctf_field_validate(enumeration->payload);
1349end:
1350 return ret;
1351}
1352
1353static
1354int bt_ctf_field_structure_validate(struct bt_ctf_field *field)
1355{
1356 size_t i;
1357 int ret = 0;
1358 struct bt_ctf_field_structure *structure;
1359
1360 if (!field) {
1361 ret = -1;
1362 goto end;
1363 }
1364
1365 structure = container_of(field, struct bt_ctf_field_structure, parent);
1366 for (i = 0; i < structure->fields->len; i++) {
1367 ret = bt_ctf_field_validate(structure->fields->pdata[i]);
1368 if (ret) {
1369 goto end;
1370 }
1371 }
1372end:
1373 return ret;
1374}
1375
1376static
1377int bt_ctf_field_variant_validate(struct bt_ctf_field *field)
1378{
1379 int ret = 0;
1380 struct bt_ctf_field_variant *variant;
1381
1382 if (!field) {
1383 ret = -1;
1384 goto end;
1385 }
1386
1387 variant = container_of(field, struct bt_ctf_field_variant, parent);
1388 ret = bt_ctf_field_validate(variant->payload);
1389end:
1390 return ret;
1391}
1392
1393static
1394int bt_ctf_field_array_validate(struct bt_ctf_field *field)
1395{
1396 size_t i;
1397 int ret = 0;
1398 struct bt_ctf_field_array *array;
1399
1400 if (!field) {
1401 ret = -1;
1402 goto end;
1403 }
1404
1405 array = container_of(field, struct bt_ctf_field_array, parent);
1406 for (i = 0; i < array->elements->len; i++) {
1407 ret = bt_ctf_field_validate(array->elements->pdata[i]);
1408 if (ret) {
1409 goto end;
1410 }
1411 }
1412end:
1413 return ret;
1414}
1415
1416static
1417int bt_ctf_field_sequence_validate(struct bt_ctf_field *field)
1418{
1419 size_t i;
1420 int ret = 0;
1421 struct bt_ctf_field_sequence *sequence;
1422
1423 if (!field) {
1424 ret = -1;
1425 goto end;
1426 }
1427
1428 sequence = container_of(field, struct bt_ctf_field_sequence, parent);
1429 for (i = 0; i < sequence->elements->len; i++) {
1430 ret = bt_ctf_field_validate(sequence->elements->pdata[i]);
1431 if (ret) {
1432 goto end;
1433 }
1434 }
1435end:
1436 return ret;
1437}
1438
12c8a1a3
JG		 1439static
1440int bt_ctf_field_generic_reset(struct bt_ctf_field *field)
1441{
1442 int ret = 0;
1443
1444 if (!field) {
1445 ret = -1;
1446 goto end;
1447 }
1448
1449 field->payload_set = 0;
1450end:
1451 return ret;
1452}
1453
1454static
1455int bt_ctf_field_enumeration_reset(struct bt_ctf_field *field)
1456{
1457 int ret = 0;
1458 struct bt_ctf_field_enumeration *enumeration;
1459
1460 if (!field) {
1461 ret = -1;
1462 goto end;
1463 }
1464
1465 enumeration = container_of(field, struct bt_ctf_field_enumeration,
1466 parent);
1467 if (!enumeration->payload) {
1468 goto end;
1469 }
1470
1471 ret = bt_ctf_field_reset(enumeration->payload);
1472end:
1473 return ret;
1474}
1475
1476static
1477int bt_ctf_field_structure_reset(struct bt_ctf_field *field)
1478{
1479 size_t i;
1480 int ret = 0;
1481 struct bt_ctf_field_structure *structure;
1482
1483 if (!field) {
1484 ret = -1;
1485 goto end;
1486 }
1487
1488 structure = container_of(field, struct bt_ctf_field_structure, parent);
1489 for (i = 0; i < structure->fields->len; i++) {
1490 struct bt_ctf_field *member = structure->fields->pdata[i];
1491
1492 if (!member) {
1493 /*
1494 * Structure members are lazily initialized; skip if
1495 * this member has not been allocated yet.
1496 */
1497 continue;
1498 }
1499
1500 ret = bt_ctf_field_reset(member);
1501 if (ret) {
1502 goto end;
1503 }
1504 }
1505end:
1506 return ret;
1507}
1508
1509static
1510int bt_ctf_field_variant_reset(struct bt_ctf_field *field)
1511{
1512 int ret = 0;
1513 struct bt_ctf_field_variant *variant;
1514
1515 if (!field) {
1516 ret = -1;
1517 goto end;
1518 }
1519
1520 variant = container_of(field, struct bt_ctf_field_variant, parent);
1521 if (variant->payload) {
1522 ret = bt_ctf_field_reset(variant->payload);
1523 }
1524end:
1525 return ret;
1526}
1527
1528static
1529int bt_ctf_field_array_reset(struct bt_ctf_field *field)
1530{
1531 size_t i;
1532 int ret = 0;
1533 struct bt_ctf_field_array *array;
1534
1535 if (!field) {
1536 ret = -1;
1537 goto end;
1538 }
1539
1540 array = container_of(field, struct bt_ctf_field_array, parent);
1541 for (i = 0; i < array->elements->len; i++) {
1542 struct bt_ctf_field *member = array->elements->pdata[i];
1543
1544 if (!member) {
1545 /*
1546 * Array elements are lazily initialized; skip if
1547 * this member has not been allocated yet.
1548 */
1549 continue;
1550 }
1551
1552 ret = bt_ctf_field_reset(member);
1553 if (ret) {
1554 goto end;
1555 }
1556 }
1557end:
1558 return ret;
1559}
1560
1561static
1562int bt_ctf_field_sequence_reset(struct bt_ctf_field *field)
1563{
1564 size_t i;
1565 int ret = 0;
1566 struct bt_ctf_field_sequence *sequence;
1567
1568 if (!field) {
1569 ret = -1;
1570 goto end;
1571 }
1572
1573 sequence = container_of(field, struct bt_ctf_field_sequence, parent);
1574 for (i = 0; i < sequence->elements->len; i++) {
1575 struct bt_ctf_field *member = sequence->elements->pdata[i];
1576
1577 if (!member) {
1578 /*
1579 * Sequence elements are lazily initialized; skip if
1580 * this member has not been allocated yet.
1581 */
1582 continue;
1583 }
1584
1585 ret = bt_ctf_field_reset(member);
1586 if (ret) {
1587 goto end;
1588 }
1589 }
1590end:
1591 return ret;
1592}
1593
1594static
1595int bt_ctf_field_string_reset(struct bt_ctf_field *field)
1596{
1597 int ret = 0;
1598 struct bt_ctf_field_string *string;
1599
1600 if (!field) {
1601 ret = -1;
1602 goto end;
1603 }
1604
1605 ret = bt_ctf_field_generic_reset(field);
1606 if (ret) {
1607 goto end;
1608 }
1609
1610 string = container_of(field, struct bt_ctf_field_string, parent);
1611 if (string->payload) {
1612 g_string_truncate(string->payload, 0);
1613 }
1614end:
1615 return ret;
1616}
1617
273b65be
JG		 1618static
1619int bt_ctf_field_integer_serialize(struct bt_ctf_field *field,
1620 struct ctf_stream_pos *pos)
1621{
1622 int ret = 0;
1623 struct bt_ctf_field_integer *integer = container_of(field,
1624 struct bt_ctf_field_integer, parent);
1625
1626retry:
1627 ret = ctf_integer_write(&pos->parent, &integer->definition.p);
1628 if (ret == -EFAULT) {
1629 /*
1630 * The field is too large to fit in the current packet's
1631 * remaining space. Bump the packet size and retry.
1632 */
1633 ret = increase_packet_size(pos);
1634 if (ret) {
1635 goto end;
1636 }
1637 goto retry;
1638 }
1639end:
1640 return ret;
1641}
1642
1643static
1644int bt_ctf_field_enumeration_serialize(struct bt_ctf_field *field,
1645 struct ctf_stream_pos *pos)
1646{
1647 struct bt_ctf_field_enumeration *enumeration = container_of(
1648 field, struct bt_ctf_field_enumeration, parent);
1649
1650 return bt_ctf_field_serialize(enumeration->payload, pos);
1651}
1652
1653static
1654int bt_ctf_field_floating_point_serialize(struct bt_ctf_field *field,
1655 struct ctf_stream_pos *pos)
1656{
1657 int ret = 0;
1658 struct bt_ctf_field_floating_point *floating_point = container_of(field,
1659 struct bt_ctf_field_floating_point, parent);
1660
1661retry:
1662 ret = ctf_float_write(&pos->parent, &floating_point->definition.p);
1663 if (ret == -EFAULT) {
1664 /*
1665 * The field is too large to fit in the current packet's
1666 * remaining space. Bump the packet size and retry.
1667 */
1668 ret = increase_packet_size(pos);
1669 if (ret) {
1670 goto end;
1671 }
1672 goto retry;
1673 }
1674end:
1675 return ret;
1676}
1677
1678static
1679int bt_ctf_field_structure_serialize(struct bt_ctf_field *field,
1680 struct ctf_stream_pos *pos)
1681{
1682 size_t i;
1683 int ret = 0;
1684 struct bt_ctf_field_structure *structure = container_of(
1685 field, struct bt_ctf_field_structure, parent);
1686
1687 while (!ctf_pos_access_ok(pos,
1688 offset_align(pos->offset,
1689 field->type->declaration->alignment))) {
9f56e450
JG		 1690 ret = increase_packet_size(pos);
1691 if (ret) {
1692 goto end;
1693 }
273b65be
JG		 1694 }
1695
70fd5a51
MD		 1696 if (!ctf_align_pos(pos, field->type->declaration->alignment)) {
1697 ret = -1;
1698 goto end;
1699 }
273b65be
JG		 1700
1701 for (i = 0; i < structure->fields->len; i++) {
1702 struct bt_ctf_field *field = g_ptr_array_index(
1703 structure->fields, i);
1704
1705 ret = bt_ctf_field_serialize(field, pos);
1706 if (ret) {
1707 break;
1708 }
1709 }
9f56e450 1710end:
273b65be
JG		 1711 return ret;
1712}
1713
1714static
1715int bt_ctf_field_variant_serialize(struct bt_ctf_field *field,
1716 struct ctf_stream_pos *pos)
1717{
1718 struct bt_ctf_field_variant *variant = container_of(
1719 field, struct bt_ctf_field_variant, parent);
1720
1721 return bt_ctf_field_serialize(variant->payload, pos);
1722}
1723
1724static
1725int bt_ctf_field_array_serialize(struct bt_ctf_field *field,
1726 struct ctf_stream_pos *pos)
1727{
1728 size_t i;
1729 int ret = 0;
1730 struct bt_ctf_field_array *array = container_of(
1731 field, struct bt_ctf_field_array, parent);
1732
1733 for (i = 0; i < array->elements->len; i++) {
1734 ret = bt_ctf_field_serialize(
1735 g_ptr_array_index(array->elements, i), pos);
1736 if (ret) {
1737 goto end;
1738 }
1739 }
1740end:
1741 return ret;
1742}
1743
1744static
1745int bt_ctf_field_sequence_serialize(struct bt_ctf_field *field,
1746 struct ctf_stream_pos *pos)
1747{
1748 size_t i;
1749 int ret = 0;
1750 struct bt_ctf_field_sequence *sequence = container_of(
1751 field, struct bt_ctf_field_sequence, parent);
1752
1753 for (i = 0; i < sequence->elements->len; i++) {
1754 ret = bt_ctf_field_serialize(
1755 g_ptr_array_index(sequence->elements, i), pos);
1756 if (ret) {
1757 goto end;
1758 }
1759 }
1760end:
1761 return ret;
1762}
1763
1764static
1765int bt_ctf_field_string_serialize(struct bt_ctf_field *field,
1766 struct ctf_stream_pos *pos)
1767{
1768 size_t i;
1769 int ret = 0;
1770 struct bt_ctf_field_string *string = container_of(field,
1771 struct bt_ctf_field_string, parent);
1772 struct bt_ctf_field_type *character_type =
1773 get_field_type(FIELD_TYPE_ALIAS_UINT8_T);
1774 struct bt_ctf_field *character = bt_ctf_field_create(character_type);
1775
1776 for (i = 0; i < string->payload->len + 1; i++) {
1777 ret = bt_ctf_field_unsigned_integer_set_value(character,
1778 (uint64_t) string->payload->str[i]);
1779 if (ret) {
1780 goto end;
1781 }
1782
1783 ret = bt_ctf_field_integer_serialize(character, pos);
1784 if (ret) {
1785 goto end;
1786 }
1787 }
1788end:
1789 bt_ctf_field_put(character);
1790 bt_ctf_field_type_put(character_type);
1791 return ret;
1792}
1793
87d43dc1
JG		 1794static
1795int bt_ctf_field_integer_copy(struct bt_ctf_field *src,
1796 struct bt_ctf_field *dst)
1797{
1798 struct bt_ctf_field_integer *integer_src, *integer_dst;
1799
1800 integer_src = container_of(src, struct bt_ctf_field_integer, parent);
8bfa3f9c 1801 integer_dst = container_of(dst, struct bt_ctf_field_integer, parent);
87d43dc1
JG		 1802
1803 memcpy(&integer_dst->definition, &integer_src->definition,
1804 sizeof(struct definition_integer));
1805 return 0;
1806}
1807
1808static
1809int bt_ctf_field_enumeration_copy(struct bt_ctf_field *src,
1810 struct bt_ctf_field *dst)
1811{
1812 int ret = 0;
1813 struct bt_ctf_field_enumeration *enum_src, *enum_dst;
1814
1815 enum_src = container_of(src, struct bt_ctf_field_enumeration, parent);
1816 enum_dst = container_of(dst, struct bt_ctf_field_enumeration, parent);
1817
1818 if (enum_src->payload) {
1819 enum_dst->payload = bt_ctf_field_copy(enum_src->payload);
1820 if (!enum_dst->payload) {
1821 ret = -1;
1822 goto end;
1823 }
1824 }
1825end:
1826 return ret;
1827}
1828
1829static
1830int bt_ctf_field_floating_point_copy(
1831 struct bt_ctf_field *src, struct bt_ctf_field *dst)
1832{
1833 struct bt_ctf_field_floating_point *float_src, *float_dst;
1834
1835 float_src = container_of(src, struct bt_ctf_field_floating_point,
1836 parent);
1837 float_dst = container_of(dst, struct bt_ctf_field_floating_point,
1838 parent);
1839
1840 memcpy(&float_dst->definition, &float_src->definition,
1841 sizeof(struct definition_float));
1842 memcpy(&float_dst->sign, &float_src->sign,
1843 sizeof(struct definition_integer));
1844 memcpy(&float_dst->mantissa, &float_src->mantissa,
1845 sizeof(struct definition_integer));
1846 memcpy(&float_dst->exp, &float_src->exp,
1847 sizeof(struct definition_integer));
1848 return 0;
1849}
1850
1851static
1852int bt_ctf_field_structure_copy(struct bt_ctf_field *src,
1853 struct bt_ctf_field *dst)
1854{
8bfa3f9c 1855 int ret = 0, i;
87d43dc1
JG		 1856 struct bt_ctf_field_structure *struct_src, *struct_dst;
1857
1858 struct_src = container_of(src, struct bt_ctf_field_structure, parent);
1859 struct_dst = container_of(dst, struct bt_ctf_field_structure, parent);
1860
8bfa3f9c 1861 /* This field_name_to_index HT is owned by the structure field type */
87d43dc1 1862 struct_dst->field_name_to_index = struct_src->field_name_to_index;
8bfa3f9c 1863 g_ptr_array_set_size(struct_dst->fields, struct_src->fields->len);
87d43dc1
JG		 1864
1865 for (i = 0; i < struct_src->fields->len; i++) {
1866 struct bt_ctf_field *field_copy = bt_ctf_field_copy(
1867 g_ptr_array_index(struct_src->fields, i));
1868
1869 if (!field_copy) {
1870 ret = -1;
1871 goto end;
1872 }
8bfa3f9c 1873 g_ptr_array_index(struct_dst->fields, i) = field_copy;
87d43dc1
JG		 1874 }
1875end:
1876 return ret;
1877}
1878
1879static
1880int bt_ctf_field_variant_copy(struct bt_ctf_field *src,
1881 struct bt_ctf_field *dst)
1882{
1883 int ret = 0;
1884 struct bt_ctf_field_variant *variant_src, *variant_dst;
1885
1886 variant_src = container_of(src, struct bt_ctf_field_variant, parent);
1887 variant_dst = container_of(dst, struct bt_ctf_field_variant, parent);
1888
1889 if (variant_src->tag) {
1890 variant_dst->tag = bt_ctf_field_copy(variant_src->tag);
1891 if (!variant_dst->tag) {
1892 ret = -1;
1893 goto end;
1894 }
1895 }
1896 if (variant_src->payload) {
1897 variant_dst->payload = bt_ctf_field_copy(variant_src->payload);
1898 if (!variant_dst->payload) {
1899 ret = -1;
1900 goto end;
1901 }
1902 }
1903end:
1904 return ret;
1905}
1906
1907static
1908int bt_ctf_field_array_copy(struct bt_ctf_field *src,
1909 struct bt_ctf_field *dst)
1910{
1911 int ret = 0, i;
1912 struct bt_ctf_field_array *array_src, *array_dst;
1913
1914 array_src = container_of(src, struct bt_ctf_field_array, parent);
1915 array_dst = container_of(dst, struct bt_ctf_field_array, parent);
1916
8bfa3f9c 1917 g_ptr_array_set_size(array_dst->elements, array_src->elements->len);
87d43dc1
JG		 1918 for (i = 0; i < array_src->elements->len; i++) {
1919 struct bt_ctf_field *field_copy = bt_ctf_field_copy(
1920 g_ptr_array_index(array_src->elements, i));
1921
1922 if (!field_copy) {
1923 ret = -1;
1924 goto end;
1925 }
8bfa3f9c 1926 g_ptr_array_index(array_dst->elements, i) = field_copy;
87d43dc1
JG		 1927 }
1928end:
1929 return ret;
1930}
1931
1932static
1933int bt_ctf_field_sequence_copy(struct bt_ctf_field *src,
1934 struct bt_ctf_field *dst)
1935{
1936 int ret = 0, i;
1937 struct bt_ctf_field_sequence *sequence_src, *sequence_dst;
1938
1939 sequence_src = container_of(src, struct bt_ctf_field_sequence, parent);
1940 sequence_dst = container_of(dst, struct bt_ctf_field_sequence, parent);
1941
8bfa3f9c 1942 g_ptr_array_set_size(sequence_dst->elements,
87d43dc1
JG		 1943 sequence_src->elements->len);
1944 for (i = 0; i < sequence_src->elements->len; i++) {
1945 struct bt_ctf_field *field_copy = bt_ctf_field_copy(
1946 g_ptr_array_index(sequence_src->elements, i));
1947
1948 if (!field_copy) {
1949 ret = -1;
1950 goto end;
1951 }
8bfa3f9c 1952 g_ptr_array_index(sequence_dst->elements, i) = field_copy;
87d43dc1
JG		 1953 }
1954end:
1955 return ret;
1956}
1957
1958static
1959int bt_ctf_field_string_copy(struct bt_ctf_field *src,
1960 struct bt_ctf_field *dst)
1961{
1962 int ret = 0;
1963 struct bt_ctf_field_string *string_src, *string_dst;
1964
1965 string_src = container_of(src, struct bt_ctf_field_string, parent);
1966 string_dst = container_of(dst, struct bt_ctf_field_string, parent);
1967
1968 if (string_src->payload) {
1969 string_dst->payload = g_string_new(string_src->payload->str);
1970 if (!string_dst->payload) {
1971 ret = -1;
1972 goto end;
1973 }
1974 }
1975end:
1976 return ret;
1977}
1978
273b65be
JG		 1979static
1980int increase_packet_size(struct ctf_stream_pos *pos)
1981{
1982 int ret;
1983
1984 assert(pos);
1985 ret = munmap_align(pos->base_mma);
1986 if (ret) {
1987 goto end;
1988 }
1989
1990 pos->packet_size += PACKET_LEN_INCREMENT;
1991 ret = posix_fallocate(pos->fd, pos->mmap_offset,
1992 pos->packet_size / CHAR_BIT);
1993 if (ret) {
1994 goto end;
1995 }
1996
1997 pos->base_mma = mmap_align(pos->packet_size / CHAR_BIT, pos->prot,
1998 pos->flags, pos->fd, pos->mmap_offset);
1999 if (pos->base_mma == MAP_FAILED) {
2000 ret = -1;
2001 }
2002end:
2003 return ret;
2004}
BabelTrace - Trace Format Babel Tower
This page took 0.103576 seconds and 4 git commands to generate.