formats/ctf/ir/fields.c

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