lib/ctf-ir/stream.c

   1 /*
   2  * stream.c
   3  *
   4  * Babeltrace CTF IR - Stream
   5  *
   6  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  *
   8  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  */
  28
  29 #define BT_LOG_TAG "STREAM"
  30 #include <babeltrace/lib-logging-internal.h>
  31
  32 #include <babeltrace/ctf-ir/clock-class.h>
  33 #include <babeltrace/ctf-writer/clock.h>
  34 #include <babeltrace/ctf-writer/clock-internal.h>
  35 #include <babeltrace/ctf-writer/event.h>
  36 #include <babeltrace/ctf-ir/event-internal.h>
  37 #include <babeltrace/ctf-ir/field-types-internal.h>
  38 #include <babeltrace/ctf-ir/fields-internal.h>
  39 #include <babeltrace/ctf-ir/stream.h>
  40 #include <babeltrace/ctf-ir/stream-internal.h>
  41 #include <babeltrace/ctf-ir/stream-class-internal.h>
  42 #include <babeltrace/ctf-ir/trace.h>
  43 #include <babeltrace/ctf-ir/trace-internal.h>
  44 #include <babeltrace/ctf-writer/writer-internal.h>
  45 #include <babeltrace/graph/component-internal.h>
  46 #include <babeltrace/ref.h>
  47 #include <babeltrace/ctf-writer/functor-internal.h>
  48 #include <babeltrace/compiler-internal.h>
  49 #include <babeltrace/align-internal.h>
  50 #include <inttypes.h>
  51 #include <unistd.h>
  52
  53 static
  54 void bt_stream_destroy(struct bt_object *obj);
  55 static
  56 int try_set_structure_field_integer(struct bt_field *, char *, uint64_t);
  57
  58 static
  59 int set_integer_field_value(struct bt_field* field, uint64_t value)
  60 {
  61         int ret = 0;
  62         struct bt_field_type *field_type = NULL;
  63
  64         if (!field) {
  65                 BT_LOGW_STR("Invalid parameter: field is NULL.");
  66                 ret = -1;
  67                 goto end;
  68         }
  69
  70         field_type = bt_field_get_type(field);
  71         assert(field_type);
  72
  73         if (bt_field_type_get_type_id(field_type) !=
  74                         BT_FIELD_TYPE_ID_INTEGER) {
  75                 /* Not an integer and the value is unset, error. */
  76                 BT_LOGW("Invalid parameter: field's type is not an integer field type: "
  77                         "field-addr=%p, ft-addr=%p, ft-id=%s",
  78                         field, field_type,
  79                         bt_field_type_id_string(field_type->id));
  80                 ret = -1;
  81                 goto end;
  82         }
  83
  84         if (bt_field_type_integer_is_signed(field_type)) {
  85                 ret = bt_field_signed_integer_set_value(field, (int64_t) value);
  86                 if (ret) {
  87                         /* Value is out of range, error. */
  88                         BT_LOGW("Cannot set signed integer field's value: "
  89                                 "addr=%p, value=%" PRId64,
  90                                 field, (int64_t) value);
  91                         goto end;
  92                 }
  93         } else {
  94                 ret = bt_field_unsigned_integer_set_value(field, value);
  95                 if (ret) {
  96                         /* Value is out of range, error. */
  97                         BT_LOGW("Cannot set unsigned integer field's value: "
  98                                 "addr=%p, value=%" PRIu64,
  99                                 field, value);
 100                         goto end;
 101                 }
 102         }
 103 end:
 104         bt_put(field_type);
 105         return ret;
 106 }
 107
 108 static
 109 int set_packet_header_magic(struct bt_stream *stream)
 110 {
 111         int ret = 0;
 112         struct bt_field *magic_field = bt_field_structure_get_field_by_name(
 113                 stream->packet_header, "magic");
 114         const uint32_t magic_value = 0xc1fc1fc1;
 115
 116         assert(stream);
 117
 118         if (!magic_field) {
 119                 /* No magic field found. Not an error, skip. */
 120                 BT_LOGV("No field named `magic` in packet header: skipping: "
 121                         "stream-addr=%p, stream-name=\"%s\"",
 122                         stream, bt_stream_get_name(stream));
 123                 goto end;
 124         }
 125
 126         ret = bt_field_unsigned_integer_set_value(magic_field,
 127                 (uint64_t) magic_value);
 128
 129         if (ret) {
 130                 BT_LOGW("Cannot set packet header field's `magic` integer field's value: "
 131                         "stream-addr=%p, stream-name=\"%s\", field-addr=%p, value=%" PRIu64,
 132                         stream, bt_stream_get_name(stream),
 133                         magic_field, (uint64_t) magic_value);
 134         } else {
 135                 BT_LOGV("Set packet header field's `magic` field's value: "
 136                         "stream-addr=%p, stream-name=\"%s\", field-addr=%p, value=%" PRIu64,
 137                         stream, bt_stream_get_name(stream),
 138                         magic_field, (uint64_t) magic_value);
 139         }
 140 end:
 141         bt_put(magic_field);
 142         return ret;
 143 }
 144
 145 static
 146 int set_packet_header_uuid(struct bt_stream *stream)
 147 {
 148         int ret = 0;
 149         int64_t i;
 150         struct bt_trace *trace = NULL;
 151         struct bt_field *uuid_field = bt_field_structure_get_field_by_name(
 152                 stream->packet_header, "uuid");
 153
 154         assert(stream);
 155
 156         if (!uuid_field) {
 157                 /* No uuid field found. Not an error, skip. */
 158                 BT_LOGV("No field named `uuid` in packet header: skipping: "
 159                         "stream-addr=%p, stream-name=\"%s\"",
 160                         stream, bt_stream_get_name(stream));
 161                 goto end;
 162         }
 163
 164         trace = (struct bt_trace *) bt_object_get_parent(stream);
 165         for (i = 0; i < 16; i++) {
 166                 struct bt_field *uuid_element =
 167                         bt_field_array_get_field(uuid_field, i);
 168
 169                 ret = bt_field_unsigned_integer_set_value(
 170                         uuid_element, (uint64_t) trace->uuid[i]);
 171                 bt_put(uuid_element);
 172                 if (ret) {
 173                         BT_LOGW("Cannot set integer field's value (for `uuid` packet header field): "
 174                                 "stream-addr=%p, stream-name=\"%s\", field-addr=%p, "
 175                                 "value=%" PRIu64 ", index=%" PRId64,
 176                                 stream, bt_stream_get_name(stream),
 177                                 uuid_element, (uint64_t) trace->uuid[i], i);
 178                         goto end;
 179                 }
 180         }
 181
 182         BT_LOGV("Set packet header field's `uuid` field's value: "
 183                 "stream-addr=%p, stream-name=\"%s\", field-addr=%p",
 184                 stream, bt_stream_get_name(stream), uuid_field);
 185
 186 end:
 187         bt_put(uuid_field);
 188         BT_PUT(trace);
 189         return ret;
 190 }
 191 static
 192 int set_packet_header_stream_id(struct bt_stream *stream)
 193 {
 194         int ret = 0;
 195         uint32_t stream_id;
 196         struct bt_field *stream_id_field = bt_field_structure_get_field_by_name(
 197                 stream->packet_header, "stream_id");
 198
 199         if (!stream_id_field) {
 200                 /* No stream_id field found. Not an error, skip. */
 201                 BT_LOGV("No field named `stream_id` in packet header: skipping: "
 202                         "stream-addr=%p, stream-name=\"%s\"",
 203                         stream, bt_stream_get_name(stream));
 204                 goto end;
 205         }
 206
 207         stream_id = stream->stream_class->id;
 208         ret = bt_field_unsigned_integer_set_value(stream_id_field,
 209                 (uint64_t) stream_id);
 210         if (ret) {
 211                 BT_LOGW("Cannot set packet header field's `stream_id` integer field's value: "
 212                         "stream-addr=%p, stream-name=\"%s\", field-addr=%p, value=%" PRIu64,
 213                         stream, bt_stream_get_name(stream),
 214                         stream_id_field, (uint64_t) stream_id);
 215         } else {
 216                 BT_LOGV("Set packet header field's `stream_id` field's value: "
 217                         "stream-addr=%p, stream-name=\"%s\", field-addr=%p, value=%" PRIu64,
 218                         stream, bt_stream_get_name(stream),
 219                         stream_id_field, (uint64_t) stream_id);
 220         }
 221
 222 end:
 223         bt_put(stream_id_field);
 224         return ret;
 225 }
 226
 227 static
 228 int auto_populate_packet_header(struct bt_stream *stream)
 229 {
 230         int ret = 0;
 231
 232         if (!stream->packet_header) {
 233                 goto end;
 234         }
 235
 236         ret = set_packet_header_magic(stream);
 237         if (ret) {
 238                 BT_LOGW("Cannot set packet header's magic number field: "
 239                         "stream-addr=%p, stream-name=\"%s\"",
 240                         stream, bt_stream_get_name(stream));
 241                 goto end;
 242         }
 243
 244         ret = set_packet_header_uuid(stream);
 245         if (ret) {
 246                 BT_LOGW("Cannot set packet header's UUID field: "
 247                         "stream-addr=%p, stream-name=\"%s\"",
 248                         stream, bt_stream_get_name(stream));
 249                 goto end;
 250         }
 251
 252         ret = set_packet_header_stream_id(stream);
 253         if (ret) {
 254                 BT_LOGW("Cannot set packet header's stream class ID field: "
 255                         "stream-addr=%p, stream-name=\"%s\"",
 256                         stream, bt_stream_get_name(stream));
 257                 goto end;
 258         }
 259
 260         BT_LOGV("Automatically populated stream's packet header's known fields: "
 261                 "stream-addr=%p, stream-name=\"%s\"",
 262                 stream, bt_stream_get_name(stream));
 263
 264 end:
 265         return ret;
 266 }
 267
 268 static
 269 int set_packet_context_packet_size(struct bt_stream *stream)
 270 {
 271         int ret = 0;
 272         struct bt_field *field = bt_field_structure_get_field_by_name(
 273                 stream->packet_context, "packet_size");
 274
 275         assert(stream);
 276
 277         if (!field) {
 278                 /* No packet size field found. Not an error, skip. */
 279                 BT_LOGV("No field named `packet_size` in packet context: skipping: "
 280                         "stream-addr=%p, stream-name=\"%s\"",
 281                         stream, bt_stream_get_name(stream));
 282                 goto end;
 283         }
 284
 285         ret = bt_field_unsigned_integer_set_value(field,
 286                 stream->pos.packet_size);
 287         if (ret) {
 288                 BT_LOGW("Cannot set packet context field's `packet_size` integer field's value: "
 289                         "stream-addr=%p, stream-name=\"%s\", field-addr=%p, value=%" PRIu64,
 290                         stream, bt_stream_get_name(stream),
 291                         field, stream->pos.packet_size);
 292         } else {
 293                 BT_LOGV("Set packet context field's `packet_size` field's value: "
 294                         "stream-addr=%p, stream-name=\"%s\", field-addr=%p, value=%" PRIu64,
 295                         stream, bt_stream_get_name(stream),
 296                         field, stream->pos.packet_size);
 297         }
 298
 299 end:
 300         bt_put(field);
 301         return ret;
 302 }
 303
 304 static
 305 int set_packet_context_content_size(struct bt_stream *stream)
 306 {
 307         int ret = 0;
 308         struct bt_field *field = bt_field_structure_get_field_by_name(
 309                 stream->packet_context, "content_size");
 310
 311         assert(stream);
 312
 313         if (!field) {
 314                 /* No content size field found. Not an error, skip. */
 315                 BT_LOGV("No field named `content_size` in packet context: skipping: "
 316                         "stream-addr=%p, stream-name=\"%s\"",
 317                         stream, bt_stream_get_name(stream));
 318                 goto end;
 319         }
 320
 321         ret = bt_field_unsigned_integer_set_value(field,
 322                 stream->pos.offset);
 323         if (ret) {
 324                 BT_LOGW("Cannot set packet context field's `content_size` integer field's value: "
 325                         "stream-addr=%p, stream-name=\"%s\", field-addr=%p, value=%" PRId64,
 326                         stream, bt_stream_get_name(stream),
 327                         field, stream->pos.offset);
 328         } else {
 329                 BT_LOGV("Set packet context field's `content_size` field's value: "
 330                         "stream-addr=%p, stream-name=\"%s\", field-addr=%p, value=%" PRId64,
 331                         stream, bt_stream_get_name(stream),
 332                         field, stream->pos.offset);
 333         }
 334
 335 end:
 336         bt_put(field);
 337         return ret;
 338 }
 339
 340 static
 341 int set_packet_context_events_discarded(struct bt_stream *stream)
 342 {
 343         int ret = 0;
 344         struct bt_field *field = bt_field_structure_get_field_by_name(
 345                 stream->packet_context, "events_discarded");
 346
 347         assert(stream);
 348
 349         if (!field) {
 350                 /* No discarded events count field found. Not an error, skip. */
 351                 BT_LOGV("No field named `events_discarded` in packet context: skipping: "
 352                         "stream-addr=%p, stream-name=\"%s\"",
 353                         stream, bt_stream_get_name(stream));
 354                 goto end;
 355         }
 356
 357         /*
 358          * If the field is set by the user, make sure that the value is
 359          * greater than or equal to the stream's current count of
 360          * discarded events. We do not allow wrapping here. If it's
 361          * valid, update the stream's current count.
 362          */
 363         if (bt_field_is_set(field)) {
 364                 uint64_t user_val;
 365
 366                 ret = bt_field_unsigned_integer_get_value(field,
 367                         &user_val);
 368                 if (ret) {
 369                         BT_LOGW("Cannot get packet context `events_discarded` field's unsigned value: "
 370                                 "stream-addr=%p, stream-name=\"%s\", field-addr=%p",
 371                                 stream, bt_stream_get_name(stream), field);
 372                         goto end;
 373                 }
 374
 375                 if (user_val < stream->discarded_events) {
 376                         BT_LOGW("Invalid packet context `events_discarded` field's unsigned value: "
 377                                 "value is lesser than the stream's current discarded events count: "
 378                                 "stream-addr=%p, stream-name=\"%s\", field-addr=%p, "
 379                                 "value=%" PRIu64 ", "
 380                                 "stream-discarded-events-count=%" PRIu64,
 381                                 stream, bt_stream_get_name(stream), field,
 382                                 user_val, stream->discarded_events);
 383                         goto end;
 384                 }
 385
 386                 stream->discarded_events = user_val;
 387         } else {
 388                 ret = bt_field_unsigned_integer_set_value(field,
 389                         stream->discarded_events);
 390                 if (ret) {
 391                         BT_LOGW("Cannot set packet context field's `events_discarded` integer field's value: "
 392                                 "stream-addr=%p, stream-name=\"%s\", field-addr=%p, value=%" PRIu64,
 393                                 stream, bt_stream_get_name(stream),
 394                                 field, stream->discarded_events);
 395                 } else {
 396                         BT_LOGV("Set packet context field's `events_discarded` field's value: "
 397                                 "stream-addr=%p, stream-name=\"%s\", field-addr=%p, value=%" PRIu64,
 398                                 stream, bt_stream_get_name(stream),
 399                                 field, stream->discarded_events);
 400                 }
 401         }
 402
 403 end:
 404         bt_put(field);
 405         return ret;
 406 }
 407
 408 static
 409 int get_event_header_timestamp(struct bt_stream *stream,
 410                 struct bt_field *event_header, uint64_t *timestamp)
 411 {
 412         int ret = 0;
 413         struct bt_field *timestamp_field = NULL;
 414         struct bt_clock_class *ts_field_mapped_clock_class = NULL;
 415
 416         *timestamp = 0;
 417
 418         if (!event_header) {
 419                 BT_LOGV_STR("Event header does not exist.");
 420                 goto end;
 421         }
 422
 423         timestamp_field = bt_field_structure_get_field_by_name(event_header,
 424                 "timestamp");
 425         if (!timestamp_field) {
 426                 BT_LOGV("Cannot get event header's `timestamp` field: "
 427                         "event-header-field-addr=%p", event_header);
 428                 goto end;
 429         }
 430
 431         if (!bt_field_type_is_integer(timestamp_field->type)) {
 432                 BT_LOGV("Event header's `timestamp` field's type is not an integer field type: "
 433                         "event-header-field-addr=%p", event_header);
 434                 goto end;
 435         }
 436
 437         ts_field_mapped_clock_class =
 438                 bt_field_type_integer_get_mapped_clock_class(
 439                         timestamp_field->type);
 440         if (!ts_field_mapped_clock_class) {
 441                 BT_LOGV("Event header's `timestamp` field's type is not mapped to a clock class: "
 442                         "event-header-field-addr=%p", event_header);
 443                 goto end;
 444         }
 445
 446         if (ts_field_mapped_clock_class !=
 447                         stream->stream_class->clock->clock_class) {
 448                 BT_LOGV("Event header's `timestamp` field's type is not mapped to the stream's clock's class: "
 449                         "event-header-field-addr=%p", event_header);
 450                 goto end;
 451         }
 452
 453         ret = bt_field_unsigned_integer_get_value(timestamp_field,
 454                 timestamp);
 455         if (ret) {
 456                 BT_LOGW("Cannot get unsigned integer field's value: "
 457                         "event-header-field-addr=%p, "
 458                         "timestamp-field-addr=%p",
 459                         event_header, timestamp_field);
 460                 goto end;
 461         }
 462
 463 end:
 464         bt_put(timestamp_field);
 465         bt_put(ts_field_mapped_clock_class);
 466         return ret;
 467 }
 468
 469 static
 470 int set_packet_context_timestamp_field(struct bt_stream *stream,
 471                 const char *field_name, struct bt_event *event)
 472 {
 473         int ret = 0;
 474         struct bt_field *field = bt_field_structure_get_field_by_name(
 475                 stream->packet_context, field_name);
 476         struct bt_clock_class *field_mapped_clock_class = NULL;
 477         uint64_t ts;
 478
 479         assert(stream);
 480
 481         if (!field) {
 482                 /* No beginning timestamp field found. Not an error, skip. */
 483                 BT_LOGV("No field named `%s` in packet context: skipping: "
 484                         "stream-addr=%p, stream-name=\"%s\"", field_name,
 485                         stream, bt_stream_get_name(stream));
 486                 goto end;
 487         }
 488
 489         if (!stream->stream_class->clock) {
 490                 BT_LOGV("Stream has no clock: skipping: "
 491                         "stream-addr=%p, stream-name=\"%s\"",
 492                         stream, bt_stream_get_name(stream));
 493                 goto end;
 494         }
 495
 496         field_mapped_clock_class =
 497                 bt_field_type_integer_get_mapped_clock_class(field->type);
 498         if (field_mapped_clock_class && field_mapped_clock_class !=
 499                         stream->stream_class->clock->clock_class) {
 500                 BT_LOGV("Packet context's `%s` field's type is not mapped to the stream's clock's class: skipping: "
 501                         "stream-addr=%p, stream-name=\"%s\", "
 502                         "field-addr=%p, ft-addr=%p, "
 503                         "ft-mapped-clock-class-addr=%p, "
 504                         "ft-mapped-clock-class-name=\"%s\", "
 505                         "stream-clock-class-addr=%p, "
 506                         "stream-clock-class-name=\"%s\"",
 507                         field_name,
 508                         stream, bt_stream_get_name(stream),
 509                         field, field->type,
 510                         field_mapped_clock_class,
 511                         bt_clock_class_get_name(field_mapped_clock_class),
 512                         stream->stream_class->clock->clock_class,
 513                         bt_clock_class_get_name(
 514                                 stream->stream_class->clock->clock_class));
 515                 goto end;
 516         }
 517
 518         if (get_event_header_timestamp(stream, event->event_header, &ts)) {
 519                 BT_LOGW("Cannot get event's timestamp: "
 520                         "event-header-field-addr=%p",
 521                         event->event_header);
 522                 ret = -1;
 523                 goto end;
 524         }
 525
 526         ret = bt_field_unsigned_integer_set_value(field, ts);
 527         if (ret) {
 528                 BT_LOGW("Cannot set packet context field's `%s` integer field's value: "
 529                         "stream-addr=%p, stream-name=\"%s\", field-addr=%p, value=%" PRIu64,
 530                         field_name, stream, bt_stream_get_name(stream),
 531                         field, stream->discarded_events);
 532         } else {
 533                 BT_LOGV("Set packet context field's `%s` field's value: "
 534                         "stream-addr=%p, stream-name=\"%s\", field-addr=%p, value=%" PRIu64,
 535                         field_name, stream, bt_stream_get_name(stream),
 536                         field, stream->discarded_events);
 537         }
 538
 539 end:
 540         bt_put(field);
 541         bt_put(field_mapped_clock_class);
 542         return ret;
 543 }
 544
 545 static
 546 int set_packet_context_timestamp_begin(struct bt_stream *stream)
 547 {
 548         int ret = 0;
 549
 550         if (stream->events->len == 0) {
 551                 BT_LOGV("Current packet contains no events: skipping: "
 552                         "stream-addr=%p, stream-name=\"%s\"",
 553                         stream, bt_stream_get_name(stream));
 554                 goto end;
 555         }
 556
 557         ret = set_packet_context_timestamp_field(stream, "timestamp_begin",
 558                 g_ptr_array_index(stream->events, 0));
 559
 560 end:
 561         return ret;
 562 }
 563
 564 static
 565 int set_packet_context_timestamp_end(struct bt_stream *stream)
 566 {
 567         int ret = 0;
 568
 569         if (stream->events->len == 0) {
 570                 BT_LOGV("Current packet contains no events: skipping: "
 571                         "stream-addr=%p, stream-name=\"%s\"",
 572                         stream, bt_stream_get_name(stream));
 573                 goto end;
 574         }
 575
 576         ret = set_packet_context_timestamp_field(stream, "timestamp_end",
 577                 g_ptr_array_index(stream->events, stream->events->len - 1));
 578
 579 end:
 580         return ret;
 581 }
 582
 583 static
 584 int auto_populate_packet_context(struct bt_stream *stream)
 585 {
 586         int ret = 0;
 587
 588         if (!stream->packet_context) {
 589                 goto end;
 590         }
 591
 592         ret = set_packet_context_packet_size(stream);
 593         if (ret) {
 594                 BT_LOGW("Cannot set packet context's packet size field: "
 595                         "stream-addr=%p, stream-name=\"%s\"",
 596                         stream, bt_stream_get_name(stream));
 597                 goto end;
 598         }
 599
 600         ret = set_packet_context_content_size(stream);
 601         if (ret) {
 602                 BT_LOGW("Cannot set packet context's content size field: "
 603                         "stream-addr=%p, stream-name=\"%s\"",
 604                         stream, bt_stream_get_name(stream));
 605                 goto end;
 606         }
 607
 608         ret = set_packet_context_timestamp_begin(stream);
 609         if (ret) {
 610                 BT_LOGW("Cannot set packet context's beginning timestamp field: "
 611                         "stream-addr=%p, stream-name=\"%s\"",
 612                         stream, bt_stream_get_name(stream));
 613                 goto end;
 614         }
 615
 616         ret = set_packet_context_timestamp_end(stream);
 617         if (ret) {
 618                 BT_LOGW("Cannot set packet context's end timestamp field: "
 619                         "stream-addr=%p, stream-name=\"%s\"",
 620                         stream, bt_stream_get_name(stream));
 621                 goto end;
 622         }
 623
 624         ret = set_packet_context_events_discarded(stream);
 625         if (ret) {
 626                 BT_LOGW("Cannot set packet context's discarded events count field: "
 627                         "stream-addr=%p, stream-name=\"%s\"",
 628                         stream, bt_stream_get_name(stream));
 629                 goto end;
 630         }
 631
 632         BT_LOGV("Automatically populated stream's packet context's known fields: "
 633                 "stream-addr=%p, stream-name=\"%s\"",
 634                 stream, bt_stream_get_name(stream));
 635
 636 end:
 637         return ret;
 638 }
 639
 640 static
 641 void release_event(struct bt_event *event)
 642 {
 643         if (bt_object_get_ref_count(event)) {
 644                 /*
 645                  * The event is being orphaned, but it must guarantee the
 646                  * existence of its event class for the duration of its
 647                  * lifetime.
 648                  */
 649                 bt_get(event->event_class);
 650                 BT_PUT(event->base.parent);
 651         } else {
 652                 bt_object_release(event);
 653         }
 654 }
 655
 656 static
 657 int create_stream_file(struct bt_ctf_writer *writer,
 658                 struct bt_stream *stream)
 659 {
 660         int fd;
 661         GString *filename = g_string_new(NULL);
 662         int64_t stream_class_id;
 663         char *file_path = NULL;
 664
 665         BT_LOGD("Creating stream file: writer-addr=%p, stream-addr=%p, "
 666                 "stream-name=\"%s\", stream-class-addr=%p, stream-class-name=\"%s\"",
 667                 writer, stream, bt_stream_get_name(stream),
 668                 stream->stream_class, stream->stream_class->name->str);
 669
 670         if (stream->name && stream->name->len > 0) {
 671                 /* Use stream name's base name as prefix */
 672                 gchar *basename = g_path_get_basename(stream->name->str);
 673
 674                 assert(basename);
 675
 676                 if (strcmp(basename, G_DIR_SEPARATOR_S) == 0) {
 677                         g_string_assign(filename, "stream");
 678                 } else {
 679                         g_string_assign(filename, basename);
 680                 }
 681
 682                 g_free(basename);
 683                 goto append_ids;
 684         }
 685
 686         if (stream->stream_class->name &&
 687                         stream->stream_class->name->len > 0) {
 688                 /* Use stream class name's base name as prefix */
 689                 gchar *basename =
 690                         g_path_get_basename(stream->stream_class->name->str);
 691
 692                 assert(basename);
 693
 694                 if (strcmp(basename, G_DIR_SEPARATOR_S) == 0) {
 695                         g_string_assign(filename, "stream");
 696                 } else {
 697                         g_string_assign(filename, basename);
 698                 }
 699
 700                 g_free(basename);
 701                 goto append_ids;
 702         }
 703
 704         /* Default to using `stream-` as prefix */
 705         g_string_assign(filename, "stream");
 706
 707 append_ids:
 708         stream_class_id = bt_stream_class_get_id(stream->stream_class);
 709         assert(stream_class_id >= 0);
 710         assert(stream->id >= 0);
 711         g_string_append_printf(filename, "-%" PRId64 "-%" PRId64,
 712                 stream_class_id, stream->id);
 713
 714         file_path = g_build_filename(writer->path->str, filename->str, NULL);
 715         if (file_path == NULL) {
 716                 fd = -1;
 717                 goto end;
 718         }
 719
 720         fd = open(file_path,
 721                 O_RDWR | O_CREAT | O_TRUNC,
 722                 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
 723         g_free(file_path);
 724         if (fd < 0) {
 725                 BT_LOGW_ERRNO("Failed to open stream file for writing",
 726                         ": file_path=\"%s\", filename=\"%s\", ret=%d",
 727                         file_path, filename->str, fd);
 728                 goto end;
 729         }
 730
 731         BT_LOGD("Created stream file for writing: "
 732                 "stream-addr=%p, stream-name=\"%s\", "
 733                 "filename=\"%s\", fd=%d", stream, bt_stream_get_name(stream),
 734                 filename->str, fd);
 735
 736 end:
 737         g_string_free(filename, TRUE);
 738         return fd;
 739 }
 740
 741 static
 742 void set_stream_fd(struct bt_stream *stream, int fd)
 743 {
 744         (void) bt_stream_pos_init(&stream->pos, fd, O_RDWR);
 745         stream->pos.fd = fd;
 746 }
 747
 748 static
 749 void component_destroy_listener(struct bt_component *component, void *data)
 750 {
 751         struct bt_stream *stream = data;
 752
 753         BT_LOGD("Component is being destroyed, stream is notified: "
 754                 "comp-addr=%p, stream-addr=%p", component, stream);
 755         g_hash_table_remove(stream->comp_cur_port, component);
 756 }
 757
 758 static
 759 struct bt_stream *bt_stream_create_with_id_no_check(
 760                 struct bt_stream_class *stream_class,
 761                 const char *name, uint64_t id)
 762 {
 763         int ret;
 764         struct bt_stream *stream = NULL;
 765         struct bt_trace *trace = NULL;
 766         struct bt_ctf_writer *writer = NULL;
 767
 768         if (!stream_class) {
 769                 BT_LOGW_STR("Invalid parameter: stream class is NULL.");
 770                 goto error;
 771         }
 772
 773         BT_LOGD("Creating stream object: stream-class-addr=%p, "
 774                 "stream-class-name=\"%s\", stream-name=\"%s\", "
 775                 "stream-id=%" PRIu64,
 776                 stream_class, bt_stream_class_get_name(stream_class),
 777                 name, id);
 778         trace = bt_stream_class_borrow_trace(stream_class);
 779         if (!trace) {
 780                 BT_LOGW("Invalid parameter: cannot create stream from a stream class which is not part of trace: "
 781                         "stream-class-addr=%p, stream-class-name=\"%s\", "
 782                         "stream-name=\"%s\"",
 783                         stream_class, bt_stream_class_get_name(stream_class),
 784                         name);
 785                 goto error;
 786         }
 787
 788         if (bt_trace_is_static(trace)) {
 789                 /*
 790                  * A static trace has the property that all its stream
 791                  * classes, clock classes, and streams are definitive:
 792                  * no more can be added, and each object is also frozen.
 793                  */
 794                 BT_LOGW("Invalid parameter: cannot create stream from a stream class which is part of a static trace: "
 795                         "stream-class-addr=%p, stream-class-name=\"%s\", "
 796                         "stream-name=\"%s\", trace-addr=%p",
 797                         stream_class, bt_stream_class_get_name(stream_class),
 798                         name, trace);
 799                 goto error;
 800         }
 801
 802         if (id != -1ULL) {
 803                 /*
 804                  * Validate that the given ID is unique amongst all the
 805                  * existing trace's streams created from the same stream
 806                  * class.
 807                  */
 808                 size_t i;
 809
 810                 for (i = 0; i < trace->streams->len; i++) {
 811                         struct bt_stream *trace_stream =
 812                                 g_ptr_array_index(trace->streams, i);
 813
 814                         if (trace_stream->stream_class != stream_class) {
 815                                 continue;
 816                         }
 817
 818                         if (trace_stream->id == id) {
 819                                 BT_LOGW_STR("Invalid parameter: another stream in the same trace already has this ID.");
 820                                 goto error;
 821                         }
 822                 }
 823         }
 824
 825         stream = g_new0(struct bt_stream, 1);
 826         if (!stream) {
 827                 BT_LOGE_STR("Failed to allocate one stream.");
 828                 goto error;
 829         }
 830
 831         bt_object_init(stream, bt_stream_destroy);
 832         /*
 833          * Acquire reference to parent since stream will become publicly
 834          * reachable; it needs its parent to remain valid.
 835          */
 836         bt_object_set_parent(stream, trace);
 837         stream->stream_class = stream_class;
 838         stream->pos.fd = -1;
 839         stream->id = (int64_t) id;
 840
 841         stream->destroy_listeners = g_array_new(FALSE, TRUE,
 842                 sizeof(struct bt_stream_destroy_listener));
 843         if (!stream->destroy_listeners) {
 844                 BT_LOGE_STR("Failed to allocate a GArray.");
 845                 goto error;
 846         }
 847
 848         if (name) {
 849                 stream->name = g_string_new(name);
 850                 if (!stream->name) {
 851                         BT_LOGE_STR("Failed to allocate a GString.");
 852                         goto error;
 853                 }
 854         }
 855
 856         BT_LOGD("Set stream's trace parent: trace-addr=%p", trace);
 857
 858         if (trace->is_created_by_writer) {
 859                 int fd;
 860                 writer = (struct bt_ctf_writer *) bt_object_get_parent(trace);
 861                 stream->id = (int64_t) stream_class->next_stream_id++;
 862
 863                 BT_LOGD("Stream object belongs to a writer's trace: "
 864                         "writer-addr=%p", writer);
 865                 assert(writer);
 866
 867                 if (stream_class->packet_context_type) {
 868                         BT_LOGD("Creating stream's packet context field: "
 869                                 "ft-addr=%p", stream_class->packet_context_type);
 870                         stream->packet_context = bt_field_create(
 871                                 stream_class->packet_context_type);
 872                         if (!stream->packet_context) {
 873                                 BT_LOGW_STR("Cannot create stream's packet context field.");
 874                                 goto error;
 875                         }
 876
 877                         /* Initialize events_discarded */
 878                         ret = try_set_structure_field_integer(
 879                                 stream->packet_context, "events_discarded", 0);
 880                         if (ret < 0) {
 881                                 BT_LOGW("Cannot set `events_discarded` field in packet context: "
 882                                         "ret=%d, packet-context-field-addr=%p",
 883                                         ret, stream->packet_context);
 884                                 goto error;
 885                         }
 886                 }
 887
 888                 stream->events = g_ptr_array_new_with_free_func(
 889                         (GDestroyNotify) release_event);
 890                 if (!stream->events) {
 891                         BT_LOGE_STR("Failed to allocate a GPtrArray.");
 892                         goto error;
 893                 }
 894
 895                 if (trace->packet_header_type) {
 896                         BT_LOGD("Creating stream's packet header field: "
 897                                 "ft-addr=%p", trace->packet_header_type);
 898                         stream->packet_header =
 899                                 bt_field_create(trace->packet_header_type);
 900                         if (!stream->packet_header) {
 901                                 BT_LOGW_STR("Cannot create stream's packet header field.");
 902                                 goto error;
 903                         }
 904                 }
 905
 906                 /*
 907                  * Attempt to populate the default trace packet header fields
 908                  * (magic, uuid and stream_id). This will _not_ fail shall the
 909                  * fields not be found or be of an incompatible type; they will
 910                  * simply not be populated automatically. The user will have to
 911                  * make sure to set the trace packet header fields himself
 912                  * before flushing.
 913                  */
 914                 ret = auto_populate_packet_header(stream);
 915                 if (ret) {
 916                         BT_LOGW_STR("Cannot automatically populate the stream's packet header.");
 917                         goto error;
 918                 }
 919
 920                 /* Create file associated with this stream */
 921                 fd = create_stream_file(writer, stream);
 922                 if (fd < 0) {
 923                         BT_LOGW_STR("Cannot create stream file.");
 924                         goto error;
 925                 }
 926
 927                 set_stream_fd(stream, fd);
 928
 929                 /* Freeze the writer */
 930                 BT_LOGD_STR("Freezing stream's CTF writer.");
 931                 bt_ctf_writer_freeze(writer);
 932         } else {
 933                 /* Non-writer stream indicated by a negative FD */
 934                 set_stream_fd(stream, -1);
 935                 stream->comp_cur_port = g_hash_table_new(g_direct_hash,
 936                         g_direct_equal);
 937                 if (!stream->comp_cur_port) {
 938                         BT_LOGE_STR("Failed to allocate a GHashTable.");
 939                         goto error;
 940                 }
 941         }
 942
 943         /* Add this stream to the trace's streams */
 944         g_ptr_array_add(trace->streams, stream);
 945         BT_LOGD("Created stream object: addr=%p", stream);
 946         goto end;
 947
 948 error:
 949         BT_PUT(stream);
 950
 951 end:
 952         bt_put(writer);
 953         return stream;
 954 }
 955
 956 struct bt_stream *bt_stream_create_with_id(
 957                 struct bt_stream_class *stream_class,
 958                 const char *name, uint64_t id_param)
 959 {
 960         struct bt_trace *trace;
 961         struct bt_stream *stream = NULL;
 962         int64_t id = (int64_t) id_param;
 963
 964         if (!stream_class) {
 965                 BT_LOGW_STR("Invalid parameter: stream class is NULL.");
 966                 goto end;
 967         }
 968
 969         if (id < 0) {
 970                 BT_LOGW("Invalid parameter: invalid stream's ID: "
 971                         "name=\"%s\", id=%" PRIu64,
 972                         name, id_param);
 973                 goto end;
 974         }
 975
 976         trace = bt_stream_class_borrow_trace(stream_class);
 977         if (!trace) {
 978                 BT_LOGW("Invalid parameter: cannot create stream from a stream class which is not part of trace: "
 979                         "stream-class-addr=%p, stream-class-name=\"%s\", "
 980                         "stream-name=\"%s\", stream-id=%" PRIu64,
 981                         stream_class, bt_stream_class_get_name(stream_class),
 982                         name, id_param);
 983                 goto end;
 984         }
 985
 986         if (trace->is_created_by_writer) {
 987                 BT_LOGW("Invalid parameter: cannot create a CTF writer stream with this function; use bt_stream_create(): "
 988                         "stream-class-addr=%p, stream-class-name=\"%s\", "
 989                         "stream-name=\"%s\", stream-id=%" PRIu64,
 990                         stream_class, bt_stream_class_get_name(stream_class),
 991                         name, id_param);
 992                 goto end;
 993         }
 994
 995         stream = bt_stream_create_with_id_no_check(stream_class,
 996                 name, id_param);
 997
 998 end:
 999         return stream;
1000 }
1001
1002 struct bt_stream *bt_stream_create(
1003                 struct bt_stream_class *stream_class,
1004                 const char *name)
1005 {
1006         return bt_stream_create_with_id_no_check(stream_class,
1007                 name, -1ULL);
1008 }
1009
1010 struct bt_stream_class *bt_stream_get_class(
1011                 struct bt_stream *stream)
1012 {
1013         struct bt_stream_class *stream_class = NULL;
1014
1015         if (!stream) {
1016                 BT_LOGW_STR("Invalid parameter: stream is NULL.");
1017                 goto end;
1018         }
1019
1020         stream_class = stream->stream_class;
1021         bt_get(stream_class);
1022 end:
1023         return stream_class;
1024 }
1025
1026 int bt_stream_get_discarded_events_count(
1027                 struct bt_stream *stream, uint64_t *count)
1028 {
1029         int ret = 0;
1030
1031         if (!stream) {
1032                 BT_LOGW_STR("Invalid parameter: stream is NULL.");
1033                 ret = -1;
1034                 goto end;
1035         }
1036
1037         if (!count) {
1038                 BT_LOGW_STR("Invalid parameter: count is NULL.");
1039                 ret = -1;
1040                 goto end;
1041         }
1042
1043         if (stream->pos.fd < 0) {
1044                 BT_LOGW("Invalid parameter: stream is not a CTF writer stream: "
1045                         "stream-addr=%p, stream-name=\"%s\"",
1046                         stream, bt_stream_get_name(stream));
1047                 ret = -1;
1048                 goto end;
1049         }
1050
1051         *count = (uint64_t) stream->discarded_events;
1052
1053 end:
1054         return ret;
1055 }
1056
1057 static
1058 int set_packet_context_events_discarded_field(struct bt_stream *stream,
1059         uint64_t count)
1060 {
1061         int ret = 0;
1062         struct bt_field *events_discarded_field = NULL;
1063
1064         if (!stream->packet_context) {
1065                 goto end;
1066         }
1067
1068         events_discarded_field = bt_field_structure_get_field_by_name(
1069                 stream->packet_context, "events_discarded");
1070         if (!events_discarded_field) {
1071                 goto end;
1072         }
1073
1074         ret = bt_field_unsigned_integer_set_value(
1075                 events_discarded_field, count);
1076         if (ret) {
1077                 BT_LOGW("Cannot set packet context's `events_discarded` field: "
1078                         "field-addr=%p, value=%" PRIu64,
1079                         events_discarded_field, count);
1080                 goto end;
1081         }
1082
1083 end:
1084         bt_put(events_discarded_field);
1085         return ret;
1086 }
1087
1088 void bt_stream_append_discarded_events(struct bt_stream *stream,
1089                 uint64_t event_count)
1090 {
1091         int ret;
1092         uint64_t new_count;
1093         struct bt_field *events_discarded_field = NULL;
1094
1095         if (!stream) {
1096                 BT_LOGW_STR("Invalid parameter: stream is NULL.");
1097                 goto end;
1098         }
1099
1100         BT_LOGV("Appending discarded events to stream: "
1101                 "stream-addr=%p, stream-name=\"%s\", append-count=%" PRIu64,
1102                 stream, bt_stream_get_name(stream), event_count);
1103
1104         if (!stream->packet_context) {
1105                 BT_LOGW_STR("Invalid parameter: stream has no packet context field.");
1106                 goto end;
1107         }
1108
1109         if (stream->pos.fd < 0) {
1110                 BT_LOGW_STR("Invalid parameter: stream is not a CTF writer stream.");
1111                 goto end;
1112         }
1113
1114         events_discarded_field = bt_field_structure_get_field_by_name(
1115                 stream->packet_context, "events_discarded");
1116         if (!events_discarded_field) {
1117                 BT_LOGW_STR("No field named `events_discarded` in stream's packet context.");
1118                 goto end;
1119         }
1120
1121         new_count = stream->discarded_events + event_count;
1122         if (new_count < stream->discarded_events) {
1123                 BT_LOGW("New discarded events count is less than the stream's current discarded events count: "
1124                         "cur-count=%" PRIu64 ", new-count=%" PRIu64,
1125                         stream->discarded_events, new_count);
1126                 goto end;
1127         }
1128
1129         ret = set_packet_context_events_discarded_field(stream, new_count);
1130         if (ret) {
1131                 /* set_packet_context_events_discarded_field() logs errors */
1132                 goto end;
1133         }
1134
1135         stream->discarded_events = new_count;
1136         BT_LOGV("Appended discarded events to stream: "
1137                 "stream-addr=%p, stream-name=\"%s\", append-count=%" PRIu64,
1138                 stream, bt_stream_get_name(stream), event_count);
1139
1140 end:
1141         bt_put(events_discarded_field);
1142 }
1143
1144 static int auto_populate_event_header(struct bt_stream *stream,
1145                 struct bt_event *event)
1146 {
1147         int ret = 0;
1148         struct bt_field *id_field = NULL, *timestamp_field = NULL;
1149         struct bt_clock_class *mapped_clock_class = NULL;
1150         int64_t event_class_id;
1151
1152         assert(event);
1153
1154         if (!event->event_header) {
1155                 goto end;
1156         }
1157
1158         if (event->frozen) {
1159                 BT_LOGW_STR("Cannot populate event header field: event is frozen.");
1160                 ret = -1;
1161                 goto end;
1162         }
1163
1164         BT_LOGV("Automatically populating event's header field: "
1165                 "stream-addr=%p, stream-name=\"%s\", event-addr=%p",
1166                 stream, bt_stream_get_name(stream), event);
1167
1168         id_field = bt_field_structure_get_field_by_name(event->event_header, "id");
1169         event_class_id = bt_event_class_get_id(event->event_class);
1170         if (event_class_id < 0) {
1171                 BT_LOGE("Event class ID cannot be found");
1172                 ret = -1;
1173                 goto end;
1174         }
1175         if (id_field && bt_field_type_is_integer(id_field->type)) {
1176                 ret = set_integer_field_value(id_field, event_class_id);
1177                 if (ret) {
1178                         BT_LOGW("Cannot set event header's `id` field's value: "
1179                                 "addr=%p, value=%" PRIu64, id_field,
1180                                 event_class_id);
1181                         goto end;
1182                 }
1183         }
1184
1185         /*
1186          * The conditions to automatically set the timestamp are:
1187          *
1188          * 1. The event header field "timestamp" exists and is an
1189          *    integer field.
1190          * 2. This stream's class has a registered clock (set with
1191          *    bt_stream_class_set_clock()).
1192          * 3. The event header field "timestamp" has its type mapped to
1193          *    a clock class which is also the clock class of this
1194          *    stream's class's registered clock.
1195          */
1196         timestamp_field = bt_field_structure_get_field_by_name(event->event_header,
1197                         "timestamp");
1198         if (timestamp_field && stream->stream_class->clock &&
1199                         bt_field_type_is_integer(timestamp_field->type)) {
1200                 struct bt_clock_class *stream_class_clock_class =
1201                         stream->stream_class->clock->clock_class;
1202
1203                 mapped_clock_class =
1204                         bt_field_type_integer_get_mapped_clock_class(
1205                                 timestamp_field->type);
1206                 if (!mapped_clock_class ||
1207                                 mapped_clock_class == stream_class_clock_class) {
1208                         uint64_t timestamp;
1209
1210                         ret = bt_ctf_clock_get_value(
1211                                 stream->stream_class->clock,
1212                                 &timestamp);
1213                         assert(ret == 0);
1214                         ret = set_integer_field_value(timestamp_field,
1215                                         timestamp);
1216                         if (ret) {
1217                                 BT_LOGW("Cannot set event header's `timestamp` field's value: "
1218                                         "addr=%p, value=%" PRIu64,
1219                                         timestamp_field, timestamp);
1220                                 goto end;
1221                         }
1222                 }
1223         }
1224
1225         BT_LOGV("Automatically populated event's header field: "
1226                 "stream-addr=%p, stream-name=\"%s\", event-addr=%p",
1227                 stream, bt_stream_get_name(stream), event);
1228
1229 end:
1230         bt_put(id_field);
1231         bt_put(timestamp_field);
1232         bt_put(mapped_clock_class);
1233         return ret;
1234 }
1235
1236 int bt_stream_append_event(struct bt_stream *stream,
1237                 struct bt_event *event)
1238 {
1239         int ret = 0;
1240
1241         if (!stream) {
1242                 BT_LOGW_STR("Invalid parameter: stream is NULL.");
1243                 ret = -1;
1244                 goto end;
1245         }
1246
1247         if (!event) {
1248                 BT_LOGW_STR("Invalid parameter: event is NULL.");
1249                 ret = -1;
1250                 goto end;
1251         }
1252
1253         if (stream->pos.fd < 0) {
1254                 BT_LOGW_STR("Invalid parameter: stream is not a CTF writer stream.");
1255                 ret = -1;
1256                 goto end;
1257         }
1258
1259         BT_LOGV("Appending event to stream: "
1260                 "stream-addr=%p, stream-name=\"%s\", event-addr=%p, "
1261                 "event-class-name=\"%s\", event-class-id=%" PRId64,
1262                 stream, bt_stream_get_name(stream), event,
1263                 bt_event_class_get_name(bt_event_borrow_event_class(event)),
1264                 bt_event_class_get_id(bt_event_borrow_event_class(event)));
1265
1266         /*
1267          * The event is not supposed to have a parent stream at this
1268          * point. The only other way an event can have a parent stream
1269          * is if it was assigned when setting a packet to the event,
1270          * in which case the packet's stream is not a writer stream,
1271          * and thus the user is trying to append an event which belongs
1272          * to another stream.
1273          */
1274         if (event->base.parent) {
1275                 ret = -1;
1276                 goto end;
1277         }
1278
1279         bt_object_set_parent(event, stream);
1280         BT_LOGV_STR("Automatically populating the header of the event to append.");
1281         ret = auto_populate_event_header(stream, event);
1282         if (ret) {
1283                 /* auto_populate_event_header() reports errors */
1284                 goto error;
1285         }
1286
1287         /* Make sure the various scopes of the event are set */
1288         BT_LOGV_STR("Validating event to append.");
1289         ret = bt_event_validate(event);
1290         if (ret) {
1291                 goto error;
1292         }
1293
1294         /* Save the new event and freeze it */
1295         BT_LOGV_STR("Freezing the event to append.");
1296         bt_event_freeze(event);
1297         g_ptr_array_add(stream->events, event);
1298
1299         /*
1300          * Event had to hold a reference to its event class as long as it wasn't
1301          * part of the same trace hierarchy. From now on, the event and its
1302          * class share the same lifetime guarantees and the reference is no
1303          * longer needed.
1304          */
1305         BT_LOGV_STR("Putting the event's class.");
1306         bt_put(event->event_class);
1307         BT_LOGV("Appended event to stream: "
1308                 "stream-addr=%p, stream-name=\"%s\", event-addr=%p, "
1309                 "event-class-name=\"%s\", event-class-id=%" PRId64,
1310                 stream, bt_stream_get_name(stream), event,
1311                 bt_event_class_get_name(bt_event_borrow_event_class(event)),
1312                 bt_event_class_get_id(bt_event_borrow_event_class(event)));
1313
1314 end:
1315         return ret;
1316
1317 error:
1318         /*
1319          * Orphan the event; we were not successful in associating it to
1320          * a stream.
1321          */
1322         bt_object_set_parent(event, NULL);
1323
1324         return ret;
1325 }
1326
1327 struct bt_field *bt_stream_get_packet_context(struct bt_stream *stream)
1328 {
1329         struct bt_field *packet_context = NULL;
1330
1331         if (!stream) {
1332                 BT_LOGW_STR("Invalid parameter: stream is NULL.");
1333                 goto end;
1334         }
1335
1336         if (stream->pos.fd < 0) {
1337                 BT_LOGW("Invalid parameter: stream is not a CTF writer stream: "
1338                         "stream-addr=%p, stream-name=\"%s\"", stream,
1339                         bt_stream_get_name(stream));
1340                 goto end;
1341         }
1342
1343         packet_context = stream->packet_context;
1344         if (packet_context) {
1345                 bt_get(packet_context);
1346         }
1347 end:
1348         return packet_context;
1349 }
1350
1351 int bt_stream_set_packet_context(struct bt_stream *stream,
1352                 struct bt_field *field)
1353 {
1354         int ret = 0;
1355         struct bt_field_type *field_type;
1356
1357         if (!stream) {
1358                 BT_LOGW_STR("Invalid parameter: stream is NULL.");
1359                 ret = -1;
1360                 goto end;
1361         }
1362
1363         if (stream->pos.fd < 0) {
1364                 BT_LOGW_STR("Invalid parameter: stream is not a CTF writer stream.");
1365                 ret = -1;
1366                 goto end;
1367         }
1368
1369         field_type = bt_field_get_type(field);
1370         if (bt_field_type_compare(field_type,
1371                         stream->stream_class->packet_context_type)) {
1372                 BT_LOGW("Invalid parameter: packet context's field type is different from the stream's packet context field type: "
1373                         "stream-addr=%p, stream-name=\"%s\", "
1374                         "packet-context-field-addr=%p, "
1375                         "packet-context-ft-addr=%p",
1376                         stream, bt_stream_get_name(stream),
1377                         field, field_type);
1378                 ret = -1;
1379                 goto end;
1380         }
1381
1382         bt_put(field_type);
1383         bt_put(stream->packet_context);
1384         stream->packet_context = bt_get(field);
1385         BT_LOGV("Set stream's packet context field: "
1386                 "stream-addr=%p, stream-name=\"%s\", "
1387                 "packet-context-field-addr=%p",
1388                 stream, bt_stream_get_name(stream), field);
1389 end:
1390         return ret;
1391 }
1392
1393 struct bt_field *bt_stream_get_packet_header(struct bt_stream *stream)
1394 {
1395         struct bt_field *packet_header = NULL;
1396
1397         if (!stream) {
1398                 BT_LOGW_STR("Invalid parameter: stream is NULL.");
1399                 goto end;
1400         }
1401
1402         if (stream->pos.fd < 0) {
1403                 BT_LOGW("Invalid parameter: stream is not a CTF writer stream: "
1404                         "stream-addr=%p, stream-name=\"%s\"", stream,
1405                         bt_stream_get_name(stream));
1406                 goto end;
1407         }
1408
1409         packet_header = stream->packet_header;
1410         if (packet_header) {
1411                 bt_get(packet_header);
1412         }
1413 end:
1414         return packet_header;
1415 }
1416
1417 int bt_stream_set_packet_header(struct bt_stream *stream,
1418                 struct bt_field *field)
1419 {
1420         int ret = 0;
1421         struct bt_trace *trace = NULL;
1422         struct bt_field_type *field_type = NULL;
1423
1424         if (!stream) {
1425                 BT_LOGW_STR("Invalid parameter: stream is NULL.");
1426                 ret = -1;
1427                 goto end;
1428         }
1429
1430         if (stream->pos.fd < 0) {
1431                 BT_LOGW_STR("Invalid parameter: stream is not a CTF writer stream.");
1432                 ret = -1;
1433                 goto end;
1434         }
1435
1436         trace = (struct bt_trace *) bt_object_get_parent(stream);
1437
1438         if (!field) {
1439                 if (trace->packet_header_type) {
1440                         BT_LOGW("Invalid parameter: setting no packet header but packet header field type is not NULL: "
1441                                 "stream-addr=%p, stream-name=\"%s\", "
1442                                 "packet-header-field-addr=%p, "
1443                                 "expected-ft-addr=%p",
1444                                 stream, bt_stream_get_name(stream),
1445                                 field, trace->packet_header_type);
1446                         ret = -1;
1447                         goto end;
1448                 }
1449
1450                 goto skip_validation;
1451         }
1452
1453         field_type = bt_field_get_type(field);
1454         assert(field_type);
1455
1456         if (bt_field_type_compare(field_type, trace->packet_header_type)) {
1457                 BT_LOGW("Invalid parameter: packet header's field type is different from the stream's packet header field type: "
1458                         "stream-addr=%p, stream-name=\"%s\", "
1459                         "packet-header-field-addr=%p, "
1460                         "packet-header-ft-addr=%p",
1461                         stream, bt_stream_get_name(stream),
1462                         field, field_type);
1463                 ret = -1;
1464                 goto end;
1465         }
1466
1467 skip_validation:
1468         bt_put(stream->packet_header);
1469         stream->packet_header = bt_get(field);
1470         BT_LOGV("Set stream's packet header field: "
1471                 "stream-addr=%p, stream-name=\"%s\", "
1472                 "packet-header-field-addr=%p",
1473                 stream, bt_stream_get_name(stream), field);
1474 end:
1475         BT_PUT(trace);
1476         bt_put(field_type);
1477         return ret;
1478 }
1479
1480 static
1481 void reset_structure_field(struct bt_field *structure, const char *name)
1482 {
1483         struct bt_field *member;
1484
1485         member = bt_field_structure_get_field_by_name(structure, name);
1486         if (member) {
1487                 (void) bt_field_reset(member);
1488                 bt_put(member);
1489         }
1490 }
1491
1492 int bt_stream_flush(struct bt_stream *stream)
1493 {
1494         int ret = 0;
1495         size_t i;
1496         struct bt_stream_pos packet_context_pos;
1497         struct bt_trace *trace;
1498         enum bt_byte_order native_byte_order;
1499         bool has_packet_size = false;
1500
1501         if (!stream) {
1502                 BT_LOGW_STR("Invalid parameter: stream is NULL.");
1503                 ret = -1;
1504                 goto end_no_stream;
1505         }
1506
1507         if (stream->pos.fd < 0) {
1508                 BT_LOGW_STR("Invalid parameter: stream is not a CTF writer stream.");
1509                 ret = -1;
1510                 goto end;
1511         }
1512
1513         if (stream->packet_context) {
1514                 struct bt_field *packet_size_field;
1515
1516                 packet_size_field = bt_field_structure_get_field_by_name(
1517                                 stream->packet_context, "packet_size");
1518                 has_packet_size = (packet_size_field != NULL);
1519                 bt_put(packet_size_field);
1520         }
1521
1522         if (stream->flushed_packet_count == 1) {
1523                 if (!stream->packet_context) {
1524                         BT_LOGW_STR("Cannot flush a stream which has no packet context field more than once.");
1525                         ret = -1;
1526                         goto end;
1527                 }
1528
1529                 if (!has_packet_size) {
1530                         BT_LOGW_STR("Cannot flush a stream which has no packet context's `packet_size` field more than once.");
1531                         ret = -1;
1532                         goto end;
1533                 }
1534         }
1535
1536         BT_LOGV("Flushing stream's current packet: stream-addr=%p, "
1537                 "stream-name=\"%s\", packet-index=%u", stream,
1538                 bt_stream_get_name(stream), stream->flushed_packet_count);
1539         trace = bt_stream_class_borrow_trace(stream->stream_class);
1540         assert(trace);
1541         native_byte_order = bt_trace_get_native_byte_order(trace);
1542
1543         ret = auto_populate_packet_header(stream);
1544         if (ret) {
1545                 BT_LOGW_STR("Cannot automatically populate the stream's packet header field.");
1546                 ret = -1;
1547                 goto end;
1548         }
1549
1550         ret = auto_populate_packet_context(stream);
1551         if (ret) {
1552                 BT_LOGW_STR("Cannot automatically populate the stream's packet context field.");
1553                 ret = -1;
1554                 goto end;
1555         }
1556
1557         /* mmap the next packet */
1558         BT_LOGV("Seeking to the next packet: pos-offset=%" PRId64,
1559                 stream->pos.offset);
1560         bt_stream_pos_packet_seek(&stream->pos, 0, SEEK_CUR);
1561         assert(stream->pos.packet_size % 8 == 0);
1562
1563         if (stream->packet_header) {
1564                 BT_LOGV_STR("Serializing packet header field.");
1565                 ret = bt_field_serialize(stream->packet_header, &stream->pos,
1566                         native_byte_order);
1567                 if (ret) {
1568                         BT_LOGW("Cannot serialize stream's packet header field: "
1569                                 "field-addr=%p", stream->packet_header);
1570                         goto end;
1571                 }
1572         }
1573
1574         if (stream->packet_context) {
1575                 /* Write packet context */
1576                 memcpy(&packet_context_pos, &stream->pos,
1577                         sizeof(packet_context_pos));
1578                 BT_LOGV_STR("Serializing packet context field.");
1579                 ret = bt_field_serialize(stream->packet_context,
1580                         &stream->pos, native_byte_order);
1581                 if (ret) {
1582                         BT_LOGW("Cannot serialize stream's packet context field: "
1583                                 "field-addr=%p", stream->packet_context);
1584                         goto end;
1585                 }
1586         }
1587
1588         BT_LOGV("Serializing events: count=%u", stream->events->len);
1589
1590         for (i = 0; i < stream->events->len; i++) {
1591                 struct bt_event *event = g_ptr_array_index(
1592                         stream->events, i);
1593                 struct bt_event_class *event_class =
1594                         bt_event_borrow_event_class(event);
1595
1596                 BT_LOGV("Serializing event: index=%zu, event-addr=%p, "
1597                         "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
1598                         "pos-offset=%" PRId64 ", packet-size=%" PRIu64,
1599                         i, event, bt_event_class_get_name(event_class),
1600                         bt_event_class_get_id(event_class),
1601                         stream->pos.offset, stream->pos.packet_size);
1602
1603                 /* Write event header */
1604                 if (event->event_header) {
1605                         BT_LOGV_STR("Serializing event's header field.");
1606                         ret = bt_field_serialize(event->event_header,
1607                                         &stream->pos, native_byte_order);
1608                         if (ret) {
1609                                 BT_LOGW("Cannot serialize event's header field: "
1610                                                 "field-addr=%p", event->event_header);
1611                                 goto end;
1612                         }
1613                 }
1614
1615                 /* Write stream event context */
1616                 if (event->stream_event_context) {
1617                         BT_LOGV_STR("Serializing event's stream event context field.");
1618                         ret = bt_field_serialize(
1619                                 event->stream_event_context, &stream->pos,
1620                                 native_byte_order);
1621                         if (ret) {
1622                                 BT_LOGW("Cannot serialize event's stream event context field: "
1623                                         "field-addr=%p", event->stream_event_context);
1624                                 goto end;
1625                         }
1626                 }
1627
1628                 /* Write event content */
1629                 ret = bt_event_serialize(event, &stream->pos,
1630                         native_byte_order);
1631                 if (ret) {
1632                         /* bt_event_serialize() logs errors */
1633                         goto end;
1634                 }
1635         }
1636
1637         if (!has_packet_size && stream->pos.offset % 8 != 0) {
1638                 BT_LOGW("Stream's packet context field type has no `packet_size` field, "
1639                         "but current content size is not a multiple of 8 bits: "
1640                         "content-size=%" PRId64 ", "
1641                         "packet-size=%" PRIu64,
1642                         stream->pos.offset,
1643                         stream->pos.packet_size);
1644                 ret = -1;
1645                 goto end;
1646         }
1647
1648         assert(stream->pos.packet_size % 8 == 0);
1649
1650         /*
1651          * Remove extra padding bytes.
1652          */
1653         stream->pos.packet_size = (stream->pos.offset + 7) & ~7;
1654
1655         if (stream->packet_context) {
1656                 /*
1657                  * The whole packet is serialized at this point. Make sure that,
1658                  * if `packet_size` is missing, the current content size is
1659                  * equal to the current packet size.
1660                  */
1661                 struct bt_field *field = bt_field_structure_get_field_by_name(
1662                         stream->packet_context, "content_size");
1663
1664                 bt_put(field);
1665                 if (!field) {
1666                         if (stream->pos.offset != stream->pos.packet_size) {
1667                                 BT_LOGW("Stream's packet context's `content_size` field is missing, "
1668                                         "but current packet's content size is not equal to its packet size: "
1669                                         "content-size=%" PRId64 ", "
1670                                         "packet-size=%" PRIu64,
1671                                         stream->pos.offset,
1672                                         stream->pos.packet_size);
1673                                 ret = -1;
1674                                 goto end;
1675                         }
1676                 }
1677
1678                 /*
1679                  * Overwrite the packet context now that the stream
1680                  * position's packet and content sizes have the correct
1681                  * values.
1682                  *
1683                  * Copy base_mma as the packet may have been remapped
1684                  * (e.g. when a packet is resized).
1685                  */
1686                 packet_context_pos.base_mma = stream->pos.base_mma;
1687                 ret = auto_populate_packet_context(stream);
1688                 if (ret) {
1689                         BT_LOGW_STR("Cannot automatically populate the stream's packet context field.");
1690                         ret = -1;
1691                         goto end;
1692                 }
1693
1694                 BT_LOGV("Rewriting (serializing) packet context field.");
1695                 ret = bt_field_serialize(stream->packet_context,
1696                         &packet_context_pos, native_byte_order);
1697                 if (ret) {
1698                         BT_LOGW("Cannot serialize stream's packet context field: "
1699                                 "field-addr=%p", stream->packet_context);
1700                         goto end;
1701                 }
1702         }
1703
1704         g_ptr_array_set_size(stream->events, 0);
1705         stream->flushed_packet_count++;
1706         stream->size += stream->pos.packet_size / CHAR_BIT;
1707
1708 end:
1709         /* Reset automatically-set fields. */
1710         if (stream->packet_context) {
1711                 reset_structure_field(stream->packet_context, "timestamp_begin");
1712                 reset_structure_field(stream->packet_context, "timestamp_end");
1713                 reset_structure_field(stream->packet_context, "packet_size");
1714                 reset_structure_field(stream->packet_context, "content_size");
1715                 reset_structure_field(stream->packet_context, "events_discarded");
1716         }
1717
1718         if (ret < 0) {
1719                 /*
1720                  * We failed to write the packet. Its size is therefore set to 0
1721                  * to ensure the next mapping is done in the same place rather
1722                  * than advancing by "stream->pos.packet_size", which would
1723                  * leave a corrupted packet in the trace.
1724                  */
1725                 stream->pos.packet_size = 0;
1726         } else {
1727                 BT_LOGV("Flushed stream's current packet: content-size=%" PRId64 ", "
1728                         "packet-size=%" PRIu64,
1729                         stream->pos.offset, stream->pos.packet_size);
1730         }
1731
1732 end_no_stream:
1733         return ret;
1734 }
1735
1736 /* Pre-2.0 CTF writer backward compatibility */
1737 void bt_ctf_stream_get(struct bt_stream *stream)
1738 {
1739         bt_get(stream);
1740 }
1741
1742 /* Pre-2.0 CTF writer backward compatibility */
1743 void bt_ctf_stream_put(struct bt_stream *stream)
1744 {
1745         bt_put(stream);
1746 }
1747
1748 static
1749 void bt_stream_destroy(struct bt_object *obj)
1750 {
1751         struct bt_stream *stream;
1752         int i;
1753
1754         stream = container_of(obj, struct bt_stream, base);
1755         BT_LOGD("Destroying stream object: addr=%p, name=\"%s\"",
1756                 stream, bt_stream_get_name(stream));
1757
1758         /* Call destroy listeners in reverse registration order */
1759         for (i = stream->destroy_listeners->len - 1; i >= 0; i--) {
1760                 struct bt_stream_destroy_listener *listener =
1761                         &g_array_index(stream->destroy_listeners,
1762                                 struct bt_stream_destroy_listener, i);
1763
1764                 BT_LOGD("Calling destroy listener: func=%p, data=%p, index=%d",
1765                         listener->func, listener->data, i);
1766                 listener->func(stream, listener->data);
1767         }
1768
1769         (void) bt_stream_pos_fini(&stream->pos);
1770         if (stream->pos.fd >= 0) {
1771                 int ret;
1772
1773                 /*
1774                  * Truncate the file's size to the minimum required to fit the
1775                  * last packet as we might have grown it too much on the last
1776                  * mmap.
1777                  */
1778                 do {
1779                         ret = ftruncate(stream->pos.fd, stream->size);
1780                 } while (ret == -1 && errno == EINTR);
1781                 if (ret) {
1782                         BT_LOGE_ERRNO("Failed to truncate stream file",
1783                                 ": ret=%d, size=%" PRIu64,
1784                                 ret, (uint64_t) stream->size);
1785                 }
1786
1787                 if (close(stream->pos.fd)) {
1788                         BT_LOGE_ERRNO("Failed to close stream file",
1789                                 ": ret=%d", ret);
1790                 }
1791         }
1792
1793         if (stream->events) {
1794                 BT_LOGD_STR("Putting events.");
1795                 g_ptr_array_free(stream->events, TRUE);
1796         }
1797
1798         if (stream->name) {
1799                 g_string_free(stream->name, TRUE);
1800         }
1801
1802         if (stream->comp_cur_port) {
1803                 GHashTableIter ht_iter;
1804                 gpointer comp_gptr, port_gptr;
1805
1806                 /*
1807                  * Since we're destroying the stream, remove the destroy
1808                  * listeners that it registered for each component in
1809                  * its component-port mapping hash table. Otherwise they
1810                  * would be called and the stream would be accessed once
1811                  * it's freed or another stream would be accessed.
1812                  */
1813                 g_hash_table_iter_init(&ht_iter, stream->comp_cur_port);
1814
1815                 while (g_hash_table_iter_next(&ht_iter, &comp_gptr, &port_gptr)) {
1816                         assert(comp_gptr);
1817                         bt_component_remove_destroy_listener((void *) comp_gptr,
1818                                 component_destroy_listener, stream);
1819                 }
1820
1821                 g_hash_table_destroy(stream->comp_cur_port);
1822         }
1823
1824         if (stream->destroy_listeners) {
1825                 g_array_free(stream->destroy_listeners, TRUE);
1826         }
1827
1828         BT_LOGD_STR("Putting packet header field.");
1829         bt_put(stream->packet_header);
1830         BT_LOGD_STR("Putting packet context field.");
1831         bt_put(stream->packet_context);
1832         g_free(stream);
1833 }
1834
1835 static
1836 int _set_structure_field_integer(struct bt_field *structure, char *name,
1837                 uint64_t value, bt_bool force)
1838 {
1839         int ret = 0;
1840         struct bt_field_type *field_type = NULL;
1841         struct bt_field *integer;
1842
1843         assert(structure);
1844         assert(name);
1845
1846         integer = bt_field_structure_get_field_by_name(structure, name);
1847         if (!integer) {
1848                 /* Field not found, not an error. */
1849                 BT_LOGV("Field not found: struct-field-addr=%p, "
1850                         "name=\"%s\", force=%d", structure, name, force);
1851                 goto end;
1852         }
1853
1854         /* Make sure the payload has not already been set. */
1855         if (!force && bt_field_is_set(integer)) {
1856                 /* Payload already set, not an error */
1857                 BT_LOGV("Field's payload is already set: struct-field-addr=%p, "
1858                         "name=\"%s\", force=%d", structure, name, force);
1859                 goto end;
1860         }
1861
1862         field_type = bt_field_get_type(integer);
1863         assert(field_type);
1864         if (bt_field_type_get_type_id(field_type) != BT_FIELD_TYPE_ID_INTEGER) {
1865                 /*
1866                  * The user most likely meant for us to populate this field
1867                  * automatically. However, we can only do this if the field
1868                  * is an integer. Return an error.
1869                  */
1870                 BT_LOGW("Invalid parameter: field's type is not an integer field type: "
1871                         "field-addr=%p, ft-addr=%p, ft-id=%s",
1872                         integer, field_type,
1873                         bt_field_type_id_string(field_type->id));
1874                 ret = -1;
1875                 goto end;
1876         }
1877
1878         if (bt_field_type_integer_is_signed(field_type)) {
1879                 ret = bt_field_signed_integer_set_value(integer,
1880                         (int64_t) value);
1881         } else {
1882                 ret = bt_field_unsigned_integer_set_value(integer, value);
1883         }
1884         ret = !ret ? 1 : ret;
1885 end:
1886         bt_put(integer);
1887         bt_put(field_type);
1888         return ret;
1889 }
1890
1891 /*
1892  * Returns the following codes:
1893  * 1 if the field was found and set,
1894  * 0 if nothing was done (field not found, or was already set),
1895  * <0 if an error was encoutered
1896  */
1897 static
1898 int try_set_structure_field_integer(struct bt_field *structure, char *name,
1899                 uint64_t value)
1900 {
1901         return _set_structure_field_integer(structure, name, value, BT_FALSE);
1902 }
1903
1904 const char *bt_stream_get_name(struct bt_stream *stream)
1905 {
1906         const char *name = NULL;
1907
1908         if (!stream) {
1909                 BT_LOGW_STR("Invalid parameter: stream is NULL.");
1910                 goto end;
1911         }
1912
1913         name = stream->name ? stream->name->str : NULL;
1914
1915 end:
1916         return name;
1917 }
1918
1919 int bt_stream_is_writer(struct bt_stream *stream)
1920 {
1921         int ret = -1;
1922
1923         if (!stream) {
1924                 BT_LOGW_STR("Invalid parameter: stream is NULL.");
1925                 goto end;
1926         }
1927
1928         ret = (stream->pos.fd >= 0);
1929
1930 end:
1931         return ret;
1932 }
1933
1934 BT_HIDDEN
1935 void bt_stream_map_component_to_port(struct bt_stream *stream,
1936                 struct bt_component *comp,
1937                 struct bt_port *port)
1938 {
1939         assert(stream);
1940         assert(comp);
1941         assert(port);
1942         assert(stream->comp_cur_port);
1943
1944         /*
1945          * Do not take a reference to the component here because we
1946          * don't want the component to exist as long as this stream
1947          * exists. Instead, keep a weak reference, but add a destroy
1948          * listener so that we remove this hash table entry when we know
1949          * the component is destroyed.
1950          */
1951         BT_LOGV("Adding component's destroy listener for stream: "
1952                 "stream-addr=%p, stream-name=\"%s\", comp-addr=%p, "
1953                 "comp-name=\"%s\", port-addr=%p, port-name=\"%s\"",
1954                 stream, bt_stream_get_name(stream),
1955                 comp, bt_component_get_name(comp), port,
1956                 bt_port_get_name(port));
1957         bt_component_add_destroy_listener(comp, component_destroy_listener,
1958                 stream);
1959         g_hash_table_insert(stream->comp_cur_port, comp, port);
1960         BT_LOGV_STR("Mapped component to port for stream.");
1961 }
1962
1963 BT_HIDDEN
1964 struct bt_port *bt_stream_port_for_component(struct bt_stream *stream,
1965                 struct bt_component *comp)
1966 {
1967         assert(stream);
1968         assert(comp);
1969         assert(stream->comp_cur_port);
1970         return g_hash_table_lookup(stream->comp_cur_port, comp);
1971 }
1972
1973 BT_HIDDEN
1974 void bt_stream_add_destroy_listener(struct bt_stream *stream,
1975                 bt_stream_destroy_listener_func func, void *data)
1976 {
1977         struct bt_stream_destroy_listener listener;
1978
1979         assert(stream);
1980         assert(func);
1981         listener.func = func;
1982         listener.data = data;
1983         g_array_append_val(stream->destroy_listeners, listener);
1984         BT_LOGV("Added stream destroy listener: stream-addr=%p, "
1985                 "stream-name=\"%s\", func=%p, data=%p",
1986                 stream, bt_stream_get_name(stream), func, data);
1987 }
1988
1989 BT_HIDDEN
1990 void bt_stream_remove_destroy_listener(struct bt_stream *stream,
1991                 bt_stream_destroy_listener_func func, void *data)
1992 {
1993         size_t i;
1994
1995         assert(stream);
1996         assert(func);
1997
1998         for (i = 0; i < stream->destroy_listeners->len; i++) {
1999                 struct bt_stream_destroy_listener *listener =
2000                         &g_array_index(stream->destroy_listeners,
2001                                 struct bt_stream_destroy_listener, i);
2002
2003                 if (listener->func == func && listener->data == data) {
2004                         g_array_remove_index(stream->destroy_listeners, i);
2005                         i--;
2006                         BT_LOGV("Removed stream destroy listener: stream-addr=%p, "
2007                                 "stream-name=\"%s\", func=%p, data=%p",
2008                                 stream, bt_stream_get_name(stream),
2009                                 func, data);
2010                 }
2011         }
2012 }
2013
2014 int64_t bt_stream_get_id(struct bt_stream *stream)
2015 {
2016         int64_t ret;
2017
2018         if (!stream) {
2019                 BT_LOGW_STR("Invalid parameter: stream is NULL.");
2020                 ret = (int64_t) -1;
2021                 goto end;
2022         }
2023
2024         ret = stream->id;
2025         if (ret < 0) {
2026                 BT_LOGV("Stream's ID is not set: addr=%p, name=\"%s\"",
2027                         stream, bt_stream_get_name(stream));
2028         }
2029
2030 end:
2031         return ret;
2032 }