lib/ctf-ir/trace.c

   1 /*
   2  * trace.c
   3  *
   4  * Babeltrace CTF IR - Trace
   5  *
   6  * Copyright 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 #define BT_LOG_TAG "TRACE"
  30 #include <babeltrace/lib-logging-internal.h>
  31
  32 #include <babeltrace/ctf-ir/trace-internal.h>
  33 #include <babeltrace/ctf-ir/clock-class-internal.h>
  34 #include <babeltrace/ctf-ir/stream-internal.h>
  35 #include <babeltrace/ctf-ir/stream-class-internal.h>
  36 #include <babeltrace/ctf-ir/event-internal.h>
  37 #include <babeltrace/ctf-ir/event-class.h>
  38 #include <babeltrace/ctf-ir/event-class-internal.h>
  39 #include <babeltrace/ctf-writer/functor-internal.h>
  40 #include <babeltrace/ctf-writer/clock-internal.h>
  41 #include <babeltrace/ctf-ir/field-types-internal.h>
  42 #include <babeltrace/ctf-ir/attributes-internal.h>
  43 #include <babeltrace/ctf-ir/validation-internal.h>
  44 #include <babeltrace/ctf-ir/visitor-internal.h>
  45 #include <babeltrace/ctf-ir/utils.h>
  46 #include <babeltrace/ctf-ir/utils-internal.h>
  47 #include <babeltrace/compiler-internal.h>
  48 #include <babeltrace/values.h>
  49 #include <babeltrace/values-internal.h>
  50 #include <babeltrace/ref.h>
  51 #include <babeltrace/types.h>
  52 #include <babeltrace/endian-internal.h>
  53 #include <inttypes.h>
  54 #include <stdint.h>
  55 #include <string.h>
  56 #include <stdlib.h>
  57
  58 #define DEFAULT_IDENTIFIER_SIZE 128
  59 #define DEFAULT_METADATA_STRING_SIZE 4096
  60
  61 struct listener_wrapper {
  62         bt_listener_cb listener;
  63         void *data;
  64 };
  65
  66 struct bt_trace_is_static_listener_elem {
  67         bt_trace_is_static_listener func;
  68         bt_trace_listener_removed removed;
  69         void *data;
  70 };
  71
  72 static
  73 void bt_trace_destroy(struct bt_object *obj);
  74 static
  75 void bt_trace_freeze(struct bt_trace *trace);
  76
  77 static
  78 const unsigned int field_type_aliases_alignments[] = {
  79         [FIELD_TYPE_ALIAS_UINT5_T] = 1,
  80         [FIELD_TYPE_ALIAS_UINT8_T ... FIELD_TYPE_ALIAS_UINT16_T] = 8,
  81         [FIELD_TYPE_ALIAS_UINT27_T] = 1,
  82         [FIELD_TYPE_ALIAS_UINT32_T ... FIELD_TYPE_ALIAS_UINT64_T] = 8,
  83 };
  84
  85 static
  86 const unsigned int field_type_aliases_sizes[] = {
  87         [FIELD_TYPE_ALIAS_UINT5_T] = 5,
  88         [FIELD_TYPE_ALIAS_UINT8_T] = 8,
  89         [FIELD_TYPE_ALIAS_UINT16_T] = 16,
  90         [FIELD_TYPE_ALIAS_UINT27_T] = 27,
  91         [FIELD_TYPE_ALIAS_UINT32_T] = 32,
  92         [FIELD_TYPE_ALIAS_UINT64_T] = 64,
  93 };
  94
  95 struct bt_trace *bt_trace_create(void)
  96 {
  97         struct bt_trace *trace = NULL;
  98
  99         trace = g_new0(struct bt_trace, 1);
 100         if (!trace) {
 101                 BT_LOGE_STR("Failed to allocate one trace.");
 102                 goto error;
 103         }
 104
 105         BT_LOGD_STR("Creating trace object.");
 106         trace->native_byte_order = BT_BYTE_ORDER_UNSPECIFIED;
 107         bt_object_init(trace, bt_trace_destroy);
 108         trace->clocks = g_ptr_array_new_with_free_func(
 109                 (GDestroyNotify) bt_put);
 110         if (!trace->clocks) {
 111                 BT_LOGE_STR("Failed to allocate one GPtrArray.");
 112                 goto error;
 113         }
 114
 115         trace->streams = g_ptr_array_new_with_free_func(
 116                 (GDestroyNotify) bt_object_release);
 117         if (!trace->streams) {
 118                 BT_LOGE_STR("Failed to allocate one GPtrArray.");
 119                 goto error;
 120         }
 121
 122         trace->stream_classes = g_ptr_array_new_with_free_func(
 123                 (GDestroyNotify) bt_object_release);
 124         if (!trace->stream_classes) {
 125                 BT_LOGE_STR("Failed to allocate one GPtrArray.");
 126                 goto error;
 127         }
 128
 129         /* Create the environment array object */
 130         trace->environment = bt_attributes_create();
 131         if (!trace->environment) {
 132                 BT_LOGE_STR("Cannot create empty attributes object.");
 133                 goto error;
 134         }
 135
 136         trace->listeners = g_ptr_array_new_with_free_func(
 137                         (GDestroyNotify) g_free);
 138         if (!trace->listeners) {
 139                 BT_LOGE_STR("Failed to allocate one GPtrArray.");
 140                 goto error;
 141         }
 142
 143         trace->is_static_listeners = g_array_new(FALSE, TRUE,
 144                 sizeof(struct bt_trace_is_static_listener_elem));
 145         if (!trace->is_static_listeners) {
 146                 BT_LOGE_STR("Failed to allocate one GArray.");
 147                 goto error;
 148         }
 149
 150         BT_LOGD("Created trace object: addr=%p", trace);
 151         return trace;
 152
 153 error:
 154         BT_PUT(trace);
 155         return trace;
 156 }
 157
 158 const char *bt_trace_get_name(struct bt_trace *trace)
 159 {
 160         const char *name = NULL;
 161
 162         if (!trace) {
 163                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
 164                 goto end;
 165         }
 166
 167         if (!trace->name) {
 168                 goto end;
 169         }
 170
 171         name = trace->name->str;
 172 end:
 173         return name;
 174 }
 175
 176 int bt_trace_set_name(struct bt_trace *trace, const char *name)
 177 {
 178         int ret = 0;
 179
 180         if (!trace) {
 181                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
 182                 ret = -1;
 183                 goto end;
 184         }
 185
 186         if (!name) {
 187                 BT_LOGW_STR("Invalid parameter: name is NULL.");
 188                 ret = -1;
 189                 goto end;
 190         }
 191
 192         if (trace->frozen) {
 193                 BT_LOGW("Invalid parameter: trace is frozen: "
 194                         "addr=%p, name=\"%s\"",
 195                         trace, bt_trace_get_name(trace));
 196                 ret = -1;
 197                 goto end;
 198         }
 199
 200         trace->name = trace->name ? g_string_assign(trace->name, name) :
 201                         g_string_new(name);
 202         if (!trace->name) {
 203                 BT_LOGE_STR("Failed to allocate one GString.");
 204                 ret = -1;
 205                 goto end;
 206         }
 207
 208         BT_LOGV("Set trace's name: addr=%p, name=\"%s\"", trace, name);
 209
 210 end:
 211         return ret;
 212 }
 213
 214 const unsigned char *bt_trace_get_uuid(struct bt_trace *trace)
 215 {
 216         return trace && trace->uuid_set ? trace->uuid : NULL;
 217 }
 218
 219 int bt_trace_set_uuid(struct bt_trace *trace, const unsigned char *uuid)
 220 {
 221         int ret = 0;
 222
 223         if (!trace) {
 224                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
 225                 ret = -1;
 226                 goto end;
 227         }
 228
 229         if (!uuid) {
 230                 BT_LOGW_STR("Invalid parameter: UUID is NULL.");
 231                 ret = -1;
 232                 goto end;
 233         }
 234
 235         if (trace->frozen) {
 236                 BT_LOGW("Invalid parameter: trace is frozen: "
 237                         "addr=%p, name=\"%s\"",
 238                         trace, bt_trace_get_name(trace));
 239                 ret = -1;
 240                 goto end;
 241         }
 242
 243         memcpy(trace->uuid, uuid, BABELTRACE_UUID_LEN);
 244         trace->uuid_set = BT_TRUE;
 245         BT_LOGV("Set trace's UUID: addr=%p, name=\"%s\", "
 246                 "uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\"",
 247                 trace, bt_trace_get_name(trace),
 248                 (unsigned int) uuid[0],
 249                 (unsigned int) uuid[1],
 250                 (unsigned int) uuid[2],
 251                 (unsigned int) uuid[3],
 252                 (unsigned int) uuid[4],
 253                 (unsigned int) uuid[5],
 254                 (unsigned int) uuid[6],
 255                 (unsigned int) uuid[7],
 256                 (unsigned int) uuid[8],
 257                 (unsigned int) uuid[9],
 258                 (unsigned int) uuid[10],
 259                 (unsigned int) uuid[11],
 260                 (unsigned int) uuid[12],
 261                 (unsigned int) uuid[13],
 262                 (unsigned int) uuid[14],
 263                 (unsigned int) uuid[15]);
 264
 265 end:
 266         return ret;
 267 }
 268
 269 void bt_trace_destroy(struct bt_object *obj)
 270 {
 271         struct bt_trace *trace;
 272
 273         trace = container_of(obj, struct bt_trace, base);
 274
 275         BT_LOGD("Destroying trace object: addr=%p, name=\"%s\"",
 276                 trace, bt_trace_get_name(trace));
 277
 278         /*
 279          * Call remove listeners first so that everything else still
 280          * exists in the trace.
 281          */
 282         if (trace->is_static_listeners) {
 283                 size_t i;
 284
 285                 for (i = 0; i < trace->is_static_listeners->len; i++) {
 286                         struct bt_trace_is_static_listener_elem elem =
 287                                 g_array_index(trace->is_static_listeners,
 288                                         struct bt_trace_is_static_listener_elem, i);
 289
 290                         if (elem.removed) {
 291                                 elem.removed(trace, elem.data);
 292                         }
 293                 }
 294
 295                 g_array_free(trace->is_static_listeners, TRUE);
 296         }
 297
 298         if (trace->listeners) {
 299                 g_ptr_array_free(trace->listeners, TRUE);
 300         }
 301
 302         if (trace->environment) {
 303                 BT_LOGD_STR("Destroying environment attributes.");
 304                 bt_attributes_destroy(trace->environment);
 305         }
 306
 307         if (trace->name) {
 308                 g_string_free(trace->name, TRUE);
 309         }
 310
 311         if (trace->clocks) {
 312                 BT_LOGD_STR("Putting clock classes.");
 313                 g_ptr_array_free(trace->clocks, TRUE);
 314         }
 315
 316         if (trace->streams) {
 317                 BT_LOGD_STR("Destroying streams.");
 318                 g_ptr_array_free(trace->streams, TRUE);
 319         }
 320
 321         if (trace->stream_classes) {
 322                 BT_LOGD_STR("Destroying stream classes.");
 323                 g_ptr_array_free(trace->stream_classes, TRUE);
 324         }
 325
 326         BT_LOGD_STR("Putting packet header field type.");
 327         bt_put(trace->packet_header_type);
 328         g_free(trace);
 329 }
 330
 331 int bt_trace_set_environment_field(struct bt_trace *trace,
 332                 const char *name, struct bt_value *value)
 333 {
 334         int ret = 0;
 335
 336         if (!trace) {
 337                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
 338                 ret = -1;
 339                 goto end;
 340         }
 341
 342         if (!name) {
 343                 BT_LOGW_STR("Invalid parameter: name is NULL.");
 344                 ret = -1;
 345                 goto end;
 346         }
 347
 348         if (!value) {
 349                 BT_LOGW_STR("Invalid parameter: value is NULL.");
 350                 ret = -1;
 351                 goto end;
 352         }
 353
 354         if (!bt_identifier_is_valid(name)) {
 355                 BT_LOGW("Invalid parameter: environment field's name is not a valid CTF identifier: "
 356                         "trace-addr=%p, trace-name=\"%s\", "
 357                         "env-name=\"%s\"",
 358                         trace, bt_trace_get_name(trace), name);
 359                 ret = -1;
 360                 goto end;
 361         }
 362
 363         if (!bt_value_is_integer(value) && !bt_value_is_string(value)) {
 364                 BT_LOGW("Invalid parameter: environment field's value is not an integer or string value: "
 365                         "trace-addr=%p, trace-name=\"%s\", "
 366                         "env-name=\"%s\", env-value-type=%s",
 367                         trace, bt_trace_get_name(trace), name,
 368                         bt_value_type_string(bt_value_get_type(value)));
 369                 ret = -1;
 370                 goto end;
 371         }
 372
 373         if (trace->is_static) {
 374                 BT_LOGW("Invalid parameter: trace is static: "
 375                         "addr=%p, name=\"%s\"",
 376                         trace, bt_trace_get_name(trace));
 377                 ret = -1;
 378                 goto end;
 379         }
 380
 381         if (trace->frozen) {
 382                 /*
 383                  * New environment fields may be added to a frozen trace,
 384                  * but existing fields may not be changed.
 385                  *
 386                  * The object passed is frozen like all other attributes.
 387                  */
 388                 struct bt_value *attribute =
 389                         bt_attributes_get_field_value_by_name(
 390                                 trace->environment, name);
 391
 392                 if (attribute) {
 393                         BT_LOGW("Invalid parameter: trace is frozen and environment field already exists with this name: "
 394                                 "trace-addr=%p, trace-name=\"%s\", "
 395                                 "env-name=\"%s\"",
 396                                 trace, bt_trace_get_name(trace), name);
 397                         BT_PUT(attribute);
 398                         ret = -1;
 399                         goto end;
 400                 }
 401
 402                 bt_value_freeze(value);
 403         }
 404
 405         ret = bt_attributes_set_field_value(trace->environment, name,
 406                 value);
 407         if (ret) {
 408                 BT_LOGE("Cannot set environment field's value: "
 409                         "trace-addr=%p, trace-name=\"%s\", "
 410                         "env-name=\"%s\"",
 411                         trace, bt_trace_get_name(trace), name);
 412         } else {
 413                 BT_LOGV("Set environment field's value: "
 414                         "trace-addr=%p, trace-name=\"%s\", "
 415                         "env-name=\"%s\", value-addr=%p",
 416                         trace, bt_trace_get_name(trace), name, value);
 417         }
 418
 419 end:
 420         return ret;
 421 }
 422
 423 int bt_trace_set_environment_field_string(struct bt_trace *trace,
 424                 const char *name, const char *value)
 425 {
 426         int ret = 0;
 427         struct bt_value *env_value_string_obj = NULL;
 428
 429         if (!value) {
 430                 BT_LOGW_STR("Invalid parameter: value is NULL.");
 431                 ret = -1;
 432                 goto end;
 433         }
 434
 435         env_value_string_obj = bt_value_string_create_init(value);
 436         if (!env_value_string_obj) {
 437                 BT_LOGE_STR("Cannot create string value object.");
 438                 ret = -1;
 439                 goto end;
 440         }
 441
 442         /* bt_trace_set_environment_field() logs errors */
 443         ret = bt_trace_set_environment_field(trace, name,
 444                 env_value_string_obj);
 445
 446 end:
 447         bt_put(env_value_string_obj);
 448         return ret;
 449 }
 450
 451 int bt_trace_set_environment_field_integer(struct bt_trace *trace,
 452                 const char *name, int64_t value)
 453 {
 454         int ret = 0;
 455         struct bt_value *env_value_integer_obj = NULL;
 456
 457         env_value_integer_obj = bt_value_integer_create_init(value);
 458         if (!env_value_integer_obj) {
 459                 BT_LOGE_STR("Cannot create integer value object.");
 460                 ret = -1;
 461                 goto end;
 462         }
 463
 464         /* bt_trace_set_environment_field() logs errors */
 465         ret = bt_trace_set_environment_field(trace, name,
 466                 env_value_integer_obj);
 467
 468 end:
 469         bt_put(env_value_integer_obj);
 470         return ret;
 471 }
 472
 473 int64_t bt_trace_get_environment_field_count(struct bt_trace *trace)
 474 {
 475         int64_t ret = 0;
 476
 477         if (!trace) {
 478                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
 479                 ret = (int64_t) -1;
 480                 goto end;
 481         }
 482
 483         ret = bt_attributes_get_count(trace->environment);
 484         assert(ret >= 0);
 485
 486 end:
 487         return ret;
 488 }
 489
 490 const char *
 491 bt_trace_get_environment_field_name_by_index(struct bt_trace *trace,
 492                 uint64_t index)
 493 {
 494         const char *ret = NULL;
 495
 496         if (!trace) {
 497                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
 498                 goto end;
 499         }
 500
 501         ret = bt_attributes_get_field_name(trace->environment, index);
 502
 503 end:
 504         return ret;
 505 }
 506
 507 struct bt_value *bt_trace_get_environment_field_value_by_index(
 508                 struct bt_trace *trace, uint64_t index)
 509 {
 510         struct bt_value *ret = NULL;
 511
 512         if (!trace) {
 513                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
 514                 goto end;
 515         }
 516
 517         ret = bt_attributes_get_field_value(trace->environment, index);
 518
 519 end:
 520         return ret;
 521 }
 522
 523 struct bt_value *bt_trace_get_environment_field_value_by_name(
 524                 struct bt_trace *trace, const char *name)
 525 {
 526         struct bt_value *ret = NULL;
 527
 528         if (!trace) {
 529                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
 530                 goto end;
 531         }
 532
 533         if (!name) {
 534                 BT_LOGW_STR("Invalid parameter: name is NULL.");
 535                 goto end;
 536         }
 537
 538         ret = bt_attributes_get_field_value_by_name(trace->environment,
 539                 name);
 540
 541 end:
 542         return ret;
 543 }
 544
 545 int bt_trace_add_clock_class(struct bt_trace *trace,
 546                 struct bt_clock_class *clock_class)
 547 {
 548         int ret = 0;
 549
 550         if (!trace) {
 551                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
 552                 ret = -1;
 553                 goto end;
 554         }
 555
 556         if (trace->is_static) {
 557                 BT_LOGW("Invalid parameter: trace is static: "
 558                         "addr=%p, name=\"%s\"",
 559                         trace, bt_trace_get_name(trace));
 560                 ret = -1;
 561                 goto end;
 562         }
 563
 564         if (!bt_clock_class_is_valid(clock_class)) {
 565                 BT_LOGW("Invalid parameter: clock class is invalid: "
 566                         "trace-addr=%p, trace-name=\"%s\", "
 567                         "clock-class-addr=%p, clock-class-name=\"%s\"",
 568                         trace, bt_trace_get_name(trace),
 569                         clock_class, bt_clock_class_get_name(clock_class));
 570                 ret = -1;
 571                 goto end;
 572         }
 573
 574         /* Check for duplicate clock classes */
 575         if (bt_trace_has_clock_class(trace, clock_class)) {
 576                 BT_LOGW("Invalid parameter: clock class already exists in trace: "
 577                         "trace-addr=%p, trace-name=\"%s\", "
 578                         "clock-class-addr=%p, clock-class-name=\"%s\"",
 579                         trace, bt_trace_get_name(trace),
 580                         clock_class, bt_clock_class_get_name(clock_class));
 581                 ret = -1;
 582                 goto end;
 583         }
 584
 585         bt_get(clock_class);
 586         g_ptr_array_add(trace->clocks, clock_class);
 587
 588         if (trace->frozen) {
 589                 BT_LOGV_STR("Freezing added clock class because trace is frozen.");
 590                 bt_clock_class_freeze(clock_class);
 591         }
 592
 593         BT_LOGV("Added clock class to trace: "
 594                 "trace-addr=%p, trace-name=\"%s\", "
 595                 "clock-class-addr=%p, clock-class-name=\"%s\"",
 596                 trace, bt_trace_get_name(trace),
 597                 clock_class, bt_clock_class_get_name(clock_class));
 598
 599 end:
 600         return ret;
 601 }
 602
 603 int64_t bt_trace_get_clock_class_count(struct bt_trace *trace)
 604 {
 605         int64_t ret = (int64_t) -1;
 606
 607         if (!trace) {
 608                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
 609                 goto end;
 610         }
 611
 612         ret = trace->clocks->len;
 613 end:
 614         return ret;
 615 }
 616
 617 struct bt_clock_class *bt_trace_get_clock_class_by_index(
 618                 struct bt_trace *trace, uint64_t index)
 619 {
 620         struct bt_clock_class *clock_class = NULL;
 621
 622         if (!trace) {
 623                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
 624                 goto end;
 625         }
 626
 627         if (index >= trace->clocks->len) {
 628                 BT_LOGW("Invalid parameter: index is out of bounds: "
 629                         "addr=%p, name=\"%s\", "
 630                         "index=%" PRIu64 ", count=%u",
 631                         trace, bt_trace_get_name(trace),
 632                         index, trace->clocks->len);
 633                 goto end;
 634         }
 635
 636         clock_class = g_ptr_array_index(trace->clocks, index);
 637         bt_get(clock_class);
 638 end:
 639         return clock_class;
 640 }
 641
 642 static
 643 bool packet_header_field_type_is_valid(struct bt_trace *trace,
 644                 struct bt_field_type *packet_header_type)
 645 {
 646         int ret;
 647         bool is_valid = true;
 648         struct bt_field_type *field_type = NULL;
 649
 650         if (!packet_header_type) {
 651                 /*
 652                  * No packet header field type: trace must have only
 653                  * one stream. At this point the stream class being
 654                  * added is not part of the trace yet, so we validate
 655                  * that the trace contains no stream classes yet.
 656                  */
 657                 if (trace->stream_classes->len >= 1) {
 658                         BT_LOGW_STR("Invalid packet header field type: "
 659                                 "packet header field type does not exist but there's more than one stream class in the trace.");
 660                         goto invalid;
 661                 }
 662
 663                 /* No packet header field type: valid at this point */
 664                 goto end;
 665         }
 666
 667         /* Packet header field type, if it exists, must be a structure */
 668         if (!bt_field_type_is_structure(packet_header_type)) {
 669                 BT_LOGW("Invalid packet header field type: must be a structure field type if it exists: "
 670                         "ft-addr=%p, ft-id=%s",
 671                         packet_header_type,
 672                         bt_field_type_id_string(packet_header_type->id));
 673                 goto invalid;
 674         }
 675
 676         /*
 677          * If there's a `magic` field, it must be a 32-bit unsigned
 678          * integer field type. Also it must be the first field of the
 679          * packet header field type.
 680          */
 681         field_type = bt_field_type_structure_get_field_type_by_name(
 682                 packet_header_type, "magic");
 683         if (field_type) {
 684                 const char *field_name;
 685
 686                 if (!bt_field_type_is_integer(field_type)) {
 687                         BT_LOGW("Invalid packet header field type: `magic` field must be an integer field type: "
 688                                 "magic-ft-addr=%p, magic-ft-id=%s",
 689                                 field_type,
 690                                 bt_field_type_id_string(field_type->id));
 691                         goto invalid;
 692                 }
 693
 694                 if (bt_field_type_integer_is_signed(field_type)) {
 695                         BT_LOGW("Invalid packet header field type: `magic` field must be an unsigned integer field type: "
 696                                 "magic-ft-addr=%p", field_type);
 697                         goto invalid;
 698                 }
 699
 700                 if (bt_field_type_integer_get_size(field_type) != 32) {
 701                         BT_LOGW("Invalid packet header field type: `magic` field must be a 32-bit unsigned integer field type: "
 702                                 "magic-ft-addr=%p, magic-ft-size=%u",
 703                                 field_type,
 704                                 bt_field_type_integer_get_size(field_type));
 705                         goto invalid;
 706                 }
 707
 708                 ret = bt_field_type_structure_get_field_by_index(
 709                         packet_header_type, &field_name, NULL, 0);
 710                 assert(ret == 0);
 711
 712                 if (strcmp(field_name, "magic") != 0) {
 713                         BT_LOGW("Invalid packet header field type: `magic` field must be the first field: "
 714                                 "magic-ft-addr=%p, first-field-name=\"%s\"",
 715                                 field_type, field_name);
 716                         goto invalid;
 717                 }
 718
 719                 BT_PUT(field_type);
 720         }
 721
 722         /*
 723          * If there's a `uuid` field, it must be an array field type of
 724          * length 16 with an 8-bit unsigned integer element field type.
 725          */
 726         field_type = bt_field_type_structure_get_field_type_by_name(
 727                 packet_header_type, "uuid");
 728         if (field_type) {
 729                 struct bt_field_type *elem_ft;
 730
 731                 if (!bt_field_type_is_array(field_type)) {
 732                         BT_LOGW("Invalid packet header field type: `uuid` field must be an array field type: "
 733                                 "uuid-ft-addr=%p, uuid-ft-id=%s",
 734                                 field_type,
 735                                 bt_field_type_id_string(field_type->id));
 736                         goto invalid;
 737                 }
 738
 739                 if (bt_field_type_array_get_length(field_type) != 16) {
 740                         BT_LOGW("Invalid packet header field type: `uuid` array field type's length must be 16: "
 741                                 "uuid-ft-addr=%p, uuid-ft-length=%" PRId64,
 742                                 field_type,
 743                                 bt_field_type_array_get_length(field_type));
 744                         goto invalid;
 745                 }
 746
 747                 elem_ft = bt_field_type_array_get_element_type(field_type);
 748                 assert(elem_ft);
 749
 750                 if (!bt_field_type_is_integer(elem_ft)) {
 751                         BT_LOGW("Invalid packet header field type: `uuid` field's element field type must be an integer field type: "
 752                                 "elem-ft-addr=%p, elem-ft-id=%s",
 753                                 elem_ft,
 754                                 bt_field_type_id_string(elem_ft->id));
 755                         bt_put(elem_ft);
 756                         goto invalid;
 757                 }
 758
 759                 if (bt_field_type_integer_is_signed(elem_ft)) {
 760                         BT_LOGW("Invalid packet header field type: `uuid` field's element field type must be an unsigned integer field type: "
 761                                 "elem-ft-addr=%p", elem_ft);
 762                         bt_put(elem_ft);
 763                         goto invalid;
 764                 }
 765
 766                 if (bt_field_type_integer_get_size(elem_ft) != 8) {
 767                         BT_LOGW("Invalid packet header field type: `uuid` field's element field type must be an 8-bit unsigned integer field type: "
 768                                 "elem-ft-addr=%p, elem-ft-size=%u",
 769                                 elem_ft,
 770                                 bt_field_type_integer_get_size(elem_ft));
 771                         bt_put(elem_ft);
 772                         goto invalid;
 773                 }
 774
 775                 bt_put(elem_ft);
 776                 BT_PUT(field_type);
 777         }
 778
 779         /*
 780          * The `stream_id` field must exist if there's more than one
 781          * stream classes in the trace.
 782          */
 783         field_type = bt_field_type_structure_get_field_type_by_name(
 784                 packet_header_type, "stream_id");
 785
 786         if (!field_type && trace->stream_classes->len >= 1) {
 787                 BT_LOGW_STR("Invalid packet header field type: "
 788                         "`stream_id` field does not exist but there's more than one stream class in the trace.");
 789                 goto invalid;
 790         }
 791
 792         /*
 793          * If there's a `stream_id` field, it must be an unsigned
 794          * integer field type.
 795          */
 796         if (field_type) {
 797                 if (!bt_field_type_is_integer(field_type)) {
 798                         BT_LOGW("Invalid packet header field type: `stream_id` field must be an integer field type: "
 799                                 "stream-id-ft-addr=%p, stream-id-ft-id=%s",
 800                                 field_type,
 801                                 bt_field_type_id_string(field_type->id));
 802                         goto invalid;
 803                 }
 804
 805                 if (bt_field_type_integer_is_signed(field_type)) {
 806                         BT_LOGW("Invalid packet header field type: `stream_id` field must be an unsigned integer field type: "
 807                                 "stream-id-ft-addr=%p", field_type);
 808                         goto invalid;
 809                 }
 810
 811                 BT_PUT(field_type);
 812         }
 813
 814         /*
 815          * If there's a `packet_seq_num` field, it must be an unsigned
 816          * integer field type.
 817          */
 818         field_type = bt_field_type_structure_get_field_type_by_name(
 819                 packet_header_type, "packet_seq_num");
 820         if (field_type) {
 821                 if (!bt_field_type_is_integer(field_type)) {
 822                         BT_LOGW("Invalid packet header field type: `packet_seq_num` field must be an integer field type: "
 823                                 "stream-id-ft-addr=%p, packet-seq-num-ft-id=%s",
 824                                 field_type,
 825                                 bt_field_type_id_string(field_type->id));
 826                         goto invalid;
 827                 }
 828
 829                 if (bt_field_type_integer_is_signed(field_type)) {
 830                         BT_LOGW("Invalid packet header field type: `packet_seq_num` field must be an unsigned integer field type: "
 831                                 "packet-seq-num-ft-addr=%p", field_type);
 832                         goto invalid;
 833                 }
 834
 835                 BT_PUT(field_type);
 836         }
 837
 838         goto end;
 839
 840 invalid:
 841         is_valid = false;
 842
 843 end:
 844         bt_put(field_type);
 845         return is_valid;
 846 }
 847
 848 static
 849 bool packet_context_field_type_is_valid(struct bt_trace *trace,
 850                 struct bt_stream_class *stream_class,
 851                 struct bt_field_type *packet_context_type)
 852 {
 853         bool is_valid = true;
 854         struct bt_field_type *field_type = NULL;
 855
 856         if (!packet_context_type) {
 857                 /* No packet context field type: valid at this point */
 858                 goto end;
 859         }
 860
 861         /* Packet context field type, if it exists, must be a structure */
 862         if (!bt_field_type_is_structure(packet_context_type)) {
 863                 BT_LOGW("Invalid packet context field type: must be a structure field type if it exists: "
 864                         "ft-addr=%p, ft-id=%s",
 865                         packet_context_type,
 866                         bt_field_type_id_string(packet_context_type->id));
 867                 goto invalid;
 868         }
 869
 870         /*
 871          * If there's a `packet_size` field, it must be an unsigned
 872          * integer field type.
 873          */
 874         field_type = bt_field_type_structure_get_field_type_by_name(
 875                 packet_context_type, "packet_size");
 876         if (field_type) {
 877                 if (!bt_field_type_is_integer(field_type)) {
 878                         BT_LOGW("Invalid packet context field type: `packet_size` field must be an integer field type: "
 879                                 "packet-size-ft-addr=%p, packet-size-ft-id=%s",
 880                                 field_type,
 881                                 bt_field_type_id_string(field_type->id));
 882                         goto invalid;
 883                 }
 884
 885                 if (bt_field_type_integer_is_signed(field_type)) {
 886                         BT_LOGW("Invalid packet context field type: `packet_size` field must be an unsigned integer field type: "
 887                                 "packet-size-ft-addr=%p", field_type);
 888                         goto invalid;
 889                 }
 890
 891                 BT_PUT(field_type);
 892         }
 893
 894         /*
 895          * If there's a `content_size` field, it must be an unsigned
 896          * integer field type.
 897          */
 898         field_type = bt_field_type_structure_get_field_type_by_name(
 899                 packet_context_type, "content_size");
 900         if (field_type) {
 901                 if (!bt_field_type_is_integer(field_type)) {
 902                         BT_LOGW("Invalid packet context field type: `content_size` field must be an integer field type: "
 903                                 "content-size-ft-addr=%p, content-size-ft-id=%s",
 904                                 field_type,
 905                                 bt_field_type_id_string(field_type->id));
 906                         goto invalid;
 907                 }
 908
 909                 if (bt_field_type_integer_is_signed(field_type)) {
 910                         BT_LOGW("Invalid packet context field type: `content_size` field must be an unsigned integer field type: "
 911                                 "content-size-ft-addr=%p", field_type);
 912                         goto invalid;
 913                 }
 914
 915                 BT_PUT(field_type);
 916         }
 917
 918         /*
 919          * If there's a `events_discarded` field, it must be an unsigned
 920          * integer field type.
 921          */
 922         field_type = bt_field_type_structure_get_field_type_by_name(
 923                 packet_context_type, "events_discarded");
 924         if (field_type) {
 925                 if (!bt_field_type_is_integer(field_type)) {
 926                         BT_LOGW("Invalid packet context field type: `events_discarded` field must be an integer field type: "
 927                                 "events-discarded-ft-addr=%p, events-discarded-ft-id=%s",
 928                                 field_type,
 929                                 bt_field_type_id_string(field_type->id));
 930                         goto invalid;
 931                 }
 932
 933                 if (bt_field_type_integer_is_signed(field_type)) {
 934                         BT_LOGW("Invalid packet context field type: `events_discarded` field must be an unsigned integer field type: "
 935                                 "events-discarded-ft-addr=%p", field_type);
 936                         goto invalid;
 937                 }
 938
 939                 BT_PUT(field_type);
 940         }
 941
 942         /*
 943          * If there's a `timestamp_begin` field, it must be an unsigned
 944          * integer field type. Also, if the trace is not a CTF writer's
 945          * trace, then we cannot automatically set the mapped clock
 946          * class of this field, so it must have a mapped clock class.
 947          */
 948         field_type = bt_field_type_structure_get_field_type_by_name(
 949                 packet_context_type, "timestamp_begin");
 950         if (field_type) {
 951                 if (!bt_field_type_is_integer(field_type)) {
 952                         BT_LOGW("Invalid packet context field type: `timestamp_begin` field must be an integer field type: "
 953                                 "timestamp-begin-ft-addr=%p, timestamp-begin-ft-id=%s",
 954                                 field_type,
 955                                 bt_field_type_id_string(field_type->id));
 956                         goto invalid;
 957                 }
 958
 959                 if (bt_field_type_integer_is_signed(field_type)) {
 960                         BT_LOGW("Invalid packet context field type: `timestamp_begin` field must be an unsigned integer field type: "
 961                                 "timestamp-begin-ft-addr=%p", field_type);
 962                         goto invalid;
 963                 }
 964
 965                 if (!trace->is_created_by_writer) {
 966                         struct bt_clock_class *clock_class =
 967                                 bt_field_type_integer_get_mapped_clock_class(
 968                                         field_type);
 969
 970                         bt_put(clock_class);
 971                         if (!clock_class) {
 972                                 BT_LOGW("Invalid packet context field type: `timestamp_begin` field must be mapped to a clock class: "
 973                                         "timestamp-begin-ft-addr=%p", field_type);
 974                                 goto invalid;
 975                         }
 976                 }
 977
 978                 BT_PUT(field_type);
 979         }
 980
 981         /*
 982          * If there's a `timestamp_end` field, it must be an unsigned
 983          * integer field type. Also, if the trace is not a CTF writer's
 984          * trace, then we cannot automatically set the mapped clock
 985          * class of this field, so it must have a mapped clock class.
 986          */
 987         field_type = bt_field_type_structure_get_field_type_by_name(
 988                 packet_context_type, "timestamp_end");
 989         if (field_type) {
 990                 if (!bt_field_type_is_integer(field_type)) {
 991                         BT_LOGW("Invalid packet context field type: `timestamp_end` field must be an integer field type: "
 992                                 "timestamp-end-ft-addr=%p, timestamp-end-ft-id=%s",
 993                                 field_type,
 994                                 bt_field_type_id_string(field_type->id));
 995                         goto invalid;
 996                 }
 997
 998                 if (bt_field_type_integer_is_signed(field_type)) {
 999                         BT_LOGW("Invalid packet context field type: `timestamp_end` field must be an unsigned integer field type: "
1000                                 "timestamp-end-ft-addr=%p", field_type);
1001                         goto invalid;
1002                 }
1003
1004                 if (!trace->is_created_by_writer) {
1005                         struct bt_clock_class *clock_class =
1006                                 bt_field_type_integer_get_mapped_clock_class(
1007                                         field_type);
1008
1009                         bt_put(clock_class);
1010                         if (!clock_class) {
1011                                 BT_LOGW("Invalid packet context field type: `timestamp_end` field must be mapped to a clock class: "
1012                                         "timestamp-end-ft-addr=%p", field_type);
1013                                 goto invalid;
1014                         }
1015                 }
1016
1017                 BT_PUT(field_type);
1018         }
1019
1020         goto end;
1021
1022 invalid:
1023         is_valid = false;
1024
1025 end:
1026         bt_put(field_type);
1027         return is_valid;
1028 }
1029
1030 static
1031 bool event_header_field_type_is_valid(struct bt_trace *trace,
1032                 struct bt_stream_class *stream_class,
1033                 struct bt_field_type *event_header_type)
1034 {
1035         bool is_valid = true;
1036         struct bt_field_type *field_type = NULL;
1037
1038         /*
1039          * We do not validate that the `timestamp` field exists here
1040          * because CTF does not require this exact name to be mapped to
1041          * a clock class.
1042          */
1043
1044         if (!event_header_type) {
1045                 /*
1046                  * No event header field type: stream class must have
1047                  * only one event class.
1048                  */
1049                 if (bt_stream_class_get_event_class_count(stream_class) > 1) {
1050                         BT_LOGW_STR("Invalid event header field type: "
1051                                 "event header field type does not exist but there's more than one event class in the stream class.");
1052                         goto invalid;
1053                 }
1054
1055                 /* No event header field type: valid at this point */
1056                 goto end;
1057         }
1058
1059         /* Event header field type, if it exists, must be a structure */
1060         if (!bt_field_type_is_structure(event_header_type)) {
1061                 BT_LOGW("Invalid event header field type: must be a structure field type if it exists: "
1062                         "ft-addr=%p, ft-id=%s",
1063                         event_header_type,
1064                         bt_field_type_id_string(event_header_type->id));
1065                 goto invalid;
1066         }
1067
1068         /*
1069          * If there's an `id` field, it must be an unsigned integer
1070          * field type or an enumeration field type with an unsigned
1071          * integer container field type.
1072          */
1073         field_type = bt_field_type_structure_get_field_type_by_name(
1074                 event_header_type, "id");
1075         if (field_type) {
1076                 struct bt_field_type *int_ft;
1077
1078                 if (bt_field_type_is_integer(field_type)) {
1079                         int_ft = bt_get(field_type);
1080                 } else if (bt_field_type_is_enumeration(field_type)) {
1081                         int_ft = bt_field_type_enumeration_get_container_type(
1082                                 field_type);
1083                 } else {
1084                         BT_LOGW("Invalid event header field type: `id` field must be an integer or enumeration field type: "
1085                                 "id-ft-addr=%p, id-ft-id=%s",
1086                                 field_type,
1087                                 bt_field_type_id_string(field_type->id));
1088                         goto invalid;
1089                 }
1090
1091                 assert(int_ft);
1092                 if (bt_field_type_integer_is_signed(int_ft)) {
1093                         BT_LOGW("Invalid event header field type: `id` field must be an unsigned integer or enumeration field type: "
1094                                 "id-ft-addr=%p", int_ft);
1095                         goto invalid;
1096                 }
1097
1098                 bt_put(int_ft);
1099                 BT_PUT(field_type);
1100         }
1101
1102         goto end;
1103
1104 invalid:
1105         is_valid = false;
1106
1107 end:
1108         bt_put(field_type);
1109         return is_valid;
1110 }
1111
1112 static
1113 int check_packet_header_type_has_no_clock_class(struct bt_trace *trace)
1114 {
1115         int ret = 0;
1116
1117         if (trace->packet_header_type) {
1118                 struct bt_clock_class *clock_class = NULL;
1119
1120                 ret = bt_validate_single_clock_class(trace->packet_header_type,
1121                         &clock_class);
1122                 bt_put(clock_class);
1123                 if (ret || clock_class) {
1124                         BT_LOGW("Trace's packet header field type cannot "
1125                                 "contain a field type which is mapped to "
1126                                 "a clock class: "
1127                                 "trace-addr=%p, trace-name=\"%s\", "
1128                                 "clock-class-name=\"%s\"",
1129                                 trace, bt_trace_get_name(trace),
1130                                 clock_class ?
1131                                         bt_clock_class_get_name(clock_class) :
1132                                         NULL);
1133                         ret = -1;
1134                 }
1135         }
1136
1137         return ret;
1138 }
1139
1140 int bt_trace_add_stream_class(struct bt_trace *trace,
1141                 struct bt_stream_class *stream_class)
1142 {
1143         int ret;
1144         int64_t i;
1145         int64_t stream_id;
1146         struct bt_validation_output trace_sc_validation_output = { 0 };
1147         struct bt_validation_output *ec_validation_outputs = NULL;
1148         const enum bt_validation_flag trace_sc_validation_flags =
1149                 BT_VALIDATION_FLAG_TRACE |
1150                 BT_VALIDATION_FLAG_STREAM;
1151         const enum bt_validation_flag ec_validation_flags =
1152                 BT_VALIDATION_FLAG_EVENT;
1153         struct bt_field_type *packet_header_type = NULL;
1154         struct bt_field_type *packet_context_type = NULL;
1155         struct bt_field_type *event_header_type = NULL;
1156         struct bt_field_type *stream_event_ctx_type = NULL;
1157         int64_t event_class_count;
1158         struct bt_trace *current_parent_trace = NULL;
1159         struct bt_clock_class *expected_clock_class = NULL;
1160
1161         if (!trace) {
1162                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1163                 ret = -1;
1164                 goto end;
1165         }
1166
1167         if (!stream_class) {
1168                 BT_LOGW_STR("Invalid parameter: stream class is NULL.");
1169                 ret = -1;
1170                 goto end;
1171         }
1172
1173         if (trace->is_static) {
1174                 BT_LOGW_STR("Invalid parameter: trace is static.");
1175                 ret = -1;
1176                 goto end;
1177         }
1178
1179         BT_LOGD("Adding stream class to trace: "
1180                 "trace-addr=%p, trace-name=\"%s\", "
1181                 "stream-class-addr=%p, stream-class-name=\"%s\", "
1182                 "stream-class-id=%" PRId64,
1183                 trace, bt_trace_get_name(trace),
1184                 stream_class, bt_stream_class_get_name(stream_class),
1185                 bt_stream_class_get_id(stream_class));
1186
1187         current_parent_trace = bt_stream_class_get_trace(stream_class);
1188         if (current_parent_trace) {
1189                 /* Stream class is already associated to a trace, abort. */
1190                 BT_LOGW("Invalid parameter: stream class is already part of a trace: "
1191                         "stream-class-trace-addr=%p, "
1192                         "stream-class-trace-name=\"%s\"",
1193                         current_parent_trace,
1194                         bt_trace_get_name(current_parent_trace));
1195                 ret = -1;
1196                 goto end;
1197         }
1198
1199         event_class_count =
1200                 bt_stream_class_get_event_class_count(stream_class);
1201         assert(event_class_count >= 0);
1202
1203         if (stream_class->clock) {
1204                 struct bt_clock_class *stream_clock_class =
1205                         stream_class->clock->clock_class;
1206
1207                 if (trace->is_created_by_writer) {
1208                         /*
1209                          * Make sure this clock was also added to the
1210                          * trace (potentially through its CTF writer
1211                          * owner).
1212                          */
1213                         size_t i;
1214
1215                         for (i = 0; i < trace->clocks->len; i++) {
1216                                 if (trace->clocks->pdata[i] ==
1217                                                 stream_clock_class) {
1218                                         /* Found! */
1219                                         break;
1220                                 }
1221                         }
1222
1223                         if (i == trace->clocks->len) {
1224                                 /* Not found */
1225                                 BT_LOGW("Stream class's clock's class is not part of the trace: "
1226                                         "clock-class-addr=%p, clock-class-name=\"%s\"",
1227                                         stream_clock_class,
1228                                         bt_clock_class_get_name(stream_clock_class));
1229                                 ret = -1;
1230                                 goto end;
1231                         }
1232                 } else {
1233                         /*
1234                          * This trace was NOT created by a CTF writer,
1235                          * thus do not allow the stream class to add to
1236                          * have a clock at all. Those are two
1237                          * independent APIs (non-writer and writer
1238                          * APIs), and isolating them simplifies things.
1239                          */
1240                         BT_LOGW("Cannot add stream class with a clock to a trace which was not created by a CTF writer object: "
1241                                 "clock-class-addr=%p, clock-class-name=\"%s\"",
1242                                 stream_clock_class,
1243                                 bt_clock_class_get_name(stream_clock_class));
1244                         ret = -1;
1245                         goto end;
1246                 }
1247
1248                 if (stream_class->clock_class &&
1249                                 stream_class->clock_class !=
1250                                 stream_class->clock->clock_class) {
1251                         /*
1252                          * Stream class already has an expected clock
1253                          * class, but it does not match its clock's
1254                          * class.
1255                          */
1256                         BT_LOGW("Invalid parameter: stream class's clock's "
1257                                 "class does not match stream class's "
1258                                 "expected clock class: "
1259                                 "stream-class-addr=%p, "
1260                                 "stream-class-id=%" PRId64 ", "
1261                                 "stream-class-name=\"%s\", "
1262                                 "expected-clock-class-addr=%p, "
1263                                 "expected-clock-class-name=\"%s\"",
1264                                 stream_class,
1265                                 bt_stream_class_get_id(stream_class),
1266                                 bt_stream_class_get_name(stream_class),
1267                                 expected_clock_class,
1268                                 bt_clock_class_get_name(expected_clock_class));
1269                 } else if (!stream_class->clock_class) {
1270                         /*
1271                          * Set expected clock class to stream class's
1272                          * clock's class.
1273                          */
1274                         expected_clock_class =
1275                                 bt_get(stream_class->clock->clock_class);
1276                 }
1277         }
1278
1279         if (!stream_class->frozen) {
1280                 /*
1281                  * Stream class is not frozen yet. Validate that the
1282                  * stream class contains at most a single clock class
1283                  * because the previous
1284                  * bt_stream_class_add_event_class() calls did not make
1285                  * this validation since the stream class's direct field
1286                  * types (packet context, event header, event context)
1287                  * could change afterwards. This stream class is about
1288                  * to be frozen and those field types won't be changed
1289                  * if this function succeeds.
1290                  *
1291                  * At this point we're also sure that the stream class's
1292                  * clock, if any, has the same class as the stream
1293                  * class's expected clock class, if any. This is why, if
1294                  * bt_stream_class_validate_single_clock_class()
1295                  * succeeds below, the call to
1296                  * bt_stream_class_map_clock_class() at the end of this
1297                  * function is safe because it maps to the same, single
1298                  * clock class.
1299                  */
1300                 ret = bt_stream_class_validate_single_clock_class(stream_class,
1301                         &expected_clock_class);
1302                 if (ret) {
1303                         BT_LOGW("Invalid parameter: stream class or one of its "
1304                                 "event classes contains a field type which is "
1305                                 "not recursively mapped to the expected "
1306                                 "clock class: "
1307                                 "stream-class-addr=%p, "
1308                                 "stream-class-id=%" PRId64 ", "
1309                                 "stream-class-name=\"%s\", "
1310                                 "expected-clock-class-addr=%p, "
1311                                 "expected-clock-class-name=\"%s\"",
1312                                 stream_class, bt_stream_class_get_id(stream_class),
1313                                 bt_stream_class_get_name(stream_class),
1314                                 expected_clock_class,
1315                                 expected_clock_class ?
1316                                         bt_clock_class_get_name(expected_clock_class) :
1317                                         NULL);
1318                         goto end;
1319                 }
1320         }
1321
1322         ret = check_packet_header_type_has_no_clock_class(trace);
1323         if (ret) {
1324                 /* check_packet_header_type_has_no_clock_class() logs errors */
1325                 goto end;
1326         }
1327
1328         /*
1329          * We're about to freeze both the trace and the stream class.
1330          * Also, each event class contained in this stream class are
1331          * already frozen.
1332          *
1333          * This trace, this stream class, and all its event classes
1334          * should be valid at this point.
1335          *
1336          * Validate trace and stream class first, then each event
1337          * class of this stream class can be validated individually.
1338          */
1339         packet_header_type =
1340                 bt_trace_get_packet_header_type(trace);
1341         packet_context_type =
1342                 bt_stream_class_get_packet_context_type(stream_class);
1343         event_header_type =
1344                 bt_stream_class_get_event_header_type(stream_class);
1345         stream_event_ctx_type =
1346                 bt_stream_class_get_event_context_type(stream_class);
1347
1348         BT_LOGD("Validating trace and stream class field types.");
1349         ret = bt_validate_class_types(trace->environment,
1350                 packet_header_type, packet_context_type, event_header_type,
1351                 stream_event_ctx_type, NULL, NULL, trace->valid,
1352                 stream_class->valid, 1, &trace_sc_validation_output,
1353                 trace_sc_validation_flags);
1354         BT_PUT(packet_header_type);
1355         BT_PUT(packet_context_type);
1356         BT_PUT(event_header_type);
1357         BT_PUT(stream_event_ctx_type);
1358
1359         if (ret) {
1360                 /*
1361                  * This means something went wrong during the validation
1362                  * process, not that the objects are invalid.
1363                  */
1364                 BT_LOGE("Failed to validate trace and stream class field types: "
1365                         "ret=%d", ret);
1366                 goto end;
1367         }
1368
1369         if ((trace_sc_validation_output.valid_flags &
1370                         trace_sc_validation_flags) !=
1371                         trace_sc_validation_flags) {
1372                 /* Invalid trace/stream class */
1373                 BT_LOGW("Invalid trace or stream class field types: "
1374                         "valid-flags=0x%x",
1375                         trace_sc_validation_output.valid_flags);
1376                 ret = -1;
1377                 goto end;
1378         }
1379
1380         if (event_class_count > 0) {
1381                 ec_validation_outputs = g_new0(struct bt_validation_output,
1382                         event_class_count);
1383                 if (!ec_validation_outputs) {
1384                         BT_LOGE_STR("Failed to allocate one validation output structure.");
1385                         ret = -1;
1386                         goto end;
1387                 }
1388         }
1389
1390         /* Validate each event class individually */
1391         for (i = 0; i < event_class_count; i++) {
1392                 struct bt_event_class *event_class =
1393                         bt_stream_class_get_event_class_by_index(
1394                                 stream_class, i);
1395                 struct bt_field_type *event_context_type = NULL;
1396                 struct bt_field_type *event_payload_type = NULL;
1397
1398                 event_context_type =
1399                         bt_event_class_get_context_type(event_class);
1400                 event_payload_type =
1401                         bt_event_class_get_payload_type(event_class);
1402
1403                 /*
1404                  * It is important to use the field types returned by
1405                  * the previous trace and stream class validation here
1406                  * because copies could have been made.
1407                  */
1408                 BT_LOGD("Validating event class's field types: "
1409                         "addr=%p, name=\"%s\", id=%" PRId64,
1410                         event_class, bt_event_class_get_name(event_class),
1411                         bt_event_class_get_id(event_class));
1412                 ret = bt_validate_class_types(trace->environment,
1413                         trace_sc_validation_output.packet_header_type,
1414                         trace_sc_validation_output.packet_context_type,
1415                         trace_sc_validation_output.event_header_type,
1416                         trace_sc_validation_output.stream_event_ctx_type,
1417                         event_context_type, event_payload_type,
1418                         1, 1, event_class->valid, &ec_validation_outputs[i],
1419                         ec_validation_flags);
1420                 BT_PUT(event_context_type);
1421                 BT_PUT(event_payload_type);
1422                 BT_PUT(event_class);
1423
1424                 if (ret) {
1425                         BT_LOGE("Failed to validate event class field types: "
1426                                 "ret=%d", ret);
1427                         goto end;
1428                 }
1429
1430                 if ((ec_validation_outputs[i].valid_flags &
1431                                 ec_validation_flags) != ec_validation_flags) {
1432                         /* Invalid event class */
1433                         BT_LOGW("Invalid event class field types: "
1434                                 "valid-flags=0x%x",
1435                                 ec_validation_outputs[i].valid_flags);
1436                         ret = -1;
1437                         goto end;
1438                 }
1439         }
1440
1441         stream_id = bt_stream_class_get_id(stream_class);
1442         if (stream_id < 0) {
1443                 stream_id = trace->next_stream_id++;
1444                 if (stream_id < 0) {
1445                         BT_LOGE_STR("No more stream class IDs available.");
1446                         ret = -1;
1447                         goto end;
1448                 }
1449
1450                 /* Try to assign a new stream id */
1451                 for (i = 0; i < trace->stream_classes->len; i++) {
1452                         if (stream_id == bt_stream_class_get_id(
1453                                 trace->stream_classes->pdata[i])) {
1454                                 /* Duplicate stream id found */
1455                                 BT_LOGW("Duplicate stream class ID: "
1456                                         "id=%" PRId64, (int64_t) stream_id);
1457                                 ret = -1;
1458                                 goto end;
1459                         }
1460                 }
1461
1462                 if (bt_stream_class_set_id_no_check(stream_class,
1463                                 stream_id)) {
1464                         /* TODO Should retry with a different stream id */
1465                         BT_LOGE("Cannot set stream class's ID: "
1466                                 "id=%" PRId64, (int64_t) stream_id);
1467                         ret = -1;
1468                         goto end;
1469                 }
1470         }
1471
1472         /*
1473          * At this point all the field types in the validation output
1474          * are valid. Validate the semantics of some scopes according to
1475          * the CTF specification.
1476          */
1477         if (!packet_header_field_type_is_valid(trace,
1478                         trace_sc_validation_output.packet_header_type)) {
1479                 BT_LOGW_STR("Invalid trace's packet header field type.");
1480                 ret = -1;
1481                 goto end;
1482         }
1483
1484         if (!packet_context_field_type_is_valid(trace,
1485                         stream_class,
1486                         trace_sc_validation_output.packet_context_type)) {
1487                 BT_LOGW_STR("Invalid stream class's packet context field type.");
1488                 ret = -1;
1489                 goto end;
1490         }
1491
1492         if (!event_header_field_type_is_valid(trace,
1493                         stream_class,
1494                         trace_sc_validation_output.event_header_type)) {
1495                 BT_LOGW_STR("Invalid steam class's event header field type.");
1496                 ret = -1;
1497                 goto end;
1498         }
1499
1500         /*
1501          * Now is the time to automatically map specific field types of
1502          * the stream class's packet context and event header field
1503          * types to the stream class's clock's class if they are not
1504          * mapped to a clock class yet. We do it here because we know
1505          * that after this point, everything is frozen so it won't be
1506          * possible for the user to modify the stream class's clock, or
1507          * to map those field types to other clock classes.
1508          */
1509         if (trace->is_created_by_writer) {
1510                 if (bt_stream_class_map_clock_class(stream_class,
1511                                 trace_sc_validation_output.packet_context_type,
1512                                 trace_sc_validation_output.event_header_type)) {
1513                         BT_LOGW_STR("Cannot automatically map selected stream class's field types to stream class's clock's class.");
1514                         ret = -1;
1515                         goto end;
1516                 }
1517         }
1518
1519
1520
1521         bt_object_set_parent(stream_class, trace);
1522         g_ptr_array_add(trace->stream_classes, stream_class);
1523
1524         /*
1525          * At this point we know that the function will be successful.
1526          * Therefore we can replace the trace and stream class field
1527          * types with what's in their validation output structure and
1528          * mark them as valid. We can also replace the field types of
1529          * all the event classes of the stream class and mark them as
1530          * valid.
1531          */
1532         bt_validation_replace_types(trace, stream_class, NULL,
1533                 &trace_sc_validation_output, trace_sc_validation_flags);
1534         trace->valid = 1;
1535         stream_class->valid = 1;
1536
1537         /*
1538          * Put what was not moved in bt_validation_replace_types().
1539          */
1540         bt_validation_output_put_types(&trace_sc_validation_output);
1541
1542         for (i = 0; i < event_class_count; i++) {
1543                 struct bt_event_class *event_class =
1544                         bt_stream_class_get_event_class_by_index(
1545                                 stream_class, i);
1546
1547                 bt_validation_replace_types(NULL, NULL, event_class,
1548                         &ec_validation_outputs[i], ec_validation_flags);
1549                 event_class->valid = 1;
1550                 BT_PUT(event_class);
1551
1552                 /*
1553                  * Put what was not moved in
1554                  * bt_validation_replace_types().
1555                  */
1556                 bt_validation_output_put_types(&ec_validation_outputs[i]);
1557         }
1558
1559         /*
1560          * Freeze the trace and the stream class.
1561          */
1562         bt_stream_class_freeze(stream_class);
1563         bt_trace_freeze(trace);
1564
1565         /*
1566          * It is safe to set the stream class's unique clock class
1567          * now because the stream class is frozen.
1568          */
1569         if (expected_clock_class) {
1570                 BT_MOVE(stream_class->clock_class, expected_clock_class);
1571         }
1572
1573         /* Notifiy listeners of the trace's schema modification. */
1574         bt_stream_class_visit(stream_class,
1575                         bt_trace_object_modification, trace);
1576         BT_LOGD("Added stream class to trace: "
1577                 "trace-addr=%p, trace-name=\"%s\", "
1578                 "stream-class-addr=%p, stream-class-name=\"%s\", "
1579                 "stream-class-id=%" PRId64,
1580                 trace, bt_trace_get_name(trace),
1581                 stream_class, bt_stream_class_get_name(stream_class),
1582                 bt_stream_class_get_id(stream_class));
1583
1584 end:
1585         if (ret) {
1586                 bt_object_set_parent(stream_class, NULL);
1587
1588                 if (ec_validation_outputs) {
1589                         for (i = 0; i < event_class_count; i++) {
1590                                 bt_validation_output_put_types(
1591                                         &ec_validation_outputs[i]);
1592                         }
1593                 }
1594         }
1595
1596         g_free(ec_validation_outputs);
1597         bt_validation_output_put_types(&trace_sc_validation_output);
1598         bt_put(current_parent_trace);
1599         bt_put(expected_clock_class);
1600         assert(!packet_header_type);
1601         assert(!packet_context_type);
1602         assert(!event_header_type);
1603         assert(!stream_event_ctx_type);
1604         return ret;
1605 }
1606
1607 int64_t bt_trace_get_stream_count(struct bt_trace *trace)
1608 {
1609         int64_t ret;
1610
1611         if (!trace) {
1612                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1613                 ret = (int64_t) -1;
1614                 goto end;
1615         }
1616
1617         ret = (int64_t) trace->streams->len;
1618
1619 end:
1620         return ret;
1621 }
1622
1623 struct bt_stream *bt_trace_get_stream_by_index(
1624                 struct bt_trace *trace,
1625                 uint64_t index)
1626 {
1627         struct bt_stream *stream = NULL;
1628
1629         if (!trace) {
1630                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1631                 goto end;
1632         }
1633
1634         if (index >= trace->streams->len) {
1635                 BT_LOGW("Invalid parameter: index is out of bounds: "
1636                         "addr=%p, name=\"%s\", "
1637                         "index=%" PRIu64 ", count=%u",
1638                         trace, bt_trace_get_name(trace),
1639                         index, trace->streams->len);
1640                 goto end;
1641         }
1642
1643         stream = bt_get(g_ptr_array_index(trace->streams, index));
1644
1645 end:
1646         return stream;
1647 }
1648
1649 int64_t bt_trace_get_stream_class_count(struct bt_trace *trace)
1650 {
1651         int64_t ret;
1652
1653         if (!trace) {
1654                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1655                 ret = (int64_t) -1;
1656                 goto end;
1657         }
1658
1659         ret = (int64_t) trace->stream_classes->len;
1660 end:
1661         return ret;
1662 }
1663
1664 struct bt_stream_class *bt_trace_get_stream_class_by_index(
1665                 struct bt_trace *trace, uint64_t index)
1666 {
1667         struct bt_stream_class *stream_class = NULL;
1668
1669         if (!trace) {
1670                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1671                 goto end;
1672         }
1673
1674         if (index >= trace->stream_classes->len) {
1675                 BT_LOGW("Invalid parameter: index is out of bounds: "
1676                         "addr=%p, name=\"%s\", "
1677                         "index=%" PRIu64 ", count=%u",
1678                         trace, bt_trace_get_name(trace),
1679                         index, trace->stream_classes->len);
1680                 goto end;
1681         }
1682
1683         stream_class = g_ptr_array_index(trace->stream_classes, index);
1684         bt_get(stream_class);
1685 end:
1686         return stream_class;
1687 }
1688
1689 struct bt_stream_class *bt_trace_get_stream_class_by_id(
1690                 struct bt_trace *trace, uint64_t id_param)
1691 {
1692         int i;
1693         struct bt_stream_class *stream_class = NULL;
1694         int64_t id = (int64_t) id_param;
1695
1696         if (!trace) {
1697                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1698                 goto end;
1699         }
1700
1701         if (id < 0) {
1702                 BT_LOGW("Invalid parameter: invalid stream class's ID: "
1703                         "trace-addr=%p, trace-name=\"%s\", id=%" PRIu64,
1704                         trace, bt_trace_get_name(trace), id_param);
1705                 goto end;
1706         }
1707
1708         for (i = 0; i < trace->stream_classes->len; i++) {
1709                 struct bt_stream_class *stream_class_candidate;
1710
1711                 stream_class_candidate =
1712                         g_ptr_array_index(trace->stream_classes, i);
1713
1714                 if (bt_stream_class_get_id(stream_class_candidate) ==
1715                                 (int64_t) id) {
1716                         stream_class = stream_class_candidate;
1717                         bt_get(stream_class);
1718                         goto end;
1719                 }
1720         }
1721
1722 end:
1723         return stream_class;
1724 }
1725
1726 struct bt_clock_class *bt_trace_get_clock_class_by_name(
1727                 struct bt_trace *trace, const char *name)
1728 {
1729         size_t i;
1730         struct bt_clock_class *clock_class = NULL;
1731
1732         if (!trace) {
1733                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1734                 goto end;
1735         }
1736
1737         if (!name) {
1738                 BT_LOGW_STR("Invalid parameter: name is NULL.");
1739                 goto end;
1740         }
1741
1742         for (i = 0; i < trace->clocks->len; i++) {
1743                 struct bt_clock_class *cur_clk =
1744                         g_ptr_array_index(trace->clocks, i);
1745                 const char *cur_clk_name = bt_clock_class_get_name(cur_clk);
1746
1747                 if (!cur_clk_name) {
1748                         goto end;
1749                 }
1750
1751                 if (!strcmp(cur_clk_name, name)) {
1752                         clock_class = cur_clk;
1753                         bt_get(clock_class);
1754                         goto end;
1755                 }
1756         }
1757
1758 end:
1759         return clock_class;
1760 }
1761
1762 BT_HIDDEN
1763 bt_bool bt_trace_has_clock_class(struct bt_trace *trace,
1764                 struct bt_clock_class *clock_class)
1765 {
1766         struct search_query query = { .value = clock_class, .found = 0 };
1767
1768         assert(trace);
1769         assert(clock_class);
1770
1771         g_ptr_array_foreach(trace->clocks, value_exists, &query);
1772         return query.found;
1773 }
1774
1775 BT_HIDDEN
1776 const char *get_byte_order_string(enum bt_byte_order byte_order)
1777 {
1778         const char *string;
1779
1780         switch (byte_order) {
1781         case BT_BYTE_ORDER_LITTLE_ENDIAN:
1782                 string = "le";
1783                 break;
1784         case BT_BYTE_ORDER_BIG_ENDIAN:
1785                 string = "be";
1786                 break;
1787         case BT_BYTE_ORDER_NATIVE:
1788                 string = "native";
1789                 break;
1790         default:
1791                 abort();
1792         }
1793
1794         return string;
1795 }
1796
1797 static
1798 int append_trace_metadata(struct bt_trace *trace,
1799                 struct metadata_context *context)
1800 {
1801         unsigned char *uuid = trace->uuid;
1802         int ret = 0;
1803
1804         if (trace->native_byte_order == BT_BYTE_ORDER_NATIVE ||
1805                         trace->native_byte_order == BT_BYTE_ORDER_UNSPECIFIED) {
1806                 BT_LOGW("Invalid parameter: trace's byte order cannot be BT_BYTE_ORDER_NATIVE or BT_BYTE_ORDER_UNSPECIFIED at this point; "
1807                         "set it with bt_trace_set_native_byte_order(): "
1808                         "addr=%p, name=\"%s\"",
1809                         trace, bt_trace_get_name(trace));
1810                 ret = -1;
1811                 goto end;
1812         }
1813
1814         g_string_append(context->string, "trace {\n");
1815         g_string_append(context->string, "\tmajor = 1;\n");
1816         g_string_append(context->string, "\tminor = 8;\n");
1817         assert(trace->native_byte_order == BT_BYTE_ORDER_LITTLE_ENDIAN ||
1818                 trace->native_byte_order == BT_BYTE_ORDER_BIG_ENDIAN ||
1819                 trace->native_byte_order == BT_BYTE_ORDER_NETWORK);
1820
1821         if (trace->uuid_set) {
1822                 g_string_append_printf(context->string,
1823                         "\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n",
1824                         uuid[0], uuid[1], uuid[2], uuid[3],
1825                         uuid[4], uuid[5], uuid[6], uuid[7],
1826                         uuid[8], uuid[9], uuid[10], uuid[11],
1827                         uuid[12], uuid[13], uuid[14], uuid[15]);
1828         }
1829
1830         g_string_append_printf(context->string, "\tbyte_order = %s;\n",
1831                 get_byte_order_string(trace->native_byte_order));
1832
1833         if (trace->packet_header_type) {
1834                 g_string_append(context->string, "\tpacket.header := ");
1835                 context->current_indentation_level++;
1836                 g_string_assign(context->field_name, "");
1837                 BT_LOGD_STR("Serializing trace's packet header field type's metadata.");
1838                 ret = bt_field_type_serialize(trace->packet_header_type,
1839                         context);
1840                 if (ret) {
1841                         goto end;
1842                 }
1843                 context->current_indentation_level--;
1844         }
1845
1846         g_string_append(context->string, ";\n};\n\n");
1847 end:
1848         return ret;
1849 }
1850
1851 static
1852 void append_env_metadata(struct bt_trace *trace,
1853                 struct metadata_context *context)
1854 {
1855         int64_t i;
1856         int64_t env_size;
1857
1858         env_size = bt_attributes_get_count(trace->environment);
1859         if (env_size <= 0) {
1860                 return;
1861         }
1862
1863         g_string_append(context->string, "env {\n");
1864
1865         for (i = 0; i < env_size; i++) {
1866                 struct bt_value *env_field_value_obj = NULL;
1867                 const char *entry_name;
1868
1869                 entry_name = bt_attributes_get_field_name(
1870                         trace->environment, i);
1871                 env_field_value_obj = bt_attributes_get_field_value(
1872                         trace->environment, i);
1873
1874                 assert(entry_name);
1875                 assert(env_field_value_obj);
1876
1877                 switch (bt_value_get_type(env_field_value_obj)) {
1878                 case BT_VALUE_TYPE_INTEGER:
1879                 {
1880                         int ret;
1881                         int64_t int_value;
1882
1883                         ret = bt_value_integer_get(env_field_value_obj,
1884                                 &int_value);
1885                         assert(ret == 0);
1886                         g_string_append_printf(context->string,
1887                                 "\t%s = %" PRId64 ";\n", entry_name,
1888                                 int_value);
1889                         break;
1890                 }
1891                 case BT_VALUE_TYPE_STRING:
1892                 {
1893                         int ret;
1894                         const char *str_value;
1895                         char *escaped_str = NULL;
1896
1897                         ret = bt_value_string_get(env_field_value_obj,
1898                                 &str_value);
1899                         assert(ret == 0);
1900                         escaped_str = g_strescape(str_value, NULL);
1901                         if (!escaped_str) {
1902                                 BT_LOGE("Cannot escape string: string=\"%s\"",
1903                                         str_value);
1904                                 goto loop_next;
1905                         }
1906
1907                         g_string_append_printf(context->string,
1908                                 "\t%s = \"%s\";\n", entry_name, escaped_str);
1909                         free(escaped_str);
1910                         break;
1911                 }
1912                 default:
1913                         goto loop_next;
1914                 }
1915
1916 loop_next:
1917                 BT_PUT(env_field_value_obj);
1918         }
1919
1920         g_string_append(context->string, "};\n\n");
1921 }
1922
1923 char *bt_trace_get_metadata_string(struct bt_trace *trace)
1924 {
1925         char *metadata = NULL;
1926         struct metadata_context *context = NULL;
1927         int err = 0;
1928         size_t i;
1929
1930         if (!trace) {
1931                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1932                 goto end;
1933         }
1934
1935         context = g_new0(struct metadata_context, 1);
1936         if (!context) {
1937                 BT_LOGE_STR("Failed to allocate one metadata context.");
1938                 goto end;
1939         }
1940
1941         context->field_name = g_string_sized_new(DEFAULT_IDENTIFIER_SIZE);
1942         context->string = g_string_sized_new(DEFAULT_METADATA_STRING_SIZE);
1943         g_string_append(context->string, "/* CTF 1.8 */\n\n");
1944         if (append_trace_metadata(trace, context)) {
1945                 /* append_trace_metadata() logs errors */
1946                 goto error;
1947         }
1948         append_env_metadata(trace, context);
1949         g_ptr_array_foreach(trace->clocks,
1950                 (GFunc)bt_clock_class_serialize, context);
1951
1952         for (i = 0; i < trace->stream_classes->len; i++) {
1953                 /* bt_stream_class_serialize() logs details */
1954                 err = bt_stream_class_serialize(
1955                         trace->stream_classes->pdata[i], context);
1956                 if (err) {
1957                         /* bt_stream_class_serialize() logs errors */
1958                         goto error;
1959                 }
1960         }
1961
1962         metadata = context->string->str;
1963
1964 error:
1965         g_string_free(context->string, err ? TRUE : FALSE);
1966         g_string_free(context->field_name, TRUE);
1967         g_free(context);
1968
1969 end:
1970         return metadata;
1971 }
1972
1973 enum bt_byte_order bt_trace_get_native_byte_order(
1974                 struct bt_trace *trace)
1975 {
1976         enum bt_byte_order ret = BT_BYTE_ORDER_UNKNOWN;
1977
1978         if (!trace) {
1979                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1980                 goto end;
1981         }
1982
1983         ret = trace->native_byte_order;
1984
1985 end:
1986         return ret;
1987 }
1988
1989 int bt_trace_set_native_byte_order(struct bt_trace *trace,
1990                 enum bt_byte_order byte_order)
1991 {
1992         int ret = 0;
1993
1994         if (!trace) {
1995                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1996                 ret = -1;
1997                 goto end;
1998         }
1999
2000         if (trace->frozen) {
2001                 BT_LOGW("Invalid parameter: trace is frozen: "
2002                         "addr=%p, name=\"%s\"",
2003                         trace, bt_trace_get_name(trace));
2004                 ret = -1;
2005                 goto end;
2006         }
2007
2008         if (trace->is_created_by_writer &&
2009                         byte_order == BT_BYTE_ORDER_UNSPECIFIED) {
2010                 BT_LOGW("Invalid parameter: BT_BYTE_ORDER_UNSPECIFIED byte order is not allowed for a CTF writer trace: "
2011                         "addr=%p, name=\"%s\"",
2012                         trace, bt_trace_get_name(trace));
2013                 ret = -1;
2014                 goto end;
2015         }
2016
2017         if (byte_order != BT_BYTE_ORDER_LITTLE_ENDIAN &&
2018                         byte_order != BT_BYTE_ORDER_BIG_ENDIAN &&
2019                         byte_order != BT_BYTE_ORDER_NETWORK) {
2020                 BT_LOGW("Invalid parameter: invalid byte order: "
2021                         "addr=%p, name=\"%s\", bo=%s",
2022                         trace, bt_trace_get_name(trace),
2023                         bt_byte_order_string(byte_order));
2024                 ret = -1;
2025                 goto end;
2026         }
2027
2028         trace->native_byte_order = byte_order;
2029         BT_LOGV("Set trace's native byte order: "
2030                 "addr=%p, name=\"%s\", bo=%s",
2031                 trace, bt_trace_get_name(trace),
2032                 bt_byte_order_string(byte_order));
2033
2034 end:
2035         return ret;
2036 }
2037
2038 struct bt_field_type *bt_trace_get_packet_header_type(
2039                 struct bt_trace *trace)
2040 {
2041         struct bt_field_type *field_type = NULL;
2042
2043         if (!trace) {
2044                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
2045                 goto end;
2046         }
2047
2048         bt_get(trace->packet_header_type);
2049         field_type = trace->packet_header_type;
2050 end:
2051         return field_type;
2052 }
2053
2054 int bt_trace_set_packet_header_type(struct bt_trace *trace,
2055                 struct bt_field_type *packet_header_type)
2056 {
2057         int ret = 0;
2058
2059         if (!trace) {
2060                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
2061                 ret = -1;
2062                 goto end;
2063         }
2064
2065         if (trace->frozen) {
2066                 BT_LOGW("Invalid parameter: trace is frozen: "
2067                         "addr=%p, name=\"%s\"",
2068                         trace, bt_trace_get_name(trace));
2069                 ret = -1;
2070                 goto end;
2071         }
2072
2073         /* packet_header_type must be a structure. */
2074         if (packet_header_type &&
2075                         !bt_field_type_is_structure(packet_header_type)) {
2076                 BT_LOGW("Invalid parameter: packet header field type must be a structure field type if it exists: "
2077                         "addr=%p, name=\"%s\", ft-addr=%p, ft-id=%s",
2078                         trace, bt_trace_get_name(trace),
2079                         packet_header_type,
2080                         bt_field_type_id_string(packet_header_type->id));
2081                 ret = -1;
2082                 goto end;
2083         }
2084
2085         bt_put(trace->packet_header_type);
2086         trace->packet_header_type = bt_get(packet_header_type);
2087         BT_LOGV("Set trace's packet header field type: "
2088                 "addr=%p, name=\"%s\", packet-context-ft-addr=%p",
2089                 trace, bt_trace_get_name(trace), packet_header_type);
2090 end:
2091         return ret;
2092 }
2093
2094 static
2095 int64_t get_stream_class_count(void *element)
2096 {
2097         return bt_trace_get_stream_class_count(
2098                         (struct bt_trace *) element);
2099 }
2100
2101 static
2102 void *get_stream_class(void *element, int i)
2103 {
2104         return bt_trace_get_stream_class_by_index(
2105                         (struct bt_trace *) element, i);
2106 }
2107
2108 static
2109 int visit_stream_class(void *object, bt_visitor visitor,void *data)
2110 {
2111         return bt_stream_class_visit(object, visitor, data);
2112 }
2113
2114 int bt_trace_visit(struct bt_trace *trace,
2115                 bt_visitor visitor, void *data)
2116 {
2117         int ret;
2118         struct bt_visitor_object obj = {
2119                 .object = trace,
2120                 .type = BT_VISITOR_OBJECT_TYPE_TRACE
2121         };
2122
2123         if (!trace) {
2124                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
2125                 ret = -1;
2126                 goto end;
2127         }
2128
2129         if (!visitor) {
2130                 BT_LOGW_STR("Invalid parameter: visitor is NULL.");
2131                 ret = -1;
2132                 goto end;
2133         }
2134
2135         BT_LOGV("Visiting trace: addr=%p, name=\"%s\"",
2136                 trace, bt_trace_get_name(trace));
2137         ret = visitor_helper(&obj, get_stream_class_count,
2138                         get_stream_class, visit_stream_class, visitor, data);
2139 end:
2140         return ret;
2141 }
2142
2143 static
2144 int invoke_listener(struct bt_visitor_object *object, void *data)
2145 {
2146         struct listener_wrapper *listener_wrapper = data;
2147
2148         listener_wrapper->listener(object, listener_wrapper->data);
2149         return 0;
2150 }
2151
2152 // TODO: add logging to this function once we use it internally.
2153 int bt_trace_add_listener(struct bt_trace *trace,
2154                 bt_listener_cb listener, void *listener_data)
2155 {
2156         int ret = 0;
2157         struct listener_wrapper *listener_wrapper =
2158                         g_new0(struct listener_wrapper, 1);
2159
2160         if (!trace || !listener || !listener_wrapper) {
2161                 ret = -1;
2162                 goto error;
2163         }
2164
2165         listener_wrapper->listener = listener;
2166         listener_wrapper->data = listener_data;
2167
2168         /* Visit the current schema. */
2169         ret = bt_trace_visit(trace, invoke_listener, listener_wrapper);
2170         if (ret) {
2171                 goto error;
2172         }
2173
2174         /*
2175          * Add listener to the array of callbacks which will be invoked on
2176          * schema changes.
2177          */
2178         g_ptr_array_add(trace->listeners, listener_wrapper);
2179         return ret;
2180 error:
2181         g_free(listener_wrapper);
2182         return ret;
2183 }
2184
2185 BT_HIDDEN
2186 int bt_trace_object_modification(struct bt_visitor_object *object,
2187                 void *trace_ptr)
2188 {
2189         size_t i;
2190         struct bt_trace *trace = trace_ptr;
2191
2192         assert(trace);
2193         assert(object);
2194
2195         if (trace->listeners->len == 0) {
2196                 goto end;
2197         }
2198
2199         for (i = 0; i < trace->listeners->len; i++) {
2200                 struct listener_wrapper *listener =
2201                                 g_ptr_array_index(trace->listeners, i);
2202
2203                 listener->listener(object, listener->data);
2204         }
2205 end:
2206         return 0;
2207 }
2208
2209 BT_HIDDEN
2210 struct bt_field_type *get_field_type(enum field_type_alias alias)
2211 {
2212         int ret;
2213         unsigned int alignment, size;
2214         struct bt_field_type *field_type = NULL;
2215
2216         if (alias >= NR_FIELD_TYPE_ALIAS) {
2217                 goto end;
2218         }
2219
2220         alignment = field_type_aliases_alignments[alias];
2221         size = field_type_aliases_sizes[alias];
2222         field_type = bt_field_type_integer_create(size);
2223         ret = bt_field_type_set_alignment(field_type, alignment);
2224         if (ret) {
2225                 BT_PUT(field_type);
2226         }
2227 end:
2228         return field_type;
2229 }
2230
2231 static
2232 void bt_trace_freeze(struct bt_trace *trace)
2233 {
2234         int i;
2235
2236         if (trace->frozen) {
2237                 return;
2238         }
2239
2240         BT_LOGD("Freezing trace: addr=%p, name=\"%s\"",
2241                 trace, bt_trace_get_name(trace));
2242         BT_LOGD_STR("Freezing packet header field type.");
2243         bt_field_type_freeze(trace->packet_header_type);
2244         BT_LOGD_STR("Freezing environment attributes.");
2245         bt_attributes_freeze(trace->environment);
2246
2247         if (trace->clocks->len > 0) {
2248                 BT_LOGD_STR("Freezing clock classes.");
2249         }
2250
2251         for (i = 0; i < trace->clocks->len; i++) {
2252                 struct bt_clock_class *clock_class =
2253                         g_ptr_array_index(trace->clocks, i);
2254
2255                 bt_clock_class_freeze(clock_class);
2256         }
2257
2258         trace->frozen = 1;
2259 }
2260
2261 bt_bool bt_trace_is_static(struct bt_trace *trace)
2262 {
2263         bt_bool is_static = BT_FALSE;
2264
2265         if (!trace) {
2266                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
2267                 goto end;
2268         }
2269
2270         is_static = trace->is_static;
2271
2272 end:
2273         return is_static;
2274 }
2275
2276 int bt_trace_set_is_static(struct bt_trace *trace)
2277 {
2278         int ret = 0;
2279         size_t i;
2280
2281         if (!trace) {
2282                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
2283                 ret = -1;
2284                 goto end;
2285         }
2286
2287         ret = check_packet_header_type_has_no_clock_class(trace);
2288         if (ret) {
2289                 /* check_packet_header_type_has_no_clock_class() logs errors */
2290                 goto end;
2291         }
2292
2293         trace->is_static = BT_TRUE;
2294         bt_trace_freeze(trace);
2295         BT_LOGV("Set trace static: addr=%p, name=\"%s\"",
2296                 trace, bt_trace_get_name(trace));
2297
2298         /* Call all the "trace is static" listeners */
2299         for (i = 0; i < trace->is_static_listeners->len; i++) {
2300                 struct bt_trace_is_static_listener_elem elem =
2301                         g_array_index(trace->is_static_listeners,
2302                                 struct bt_trace_is_static_listener_elem, i);
2303
2304                 if (elem.func) {
2305                         elem.func(trace, elem.data);
2306                 }
2307         }
2308
2309 end:
2310         return ret;
2311 }
2312
2313 int bt_trace_add_is_static_listener(struct bt_trace *trace,
2314                 bt_trace_is_static_listener listener,
2315                 bt_trace_listener_removed listener_removed, void *data)
2316 {
2317         int i;
2318         struct bt_trace_is_static_listener_elem new_elem = {
2319                 .func = listener,
2320                 .removed = listener_removed,
2321                 .data = data,
2322         };
2323
2324         if (!trace) {
2325                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
2326                 i = -1;
2327                 goto end;
2328         }
2329
2330         if (!listener) {
2331                 BT_LOGW_STR("Invalid parameter: listener is NULL.");
2332                 i = -1;
2333                 goto end;
2334         }
2335
2336         if (trace->is_static) {
2337                 BT_LOGW("Invalid parameter: trace is already static: "
2338                         "addr=%p, name=\"%s\"",
2339                         trace, bt_trace_get_name(trace));
2340                 i = -1;
2341                 goto end;
2342         }
2343
2344         if (trace->in_remove_listener) {
2345                 BT_LOGW("Cannot call this function during the execution of a remove listener: "
2346                         "addr=%p, name=\"%s\"",
2347                         trace, bt_trace_get_name(trace));
2348                 i = -1;
2349                 goto end;
2350         }
2351
2352         /* Find the next available spot */
2353         for (i = 0; i < trace->is_static_listeners->len; i++) {
2354                 struct bt_trace_is_static_listener_elem elem =
2355                         g_array_index(trace->is_static_listeners,
2356                                 struct bt_trace_is_static_listener_elem, i);
2357
2358                 if (!elem.func) {
2359                         break;
2360                 }
2361         }
2362
2363         if (i == trace->is_static_listeners->len) {
2364                 g_array_append_val(trace->is_static_listeners, new_elem);
2365         } else {
2366                 g_array_insert_val(trace->is_static_listeners, i, new_elem);
2367         }
2368
2369         BT_LOGV("Added \"trace is static\" listener: "
2370                 "trace-addr=%p, trace-name=\"%s\", func-addr=%p, "
2371                 "data-addr=%p, listener-id=%d",
2372                 trace, bt_trace_get_name(trace), listener, data, i);
2373
2374 end:
2375         return i;
2376 }
2377
2378 int bt_trace_remove_is_static_listener(
2379                 struct bt_trace *trace, int listener_id)
2380 {
2381         int ret = 0;
2382         struct bt_trace_is_static_listener_elem *elem;
2383
2384         if (!trace) {
2385                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
2386                 ret = -1;
2387                 goto end;
2388         }
2389
2390         if (trace->in_remove_listener) {
2391                 BT_LOGW("Cannot call this function during the execution of a remove listener: "
2392                         "addr=%p, name=\"%s\", listener-id=%d",
2393                         trace, bt_trace_get_name(trace),
2394                         listener_id);
2395                 ret = -1;
2396                 goto end;
2397         }
2398
2399         if (listener_id < 0) {
2400                 BT_LOGW("Invalid listener ID: must be zero or positive: "
2401                         "listener-id=%d", listener_id);
2402                 ret = -1;
2403                 goto end;
2404         }
2405
2406         if (listener_id >= trace->is_static_listeners->len) {
2407                 BT_LOGW("Invalid parameter: no listener with this listener ID: "
2408                         "addr=%p, name=\"%s\", listener-id=%d",
2409                         trace, bt_trace_get_name(trace),
2410                         listener_id);
2411                 ret = -1;
2412                 goto end;
2413         }
2414
2415         elem = &g_array_index(trace->is_static_listeners,
2416                         struct bt_trace_is_static_listener_elem,
2417                         listener_id);
2418         if (!elem->func) {
2419                 BT_LOGW("Invalid parameter: no listener with this listener ID: "
2420                         "addr=%p, name=\"%s\", listener-id=%d",
2421                         trace, bt_trace_get_name(trace),
2422                         listener_id);
2423                 ret = -1;
2424                 goto end;
2425         }
2426
2427         if (elem->removed) {
2428                 /* Call remove listener */
2429                 BT_LOGV("Calling remove listener: "
2430                         "trace-addr=%p, trace-name=\"%s\", "
2431                         "listener-id=%d", trace, bt_trace_get_name(trace),
2432                         listener_id);
2433                 trace->in_remove_listener = BT_TRUE;
2434                 elem->removed(trace, elem->data);
2435                 trace->in_remove_listener = BT_FALSE;
2436         }
2437
2438         elem->func = NULL;
2439         elem->removed = NULL;
2440         elem->data = NULL;
2441         BT_LOGV("Removed \"trace is static\" listener: "
2442                 "trace-addr=%p, trace-name=\"%s\", "
2443                 "listener-id=%d", trace, bt_trace_get_name(trace),
2444                 listener_id);
2445
2446 end:
2447         return ret;
2448 }