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_borrow_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                         ret = -1;
 403                         goto end;
 404                 }
 405
 406                 bt_value_freeze(value);
 407         }
 408
 409         ret = bt_attributes_set_field_value(trace->environment, name,
 410                 value);
 411         if (ret) {
 412                 BT_LOGE("Cannot set environment field's value: "
 413                         "trace-addr=%p, trace-name=\"%s\", "
 414                         "env-name=\"%s\"",
 415                         trace, bt_trace_common_get_name(trace), name);
 416         } else {
 417                 BT_LOGV("Set environment field's value: "
 418                         "trace-addr=%p, trace-name=\"%s\", "
 419                         "env-name=\"%s\", value-addr=%p",
 420                         trace, bt_trace_common_get_name(trace), name, value);
 421         }
 422
 423 end:
 424         return ret;
 425 }
 426
 427 int bt_trace_set_environment_field(struct bt_trace *trace,
 428                 const char *name, struct bt_value *value)
 429 {
 430         int ret;
 431
 432         if (trace->is_static) {
 433                 BT_LOGW("Invalid parameter: trace is static: "
 434                         "addr=%p, name=\"%s\"",
 435                         trace, bt_trace_get_name(trace));
 436                 ret = -1;
 437                 goto end;
 438         }
 439
 440         ret = bt_trace_common_set_environment_field(BT_TO_COMMON(trace),
 441                 name, value);
 442
 443 end:
 444         return ret;
 445 }
 446
 447 BT_HIDDEN
 448 int bt_trace_common_set_environment_field_string(struct bt_trace_common *trace,
 449                 const char *name, const char *value)
 450 {
 451         int ret = 0;
 452         struct bt_value *env_value_string_obj = NULL;
 453
 454         if (!value) {
 455                 BT_LOGW_STR("Invalid parameter: value is NULL.");
 456                 ret = -1;
 457                 goto end;
 458         }
 459
 460         env_value_string_obj = bt_value_string_create_init(value);
 461         if (!env_value_string_obj) {
 462                 BT_LOGE_STR("Cannot create string value object.");
 463                 ret = -1;
 464                 goto end;
 465         }
 466
 467         /* bt_trace_common_set_environment_field() logs errors */
 468         ret = bt_trace_common_set_environment_field(trace, name,
 469                 env_value_string_obj);
 470
 471 end:
 472         bt_put(env_value_string_obj);
 473         return ret;
 474 }
 475
 476 int bt_trace_set_environment_field_string(struct bt_trace *trace,
 477                 const char *name, const char *value)
 478 {
 479         return bt_trace_common_set_environment_field_string(BT_TO_COMMON(trace),
 480                 name, value);
 481 }
 482
 483 BT_HIDDEN
 484 int bt_trace_common_set_environment_field_integer(
 485                 struct bt_trace_common *trace, const char *name, int64_t value)
 486 {
 487         int ret = 0;
 488         struct bt_value *env_value_integer_obj = NULL;
 489
 490         env_value_integer_obj = bt_value_integer_create_init(value);
 491         if (!env_value_integer_obj) {
 492                 BT_LOGE_STR("Cannot create integer value object.");
 493                 ret = -1;
 494                 goto end;
 495         }
 496
 497         /* bt_trace_common_set_environment_field() logs errors */
 498         ret = bt_trace_common_set_environment_field(trace, name,
 499                 env_value_integer_obj);
 500
 501 end:
 502         bt_put(env_value_integer_obj);
 503         return ret;
 504 }
 505
 506 int bt_trace_set_environment_field_integer(
 507                 struct bt_trace *trace, const char *name, int64_t value)
 508 {
 509         return bt_trace_common_set_environment_field_integer(
 510                 BT_TO_COMMON(trace), name, value);
 511 }
 512
 513 int64_t bt_trace_get_environment_field_count(struct bt_trace *trace)
 514 {
 515         return bt_trace_common_get_environment_field_count(BT_TO_COMMON(trace));
 516 }
 517
 518 const char *
 519 bt_trace_get_environment_field_name_by_index(struct bt_trace *trace,
 520                 uint64_t index)
 521 {
 522         return bt_trace_common_get_environment_field_name_by_index(
 523                 BT_TO_COMMON(trace), index);
 524 }
 525
 526 struct bt_value *bt_trace_borrow_environment_field_value_by_index(
 527                 struct bt_trace *trace, uint64_t index)
 528 {
 529         return bt_trace_common_borrow_environment_field_value_by_index(
 530                 BT_TO_COMMON(trace), index);
 531 }
 532
 533 struct bt_value *bt_trace_borrow_environment_field_value_by_name(
 534                 struct bt_trace *trace, const char *name)
 535 {
 536         return bt_trace_common_borrow_environment_field_value_by_name(
 537                 BT_TO_COMMON(trace), name);
 538 }
 539
 540 BT_HIDDEN
 541 int bt_trace_common_add_clock_class(struct bt_trace_common *trace,
 542                 struct bt_clock_class *clock_class)
 543 {
 544         int ret = 0;
 545
 546         if (!trace) {
 547                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
 548                 ret = -1;
 549                 goto end;
 550         }
 551
 552         if (!bt_clock_class_is_valid(clock_class)) {
 553                 BT_LOGW("Invalid parameter: clock class is invalid: "
 554                         "trace-addr=%p, trace-name=\"%s\", "
 555                         "clock-class-addr=%p, clock-class-name=\"%s\"",
 556                         trace, bt_trace_common_get_name(trace),
 557                         clock_class, bt_clock_class_get_name(clock_class));
 558                 ret = -1;
 559                 goto end;
 560         }
 561
 562         /* Check for duplicate clock classes */
 563         if (bt_trace_common_has_clock_class(trace, clock_class)) {
 564                 BT_LOGW("Invalid parameter: clock class already exists in trace: "
 565                         "trace-addr=%p, trace-name=\"%s\", "
 566                         "clock-class-addr=%p, clock-class-name=\"%s\"",
 567                         trace, bt_trace_common_get_name(trace),
 568                         clock_class, bt_clock_class_get_name(clock_class));
 569                 ret = -1;
 570                 goto end;
 571         }
 572
 573         bt_get(clock_class);
 574         g_ptr_array_add(trace->clock_classes, clock_class);
 575
 576         if (trace->frozen) {
 577                 BT_LOGV_STR("Freezing added clock class because trace is frozen.");
 578                 bt_clock_class_freeze(clock_class);
 579         }
 580
 581         BT_LOGV("Added clock class to trace: "
 582                 "trace-addr=%p, trace-name=\"%s\", "
 583                 "clock-class-addr=%p, clock-class-name=\"%s\"",
 584                 trace, bt_trace_common_get_name(trace),
 585                 clock_class, bt_clock_class_get_name(clock_class));
 586
 587 end:
 588         return ret;
 589 }
 590
 591 int bt_trace_add_clock_class(struct bt_trace *trace,
 592                 struct bt_clock_class *clock_class)
 593 {
 594         int ret;
 595
 596         if (trace->is_static) {
 597                 BT_LOGW("Invalid parameter: trace is static: "
 598                         "addr=%p, name=\"%s\"",
 599                         trace, bt_trace_get_name(trace));
 600                 ret = -1;
 601                 goto end;
 602         }
 603
 604         ret = bt_trace_common_add_clock_class(BT_TO_COMMON(trace),
 605                 clock_class);
 606
 607 end:
 608         return ret;
 609 }
 610
 611 int64_t bt_trace_get_clock_class_count(struct bt_trace *trace)
 612 {
 613         return bt_trace_common_get_clock_class_count(BT_TO_COMMON(trace));
 614 }
 615
 616 struct bt_clock_class *bt_trace_borrow_clock_class_by_index(
 617                 struct bt_trace *trace, uint64_t index)
 618 {
 619         return bt_trace_common_borrow_clock_class_by_index(
 620                 BT_TO_COMMON(trace), index);
 621 }
 622
 623 static
 624 bool packet_header_field_type_is_valid(struct bt_trace_common *trace,
 625                 struct bt_field_type_common *packet_header_type)
 626 {
 627         int ret;
 628         bool is_valid = true;
 629         struct bt_field_type_common *field_type = NULL;
 630
 631         if (!packet_header_type) {
 632                 /*
 633                  * No packet header field type: trace must have only
 634                  * one stream. At this point the stream class being
 635                  * added is not part of the trace yet, so we validate
 636                  * that the trace contains no stream classes yet.
 637                  */
 638                 if (trace->stream_classes->len >= 1) {
 639                         BT_LOGW_STR("Invalid packet header field type: "
 640                                 "packet header field type does not exist but there's more than one stream class in the trace.");
 641                         goto invalid;
 642                 }
 643
 644                 /* No packet header field type: valid at this point */
 645                 goto end;
 646         }
 647
 648         /* Packet header field type, if it exists, must be a structure */
 649         if (packet_header_type->id != BT_FIELD_TYPE_ID_STRUCT) {
 650                 BT_LOGW("Invalid packet header field type: must be a structure field type if it exists: "
 651                         "ft-addr=%p, ft-id=%s",
 652                         packet_header_type,
 653                         bt_common_field_type_id_string(packet_header_type->id));
 654                 goto invalid;
 655         }
 656
 657         /*
 658          * If there's a `magic` field, it must be a 32-bit unsigned
 659          * integer field type. Also it must be the first field of the
 660          * packet header field type.
 661          */
 662         field_type = bt_field_type_common_structure_borrow_field_type_by_name(
 663                 packet_header_type, "magic");
 664         if (field_type) {
 665                 const char *field_name;
 666
 667                 if (field_type->id != BT_FIELD_TYPE_ID_INTEGER) {
 668                         BT_LOGW("Invalid packet header field type: `magic` field must be an integer field type: "
 669                                 "magic-ft-addr=%p, magic-ft-id=%s",
 670                                 field_type,
 671                                 bt_common_field_type_id_string(field_type->id));
 672                         goto invalid;
 673                 }
 674
 675                 if (bt_field_type_common_integer_is_signed(field_type)) {
 676                         BT_LOGW("Invalid packet header field type: `magic` field must be an unsigned integer field type: "
 677                                 "magic-ft-addr=%p", field_type);
 678                         goto invalid;
 679                 }
 680
 681                 if (bt_field_type_common_integer_get_size(field_type) != 32) {
 682                         BT_LOGW("Invalid packet header field type: `magic` field must be a 32-bit unsigned integer field type: "
 683                                 "magic-ft-addr=%p, magic-ft-size=%u",
 684                                 field_type,
 685                                 bt_field_type_common_integer_get_size(field_type));
 686                         goto invalid;
 687                 }
 688
 689                 ret = bt_field_type_common_structure_borrow_field_by_index(
 690                         packet_header_type, &field_name, NULL, 0);
 691                 BT_ASSERT(ret == 0);
 692
 693                 if (strcmp(field_name, "magic") != 0) {
 694                         BT_LOGW("Invalid packet header field type: `magic` field must be the first field: "
 695                                 "magic-ft-addr=%p, first-field-name=\"%s\"",
 696                                 field_type, field_name);
 697                         goto invalid;
 698                 }
 699         }
 700
 701         /*
 702          * If there's a `uuid` field, it must be an array field type of
 703          * length 16 with an 8-bit unsigned integer element field type.
 704          */
 705         field_type = bt_field_type_common_structure_borrow_field_type_by_name(
 706                 packet_header_type, "uuid");
 707         if (field_type) {
 708                 struct bt_field_type_common *elem_ft;
 709
 710                 if (field_type->id != BT_FIELD_TYPE_ID_ARRAY) {
 711                         BT_LOGW("Invalid packet header field type: `uuid` field must be an array field type: "
 712                                 "uuid-ft-addr=%p, uuid-ft-id=%s",
 713                                 field_type,
 714                                 bt_common_field_type_id_string(field_type->id));
 715                         goto invalid;
 716                 }
 717
 718                 if (bt_field_type_common_array_get_length(field_type) != 16) {
 719                         BT_LOGW("Invalid packet header field type: `uuid` array field type's length must be 16: "
 720                                 "uuid-ft-addr=%p, uuid-ft-length=%" PRId64,
 721                                 field_type,
 722                                 bt_field_type_common_array_get_length(field_type));
 723                         goto invalid;
 724                 }
 725
 726                 elem_ft = bt_field_type_common_array_borrow_element_field_type(field_type);
 727                 BT_ASSERT(elem_ft);
 728
 729                 if (elem_ft->id != BT_FIELD_TYPE_ID_INTEGER) {
 730                         BT_LOGW("Invalid packet header field type: `uuid` field's element field type must be an integer field type: "
 731                                 "elem-ft-addr=%p, elem-ft-id=%s",
 732                                 elem_ft,
 733                                 bt_common_field_type_id_string(elem_ft->id));
 734                         goto invalid;
 735                 }
 736
 737                 if (bt_field_type_common_integer_is_signed(elem_ft)) {
 738                         BT_LOGW("Invalid packet header field type: `uuid` field's element field type must be an unsigned integer field type: "
 739                                 "elem-ft-addr=%p", elem_ft);
 740                         goto invalid;
 741                 }
 742
 743                 if (bt_field_type_common_integer_get_size(elem_ft) != 8) {
 744                         BT_LOGW("Invalid packet header field type: `uuid` field's element field type must be an 8-bit unsigned integer field type: "
 745                                 "elem-ft-addr=%p, elem-ft-size=%u",
 746                                 elem_ft,
 747                                 bt_field_type_common_integer_get_size(elem_ft));
 748                         goto invalid;
 749                 }
 750         }
 751
 752         /*
 753          * The `stream_id` field must exist if there's more than one
 754          * stream classes in the trace.
 755          */
 756         field_type = bt_field_type_common_structure_borrow_field_type_by_name(
 757                 packet_header_type, "stream_id");
 758
 759         if (!field_type && trace->stream_classes->len >= 1) {
 760                 BT_LOGW_STR("Invalid packet header field type: "
 761                         "`stream_id` field does not exist but there's more than one stream class in the trace.");
 762                 goto invalid;
 763         }
 764
 765         /*
 766          * If there's a `stream_id` field, it must be an unsigned
 767          * integer field type.
 768          */
 769         if (field_type) {
 770                 if (field_type->id != BT_FIELD_TYPE_ID_INTEGER) {
 771                         BT_LOGW("Invalid packet header field type: `stream_id` field must be an integer field type: "
 772                                 "stream-id-ft-addr=%p, stream-id-ft-id=%s",
 773                                 field_type,
 774                                 bt_common_field_type_id_string(field_type->id));
 775                         goto invalid;
 776                 }
 777
 778                 if (bt_field_type_common_integer_is_signed(field_type)) {
 779                         BT_LOGW("Invalid packet header field type: `stream_id` field must be an unsigned integer field type: "
 780                                 "stream-id-ft-addr=%p", field_type);
 781                         goto invalid;
 782                 }
 783         }
 784
 785         /*
 786          * If there's a `packet_seq_num` field, it must be an unsigned
 787          * integer field type.
 788          */
 789         field_type = bt_field_type_common_structure_borrow_field_type_by_name(
 790                 packet_header_type, "packet_seq_num");
 791         if (field_type) {
 792                 if (field_type->id != BT_FIELD_TYPE_ID_INTEGER) {
 793                         BT_LOGW("Invalid packet header field type: `packet_seq_num` field must be an integer field type: "
 794                                 "stream-id-ft-addr=%p, packet-seq-num-ft-id=%s",
 795                                 field_type,
 796                                 bt_common_field_type_id_string(field_type->id));
 797                         goto invalid;
 798                 }
 799
 800                 if (bt_field_type_common_integer_is_signed(field_type)) {
 801                         BT_LOGW("Invalid packet header field type: `packet_seq_num` field must be an unsigned integer field type: "
 802                                 "packet-seq-num-ft-addr=%p", field_type);
 803                         goto invalid;
 804                 }
 805         }
 806
 807         goto end;
 808
 809 invalid:
 810         is_valid = false;
 811
 812 end:
 813         return is_valid;
 814 }
 815
 816 static
 817 bool packet_context_field_type_is_valid(struct bt_trace_common *trace,
 818                 struct bt_stream_class_common *stream_class,
 819                 struct bt_field_type_common *packet_context_type,
 820                 bool check_ts_begin_end_mapped)
 821 {
 822         bool is_valid = true;
 823         struct bt_field_type_common *field_type = NULL;
 824
 825         if (!packet_context_type) {
 826                 /* No packet context field type: valid at this point */
 827                 goto end;
 828         }
 829
 830         /* Packet context field type, if it exists, must be a structure */
 831         if (packet_context_type->id != BT_FIELD_TYPE_ID_STRUCT) {
 832                 BT_LOGW("Invalid packet context field type: must be a structure field type if it exists: "
 833                         "ft-addr=%p, ft-id=%s",
 834                         packet_context_type,
 835                         bt_common_field_type_id_string(packet_context_type->id));
 836                 goto invalid;
 837         }
 838
 839         /*
 840          * If there's a `packet_size` field, it must be an unsigned
 841          * integer field type.
 842          */
 843         field_type = bt_field_type_common_structure_borrow_field_type_by_name(
 844                 packet_context_type, "packet_size");
 845         if (field_type) {
 846                 if (field_type->id != BT_FIELD_TYPE_ID_INTEGER) {
 847                         BT_LOGW("Invalid packet context field type: `packet_size` field must be an integer field type: "
 848                                 "packet-size-ft-addr=%p, packet-size-ft-id=%s",
 849                                 field_type,
 850                                 bt_common_field_type_id_string(field_type->id));
 851                         goto invalid;
 852                 }
 853
 854                 if (bt_field_type_common_integer_is_signed(field_type)) {
 855                         BT_LOGW("Invalid packet context field type: `packet_size` field must be an unsigned integer field type: "
 856                                 "packet-size-ft-addr=%p", field_type);
 857                         goto invalid;
 858                 }
 859         }
 860
 861         /*
 862          * If there's a `content_size` field, it must be an unsigned
 863          * integer field type.
 864          */
 865         field_type = bt_field_type_common_structure_borrow_field_type_by_name(
 866                 packet_context_type, "content_size");
 867         if (field_type) {
 868                 if (field_type->id != BT_FIELD_TYPE_ID_INTEGER) {
 869                         BT_LOGW("Invalid packet context field type: `content_size` field must be an integer field type: "
 870                                 "content-size-ft-addr=%p, content-size-ft-id=%s",
 871                                 field_type,
 872                                 bt_common_field_type_id_string(field_type->id));
 873                         goto invalid;
 874                 }
 875
 876                 if (bt_field_type_common_integer_is_signed(field_type)) {
 877                         BT_LOGW("Invalid packet context field type: `content_size` field must be an unsigned integer field type: "
 878                                 "content-size-ft-addr=%p", field_type);
 879                         goto invalid;
 880                 }
 881         }
 882
 883         /*
 884          * If there's a `events_discarded` field, it must be an unsigned
 885          * integer field type.
 886          */
 887         field_type = bt_field_type_common_structure_borrow_field_type_by_name(
 888                 packet_context_type, "events_discarded");
 889         if (field_type) {
 890                 if (field_type->id != BT_FIELD_TYPE_ID_INTEGER) {
 891                         BT_LOGW("Invalid packet context field type: `events_discarded` field must be an integer field type: "
 892                                 "events-discarded-ft-addr=%p, events-discarded-ft-id=%s",
 893                                 field_type,
 894                                 bt_common_field_type_id_string(field_type->id));
 895                         goto invalid;
 896                 }
 897
 898                 if (bt_field_type_common_integer_is_signed(field_type)) {
 899                         BT_LOGW("Invalid packet context field type: `events_discarded` field must be an unsigned integer field type: "
 900                                 "events-discarded-ft-addr=%p", field_type);
 901                         goto invalid;
 902                 }
 903         }
 904
 905         /*
 906          * If there's a `timestamp_begin` field, it must be an unsigned
 907          * integer field type. Also, if the trace is not a CTF writer's
 908          * trace, then we cannot automatically set the mapped clock
 909          * class of this field, so it must have a mapped clock class.
 910          */
 911         field_type = bt_field_type_common_structure_borrow_field_type_by_name(
 912                 packet_context_type, "timestamp_begin");
 913         if (field_type) {
 914                 if (field_type->id != BT_FIELD_TYPE_ID_INTEGER) {
 915                         BT_LOGW("Invalid packet context field type: `timestamp_begin` field must be an integer field type: "
 916                                 "timestamp-begin-ft-addr=%p, timestamp-begin-ft-id=%s",
 917                                 field_type,
 918                                 bt_common_field_type_id_string(field_type->id));
 919                         goto invalid;
 920                 }
 921
 922                 if (bt_field_type_common_integer_is_signed(field_type)) {
 923                         BT_LOGW("Invalid packet context field type: `timestamp_begin` field must be an unsigned integer field type: "
 924                                 "timestamp-begin-ft-addr=%p", field_type);
 925                         goto invalid;
 926                 }
 927
 928                 if (check_ts_begin_end_mapped) {
 929                         struct bt_clock_class *clock_class =
 930                                 bt_field_type_common_integer_borrow_mapped_clock_class(
 931                                         field_type);
 932
 933                         if (!clock_class) {
 934                                 BT_LOGW("Invalid packet context field type: `timestamp_begin` field must be mapped to a clock class: "
 935                                         "timestamp-begin-ft-addr=%p", field_type);
 936                                 goto invalid;
 937                         }
 938                 }
 939         }
 940
 941         /*
 942          * If there's a `timestamp_end` field, it must be an unsigned
 943          * integer field type. Also, if the trace is not a CTF writer's
 944          * trace, then we cannot automatically set the mapped clock
 945          * class of this field, so it must have a mapped clock class.
 946          */
 947         field_type = bt_field_type_common_structure_borrow_field_type_by_name(
 948                 packet_context_type, "timestamp_end");
 949         if (field_type) {
 950                 if (field_type->id != BT_FIELD_TYPE_ID_INTEGER) {
 951                         BT_LOGW("Invalid packet context field type: `timestamp_end` field must be an integer field type: "
 952                                 "timestamp-end-ft-addr=%p, timestamp-end-ft-id=%s",
 953                                 field_type,
 954                                 bt_common_field_type_id_string(field_type->id));
 955                         goto invalid;
 956                 }
 957
 958                 if (bt_field_type_common_integer_is_signed(field_type)) {
 959                         BT_LOGW("Invalid packet context field type: `timestamp_end` field must be an unsigned integer field type: "
 960                                 "timestamp-end-ft-addr=%p", field_type);
 961                         goto invalid;
 962                 }
 963
 964                 if (check_ts_begin_end_mapped) {
 965                         struct bt_clock_class *clock_class =
 966                                 bt_field_type_common_integer_borrow_mapped_clock_class(
 967                                         field_type);
 968
 969                         if (!clock_class) {
 970                                 BT_LOGW("Invalid packet context field type: `timestamp_end` field must be mapped to a clock class: "
 971                                         "timestamp-end-ft-addr=%p", field_type);
 972                                 goto invalid;
 973                         }
 974                 }
 975         }
 976
 977         goto end;
 978
 979 invalid:
 980         is_valid = false;
 981
 982 end:
 983         return is_valid;
 984 }
 985
 986 static
 987 bool event_header_field_type_is_valid(struct bt_trace_common *trace,
 988                 struct bt_stream_class_common *stream_class,
 989                 struct bt_field_type_common *event_header_type)
 990 {
 991         bool is_valid = true;
 992         struct bt_field_type_common *field_type = NULL;
 993
 994         /*
 995          * We do not validate that the `timestamp` field exists here
 996          * because CTF does not require this exact name to be mapped to
 997          * a clock class.
 998          */
 999
1000         if (!event_header_type) {
1001                 /*
1002                  * No event header field type: stream class must have
1003                  * only one event class.
1004                  */
1005                 if (bt_stream_class_common_get_event_class_count(stream_class) > 1) {
1006                         BT_LOGW_STR("Invalid event header field type: "
1007                                 "event header field type does not exist but there's more than one event class in the stream class.");
1008                         goto invalid;
1009                 }
1010
1011                 /* No event header field type: valid at this point */
1012                 goto end;
1013         }
1014
1015         /* Event header field type, if it exists, must be a structure */
1016         if (event_header_type->id != BT_FIELD_TYPE_ID_STRUCT) {
1017                 BT_LOGW("Invalid event header field type: must be a structure field type if it exists: "
1018                         "ft-addr=%p, ft-id=%s",
1019                         event_header_type,
1020                         bt_common_field_type_id_string(event_header_type->id));
1021                 goto invalid;
1022         }
1023
1024         /*
1025          * If there's an `id` field, it must be an unsigned integer
1026          * field type or an enumeration field type with an unsigned
1027          * integer container field type.
1028          */
1029         field_type = bt_field_type_common_structure_borrow_field_type_by_name(
1030                 event_header_type, "id");
1031         if (field_type) {
1032                 struct bt_field_type_common *int_ft;
1033
1034                 if (field_type->id == BT_FIELD_TYPE_ID_INTEGER) {
1035                         int_ft = field_type;
1036                 } else if (field_type->id == BT_FIELD_TYPE_ID_ENUM) {
1037                         int_ft = bt_field_type_common_enumeration_borrow_container_field_type(
1038                                 field_type);
1039                 } else {
1040                         BT_LOGW("Invalid event header field type: `id` field must be an integer or enumeration field type: "
1041                                 "id-ft-addr=%p, id-ft-id=%s",
1042                                 field_type,
1043                                 bt_common_field_type_id_string(field_type->id));
1044                         goto invalid;
1045                 }
1046
1047                 BT_ASSERT(int_ft);
1048                 if (bt_field_type_common_integer_is_signed(int_ft)) {
1049                         BT_LOGW("Invalid event header field type: `id` field must be an unsigned integer or enumeration field type: "
1050                                 "id-ft-addr=%p", int_ft);
1051                         goto invalid;
1052                 }
1053         }
1054
1055         goto end;
1056
1057 invalid:
1058         is_valid = false;
1059
1060 end:
1061         return is_valid;
1062 }
1063
1064 static
1065 int check_packet_header_type_has_no_clock_class(struct bt_trace_common *trace)
1066 {
1067         int ret = 0;
1068
1069         if (trace->packet_header_field_type) {
1070                 struct bt_clock_class *clock_class = NULL;
1071
1072                 ret = bt_field_type_common_validate_single_clock_class(
1073                         trace->packet_header_field_type,
1074                         &clock_class);
1075                 bt_put(clock_class);
1076                 if (ret || clock_class) {
1077                         BT_LOGW("Trace's packet header field type cannot "
1078                                 "contain a field type which is mapped to "
1079                                 "a clock class: "
1080                                 "trace-addr=%p, trace-name=\"%s\", "
1081                                 "clock-class-name=\"%s\"",
1082                                 trace, bt_trace_common_get_name(trace),
1083                                 clock_class ?
1084                                         bt_clock_class_get_name(clock_class) :
1085                                         NULL);
1086                         ret = -1;
1087                 }
1088         }
1089
1090         return ret;
1091 }
1092
1093 BT_HIDDEN
1094 int bt_trace_common_add_stream_class(struct bt_trace_common *trace,
1095                 struct bt_stream_class_common *stream_class,
1096                 bt_validation_flag_copy_field_type_func copy_field_type_func,
1097                 struct bt_clock_class *init_expected_clock_class,
1098                 int (*map_clock_classes_func)(struct bt_stream_class_common *stream_class,
1099                         struct bt_field_type_common *packet_context_field_type,
1100                         struct bt_field_type_common *event_header_field_type),
1101                 bool check_ts_begin_end_mapped)
1102 {
1103         int ret;
1104         int64_t i;
1105         int64_t stream_id;
1106         struct bt_validation_output trace_sc_validation_output = { 0 };
1107         struct bt_validation_output *ec_validation_outputs = NULL;
1108         const enum bt_validation_flag trace_sc_validation_flags =
1109                 BT_VALIDATION_FLAG_TRACE |
1110                 BT_VALIDATION_FLAG_STREAM;
1111         const enum bt_validation_flag ec_validation_flags =
1112                 BT_VALIDATION_FLAG_EVENT;
1113         struct bt_field_type_common *packet_header_type = NULL;
1114         struct bt_field_type_common *packet_context_type = NULL;
1115         struct bt_field_type_common *event_header_type = NULL;
1116         struct bt_field_type_common *stream_event_ctx_type = NULL;
1117         int64_t event_class_count;
1118         struct bt_trace_common *current_parent_trace = NULL;
1119         struct bt_clock_class *expected_clock_class =
1120                 bt_get(init_expected_clock_class);
1121
1122         BT_ASSERT(copy_field_type_func);
1123
1124         if (!trace) {
1125                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1126                 ret = -1;
1127                 goto end;
1128         }
1129
1130         if (!stream_class) {
1131                 BT_LOGW_STR("Invalid parameter: stream class is NULL.");
1132                 ret = -1;
1133                 goto end;
1134         }
1135
1136         BT_LOGD("Adding stream class to trace: "
1137                 "trace-addr=%p, trace-name=\"%s\", "
1138                 "stream-class-addr=%p, stream-class-name=\"%s\", "
1139                 "stream-class-id=%" PRId64,
1140                 trace, bt_trace_common_get_name(trace),
1141                 stream_class, bt_stream_class_common_get_name(stream_class),
1142                 bt_stream_class_common_get_id(stream_class));
1143
1144         current_parent_trace = bt_stream_class_common_borrow_trace(stream_class);
1145         if (current_parent_trace) {
1146                 /* Stream class is already associated to a trace, abort. */
1147                 BT_LOGW("Invalid parameter: stream class is already part of a trace: "
1148                         "stream-class-trace-addr=%p, "
1149                         "stream-class-trace-name=\"%s\"",
1150                         current_parent_trace,
1151                         bt_trace_common_get_name(current_parent_trace));
1152                 ret = -1;
1153                 goto end;
1154         }
1155
1156         event_class_count =
1157                 bt_stream_class_common_get_event_class_count(stream_class);
1158         BT_ASSERT(event_class_count >= 0);
1159
1160         if (!stream_class->frozen) {
1161                 /*
1162                  * Stream class is not frozen yet. Validate that the
1163                  * stream class contains at most a single clock class
1164                  * because the previous
1165                  * bt_stream_class_common_add_event_class() calls did
1166                  * not make this validation since the stream class's
1167                  * direct field types (packet context, event header,
1168                  * event context) could change afterwards. This stream
1169                  * class is about to be frozen and those field types
1170                  * won't be changed if this function succeeds.
1171                  *
1172                  * At this point we're also sure that the stream class's
1173                  * clock, if any, has the same class as the stream
1174                  * class's expected clock class, if any. This is why, if
1175                  * bt_stream_class_common_validate_single_clock_class()
1176                  * succeeds below, the call to
1177                  * bt_stream_class_map_clock_class() at the end of this
1178                  * function is safe because it maps to the same, single
1179                  * clock class.
1180                  */
1181                 ret = bt_stream_class_common_validate_single_clock_class(
1182                         stream_class, &expected_clock_class);
1183                 if (ret) {
1184                         BT_LOGW("Invalid parameter: stream class or one of its "
1185                                 "event classes contains a field type which is "
1186                                 "not recursively mapped to the expected "
1187                                 "clock class: "
1188                                 "stream-class-addr=%p, "
1189                                 "stream-class-id=%" PRId64 ", "
1190                                 "stream-class-name=\"%s\", "
1191                                 "expected-clock-class-addr=%p, "
1192                                 "expected-clock-class-name=\"%s\"",
1193                                 stream_class, bt_stream_class_common_get_id(stream_class),
1194                                 bt_stream_class_common_get_name(stream_class),
1195                                 expected_clock_class,
1196                                 expected_clock_class ?
1197                                         bt_clock_class_get_name(expected_clock_class) :
1198                                         NULL);
1199                         goto end;
1200                 }
1201         }
1202
1203         ret = check_packet_header_type_has_no_clock_class(trace);
1204         if (ret) {
1205                 /* check_packet_header_type_has_no_clock_class() logs errors */
1206                 goto end;
1207         }
1208
1209         /*
1210          * We're about to freeze both the trace and the stream class.
1211          * Also, each event class contained in this stream class are
1212          * already frozen.
1213          *
1214          * This trace, this stream class, and all its event classes
1215          * should be valid at this point.
1216          *
1217          * Validate trace and stream class first, then each event
1218          * class of this stream class can be validated individually.
1219          */
1220         packet_header_type =
1221                 bt_trace_common_borrow_packet_header_field_type(trace);
1222         packet_context_type =
1223                 bt_stream_class_common_borrow_packet_context_field_type(stream_class);
1224         event_header_type =
1225                 bt_stream_class_common_borrow_event_header_field_type(stream_class);
1226         stream_event_ctx_type =
1227                 bt_stream_class_common_borrow_event_context_field_type(stream_class);
1228
1229         BT_LOGD("Validating trace and stream class field types.");
1230         ret = bt_validate_class_types(trace->environment,
1231                 packet_header_type, packet_context_type, event_header_type,
1232                 stream_event_ctx_type, NULL, NULL, trace->valid,
1233                 stream_class->valid, 1, &trace_sc_validation_output,
1234                 trace_sc_validation_flags, copy_field_type_func);
1235
1236         if (ret) {
1237                 /*
1238                  * This means something went wrong during the validation
1239                  * process, not that the objects are invalid.
1240                  */
1241                 BT_LOGE("Failed to validate trace and stream class field types: "
1242                         "ret=%d", ret);
1243                 goto end;
1244         }
1245
1246         if ((trace_sc_validation_output.valid_flags &
1247                         trace_sc_validation_flags) !=
1248                         trace_sc_validation_flags) {
1249                 /* Invalid trace/stream class */
1250                 BT_LOGW("Invalid trace or stream class field types: "
1251                         "valid-flags=0x%x",
1252                         trace_sc_validation_output.valid_flags);
1253                 ret = -1;
1254                 goto end;
1255         }
1256
1257         if (event_class_count > 0) {
1258                 ec_validation_outputs = g_new0(struct bt_validation_output,
1259                         event_class_count);
1260                 if (!ec_validation_outputs) {
1261                         BT_LOGE_STR("Failed to allocate one validation output structure.");
1262                         ret = -1;
1263                         goto end;
1264                 }
1265         }
1266
1267         /* Validate each event class individually */
1268         for (i = 0; i < event_class_count; i++) {
1269                 struct bt_event_class_common *event_class =
1270                         bt_stream_class_common_borrow_event_class_by_index(
1271                                 stream_class, i);
1272                 struct bt_field_type_common *event_context_type = NULL;
1273                 struct bt_field_type_common *event_payload_type = NULL;
1274
1275                 event_context_type =
1276                         bt_event_class_common_borrow_context_field_type(
1277                                 event_class);
1278                 event_payload_type =
1279                         bt_event_class_common_borrow_payload_field_type(
1280                                 event_class);
1281
1282                 /*
1283                  * It is important to use the field types returned by
1284                  * the previous trace and stream class validation here
1285                  * because copies could have been made.
1286                  */
1287                 BT_LOGD("Validating event class's field types: "
1288                         "addr=%p, name=\"%s\", id=%" PRId64,
1289                         event_class, bt_event_class_common_get_name(event_class),
1290                         bt_event_class_common_get_id(event_class));
1291                 ret = bt_validate_class_types(trace->environment,
1292                         trace_sc_validation_output.packet_header_type,
1293                         trace_sc_validation_output.packet_context_type,
1294                         trace_sc_validation_output.event_header_type,
1295                         trace_sc_validation_output.stream_event_ctx_type,
1296                         event_context_type, event_payload_type,
1297                         1, 1, event_class->valid, &ec_validation_outputs[i],
1298                         ec_validation_flags, copy_field_type_func);
1299
1300                 if (ret) {
1301                         BT_LOGE("Failed to validate event class field types: "
1302                                 "ret=%d", ret);
1303                         goto end;
1304                 }
1305
1306                 if ((ec_validation_outputs[i].valid_flags &
1307                                 ec_validation_flags) != ec_validation_flags) {
1308                         /* Invalid event class */
1309                         BT_LOGW("Invalid event class field types: "
1310                                 "valid-flags=0x%x",
1311                                 ec_validation_outputs[i].valid_flags);
1312                         ret = -1;
1313                         goto end;
1314                 }
1315         }
1316
1317         stream_id = bt_stream_class_common_get_id(stream_class);
1318         if (stream_id < 0) {
1319                 stream_id = trace->next_stream_id++;
1320                 if (stream_id < 0) {
1321                         BT_LOGE_STR("No more stream class IDs available.");
1322                         ret = -1;
1323                         goto end;
1324                 }
1325
1326                 /* Try to assign a new stream id */
1327                 for (i = 0; i < trace->stream_classes->len; i++) {
1328                         if (stream_id == bt_stream_class_common_get_id(
1329                                 trace->stream_classes->pdata[i])) {
1330                                 /* Duplicate stream id found */
1331                                 BT_LOGW("Duplicate stream class ID: "
1332                                         "id=%" PRId64, (int64_t) stream_id);
1333                                 ret = -1;
1334                                 goto end;
1335                         }
1336                 }
1337
1338                 if (bt_stream_class_common_set_id_no_check(stream_class,
1339                                 stream_id)) {
1340                         /* TODO Should retry with a different stream id */
1341                         BT_LOGE("Cannot set stream class's ID: "
1342                                 "id=%" PRId64, (int64_t) stream_id);
1343                         ret = -1;
1344                         goto end;
1345                 }
1346         }
1347
1348         /*
1349          * At this point all the field types in the validation output
1350          * are valid. Validate the semantics of some scopes according to
1351          * the CTF specification.
1352          */
1353         if (!packet_header_field_type_is_valid(trace,
1354                         trace_sc_validation_output.packet_header_type)) {
1355                 BT_LOGW_STR("Invalid trace's packet header field type.");
1356                 ret = -1;
1357                 goto end;
1358         }
1359
1360         if (!packet_context_field_type_is_valid(trace,
1361                         stream_class,
1362                         trace_sc_validation_output.packet_context_type,
1363                         check_ts_begin_end_mapped)) {
1364                 BT_LOGW_STR("Invalid stream class's packet context field type.");
1365                 ret = -1;
1366                 goto end;
1367         }
1368
1369         if (!event_header_field_type_is_valid(trace,
1370                         stream_class,
1371                         trace_sc_validation_output.event_header_type)) {
1372                 BT_LOGW_STR("Invalid steam class's event header field type.");
1373                 ret = -1;
1374                 goto end;
1375         }
1376
1377         /*
1378          * Now is the time to automatically map specific field types of
1379          * the stream class's packet context and event header field
1380          * types to the stream class's clock's class if they are not
1381          * mapped to a clock class yet. We do it here because we know
1382          * that after this point, everything is frozen so it won't be
1383          * possible for the user to modify the stream class's clock, or
1384          * to map those field types to other clock classes.
1385          */
1386         if (map_clock_classes_func) {
1387                 if (map_clock_classes_func(stream_class,
1388                                 trace_sc_validation_output.packet_context_type,
1389                                 trace_sc_validation_output.event_header_type)) {
1390                         /* map_clock_classes_func() logs errors */
1391                         ret = -1;
1392                         goto end;
1393                 }
1394         }
1395
1396         bt_object_set_parent(stream_class, trace);
1397         g_ptr_array_add(trace->stream_classes, stream_class);
1398
1399         /*
1400          * At this point we know that the function will be successful.
1401          * Therefore we can replace the trace and stream class field
1402          * types with what's in their validation output structure and
1403          * mark them as valid. We can also replace the field types of
1404          * all the event classes of the stream class and mark them as
1405          * valid.
1406          */
1407         bt_validation_replace_types(trace, stream_class, NULL,
1408                 &trace_sc_validation_output, trace_sc_validation_flags);
1409         trace->valid = 1;
1410         stream_class->valid = 1;
1411
1412         /*
1413          * Put what was not moved in bt_validation_replace_types().
1414          */
1415         bt_validation_output_put_types(&trace_sc_validation_output);
1416
1417         for (i = 0; i < event_class_count; i++) {
1418                 struct bt_event_class_common *event_class =
1419                         bt_stream_class_common_borrow_event_class_by_index(
1420                                 stream_class, i);
1421
1422                 bt_validation_replace_types(NULL, NULL, event_class,
1423                         &ec_validation_outputs[i], ec_validation_flags);
1424                 event_class->valid = 1;
1425
1426                 /*
1427                  * Put what was not moved in
1428                  * bt_validation_replace_types().
1429                  */
1430                 bt_validation_output_put_types(&ec_validation_outputs[i]);
1431         }
1432
1433         /*
1434          * Freeze the trace and the stream class.
1435          */
1436         bt_stream_class_common_freeze(stream_class);
1437         bt_trace_common_freeze(trace);
1438
1439         /*
1440          * It is safe to set the stream class's unique clock class
1441          * now because the stream class is frozen.
1442          */
1443         if (expected_clock_class) {
1444                 BT_MOVE(stream_class->clock_class, expected_clock_class);
1445         }
1446
1447         BT_LOGD("Added stream class to trace: "
1448                 "trace-addr=%p, trace-name=\"%s\", "
1449                 "stream-class-addr=%p, stream-class-name=\"%s\", "
1450                 "stream-class-id=%" PRId64,
1451                 trace, bt_trace_common_get_name(trace),
1452                 stream_class, bt_stream_class_common_get_name(stream_class),
1453                 bt_stream_class_common_get_id(stream_class));
1454
1455 end:
1456         if (ret) {
1457                 bt_object_set_parent(stream_class, NULL);
1458
1459                 if (ec_validation_outputs) {
1460                         for (i = 0; i < event_class_count; i++) {
1461                                 bt_validation_output_put_types(
1462                                         &ec_validation_outputs[i]);
1463                         }
1464                 }
1465         }
1466
1467         g_free(ec_validation_outputs);
1468         bt_validation_output_put_types(&trace_sc_validation_output);
1469         bt_put(expected_clock_class);
1470         return ret;
1471 }
1472
1473 int bt_trace_add_stream_class(struct bt_trace *trace,
1474                 struct bt_stream_class *stream_class)
1475 {
1476         int ret = 0;
1477
1478         if (!trace) {
1479                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1480                 ret = -1;
1481                 goto end;
1482         }
1483
1484         if (trace->is_static) {
1485                 BT_LOGW_STR("Invalid parameter: trace is static.");
1486                 ret = -1;
1487                 goto end;
1488         }
1489
1490         ret = bt_trace_common_add_stream_class(BT_TO_COMMON(trace),
1491                 BT_TO_COMMON(stream_class),
1492                 (bt_validation_flag_copy_field_type_func) bt_field_type_copy,
1493                 NULL, NULL, true);
1494         if (ret) {
1495                 goto end;
1496         }
1497
1498         /* Notifiy listeners of the trace's schema modification. */
1499         bt_stream_class_common_visit(BT_TO_COMMON(stream_class),
1500                         bt_trace_object_modification, trace);
1501
1502 end:
1503         return ret;
1504 }
1505
1506 int64_t bt_trace_get_stream_count(struct bt_trace *trace)
1507 {
1508         return bt_trace_common_get_stream_count(BT_TO_COMMON(trace));
1509 }
1510
1511 struct bt_stream *bt_trace_borrow_stream_by_index(
1512                 struct bt_trace *trace, uint64_t index)
1513 {
1514         return BT_FROM_COMMON(bt_trace_common_borrow_stream_by_index(
1515                 BT_TO_COMMON(trace), index));
1516 }
1517
1518 int64_t bt_trace_get_stream_class_count(struct bt_trace *trace)
1519 {
1520         return bt_trace_common_get_stream_class_count(BT_TO_COMMON(trace));
1521 }
1522
1523 struct bt_stream_class *bt_trace_borrow_stream_class_by_index(
1524                 struct bt_trace *trace, uint64_t index)
1525 {
1526         return BT_FROM_COMMON(bt_trace_common_borrow_stream_class_by_index(
1527                 BT_TO_COMMON(trace), index));
1528 }
1529
1530 struct bt_stream_class *bt_trace_borrow_stream_class_by_id(
1531                 struct bt_trace *trace, uint64_t id)
1532 {
1533         return BT_FROM_COMMON(
1534                 bt_trace_common_borrow_stream_class_by_id(
1535                         BT_TO_COMMON(trace), id));
1536 }
1537
1538 struct bt_clock_class *bt_trace_borrow_clock_class_by_name(
1539                 struct bt_trace *trace, const char *name)
1540 {
1541         return bt_trace_common_borrow_clock_class_by_name(BT_TO_COMMON(trace),
1542                 name);
1543 }
1544
1545 BT_HIDDEN
1546 bt_bool bt_trace_common_has_clock_class(struct bt_trace_common *trace,
1547                 struct bt_clock_class *clock_class)
1548 {
1549         struct search_query query = { .value = clock_class, .found = 0 };
1550
1551         BT_ASSERT(trace);
1552         BT_ASSERT(clock_class);
1553
1554         g_ptr_array_foreach(trace->clock_classes, value_exists, &query);
1555         return query.found;
1556 }
1557
1558 enum bt_byte_order bt_trace_get_native_byte_order(
1559                 struct bt_trace *trace)
1560 {
1561         return bt_trace_common_get_native_byte_order(BT_TO_COMMON(trace));
1562 }
1563
1564 BT_HIDDEN
1565 int bt_trace_common_set_native_byte_order(struct bt_trace_common *trace,
1566                 enum bt_byte_order byte_order, bool allow_unspecified)
1567 {
1568         int ret = 0;
1569
1570         if (!trace) {
1571                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1572                 ret = -1;
1573                 goto end;
1574         }
1575
1576         if (trace->frozen) {
1577                 BT_LOGW("Invalid parameter: trace is frozen: "
1578                         "addr=%p, name=\"%s\"",
1579                         trace, bt_trace_common_get_name(trace));
1580                 ret = -1;
1581                 goto end;
1582         }
1583
1584         if (byte_order == BT_BYTE_ORDER_UNSPECIFIED && !allow_unspecified) {
1585                 BT_LOGW("Invalid parameter: BT_BYTE_ORDER_UNSPECIFIED byte order is not allowed: "
1586                         "addr=%p, name=\"%s\"",
1587                         trace, bt_trace_common_get_name(trace));
1588                 ret = -1;
1589                 goto end;
1590         }
1591
1592         if (byte_order != BT_BYTE_ORDER_LITTLE_ENDIAN &&
1593                         byte_order != BT_BYTE_ORDER_BIG_ENDIAN &&
1594                         byte_order != BT_BYTE_ORDER_NETWORK) {
1595                 BT_LOGW("Invalid parameter: invalid byte order: "
1596                         "addr=%p, name=\"%s\", bo=%s",
1597                         trace, bt_trace_common_get_name(trace),
1598                         bt_common_byte_order_string(byte_order));
1599                 ret = -1;
1600                 goto end;
1601         }
1602
1603         trace->native_byte_order = byte_order;
1604         BT_LOGV("Set trace's native byte order: "
1605                 "addr=%p, name=\"%s\", bo=%s",
1606                 trace, bt_trace_common_get_name(trace),
1607                 bt_common_byte_order_string(byte_order));
1608
1609 end:
1610         return ret;
1611 }
1612
1613 int bt_trace_set_native_byte_order(struct bt_trace *trace,
1614                 enum bt_byte_order byte_order)
1615 {
1616         return bt_trace_common_set_native_byte_order(BT_TO_COMMON(trace),
1617                 byte_order, true);
1618 }
1619
1620 struct bt_field_type *bt_trace_borrow_packet_header_field_type(
1621                 struct bt_trace *trace)
1622 {
1623         return BT_FROM_COMMON(bt_trace_common_borrow_packet_header_field_type(
1624                 BT_TO_COMMON(trace)));
1625 }
1626
1627 BT_HIDDEN
1628 int bt_trace_common_set_packet_header_field_type(struct bt_trace_common *trace,
1629                 struct bt_field_type_common *packet_header_type)
1630 {
1631         int ret = 0;
1632
1633         if (!trace) {
1634                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1635                 ret = -1;
1636                 goto end;
1637         }
1638
1639         if (trace->frozen) {
1640                 BT_LOGW("Invalid parameter: trace is frozen: "
1641                         "addr=%p, name=\"%s\"",
1642                         trace, bt_trace_common_get_name(trace));
1643                 ret = -1;
1644                 goto end;
1645         }
1646
1647         /* packet_header_type must be a structure. */
1648         if (packet_header_type &&
1649                         packet_header_type->id != BT_FIELD_TYPE_ID_STRUCT) {
1650                 BT_LOGW("Invalid parameter: packet header field type must be a structure field type if it exists: "
1651                         "addr=%p, name=\"%s\", ft-addr=%p, ft-id=%s",
1652                         trace, bt_trace_common_get_name(trace),
1653                         packet_header_type,
1654                         bt_common_field_type_id_string(packet_header_type->id));
1655                 ret = -1;
1656                 goto end;
1657         }
1658
1659         bt_put(trace->packet_header_field_type);
1660         trace->packet_header_field_type = bt_get(packet_header_type);
1661         BT_LOGV("Set trace's packet header field type: "
1662                 "addr=%p, name=\"%s\", packet-context-ft-addr=%p",
1663                 trace, bt_trace_common_get_name(trace), packet_header_type);
1664 end:
1665         return ret;
1666 }
1667
1668 int bt_trace_set_packet_header_field_type(struct bt_trace *trace,
1669                 struct bt_field_type *packet_header_type)
1670 {
1671         return bt_trace_common_set_packet_header_field_type(BT_TO_COMMON(trace),
1672                 (void *) packet_header_type);
1673 }
1674
1675 static
1676 int64_t get_stream_class_count(void *element)
1677 {
1678         return bt_trace_get_stream_class_count(
1679                         (struct bt_trace *) element);
1680 }
1681
1682 static
1683 void *get_stream_class(void *element, int i)
1684 {
1685         return bt_trace_get_stream_class_by_index(
1686                         (struct bt_trace *) element, i);
1687 }
1688
1689 static
1690 int visit_stream_class(void *object, bt_visitor visitor,void *data)
1691 {
1692         return bt_stream_class_visit(object, visitor, data);
1693 }
1694
1695 int bt_trace_visit(struct bt_trace *trace,
1696                 bt_visitor visitor, void *data)
1697 {
1698         int ret;
1699         struct bt_visitor_object obj = {
1700                 .object = trace,
1701                 .type = BT_VISITOR_OBJECT_TYPE_TRACE
1702         };
1703
1704         if (!trace) {
1705                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1706                 ret = -1;
1707                 goto end;
1708         }
1709
1710         if (!visitor) {
1711                 BT_LOGW_STR("Invalid parameter: visitor is NULL.");
1712                 ret = -1;
1713                 goto end;
1714         }
1715
1716         BT_LOGV("Visiting trace: addr=%p, name=\"%s\"",
1717                 trace, bt_trace_get_name(trace));
1718         ret = visitor_helper(&obj, get_stream_class_count,
1719                         get_stream_class, visit_stream_class, visitor, data);
1720 end:
1721         return ret;
1722 }
1723
1724 static
1725 int invoke_listener(struct bt_visitor_object *object, void *data)
1726 {
1727         struct listener_wrapper *listener_wrapper = data;
1728
1729         listener_wrapper->listener(object, listener_wrapper->data);
1730         return 0;
1731 }
1732
1733 // TODO: add logging to this function once we use it internally.
1734 int bt_trace_add_listener(struct bt_trace *trace,
1735                 bt_listener_cb listener, void *listener_data)
1736 {
1737         int ret = 0;
1738         struct listener_wrapper *listener_wrapper =
1739                         g_new0(struct listener_wrapper, 1);
1740
1741         if (!trace || !listener || !listener_wrapper) {
1742                 ret = -1;
1743                 goto error;
1744         }
1745
1746         listener_wrapper->listener = listener;
1747         listener_wrapper->data = listener_data;
1748
1749         /* Visit the current schema. */
1750         ret = bt_trace_visit(trace, invoke_listener, listener_wrapper);
1751         if (ret) {
1752                 goto error;
1753         }
1754
1755         /*
1756          * Add listener to the array of callbacks which will be invoked on
1757          * schema changes.
1758          */
1759         g_ptr_array_add(trace->listeners, listener_wrapper);
1760         return ret;
1761 error:
1762         g_free(listener_wrapper);
1763         return ret;
1764 }
1765
1766 BT_HIDDEN
1767 int bt_trace_object_modification(struct bt_visitor_object *object,
1768                 void *trace_ptr)
1769 {
1770         size_t i;
1771         struct bt_trace *trace = trace_ptr;
1772
1773         BT_ASSERT(trace);
1774         BT_ASSERT(object);
1775
1776         if (trace->listeners->len == 0) {
1777                 goto end;
1778         }
1779
1780         for (i = 0; i < trace->listeners->len; i++) {
1781                 struct listener_wrapper *listener =
1782                                 g_ptr_array_index(trace->listeners, i);
1783
1784                 listener->listener(object, listener->data);
1785         }
1786 end:
1787         return 0;
1788 }
1789
1790 bt_bool bt_trace_is_static(struct bt_trace *trace)
1791 {
1792         BT_ASSERT_PRE_NON_NULL(trace, "Trace");
1793         return trace->is_static;
1794 }
1795
1796 int bt_trace_set_is_static(struct bt_trace *trace)
1797 {
1798         int ret = 0;
1799         size_t i;
1800
1801         if (!trace) {
1802                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1803                 ret = -1;
1804                 goto end;
1805         }
1806
1807         ret = check_packet_header_type_has_no_clock_class(BT_TO_COMMON(trace));
1808         if (ret) {
1809                 /* check_packet_header_type_has_no_clock_class() logs errors */
1810                 goto end;
1811         }
1812
1813         trace->is_static = BT_TRUE;
1814         bt_trace_common_freeze(BT_TO_COMMON(trace));
1815         BT_LOGV("Set trace static: addr=%p, name=\"%s\"",
1816                 trace, bt_trace_get_name(trace));
1817
1818         /* Call all the "trace is static" listeners */
1819         for (i = 0; i < trace->is_static_listeners->len; i++) {
1820                 struct bt_trace_is_static_listener_elem elem =
1821                         g_array_index(trace->is_static_listeners,
1822                                 struct bt_trace_is_static_listener_elem, i);
1823
1824                 if (elem.func) {
1825                         elem.func(trace, elem.data);
1826                 }
1827         }
1828
1829 end:
1830         return ret;
1831 }
1832
1833 int bt_trace_add_is_static_listener(struct bt_trace *trace,
1834                 bt_trace_is_static_listener listener,
1835                 bt_trace_listener_removed listener_removed, void *data)
1836 {
1837         int i;
1838         struct bt_trace_is_static_listener_elem new_elem = {
1839                 .func = listener,
1840                 .removed = listener_removed,
1841                 .data = data,
1842         };
1843
1844         if (!trace) {
1845                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1846                 i = -1;
1847                 goto end;
1848         }
1849
1850         if (!listener) {
1851                 BT_LOGW_STR("Invalid parameter: listener is NULL.");
1852                 i = -1;
1853                 goto end;
1854         }
1855
1856         if (trace->is_static) {
1857                 BT_LOGW("Invalid parameter: trace is already static: "
1858                         "addr=%p, name=\"%s\"",
1859                         trace, bt_trace_get_name(trace));
1860                 i = -1;
1861                 goto end;
1862         }
1863
1864         if (trace->in_remove_listener) {
1865                 BT_LOGW("Cannot call this function during the execution of a remove listener: "
1866                         "addr=%p, name=\"%s\"",
1867                         trace, bt_trace_get_name(trace));
1868                 i = -1;
1869                 goto end;
1870         }
1871
1872         /* Find the next available spot */
1873         for (i = 0; i < trace->is_static_listeners->len; i++) {
1874                 struct bt_trace_is_static_listener_elem elem =
1875                         g_array_index(trace->is_static_listeners,
1876                                 struct bt_trace_is_static_listener_elem, i);
1877
1878                 if (!elem.func) {
1879                         break;
1880                 }
1881         }
1882
1883         if (i == trace->is_static_listeners->len) {
1884                 g_array_append_val(trace->is_static_listeners, new_elem);
1885         } else {
1886                 g_array_insert_val(trace->is_static_listeners, i, new_elem);
1887         }
1888
1889         BT_LOGV("Added \"trace is static\" listener: "
1890                 "trace-addr=%p, trace-name=\"%s\", func-addr=%p, "
1891                 "data-addr=%p, listener-id=%d",
1892                 trace, bt_trace_get_name(trace), listener, data, i);
1893
1894 end:
1895         return i;
1896 }
1897
1898 int bt_trace_remove_is_static_listener(
1899                 struct bt_trace *trace, int listener_id)
1900 {
1901         int ret = 0;
1902         struct bt_trace_is_static_listener_elem *elem;
1903
1904         if (!trace) {
1905                 BT_LOGW_STR("Invalid parameter: trace is NULL.");
1906                 ret = -1;
1907                 goto end;
1908         }
1909
1910         if (trace->in_remove_listener) {
1911                 BT_LOGW("Cannot call this function during the execution of a remove listener: "
1912                         "addr=%p, name=\"%s\", listener-id=%d",
1913                         trace, bt_trace_get_name(trace),
1914                         listener_id);
1915                 ret = -1;
1916                 goto end;
1917         }
1918
1919         if (listener_id < 0) {
1920                 BT_LOGW("Invalid listener ID: must be zero or positive: "
1921                         "listener-id=%d", listener_id);
1922                 ret = -1;
1923                 goto end;
1924         }
1925
1926         if (listener_id >= trace->is_static_listeners->len) {
1927                 BT_LOGW("Invalid parameter: no listener with this listener ID: "
1928                         "addr=%p, name=\"%s\", listener-id=%d",
1929                         trace, bt_trace_get_name(trace),
1930                         listener_id);
1931                 ret = -1;
1932                 goto end;
1933         }
1934
1935         elem = &g_array_index(trace->is_static_listeners,
1936                         struct bt_trace_is_static_listener_elem,
1937                         listener_id);
1938         if (!elem->func) {
1939                 BT_LOGW("Invalid parameter: no listener with this listener ID: "
1940                         "addr=%p, name=\"%s\", listener-id=%d",
1941                         trace, bt_trace_get_name(trace),
1942                         listener_id);
1943                 ret = -1;
1944                 goto end;
1945         }
1946
1947         if (elem->removed) {
1948                 /* Call remove listener */
1949                 BT_LOGV("Calling remove listener: "
1950                         "trace-addr=%p, trace-name=\"%s\", "
1951                         "listener-id=%d", trace, bt_trace_get_name(trace),
1952                         listener_id);
1953                 trace->in_remove_listener = BT_TRUE;
1954                 elem->removed(trace, elem->data);
1955                 trace->in_remove_listener = BT_FALSE;
1956         }
1957
1958         elem->func = NULL;
1959         elem->removed = NULL;
1960         elem->data = NULL;
1961         BT_LOGV("Removed \"trace is static\" listener: "
1962                 "trace-addr=%p, trace-name=\"%s\", "
1963                 "listener-id=%d", trace, bt_trace_get_name(trace),
1964                 listener_id);
1965
1966 end:
1967         return ret;
1968 }