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         stream->events = g_ptr_array_new_with_free_func(
 300                 (GDestroyNotify) bt_ctf_event_put);
 301         if (!stream->events) {
 302                 goto error_destroy;
 303         }
 304         if (stream_class->event_context_type) {
 305                 stream->event_contexts = g_ptr_array_new_with_free_func(
 306                         (GDestroyNotify) bt_ctf_field_put);
 307                 if (!stream->event_contexts) {
 308                         goto error_destroy;
 309                 }
 310         }
 311
 312         /* A trace is not allowed to have a NULL packet header */
 313         assert(trace->packet_header_type);
 314         stream->packet_header = bt_ctf_field_create(trace->packet_header_type);
 315         /*
 316          * Attempt to populate the default trace packet header fields
 317          * (magic, uuid and stream_id). This will _not_ fail shall the
 318          * fields not be found or be of an incompatible type; they will
 319          * simply not be populated automatically. The user will have to
 320          * make sure to set the trace packet header fields himself before
 321          * flushing.
 322          */
 323         ret = set_packet_header(stream);
 324         if (ret) {
 325                 goto error_destroy;
 326         }
 327 end:
 328         return stream;
 329 error_destroy:
 330         bt_ctf_stream_destroy(&stream->ref_count);
 331         return NULL;
 332 }
 333
 334 BT_HIDDEN
 335 int bt_ctf_stream_set_fd(struct bt_ctf_stream *stream, int fd)
 336 {
 337         int ret = 0;
 338
 339         if (stream->pos.fd != -1) {
 340                 ret = -1;
 341                 goto end;
 342         }
 343
 344         ctf_init_pos(&stream->pos, NULL, fd, O_RDWR);
 345         stream->pos.fd = fd;
 346 end:
 347         return ret;
 348 }
 349
 350 BT_HIDDEN
 351 void bt_ctf_stream_set_trace(struct bt_ctf_stream *stream,
 352                 struct bt_ctf_trace *trace)
 353 {
 354         stream->trace = trace;
 355 }
 356
 357 struct bt_ctf_stream_class *bt_ctf_stream_get_class(
 358                 struct bt_ctf_stream *stream)
 359 {
 360         struct bt_ctf_stream_class *stream_class = NULL;
 361
 362         if (!stream) {
 363                 goto end;
 364         }
 365
 366         stream_class = stream->stream_class;
 367         bt_ctf_stream_class_get(stream_class);
 368 end:
 369         return stream_class;
 370 }
 371
 372 int bt_ctf_stream_get_discarded_events_count(
 373                 struct bt_ctf_stream *stream, uint64_t *count)
 374 {
 375         int64_t ret = 0;
 376         int field_signed;
 377         struct bt_ctf_field *events_discarded_field = NULL;
 378         struct bt_ctf_field_type *events_discarded_field_type = NULL;
 379
 380         if (!stream || !count || !stream->packet_context) {
 381                 ret = -1;
 382                 goto end;
 383         }
 384
 385         events_discarded_field = bt_ctf_field_structure_get_field(
 386                 stream->packet_context, "events_discarded");
 387         if (!events_discarded_field) {
 388                 ret = -1;
 389                 goto end;
 390         }
 391
 392         events_discarded_field_type = bt_ctf_field_get_type(
 393                 events_discarded_field);
 394         if (!events_discarded_field_type) {
 395                 ret = -1;
 396                 goto end;
 397         }
 398
 399         field_signed = bt_ctf_field_type_integer_get_signed(
 400                 events_discarded_field_type);
 401         if (field_signed < 0) {
 402                 ret = field_signed;
 403                 goto end;
 404         }
 405
 406         if (field_signed) {
 407                 int64_t signed_count;
 408
 409                 ret = bt_ctf_field_signed_integer_get_value(
 410                         events_discarded_field, &signed_count);
 411                 if (ret) {
 412                         goto end;
 413                 }
 414                 if (signed_count < 0) {
 415                         /* Invalid value */
 416                         ret = -1;
 417                         goto end;
 418                 }
 419                 *count = (uint64_t) signed_count;
 420         } else {
 421                 ret = bt_ctf_field_unsigned_integer_get_value(
 422                         events_discarded_field, count);
 423                 if (ret) {
 424                         goto end;
 425                 }
 426         }
 427 end:
 428         if (events_discarded_field) {
 429                 bt_ctf_field_put(events_discarded_field);
 430         }
 431         if (events_discarded_field_type) {
 432                 bt_ctf_field_type_put(events_discarded_field_type);
 433         }
 434         return ret;
 435 }
 436
 437 void bt_ctf_stream_append_discarded_events(struct bt_ctf_stream *stream,
 438                 uint64_t event_count)
 439 {
 440         int ret;
 441         int field_signed;
 442         uint64_t previous_count;
 443         uint64_t new_count;
 444         struct bt_ctf_field *events_discarded_field = NULL;
 445         struct bt_ctf_field_type *events_discarded_field_type = NULL;
 446
 447         if (!stream || !stream->packet_context) {
 448                 goto end;
 449         }
 450
 451         ret = bt_ctf_stream_get_discarded_events_count(stream,
 452                 &previous_count);
 453         if (ret) {
 454                 goto end;
 455         }
 456
 457         events_discarded_field = bt_ctf_field_structure_get_field(
 458                 stream->packet_context, "events_discarded");
 459         if (!events_discarded_field) {
 460                 goto end;
 461         }
 462
 463         events_discarded_field_type = bt_ctf_field_get_type(
 464                 events_discarded_field);
 465         if (!events_discarded_field_type) {
 466                 goto end;
 467         }
 468
 469         field_signed = bt_ctf_field_type_integer_get_signed(
 470                 events_discarded_field_type);
 471         if (field_signed < 0) {
 472                 goto end;
 473         }
 474
 475         new_count = previous_count + event_count;
 476         if (field_signed) {
 477                 ret = bt_ctf_field_signed_integer_set_value(
 478                         events_discarded_field, (int64_t) new_count);
 479                 if (ret) {
 480                         goto end;
 481                 }
 482         } else {
 483                 ret = bt_ctf_field_unsigned_integer_set_value(
 484                         events_discarded_field, new_count);
 485                 if (ret) {
 486                         goto end;
 487                 }
 488         }
 489
 490 end:
 491         if (events_discarded_field) {
 492                 bt_ctf_field_put(events_discarded_field);
 493         }
 494         if (events_discarded_field_type) {
 495                 bt_ctf_field_type_put(events_discarded_field_type);
 496         }
 497 }
 498
 499 int bt_ctf_stream_append_event(struct bt_ctf_stream *stream,
 500                 struct bt_ctf_event *event)
 501 {
 502         int ret = 0;
 503         struct bt_ctf_field *event_context_copy = NULL;
 504
 505         if (!stream || !event) {
 506                 ret = -1;
 507                 goto end;
 508         }
 509
 510         ret = bt_ctf_event_populate_event_header(event);
 511         if (ret) {
 512                 goto end;
 513         }
 514
 515         /* Make sure the event's payload is set */
 516         ret = bt_ctf_event_validate(event);
 517         if (ret) {
 518                 goto end;
 519         }
 520
 521         /* Sample the current stream event context by copying it */
 522         if (stream->event_context) {
 523                 /* Make sure the event context's payload is set */
 524                 ret = bt_ctf_field_validate(stream->event_context);
 525                 if (ret) {
 526                         goto end;
 527                 }
 528
 529                 event_context_copy = bt_ctf_field_copy(stream->event_context);
 530                 if (!event_context_copy) {
 531                         ret = -1;
 532                         goto end;
 533                 }
 534         }
 535
 536         bt_ctf_event_get(event);
 537         /* Save the new event along with its associated stream event context */
 538         g_ptr_array_add(stream->events, event);
 539         if (event_context_copy) {
 540                 g_ptr_array_add(stream->event_contexts, event_context_copy);
 541         }
 542 end:
 543         return ret;
 544 }
 545
 546 struct bt_ctf_field *bt_ctf_stream_get_packet_context(
 547                 struct bt_ctf_stream *stream)
 548 {
 549         struct bt_ctf_field *packet_context = NULL;
 550
 551         if (!stream) {
 552                 goto end;
 553         }
 554
 555         packet_context = stream->packet_context;
 556         if (packet_context) {
 557                 bt_ctf_field_get(packet_context);
 558         }
 559 end:
 560         return packet_context;
 561 }
 562
 563 int bt_ctf_stream_set_packet_context(struct bt_ctf_stream *stream,
 564                 struct bt_ctf_field *field)
 565 {
 566         int ret = 0;
 567         struct bt_ctf_field_type *field_type;
 568
 569         if (!stream || !field) {
 570                 ret = -1;
 571                 goto end;
 572         }
 573
 574         field_type = bt_ctf_field_get_type(field);
 575         if (field_type != stream->stream_class->packet_context_type) {
 576                 ret = -1;
 577                 goto end;
 578         }
 579
 580         bt_ctf_field_type_put(field_type);
 581         bt_ctf_field_get(field);
 582         bt_ctf_field_put(stream->packet_context);
 583         stream->packet_context = field;
 584 end:
 585         return ret;
 586 }
 587
 588 struct bt_ctf_field *bt_ctf_stream_get_event_context(
 589                 struct bt_ctf_stream *stream)
 590 {
 591         struct bt_ctf_field *event_context = NULL;
 592
 593         if (!stream) {
 594                 goto end;
 595         }
 596
 597         event_context = stream->event_context;
 598         if (event_context) {
 599                 bt_ctf_field_get(event_context);
 600         }
 601 end:
 602         return event_context;
 603 }
 604
 605 int bt_ctf_stream_set_event_context(struct bt_ctf_stream *stream,
 606                 struct bt_ctf_field *field)
 607 {
 608         int ret = 0;
 609         struct bt_ctf_field_type *field_type = NULL;
 610
 611         if (!stream || !field) {
 612                 ret = -1;
 613                 goto end;
 614         }
 615
 616         field_type = bt_ctf_field_get_type(field);
 617         if (field_type != stream->stream_class->event_context_type) {
 618                 ret = -1;
 619                 goto end;
 620         }
 621
 622         bt_ctf_field_get(field);
 623         bt_ctf_field_put(stream->event_context);
 624         stream->event_context = field;
 625 end:
 626         if (field_type) {
 627                 bt_ctf_field_type_put(field_type);
 628         }
 629         return ret;
 630 }
 631
 632 struct bt_ctf_field *bt_ctf_stream_get_packet_header(
 633                 struct bt_ctf_stream *stream)
 634 {
 635         struct bt_ctf_field *packet_header = NULL;
 636
 637         if (!stream) {
 638                 goto end;
 639         }
 640
 641         packet_header = stream->packet_header;
 642         if (packet_header) {
 643                 bt_ctf_field_get(packet_header);
 644         }
 645 end:
 646         return packet_header;
 647 }
 648
 649 int bt_ctf_stream_set_packet_header(struct bt_ctf_stream *stream,
 650                 struct bt_ctf_field *field)
 651 {
 652         int ret = 0;
 653         struct bt_ctf_field_type *field_type = NULL;
 654
 655         if (!stream || !field) {
 656                 ret = -1;
 657                 goto end;
 658         }
 659
 660         field_type = bt_ctf_field_get_type(field);
 661         if (field_type != stream->trace->packet_header_type) {
 662                 ret = -1;
 663                 goto end;
 664         }
 665
 666         bt_ctf_field_get(field);
 667         bt_ctf_field_put(stream->packet_header);
 668         stream->packet_header = field;
 669 end:
 670         if (field_type) {
 671                 bt_ctf_field_type_put(field_type);
 672         }
 673         return ret;
 674 }
 675
 676 static
 677 int get_event_header_timestamp(struct bt_ctf_field *event_header, uint64_t *timestamp)
 678 {
 679         int ret = 0;
 680         struct bt_ctf_field *timestamp_field = NULL;
 681         struct bt_ctf_field_type *timestamp_field_type = NULL;
 682
 683         timestamp_field = bt_ctf_field_structure_get_field(event_header,
 684                 "timestamp");
 685         if (!timestamp_field) {
 686                 ret = -1;
 687                 goto end;
 688         }
 689
 690         timestamp_field_type = bt_ctf_field_get_type(timestamp_field);
 691         assert(timestamp_field_type);
 692         if (bt_ctf_field_type_get_type_id(timestamp_field_type) !=
 693                 CTF_TYPE_INTEGER) {
 694                 ret = -1;
 695                 goto end;
 696         }
 697
 698         if (bt_ctf_field_type_integer_get_signed(timestamp_field_type)) {
 699                 int64_t val;
 700
 701                 ret = bt_ctf_field_signed_integer_get_value(timestamp_field,
 702                         &val);
 703                 if (ret) {
 704                         goto end;
 705                 }
 706                 *timestamp = (uint64_t) val;
 707         } else {
 708                 ret = bt_ctf_field_unsigned_integer_get_value(timestamp_field,
 709                         timestamp);
 710                 if (ret) {
 711                         goto end;
 712                 }
 713         }
 714 end:
 715         bt_ctf_field_put(timestamp_field);
 716         bt_ctf_field_type_put(timestamp_field_type);
 717         return ret;
 718 }
 719
 720 int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
 721 {
 722         int ret = 0;
 723         size_t i;
 724         uint64_t timestamp_begin, timestamp_end, events_discarded;
 725         struct bt_ctf_field *integer = NULL;
 726         struct ctf_stream_pos packet_context_pos;
 727
 728         if (!stream || stream->pos.fd < 0) {
 729                 /*
 730                  * Stream does not have an associated fd. It is,
 731                  * therefore, not a stream being used to write events.
 732                  */
 733                 ret = -1;
 734                 goto end;
 735         }
 736
 737         if (!stream->events->len) {
 738                 goto end;
 739         }
 740
 741         ret = bt_ctf_field_validate(stream->packet_header);
 742         if (ret) {
 743                 goto end;
 744         }
 745
 746         /* mmap the next packet */
 747         ctf_packet_seek(&stream->pos.parent, 0, SEEK_CUR);
 748
 749         ret = bt_ctf_field_serialize(stream->packet_header, &stream->pos);
 750         if (ret) {
 751                 goto end;
 752         }
 753
 754         /* Set the default context attributes if present and unset. */
 755         if (!get_event_header_timestamp(
 756                 ((struct bt_ctf_event *) g_ptr_array_index(
 757                 stream->events, 0))->event_header, &timestamp_begin)) {
 758                 ret = set_structure_field_integer(stream->packet_context,
 759                         "timestamp_begin", timestamp_begin);
 760                 if (ret) {
 761                         goto end;
 762                 }
 763         }
 764
 765         if (!get_event_header_timestamp(
 766                 ((struct bt_ctf_event *) g_ptr_array_index(
 767                 stream->events, stream->events->len - 1))->event_header,
 768                 &timestamp_end)) {
 769
 770                 ret = set_structure_field_integer(stream->packet_context,
 771                         "timestamp_end", timestamp_end);
 772                 if (ret) {
 773                         goto end;
 774                 }
 775         }
 776         ret = set_structure_field_integer(stream->packet_context,
 777                 "content_size", UINT64_MAX);
 778         if (ret) {
 779                 goto end;
 780         }
 781
 782         ret = set_structure_field_integer(stream->packet_context,
 783                 "packet_size", UINT64_MAX);
 784         if (ret) {
 785                 goto end;
 786         }
 787
 788         /* Write packet context */
 789         memcpy(&packet_context_pos, &stream->pos,
 790                sizeof(struct ctf_stream_pos));
 791         ret = bt_ctf_field_serialize(stream->packet_context,
 792                 &stream->pos);
 793         if (ret) {
 794                 goto end;
 795         }
 796
 797         ret = bt_ctf_stream_get_discarded_events_count(stream,
 798                 &events_discarded);
 799         if (ret) {
 800                 goto end;
 801         }
 802
 803         /* Unset the packet context's fields. */
 804         ret = bt_ctf_field_reset(stream->packet_context);
 805         if (ret) {
 806                 goto end;
 807         }
 808
 809         /* Set the previous number of discarded events. */
 810         ret = set_structure_field_integer(stream->packet_context,
 811                 "events_discarded", events_discarded);
 812         if (ret) {
 813                 goto end;
 814         }
 815
 816         for (i = 0; i < stream->events->len; i++) {
 817                 struct bt_ctf_event *event = g_ptr_array_index(
 818                         stream->events, i);
 819
 820                 ret = bt_ctf_field_reset(event->event_header);
 821                 if (ret) {
 822                         goto end;
 823                 }
 824
 825                 /* Write event header */
 826                 ret = bt_ctf_field_serialize(event->event_header,
 827                         &stream->pos);
 828                 if (ret) {
 829                         goto end;
 830                 }
 831
 832                 /* Write stream event context */
 833                 if (stream->event_contexts) {
 834                         ret = bt_ctf_field_serialize(
 835                                 g_ptr_array_index(stream->event_contexts, i),
 836                                 &stream->pos);
 837                         if (ret) {
 838                                 goto end;
 839                         }
 840                 }
 841
 842                 /* Write event content */
 843                 ret = bt_ctf_event_serialize(event, &stream->pos);
 844                 if (ret) {
 845                         goto end;
 846                 }
 847         }
 848
 849         /*
 850          * Update the packet total size and content size and overwrite the
 851          * packet context.
 852          * Copy base_mma as the packet may have been remapped (e.g. when a
 853          * packet is resized).
 854          */
 855         packet_context_pos.base_mma = stream->pos.base_mma;
 856         ret = set_structure_field_integer(stream->packet_context,
 857                 "content_size", stream->pos.offset);
 858         if (ret) {
 859                 goto end;
 860         }
 861
 862         ret = set_structure_field_integer(stream->packet_context,
 863                 "packet_size", stream->pos.packet_size);
 864         if (ret) {
 865                 goto end;
 866         }
 867
 868         ret = bt_ctf_field_serialize(stream->packet_context,
 869                 &packet_context_pos);
 870         if (ret) {
 871                 goto end;
 872         }
 873
 874         g_ptr_array_set_size(stream->events, 0);
 875         if (stream->event_contexts) {
 876                 g_ptr_array_set_size(stream->event_contexts, 0);
 877         }
 878         stream->flushed_packet_count++;
 879 end:
 880         bt_ctf_field_put(integer);
 881         return ret;
 882 }
 883
 884 void bt_ctf_stream_get(struct bt_ctf_stream *stream)
 885 {
 886         if (!stream) {
 887                 return;
 888         }
 889
 890         bt_ctf_ref_get(&stream->ref_count);
 891 }
 892
 893 void bt_ctf_stream_put(struct bt_ctf_stream *stream)
 894 {
 895         if (!stream) {
 896                 return;
 897         }
 898
 899         bt_ctf_ref_put(&stream->ref_count, bt_ctf_stream_destroy);
 900 }
 901
 902 static
 903 void bt_ctf_stream_destroy(struct bt_ctf_ref *ref)
 904 {
 905         struct bt_ctf_stream *stream;
 906
 907         if (!ref) {
 908                 return;
 909         }
 910
 911         stream = container_of(ref, struct bt_ctf_stream, ref_count);
 912         ctf_fini_pos(&stream->pos);
 913         if (close(stream->pos.fd)) {
 914                 perror("close");
 915         }
 916
 917         if (stream->stream_class) {
 918                 bt_ctf_stream_class_put(stream->stream_class);
 919         }
 920         if (stream->events) {
 921                 g_ptr_array_free(stream->events, TRUE);
 922         }
 923         if (stream->event_contexts) {
 924                 g_ptr_array_free(stream->event_contexts, TRUE);
 925         }
 926         if (stream->packet_header) {
 927                 bt_ctf_field_put(stream->packet_header);
 928         }
 929         if (stream->packet_context) {
 930                 bt_ctf_field_put(stream->packet_context);
 931         }
 932         if (stream->event_context) {
 933                 bt_ctf_field_put(stream->event_context);
 934         }
 935         g_free(stream);
 936 }
 937
 938 static
 939 int set_structure_field_integer(struct bt_ctf_field *structure, char *name,
 940                 uint64_t value)
 941 {
 942         int ret = 0;
 943         struct bt_ctf_field_type *field_type = NULL;
 944         struct bt_ctf_field *integer =
 945                 bt_ctf_field_structure_get_field(structure, name);
 946
 947         if (!structure || !name) {
 948                 ret = -1;
 949                 goto end;
 950         }
 951
 952         if (!integer) {
 953                 /* Field not found, not an error. */
 954                 goto end;
 955         }
 956
 957         /* Make sure the payload has not already been set. */
 958         if (!bt_ctf_field_validate(integer)) {
 959                 /* Payload already set, not an error */
 960                 goto end;
 961         }
 962
 963         field_type = bt_ctf_field_get_type(integer);
 964         /* Something is serioulsly wrong */
 965         assert(field_type);
 966         if (bt_ctf_field_type_get_type_id(field_type) != CTF_TYPE_INTEGER) {
 967                 /*
 968                  * The user most likely meant for us to populate this field
 969                  * automatically. However, we can only do this if the field
 970                  * is an integer. Return an error.
 971                  */
 972                 ret = -1;
 973                 goto end;
 974         }
 975
 976         if (bt_ctf_field_type_integer_get_signed(field_type)) {
 977                 ret = bt_ctf_field_signed_integer_set_value(integer,
 978                         (int64_t) value);
 979         } else {
 980                 ret = bt_ctf_field_unsigned_integer_set_value(integer, value);
 981         }
 982 end:
 983         if (integer) {
 984                 bt_ctf_field_put(integer);
 985         }
 986         if (field_type) {
 987                 bt_ctf_field_type_put(field_type);
 988         }
 989         return ret;
 990 }