formats/ctf/ir/event-fields.c

   1 /*
   2  * event-fields.c
   3  *
   4  * Babeltrace CTF IR - Event Fields
   5  *
   6  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  *
   8  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  */
  28
  29 #include <babeltrace/ctf-writer/event-fields.h>
  30 #include <babeltrace/ctf-ir/event-fields-internal.h>
  31 #include <babeltrace/ctf-ir/event-types-internal.h>
  32 #include <babeltrace/compiler.h>
  33
  34 #define PACKET_LEN_INCREMENT    (getpagesize() * 8 * CHAR_BIT)
  35
  36 static
  37 struct bt_ctf_field *bt_ctf_field_integer_create(struct bt_ctf_field_type *);
  38 static
  39 struct bt_ctf_field *bt_ctf_field_enumeration_create(
  40                 struct bt_ctf_field_type *);
  41 static
  42 struct bt_ctf_field *bt_ctf_field_floating_point_create(
  43                 struct bt_ctf_field_type *);
  44 static
  45 struct bt_ctf_field *bt_ctf_field_structure_create(
  46                 struct bt_ctf_field_type *);
  47 static
  48 struct bt_ctf_field *bt_ctf_field_variant_create(
  49                 struct bt_ctf_field_type *);
  50 static
  51 struct bt_ctf_field *bt_ctf_field_array_create(
  52                 struct bt_ctf_field_type *);
  53 static
  54 struct bt_ctf_field *bt_ctf_field_sequence_create(
  55                 struct bt_ctf_field_type *);
  56 static
  57 struct bt_ctf_field *bt_ctf_field_string_create(struct bt_ctf_field_type *);
  58
  59 static
  60 void bt_ctf_field_destroy(struct bt_ctf_ref *);
  61 static
  62 void bt_ctf_field_integer_destroy(struct bt_ctf_field *);
  63 static
  64 void bt_ctf_field_enumeration_destroy(struct bt_ctf_field *);
  65 static
  66 void bt_ctf_field_floating_point_destroy(struct bt_ctf_field *);
  67 static
  68 void bt_ctf_field_structure_destroy(struct bt_ctf_field *);
  69 static
  70 void bt_ctf_field_variant_destroy(struct bt_ctf_field *);
  71 static
  72 void bt_ctf_field_array_destroy(struct bt_ctf_field *);
  73 static
  74 void bt_ctf_field_sequence_destroy(struct bt_ctf_field *);
  75 static
  76 void bt_ctf_field_string_destroy(struct bt_ctf_field *);
  77
  78 static
  79 int bt_ctf_field_generic_validate(struct bt_ctf_field *);
  80 static
  81 int bt_ctf_field_structure_validate(struct bt_ctf_field *);
  82 static
  83 int bt_ctf_field_variant_validate(struct bt_ctf_field *);
  84 static
  85 int bt_ctf_field_enumeration_validate(struct bt_ctf_field *);
  86 static
  87 int bt_ctf_field_array_validate(struct bt_ctf_field *);
  88 static
  89 int bt_ctf_field_sequence_validate(struct bt_ctf_field *);
  90
  91 static
  92 int bt_ctf_field_generic_reset(struct bt_ctf_field *);
  93 static
  94 int bt_ctf_field_structure_reset(struct bt_ctf_field *);
  95 static
  96 int bt_ctf_field_variant_reset(struct bt_ctf_field *);
  97 static
  98 int bt_ctf_field_enumeration_reset(struct bt_ctf_field *);
  99 static
 100 int bt_ctf_field_array_reset(struct bt_ctf_field *);
 101 static
 102 int bt_ctf_field_sequence_reset(struct bt_ctf_field *);
 103 static
 104 int bt_ctf_field_string_reset(struct bt_ctf_field *);
 105
 106 static
 107 int bt_ctf_field_integer_serialize(struct bt_ctf_field *,
 108                 struct ctf_stream_pos *);
 109 static
 110 int bt_ctf_field_enumeration_serialize(struct bt_ctf_field *,
 111                 struct ctf_stream_pos *);
 112 static
 113 int bt_ctf_field_floating_point_serialize(struct bt_ctf_field *,
 114                 struct ctf_stream_pos *);
 115 static
 116 int bt_ctf_field_structure_serialize(struct bt_ctf_field *,
 117                 struct ctf_stream_pos *);
 118 static
 119 int bt_ctf_field_variant_serialize(struct bt_ctf_field *,
 120                 struct ctf_stream_pos *);
 121 static
 122 int bt_ctf_field_array_serialize(struct bt_ctf_field *,
 123                 struct ctf_stream_pos *);
 124 static
 125 int bt_ctf_field_sequence_serialize(struct bt_ctf_field *,
 126                 struct ctf_stream_pos *);
 127 static
 128 int bt_ctf_field_string_serialize(struct bt_ctf_field *,
 129                 struct ctf_stream_pos *);
 130
 131 static
 132 int bt_ctf_field_integer_copy(struct bt_ctf_field *, struct bt_ctf_field *);
 133 static
 134 int bt_ctf_field_enumeration_copy(struct bt_ctf_field *, struct bt_ctf_field *);
 135 static
 136 int bt_ctf_field_floating_point_copy(struct bt_ctf_field *,
 137                 struct bt_ctf_field *);
 138 static
 139 int bt_ctf_field_structure_copy(struct bt_ctf_field *, struct bt_ctf_field *);
 140 static
 141 int bt_ctf_field_variant_copy(struct bt_ctf_field *, struct bt_ctf_field *);
 142 static
 143 int bt_ctf_field_array_copy(struct bt_ctf_field *, struct bt_ctf_field *);
 144 static
 145 int bt_ctf_field_sequence_copy(struct bt_ctf_field *, struct bt_ctf_field *);
 146 static
 147 int bt_ctf_field_string_copy(struct bt_ctf_field *, struct bt_ctf_field *);
 148
 149 static
 150 int increase_packet_size(struct ctf_stream_pos *pos);
 151
 152 static
 153 struct bt_ctf_field *(* const field_create_funcs[])(
 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
 166 static
 167 void (* const field_destroy_funcs[])(struct bt_ctf_field *) = {
 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
 179 static
 180 int (* const field_validate_funcs[])(struct bt_ctf_field *) = {
 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
 191 static
 192 int (* const field_reset_funcs[])(struct bt_ctf_field *) = {
 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
 203 static
 204 int (* const field_serialize_funcs[])(struct bt_ctf_field *,
 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
 217 static
 218 int (* const field_copy_funcs[])(struct bt_ctf_field *,
 219                 struct bt_ctf_field *) = {
 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
 230 struct 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);
 240         if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES ||
 241                 bt_ctf_field_type_validate(type)) {
 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;
 255 error:
 256         return field;
 257 }
 258
 259 void bt_ctf_field_get(struct bt_ctf_field *field)
 260 {
 261         if (field) {
 262                 bt_ctf_ref_get(&field->ref_count);
 263         }
 264 }
 265
 266 void 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
 273 struct 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);
 283 end:
 284         return ret;
 285 }
 286
 287 struct 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);
 305 end:
 306         return ret;
 307 }
 308
 309 int 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);
 330         /* The length field must be unsigned */
 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
 345         sequence->elements = g_ptr_array_sized_new((size_t)sequence_length);
 346         if (!sequence->elements) {
 347                 ret = -1;
 348                 goto end;
 349         }
 350
 351         g_ptr_array_set_free_func(sequence->elements,
 352                 (GDestroyNotify)bt_ctf_field_put);
 353         g_ptr_array_set_size(sequence->elements, (size_t)sequence_length);
 354         bt_ctf_field_get(length_field);
 355         sequence->length = length_field;
 356 end:
 357         return ret;
 358 }
 359
 360 struct 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;
 366         struct bt_ctf_field_type *field_type = NULL;
 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);
 377         field_type =
 378                 bt_ctf_field_type_structure_get_field_type_by_name(field->type,
 379                 name);
 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;
 396 end:
 397         bt_ctf_field_get(new_field);
 398 error:
 399         if (field_type) {
 400                 bt_ctf_field_type_put(field_type);
 401         }
 402         return new_field;
 403 }
 404
 405 struct bt_ctf_field *bt_ctf_field_structure_get_field_by_index(
 406                 struct bt_ctf_field *field, int index)
 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;
 449 end:
 450         bt_ctf_field_get(ret_field);
 451 error:
 452         if (field_type) {
 453                 bt_ctf_field_type_put(field_type);
 454         }
 455         return ret_field;
 456 }
 457
 458 BT_HIDDEN
 459 int 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;
 465         struct bt_ctf_field_type *expected_field_type = NULL;
 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);
 477         expected_field_type =
 478                 bt_ctf_field_type_structure_get_field_type_by_name(field->type,
 479                 name);
 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);
 496 end:
 497         if (expected_field_type) {
 498                 bt_ctf_field_type_put(expected_field_type);
 499         }
 500         return ret;
 501 }
 502
 503 struct 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;
 507         struct bt_ctf_field_type *field_type = NULL;
 508         struct bt_ctf_field_array *array;
 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
 520         field_type = bt_ctf_field_type_array_get_element_type(field->type);
 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;
 529 end:
 530         if (field_type) {
 531                 bt_ctf_field_type_put(field_type);
 532         }
 533         return new_field;
 534 }
 535
 536 struct 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;
 540         struct bt_ctf_field_type *field_type = NULL;
 541         struct bt_ctf_field_sequence *sequence;
 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
 553         field_type = bt_ctf_field_type_sequence_get_element_type(field->type);
 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;
 562 end:
 563         if (field_type) {
 564                 bt_ctf_field_type_put(field_type);
 565         }
 566         return new_field;
 567 }
 568
 569 struct 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
 599         if (bt_ctf_field_validate(tag_field) < 0) {
 600                 goto end;
 601         }
 602
 603         tag_enum_value = tag_enum_integer->definition.value._signed;
 604         field_type = bt_ctf_field_type_variant_get_field_type_signed(
 605                 variant_type, tag_enum_value);
 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;
 621 end:
 622         bt_ctf_field_put(tag_enum);
 623         return new_field;
 624 }
 625
 626 struct 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
 632         if (!field || bt_ctf_field_type_get_type_id(field->type) !=
 633                 CTF_TYPE_ENUM) {
 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);
 649 end:
 650         return container;
 651 }
 652
 653 const 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
 678         if (!integer_type->declaration.signedness) {
 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
 700 error_put_container_type:
 701         bt_ctf_field_type_put(container_type);
 702 error_put_container:
 703         bt_ctf_field_put(container);
 704 end:
 705         return name;
 706 }
 707
 708 int 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;
 732 end:
 733         return ret;
 734 }
 735
 736 int 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;
 770 end:
 771         return ret;
 772 }
 773
 774 int 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;
 798 end:
 799         return ret;
 800 }
 801
 802 int 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;
 835 end:
 836         return ret;
 837 }
 838
 839 int 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;
 855 end:
 856         return ret;
 857 }
 858
 859 int 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;
 875 end:
 876         return ret;
 877 }
 878
 879 const 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;
 893 end:
 894         return ret;
 895 }
 896
 897 int 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) {
 912                 g_string_assign(string->payload, value);
 913         } else {
 914                 string->payload = g_string_new(value);
 915         }
 916
 917         string->parent.payload_set = 1;
 918 end:
 919         return ret;
 920 }
 921
 922 int 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
 945 end:
 946         return ret;
 947 }
 948
 949 BT_HIDDEN
 950 int 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);
 967 end:
 968         return ret;
 969 }
 970
 971 BT_HIDDEN
 972 int 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);
 989 end:
 990         return ret;
 991 }
 992
 993 BT_HIDDEN
 994 int 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);
1012 end:
1013         return ret;
1014 }
1015
1016 BT_HIDDEN
1017 struct 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) {
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) {
1029                 goto end;
1030         }
1031
1032         copy = bt_ctf_field_create(field->type);
1033         if (!copy) {
1034                 goto end;
1035         }
1036
1037         ret = field_copy_funcs[type_id](field, copy);
1038         if (ret) {
1039                 bt_ctf_field_put(copy);
1040                 copy = NULL;
1041         }
1042 end:
1043         return copy;
1044 }
1045
1046 static
1047 struct 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
1061 static
1062 struct 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
1071 static
1072 struct 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
1104 end:
1105         return floating_point ? &floating_point->parent : NULL;
1106 }
1107
1108 static
1109 struct 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;
1128 end:
1129         return field;
1130 }
1131
1132 static
1133 struct 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
1140 static
1141 struct 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;
1153         array->elements = g_ptr_array_sized_new(array_length);
1154         if (!array->elements) {
1155                 goto error;
1156         }
1157
1158         g_ptr_array_set_free_func(array->elements,
1159                 (GDestroyNotify)bt_ctf_field_put);
1160         g_ptr_array_set_size(array->elements, array_length);
1161         return &array->parent;
1162 error:
1163         g_free(array);
1164         return NULL;
1165 }
1166
1167 static
1168 struct 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
1176 static
1177 struct 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
1184 static
1185 void 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
1209 static
1210 void 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
1222 static
1223 void 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
1237 static
1238 void 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
1251 static
1252 void 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
1265 static
1266 void 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
1280 static
1281 void 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
1294 static
1295 void 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
1309 static
1310 void 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);
1318         if (string->payload) {
1319                 g_string_free(string->payload, TRUE);
1320         }
1321         g_free(string);
1322 }
1323
1324 static
1325 int bt_ctf_field_generic_validate(struct bt_ctf_field *field)
1326 {
1327         return (field && field->payload_set) ? 0 : -1;
1328 }
1329
1330 static
1331 int 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);
1349 end:
1350         return ret;
1351 }
1352
1353 static
1354 int 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         }
1372 end:
1373         return ret;
1374 }
1375
1376 static
1377 int 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);
1389 end:
1390         return ret;
1391 }
1392
1393 static
1394 int 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         }
1412 end:
1413         return ret;
1414 }
1415
1416 static
1417 int 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         }
1435 end:
1436         return ret;
1437 }
1438
1439 static
1440 int 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;
1450 end:
1451         return ret;
1452 }
1453
1454 static
1455 int 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);
1472 end:
1473         return ret;
1474 }
1475
1476 static
1477 int 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         }
1505 end:
1506         return ret;
1507 }
1508
1509 static
1510 int 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         }
1524 end:
1525         return ret;
1526 }
1527
1528 static
1529 int 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         }
1557 end:
1558         return ret;
1559 }
1560
1561 static
1562 int 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         }
1590 end:
1591         return ret;
1592 }
1593
1594 static
1595 int 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         }
1614 end:
1615         return ret;
1616 }
1617
1618 static
1619 int 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
1626 retry:
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         }
1639 end:
1640         return ret;
1641 }
1642
1643 static
1644 int 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
1653 static
1654 int 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
1661 retry:
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         }
1674 end:
1675         return ret;
1676 }
1677
1678 static
1679 int 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))) {
1690                 ret = increase_packet_size(pos);
1691                 if (ret) {
1692                         goto end;
1693                 }
1694         }
1695
1696         if (!ctf_align_pos(pos, field->type->declaration->alignment)) {
1697                 ret = -1;
1698                 goto end;
1699         }
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         }
1710 end:
1711         return ret;
1712 }
1713
1714 static
1715 int 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
1724 static
1725 int 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         }
1740 end:
1741         return ret;
1742 }
1743
1744 static
1745 int 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         }
1760 end:
1761         return ret;
1762 }
1763
1764 static
1765 int 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         }
1788 end:
1789         bt_ctf_field_put(character);
1790         bt_ctf_field_type_put(character_type);
1791         return ret;
1792 }
1793
1794 static
1795 int 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);
1801         integer_dst = container_of(dst, struct bt_ctf_field_integer, parent);
1802
1803         memcpy(&integer_dst->definition, &integer_src->definition,
1804                 sizeof(struct definition_integer));
1805         return 0;
1806 }
1807
1808 static
1809 int 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         }
1825 end:
1826         return ret;
1827 }
1828
1829 static
1830 int 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
1851 static
1852 int bt_ctf_field_structure_copy(struct bt_ctf_field *src,
1853                 struct bt_ctf_field *dst)
1854 {
1855         int ret = 0, i;
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
1861         /* This field_name_to_index HT is owned by the structure field type */
1862         struct_dst->field_name_to_index = struct_src->field_name_to_index;
1863         g_ptr_array_set_size(struct_dst->fields, struct_src->fields->len);
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                 }
1873                 g_ptr_array_index(struct_dst->fields, i) = field_copy;
1874         }
1875 end:
1876         return ret;
1877 }
1878
1879 static
1880 int 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         }
1903 end:
1904         return ret;
1905 }
1906
1907 static
1908 int 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
1917         g_ptr_array_set_size(array_dst->elements, array_src->elements->len);
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                 }
1926                 g_ptr_array_index(array_dst->elements, i) = field_copy;
1927         }
1928 end:
1929         return ret;
1930 }
1931
1932 static
1933 int 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
1942         g_ptr_array_set_size(sequence_dst->elements,
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                 }
1952                 g_ptr_array_index(sequence_dst->elements, i) = field_copy;
1953         }
1954 end:
1955         return ret;
1956 }
1957
1958 static
1959 int 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         }
1975 end:
1976         return ret;
1977 }
1978
1979 static
1980 int 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         }
2002 end:
2003         return ret;
2004 }