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/assert-pre-internal.h>
  33 #include <babeltrace/ctf-ir/trace-internal.h>
  34 #include <babeltrace/ctf-ir/clock-class-internal.h>
  35 #include <babeltrace/ctf-ir/stream-internal.h>
  36 #include <babeltrace/ctf-ir/stream-class-internal.h>
  37 #include <babeltrace/ctf-ir/event-internal.h>
  38 #include <babeltrace/ctf-ir/event-class.h>
  39 #include <babeltrace/ctf-ir/event-class-internal.h>
  40 #include <babeltrace/ctf-writer/functor-internal.h>
  41 #include <babeltrace/ctf-writer/clock-internal.h>
  42 #include <babeltrace/ctf-ir/field-types-internal.h>
  43 #include <babeltrace/ctf-ir/attributes-internal.h>
  44 #include <babeltrace/ctf-ir/validation-internal.h>
  45 #include <babeltrace/ctf-ir/visitor-internal.h>
  46 #include <babeltrace/ctf-ir/utils.h>
  47 #include <babeltrace/ctf-ir/utils-internal.h>
  48 #include <babeltrace/compiler-internal.h>
  49 #include <babeltrace/values.h>
  50 #include <babeltrace/values-internal.h>
  51 #include <babeltrace/ref.h>
  52 #include <babeltrace/types.h>
  53 #include <babeltrace/endian-internal.h>
  54 #include <babeltrace/assert-internal.h>
  55 #include <inttypes.h>
  56 #include <stdint.h>
  57 #include <string.h>
  58 #include <stdlib.h>
  59
  60 #define DEFAULT_IDENTIFIER_SIZE 128
  61 #define DEFAULT_METADATA_STRING_SIZE 4096
  62
  63 struct listener_wrapper {
  64         bt_listener_cb listener;
  65         void *data;
  66 };
  67
  68 struct bt_trace_is_static_listener_elem {
  69         bt_trace_is_static_listener func;
  70         bt_trace_listener_removed removed;
  71         void *data;
  72 };
  73
  74 static
  75 void bt_trace_destroy(struct bt_object *obj)
  76 {
  77         struct bt_trace *trace = (void *) obj;
  78
  79         BT_LOGD("Destroying trace object: addr=%p, name=\"%s\"",
  80                 trace, bt_trace_get_name(trace));
  81
  82         /*
  83          * Call remove listeners first so that everything else still
  84          * exists in the trace.
  85          */
  86         if (trace->is_static_listeners) {
  87                 size_t i;
  88
  89                 for (i = 0; i < trace->is_static_listeners->len; i++) {
  90                         struct bt_trace_is_static_listener_elem elem =
  91                                 g_array_index(trace->is_static_listeners,
  92                                         struct bt_trace_is_static_listener_elem, i);
  93
  94                         if (elem.removed) {
  95                                 elem.removed(trace, elem.data);
  96                         }
  97                 }
  98
  99                 g_array_free(trace->is_static_listeners, TRUE);
 100         }
 101
 102         if (trace->listeners) {
 103                 g_ptr_array_free(trace->listeners, TRUE);
 104         }
 105
 106         bt_trace_common_finalize(BT_TO_COMMON(trace));
 107         g_free(trace);
 108 }
 109
 110 BT_HIDDEN
 111 int bt_trace_common_initialize(struct bt_trace_common *trace,
 112                 bt_object_release_func release_func)
 113 {
 114         int ret = 0;
 115
 116         BT_LOGD_STR("Initializing common trace object.");
 117         trace->native_byte_order = BT_BYTE_ORDER_UNSPECIFIED;
 118         bt_object_init(trace, release_func);
 119         trace->clock_classes = g_ptr_array_new_with_free_func(
 120                 (GDestroyNotify) bt_put);
 121         if (!trace->clock_classes) {
 122                 BT_LOGE_STR("Failed to allocate one GPtrArray.");
 123                 goto error;
 124         }
 125
 126         trace->streams = g_ptr_array_new_with_free_func(
 127                 (GDestroyNotify) bt_object_release);
 128         if (!trace->streams) {
 129                 BT_LOGE_STR("Failed to allocate one GPtrArray.");
 130                 goto error;
 131         }
 132
 133         trace->stream_classes = g_ptr_array_new_with_free_func(
 134                 (GDestroyNotify) bt_object_release);
 135         if (!trace->stream_classes) {
 136                 BT_LOGE_STR("Failed to allocate one GPtrArray.");
 137                 goto error;
 138         }
 139
 140         /* Create the environment array object */
 141         trace->environment = bt_attributes_create();
 142         if (!trace->environment) {
 143                 BT_LOGE_STR("Cannot create empty attributes object.");
 144                 goto error;
 145         }
 146
 147         BT_LOGD("Initialized common trace object: addr=%p", trace);
 148         goto end;
 149
 150 error:
 151         ret = -1;
 152
 153 end:
 154         return ret;
 155 }
 156
 157 BT_HIDDEN
 158 void bt_trace_common_finalize(struct bt_trace_common *trace)
 159 {
 160         BT_LOGD("Finalizing common trace object: addr=%p, name=\"%s\"",
 161                 trace, bt_trace_common_get_name(trace));
 162
 163         if (trace->environment) {
 164                 BT_LOGD_STR("Destroying environment attributes.");
 165                 bt_attributes_destroy(trace->environment);
 166         }
 167
 168         if (trace->name) {
 169                 g_string_free(trace->name, TRUE);
 170         }
 171
 172         if (trace->clock_classes) {
 173                 BT_LOGD_STR("Putting clock classes.");
 174                 g_ptr_array_free(trace->clock_classes, TRUE);
 175         }
 176
 177         if (trace->streams) {
 178                 BT_LOGD_STR("Destroying streams.");
 179                 g_ptr_array_free(trace->streams, TRUE);
 180         }
 181
 182         if (trace->stream_classes) {
 183                 BT_LOGD_STR("Destroying stream classes.");
 184                 g_ptr_array_free(trace->stream_classes, TRUE);
 185         }
 186
 187         BT_LOGD_STR("Putting packet header field type.");
 188         bt_put(trace->packet_header_field_type);
 189 }
 190
 191 struct bt_trace *bt_trace_create(void)
 192 {
 193         struct bt_trace *trace = NULL;
 194         int ret;
 195
 196         BT_LOGD_STR("Creating trace object.");
 197         trace = g_new0(struct bt_trace, 1);
 198         if (!trace) {
 199                 BT_LOGE_STR("Failed to allocate one trace.");
 200                 goto error;
 201         }
 202
 203         ret = bt_trace_common_initialize(BT_TO_COMMON(trace), bt_trace_destroy);
 204         if (ret) {
 205                 /* bt_trace_common_initialize() logs errors */
 206                 goto error;
 207         }
 208
 209         trace->listeners = g_ptr_array_new_with_free_func(
 210                         (GDestroyNotify) g_free);
 211         if (!trace->listeners) {
 212                 BT_LOGE_STR("Failed to allocate one GPtrArray.");
 213                 goto error;
 214         }
 215
 216         trace->is_static_listeners = g_array_new(FALSE, TRUE,
 217                 sizeof(struct bt_trace_is_static_listener_elem));
 218         if (!trace->is_static_listeners) {
 219                 BT_LOGE_STR("Failed to allocate one GArray.");
 220                 goto error;
 221         }
 222
 223         BT_LOGD("Created trace object: addr=%p", trace);
 224         return trace;
 225
 226 error:
 227         BT_PUT(trace);
 228         return trace;
 229 }
 230
 231 const char *bt_trace_get_name(struct bt_trace *trace)
 232 {
 233         return bt_trace_common_get_name(BT_TO_COMMON(trace));
 234 }
 235
 236 BT_HIDDEN
 237 int bt_trace_common_set_name(struct bt_trace_common *trace, const char *name)
 238 {
 239         int ret = 0;
 240
 241         if (!trace) {
 242                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
 243                 ret = -1;
 244                 goto end;
 245         }
 246
 247         if (!name) {
 248                 BT_LOGW_STR("Invalid parameter: name is NULL.");
 249                 ret = -1;
 250                 goto end;
 251         }
 252
 253         if (trace->frozen) {
 254                 BT_LOGW("Invalid parameter: trace is frozen: "
 255                         "addr=%p, name=\"%s\"",
 256                         trace, bt_trace_common_get_name(trace));
 257                 ret = -1;
 258                 goto end;
 259         }
 260
 261         trace->name = trace->name ? g_string_assign(trace->name, name) :
 262                         g_string_new(name);
 263         if (!trace->name) {
 264                 BT_LOGE_STR("Failed to allocate one GString.");
 265                 ret = -1;
 266                 goto end;
 267         }
 268
 269         BT_LOGV("Set trace's name: addr=%p, name=\"%s\"", trace, name);
 270
 271 end:
 272         return ret;
 273 }
 274
 275 int bt_trace_set_name(struct bt_trace *trace, const char *name)
 276 {
 277         return bt_trace_common_set_name(BT_TO_COMMON(trace), name);
 278 }
 279
 280 const unsigned char *bt_trace_get_uuid(struct bt_trace *trace)
 281 {
 282         return bt_trace_common_get_uuid(BT_TO_COMMON(trace));
 283 }
 284
 285 BT_HIDDEN
 286 int bt_trace_common_set_uuid(struct bt_trace_common *trace,
 287                 const unsigned char *uuid)
 288 {
 289         int ret = 0;
 290
 291         if (!trace) {
 292                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
 293                 ret = -1;
 294                 goto end;
 295         }
 296
 297         if (!uuid) {
 298                 BT_LOGW_STR("Invalid parameter: UUID is NULL.");
 299                 ret = -1;
 300                 goto end;
 301         }
 302
 303         if (trace->frozen) {
 304                 BT_LOGW("Invalid parameter: trace is frozen: "
 305                         "addr=%p, name=\"%s\"",
 306                         trace, bt_trace_common_get_name(trace));
 307                 ret = -1;
 308                 goto end;
 309         }
 310
 311         memcpy(trace->uuid, uuid, BABELTRACE_UUID_LEN);
 312         trace->uuid_set = BT_TRUE;
 313         BT_LOGV("Set trace's UUID: addr=%p, name=\"%s\", "
 314                 "uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\"",
 315                 trace, bt_trace_common_get_name(trace),
 316                 (unsigned int) uuid[0],
 317                 (unsigned int) uuid[1],
 318                 (unsigned int) uuid[2],
 319                 (unsigned int) uuid[3],
 320                 (unsigned int) uuid[4],
 321                 (unsigned int) uuid[5],
 322                 (unsigned int) uuid[6],
 323                 (unsigned int) uuid[7],
 324                 (unsigned int) uuid[8],
 325                 (unsigned int) uuid[9],
 326                 (unsigned int) uuid[10],
 327                 (unsigned int) uuid[11],
 328                 (unsigned int) uuid[12],
 329                 (unsigned int) uuid[13],
 330                 (unsigned int) uuid[14],
 331                 (unsigned int) uuid[15]);
 332
 333 end:
 334         return ret;
 335 }
 336
 337 int bt_trace_set_uuid(struct bt_trace *trace,
 338                 const unsigned char *uuid)
 339 {
 340         return bt_trace_common_set_uuid(BT_TO_COMMON(trace), uuid);
 341 }
 342
 343 BT_HIDDEN
 344 int bt_trace_common_set_environment_field(struct bt_trace_common *trace,
 345                 const char *name, struct bt_value *value)
 346 {
 347         int ret = 0;
 348
 349         if (!trace) {
 350                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
 351                 ret = -1;
 352                 goto end;
 353         }
 354
 355         if (!name) {
 356                 BT_LOGW_STR("Invalid parameter: name is NULL.");
 357                 ret = -1;
 358                 goto end;
 359         }
 360
 361         if (!value) {
 362                 BT_LOGW_STR("Invalid parameter: value is NULL.");
 363                 ret = -1;
 364                 goto end;
 365         }
 366
 367         if (!bt_identifier_is_valid(name)) {
 368                 BT_LOGW("Invalid parameter: environment field's name is not a valid CTF identifier: "
 369                         "trace-addr=%p, trace-name=\"%s\", "
 370                         "env-name=\"%s\"",
 371                         trace, bt_trace_common_get_name(trace), name);
 372                 ret = -1;
 373                 goto end;
 374         }
 375
 376         if (!bt_value_is_integer(value) && !bt_value_is_string(value)) {
 377                 BT_LOGW("Invalid parameter: environment field's value is not an integer or string value: "
 378                         "trace-addr=%p, trace-name=\"%s\", "
 379                         "env-name=\"%s\", env-value-type=%s",
 380                         trace, bt_trace_common_get_name(trace), name,
 381                         bt_value_type_string(bt_value_get_type(value)));
 382                 ret = -1;
 383                 goto end;
 384         }
 385
 386         if (trace->frozen) {
 387                 /*
 388                  * New environment fields may be added to a frozen trace,
 389                  * but existing fields may not be changed.
 390                  *
 391                  * The object passed is frozen like all other attributes.
 392                  */
 393                 struct bt_value *attribute =
 394                         bt_attributes_get_field_value_by_name(
 395                                 trace->environment, name);
 396
 397                 if (attribute) {
 398                         BT_LOGW("Invalid parameter: trace is frozen and environment field already exists with this name: "
 399                                 "trace-addr=%p, trace-name=\"%s\", "
 400                                 "env-name=\"%s\"",
 401                                 trace, bt_trace_common_get_name(trace), name);
 402                         BT_PUT(attribute);
 403                         ret = -1;
 404                         goto end;
 405                 }
 406
 407                 bt_value_freeze(value);
 408         }
 409
 410         ret = bt_attributes_set_field_value(trace->environment, name,
 411                 value);
 412         if (ret) {
 413                 BT_LOGE("Cannot set environment field's value: "
 414                         "trace-addr=%p, trace-name=\"%s\", "
 415                         "env-name=\"%s\"",
 416                         trace, bt_trace_common_get_name(trace), name);
 417         } else {
 418                 BT_LOGV("Set environment field's value: "
 419                         "trace-addr=%p, trace-name=\"%s\", "
 420                         "env-name=\"%s\", value-addr=%p",
 421                         trace, bt_trace_common_get_name(trace), name, value);
 422         }
 423
 424 end:
 425         return ret;
 426 }
 427
 428 int bt_trace_set_environment_field(struct bt_trace *trace,
 429                 const char *name, struct bt_value *value)
 430 {
 431         int ret;
 432
 433         if (trace->is_static) {
 434                 BT_LOGW("Invalid parameter: trace is static: "
 435                         "addr=%p, name=\"%s\"",
 436                         trace, bt_trace_get_name(trace));
 437                 ret = -1;
 438                 goto end;
 439         }
 440
 441         ret = bt_trace_common_set_environment_field(BT_TO_COMMON(trace),
 442                 name, value);
 443
 444 end:
 445         return ret;
 446 }
 447
 448 BT_HIDDEN
 449 int bt_trace_common_set_environment_field_string(struct bt_trace_common *trace,
 450                 const char *name, const char *value)
 451 {
 452         int ret = 0;
 453         struct bt_value *env_value_string_obj = NULL;
 454
 455         if (!value) {
 456                 BT_LOGW_STR("Invalid parameter: value is NULL.");
 457                 ret = -1;
 458                 goto end;
 459         }
 460
 461         env_value_string_obj = bt_value_string_create_init(value);
 462         if (!env_value_string_obj) {
 463                 BT_LOGE_STR("Cannot create string value object.");
 464                 ret = -1;
 465                 goto end;
 466         }
 467
 468         /* bt_trace_common_set_environment_field() logs errors */
 469         ret = bt_trace_common_set_environment_field(trace, name,
 470                 env_value_string_obj);
 471
 472 end:
 473         bt_put(env_value_string_obj);
 474         return ret;
 475 }
 476
 477 int bt_trace_set_environment_field_string(struct bt_trace *trace,
 478                 const char *name, const char *value)
 479 {
 480         return bt_trace_common_set_environment_field_string(BT_TO_COMMON(trace),
 481                 name, value);
 482 }
 483
 484 BT_HIDDEN
 485 int bt_trace_common_set_environment_field_integer(
 486                 struct bt_trace_common *trace, const char *name, int64_t value)
 487 {
 488         int ret = 0;
 489         struct bt_value *env_value_integer_obj = NULL;
 490
 491         env_value_integer_obj = bt_value_integer_create_init(value);
 492         if (!env_value_integer_obj) {
 493                 BT_LOGE_STR("Cannot create integer value object.");
 494                 ret = -1;
 495                 goto end;
 496         }
 497
 498         /* bt_trace_common_set_environment_field() logs errors */
 499         ret = bt_trace_common_set_environment_field(trace, name,
 500                 env_value_integer_obj);
 501
 502 end:
 503         bt_put(env_value_integer_obj);
 504         return ret;
 505 }
 506
 507 int bt_trace_set_environment_field_integer(
 508                 struct bt_trace *trace, const char *name, int64_t value)
 509 {
 510         return bt_trace_common_set_environment_field_integer(
 511                 BT_TO_COMMON(trace), name, value);
 512 }
 513
 514 int64_t bt_trace_get_environment_field_count(struct bt_trace *trace)
 515 {
 516         return bt_trace_common_get_environment_field_count(BT_TO_COMMON(trace));
 517 }
 518
 519 const char *
 520 bt_trace_get_environment_field_name_by_index(struct bt_trace *trace,
 521                 uint64_t index)
 522 {
 523         return bt_trace_common_get_environment_field_name_by_index(
 524                 BT_TO_COMMON(trace), index);
 525 }
 526
 527 struct bt_value *bt_trace_get_environment_field_value_by_index(
 528                 struct bt_trace *trace, uint64_t index)
 529 {
 530         return bt_trace_common_get_environment_field_value_by_index(
 531                 BT_TO_COMMON(trace), index);
 532 }
 533
 534 struct bt_value *bt_trace_get_environment_field_value_by_name(
 535                 struct bt_trace *trace, const char *name)
 536 {
 537         return bt_trace_common_get_environment_field_value_by_name(
 538                 BT_TO_COMMON(trace), name);
 539 }
 540
 541 BT_HIDDEN
 542 int bt_trace_common_add_clock_class(struct bt_trace_common *trace,
 543                 struct bt_clock_class *clock_class)
 544 {
 545         int ret = 0;
 546
 547         if (!trace) {
 548                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
 549                 ret = -1;
 550                 goto end;
 551         }
 552
 553         if (!bt_clock_class_is_valid(clock_class)) {
 554                 BT_LOGW("Invalid parameter: clock class is invalid: "
 555                         "trace-addr=%p, trace-name=\"%s\", "
 556                         "clock-class-addr=%p, clock-class-name=\"%s\"",
 557                         trace, bt_trace_common_get_name(trace),
 558                         clock_class, bt_clock_class_get_name(clock_class));
 559                 ret = -1;
 560                 goto end;
 561         }
 562
 563         /* Check for duplicate clock classes */
 564         if (bt_trace_common_has_clock_class(trace, clock_class)) {
 565                 BT_LOGW("Invalid parameter: clock class already exists in trace: "
 566                         "trace-addr=%p, trace-name=\"%s\", "
 567                         "clock-class-addr=%p, clock-class-name=\"%s\"",
 568                         trace, bt_trace_common_get_name(trace),
 569                         clock_class, bt_clock_class_get_name(clock_class));
 570                 ret = -1;
 571                 goto end;
 572         }
 573
 574         bt_get(clock_class);
 575         g_ptr_array_add(trace->clock_classes, clock_class);
 576
 577         if (trace->frozen) {
 578                 BT_LOGV_STR("Freezing added clock class because trace is frozen.");
 579                 bt_clock_class_freeze(clock_class);
 580         }
 581
 582         BT_LOGV("Added clock class to trace: "
 583                 "trace-addr=%p, trace-name=\"%s\", "
 584                 "clock-class-addr=%p, clock-class-name=\"%s\"",
 585                 trace, bt_trace_common_get_name(trace),
 586                 clock_class, bt_clock_class_get_name(clock_class));
 587
 588 end:
 589         return ret;
 590 }
 591
 592 int bt_trace_add_clock_class(struct bt_trace *trace,
 593                 struct bt_clock_class *clock_class)
 594 {
 595         int ret;
 596
 597         if (trace->is_static) {
 598                 BT_LOGW("Invalid parameter: trace is static: "
 599                         "addr=%p, name=\"%s\"",
 600                         trace, bt_trace_get_name(trace));
 601                 ret = -1;
 602                 goto end;
 603         }
 604
 605         ret = bt_trace_common_add_clock_class(BT_TO_COMMON(trace),
 606                 clock_class);
 607
 608 end:
 609         return ret;
 610 }
 611
 612 int64_t bt_trace_get_clock_class_count(struct bt_trace *trace)
 613 {
 614         return bt_trace_common_get_clock_class_count(BT_TO_COMMON(trace));
 615 }
 616
 617 struct bt_clock_class *bt_trace_get_clock_class_by_index(
 618                 struct bt_trace *trace, uint64_t index)
 619 {
 620         return bt_trace_common_get_clock_class_by_index(
 621                 BT_TO_COMMON(trace), index);
 622 }
 623
 624 static
 625 bool packet_header_field_type_is_valid(struct bt_trace_common *trace,
 626                 struct bt_field_type_common *packet_header_type)
 627 {
 628         int ret;
 629         bool is_valid = true;
 630         struct bt_field_type_common *field_type = NULL;
 631
 632         if (!packet_header_type) {
 633                 /*
 634                  * No packet header field type: trace must have only
 635                  * one stream. At this point the stream class being
 636                  * added is not part of the trace yet, so we validate
 637                  * that the trace contains no stream classes yet.
 638                  */
 639                 if (trace->stream_classes->len >= 1) {
 640                         BT_LOGW_STR("Invalid packet header field type: "
 641                                 "packet header field type does not exist but there's more than one stream class in the trace.");
 642                         goto invalid;
 643                 }
 644
 645                 /* No packet header field type: valid at this point */
 646                 goto end;
 647         }
 648
 649         /* Packet header field type, if it exists, must be a structure */
 650         if (packet_header_type->id != BT_FIELD_TYPE_ID_STRUCT) {
 651                 BT_LOGW("Invalid packet header field type: must be a structure field type if it exists: "
 652                         "ft-addr=%p, ft-id=%s",
 653                         packet_header_type,
 654                         bt_common_field_type_id_string(packet_header_type->id));
 655                 goto invalid;
 656         }
 657
 658         /*
 659          * If there's a `magic` field, it must be a 32-bit unsigned
 660          * integer field type. Also it must be the first field of the
 661          * packet header field type.
 662          */
 663         field_type = bt_field_type_common_structure_get_field_type_by_name(
 664                 packet_header_type, "magic");
 665         if (field_type) {
 666                 const char *field_name;
 667
 668                 if (field_type->id != BT_FIELD_TYPE_ID_INTEGER) {
 669                         BT_LOGW("Invalid packet header field type: `magic` field must be an integer field type: "
 670                                 "magic-ft-addr=%p, magic-ft-id=%s",
 671                                 field_type,
 672                                 bt_common_field_type_id_string(field_type->id));
 673                         goto invalid;
 674                 }
 675
 676                 if (bt_field_type_common_integer_is_signed(field_type)) {
 677                         BT_LOGW("Invalid packet header field type: `magic` field must be an unsigned integer field type: "
 678                                 "magic-ft-addr=%p", field_type);
 679                         goto invalid;
 680                 }
 681
 682                 if (bt_field_type_common_integer_get_size(field_type) != 32) {
 683                         BT_LOGW("Invalid packet header field type: `magic` field must be a 32-bit unsigned integer field type: "
 684                                 "magic-ft-addr=%p, magic-ft-size=%u",
 685                                 field_type,
 686                                 bt_field_type_common_integer_get_size(field_type));
 687                         goto invalid;
 688                 }
 689
 690                 ret = bt_field_type_common_structure_get_field_by_index(
 691                         packet_header_type, &field_name, NULL, 0);
 692                 BT_ASSERT(ret == 0);
 693
 694                 if (strcmp(field_name, "magic") != 0) {
 695                         BT_LOGW("Invalid packet header field type: `magic` field must be the first field: "
 696                                 "magic-ft-addr=%p, first-field-name=\"%s\"",
 697                                 field_type, field_name);
 698                         goto invalid;
 699                 }
 700
 701                 BT_PUT(field_type);
 702         }
 703
 704         /*
 705          * If there's a `uuid` field, it must be an array field type of
 706          * length 16 with an 8-bit unsigned integer element field type.
 707          */
 708         field_type = bt_field_type_common_structure_get_field_type_by_name(
 709                 packet_header_type, "uuid");
 710         if (field_type) {
 711                 struct bt_field_type_common *elem_ft;
 712
 713                 if (field_type->id != BT_FIELD_TYPE_ID_ARRAY) {
 714                         BT_LOGW("Invalid packet header field type: `uuid` field must be an array field type: "
 715                                 "uuid-ft-addr=%p, uuid-ft-id=%s",
 716                                 field_type,
 717                                 bt_common_field_type_id_string(field_type->id));
 718                         goto invalid;
 719                 }
 720
 721                 if (bt_field_type_common_array_get_length(field_type) != 16) {
 722                         BT_LOGW("Invalid packet header field type: `uuid` array field type's length must be 16: "
 723                                 "uuid-ft-addr=%p, uuid-ft-length=%" PRId64,
 724                                 field_type,
 725                                 bt_field_type_common_array_get_length(field_type));
 726                         goto invalid;
 727                 }
 728
 729                 elem_ft = bt_field_type_common_array_get_element_field_type(field_type);
 730                 BT_ASSERT(elem_ft);
 731
 732                 if (elem_ft->id != BT_FIELD_TYPE_ID_INTEGER) {
 733                         BT_LOGW("Invalid packet header field type: `uuid` field's element field type must be an integer field type: "
 734                                 "elem-ft-addr=%p, elem-ft-id=%s",
 735                                 elem_ft,
 736                                 bt_common_field_type_id_string(elem_ft->id));
 737                         bt_put(elem_ft);
 738                         goto invalid;
 739                 }
 740
 741                 if (bt_field_type_common_integer_is_signed(elem_ft)) {
 742                         BT_LOGW("Invalid packet header field type: `uuid` field's element field type must be an unsigned integer field type: "
 743                                 "elem-ft-addr=%p", elem_ft);
 744                         bt_put(elem_ft);
 745                         goto invalid;
 746                 }
 747
 748                 if (bt_field_type_common_integer_get_size(elem_ft) != 8) {
 749                         BT_LOGW("Invalid packet header field type: `uuid` field's element field type must be an 8-bit unsigned integer field type: "
 750                                 "elem-ft-addr=%p, elem-ft-size=%u",
 751                                 elem_ft,
 752                                 bt_field_type_common_integer_get_size(elem_ft));
 753                         bt_put(elem_ft);
 754                         goto invalid;
 755                 }
 756
 757                 bt_put(elem_ft);
 758                 BT_PUT(field_type);
 759         }
 760
 761         /*
 762          * The `stream_id` field must exist if there's more than one
 763          * stream classes in the trace.
 764          */
 765         field_type = bt_field_type_common_structure_get_field_type_by_name(
 766                 packet_header_type, "stream_id");
 767
 768         if (!field_type && trace->stream_classes->len >= 1) {
 769                 BT_LOGW_STR("Invalid packet header field type: "
 770                         "`stream_id` field does not exist but there's more than one stream class in the trace.");
 771                 goto invalid;
 772         }
 773
 774         /*
 775          * If there's a `stream_id` field, it must be an unsigned
 776          * integer field type.
 777          */
 778         if (field_type) {
 779                 if (field_type->id != BT_FIELD_TYPE_ID_INTEGER) {
 780                         BT_LOGW("Invalid packet header field type: `stream_id` field must be an integer field type: "
 781                                 "stream-id-ft-addr=%p, stream-id-ft-id=%s",
 782                                 field_type,
 783                                 bt_common_field_type_id_string(field_type->id));
 784                         goto invalid;
 785                 }
 786
 787                 if (bt_field_type_common_integer_is_signed(field_type)) {
 788                         BT_LOGW("Invalid packet header field type: `stream_id` field must be an unsigned integer field type: "
 789                                 "stream-id-ft-addr=%p", field_type);
 790                         goto invalid;
 791                 }
 792
 793                 BT_PUT(field_type);
 794         }
 795
 796         /*
 797          * If there's a `packet_seq_num` field, it must be an unsigned
 798          * integer field type.
 799          */
 800         field_type = bt_field_type_common_structure_get_field_type_by_name(
 801                 packet_header_type, "packet_seq_num");
 802         if (field_type) {
 803                 if (field_type->id != BT_FIELD_TYPE_ID_INTEGER) {
 804                         BT_LOGW("Invalid packet header field type: `packet_seq_num` field must be an integer field type: "
 805                                 "stream-id-ft-addr=%p, packet-seq-num-ft-id=%s",
 806                                 field_type,
 807                                 bt_common_field_type_id_string(field_type->id));
 808                         goto invalid;
 809                 }
 810
 811                 if (bt_field_type_common_integer_is_signed(field_type)) {
 812                         BT_LOGW("Invalid packet header field type: `packet_seq_num` field must be an unsigned integer field type: "
 813                                 "packet-seq-num-ft-addr=%p", field_type);
 814                         goto invalid;
 815                 }
 816
 817                 BT_PUT(field_type);
 818         }
 819
 820         goto end;
 821
 822 invalid:
 823         is_valid = false;
 824
 825 end:
 826         bt_put(field_type);
 827         return is_valid;
 828 }
 829
 830 static
 831 bool packet_context_field_type_is_valid(struct bt_trace_common *trace,
 832                 struct bt_stream_class_common *stream_class,
 833                 struct bt_field_type_common *packet_context_type,
 834                 bool check_ts_begin_end_mapped)
 835 {
 836         bool is_valid = true;
 837         struct bt_field_type_common *field_type = NULL;
 838
 839         if (!packet_context_type) {
 840                 /* No packet context field type: valid at this point */
 841                 goto end;
 842         }
 843
 844         /* Packet context field type, if it exists, must be a structure */
 845         if (packet_context_type->id != BT_FIELD_TYPE_ID_STRUCT) {
 846                 BT_LOGW("Invalid packet context field type: must be a structure field type if it exists: "
 847                         "ft-addr=%p, ft-id=%s",
 848                         packet_context_type,
 849                         bt_common_field_type_id_string(packet_context_type->id));
 850                 goto invalid;
 851         }
 852
 853         /*
 854          * If there's a `packet_size` field, it must be an unsigned
 855          * integer field type.
 856          */
 857         field_type = bt_field_type_common_structure_get_field_type_by_name(
 858                 packet_context_type, "packet_size");
 859         if (field_type) {
 860                 if (field_type->id != BT_FIELD_TYPE_ID_INTEGER) {
 861                         BT_LOGW("Invalid packet context field type: `packet_size` field must be an integer field type: "
 862                                 "packet-size-ft-addr=%p, packet-size-ft-id=%s",
 863                                 field_type,
 864                                 bt_common_field_type_id_string(field_type->id));
 865                         goto invalid;
 866                 }
 867
 868                 if (bt_field_type_common_integer_is_signed(field_type)) {
 869                         BT_LOGW("Invalid packet context field type: `packet_size` field must be an unsigned integer field type: "
 870                                 "packet-size-ft-addr=%p", field_type);
 871                         goto invalid;
 872                 }
 873
 874                 BT_PUT(field_type);
 875         }
 876
 877         /*
 878          * If there's a `content_size` field, it must be an unsigned
 879          * integer field type.
 880          */
 881         field_type = bt_field_type_common_structure_get_field_type_by_name(
 882                 packet_context_type, "content_size");
 883         if (field_type) {
 884                 if (field_type->id != BT_FIELD_TYPE_ID_INTEGER) {
 885                         BT_LOGW("Invalid packet context field type: `content_size` field must be an integer field type: "
 886                                 "content-size-ft-addr=%p, content-size-ft-id=%s",
 887                                 field_type,
 888                                 bt_common_field_type_id_string(field_type->id));
 889                         goto invalid;
 890                 }
 891
 892                 if (bt_field_type_common_integer_is_signed(field_type)) {
 893                         BT_LOGW("Invalid packet context field type: `content_size` field must be an unsigned integer field type: "
 894                                 "content-size-ft-addr=%p", field_type);
 895                         goto invalid;
 896                 }
 897
 898                 BT_PUT(field_type);
 899         }
 900
 901         /*
 902          * If there's a `events_discarded` field, it must be an unsigned
 903          * integer field type.
 904          */
 905         field_type = bt_field_type_common_structure_get_field_type_by_name(
 906                 packet_context_type, "events_discarded");
 907         if (field_type) {
 908                 if (field_type->id != BT_FIELD_TYPE_ID_INTEGER) {
 909                         BT_LOGW("Invalid packet context field type: `events_discarded` field must be an integer field type: "
 910                                 "events-discarded-ft-addr=%p, events-discarded-ft-id=%s",
 911                                 field_type,
 912                                 bt_common_field_type_id_string(field_type->id));
 913                         goto invalid;
 914                 }
 915
 916                 if (bt_field_type_common_integer_is_signed(field_type)) {
 917                         BT_LOGW("Invalid packet context field type: `events_discarded` field must be an unsigned integer field type: "
 918                                 "events-discarded-ft-addr=%p", field_type);
 919                         goto invalid;
 920                 }
 921
 922                 BT_PUT(field_type);
 923         }
 924
 925         /*
 926          * If there's a `timestamp_begin` field, it must be an unsigned
 927          * integer field type. Also, if the trace is not a CTF writer's
 928          * trace, then we cannot automatically set the mapped clock
 929          * class of this field, so it must have a mapped clock class.
 930          */
 931         field_type = bt_field_type_common_structure_get_field_type_by_name(
 932                 packet_context_type, "timestamp_begin");
 933         if (field_type) {
 934                 if (field_type->id != BT_FIELD_TYPE_ID_INTEGER) {
 935                         BT_LOGW("Invalid packet context field type: `timestamp_begin` field must be an integer field type: "
 936                                 "timestamp-begin-ft-addr=%p, timestamp-begin-ft-id=%s",
 937                                 field_type,
 938                                 bt_common_field_type_id_string(field_type->id));
 939                         goto invalid;
 940                 }
 941
 942                 if (bt_field_type_common_integer_is_signed(field_type)) {
 943                         BT_LOGW("Invalid packet context field type: `timestamp_begin` field must be an unsigned integer field type: "
 944                                 "timestamp-begin-ft-addr=%p", field_type);
 945                         goto invalid;
 946                 }
 947
 948                 if (check_ts_begin_end_mapped) {
 949                         struct bt_clock_class *clock_class =
 950                                 bt_field_type_common_integer_get_mapped_clock_class(
 951                                         field_type);
 952
 953                         bt_put(clock_class);
 954                         if (!clock_class) {
 955                                 BT_LOGW("Invalid packet context field type: `timestamp_begin` field must be mapped to a clock class: "
 956                                         "timestamp-begin-ft-addr=%p", field_type);
 957                                 goto invalid;
 958                         }
 959                 }
 960
 961                 BT_PUT(field_type);
 962         }
 963
 964         /*
 965          * If there's a `timestamp_end` field, it must be an unsigned
 966          * integer field type. Also, if the trace is not a CTF writer's
 967          * trace, then we cannot automatically set the mapped clock
 968          * class of this field, so it must have a mapped clock class.
 969          */
 970         field_type = bt_field_type_common_structure_get_field_type_by_name(
 971                 packet_context_type, "timestamp_end");
 972         if (field_type) {
 973                 if (field_type->id != BT_FIELD_TYPE_ID_INTEGER) {
 974                         BT_LOGW("Invalid packet context field type: `timestamp_end` field must be an integer field type: "
 975                                 "timestamp-end-ft-addr=%p, timestamp-end-ft-id=%s",
 976                                 field_type,
 977                                 bt_common_field_type_id_string(field_type->id));
 978                         goto invalid;
 979                 }
 980
 981                 if (bt_field_type_common_integer_is_signed(field_type)) {
 982                         BT_LOGW("Invalid packet context field type: `timestamp_end` field must be an unsigned integer field type: "
 983                                 "timestamp-end-ft-addr=%p", field_type);
 984                         goto invalid;
 985                 }
 986
 987                 if (check_ts_begin_end_mapped) {
 988                         struct bt_clock_class *clock_class =
 989                                 bt_field_type_common_integer_get_mapped_clock_class(
 990                                         field_type);
 991
 992                         bt_put(clock_class);
 993                         if (!clock_class) {
 994                                 BT_LOGW("Invalid packet context field type: `timestamp_end` field must be mapped to a clock class: "
 995                                         "timestamp-end-ft-addr=%p", field_type);
 996                                 goto invalid;
 997                         }
 998                 }
 999
1000                 BT_PUT(field_type);
1001         }
1002
1003         goto end;
1004
1005 invalid:
1006         is_valid = false;
1007
1008 end:
1009         bt_put(field_type);
1010         return is_valid;
1011 }
1012
1013 static
1014 bool event_header_field_type_is_valid(struct bt_trace_common *trace,
1015                 struct bt_stream_class_common *stream_class,
1016                 struct bt_field_type_common *event_header_type)
1017 {
1018         bool is_valid = true;
1019         struct bt_field_type_common *field_type = NULL;
1020
1021         /*
1022          * We do not validate that the `timestamp` field exists here
1023          * because CTF does not require this exact name to be mapped to
1024          * a clock class.
1025          */
1026
1027         if (!event_header_type) {
1028                 /*
1029                  * No event header field type: stream class must have
1030                  * only one event class.
1031                  */
1032                 if (bt_stream_class_common_get_event_class_count(stream_class) > 1) {
1033                         BT_LOGW_STR("Invalid event header field type: "
1034                                 "event header field type does not exist but there's more than one event class in the stream class.");
1035                         goto invalid;
1036                 }
1037
1038                 /* No event header field type: valid at this point */
1039                 goto end;
1040         }
1041
1042         /* Event header field type, if it exists, must be a structure */
1043         if (event_header_type->id != BT_FIELD_TYPE_ID_STRUCT) {
1044                 BT_LOGW("Invalid event header field type: must be a structure field type if it exists: "
1045                         "ft-addr=%p, ft-id=%s",
1046                         event_header_type,
1047                         bt_common_field_type_id_string(event_header_type->id));
1048                 goto invalid;
1049         }
1050
1051         /*
1052          * If there's an `id` field, it must be an unsigned integer
1053          * field type or an enumeration field type with an unsigned
1054          * integer container field type.
1055          */
1056         field_type = bt_field_type_common_structure_get_field_type_by_name(
1057                 event_header_type, "id");
1058         if (field_type) {
1059                 struct bt_field_type_common *int_ft;
1060
1061                 if (field_type->id == BT_FIELD_TYPE_ID_INTEGER) {
1062                         int_ft = bt_get(field_type);
1063                 } else if (field_type->id == BT_FIELD_TYPE_ID_ENUM) {
1064                         int_ft = bt_field_type_common_enumeration_get_container_field_type(
1065                                 field_type);
1066                 } else {
1067                         BT_LOGW("Invalid event header field type: `id` field must be an integer or enumeration field type: "
1068                                 "id-ft-addr=%p, id-ft-id=%s",
1069                                 field_type,
1070                                 bt_common_field_type_id_string(field_type->id));
1071                         goto invalid;
1072                 }
1073
1074                 BT_ASSERT(int_ft);
1075                 if (bt_field_type_common_integer_is_signed(int_ft)) {
1076                         BT_LOGW("Invalid event header field type: `id` field must be an unsigned integer or enumeration field type: "
1077                                 "id-ft-addr=%p", int_ft);
1078                         goto invalid;
1079                 }
1080
1081                 bt_put(int_ft);
1082                 BT_PUT(field_type);
1083         }
1084
1085         goto end;
1086
1087 invalid:
1088         is_valid = false;
1089
1090 end:
1091         bt_put(field_type);
1092         return is_valid;
1093 }
1094
1095 static
1096 int check_packet_header_type_has_no_clock_class(struct bt_trace_common *trace)
1097 {
1098         int ret = 0;
1099
1100         if (trace->packet_header_field_type) {
1101                 struct bt_clock_class *clock_class = NULL;
1102
1103                 ret = bt_field_type_common_validate_single_clock_class(
1104                         trace->packet_header_field_type,
1105                         &clock_class);
1106                 bt_put(clock_class);
1107                 if (ret || clock_class) {
1108                         BT_LOGW("Trace's packet header field type cannot "
1109                                 "contain a field type which is mapped to "
1110                                 "a clock class: "
1111                                 "trace-addr=%p, trace-name=\"%s\", "
1112                                 "clock-class-name=\"%s\"",
1113                                 trace, bt_trace_common_get_name(trace),
1114                                 clock_class ?
1115                                         bt_clock_class_get_name(clock_class) :
1116                                         NULL);
1117                         ret = -1;
1118                 }
1119         }
1120
1121         return ret;
1122 }
1123
1124 BT_HIDDEN
1125 int bt_trace_common_add_stream_class(struct bt_trace_common *trace,
1126                 struct bt_stream_class_common *stream_class,
1127                 bt_validation_flag_copy_field_type_func copy_field_type_func,
1128                 struct bt_clock_class *init_expected_clock_class,
1129                 int (*map_clock_classes_func)(struct bt_stream_class_common *stream_class,
1130                         struct bt_field_type_common *packet_context_field_type,
1131                         struct bt_field_type_common *event_header_field_type),
1132                 bool check_ts_begin_end_mapped)
1133 {
1134         int ret;
1135         int64_t i;
1136         int64_t stream_id;
1137         struct bt_validation_output trace_sc_validation_output = { 0 };
1138         struct bt_validation_output *ec_validation_outputs = NULL;
1139         const enum bt_validation_flag trace_sc_validation_flags =
1140                 BT_VALIDATION_FLAG_TRACE |
1141                 BT_VALIDATION_FLAG_STREAM;
1142         const enum bt_validation_flag ec_validation_flags =
1143                 BT_VALIDATION_FLAG_EVENT;
1144         struct bt_field_type_common *packet_header_type = NULL;
1145         struct bt_field_type_common *packet_context_type = NULL;
1146         struct bt_field_type_common *event_header_type = NULL;
1147         struct bt_field_type_common *stream_event_ctx_type = NULL;
1148         int64_t event_class_count;
1149         struct bt_trace_common *current_parent_trace = NULL;
1150         struct bt_clock_class *expected_clock_class =
1151                 bt_get(init_expected_clock_class);
1152
1153         BT_ASSERT(copy_field_type_func);
1154
1155         if (!trace) {
1156                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1157                 ret = -1;
1158                 goto end;
1159         }
1160
1161         if (!stream_class) {
1162                 BT_LOGW_STR("Invalid parameter: stream class is NULL.");
1163                 ret = -1;
1164                 goto end;
1165         }
1166
1167         BT_LOGD("Adding stream class to trace: "
1168                 "trace-addr=%p, trace-name=\"%s\", "
1169                 "stream-class-addr=%p, stream-class-name=\"%s\", "
1170                 "stream-class-id=%" PRId64,
1171                 trace, bt_trace_common_get_name(trace),
1172                 stream_class, bt_stream_class_common_get_name(stream_class),
1173                 bt_stream_class_common_get_id(stream_class));
1174
1175         current_parent_trace = bt_stream_class_common_get_trace(stream_class);
1176         if (current_parent_trace) {
1177                 /* Stream class is already associated to a trace, abort. */
1178                 BT_LOGW("Invalid parameter: stream class is already part of a trace: "
1179                         "stream-class-trace-addr=%p, "
1180                         "stream-class-trace-name=\"%s\"",
1181                         current_parent_trace,
1182                         bt_trace_common_get_name(current_parent_trace));
1183                 ret = -1;
1184                 goto end;
1185         }
1186
1187         event_class_count =
1188                 bt_stream_class_common_get_event_class_count(stream_class);
1189         BT_ASSERT(event_class_count >= 0);
1190
1191         if (!stream_class->frozen) {
1192                 /*
1193                  * Stream class is not frozen yet. Validate that the
1194                  * stream class contains at most a single clock class
1195                  * because the previous
1196                  * bt_stream_class_common_add_event_class() calls did
1197                  * not make this validation since the stream class's
1198                  * direct field types (packet context, event header,
1199                  * event context) could change afterwards. This stream
1200                  * class is about to be frozen and those field types
1201                  * won't be changed if this function succeeds.
1202                  *
1203                  * At this point we're also sure that the stream class's
1204                  * clock, if any, has the same class as the stream
1205                  * class's expected clock class, if any. This is why, if
1206                  * bt_stream_class_common_validate_single_clock_class()
1207                  * succeeds below, the call to
1208                  * bt_stream_class_map_clock_class() at the end of this
1209                  * function is safe because it maps to the same, single
1210                  * clock class.
1211                  */
1212                 ret = bt_stream_class_common_validate_single_clock_class(
1213                         stream_class, &expected_clock_class);
1214                 if (ret) {
1215                         BT_LOGW("Invalid parameter: stream class or one of its "
1216                                 "event classes contains a field type which is "
1217                                 "not recursively mapped to the expected "
1218                                 "clock class: "
1219                                 "stream-class-addr=%p, "
1220                                 "stream-class-id=%" PRId64 ", "
1221                                 "stream-class-name=\"%s\", "
1222                                 "expected-clock-class-addr=%p, "
1223                                 "expected-clock-class-name=\"%s\"",
1224                                 stream_class, bt_stream_class_common_get_id(stream_class),
1225                                 bt_stream_class_common_get_name(stream_class),
1226                                 expected_clock_class,
1227                                 expected_clock_class ?
1228                                         bt_clock_class_get_name(expected_clock_class) :
1229                                         NULL);
1230                         goto end;
1231                 }
1232         }
1233
1234         ret = check_packet_header_type_has_no_clock_class(trace);
1235         if (ret) {
1236                 /* check_packet_header_type_has_no_clock_class() logs errors */
1237                 goto end;
1238         }
1239
1240         /*
1241          * We're about to freeze both the trace and the stream class.
1242          * Also, each event class contained in this stream class are
1243          * already frozen.
1244          *
1245          * This trace, this stream class, and all its event classes
1246          * should be valid at this point.
1247          *
1248          * Validate trace and stream class first, then each event
1249          * class of this stream class can be validated individually.
1250          */
1251         packet_header_type =
1252                 bt_trace_common_get_packet_header_field_type(trace);
1253         packet_context_type =
1254                 bt_stream_class_common_get_packet_context_field_type(stream_class);
1255         event_header_type =
1256                 bt_stream_class_common_get_event_header_field_type(stream_class);
1257         stream_event_ctx_type =
1258                 bt_stream_class_common_get_event_context_field_type(stream_class);
1259
1260         BT_LOGD("Validating trace and stream class field types.");
1261         ret = bt_validate_class_types(trace->environment,
1262                 packet_header_type, packet_context_type, event_header_type,
1263                 stream_event_ctx_type, NULL, NULL, trace->valid,
1264                 stream_class->valid, 1, &trace_sc_validation_output,
1265                 trace_sc_validation_flags, copy_field_type_func);
1266         BT_PUT(packet_header_type);
1267         BT_PUT(packet_context_type);
1268         BT_PUT(event_header_type);
1269         BT_PUT(stream_event_ctx_type);
1270
1271         if (ret) {
1272                 /*
1273                  * This means something went wrong during the validation
1274                  * process, not that the objects are invalid.
1275                  */
1276                 BT_LOGE("Failed to validate trace and stream class field types: "
1277                         "ret=%d", ret);
1278                 goto end;
1279         }
1280
1281         if ((trace_sc_validation_output.valid_flags &
1282                         trace_sc_validation_flags) !=
1283                         trace_sc_validation_flags) {
1284                 /* Invalid trace/stream class */
1285                 BT_LOGW("Invalid trace or stream class field types: "
1286                         "valid-flags=0x%x",
1287                         trace_sc_validation_output.valid_flags);
1288                 ret = -1;
1289                 goto end;
1290         }
1291
1292         if (event_class_count > 0) {
1293                 ec_validation_outputs = g_new0(struct bt_validation_output,
1294                         event_class_count);
1295                 if (!ec_validation_outputs) {
1296                         BT_LOGE_STR("Failed to allocate one validation output structure.");
1297                         ret = -1;
1298                         goto end;
1299                 }
1300         }
1301
1302         /* Validate each event class individually */
1303         for (i = 0; i < event_class_count; i++) {
1304                 struct bt_event_class_common *event_class =
1305                         bt_stream_class_common_get_event_class_by_index(
1306                                 stream_class, i);
1307                 struct bt_field_type_common *event_context_type = NULL;
1308                 struct bt_field_type_common *event_payload_type = NULL;
1309
1310                 event_context_type =
1311                         bt_event_class_common_get_context_field_type(event_class);
1312                 event_payload_type =
1313                         bt_event_class_common_get_payload_field_type(event_class);
1314
1315                 /*
1316                  * It is important to use the field types returned by
1317                  * the previous trace and stream class validation here
1318                  * because copies could have been made.
1319                  */
1320                 BT_LOGD("Validating event class's field types: "
1321                         "addr=%p, name=\"%s\", id=%" PRId64,
1322                         event_class, bt_event_class_common_get_name(event_class),
1323                         bt_event_class_common_get_id(event_class));
1324                 ret = bt_validate_class_types(trace->environment,
1325                         trace_sc_validation_output.packet_header_type,
1326                         trace_sc_validation_output.packet_context_type,
1327                         trace_sc_validation_output.event_header_type,
1328                         trace_sc_validation_output.stream_event_ctx_type,
1329                         event_context_type, event_payload_type,
1330                         1, 1, event_class->valid, &ec_validation_outputs[i],
1331                         ec_validation_flags, copy_field_type_func);
1332                 BT_PUT(event_context_type);
1333                 BT_PUT(event_payload_type);
1334                 BT_PUT(event_class);
1335
1336                 if (ret) {
1337                         BT_LOGE("Failed to validate event class field types: "
1338                                 "ret=%d", ret);
1339                         goto end;
1340                 }
1341
1342                 if ((ec_validation_outputs[i].valid_flags &
1343                                 ec_validation_flags) != ec_validation_flags) {
1344                         /* Invalid event class */
1345                         BT_LOGW("Invalid event class field types: "
1346                                 "valid-flags=0x%x",
1347                                 ec_validation_outputs[i].valid_flags);
1348                         ret = -1;
1349                         goto end;
1350                 }
1351         }
1352
1353         stream_id = bt_stream_class_common_get_id(stream_class);
1354         if (stream_id < 0) {
1355                 stream_id = trace->next_stream_id++;
1356                 if (stream_id < 0) {
1357                         BT_LOGE_STR("No more stream class IDs available.");
1358                         ret = -1;
1359                         goto end;
1360                 }
1361
1362                 /* Try to assign a new stream id */
1363                 for (i = 0; i < trace->stream_classes->len; i++) {
1364                         if (stream_id == bt_stream_class_common_get_id(
1365                                 trace->stream_classes->pdata[i])) {
1366                                 /* Duplicate stream id found */
1367                                 BT_LOGW("Duplicate stream class ID: "
1368                                         "id=%" PRId64, (int64_t) stream_id);
1369                                 ret = -1;
1370                                 goto end;
1371                         }
1372                 }
1373
1374                 if (bt_stream_class_common_set_id_no_check(stream_class,
1375                                 stream_id)) {
1376                         /* TODO Should retry with a different stream id */
1377                         BT_LOGE("Cannot set stream class's ID: "
1378                                 "id=%" PRId64, (int64_t) stream_id);
1379                         ret = -1;
1380                         goto end;
1381                 }
1382         }
1383
1384         /*
1385          * At this point all the field types in the validation output
1386          * are valid. Validate the semantics of some scopes according to
1387          * the CTF specification.
1388          */
1389         if (!packet_header_field_type_is_valid(trace,
1390                         trace_sc_validation_output.packet_header_type)) {
1391                 BT_LOGW_STR("Invalid trace's packet header field type.");
1392                 ret = -1;
1393                 goto end;
1394         }
1395
1396         if (!packet_context_field_type_is_valid(trace,
1397                         stream_class,
1398                         trace_sc_validation_output.packet_context_type,
1399                         check_ts_begin_end_mapped)) {
1400                 BT_LOGW_STR("Invalid stream class's packet context field type.");
1401                 ret = -1;
1402                 goto end;
1403         }
1404
1405         if (!event_header_field_type_is_valid(trace,
1406                         stream_class,
1407                         trace_sc_validation_output.event_header_type)) {
1408                 BT_LOGW_STR("Invalid steam class's event header field type.");
1409                 ret = -1;
1410                 goto end;
1411         }
1412
1413         /*
1414          * Now is the time to automatically map specific field types of
1415          * the stream class's packet context and event header field
1416          * types to the stream class's clock's class if they are not
1417          * mapped to a clock class yet. We do it here because we know
1418          * that after this point, everything is frozen so it won't be
1419          * possible for the user to modify the stream class's clock, or
1420          * to map those field types to other clock classes.
1421          */
1422         if (map_clock_classes_func) {
1423                 if (map_clock_classes_func(stream_class,
1424                                 trace_sc_validation_output.packet_context_type,
1425                                 trace_sc_validation_output.event_header_type)) {
1426                         /* map_clock_classes_func() logs errors */
1427                         ret = -1;
1428                         goto end;
1429                 }
1430         }
1431
1432         bt_object_set_parent(stream_class, trace);
1433         g_ptr_array_add(trace->stream_classes, stream_class);
1434
1435         /*
1436          * At this point we know that the function will be successful.
1437          * Therefore we can replace the trace and stream class field
1438          * types with what's in their validation output structure and
1439          * mark them as valid. We can also replace the field types of
1440          * all the event classes of the stream class and mark them as
1441          * valid.
1442          */
1443         bt_validation_replace_types(trace, stream_class, NULL,
1444                 &trace_sc_validation_output, trace_sc_validation_flags);
1445         trace->valid = 1;
1446         stream_class->valid = 1;
1447
1448         /*
1449          * Put what was not moved in bt_validation_replace_types().
1450          */
1451         bt_validation_output_put_types(&trace_sc_validation_output);
1452
1453         for (i = 0; i < event_class_count; i++) {
1454                 struct bt_event_class_common *event_class =
1455                         bt_stream_class_common_get_event_class_by_index(
1456                                 stream_class, i);
1457
1458                 bt_validation_replace_types(NULL, NULL, event_class,
1459                         &ec_validation_outputs[i], ec_validation_flags);
1460                 event_class->valid = 1;
1461                 BT_PUT(event_class);
1462
1463                 /*
1464                  * Put what was not moved in
1465                  * bt_validation_replace_types().
1466                  */
1467                 bt_validation_output_put_types(&ec_validation_outputs[i]);
1468         }
1469
1470         /*
1471          * Freeze the trace and the stream class.
1472          */
1473         bt_stream_class_common_freeze(stream_class);
1474         bt_trace_common_freeze(trace);
1475
1476         /*
1477          * It is safe to set the stream class's unique clock class
1478          * now because the stream class is frozen.
1479          */
1480         if (expected_clock_class) {
1481                 BT_MOVE(stream_class->clock_class, expected_clock_class);
1482         }
1483
1484         BT_LOGD("Added stream class to trace: "
1485                 "trace-addr=%p, trace-name=\"%s\", "
1486                 "stream-class-addr=%p, stream-class-name=\"%s\", "
1487                 "stream-class-id=%" PRId64,
1488                 trace, bt_trace_common_get_name(trace),
1489                 stream_class, bt_stream_class_common_get_name(stream_class),
1490                 bt_stream_class_common_get_id(stream_class));
1491
1492 end:
1493         if (ret) {
1494                 bt_object_set_parent(stream_class, NULL);
1495
1496                 if (ec_validation_outputs) {
1497                         for (i = 0; i < event_class_count; i++) {
1498                                 bt_validation_output_put_types(
1499                                         &ec_validation_outputs[i]);
1500                         }
1501                 }
1502         }
1503
1504         g_free(ec_validation_outputs);
1505         bt_validation_output_put_types(&trace_sc_validation_output);
1506         bt_put(current_parent_trace);
1507         bt_put(expected_clock_class);
1508         BT_ASSERT(!packet_header_type);
1509         BT_ASSERT(!packet_context_type);
1510         BT_ASSERT(!event_header_type);
1511         BT_ASSERT(!stream_event_ctx_type);
1512         return ret;
1513 }
1514
1515 int bt_trace_add_stream_class(struct bt_trace *trace,
1516                 struct bt_stream_class *stream_class)
1517 {
1518         int ret = 0;
1519
1520         if (!trace) {
1521                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1522                 ret = -1;
1523                 goto end;
1524         }
1525
1526         if (trace->is_static) {
1527                 BT_LOGW_STR("Invalid parameter: trace is static.");
1528                 ret = -1;
1529                 goto end;
1530         }
1531
1532         ret = bt_trace_common_add_stream_class(BT_TO_COMMON(trace),
1533                 BT_TO_COMMON(stream_class),
1534                 (bt_validation_flag_copy_field_type_func) bt_field_type_copy,
1535                 NULL, NULL, true);
1536         if (ret) {
1537                 goto end;
1538         }
1539
1540         /* Notifiy listeners of the trace's schema modification. */
1541         bt_stream_class_common_visit(BT_TO_COMMON(stream_class),
1542                         bt_trace_object_modification, trace);
1543
1544 end:
1545         return ret;
1546 }
1547
1548 int64_t bt_trace_get_stream_count(struct bt_trace *trace)
1549 {
1550         return bt_trace_common_get_stream_count(BT_TO_COMMON(trace));
1551 }
1552
1553 struct bt_stream *bt_trace_get_stream_by_index(
1554                 struct bt_trace *trace,
1555                 uint64_t index)
1556 {
1557         return BT_FROM_COMMON(bt_trace_common_get_stream_by_index(
1558                 BT_TO_COMMON(trace), index));
1559 }
1560
1561 int64_t bt_trace_get_stream_class_count(struct bt_trace *trace)
1562 {
1563         return bt_trace_common_get_stream_class_count(BT_TO_COMMON(trace));
1564 }
1565
1566 struct bt_stream_class *bt_trace_get_stream_class_by_index(
1567                 struct bt_trace *trace, uint64_t index)
1568 {
1569         return BT_FROM_COMMON(bt_trace_common_get_stream_class_by_index(
1570                 BT_TO_COMMON(trace), index));
1571 }
1572
1573 struct bt_stream_class *bt_trace_get_stream_class_by_id(
1574                 struct bt_trace *trace, uint64_t id)
1575 {
1576         return BT_FROM_COMMON(
1577                 bt_trace_common_get_stream_class_by_id(
1578                         BT_TO_COMMON(trace), id));
1579 }
1580
1581 struct bt_clock_class *bt_trace_get_clock_class_by_name(
1582                 struct bt_trace *trace, const char *name)
1583 {
1584         return bt_trace_common_get_clock_class_by_name(BT_TO_COMMON(trace),
1585                 name);
1586 }
1587
1588 BT_HIDDEN
1589 bt_bool bt_trace_common_has_clock_class(struct bt_trace_common *trace,
1590                 struct bt_clock_class *clock_class)
1591 {
1592         struct search_query query = { .value = clock_class, .found = 0 };
1593
1594         BT_ASSERT(trace);
1595         BT_ASSERT(clock_class);
1596
1597         g_ptr_array_foreach(trace->clock_classes, value_exists, &query);
1598         return query.found;
1599 }
1600
1601 enum bt_byte_order bt_trace_get_native_byte_order(
1602                 struct bt_trace *trace)
1603 {
1604         return bt_trace_common_get_native_byte_order(BT_TO_COMMON(trace));
1605 }
1606
1607 BT_HIDDEN
1608 int bt_trace_common_set_native_byte_order(struct bt_trace_common *trace,
1609                 enum bt_byte_order byte_order, bool allow_unspecified)
1610 {
1611         int ret = 0;
1612
1613         if (!trace) {
1614                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1615                 ret = -1;
1616                 goto end;
1617         }
1618
1619         if (trace->frozen) {
1620                 BT_LOGW("Invalid parameter: trace is frozen: "
1621                         "addr=%p, name=\"%s\"",
1622                         trace, bt_trace_common_get_name(trace));
1623                 ret = -1;
1624                 goto end;
1625         }
1626
1627         if (byte_order == BT_BYTE_ORDER_UNSPECIFIED && !allow_unspecified) {
1628                 BT_LOGW("Invalid parameter: BT_BYTE_ORDER_UNSPECIFIED byte order is not allowed: "
1629                         "addr=%p, name=\"%s\"",
1630                         trace, bt_trace_common_get_name(trace));
1631                 ret = -1;
1632                 goto end;
1633         }
1634
1635         if (byte_order != BT_BYTE_ORDER_LITTLE_ENDIAN &&
1636                         byte_order != BT_BYTE_ORDER_BIG_ENDIAN &&
1637                         byte_order != BT_BYTE_ORDER_NETWORK) {
1638                 BT_LOGW("Invalid parameter: invalid byte order: "
1639                         "addr=%p, name=\"%s\", bo=%s",
1640                         trace, bt_trace_common_get_name(trace),
1641                         bt_common_byte_order_string(byte_order));
1642                 ret = -1;
1643                 goto end;
1644         }
1645
1646         trace->native_byte_order = byte_order;
1647         BT_LOGV("Set trace's native byte order: "
1648                 "addr=%p, name=\"%s\", bo=%s",
1649                 trace, bt_trace_common_get_name(trace),
1650                 bt_common_byte_order_string(byte_order));
1651
1652 end:
1653         return ret;
1654 }
1655
1656 int bt_trace_set_native_byte_order(struct bt_trace *trace,
1657                 enum bt_byte_order byte_order)
1658 {
1659         return bt_trace_common_set_native_byte_order(BT_TO_COMMON(trace),
1660                 byte_order, true);
1661 }
1662
1663 struct bt_field_type *bt_trace_get_packet_header_field_type(
1664                 struct bt_trace *trace)
1665 {
1666         return BT_FROM_COMMON(bt_trace_common_get_packet_header_field_type(
1667                 BT_TO_COMMON(trace)));
1668 }
1669
1670 BT_HIDDEN
1671 int bt_trace_common_set_packet_header_field_type(struct bt_trace_common *trace,
1672                 struct bt_field_type_common *packet_header_type)
1673 {
1674         int ret = 0;
1675
1676         if (!trace) {
1677                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1678                 ret = -1;
1679                 goto end;
1680         }
1681
1682         if (trace->frozen) {
1683                 BT_LOGW("Invalid parameter: trace is frozen: "
1684                         "addr=%p, name=\"%s\"",
1685                         trace, bt_trace_common_get_name(trace));
1686                 ret = -1;
1687                 goto end;
1688         }
1689
1690         /* packet_header_type must be a structure. */
1691         if (packet_header_type &&
1692                         packet_header_type->id != BT_FIELD_TYPE_ID_STRUCT) {
1693                 BT_LOGW("Invalid parameter: packet header field type must be a structure field type if it exists: "
1694                         "addr=%p, name=\"%s\", ft-addr=%p, ft-id=%s",
1695                         trace, bt_trace_common_get_name(trace),
1696                         packet_header_type,
1697                         bt_common_field_type_id_string(packet_header_type->id));
1698                 ret = -1;
1699                 goto end;
1700         }
1701
1702         bt_put(trace->packet_header_field_type);
1703         trace->packet_header_field_type = bt_get(packet_header_type);
1704         BT_LOGV("Set trace's packet header field type: "
1705                 "addr=%p, name=\"%s\", packet-context-ft-addr=%p",
1706                 trace, bt_trace_common_get_name(trace), packet_header_type);
1707 end:
1708         return ret;
1709 }
1710
1711 int bt_trace_set_packet_header_field_type(struct bt_trace *trace,
1712                 struct bt_field_type *packet_header_type)
1713 {
1714         return bt_trace_common_set_packet_header_field_type(BT_TO_COMMON(trace),
1715                 (void *) packet_header_type);
1716 }
1717
1718 static
1719 int64_t get_stream_class_count(void *element)
1720 {
1721         return bt_trace_get_stream_class_count(
1722                         (struct bt_trace *) element);
1723 }
1724
1725 static
1726 void *get_stream_class(void *element, int i)
1727 {
1728         return bt_trace_get_stream_class_by_index(
1729                         (struct bt_trace *) element, i);
1730 }
1731
1732 static
1733 int visit_stream_class(void *object, bt_visitor visitor,void *data)
1734 {
1735         return bt_stream_class_visit(object, visitor, data);
1736 }
1737
1738 int bt_trace_visit(struct bt_trace *trace,
1739                 bt_visitor visitor, void *data)
1740 {
1741         int ret;
1742         struct bt_visitor_object obj = {
1743                 .object = trace,
1744                 .type = BT_VISITOR_OBJECT_TYPE_TRACE
1745         };
1746
1747         if (!trace) {
1748                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1749                 ret = -1;
1750                 goto end;
1751         }
1752
1753         if (!visitor) {
1754                 BT_LOGW_STR("Invalid parameter: visitor is NULL.");
1755                 ret = -1;
1756                 goto end;
1757         }
1758
1759         BT_LOGV("Visiting trace: addr=%p, name=\"%s\"",
1760                 trace, bt_trace_get_name(trace));
1761         ret = visitor_helper(&obj, get_stream_class_count,
1762                         get_stream_class, visit_stream_class, visitor, data);
1763 end:
1764         return ret;
1765 }
1766
1767 static
1768 int invoke_listener(struct bt_visitor_object *object, void *data)
1769 {
1770         struct listener_wrapper *listener_wrapper = data;
1771
1772         listener_wrapper->listener(object, listener_wrapper->data);
1773         return 0;
1774 }
1775
1776 // TODO: add logging to this function once we use it internally.
1777 int bt_trace_add_listener(struct bt_trace *trace,
1778                 bt_listener_cb listener, void *listener_data)
1779 {
1780         int ret = 0;
1781         struct listener_wrapper *listener_wrapper =
1782                         g_new0(struct listener_wrapper, 1);
1783
1784         if (!trace || !listener || !listener_wrapper) {
1785                 ret = -1;
1786                 goto error;
1787         }
1788
1789         listener_wrapper->listener = listener;
1790         listener_wrapper->data = listener_data;
1791
1792         /* Visit the current schema. */
1793         ret = bt_trace_visit(trace, invoke_listener, listener_wrapper);
1794         if (ret) {
1795                 goto error;
1796         }
1797
1798         /*
1799          * Add listener to the array of callbacks which will be invoked on
1800          * schema changes.
1801          */
1802         g_ptr_array_add(trace->listeners, listener_wrapper);
1803         return ret;
1804 error:
1805         g_free(listener_wrapper);
1806         return ret;
1807 }
1808
1809 BT_HIDDEN
1810 int bt_trace_object_modification(struct bt_visitor_object *object,
1811                 void *trace_ptr)
1812 {
1813         size_t i;
1814         struct bt_trace *trace = trace_ptr;
1815
1816         BT_ASSERT(trace);
1817         BT_ASSERT(object);
1818
1819         if (trace->listeners->len == 0) {
1820                 goto end;
1821         }
1822
1823         for (i = 0; i < trace->listeners->len; i++) {
1824                 struct listener_wrapper *listener =
1825                                 g_ptr_array_index(trace->listeners, i);
1826
1827                 listener->listener(object, listener->data);
1828         }
1829 end:
1830         return 0;
1831 }
1832
1833 bt_bool bt_trace_is_static(struct bt_trace *trace)
1834 {
1835         BT_ASSERT_PRE_NON_NULL(trace, "Trace");
1836         return trace->is_static;
1837 }
1838
1839 int bt_trace_set_is_static(struct bt_trace *trace)
1840 {
1841         int ret = 0;
1842         size_t i;
1843
1844         if (!trace) {
1845                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1846                 ret = -1;
1847                 goto end;
1848         }
1849
1850         ret = check_packet_header_type_has_no_clock_class(BT_TO_COMMON(trace));
1851         if (ret) {
1852                 /* check_packet_header_type_has_no_clock_class() logs errors */
1853                 goto end;
1854         }
1855
1856         trace->is_static = BT_TRUE;
1857         bt_trace_common_freeze(BT_TO_COMMON(trace));
1858         BT_LOGV("Set trace static: addr=%p, name=\"%s\"",
1859                 trace, bt_trace_get_name(trace));
1860
1861         /* Call all the "trace is static" listeners */
1862         for (i = 0; i < trace->is_static_listeners->len; i++) {
1863                 struct bt_trace_is_static_listener_elem elem =
1864                         g_array_index(trace->is_static_listeners,
1865                                 struct bt_trace_is_static_listener_elem, i);
1866
1867                 if (elem.func) {
1868                         elem.func(trace, elem.data);
1869                 }
1870         }
1871
1872 end:
1873         return ret;
1874 }
1875
1876 int bt_trace_add_is_static_listener(struct bt_trace *trace,
1877                 bt_trace_is_static_listener listener,
1878                 bt_trace_listener_removed listener_removed, void *data)
1879 {
1880         int i;
1881         struct bt_trace_is_static_listener_elem new_elem = {
1882                 .func = listener,
1883                 .removed = listener_removed,
1884                 .data = data,
1885         };
1886
1887         if (!trace) {
1888                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1889                 i = -1;
1890                 goto end;
1891         }
1892
1893         if (!listener) {
1894                 BT_LOGW_STR("Invalid parameter: listener is NULL.");
1895                 i = -1;
1896                 goto end;
1897         }
1898
1899         if (trace->is_static) {
1900                 BT_LOGW("Invalid parameter: trace is already static: "
1901                         "addr=%p, name=\"%s\"",
1902                         trace, bt_trace_get_name(trace));
1903                 i = -1;
1904                 goto end;
1905         }
1906
1907         if (trace->in_remove_listener) {
1908                 BT_LOGW("Cannot call this function during the execution of a remove listener: "
1909                         "addr=%p, name=\"%s\"",
1910                         trace, bt_trace_get_name(trace));
1911                 i = -1;
1912                 goto end;
1913         }
1914
1915         /* Find the next available spot */
1916         for (i = 0; i < trace->is_static_listeners->len; i++) {
1917                 struct bt_trace_is_static_listener_elem elem =
1918                         g_array_index(trace->is_static_listeners,
1919                                 struct bt_trace_is_static_listener_elem, i);
1920
1921                 if (!elem.func) {
1922                         break;
1923                 }
1924         }
1925
1926         if (i == trace->is_static_listeners->len) {
1927                 g_array_append_val(trace->is_static_listeners, new_elem);
1928         } else {
1929                 g_array_insert_val(trace->is_static_listeners, i, new_elem);
1930         }
1931
1932         BT_LOGV("Added \"trace is static\" listener: "
1933                 "trace-addr=%p, trace-name=\"%s\", func-addr=%p, "
1934                 "data-addr=%p, listener-id=%d",
1935                 trace, bt_trace_get_name(trace), listener, data, i);
1936
1937 end:
1938         return i;
1939 }
1940
1941 int bt_trace_remove_is_static_listener(
1942                 struct bt_trace *trace, int listener_id)
1943 {
1944         int ret = 0;
1945         struct bt_trace_is_static_listener_elem *elem;
1946
1947         if (!trace) {
1948                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1949                 ret = -1;
1950                 goto end;
1951         }
1952
1953         if (trace->in_remove_listener) {
1954                 BT_LOGW("Cannot call this function during the execution of a remove listener: "
1955                         "addr=%p, name=\"%s\", listener-id=%d",
1956                         trace, bt_trace_get_name(trace),
1957                         listener_id);
1958                 ret = -1;
1959                 goto end;
1960         }
1961
1962         if (listener_id < 0) {
1963                 BT_LOGW("Invalid listener ID: must be zero or positive: "
1964                         "listener-id=%d", listener_id);
1965                 ret = -1;
1966                 goto end;
1967         }
1968
1969         if (listener_id >= trace->is_static_listeners->len) {
1970                 BT_LOGW("Invalid parameter: no listener with this listener ID: "
1971                         "addr=%p, name=\"%s\", listener-id=%d",
1972                         trace, bt_trace_get_name(trace),
1973                         listener_id);
1974                 ret = -1;
1975                 goto end;
1976         }
1977
1978         elem = &g_array_index(trace->is_static_listeners,
1979                         struct bt_trace_is_static_listener_elem,
1980                         listener_id);
1981         if (!elem->func) {
1982                 BT_LOGW("Invalid parameter: no listener with this listener ID: "
1983                         "addr=%p, name=\"%s\", listener-id=%d",
1984                         trace, bt_trace_get_name(trace),
1985                         listener_id);
1986                 ret = -1;
1987                 goto end;
1988         }
1989
1990         if (elem->removed) {
1991                 /* Call remove listener */
1992                 BT_LOGV("Calling remove listener: "
1993                         "trace-addr=%p, trace-name=\"%s\", "
1994                         "listener-id=%d", trace, bt_trace_get_name(trace),
1995                         listener_id);
1996                 trace->in_remove_listener = BT_TRUE;
1997                 elem->removed(trace, elem->data);
1998                 trace->in_remove_listener = BT_FALSE;
1999         }
2000
2001         elem->func = NULL;
2002         elem->removed = NULL;
2003         elem->data = NULL;
2004         BT_LOGV("Removed \"trace is static\" listener: "
2005                 "trace-addr=%p, trace-name=\"%s\", "
2006                 "listener-id=%d", trace, bt_trace_get_name(trace),
2007                 listener_id);
2008
2009 end:
2010         return ret;
2011 }