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 BT_HIDDEN
 923 int 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);
 940 end:
 941         return ret;
 942 }
 943
 944 BT_HIDDEN
 945 int 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);
 962 end:
 963         return ret;
 964 }
 965
 966 BT_HIDDEN
 967 int 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);
 985 end:
 986         return ret;
 987 }
 988
 989 BT_HIDDEN
 990 struct 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) {
 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) {
1002                 goto end;
1003         }
1004
1005         copy = bt_ctf_field_create(field->type);
1006         if (!copy) {
1007                 goto end;
1008         }
1009
1010         ret = field_copy_funcs[type_id](field, copy);
1011         if (ret) {
1012                 bt_ctf_field_put(copy);
1013                 copy = NULL;
1014         }
1015 end:
1016         return copy;
1017 }
1018
1019 static
1020 struct 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
1034 static
1035 struct 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
1044 static
1045 struct 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
1077 end:
1078         return floating_point ? &floating_point->parent : NULL;
1079 }
1080
1081 static
1082 struct 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;
1101 end:
1102         return field;
1103 }
1104
1105 static
1106 struct 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
1113 static
1114 struct 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;
1126         array->elements = g_ptr_array_sized_new(array_length);
1127         if (!array->elements) {
1128                 goto error;
1129         }
1130
1131         g_ptr_array_set_free_func(array->elements,
1132                 (GDestroyNotify)bt_ctf_field_put);
1133         g_ptr_array_set_size(array->elements, array_length);
1134         return &array->parent;
1135 error:
1136         g_free(array);
1137         return NULL;
1138 }
1139
1140 static
1141 struct 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
1149 static
1150 struct 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
1157 static
1158 void 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
1182 static
1183 void 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
1195 static
1196 void 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
1210 static
1211 void 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
1224 static
1225 void 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
1238 static
1239 void 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
1253 static
1254 void 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
1267 static
1268 void 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
1282 static
1283 void 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
1295 static
1296 int bt_ctf_field_generic_validate(struct bt_ctf_field *field)
1297 {
1298         return (field && field->payload_set) ? 0 : -1;
1299 }
1300
1301 static
1302 int 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);
1320 end:
1321         return ret;
1322 }
1323
1324 static
1325 int 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         }
1343 end:
1344         return ret;
1345 }
1346
1347 static
1348 int 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);
1360 end:
1361         return ret;
1362 }
1363
1364 static
1365 int 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         }
1383 end:
1384         return ret;
1385 }
1386
1387 static
1388 int 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         }
1406 end:
1407         return ret;
1408 }
1409
1410 static
1411 int 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;
1421 end:
1422         return ret;
1423 }
1424
1425 static
1426 int 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);
1443 end:
1444         return ret;
1445 }
1446
1447 static
1448 int 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         }
1476 end:
1477         return ret;
1478 }
1479
1480 static
1481 int 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         }
1495 end:
1496         return ret;
1497 }
1498
1499 static
1500 int 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         }
1528 end:
1529         return ret;
1530 }
1531
1532 static
1533 int 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         }
1561 end:
1562         return ret;
1563 }
1564
1565 static
1566 int 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         }
1585 end:
1586         return ret;
1587 }
1588
1589 static
1590 int 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
1597 retry:
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         }
1610 end:
1611         return ret;
1612 }
1613
1614 static
1615 int 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
1624 static
1625 int 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
1632 retry:
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         }
1645 end:
1646         return ret;
1647 }
1648
1649 static
1650 int 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))) {
1661                 ret = increase_packet_size(pos);
1662                 if (ret) {
1663                         goto end;
1664                 }
1665         }
1666
1667         if (!ctf_align_pos(pos, field->type->declaration->alignment)) {
1668                 ret = -1;
1669                 goto end;
1670         }
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         }
1681 end:
1682         return ret;
1683 }
1684
1685 static
1686 int 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
1695 static
1696 int 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         }
1711 end:
1712         return ret;
1713 }
1714
1715 static
1716 int 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         }
1731 end:
1732         return ret;
1733 }
1734
1735 static
1736 int 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         }
1759 end:
1760         bt_ctf_field_put(character);
1761         bt_ctf_field_type_put(character_type);
1762         return ret;
1763 }
1764
1765 static
1766 int 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);
1772         integer_dst = container_of(dst, struct bt_ctf_field_integer, parent);
1773
1774         memcpy(&integer_dst->definition, &integer_src->definition,
1775                 sizeof(struct definition_integer));
1776         return 0;
1777 }
1778
1779 static
1780 int 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         }
1796 end:
1797         return ret;
1798 }
1799
1800 static
1801 int 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
1822 static
1823 int bt_ctf_field_structure_copy(struct bt_ctf_field *src,
1824                 struct bt_ctf_field *dst)
1825 {
1826         int ret = 0, i;
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
1832         /* This field_name_to_index HT is owned by the structure field type */
1833         struct_dst->field_name_to_index = struct_src->field_name_to_index;
1834         g_ptr_array_set_size(struct_dst->fields, struct_src->fields->len);
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                 }
1844                 g_ptr_array_index(struct_dst->fields, i) = field_copy;
1845         }
1846 end:
1847         return ret;
1848 }
1849
1850 static
1851 int 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         }
1874 end:
1875         return ret;
1876 }
1877
1878 static
1879 int 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
1888         g_ptr_array_set_size(array_dst->elements, array_src->elements->len);
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                 }
1897                 g_ptr_array_index(array_dst->elements, i) = field_copy;
1898         }
1899 end:
1900         return ret;
1901 }
1902
1903 static
1904 int 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
1913         g_ptr_array_set_size(sequence_dst->elements,
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                 }
1923                 g_ptr_array_index(sequence_dst->elements, i) = field_copy;
1924         }
1925 end:
1926         return ret;
1927 }
1928
1929 static
1930 int 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         }
1946 end:
1947         return ret;
1948 }
1949
1950 static
1951 int 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         }
1973 end:
1974         return ret;
1975 }