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         array->elements->pdata[(size_t)index] = new_field;
 528 end:
 529         if (field_type) {
 530                 bt_ctf_field_type_put(field_type);
 531         }
 532         if (new_field) {
 533                 bt_ctf_field_get(new_field);
 534         }
 535         return new_field;
 536 }
 537
 538 struct bt_ctf_field *bt_ctf_field_sequence_get_field(struct bt_ctf_field *field,
 539                 uint64_t index)
 540 {
 541         struct bt_ctf_field *new_field = NULL;
 542         struct bt_ctf_field_type *field_type = NULL;
 543         struct bt_ctf_field_sequence *sequence;
 544
 545         if (!field || bt_ctf_field_type_get_type_id(field->type) !=
 546                 CTF_TYPE_SEQUENCE) {
 547                 goto end;
 548         }
 549
 550         sequence = container_of(field, struct bt_ctf_field_sequence, parent);
 551         if (!sequence->elements || sequence->elements->len <= index) {
 552                 goto end;
 553         }
 554
 555         field_type = bt_ctf_field_type_sequence_get_element_type(field->type);
 556         if (sequence->elements->pdata[(size_t)index]) {
 557                 new_field = sequence->elements->pdata[(size_t)index];
 558                 goto end;
 559         }
 560
 561         new_field = bt_ctf_field_create(field_type);
 562         sequence->elements->pdata[(size_t)index] = new_field;
 563 end:
 564         if (field_type) {
 565                 bt_ctf_field_type_put(field_type);
 566         }
 567         if (new_field) {
 568                 bt_ctf_field_get(new_field);
 569         }
 570         return new_field;
 571 }
 572
 573 struct bt_ctf_field *bt_ctf_field_variant_get_field(struct bt_ctf_field *field,
 574                 struct bt_ctf_field *tag_field)
 575 {
 576         struct bt_ctf_field *new_field = NULL;
 577         struct bt_ctf_field_variant *variant;
 578         struct bt_ctf_field_type_variant *variant_type;
 579         struct bt_ctf_field_type *field_type;
 580         struct bt_ctf_field *tag_enum = NULL;
 581         struct bt_ctf_field_integer *tag_enum_integer;
 582         int64_t tag_enum_value;
 583
 584         if (!field || !tag_field ||
 585                 bt_ctf_field_type_get_type_id(field->type) !=
 586                         CTF_TYPE_VARIANT ||
 587                 bt_ctf_field_type_get_type_id(tag_field->type) !=
 588                         CTF_TYPE_ENUM) {
 589                 goto end;
 590         }
 591
 592         variant = container_of(field, struct bt_ctf_field_variant, parent);
 593         variant_type = container_of(field->type,
 594                 struct bt_ctf_field_type_variant, parent);
 595         tag_enum = bt_ctf_field_enumeration_get_container(tag_field);
 596         if (!tag_enum) {
 597                 goto end;
 598         }
 599
 600         tag_enum_integer = container_of(tag_enum, struct bt_ctf_field_integer,
 601                 parent);
 602
 603         if (bt_ctf_field_validate(tag_field) < 0) {
 604                 goto end;
 605         }
 606
 607         tag_enum_value = tag_enum_integer->definition.value._signed;
 608
 609         /*
 610          * If the variant currently has a tag and a payload, and if the
 611          * requested tag value is the same as the current one, return
 612          * the current payload instead of creating a fresh one.
 613          */
 614         if (variant->tag && variant->payload) {
 615                 struct bt_ctf_field *cur_tag_container = NULL;
 616                 struct bt_ctf_field_integer *cur_tag_enum_integer;
 617                 int64_t cur_tag_value;
 618
 619                 cur_tag_container =
 620                         bt_ctf_field_enumeration_get_container(variant->tag);
 621                 cur_tag_enum_integer = container_of(cur_tag_container,
 622                         struct bt_ctf_field_integer, parent);
 623                 bt_ctf_field_put(cur_tag_container);
 624                 cur_tag_value = cur_tag_enum_integer->definition.value._signed;
 625
 626                 if (cur_tag_value == tag_enum_value) {
 627                         new_field = variant->payload;
 628                         bt_ctf_field_get(new_field);
 629                         goto end;
 630                 }
 631         }
 632
 633         field_type = bt_ctf_field_type_variant_get_field_type_signed(
 634                 variant_type, tag_enum_value);
 635         if (!field_type) {
 636                 goto end;
 637         }
 638
 639         new_field = bt_ctf_field_create(field_type);
 640         if (!new_field) {
 641                 goto end;
 642         }
 643
 644         bt_ctf_field_put(variant->tag);
 645         bt_ctf_field_put(variant->payload);
 646         bt_ctf_field_get(new_field);
 647         bt_ctf_field_get(tag_field);
 648         variant->tag = tag_field;
 649         variant->payload = new_field;
 650 end:
 651         bt_ctf_field_put(tag_enum);
 652         return new_field;
 653 }
 654
 655 struct bt_ctf_field *bt_ctf_field_enumeration_get_container(
 656         struct bt_ctf_field *field)
 657 {
 658         struct bt_ctf_field *container = NULL;
 659         struct bt_ctf_field_enumeration *enumeration;
 660
 661         if (!field || bt_ctf_field_type_get_type_id(field->type) !=
 662                 CTF_TYPE_ENUM) {
 663                 goto end;
 664         }
 665
 666         enumeration = container_of(field, struct bt_ctf_field_enumeration,
 667                 parent);
 668         if (!enumeration->payload) {
 669                 struct bt_ctf_field_type_enumeration *enumeration_type =
 670                         container_of(field->type,
 671                         struct bt_ctf_field_type_enumeration, parent);
 672                 enumeration->payload =
 673                         bt_ctf_field_create(enumeration_type->container);
 674         }
 675
 676         container = enumeration->payload;
 677         bt_ctf_field_get(container);
 678 end:
 679         return container;
 680 }
 681
 682 const char *bt_ctf_field_enumeration_get_mapping_name(
 683         struct bt_ctf_field *field)
 684 {
 685         int ret;
 686         const char *name = NULL;
 687         struct bt_ctf_field *container = NULL;
 688         struct bt_ctf_field_type *container_type = NULL;
 689         struct bt_ctf_field_type_integer *integer_type = NULL;
 690         struct bt_ctf_field_type_enumeration *enumeration_type = NULL;
 691
 692         container = bt_ctf_field_enumeration_get_container(field);
 693         if (!container) {
 694                 goto end;
 695         }
 696
 697         container_type = bt_ctf_field_get_type(container);
 698         if (!container_type) {
 699                 goto error_put_container;
 700         }
 701
 702         integer_type = container_of(container_type,
 703                 struct bt_ctf_field_type_integer, parent);
 704         enumeration_type = container_of(field->type,
 705                 struct bt_ctf_field_type_enumeration, parent);
 706
 707         if (!integer_type->declaration.signedness) {
 708                 uint64_t value;
 709                 ret = bt_ctf_field_unsigned_integer_get_value(container,
 710                       &value);
 711                 if (ret) {
 712                         goto error_put_container_type;
 713                 }
 714
 715                 name = bt_ctf_field_type_enumeration_get_mapping_name_unsigned(
 716                         enumeration_type, value);
 717         } else {
 718                 int64_t value;
 719                 ret = bt_ctf_field_signed_integer_get_value(container,
 720                       &value);
 721                 if (ret) {
 722                         goto error_put_container_type;
 723                 }
 724
 725                 name = bt_ctf_field_type_enumeration_get_mapping_name_signed(
 726                         enumeration_type, value);
 727         }
 728
 729 error_put_container_type:
 730         bt_ctf_field_type_put(container_type);
 731 error_put_container:
 732         bt_ctf_field_put(container);
 733 end:
 734         return name;
 735 }
 736
 737 int bt_ctf_field_signed_integer_get_value(struct bt_ctf_field *field,
 738                 int64_t *value)
 739 {
 740         int ret = 0;
 741         struct bt_ctf_field_integer *integer;
 742         struct bt_ctf_field_type_integer *integer_type;
 743
 744         if (!field || !value || !field->payload_set ||
 745                 bt_ctf_field_type_get_type_id(field->type) !=
 746                         CTF_TYPE_INTEGER) {
 747                 ret = -1;
 748                 goto end;
 749         }
 750
 751         integer_type = container_of(field->type,
 752                 struct bt_ctf_field_type_integer, parent);
 753         if (!integer_type->declaration.signedness) {
 754                 ret = -1;
 755                 goto end;
 756         }
 757
 758         integer = container_of(field,
 759                 struct bt_ctf_field_integer, parent);
 760         *value = integer->definition.value._signed;
 761 end:
 762         return ret;
 763 }
 764
 765 int bt_ctf_field_signed_integer_set_value(struct bt_ctf_field *field,
 766                 int64_t value)
 767 {
 768         int ret = 0;
 769         struct bt_ctf_field_integer *integer;
 770         struct bt_ctf_field_type_integer *integer_type;
 771         unsigned int size;
 772         int64_t min_value, max_value;
 773
 774         if (!field ||
 775                 bt_ctf_field_type_get_type_id(field->type) !=
 776                         CTF_TYPE_INTEGER) {
 777                 ret = -1;
 778                 goto end;
 779         }
 780
 781         integer = container_of(field, struct bt_ctf_field_integer, parent);
 782         integer_type = container_of(field->type,
 783                 struct bt_ctf_field_type_integer, parent);
 784         if (!integer_type->declaration.signedness) {
 785                 ret = -1;
 786                 goto end;
 787         }
 788
 789         size = integer_type->declaration.len;
 790         min_value = -((int64_t)1 << (size - 1));
 791         max_value = ((int64_t)1 << (size - 1)) - 1;
 792         if (value < min_value || value > max_value) {
 793                 ret = -1;
 794                 goto end;
 795         }
 796
 797         integer->definition.value._signed = value;
 798         integer->parent.payload_set = 1;
 799 end:
 800         return ret;
 801 }
 802
 803 int bt_ctf_field_unsigned_integer_get_value(struct bt_ctf_field *field,
 804                 uint64_t *value)
 805 {
 806         int ret = 0;
 807         struct bt_ctf_field_integer *integer;
 808         struct bt_ctf_field_type_integer *integer_type;
 809
 810         if (!field || !value || !field->payload_set ||
 811                 bt_ctf_field_type_get_type_id(field->type) !=
 812                         CTF_TYPE_INTEGER) {
 813                 ret = -1;
 814                 goto end;
 815         }
 816
 817         integer_type = container_of(field->type,
 818                 struct bt_ctf_field_type_integer, parent);
 819         if (integer_type->declaration.signedness) {
 820                 ret = -1;
 821                 goto end;
 822         }
 823
 824         integer = container_of(field,
 825                 struct bt_ctf_field_integer, parent);
 826         *value = integer->definition.value._unsigned;
 827 end:
 828         return ret;
 829 }
 830
 831 int bt_ctf_field_unsigned_integer_set_value(struct bt_ctf_field *field,
 832                 uint64_t value)
 833 {
 834         int ret = 0;
 835         struct bt_ctf_field_integer *integer;
 836         struct bt_ctf_field_type_integer *integer_type;
 837         unsigned int size;
 838         uint64_t max_value;
 839
 840         if (!field ||
 841                 bt_ctf_field_type_get_type_id(field->type) !=
 842                         CTF_TYPE_INTEGER) {
 843                 ret = -1;
 844                 goto end;
 845         }
 846
 847         integer = container_of(field, struct bt_ctf_field_integer, parent);
 848         integer_type = container_of(field->type,
 849                 struct bt_ctf_field_type_integer, parent);
 850         if (integer_type->declaration.signedness) {
 851                 ret = -1;
 852                 goto end;
 853         }
 854
 855         size = integer_type->declaration.len;
 856         max_value = (size == 64) ? UINT64_MAX : ((uint64_t)1 << size) - 1;
 857         if (value > max_value) {
 858                 ret = -1;
 859                 goto end;
 860         }
 861
 862         integer->definition.value._unsigned = value;
 863         integer->parent.payload_set = 1;
 864 end:
 865         return ret;
 866 }
 867
 868 int bt_ctf_field_floating_point_get_value(struct bt_ctf_field *field,
 869                 double *value)
 870 {
 871         int ret = 0;
 872         struct bt_ctf_field_floating_point *floating_point;
 873
 874         if (!field || !value || !field->payload_set ||
 875                 bt_ctf_field_type_get_type_id(field->type) !=
 876                         CTF_TYPE_FLOAT) {
 877                 ret = -1;
 878                 goto end;
 879         }
 880
 881         floating_point = container_of(field,
 882                 struct bt_ctf_field_floating_point, parent);
 883         *value = floating_point->definition.value;
 884 end:
 885         return ret;
 886 }
 887
 888 int bt_ctf_field_floating_point_set_value(struct bt_ctf_field *field,
 889                 double value)
 890 {
 891         int ret = 0;
 892         struct bt_ctf_field_floating_point *floating_point;
 893
 894         if (!field ||
 895                 bt_ctf_field_type_get_type_id(field->type) !=
 896                         CTF_TYPE_FLOAT) {
 897                 ret = -1;
 898                 goto end;
 899         }
 900         floating_point = container_of(field, struct bt_ctf_field_floating_point,
 901                 parent);
 902         floating_point->definition.value = value;
 903         floating_point->parent.payload_set = 1;
 904 end:
 905         return ret;
 906 }
 907
 908 const char *bt_ctf_field_string_get_value(struct bt_ctf_field *field)
 909 {
 910         const char *ret = NULL;
 911         struct bt_ctf_field_string *string;
 912
 913         if (!field || !field->payload_set ||
 914                 bt_ctf_field_type_get_type_id(field->type) !=
 915                         CTF_TYPE_STRING) {
 916                 goto end;
 917         }
 918
 919         string = container_of(field,
 920                 struct bt_ctf_field_string, parent);
 921         ret = string->payload->str;
 922 end:
 923         return ret;
 924 }
 925
 926 int bt_ctf_field_string_set_value(struct bt_ctf_field *field,
 927                 const char *value)
 928 {
 929         int ret = 0;
 930         struct bt_ctf_field_string *string;
 931
 932         if (!field || !value ||
 933                 bt_ctf_field_type_get_type_id(field->type) !=
 934                         CTF_TYPE_STRING) {
 935                 ret = -1;
 936                 goto end;
 937         }
 938
 939         string = container_of(field, struct bt_ctf_field_string, parent);
 940         if (string->payload) {
 941                 g_string_assign(string->payload, value);
 942         } else {
 943                 string->payload = g_string_new(value);
 944         }
 945
 946         string->parent.payload_set = 1;
 947 end:
 948         return ret;
 949 }
 950
 951 int bt_ctf_field_string_append(struct bt_ctf_field *field,
 952                 const char *value)
 953 {
 954         int ret = 0;
 955         struct bt_ctf_field_string *string_field;
 956
 957         if (!field || !value ||
 958                 bt_ctf_field_type_get_type_id(field->type) !=
 959                         CTF_TYPE_STRING) {
 960                 ret = -1;
 961                 goto end;
 962         }
 963
 964         string_field = container_of(field, struct bt_ctf_field_string, parent);
 965
 966         if (string_field->payload) {
 967                 g_string_append(string_field->payload, value);
 968         } else {
 969                 string_field->payload = g_string_new(value);
 970         }
 971
 972         string_field->parent.payload_set = 1;
 973
 974 end:
 975         return ret;
 976 }
 977
 978 int bt_ctf_field_string_append_len(struct bt_ctf_field *field,
 979                 const char *value, unsigned int length)
 980 {
 981         int i;
 982         int ret = 0;
 983         unsigned int effective_length = length;
 984         struct bt_ctf_field_string *string_field;
 985
 986         if (!field || !value ||
 987                 bt_ctf_field_type_get_type_id(field->type) !=
 988                         CTF_TYPE_STRING) {
 989                 ret = -1;
 990                 goto end;
 991         }
 992
 993         string_field = container_of(field, struct bt_ctf_field_string, parent);
 994
 995         /* make sure no null bytes are appended */
 996         for (i = 0; i < length; ++i) {
 997                 if (value[i] == '\0') {
 998                         effective_length = i;
 999                         break;
1000                 }
1001         }
1002
1003         if (string_field->payload) {
1004                 g_string_append_len(string_field->payload, value,
1005                         effective_length);
1006         } else {
1007                 string_field->payload = g_string_new_len(value,
1008                         effective_length);
1009         }
1010
1011         string_field->parent.payload_set = 1;
1012
1013 end:
1014         return ret;
1015 }
1016
1017 BT_HIDDEN
1018 int bt_ctf_field_validate(struct bt_ctf_field *field)
1019 {
1020         int ret = 0;
1021         enum ctf_type_id type_id;
1022
1023         if (!field) {
1024                 ret = -1;
1025                 goto end;
1026         }
1027
1028         type_id = bt_ctf_field_type_get_type_id(field->type);
1029         if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
1030                 ret = -1;
1031                 goto end;
1032         }
1033
1034         ret = field_validate_funcs[type_id](field);
1035 end:
1036         return ret;
1037 }
1038
1039 BT_HIDDEN
1040 int bt_ctf_field_reset(struct bt_ctf_field *field)
1041 {
1042         int ret = 0;
1043         enum ctf_type_id type_id;
1044
1045         if (!field) {
1046                 ret = -1;
1047                 goto end;
1048         }
1049
1050         type_id = bt_ctf_field_type_get_type_id(field->type);
1051         if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
1052                 ret = -1;
1053                 goto end;
1054         }
1055
1056         ret = field_reset_funcs[type_id](field);
1057 end:
1058         return ret;
1059 }
1060
1061 BT_HIDDEN
1062 int bt_ctf_field_serialize(struct bt_ctf_field *field,
1063                 struct ctf_stream_pos *pos)
1064 {
1065         int ret = 0;
1066         enum ctf_type_id type_id;
1067
1068         if (!field || !pos) {
1069                 ret = -1;
1070                 goto end;
1071         }
1072
1073         type_id = bt_ctf_field_type_get_type_id(field->type);
1074         if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
1075                 ret = -1;
1076                 goto end;
1077         }
1078
1079         ret = field_serialize_funcs[type_id](field, pos);
1080 end:
1081         return ret;
1082 }
1083
1084 BT_HIDDEN
1085 struct bt_ctf_field *bt_ctf_field_copy(struct bt_ctf_field *field)
1086 {
1087         int ret;
1088         struct bt_ctf_field *copy = NULL;
1089         enum ctf_type_id type_id;
1090
1091         if (!field) {
1092                 goto end;
1093         }
1094
1095         type_id = bt_ctf_field_type_get_type_id(field->type);
1096         if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
1097                 goto end;
1098         }
1099
1100         copy = bt_ctf_field_create(field->type);
1101         if (!copy) {
1102                 goto end;
1103         }
1104
1105         copy->payload_set = field->payload_set;
1106         ret = field_copy_funcs[type_id](field, copy);
1107         if (ret) {
1108                 bt_ctf_field_put(copy);
1109                 copy = NULL;
1110         }
1111 end:
1112         return copy;
1113 }
1114
1115 static
1116 struct bt_ctf_field *bt_ctf_field_integer_create(struct bt_ctf_field_type *type)
1117 {
1118         struct bt_ctf_field_type_integer *integer_type = container_of(type,
1119                 struct bt_ctf_field_type_integer, parent);
1120         struct bt_ctf_field_integer *integer = g_new0(
1121                 struct bt_ctf_field_integer, 1);
1122
1123         if (integer) {
1124                 integer->definition.declaration = &integer_type->declaration;
1125         }
1126
1127         return integer ? &integer->parent : NULL;
1128 }
1129
1130 static
1131 struct bt_ctf_field *bt_ctf_field_enumeration_create(
1132         struct bt_ctf_field_type *type)
1133 {
1134         struct bt_ctf_field_enumeration *enumeration = g_new0(
1135                 struct bt_ctf_field_enumeration, 1);
1136
1137         return enumeration ? &enumeration->parent : NULL;
1138 }
1139
1140 static
1141 struct bt_ctf_field *bt_ctf_field_floating_point_create(
1142         struct bt_ctf_field_type *type)
1143 {
1144         struct bt_ctf_field_floating_point *floating_point;
1145         struct bt_ctf_field_type_floating_point *floating_point_type;
1146
1147         floating_point = g_new0(struct bt_ctf_field_floating_point, 1);
1148         if (!floating_point) {
1149                 goto end;
1150         }
1151
1152         floating_point_type = container_of(type,
1153                 struct bt_ctf_field_type_floating_point, parent);
1154         floating_point->definition.declaration = container_of(
1155                 type->declaration, struct declaration_float, p);
1156
1157
1158         floating_point->definition.sign = &floating_point->sign;
1159         floating_point->sign.declaration = &floating_point_type->sign;
1160         floating_point->definition.sign->p.declaration =
1161                 &floating_point_type->sign.p;
1162
1163         floating_point->definition.mantissa = &floating_point->mantissa;
1164         floating_point->mantissa.declaration = &floating_point_type->mantissa;
1165         floating_point->definition.mantissa->p.declaration =
1166                 &floating_point_type->mantissa.p;
1167
1168         floating_point->definition.exp = &floating_point->exp;
1169         floating_point->exp.declaration = &floating_point_type->exp;
1170         floating_point->definition.exp->p.declaration =
1171                 &floating_point_type->exp.p;
1172
1173 end:
1174         return floating_point ? &floating_point->parent : NULL;
1175 }
1176
1177 static
1178 struct bt_ctf_field *bt_ctf_field_structure_create(
1179         struct bt_ctf_field_type *type)
1180 {
1181         struct bt_ctf_field_type_structure *structure_type = container_of(type,
1182                 struct bt_ctf_field_type_structure, parent);
1183         struct bt_ctf_field_structure *structure = g_new0(
1184                 struct bt_ctf_field_structure, 1);
1185         struct bt_ctf_field *field = NULL;
1186
1187         if (!structure || !structure_type->fields->len) {
1188                 goto end;
1189         }
1190
1191         structure->field_name_to_index = structure_type->field_name_to_index;
1192         structure->fields = g_ptr_array_new_with_free_func(
1193                 (GDestroyNotify)bt_ctf_field_put);
1194         g_ptr_array_set_size(structure->fields,
1195                 g_hash_table_size(structure->field_name_to_index));
1196         field = &structure->parent;
1197 end:
1198         return field;
1199 }
1200
1201 static
1202 struct bt_ctf_field *bt_ctf_field_variant_create(struct bt_ctf_field_type *type)
1203 {
1204         struct bt_ctf_field_variant *variant = g_new0(
1205                 struct bt_ctf_field_variant, 1);
1206         return variant ? &variant->parent : NULL;
1207 }
1208
1209 static
1210 struct bt_ctf_field *bt_ctf_field_array_create(struct bt_ctf_field_type *type)
1211 {
1212         struct bt_ctf_field_array *array = g_new0(struct bt_ctf_field_array, 1);
1213         struct bt_ctf_field_type_array *array_type;
1214         unsigned int array_length;
1215
1216         if (!array || !type) {
1217                 goto error;
1218         }
1219
1220         array_type = container_of(type, struct bt_ctf_field_type_array, parent);
1221         array_length = array_type->length;
1222         array->elements = g_ptr_array_sized_new(array_length);
1223         if (!array->elements) {
1224                 goto error;
1225         }
1226
1227         g_ptr_array_set_free_func(array->elements,
1228                 (GDestroyNotify)bt_ctf_field_put);
1229         g_ptr_array_set_size(array->elements, array_length);
1230         return &array->parent;
1231 error:
1232         g_free(array);
1233         return NULL;
1234 }
1235
1236 static
1237 struct bt_ctf_field *bt_ctf_field_sequence_create(
1238         struct bt_ctf_field_type *type)
1239 {
1240         struct bt_ctf_field_sequence *sequence = g_new0(
1241                 struct bt_ctf_field_sequence, 1);
1242         return sequence ? &sequence->parent : NULL;
1243 }
1244
1245 static
1246 struct bt_ctf_field *bt_ctf_field_string_create(struct bt_ctf_field_type *type)
1247 {
1248         struct bt_ctf_field_string *string = g_new0(
1249                 struct bt_ctf_field_string, 1);
1250         return string ? &string->parent : NULL;
1251 }
1252
1253 static
1254 void bt_ctf_field_destroy(struct bt_ctf_ref *ref)
1255 {
1256         struct bt_ctf_field *field;
1257         struct bt_ctf_field_type *type;
1258         enum ctf_type_id type_id;
1259
1260         if (!ref) {
1261                 return;
1262         }
1263
1264         field = container_of(ref, struct bt_ctf_field, ref_count);
1265         type = field->type;
1266         type_id = bt_ctf_field_type_get_type_id(type);
1267         if (type_id <= CTF_TYPE_UNKNOWN ||
1268                 type_id >= NR_CTF_TYPES) {
1269                 return;
1270         }
1271
1272         field_destroy_funcs[type_id](field);
1273         if (type) {
1274                 bt_ctf_field_type_put(type);
1275         }
1276 }
1277
1278 static
1279 void bt_ctf_field_integer_destroy(struct bt_ctf_field *field)
1280 {
1281         struct bt_ctf_field_integer *integer;
1282
1283         if (!field) {
1284                 return;
1285         }
1286
1287         integer = container_of(field, struct bt_ctf_field_integer, parent);
1288         g_free(integer);
1289 }
1290
1291 static
1292 void bt_ctf_field_enumeration_destroy(struct bt_ctf_field *field)
1293 {
1294         struct bt_ctf_field_enumeration *enumeration;
1295
1296         if (!field) {
1297                 return;
1298         }
1299
1300         enumeration = container_of(field, struct bt_ctf_field_enumeration,
1301                 parent);
1302         bt_ctf_field_put(enumeration->payload);
1303         g_free(enumeration);
1304 }
1305
1306 static
1307 void bt_ctf_field_floating_point_destroy(struct bt_ctf_field *field)
1308 {
1309         struct bt_ctf_field_floating_point *floating_point;
1310
1311         if (!field) {
1312                 return;
1313         }
1314
1315         floating_point = container_of(field, struct bt_ctf_field_floating_point,
1316                 parent);
1317         g_free(floating_point);
1318 }
1319
1320 static
1321 void bt_ctf_field_structure_destroy(struct bt_ctf_field *field)
1322 {
1323         struct bt_ctf_field_structure *structure;
1324
1325         if (!field) {
1326                 return;
1327         }
1328
1329         structure = container_of(field, struct bt_ctf_field_structure, parent);
1330         g_ptr_array_free(structure->fields, TRUE);
1331         g_free(structure);
1332 }
1333
1334 static
1335 void bt_ctf_field_variant_destroy(struct bt_ctf_field *field)
1336 {
1337         struct bt_ctf_field_variant *variant;
1338
1339         if (!field) {
1340                 return;
1341         }
1342
1343         variant = container_of(field, struct bt_ctf_field_variant, parent);
1344         bt_ctf_field_put(variant->tag);
1345         bt_ctf_field_put(variant->payload);
1346         g_free(variant);
1347 }
1348
1349 static
1350 void bt_ctf_field_array_destroy(struct bt_ctf_field *field)
1351 {
1352         struct bt_ctf_field_array *array;
1353
1354         if (!field) {
1355                 return;
1356         }
1357
1358         array = container_of(field, struct bt_ctf_field_array, parent);
1359         g_ptr_array_free(array->elements, TRUE);
1360         g_free(array);
1361 }
1362
1363 static
1364 void bt_ctf_field_sequence_destroy(struct bt_ctf_field *field)
1365 {
1366         struct bt_ctf_field_sequence *sequence;
1367
1368         if (!field) {
1369                 return;
1370         }
1371
1372         sequence = container_of(field, struct bt_ctf_field_sequence, parent);
1373         g_ptr_array_free(sequence->elements, TRUE);
1374         bt_ctf_field_put(sequence->length);
1375         g_free(sequence);
1376 }
1377
1378 static
1379 void bt_ctf_field_string_destroy(struct bt_ctf_field *field)
1380 {
1381         struct bt_ctf_field_string *string;
1382         if (!field) {
1383                 return;
1384         }
1385
1386         string = container_of(field, struct bt_ctf_field_string, parent);
1387         if (string->payload) {
1388                 g_string_free(string->payload, TRUE);
1389         }
1390         g_free(string);
1391 }
1392
1393 static
1394 int bt_ctf_field_generic_validate(struct bt_ctf_field *field)
1395 {
1396         return (field && field->payload_set) ? 0 : -1;
1397 }
1398
1399 static
1400 int bt_ctf_field_enumeration_validate(struct bt_ctf_field *field)
1401 {
1402         int ret;
1403         struct bt_ctf_field_enumeration *enumeration;
1404
1405         if (!field) {
1406                 ret = -1;
1407                 goto end;
1408         }
1409
1410         enumeration = container_of(field, struct bt_ctf_field_enumeration,
1411                 parent);
1412         if (!enumeration->payload) {
1413                 ret = -1;
1414                 goto end;
1415         }
1416
1417         ret = bt_ctf_field_validate(enumeration->payload);
1418 end:
1419         return ret;
1420 }
1421
1422 static
1423 int bt_ctf_field_structure_validate(struct bt_ctf_field *field)
1424 {
1425         size_t i;
1426         int ret = 0;
1427         struct bt_ctf_field_structure *structure;
1428
1429         if (!field) {
1430                 ret = -1;
1431                 goto end;
1432         }
1433
1434         structure = container_of(field, struct bt_ctf_field_structure, parent);
1435         for (i = 0; i < structure->fields->len; i++) {
1436                 ret = bt_ctf_field_validate(structure->fields->pdata[i]);
1437                 if (ret) {
1438                         goto end;
1439                 }
1440         }
1441 end:
1442         return ret;
1443 }
1444
1445 static
1446 int bt_ctf_field_variant_validate(struct bt_ctf_field *field)
1447 {
1448         int ret = 0;
1449         struct bt_ctf_field_variant *variant;
1450
1451         if (!field) {
1452                 ret = -1;
1453                 goto end;
1454         }
1455
1456         variant = container_of(field, struct bt_ctf_field_variant, parent);
1457         ret = bt_ctf_field_validate(variant->payload);
1458 end:
1459         return ret;
1460 }
1461
1462 static
1463 int bt_ctf_field_array_validate(struct bt_ctf_field *field)
1464 {
1465         size_t i;
1466         int ret = 0;
1467         struct bt_ctf_field_array *array;
1468
1469         if (!field) {
1470                 ret = -1;
1471                 goto end;
1472         }
1473
1474         array = container_of(field, struct bt_ctf_field_array, parent);
1475         for (i = 0; i < array->elements->len; i++) {
1476                 ret = bt_ctf_field_validate(array->elements->pdata[i]);
1477                 if (ret) {
1478                         goto end;
1479                 }
1480         }
1481 end:
1482         return ret;
1483 }
1484
1485 static
1486 int bt_ctf_field_sequence_validate(struct bt_ctf_field *field)
1487 {
1488         size_t i;
1489         int ret = 0;
1490         struct bt_ctf_field_sequence *sequence;
1491
1492         if (!field) {
1493                 ret = -1;
1494                 goto end;
1495         }
1496
1497         sequence = container_of(field, struct bt_ctf_field_sequence, parent);
1498         for (i = 0; i < sequence->elements->len; i++) {
1499                 ret = bt_ctf_field_validate(sequence->elements->pdata[i]);
1500                 if (ret) {
1501                         goto end;
1502                 }
1503         }
1504 end:
1505         return ret;
1506 }
1507
1508 static
1509 int bt_ctf_field_generic_reset(struct bt_ctf_field *field)
1510 {
1511         int ret = 0;
1512
1513         if (!field) {
1514                 ret = -1;
1515                 goto end;
1516         }
1517
1518         field->payload_set = 0;
1519 end:
1520         return ret;
1521 }
1522
1523 static
1524 int bt_ctf_field_enumeration_reset(struct bt_ctf_field *field)
1525 {
1526         int ret = 0;
1527         struct bt_ctf_field_enumeration *enumeration;
1528
1529         if (!field) {
1530                 ret = -1;
1531                 goto end;
1532         }
1533
1534         enumeration = container_of(field, struct bt_ctf_field_enumeration,
1535                 parent);
1536         if (!enumeration->payload) {
1537                 goto end;
1538         }
1539
1540         ret = bt_ctf_field_reset(enumeration->payload);
1541 end:
1542         return ret;
1543 }
1544
1545 static
1546 int bt_ctf_field_structure_reset(struct bt_ctf_field *field)
1547 {
1548         size_t i;
1549         int ret = 0;
1550         struct bt_ctf_field_structure *structure;
1551
1552         if (!field) {
1553                 ret = -1;
1554                 goto end;
1555         }
1556
1557         structure = container_of(field, struct bt_ctf_field_structure, parent);
1558         for (i = 0; i < structure->fields->len; i++) {
1559                 struct bt_ctf_field *member = structure->fields->pdata[i];
1560
1561                 if (!member) {
1562                         /*
1563                          * Structure members are lazily initialized; skip if
1564                          * this member has not been allocated yet.
1565                          */
1566                         continue;
1567                 }
1568
1569                 ret = bt_ctf_field_reset(member);
1570                 if (ret) {
1571                         goto end;
1572                 }
1573         }
1574 end:
1575         return ret;
1576 }
1577
1578 static
1579 int bt_ctf_field_variant_reset(struct bt_ctf_field *field)
1580 {
1581         int ret = 0;
1582         struct bt_ctf_field_variant *variant;
1583
1584         if (!field) {
1585                 ret = -1;
1586                 goto end;
1587         }
1588
1589         variant = container_of(field, struct bt_ctf_field_variant, parent);
1590         if (variant->payload) {
1591                 ret = bt_ctf_field_reset(variant->payload);
1592         }
1593 end:
1594         return ret;
1595 }
1596
1597 static
1598 int bt_ctf_field_array_reset(struct bt_ctf_field *field)
1599 {
1600         size_t i;
1601         int ret = 0;
1602         struct bt_ctf_field_array *array;
1603
1604         if (!field) {
1605                 ret = -1;
1606                 goto end;
1607         }
1608
1609         array = container_of(field, struct bt_ctf_field_array, parent);
1610         for (i = 0; i < array->elements->len; i++) {
1611                 struct bt_ctf_field *member = array->elements->pdata[i];
1612
1613                 if (!member) {
1614                         /*
1615                          * Array elements are lazily initialized; skip if
1616                          * this member has not been allocated yet.
1617                          */
1618                         continue;
1619                 }
1620
1621                 ret = bt_ctf_field_reset(member);
1622                 if (ret) {
1623                         goto end;
1624                 }
1625         }
1626 end:
1627         return ret;
1628 }
1629
1630 static
1631 int bt_ctf_field_sequence_reset(struct bt_ctf_field *field)
1632 {
1633         size_t i;
1634         int ret = 0;
1635         struct bt_ctf_field_sequence *sequence;
1636
1637         if (!field) {
1638                 ret = -1;
1639                 goto end;
1640         }
1641
1642         sequence = container_of(field, struct bt_ctf_field_sequence, parent);
1643         for (i = 0; i < sequence->elements->len; i++) {
1644                 struct bt_ctf_field *member = sequence->elements->pdata[i];
1645
1646                 if (!member) {
1647                         /*
1648                          * Sequence elements are lazily initialized; skip if
1649                          * this member has not been allocated yet.
1650                          */
1651                         continue;
1652                 }
1653
1654                 ret = bt_ctf_field_reset(member);
1655                 if (ret) {
1656                         goto end;
1657                 }
1658         }
1659 end:
1660         return ret;
1661 }
1662
1663 static
1664 int bt_ctf_field_string_reset(struct bt_ctf_field *field)
1665 {
1666         int ret = 0;
1667         struct bt_ctf_field_string *string;
1668
1669         if (!field) {
1670                 ret = -1;
1671                 goto end;
1672         }
1673
1674         ret = bt_ctf_field_generic_reset(field);
1675         if (ret) {
1676                 goto end;
1677         }
1678
1679         string = container_of(field, struct bt_ctf_field_string, parent);
1680         if (string->payload) {
1681                 g_string_truncate(string->payload, 0);
1682         }
1683 end:
1684         return ret;
1685 }
1686
1687 static
1688 int bt_ctf_field_integer_serialize(struct bt_ctf_field *field,
1689                 struct ctf_stream_pos *pos)
1690 {
1691         int ret = 0;
1692         struct bt_ctf_field_integer *integer = container_of(field,
1693                 struct bt_ctf_field_integer, parent);
1694
1695 retry:
1696         ret = ctf_integer_write(&pos->parent, &integer->definition.p);
1697         if (ret == -EFAULT) {
1698                 /*
1699                  * The field is too large to fit in the current packet's
1700                  * remaining space. Bump the packet size and retry.
1701                  */
1702                 ret = increase_packet_size(pos);
1703                 if (ret) {
1704                         goto end;
1705                 }
1706                 goto retry;
1707         }
1708 end:
1709         return ret;
1710 }
1711
1712 static
1713 int bt_ctf_field_enumeration_serialize(struct bt_ctf_field *field,
1714                 struct ctf_stream_pos *pos)
1715 {
1716         struct bt_ctf_field_enumeration *enumeration = container_of(
1717                 field, struct bt_ctf_field_enumeration, parent);
1718
1719         return bt_ctf_field_serialize(enumeration->payload, pos);
1720 }
1721
1722 static
1723 int bt_ctf_field_floating_point_serialize(struct bt_ctf_field *field,
1724                 struct ctf_stream_pos *pos)
1725 {
1726         int ret = 0;
1727         struct bt_ctf_field_floating_point *floating_point = container_of(field,
1728                 struct bt_ctf_field_floating_point, parent);
1729
1730 retry:
1731         ret = ctf_float_write(&pos->parent, &floating_point->definition.p);
1732         if (ret == -EFAULT) {
1733                 /*
1734                  * The field is too large to fit in the current packet's
1735                  * remaining space. Bump the packet size and retry.
1736                  */
1737                 ret = increase_packet_size(pos);
1738                 if (ret) {
1739                         goto end;
1740                 }
1741                 goto retry;
1742         }
1743 end:
1744         return ret;
1745 }
1746
1747 static
1748 int bt_ctf_field_structure_serialize(struct bt_ctf_field *field,
1749                 struct ctf_stream_pos *pos)
1750 {
1751         size_t i;
1752         int ret = 0;
1753         struct bt_ctf_field_structure *structure = container_of(
1754                 field, struct bt_ctf_field_structure, parent);
1755
1756         while (!ctf_pos_access_ok(pos,
1757                 offset_align(pos->offset,
1758                         field->type->declaration->alignment))) {
1759                 ret = increase_packet_size(pos);
1760                 if (ret) {
1761                         goto end;
1762                 }
1763         }
1764
1765         if (!ctf_align_pos(pos, field->type->declaration->alignment)) {
1766                 ret = -1;
1767                 goto end;
1768         }
1769
1770         for (i = 0; i < structure->fields->len; i++) {
1771                 struct bt_ctf_field *field = g_ptr_array_index(
1772                         structure->fields, i);
1773
1774                 ret = bt_ctf_field_serialize(field, pos);
1775                 if (ret) {
1776                         break;
1777                 }
1778         }
1779 end:
1780         return ret;
1781 }
1782
1783 static
1784 int bt_ctf_field_variant_serialize(struct bt_ctf_field *field,
1785                 struct ctf_stream_pos *pos)
1786 {
1787         struct bt_ctf_field_variant *variant = container_of(
1788                 field, struct bt_ctf_field_variant, parent);
1789
1790         return bt_ctf_field_serialize(variant->payload, pos);
1791 }
1792
1793 static
1794 int bt_ctf_field_array_serialize(struct bt_ctf_field *field,
1795                 struct ctf_stream_pos *pos)
1796 {
1797         size_t i;
1798         int ret = 0;
1799         struct bt_ctf_field_array *array = container_of(
1800                 field, struct bt_ctf_field_array, parent);
1801
1802         for (i = 0; i < array->elements->len; i++) {
1803                 ret = bt_ctf_field_serialize(
1804                         g_ptr_array_index(array->elements, i), pos);
1805                 if (ret) {
1806                         goto end;
1807                 }
1808         }
1809 end:
1810         return ret;
1811 }
1812
1813 static
1814 int bt_ctf_field_sequence_serialize(struct bt_ctf_field *field,
1815                 struct ctf_stream_pos *pos)
1816 {
1817         size_t i;
1818         int ret = 0;
1819         struct bt_ctf_field_sequence *sequence = container_of(
1820                 field, struct bt_ctf_field_sequence, parent);
1821
1822         for (i = 0; i < sequence->elements->len; i++) {
1823                 ret = bt_ctf_field_serialize(
1824                         g_ptr_array_index(sequence->elements, i), pos);
1825                 if (ret) {
1826                         goto end;
1827                 }
1828         }
1829 end:
1830         return ret;
1831 }
1832
1833 static
1834 int bt_ctf_field_string_serialize(struct bt_ctf_field *field,
1835                 struct ctf_stream_pos *pos)
1836 {
1837         size_t i;
1838         int ret = 0;
1839         struct bt_ctf_field_string *string = container_of(field,
1840                 struct bt_ctf_field_string, parent);
1841         struct bt_ctf_field_type *character_type =
1842                 get_field_type(FIELD_TYPE_ALIAS_UINT8_T);
1843         struct bt_ctf_field *character = bt_ctf_field_create(character_type);
1844
1845         for (i = 0; i < string->payload->len + 1; i++) {
1846                 ret = bt_ctf_field_unsigned_integer_set_value(character,
1847                         (uint64_t) string->payload->str[i]);
1848                 if (ret) {
1849                         goto end;
1850                 }
1851
1852                 ret = bt_ctf_field_integer_serialize(character, pos);
1853                 if (ret) {
1854                         goto end;
1855                 }
1856         }
1857 end:
1858         bt_ctf_field_put(character);
1859         bt_ctf_field_type_put(character_type);
1860         return ret;
1861 }
1862
1863 static
1864 int bt_ctf_field_integer_copy(struct bt_ctf_field *src,
1865                 struct bt_ctf_field *dst)
1866 {
1867         struct bt_ctf_field_integer *integer_src, *integer_dst;
1868
1869         integer_src = container_of(src, struct bt_ctf_field_integer, parent);
1870         integer_dst = container_of(dst, struct bt_ctf_field_integer, parent);
1871
1872         memcpy(&integer_dst->definition, &integer_src->definition,
1873                 sizeof(struct definition_integer));
1874         return 0;
1875 }
1876
1877 static
1878 int bt_ctf_field_enumeration_copy(struct bt_ctf_field *src,
1879                 struct bt_ctf_field *dst)
1880 {
1881         int ret = 0;
1882         struct bt_ctf_field_enumeration *enum_src, *enum_dst;
1883
1884         enum_src = container_of(src, struct bt_ctf_field_enumeration, parent);
1885         enum_dst = container_of(dst, struct bt_ctf_field_enumeration, parent);
1886
1887         if (enum_src->payload) {
1888                 enum_dst->payload = bt_ctf_field_copy(enum_src->payload);
1889                 if (!enum_dst->payload) {
1890                         ret = -1;
1891                         goto end;
1892                 }
1893         }
1894 end:
1895         return ret;
1896 }
1897
1898 static
1899 int bt_ctf_field_floating_point_copy(
1900                 struct bt_ctf_field *src, struct bt_ctf_field *dst)
1901 {
1902         struct bt_ctf_field_floating_point *float_src, *float_dst;
1903
1904         float_src = container_of(src, struct bt_ctf_field_floating_point,
1905                 parent);
1906         float_dst = container_of(dst, struct bt_ctf_field_floating_point,
1907                 parent);
1908
1909         memcpy(&float_dst->definition, &float_src->definition,
1910                 sizeof(struct definition_float));
1911         memcpy(&float_dst->sign, &float_src->sign,
1912                 sizeof(struct definition_integer));
1913         memcpy(&float_dst->mantissa, &float_src->mantissa,
1914                 sizeof(struct definition_integer));
1915         memcpy(&float_dst->exp, &float_src->exp,
1916                 sizeof(struct definition_integer));
1917         return 0;
1918 }
1919
1920 static
1921 int bt_ctf_field_structure_copy(struct bt_ctf_field *src,
1922                 struct bt_ctf_field *dst)
1923 {
1924         int ret = 0, i;
1925         struct bt_ctf_field_structure *struct_src, *struct_dst;
1926
1927         struct_src = container_of(src, struct bt_ctf_field_structure, parent);
1928         struct_dst = container_of(dst, struct bt_ctf_field_structure, parent);
1929
1930         /* This field_name_to_index HT is owned by the structure field type */
1931         struct_dst->field_name_to_index = struct_src->field_name_to_index;
1932         g_ptr_array_set_size(struct_dst->fields, struct_src->fields->len);
1933
1934         for (i = 0; i < struct_src->fields->len; i++) {
1935                 struct bt_ctf_field *field =
1936                         g_ptr_array_index(struct_src->fields, i);
1937                 struct bt_ctf_field *field_copy = NULL;
1938
1939                 if (field) {
1940                         field_copy = bt_ctf_field_copy(field);
1941
1942                         if (!field_copy) {
1943                                 ret = -1;
1944                                 goto end;
1945                         }
1946                 }
1947
1948                 g_ptr_array_index(struct_dst->fields, i) = field_copy;
1949         }
1950 end:
1951         return ret;
1952 }
1953
1954 static
1955 int bt_ctf_field_variant_copy(struct bt_ctf_field *src,
1956                 struct bt_ctf_field *dst)
1957 {
1958         int ret = 0;
1959         struct bt_ctf_field_variant *variant_src, *variant_dst;
1960
1961         variant_src = container_of(src, struct bt_ctf_field_variant, parent);
1962         variant_dst = container_of(dst, struct bt_ctf_field_variant, parent);
1963
1964         if (variant_src->tag) {
1965                 variant_dst->tag = bt_ctf_field_copy(variant_src->tag);
1966                 if (!variant_dst->tag) {
1967                         ret = -1;
1968                         goto end;
1969                 }
1970         }
1971         if (variant_src->payload) {
1972                 variant_dst->payload = bt_ctf_field_copy(variant_src->payload);
1973                 if (!variant_dst->payload) {
1974                         ret = -1;
1975                         goto end;
1976                 }
1977         }
1978 end:
1979         return ret;
1980 }
1981
1982 static
1983 int bt_ctf_field_array_copy(struct bt_ctf_field *src,
1984                 struct bt_ctf_field *dst)
1985 {
1986         int ret = 0, i;
1987         struct bt_ctf_field_array *array_src, *array_dst;
1988
1989         array_src = container_of(src, struct bt_ctf_field_array, parent);
1990         array_dst = container_of(dst, struct bt_ctf_field_array, parent);
1991
1992         g_ptr_array_set_size(array_dst->elements, array_src->elements->len);
1993         for (i = 0; i < array_src->elements->len; i++) {
1994                 struct bt_ctf_field *field =
1995                         g_ptr_array_index(array_src->elements, i);
1996                 struct bt_ctf_field *field_copy = NULL;
1997
1998                 if (field) {
1999                         field_copy = bt_ctf_field_copy(field);
2000
2001                         if (!field_copy) {
2002                                 ret = -1;
2003                                 goto end;
2004                         }
2005                 }
2006
2007                 g_ptr_array_index(array_dst->elements, i) = field_copy;
2008         }
2009 end:
2010         return ret;
2011 }
2012
2013 static
2014 int bt_ctf_field_sequence_copy(struct bt_ctf_field *src,
2015                 struct bt_ctf_field *dst)
2016 {
2017         int ret = 0, i;
2018         struct bt_ctf_field_sequence *sequence_src, *sequence_dst;
2019         struct bt_ctf_field *src_length;
2020         struct bt_ctf_field *dst_length;
2021
2022         sequence_src = container_of(src, struct bt_ctf_field_sequence, parent);
2023         sequence_dst = container_of(dst, struct bt_ctf_field_sequence, parent);
2024
2025         src_length = bt_ctf_field_sequence_get_length(src);
2026
2027         if (!src_length) {
2028                 /* no length set yet: keep destination sequence empty */
2029                 goto end;
2030         }
2031
2032         /* copy source length */
2033         dst_length = bt_ctf_field_copy(src_length);
2034         bt_ctf_field_put(src_length);
2035
2036         if (!dst_length) {
2037                 ret = -1;
2038                 goto end;
2039         }
2040
2041         /* this will initialize the destination sequence's internal array */
2042         ret = bt_ctf_field_sequence_set_length(dst, dst_length);
2043         bt_ctf_field_put(dst_length);
2044
2045         if (ret) {
2046                 goto end;
2047         }
2048
2049         assert(sequence_dst->elements->len == sequence_src->elements->len);
2050
2051         for (i = 0; i < sequence_src->elements->len; i++) {
2052                 struct bt_ctf_field *field =
2053                         g_ptr_array_index(sequence_src->elements, i);
2054                 struct bt_ctf_field *field_copy = NULL;
2055
2056                 if (field) {
2057                         field_copy = bt_ctf_field_copy(field);
2058
2059                         if (!field_copy) {
2060                                 ret = -1;
2061                                 goto end;
2062                         }
2063                 }
2064
2065                 g_ptr_array_index(sequence_dst->elements, i) = field_copy;
2066         }
2067 end:
2068         return ret;
2069 }
2070
2071 static
2072 int bt_ctf_field_string_copy(struct bt_ctf_field *src,
2073                 struct bt_ctf_field *dst)
2074 {
2075         int ret = 0;
2076         struct bt_ctf_field_string *string_src, *string_dst;
2077
2078         string_src = container_of(src, struct bt_ctf_field_string, parent);
2079         string_dst = container_of(dst, struct bt_ctf_field_string, parent);
2080
2081         if (string_src->payload) {
2082                 string_dst->payload = g_string_new(string_src->payload->str);
2083                 if (!string_dst->payload) {
2084                         ret = -1;
2085                         goto end;
2086                 }
2087         }
2088 end:
2089         return ret;
2090 }
2091
2092 static
2093 int increase_packet_size(struct ctf_stream_pos *pos)
2094 {
2095         int ret;
2096
2097         assert(pos);
2098         ret = munmap_align(pos->base_mma);
2099         if (ret) {
2100                 goto end;
2101         }
2102
2103         pos->packet_size += PACKET_LEN_INCREMENT;
2104         ret = posix_fallocate(pos->fd, pos->mmap_offset,
2105                 pos->packet_size / CHAR_BIT);
2106         if (ret) {
2107                 goto end;
2108         }
2109
2110         pos->base_mma = mmap_align(pos->packet_size / CHAR_BIT, pos->prot,
2111                 pos->flags, pos->fd, pos->mmap_offset);
2112         if (pos->base_mma == MAP_FAILED) {
2113                 ret = -1;
2114         }
2115 end:
2116         return ret;
2117 }