projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Implement bt_ctf_event_class_get/set_payload()
[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
922BT_HIDDEN
923int bt_ctf_field_validate(struct bt_ctf_field *field)
924{
925 int ret = 0;
926 enum ctf_type_id type_id;
927
928 if (!field) {
929 ret = -1;
930 goto end;
931 }
932
933 type_id = bt_ctf_field_type_get_type_id(field->type);
934 if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
935 ret = -1;
936 goto end;
937 }
938
939 ret = field_validate_funcs[type_id](field);
940end:
941 return ret;
942}
943
12c8a1a3
JG		 944BT_HIDDEN
945int bt_ctf_field_reset(struct bt_ctf_field *field)
946{
947 int ret = 0;
948 enum ctf_type_id type_id;
949
950 if (!field) {
951 ret = -1;
952 goto end;
953 }
954
955 type_id = bt_ctf_field_type_get_type_id(field->type);
956 if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
957 ret = -1;
958 goto end;
959 }
960
961 ret = field_reset_funcs[type_id](field);
962end:
963 return ret;
964}
965
273b65be
JG		 966BT_HIDDEN
967int bt_ctf_field_serialize(struct bt_ctf_field *field,
968 struct ctf_stream_pos *pos)
969{
970 int ret = 0;
971 enum ctf_type_id type_id;
972
973 if (!field || !pos) {
974 ret = -1;
975 goto end;
976 }
977
978 type_id = bt_ctf_field_type_get_type_id(field->type);
979 if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
980 ret = -1;
981 goto end;
982 }
983
984 ret = field_serialize_funcs[type_id](field, pos);
985end:
986 return ret;
987}
988
87d43dc1
JG		 989BT_HIDDEN
990struct bt_ctf_field *bt_ctf_field_copy(struct bt_ctf_field *field)
991{
992 int ret;
993 struct bt_ctf_field *copy = NULL;
994 enum ctf_type_id type_id;
995
996 if (!field) {
87d43dc1
JG		 997 goto end;
998 }
999
1000 type_id = bt_ctf_field_type_get_type_id(field->type);
1001 if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
87d43dc1
JG		 1002 goto end;
1003 }
1004
1005 copy = bt_ctf_field_create(field->type);
1006 if (!copy) {
1007 goto end;
1008 }
1009
87d43dc1
JG		 1010 ret = field_copy_funcs[type_id](field, copy);
1011 if (ret) {
1012 bt_ctf_field_put(copy);
1013 copy = NULL;
1014 }
1015end:
1016 return copy;
1017}
1018
273b65be
JG		 1019static
1020struct bt_ctf_field *bt_ctf_field_integer_create(struct bt_ctf_field_type *type)
1021{
1022 struct bt_ctf_field_type_integer *integer_type = container_of(type,
1023 struct bt_ctf_field_type_integer, parent);
1024 struct bt_ctf_field_integer *integer = g_new0(
1025 struct bt_ctf_field_integer, 1);
1026
1027 if (integer) {
1028 integer->definition.declaration = &integer_type->declaration;
1029 }
1030
1031 return integer ? &integer->parent : NULL;
1032}
1033
1034static
1035struct bt_ctf_field *bt_ctf_field_enumeration_create(
1036 struct bt_ctf_field_type *type)
1037{
1038 struct bt_ctf_field_enumeration *enumeration = g_new0(
1039 struct bt_ctf_field_enumeration, 1);
1040
1041 return enumeration ? &enumeration->parent : NULL;
1042}
1043
1044static
1045struct bt_ctf_field *bt_ctf_field_floating_point_create(
1046 struct bt_ctf_field_type *type)
1047{
1048 struct bt_ctf_field_floating_point *floating_point;
1049 struct bt_ctf_field_type_floating_point *floating_point_type;
1050
1051 floating_point = g_new0(struct bt_ctf_field_floating_point, 1);
1052 if (!floating_point) {
1053 goto end;
1054 }
1055
1056 floating_point_type = container_of(type,
1057 struct bt_ctf_field_type_floating_point, parent);
1058 floating_point->definition.declaration = container_of(
1059 type->declaration, struct declaration_float, p);
1060
1061
1062 floating_point->definition.sign = &floating_point->sign;
1063 floating_point->sign.declaration = &floating_point_type->sign;
1064 floating_point->definition.sign->p.declaration =
1065 &floating_point_type->sign.p;
1066
1067 floating_point->definition.mantissa = &floating_point->mantissa;
1068 floating_point->mantissa.declaration = &floating_point_type->mantissa;
1069 floating_point->definition.mantissa->p.declaration =
1070 &floating_point_type->mantissa.p;
1071
1072 floating_point->definition.exp = &floating_point->exp;
1073 floating_point->exp.declaration = &floating_point_type->exp;
1074 floating_point->definition.exp->p.declaration =
1075 &floating_point_type->exp.p;
1076
1077end:
1078 return floating_point ? &floating_point->parent : NULL;
1079}
1080
1081static
1082struct bt_ctf_field *bt_ctf_field_structure_create(
1083 struct bt_ctf_field_type *type)
1084{
1085 struct bt_ctf_field_type_structure *structure_type = container_of(type,
1086 struct bt_ctf_field_type_structure, parent);
1087 struct bt_ctf_field_structure *structure = g_new0(
1088 struct bt_ctf_field_structure, 1);
1089 struct bt_ctf_field *field = NULL;
1090
1091 if (!structure || !structure_type->fields->len) {
1092 goto end;
1093 }
1094
1095 structure->field_name_to_index = structure_type->field_name_to_index;
1096 structure->fields = g_ptr_array_new_with_free_func(
1097 (GDestroyNotify)bt_ctf_field_put);
1098 g_ptr_array_set_size(structure->fields,
1099 g_hash_table_size(structure->field_name_to_index));
1100 field = &structure->parent;
1101end:
1102 return field;
1103}
1104
1105static
1106struct bt_ctf_field *bt_ctf_field_variant_create(struct bt_ctf_field_type *type)
1107{
1108 struct bt_ctf_field_variant *variant = g_new0(
1109 struct bt_ctf_field_variant, 1);
1110 return variant ? &variant->parent : NULL;
1111}
1112
1113static
1114struct bt_ctf_field *bt_ctf_field_array_create(struct bt_ctf_field_type *type)
1115{
1116 struct bt_ctf_field_array *array = g_new0(struct bt_ctf_field_array, 1);
1117 struct bt_ctf_field_type_array *array_type;
1118 unsigned int array_length;
1119
1120 if (!array || !type) {
1121 goto error;
1122 }
1123
1124 array_type = container_of(type, struct bt_ctf_field_type_array, parent);
1125 array_length = array_type->length;
fe0fe95c 1126 array->elements = g_ptr_array_sized_new(array_length);
273b65be
JG		 1127 if (!array->elements) {
1128 goto error;
1129 }
1130
fe0fe95c
JG		 1131 g_ptr_array_set_free_func(array->elements,
1132 (GDestroyNotify)bt_ctf_field_put);
273b65be
JG		 1133 g_ptr_array_set_size(array->elements, array_length);
1134 return &array->parent;
1135error:
1136 g_free(array);
1137 return NULL;
1138}
1139
1140static
1141struct bt_ctf_field *bt_ctf_field_sequence_create(
1142 struct bt_ctf_field_type *type)
1143{
1144 struct bt_ctf_field_sequence *sequence = g_new0(
1145 struct bt_ctf_field_sequence, 1);
1146 return sequence ? &sequence->parent : NULL;
1147}
1148
1149static
1150struct bt_ctf_field *bt_ctf_field_string_create(struct bt_ctf_field_type *type)
1151{
1152 struct bt_ctf_field_string *string = g_new0(
1153 struct bt_ctf_field_string, 1);
1154 return string ? &string->parent : NULL;
1155}
1156
1157static
1158void bt_ctf_field_destroy(struct bt_ctf_ref *ref)
1159{
1160 struct bt_ctf_field *field;
1161 struct bt_ctf_field_type *type;
1162 enum ctf_type_id type_id;
1163
1164 if (!ref) {
1165 return;
1166 }
1167
1168 field = container_of(ref, struct bt_ctf_field, ref_count);
1169 type = field->type;
1170 type_id = bt_ctf_field_type_get_type_id(type);
1171 if (type_id <= CTF_TYPE_UNKNOWN ||
1172 type_id >= NR_CTF_TYPES) {
1173 return;
1174 }
1175
1176 field_destroy_funcs[type_id](field);
1177 if (type) {
1178 bt_ctf_field_type_put(type);
1179 }
1180}
1181
1182static
1183void bt_ctf_field_integer_destroy(struct bt_ctf_field *field)
1184{
1185 struct bt_ctf_field_integer *integer;
1186
1187 if (!field) {
1188 return;
1189 }
1190
1191 integer = container_of(field, struct bt_ctf_field_integer, parent);
1192 g_free(integer);
1193}
1194
1195static
1196void bt_ctf_field_enumeration_destroy(struct bt_ctf_field *field)
1197{
1198 struct bt_ctf_field_enumeration *enumeration;
1199
1200 if (!field) {
1201 return;
1202 }
1203
1204 enumeration = container_of(field, struct bt_ctf_field_enumeration,
1205 parent);
1206 bt_ctf_field_put(enumeration->payload);
1207 g_free(enumeration);
1208}
1209
1210static
1211void bt_ctf_field_floating_point_destroy(struct bt_ctf_field *field)
1212{
1213 struct bt_ctf_field_floating_point *floating_point;
1214
1215 if (!field) {
1216 return;
1217 }
1218
1219 floating_point = container_of(field, struct bt_ctf_field_floating_point,
1220 parent);
1221 g_free(floating_point);
1222}
1223
1224static
1225void bt_ctf_field_structure_destroy(struct bt_ctf_field *field)
1226{
1227 struct bt_ctf_field_structure *structure;
1228
1229 if (!field) {
1230 return;
1231 }
1232
1233 structure = container_of(field, struct bt_ctf_field_structure, parent);
1234 g_ptr_array_free(structure->fields, TRUE);
1235 g_free(structure);
1236}
1237
1238static
1239void bt_ctf_field_variant_destroy(struct bt_ctf_field *field)
1240{
1241 struct bt_ctf_field_variant *variant;
1242
1243 if (!field) {
1244 return;
1245 }
1246
1247 variant = container_of(field, struct bt_ctf_field_variant, parent);
1248 bt_ctf_field_put(variant->tag);
1249 bt_ctf_field_put(variant->payload);
1250 g_free(variant);
1251}
1252
1253static
1254void bt_ctf_field_array_destroy(struct bt_ctf_field *field)
1255{
1256 struct bt_ctf_field_array *array;
1257
1258 if (!field) {
1259 return;
1260 }
1261
1262 array = container_of(field, struct bt_ctf_field_array, parent);
1263 g_ptr_array_free(array->elements, TRUE);
1264 g_free(array);
1265}
1266
1267static
1268void bt_ctf_field_sequence_destroy(struct bt_ctf_field *field)
1269{
1270 struct bt_ctf_field_sequence *sequence;
1271
1272 if (!field) {
1273 return;
1274 }
1275
1276 sequence = container_of(field, struct bt_ctf_field_sequence, parent);
1277 g_ptr_array_free(sequence->elements, TRUE);
1278 bt_ctf_field_put(sequence->length);
1279 g_free(sequence);
1280}
1281
1282static
1283void bt_ctf_field_string_destroy(struct bt_ctf_field *field)
1284{
1285 struct bt_ctf_field_string *string;
1286 if (!field) {
1287 return;
1288 }
1289
1290 string = container_of(field, struct bt_ctf_field_string, parent);
1291 g_string_free(string->payload, TRUE);
1292 g_free(string);
1293}
1294
1295static
1296int bt_ctf_field_generic_validate(struct bt_ctf_field *field)
1297{
da2f6971 1298 return (field && field->payload_set) ? 0 : -1;
273b65be
JG		 1299}
1300
1301static
1302int bt_ctf_field_enumeration_validate(struct bt_ctf_field *field)
1303{
1304 int ret;
1305 struct bt_ctf_field_enumeration *enumeration;
1306
1307 if (!field) {
1308 ret = -1;
1309 goto end;
1310 }
1311
1312 enumeration = container_of(field, struct bt_ctf_field_enumeration,
1313 parent);
1314 if (!enumeration->payload) {
1315 ret = -1;
1316 goto end;
1317 }
1318
1319 ret = bt_ctf_field_validate(enumeration->payload);
1320end:
1321 return ret;
1322}
1323
1324static
1325int bt_ctf_field_structure_validate(struct bt_ctf_field *field)
1326{
1327 size_t i;
1328 int ret = 0;
1329 struct bt_ctf_field_structure *structure;
1330
1331 if (!field) {
1332 ret = -1;
1333 goto end;
1334 }
1335
1336 structure = container_of(field, struct bt_ctf_field_structure, parent);
1337 for (i = 0; i < structure->fields->len; i++) {
1338 ret = bt_ctf_field_validate(structure->fields->pdata[i]);
1339 if (ret) {
1340 goto end;
1341 }
1342 }
1343end:
1344 return ret;
1345}
1346
1347static
1348int bt_ctf_field_variant_validate(struct bt_ctf_field *field)
1349{
1350 int ret = 0;
1351 struct bt_ctf_field_variant *variant;
1352
1353 if (!field) {
1354 ret = -1;
1355 goto end;
1356 }
1357
1358 variant = container_of(field, struct bt_ctf_field_variant, parent);
1359 ret = bt_ctf_field_validate(variant->payload);
1360end:
1361 return ret;
1362}
1363
1364static
1365int bt_ctf_field_array_validate(struct bt_ctf_field *field)
1366{
1367 size_t i;
1368 int ret = 0;
1369 struct bt_ctf_field_array *array;
1370
1371 if (!field) {
1372 ret = -1;
1373 goto end;
1374 }
1375
1376 array = container_of(field, struct bt_ctf_field_array, parent);
1377 for (i = 0; i < array->elements->len; i++) {
1378 ret = bt_ctf_field_validate(array->elements->pdata[i]);
1379 if (ret) {
1380 goto end;
1381 }
1382 }
1383end:
1384 return ret;
1385}
1386
1387static
1388int bt_ctf_field_sequence_validate(struct bt_ctf_field *field)
1389{
1390 size_t i;
1391 int ret = 0;
1392 struct bt_ctf_field_sequence *sequence;
1393
1394 if (!field) {
1395 ret = -1;
1396 goto end;
1397 }
1398
1399 sequence = container_of(field, struct bt_ctf_field_sequence, parent);
1400 for (i = 0; i < sequence->elements->len; i++) {
1401 ret = bt_ctf_field_validate(sequence->elements->pdata[i]);
1402 if (ret) {
1403 goto end;
1404 }
1405 }
1406end:
1407 return ret;
1408}
1409
12c8a1a3
JG		 1410static
1411int bt_ctf_field_generic_reset(struct bt_ctf_field *field)
1412{
1413 int ret = 0;
1414
1415 if (!field) {
1416 ret = -1;
1417 goto end;
1418 }
1419
1420 field->payload_set = 0;
1421end:
1422 return ret;
1423}
1424
1425static
1426int bt_ctf_field_enumeration_reset(struct bt_ctf_field *field)
1427{
1428 int ret = 0;
1429 struct bt_ctf_field_enumeration *enumeration;
1430
1431 if (!field) {
1432 ret = -1;
1433 goto end;
1434 }
1435
1436 enumeration = container_of(field, struct bt_ctf_field_enumeration,
1437 parent);
1438 if (!enumeration->payload) {
1439 goto end;
1440 }
1441
1442 ret = bt_ctf_field_reset(enumeration->payload);
1443end:
1444 return ret;
1445}
1446
1447static
1448int bt_ctf_field_structure_reset(struct bt_ctf_field *field)
1449{
1450 size_t i;
1451 int ret = 0;
1452 struct bt_ctf_field_structure *structure;
1453
1454 if (!field) {
1455 ret = -1;
1456 goto end;
1457 }
1458
1459 structure = container_of(field, struct bt_ctf_field_structure, parent);
1460 for (i = 0; i < structure->fields->len; i++) {
1461 struct bt_ctf_field *member = structure->fields->pdata[i];
1462
1463 if (!member) {
1464 /*
1465 * Structure members are lazily initialized; skip if
1466 * this member has not been allocated yet.
1467 */
1468 continue;
1469 }
1470
1471 ret = bt_ctf_field_reset(member);
1472 if (ret) {
1473 goto end;
1474 }
1475 }
1476end:
1477 return ret;
1478}
1479
1480static
1481int bt_ctf_field_variant_reset(struct bt_ctf_field *field)
1482{
1483 int ret = 0;
1484 struct bt_ctf_field_variant *variant;
1485
1486 if (!field) {
1487 ret = -1;
1488 goto end;
1489 }
1490
1491 variant = container_of(field, struct bt_ctf_field_variant, parent);
1492 if (variant->payload) {
1493 ret = bt_ctf_field_reset(variant->payload);
1494 }
1495end:
1496 return ret;
1497}
1498
1499static
1500int bt_ctf_field_array_reset(struct bt_ctf_field *field)
1501{
1502 size_t i;
1503 int ret = 0;
1504 struct bt_ctf_field_array *array;
1505
1506 if (!field) {
1507 ret = -1;
1508 goto end;
1509 }
1510
1511 array = container_of(field, struct bt_ctf_field_array, parent);
1512 for (i = 0; i < array->elements->len; i++) {
1513 struct bt_ctf_field *member = array->elements->pdata[i];
1514
1515 if (!member) {
1516 /*
1517 * Array elements are lazily initialized; skip if
1518 * this member has not been allocated yet.
1519 */
1520 continue;
1521 }
1522
1523 ret = bt_ctf_field_reset(member);
1524 if (ret) {
1525 goto end;
1526 }
1527 }
1528end:
1529 return ret;
1530}
1531
1532static
1533int bt_ctf_field_sequence_reset(struct bt_ctf_field *field)
1534{
1535 size_t i;
1536 int ret = 0;
1537 struct bt_ctf_field_sequence *sequence;
1538
1539 if (!field) {
1540 ret = -1;
1541 goto end;
1542 }
1543
1544 sequence = container_of(field, struct bt_ctf_field_sequence, parent);
1545 for (i = 0; i < sequence->elements->len; i++) {
1546 struct bt_ctf_field *member = sequence->elements->pdata[i];
1547
1548 if (!member) {
1549 /*
1550 * Sequence elements are lazily initialized; skip if
1551 * this member has not been allocated yet.
1552 */
1553 continue;
1554 }
1555
1556 ret = bt_ctf_field_reset(member);
1557 if (ret) {
1558 goto end;
1559 }
1560 }
1561end:
1562 return ret;
1563}
1564
1565static
1566int bt_ctf_field_string_reset(struct bt_ctf_field *field)
1567{
1568 int ret = 0;
1569 struct bt_ctf_field_string *string;
1570
1571 if (!field) {
1572 ret = -1;
1573 goto end;
1574 }
1575
1576 ret = bt_ctf_field_generic_reset(field);
1577 if (ret) {
1578 goto end;
1579 }
1580
1581 string = container_of(field, struct bt_ctf_field_string, parent);
1582 if (string->payload) {
1583 g_string_truncate(string->payload, 0);
1584 }
1585end:
1586 return ret;
1587}
1588
273b65be
JG		 1589static
1590int bt_ctf_field_integer_serialize(struct bt_ctf_field *field,
1591 struct ctf_stream_pos *pos)
1592{
1593 int ret = 0;
1594 struct bt_ctf_field_integer *integer = container_of(field,
1595 struct bt_ctf_field_integer, parent);
1596
1597retry:
1598 ret = ctf_integer_write(&pos->parent, &integer->definition.p);
1599 if (ret == -EFAULT) {
1600 /*
1601 * The field is too large to fit in the current packet's
1602 * remaining space. Bump the packet size and retry.
1603 */
1604 ret = increase_packet_size(pos);
1605 if (ret) {
1606 goto end;
1607 }
1608 goto retry;
1609 }
1610end:
1611 return ret;
1612}
1613
1614static
1615int bt_ctf_field_enumeration_serialize(struct bt_ctf_field *field,
1616 struct ctf_stream_pos *pos)
1617{
1618 struct bt_ctf_field_enumeration *enumeration = container_of(
1619 field, struct bt_ctf_field_enumeration, parent);
1620
1621 return bt_ctf_field_serialize(enumeration->payload, pos);
1622}
1623
1624static
1625int bt_ctf_field_floating_point_serialize(struct bt_ctf_field *field,
1626 struct ctf_stream_pos *pos)
1627{
1628 int ret = 0;
1629 struct bt_ctf_field_floating_point *floating_point = container_of(field,
1630 struct bt_ctf_field_floating_point, parent);
1631
1632retry:
1633 ret = ctf_float_write(&pos->parent, &floating_point->definition.p);
1634 if (ret == -EFAULT) {
1635 /*
1636 * The field is too large to fit in the current packet's
1637 * remaining space. Bump the packet size and retry.
1638 */
1639 ret = increase_packet_size(pos);
1640 if (ret) {
1641 goto end;
1642 }
1643 goto retry;
1644 }
1645end:
1646 return ret;
1647}
1648
1649static
1650int bt_ctf_field_structure_serialize(struct bt_ctf_field *field,
1651 struct ctf_stream_pos *pos)
1652{
1653 size_t i;
1654 int ret = 0;
1655 struct bt_ctf_field_structure *structure = container_of(
1656 field, struct bt_ctf_field_structure, parent);
1657
1658 while (!ctf_pos_access_ok(pos,
1659 offset_align(pos->offset,
1660 field->type->declaration->alignment))) {
9f56e450
JG		 1661 ret = increase_packet_size(pos);
1662 if (ret) {
1663 goto end;
1664 }
273b65be
JG		 1665 }
1666
70fd5a51
MD		 1667 if (!ctf_align_pos(pos, field->type->declaration->alignment)) {
1668 ret = -1;
1669 goto end;
1670 }
273b65be
JG		 1671
1672 for (i = 0; i < structure->fields->len; i++) {
1673 struct bt_ctf_field *field = g_ptr_array_index(
1674 structure->fields, i);
1675
1676 ret = bt_ctf_field_serialize(field, pos);
1677 if (ret) {
1678 break;
1679 }
1680 }
9f56e450 1681end:
273b65be
JG		 1682 return ret;
1683}
1684
1685static
1686int bt_ctf_field_variant_serialize(struct bt_ctf_field *field,
1687 struct ctf_stream_pos *pos)
1688{
1689 struct bt_ctf_field_variant *variant = container_of(
1690 field, struct bt_ctf_field_variant, parent);
1691
1692 return bt_ctf_field_serialize(variant->payload, pos);
1693}
1694
1695static
1696int bt_ctf_field_array_serialize(struct bt_ctf_field *field,
1697 struct ctf_stream_pos *pos)
1698{
1699 size_t i;
1700 int ret = 0;
1701 struct bt_ctf_field_array *array = container_of(
1702 field, struct bt_ctf_field_array, parent);
1703
1704 for (i = 0; i < array->elements->len; i++) {
1705 ret = bt_ctf_field_serialize(
1706 g_ptr_array_index(array->elements, i), pos);
1707 if (ret) {
1708 goto end;
1709 }
1710 }
1711end:
1712 return ret;
1713}
1714
1715static
1716int bt_ctf_field_sequence_serialize(struct bt_ctf_field *field,
1717 struct ctf_stream_pos *pos)
1718{
1719 size_t i;
1720 int ret = 0;
1721 struct bt_ctf_field_sequence *sequence = container_of(
1722 field, struct bt_ctf_field_sequence, parent);
1723
1724 for (i = 0; i < sequence->elements->len; i++) {
1725 ret = bt_ctf_field_serialize(
1726 g_ptr_array_index(sequence->elements, i), pos);
1727 if (ret) {
1728 goto end;
1729 }
1730 }
1731end:
1732 return ret;
1733}
1734
1735static
1736int bt_ctf_field_string_serialize(struct bt_ctf_field *field,
1737 struct ctf_stream_pos *pos)
1738{
1739 size_t i;
1740 int ret = 0;
1741 struct bt_ctf_field_string *string = container_of(field,
1742 struct bt_ctf_field_string, parent);
1743 struct bt_ctf_field_type *character_type =
1744 get_field_type(FIELD_TYPE_ALIAS_UINT8_T);
1745 struct bt_ctf_field *character = bt_ctf_field_create(character_type);
1746
1747 for (i = 0; i < string->payload->len + 1; i++) {
1748 ret = bt_ctf_field_unsigned_integer_set_value(character,
1749 (uint64_t) string->payload->str[i]);
1750 if (ret) {
1751 goto end;
1752 }
1753
1754 ret = bt_ctf_field_integer_serialize(character, pos);
1755 if (ret) {
1756 goto end;
1757 }
1758 }
1759end:
1760 bt_ctf_field_put(character);
1761 bt_ctf_field_type_put(character_type);
1762 return ret;
1763}
1764
87d43dc1
JG		 1765static
1766int bt_ctf_field_integer_copy(struct bt_ctf_field *src,
1767 struct bt_ctf_field *dst)
1768{
1769 struct bt_ctf_field_integer *integer_src, *integer_dst;
1770
1771 integer_src = container_of(src, struct bt_ctf_field_integer, parent);
8bfa3f9c 1772 integer_dst = container_of(dst, struct bt_ctf_field_integer, parent);
87d43dc1
JG		 1773
1774 memcpy(&integer_dst->definition, &integer_src->definition,
1775 sizeof(struct definition_integer));
1776 return 0;
1777}
1778
1779static
1780int bt_ctf_field_enumeration_copy(struct bt_ctf_field *src,
1781 struct bt_ctf_field *dst)
1782{
1783 int ret = 0;
1784 struct bt_ctf_field_enumeration *enum_src, *enum_dst;
1785
1786 enum_src = container_of(src, struct bt_ctf_field_enumeration, parent);
1787 enum_dst = container_of(dst, struct bt_ctf_field_enumeration, parent);
1788
1789 if (enum_src->payload) {
1790 enum_dst->payload = bt_ctf_field_copy(enum_src->payload);
1791 if (!enum_dst->payload) {
1792 ret = -1;
1793 goto end;
1794 }
1795 }
1796end:
1797 return ret;
1798}
1799
1800static
1801int bt_ctf_field_floating_point_copy(
1802 struct bt_ctf_field *src, struct bt_ctf_field *dst)
1803{
1804 struct bt_ctf_field_floating_point *float_src, *float_dst;
1805
1806 float_src = container_of(src, struct bt_ctf_field_floating_point,
1807 parent);
1808 float_dst = container_of(dst, struct bt_ctf_field_floating_point,
1809 parent);
1810
1811 memcpy(&float_dst->definition, &float_src->definition,
1812 sizeof(struct definition_float));
1813 memcpy(&float_dst->sign, &float_src->sign,
1814 sizeof(struct definition_integer));
1815 memcpy(&float_dst->mantissa, &float_src->mantissa,
1816 sizeof(struct definition_integer));
1817 memcpy(&float_dst->exp, &float_src->exp,
1818 sizeof(struct definition_integer));
1819 return 0;
1820}
1821
1822static
1823int bt_ctf_field_structure_copy(struct bt_ctf_field *src,
1824 struct bt_ctf_field *dst)
1825{
8bfa3f9c 1826 int ret = 0, i;
87d43dc1
JG		 1827 struct bt_ctf_field_structure *struct_src, *struct_dst;
1828
1829 struct_src = container_of(src, struct bt_ctf_field_structure, parent);
1830 struct_dst = container_of(dst, struct bt_ctf_field_structure, parent);
1831
8bfa3f9c 1832 /* This field_name_to_index HT is owned by the structure field type */
87d43dc1 1833 struct_dst->field_name_to_index = struct_src->field_name_to_index;
8bfa3f9c 1834 g_ptr_array_set_size(struct_dst->fields, struct_src->fields->len);
87d43dc1
JG		 1835
1836 for (i = 0; i < struct_src->fields->len; i++) {
1837 struct bt_ctf_field *field_copy = bt_ctf_field_copy(
1838 g_ptr_array_index(struct_src->fields, i));
1839
1840 if (!field_copy) {
1841 ret = -1;
1842 goto end;
1843 }
8bfa3f9c 1844 g_ptr_array_index(struct_dst->fields, i) = field_copy;
87d43dc1
JG		 1845 }
1846end:
1847 return ret;
1848}
1849
1850static
1851int bt_ctf_field_variant_copy(struct bt_ctf_field *src,
1852 struct bt_ctf_field *dst)
1853{
1854 int ret = 0;
1855 struct bt_ctf_field_variant *variant_src, *variant_dst;
1856
1857 variant_src = container_of(src, struct bt_ctf_field_variant, parent);
1858 variant_dst = container_of(dst, struct bt_ctf_field_variant, parent);
1859
1860 if (variant_src->tag) {
1861 variant_dst->tag = bt_ctf_field_copy(variant_src->tag);
1862 if (!variant_dst->tag) {
1863 ret = -1;
1864 goto end;
1865 }
1866 }
1867 if (variant_src->payload) {
1868 variant_dst->payload = bt_ctf_field_copy(variant_src->payload);
1869 if (!variant_dst->payload) {
1870 ret = -1;
1871 goto end;
1872 }
1873 }
1874end:
1875 return ret;
1876}
1877
1878static
1879int bt_ctf_field_array_copy(struct bt_ctf_field *src,
1880 struct bt_ctf_field *dst)
1881{
1882 int ret = 0, i;
1883 struct bt_ctf_field_array *array_src, *array_dst;
1884
1885 array_src = container_of(src, struct bt_ctf_field_array, parent);
1886 array_dst = container_of(dst, struct bt_ctf_field_array, parent);
1887
8bfa3f9c 1888 g_ptr_array_set_size(array_dst->elements, array_src->elements->len);
87d43dc1
JG		 1889 for (i = 0; i < array_src->elements->len; i++) {
1890 struct bt_ctf_field *field_copy = bt_ctf_field_copy(
1891 g_ptr_array_index(array_src->elements, i));
1892
1893 if (!field_copy) {
1894 ret = -1;
1895 goto end;
1896 }
8bfa3f9c 1897 g_ptr_array_index(array_dst->elements, i) = field_copy;
87d43dc1
JG		 1898 }
1899end:
1900 return ret;
1901}
1902
1903static
1904int bt_ctf_field_sequence_copy(struct bt_ctf_field *src,
1905 struct bt_ctf_field *dst)
1906{
1907 int ret = 0, i;
1908 struct bt_ctf_field_sequence *sequence_src, *sequence_dst;
1909
1910 sequence_src = container_of(src, struct bt_ctf_field_sequence, parent);
1911 sequence_dst = container_of(dst, struct bt_ctf_field_sequence, parent);
1912
8bfa3f9c 1913 g_ptr_array_set_size(sequence_dst->elements,
87d43dc1
JG		 1914 sequence_src->elements->len);
1915 for (i = 0; i < sequence_src->elements->len; i++) {
1916 struct bt_ctf_field *field_copy = bt_ctf_field_copy(
1917 g_ptr_array_index(sequence_src->elements, i));
1918
1919 if (!field_copy) {
1920 ret = -1;
1921 goto end;
1922 }
8bfa3f9c 1923 g_ptr_array_index(sequence_dst->elements, i) = field_copy;
87d43dc1
JG		 1924 }
1925end:
1926 return ret;
1927}
1928
1929static
1930int bt_ctf_field_string_copy(struct bt_ctf_field *src,
1931 struct bt_ctf_field *dst)
1932{
1933 int ret = 0;
1934 struct bt_ctf_field_string *string_src, *string_dst;
1935
1936 string_src = container_of(src, struct bt_ctf_field_string, parent);
1937 string_dst = container_of(dst, struct bt_ctf_field_string, parent);
1938
1939 if (string_src->payload) {
1940 string_dst->payload = g_string_new(string_src->payload->str);
1941 if (!string_dst->payload) {
1942 ret = -1;
1943 goto end;
1944 }
1945 }
1946end:
1947 return ret;
1948}
1949
273b65be
JG		 1950static
1951int increase_packet_size(struct ctf_stream_pos *pos)
1952{
1953 int ret;
1954
1955 assert(pos);
1956 ret = munmap_align(pos->base_mma);
1957 if (ret) {
1958 goto end;
1959 }
1960
1961 pos->packet_size += PACKET_LEN_INCREMENT;
1962 ret = posix_fallocate(pos->fd, pos->mmap_offset,
1963 pos->packet_size / CHAR_BIT);
1964 if (ret) {
1965 goto end;
1966 }
1967
1968 pos->base_mma = mmap_align(pos->packet_size / CHAR_BIT, pos->prot,
1969 pos->flags, pos->fd, pos->mmap_offset);
1970 if (pos->base_mma == MAP_FAILED) {
1971 ret = -1;
1972 }
1973end:
1974 return ret;
1975}
BabelTrace - Trace Format Babel Tower
This page took 0.103191 seconds and 4 git commands to generate.