formats/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 #include <babeltrace/ctf-ir/clock.h>
  30 #include <babeltrace/ctf-ir/clock-internal.h>
  31 #include <babeltrace/ctf-writer/event.h>
  32 #include <babeltrace/ctf-ir/event-internal.h>
  33 #include <babeltrace/ctf-ir/event-types-internal.h>
  34 #include <babeltrace/ctf-ir/event-fields-internal.h>
  35 #include <babeltrace/ctf-ir/stream.h>
  36 #include <babeltrace/ctf-ir/stream-internal.h>
  37 #include <babeltrace/ctf-ir/stream-class-internal.h>
  38 #include <babeltrace/ctf-writer/functor-internal.h>
  39 #include <babeltrace/compiler.h>
  40 #include <babeltrace/align.h>
  41 #include <babeltrace/ctf/ctf-index.h>
  42
  43 static
  44 void bt_ctf_stream_destroy(struct bt_ctf_ref *ref);
  45 static
  46 int set_structure_field_integer(struct bt_ctf_field *, char *, uint64_t);
  47
  48 static
  49 int set_packet_header_magic(struct bt_ctf_stream *stream)
  50 {
  51         int ret = 0;
  52         struct bt_ctf_field_type *magic_field_type = NULL;
  53         struct bt_ctf_field *magic_field = bt_ctf_field_structure_get_field(
  54                 stream->packet_header, "magic");
  55
  56         if (!magic_field) {
  57                 /* No magic field found. Not an error, skip. */
  58                 goto end;
  59         }
  60
  61         if (!bt_ctf_field_validate(magic_field)) {
  62                 /* Value already set. Not an error, skip. */
  63                 goto end;
  64         }
  65
  66         magic_field_type = bt_ctf_field_get_type(magic_field);
  67         assert(magic_field_type);
  68
  69         if (bt_ctf_field_type_get_type_id(magic_field_type) !=
  70                 CTF_TYPE_INTEGER) {
  71                 /* Magic field is not an integer. Not an error, skip. */
  72                 goto end;
  73         }
  74
  75         if (bt_ctf_field_type_integer_get_size(magic_field_type) != 32) {
  76                 /*
  77                  * Magic field is not of the expected size.
  78                  * Not an error, skip.
  79                  */
  80                 goto end;
  81         }
  82
  83         ret = bt_ctf_field_type_integer_get_signed(magic_field_type);
  84         assert(ret >= 0);
  85         if (ret) {
  86                 ret = bt_ctf_field_signed_integer_set_value(magic_field,
  87                         (int64_t) 0xC1FC1FC1);
  88         } else {
  89                 ret = bt_ctf_field_unsigned_integer_set_value(magic_field,
  90                         (uint64_t) 0xC1FC1FC1);
  91         }
  92 end:
  93         if (magic_field) {
  94                 bt_ctf_field_put(magic_field);
  95         }
  96         if (magic_field_type) {
  97                 bt_ctf_field_type_put(magic_field_type);
  98         }
  99         return ret;
 100 }
 101
 102 static
 103 int set_packet_header_uuid(struct bt_ctf_stream *stream)
 104 {
 105         int i, ret = 0;
 106         struct bt_ctf_field_type *uuid_field_type = NULL;
 107         struct bt_ctf_field_type *element_field_type = NULL;
 108         struct bt_ctf_field *uuid_field = bt_ctf_field_structure_get_field(
 109                 stream->packet_header, "uuid");
 110
 111         if (!uuid_field) {
 112                 /* No uuid field found. Not an error, skip. */
 113                 goto end;
 114         }
 115
 116         if (!bt_ctf_field_validate(uuid_field)) {
 117                 /* Value already set. Not an error, skip. */
 118                 goto end;
 119         }
 120
 121         uuid_field_type = bt_ctf_field_get_type(uuid_field);
 122         assert(uuid_field_type);
 123         if (bt_ctf_field_type_get_type_id(uuid_field_type) !=
 124                 CTF_TYPE_ARRAY) {
 125                 /* UUID field is not an array. Not an error, skip. */
 126                 goto end;
 127         }
 128
 129         if (bt_ctf_field_type_array_get_length(uuid_field_type) != 16) {
 130                 /*
 131                  * UUID field is not of the expected size.
 132                  * Not an error, skip.
 133                  */
 134                 goto end;
 135         }
 136
 137         element_field_type = bt_ctf_field_type_array_get_element_type(
 138                 uuid_field_type);
 139         assert(element_field_type);
 140         if (bt_ctf_field_type_get_type_id(element_field_type) !=
 141                 CTF_TYPE_INTEGER) {
 142                 /* UUID array elements are not integers. Not an error, skip */
 143                 goto end;
 144         }
 145
 146         for (i = 0; i < 16; i++) {
 147                 struct bt_ctf_field *uuid_element =
 148                         bt_ctf_field_array_get_field(uuid_field, i);
 149
 150                 ret = bt_ctf_field_type_integer_get_signed(element_field_type);
 151                 assert(ret >= 0);
 152
 153                 if (ret) {
 154                         ret = bt_ctf_field_signed_integer_set_value(
 155                                 uuid_element, (int64_t) stream->trace->uuid[i]);
 156                 } else {
 157                         ret = bt_ctf_field_unsigned_integer_set_value(
 158                                 uuid_element,
 159                                 (uint64_t) stream->trace->uuid[i]);
 160                 }
 161                 bt_ctf_field_put(uuid_element);
 162                 if (ret) {
 163                         goto end;
 164                 }
 165         }
 166
 167 end:
 168         if (uuid_field) {
 169                 bt_ctf_field_put(uuid_field);
 170         }
 171         if (uuid_field_type) {
 172                 bt_ctf_field_type_put(uuid_field_type);
 173         }
 174         if (element_field_type) {
 175                 bt_ctf_field_type_put(element_field_type);
 176         }
 177         return ret;
 178 }
 179 static
 180 int set_packet_header_stream_id(struct bt_ctf_stream *stream)
 181 {
 182         int ret = 0;
 183         uint32_t stream_id;
 184         struct bt_ctf_field_type *stream_id_field_type = NULL;
 185         struct bt_ctf_field *stream_id_field = bt_ctf_field_structure_get_field(
 186                 stream->packet_header, "stream_id");
 187
 188         if (!stream_id_field) {
 189                 /* No stream_id field found. Not an error, skip. */
 190                 goto end;
 191         }
 192
 193         if (!bt_ctf_field_validate(stream_id_field)) {
 194                 /* Value already set. Not an error, skip. */
 195                 goto end;
 196         }
 197
 198         stream_id_field_type = bt_ctf_field_get_type(stream_id_field);
 199         assert(stream_id_field_type);
 200         if (bt_ctf_field_type_get_type_id(stream_id_field_type) !=
 201                 CTF_TYPE_INTEGER) {
 202                 /* stream_id field is not an integer. Not an error, skip. */
 203                 goto end;
 204         }
 205
 206         stream_id = stream->stream_class->id;
 207         ret = bt_ctf_field_type_integer_get_signed(stream_id_field_type);
 208         assert(ret >= 0);
 209         if (ret) {
 210                 ret = bt_ctf_field_signed_integer_set_value(stream_id_field,
 211                         (int64_t) stream_id);
 212         } else {
 213                 ret = bt_ctf_field_unsigned_integer_set_value(stream_id_field,
 214                         (uint64_t) stream_id);
 215         }
 216 end:
 217         if (stream_id_field) {
 218                 bt_ctf_field_put(stream_id_field);
 219         }
 220         if (stream_id_field_type) {
 221                 bt_ctf_field_type_put(stream_id_field_type);
 222         }
 223         return ret;
 224 }
 225
 226 static
 227 int set_packet_header(struct bt_ctf_stream *stream)
 228 {
 229         int ret;
 230
 231         ret = set_packet_header_magic(stream);
 232         if (ret) {
 233                 goto end;
 234         }
 235
 236         ret = set_packet_header_uuid(stream);
 237         if (ret) {
 238                 goto end;
 239         }
 240
 241         ret = set_packet_header_stream_id(stream);
 242         if (ret) {
 243                 goto end;
 244         }
 245 end:
 246         return ret;
 247 }
 248
 249 BT_HIDDEN
 250 struct bt_ctf_stream *bt_ctf_stream_create(
 251         struct bt_ctf_stream_class *stream_class,
 252         struct bt_ctf_trace *trace)
 253 {
 254         int ret;
 255         struct bt_ctf_stream *stream = NULL;
 256
 257         if (!stream_class || !trace) {
 258                 goto end;
 259         }
 260
 261         stream = g_new0(struct bt_ctf_stream, 1);
 262         if (!stream) {
 263                 goto end;
 264         }
 265
 266         stream->trace = trace;
 267         bt_ctf_ref_init(&stream->ref_count);
 268         stream->packet_context = bt_ctf_field_create(
 269                 stream_class->packet_context_type);
 270         if (!stream->packet_context) {
 271                 goto error_destroy;
 272         }
 273
 274         /*
 275          * A stream class may not have a stream event context defined
 276          * in which case this stream will never have a stream_event_context
 277          * member since, after a stream's creation, the parent stream class
 278          * is "frozen" (immutable).
 279          */
 280         if (stream_class->event_context_type) {
 281                 stream->event_context = bt_ctf_field_create(
 282                         stream_class->event_context_type);
 283                 if (!stream->packet_context) {
 284                         goto error_destroy;
 285                 }
 286         }
 287
 288         /* Initialize events_discarded */
 289         ret = set_structure_field_integer(stream->packet_context,
 290                 "events_discarded", 0);
 291         if (ret) {
 292                 goto error_destroy;
 293         }
 294
 295         stream->pos.fd = -1;
 296         stream->id = stream_class->next_stream_id++;
 297         stream->stream_class = stream_class;
 298         bt_ctf_stream_class_get(stream_class);
 299         bt_ctf_stream_class_freeze(stream_class);
 300         stream->events = g_ptr_array_new_with_free_func(
 301                 (GDestroyNotify) bt_ctf_event_put);
 302         if (!stream->events) {
 303                 goto error_destroy;
 304         }
 305         if (stream_class->event_context_type) {
 306                 stream->event_contexts = g_ptr_array_new_with_free_func(
 307                         (GDestroyNotify) bt_ctf_field_put);
 308                 if (!stream->event_contexts) {
 309                         goto error_destroy;
 310                 }
 311         }
 312
 313         /* A trace is not allowed to have a NULL packet header */
 314         assert(trace->packet_header_type);
 315         stream->packet_header = bt_ctf_field_create(trace->packet_header_type);
 316         /*
 317          * Attempt to populate the default trace packet header fields
 318          * (magic, uuid and stream_id). This will _not_ fail shall the
 319          * fields not be found or be of an incompatible type; they will
 320          * simply not be populated automatically. The user will have to
 321          * make sure to set the trace packet header fields himself before
 322          * flushing.
 323          */
 324         ret = set_packet_header(stream);
 325         if (ret) {
 326                 goto error_destroy;
 327         }
 328 end:
 329         return stream;
 330 error_destroy:
 331         bt_ctf_stream_destroy(&stream->ref_count);
 332         return NULL;
 333 }
 334
 335 BT_HIDDEN
 336 int bt_ctf_stream_set_fd(struct bt_ctf_stream *stream, int fd)
 337 {
 338         int ret = 0;
 339
 340         if (stream->pos.fd != -1) {
 341                 ret = -1;
 342                 goto end;
 343         }
 344
 345         ctf_init_pos(&stream->pos, NULL, fd, O_RDWR);
 346         stream->pos.fd = fd;
 347 end:
 348         return ret;
 349 }
 350
 351 BT_HIDDEN
 352 void bt_ctf_stream_set_trace(struct bt_ctf_stream *stream,
 353                 struct bt_ctf_trace *trace)
 354 {
 355         stream->trace = trace;
 356 }
 357
 358 struct bt_ctf_stream_class *bt_ctf_stream_get_class(
 359                 struct bt_ctf_stream *stream)
 360 {
 361         struct bt_ctf_stream_class *stream_class = NULL;
 362
 363         if (!stream) {
 364                 goto end;
 365         }
 366
 367         stream_class = stream->stream_class;
 368         bt_ctf_stream_class_get(stream_class);
 369 end:
 370         return stream_class;
 371 }
 372
 373 int bt_ctf_stream_get_discarded_events_count(
 374                 struct bt_ctf_stream *stream, uint64_t *count)
 375 {
 376         int64_t ret = 0;
 377         int field_signed;
 378         struct bt_ctf_field *events_discarded_field = NULL;
 379         struct bt_ctf_field_type *events_discarded_field_type = NULL;
 380
 381         if (!stream || !count || !stream->packet_context) {
 382                 ret = -1;
 383                 goto end;
 384         }
 385
 386         events_discarded_field = bt_ctf_field_structure_get_field(
 387                 stream->packet_context, "events_discarded");
 388         if (!events_discarded_field) {
 389                 ret = -1;
 390                 goto end;
 391         }
 392
 393         events_discarded_field_type = bt_ctf_field_get_type(
 394                 events_discarded_field);
 395         if (!events_discarded_field_type) {
 396                 ret = -1;
 397                 goto end;
 398         }
 399
 400         field_signed = bt_ctf_field_type_integer_get_signed(
 401                 events_discarded_field_type);
 402         if (field_signed < 0) {
 403                 ret = field_signed;
 404                 goto end;
 405         }
 406
 407         if (field_signed) {
 408                 int64_t signed_count;
 409
 410                 ret = bt_ctf_field_signed_integer_get_value(
 411                         events_discarded_field, &signed_count);
 412                 if (ret) {
 413                         goto end;
 414                 }
 415                 if (signed_count < 0) {
 416                         /* Invalid value */
 417                         ret = -1;
 418                         goto end;
 419                 }
 420                 *count = (uint64_t) signed_count;
 421         } else {
 422                 ret = bt_ctf_field_unsigned_integer_get_value(
 423                         events_discarded_field, count);
 424                 if (ret) {
 425                         goto end;
 426                 }
 427         }
 428 end:
 429         if (events_discarded_field) {
 430                 bt_ctf_field_put(events_discarded_field);
 431         }
 432         if (events_discarded_field_type) {
 433                 bt_ctf_field_type_put(events_discarded_field_type);
 434         }
 435         return ret;
 436 }
 437
 438 void bt_ctf_stream_append_discarded_events(struct bt_ctf_stream *stream,
 439                 uint64_t event_count)
 440 {
 441         int ret;
 442         int field_signed;
 443         uint64_t previous_count;
 444         uint64_t new_count;
 445         struct bt_ctf_field *events_discarded_field = NULL;
 446         struct bt_ctf_field_type *events_discarded_field_type = NULL;
 447
 448         if (!stream || !stream->packet_context) {
 449                 goto end;
 450         }
 451
 452         ret = bt_ctf_stream_get_discarded_events_count(stream,
 453                 &previous_count);
 454         if (ret) {
 455                 goto end;
 456         }
 457
 458         events_discarded_field = bt_ctf_field_structure_get_field(
 459                 stream->packet_context, "events_discarded");
 460         if (!events_discarded_field) {
 461                 goto end;
 462         }
 463
 464         events_discarded_field_type = bt_ctf_field_get_type(
 465                 events_discarded_field);
 466         if (!events_discarded_field_type) {
 467                 goto end;
 468         }
 469
 470         field_signed = bt_ctf_field_type_integer_get_signed(
 471                 events_discarded_field_type);
 472         if (field_signed < 0) {
 473                 goto end;
 474         }
 475
 476         new_count = previous_count + event_count;
 477         if (field_signed) {
 478                 ret = bt_ctf_field_signed_integer_set_value(
 479                         events_discarded_field, (int64_t) new_count);
 480                 if (ret) {
 481                         goto end;
 482                 }
 483         } else {
 484                 ret = bt_ctf_field_unsigned_integer_set_value(
 485                         events_discarded_field, new_count);
 486                 if (ret) {
 487                         goto end;
 488                 }
 489         }
 490
 491 end:
 492         if (events_discarded_field) {
 493                 bt_ctf_field_put(events_discarded_field);
 494         }
 495         if (events_discarded_field_type) {
 496                 bt_ctf_field_type_put(events_discarded_field_type);
 497         }
 498 }
 499
 500 int bt_ctf_stream_append_event(struct bt_ctf_stream *stream,
 501                 struct bt_ctf_event *event)
 502 {
 503         int ret = 0;
 504         uint64_t timestamp;
 505         struct bt_ctf_field *event_context_copy = NULL;
 506
 507         if (!stream || !event) {
 508                 ret = -1;
 509                 goto end;
 510         }
 511
 512         /* Make sure the event's payload is set */
 513         ret = bt_ctf_event_validate(event);
 514         if (ret) {
 515                 goto end;
 516         }
 517
 518         /* Sample the current stream event context by copying it */
 519         if (stream->event_context) {
 520                 /* Make sure the event context's payload is set */
 521                 ret = bt_ctf_field_validate(stream->event_context);
 522                 if (ret) {
 523                         goto end;
 524                 }
 525
 526                 event_context_copy = bt_ctf_field_copy(stream->event_context);
 527                 if (!event_context_copy) {
 528                         ret = -1;
 529                         goto end;
 530                 }
 531         }
 532
 533         timestamp = bt_ctf_clock_get_time(stream->stream_class->clock);
 534         ret = bt_ctf_event_set_timestamp(event, timestamp);
 535         if (ret) {
 536                 goto end;
 537         }
 538
 539         bt_ctf_event_get(event);
 540         /* Save the new event along with its associated stream event context */
 541         g_ptr_array_add(stream->events, event);
 542         if (event_context_copy) {
 543                 g_ptr_array_add(stream->event_contexts, event_context_copy);
 544         }
 545 end:
 546         return ret;
 547 }
 548
 549 struct bt_ctf_field *bt_ctf_stream_get_packet_context(
 550                 struct bt_ctf_stream *stream)
 551 {
 552         struct bt_ctf_field *packet_context = NULL;
 553
 554         if (!stream) {
 555                 goto end;
 556         }
 557
 558         packet_context = stream->packet_context;
 559         if (packet_context) {
 560                 bt_ctf_field_get(packet_context);
 561         }
 562 end:
 563         return packet_context;
 564 }
 565
 566 int bt_ctf_stream_set_packet_context(struct bt_ctf_stream *stream,
 567                 struct bt_ctf_field *field)
 568 {
 569         int ret = 0;
 570         struct bt_ctf_field_type *field_type;
 571
 572         if (!stream || !field) {
 573                 ret = -1;
 574                 goto end;
 575         }
 576
 577         field_type = bt_ctf_field_get_type(field);
 578         if (field_type != stream->stream_class->packet_context_type) {
 579                 ret = -1;
 580                 goto end;
 581         }
 582
 583         bt_ctf_field_type_put(field_type);
 584         bt_ctf_field_get(field);
 585         bt_ctf_field_put(stream->packet_context);
 586         stream->packet_context = field;
 587 end:
 588         return ret;
 589 }
 590
 591 struct bt_ctf_field *bt_ctf_stream_get_event_context(
 592                 struct bt_ctf_stream *stream)
 593 {
 594         struct bt_ctf_field *event_context = NULL;
 595
 596         if (!stream) {
 597                 goto end;
 598         }
 599
 600         event_context = stream->event_context;
 601         if (event_context) {
 602                 bt_ctf_field_get(event_context);
 603         }
 604 end:
 605         return event_context;
 606 }
 607
 608 int bt_ctf_stream_set_event_context(struct bt_ctf_stream *stream,
 609                 struct bt_ctf_field *field)
 610 {
 611         int ret = 0;
 612         struct bt_ctf_field_type *field_type = NULL;
 613
 614         if (!stream || !field) {
 615                 ret = -1;
 616                 goto end;
 617         }
 618
 619         field_type = bt_ctf_field_get_type(field);
 620         if (field_type != stream->stream_class->event_context_type) {
 621                 ret = -1;
 622                 goto end;
 623         }
 624
 625         bt_ctf_field_get(field);
 626         bt_ctf_field_put(stream->event_context);
 627         stream->event_context = field;
 628 end:
 629         if (field_type) {
 630                 bt_ctf_field_type_put(field_type);
 631         }
 632         return ret;
 633 }
 634
 635 struct bt_ctf_field *bt_ctf_stream_get_packet_header(
 636                 struct bt_ctf_stream *stream)
 637 {
 638         struct bt_ctf_field *packet_header = NULL;
 639
 640         if (!stream) {
 641                 goto end;
 642         }
 643
 644         packet_header = stream->packet_header;
 645         if (packet_header) {
 646                 bt_ctf_field_get(packet_header);
 647         }
 648 end:
 649         return packet_header;
 650 }
 651
 652 int bt_ctf_stream_set_packet_header(struct bt_ctf_stream *stream,
 653                 struct bt_ctf_field *field)
 654 {
 655         int ret = 0;
 656         struct bt_ctf_field_type *field_type = NULL;
 657
 658         if (!stream || !field) {
 659                 ret = -1;
 660                 goto end;
 661         }
 662
 663         field_type = bt_ctf_field_get_type(field);
 664         if (field_type != stream->trace->packet_header_type) {
 665                 ret = -1;
 666                 goto end;
 667         }
 668
 669         bt_ctf_field_get(field);
 670         bt_ctf_field_put(stream->packet_header);
 671         stream->packet_header = field;
 672 end:
 673         if (field_type) {
 674                 bt_ctf_field_type_put(field_type);
 675         }
 676         return ret;
 677 }
 678
 679 int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
 680 {
 681         int ret = 0;
 682         size_t i;
 683         uint64_t timestamp_begin, timestamp_end, events_discarded;
 684         struct bt_ctf_stream_class *stream_class;
 685         struct bt_ctf_field *integer = NULL;
 686         struct ctf_stream_pos packet_context_pos;
 687
 688         if (!stream || stream->pos.fd < 0) {
 689                 /*
 690                  * Stream does not have an associated fd. It is,
 691                  * therefore, not a stream being used to write events.
 692                  */
 693                 ret = -1;
 694                 goto end;
 695         }
 696
 697         if (!stream->events->len) {
 698                 goto end;
 699         }
 700
 701         ret = bt_ctf_field_validate(stream->packet_header);
 702         if (ret) {
 703                 goto end;
 704         }
 705
 706         if (stream->flushed_packet_count) {
 707                 /* ctf_init_pos has already initialized the first packet */
 708                 ctf_packet_seek(&stream->pos.parent, 0, SEEK_CUR);
 709         }
 710
 711         ret = bt_ctf_field_serialize(stream->packet_header, &stream->pos);
 712         if (ret) {
 713                 goto end;
 714         }
 715
 716         stream_class = stream->stream_class;
 717         timestamp_begin = ((struct bt_ctf_event *) g_ptr_array_index(
 718                 stream->events, 0))->timestamp;
 719         timestamp_end = ((struct bt_ctf_event *) g_ptr_array_index(
 720                 stream->events, stream->events->len - 1))->timestamp;
 721
 722         /* Set the default context attributes if present and unset. */
 723         ret = set_structure_field_integer(stream->packet_context,
 724                 "timestamp_begin", timestamp_begin);
 725         if (ret) {
 726                 goto end;
 727         }
 728
 729         ret = set_structure_field_integer(stream->packet_context,
 730                 "timestamp_end", timestamp_end);
 731         if (ret) {
 732                 goto end;
 733         }
 734
 735         ret = set_structure_field_integer(stream->packet_context,
 736                 "content_size", UINT64_MAX);
 737         if (ret) {
 738                 goto end;
 739         }
 740
 741         ret = set_structure_field_integer(stream->packet_context,
 742                 "packet_size", UINT64_MAX);
 743         if (ret) {
 744                 goto end;
 745         }
 746
 747         /* Write packet context */
 748         memcpy(&packet_context_pos, &stream->pos,
 749                sizeof(struct ctf_stream_pos));
 750         ret = bt_ctf_field_serialize(stream->packet_context,
 751                 &stream->pos);
 752         if (ret) {
 753                 goto end;
 754         }
 755
 756         ret = bt_ctf_stream_get_discarded_events_count(stream,
 757                 &events_discarded);
 758         if (ret) {
 759                 goto end;
 760         }
 761
 762         /* Unset the packet context's fields. */
 763         ret = bt_ctf_field_reset(stream->packet_context);
 764         if (ret) {
 765                 goto end;
 766         }
 767
 768         /* Set the previous number of discarded events. */
 769         ret = set_structure_field_integer(stream->packet_context,
 770                 "events_discarded", events_discarded);
 771         if (ret) {
 772                 goto end;
 773         }
 774
 775         for (i = 0; i < stream->events->len; i++) {
 776                 struct bt_ctf_event *event = g_ptr_array_index(
 777                         stream->events, i);
 778                 uint32_t event_id = bt_ctf_event_class_get_id(
 779                         event->event_class);
 780                 uint64_t timestamp = bt_ctf_event_get_timestamp(event);
 781
 782                 ret = bt_ctf_field_reset(stream_class->event_header);
 783                 if (ret) {
 784                         goto end;
 785                 }
 786
 787                 ret = set_structure_field_integer(stream_class->event_header,
 788                         "id", event_id);
 789                 if (ret) {
 790                         goto end;
 791                 }
 792                 ret = set_structure_field_integer(stream_class->event_header,
 793                         "timestamp", timestamp);
 794                 if (ret) {
 795                         goto end;
 796                 }
 797
 798                 /* Write event header */
 799                 ret = bt_ctf_field_serialize(stream_class->event_header,
 800                         &stream->pos);
 801                 if (ret) {
 802                         goto end;
 803                 }
 804
 805                 /* Write stream event context */
 806                 if (stream->event_contexts) {
 807                         ret = bt_ctf_field_serialize(
 808                                 g_ptr_array_index(stream->event_contexts, i),
 809                                 &stream->pos);
 810                         if (ret) {
 811                                 goto end;
 812                         }
 813                 }
 814
 815                 /* Write event content */
 816                 ret = bt_ctf_event_serialize(event, &stream->pos);
 817                 if (ret) {
 818                         goto end;
 819                 }
 820         }
 821
 822         /*
 823          * Update the packet total size and content size and overwrite the
 824          * packet context.
 825          * Copy base_mma as the packet may have been remapped (e.g. when a
 826          * packet is resized).
 827          */
 828         packet_context_pos.base_mma = stream->pos.base_mma;
 829         ret = set_structure_field_integer(stream->packet_context,
 830                 "content_size", stream->pos.offset);
 831         if (ret) {
 832                 goto end;
 833         }
 834
 835         ret = set_structure_field_integer(stream->packet_context,
 836                 "packet_size", stream->pos.packet_size);
 837         if (ret) {
 838                 goto end;
 839         }
 840
 841         ret = bt_ctf_field_serialize(stream->packet_context,
 842                 &packet_context_pos);
 843         if (ret) {
 844                 goto end;
 845         }
 846
 847         g_ptr_array_set_size(stream->events, 0);
 848         if (stream->event_contexts) {
 849                 g_ptr_array_set_size(stream->event_contexts, 0);
 850         }
 851         stream->flushed_packet_count++;
 852 end:
 853         bt_ctf_field_put(integer);
 854         return ret;
 855 }
 856
 857 void bt_ctf_stream_get(struct bt_ctf_stream *stream)
 858 {
 859         if (!stream) {
 860                 return;
 861         }
 862
 863         bt_ctf_ref_get(&stream->ref_count);
 864 }
 865
 866 void bt_ctf_stream_put(struct bt_ctf_stream *stream)
 867 {
 868         if (!stream) {
 869                 return;
 870         }
 871
 872         bt_ctf_ref_put(&stream->ref_count, bt_ctf_stream_destroy);
 873 }
 874
 875 static
 876 void bt_ctf_stream_destroy(struct bt_ctf_ref *ref)
 877 {
 878         struct bt_ctf_stream *stream;
 879
 880         if (!ref) {
 881                 return;
 882         }
 883
 884         stream = container_of(ref, struct bt_ctf_stream, ref_count);
 885         ctf_fini_pos(&stream->pos);
 886         if (close(stream->pos.fd)) {
 887                 perror("close");
 888         }
 889
 890         if (stream->stream_class) {
 891                 bt_ctf_stream_class_put(stream->stream_class);
 892         }
 893         if (stream->events) {
 894                 g_ptr_array_free(stream->events, TRUE);
 895         }
 896         if (stream->event_contexts) {
 897                 g_ptr_array_free(stream->event_contexts, TRUE);
 898         }
 899         if (stream->packet_header) {
 900                 bt_ctf_field_put(stream->packet_header);
 901         }
 902         if (stream->packet_context) {
 903                 bt_ctf_field_put(stream->packet_context);
 904         }
 905         if (stream->event_context) {
 906                 bt_ctf_field_put(stream->event_context);
 907         }
 908         g_free(stream);
 909 }
 910
 911 static
 912 int set_structure_field_integer(struct bt_ctf_field *structure, char *name,
 913                 uint64_t value)
 914 {
 915         int ret = 0;
 916         struct bt_ctf_field_type *field_type = NULL;
 917         struct bt_ctf_field *integer =
 918                 bt_ctf_field_structure_get_field(structure, name);
 919
 920         if (!structure || !name) {
 921                 ret = -1;
 922                 goto end;
 923         }
 924
 925         if (!integer) {
 926                 /* Field not found, not an error. */
 927                 goto end;
 928         }
 929
 930         /* Make sure the payload has not already been set. */
 931         if (!bt_ctf_field_validate(integer)) {
 932                 /* Payload already set, not an error */
 933                 goto end;
 934         }
 935
 936         field_type = bt_ctf_field_get_type(integer);
 937         /* Something is serioulsly wrong */
 938         assert(field_type);
 939         if (bt_ctf_field_type_get_type_id(field_type) != CTF_TYPE_INTEGER) {
 940                 /*
 941                  * The user most likely meant for us to populate this field
 942                  * automatically. However, we can only do this if the field
 943                  * is an integer. Return an error.
 944                  */
 945                 ret = -1;
 946                 goto end;
 947         }
 948
 949         if (bt_ctf_field_type_integer_get_signed(field_type)) {
 950                 ret = bt_ctf_field_signed_integer_set_value(integer,
 951                         (int64_t) value);
 952         } else {
 953                 ret = bt_ctf_field_unsigned_integer_set_value(integer, value);
 954         }
 955 end:
 956         if (integer) {
 957                 bt_ctf_field_put(integer);
 958         }
 959         if (field_type) {
 960                 bt_ctf_field_type_put(field_type);
 961         }
 962         return ret;
 963 }