formats/ctf/ir/stream-class.c

   1 /*
   2  * stream-class.c
   3  *
   4  * Babeltrace CTF IR - Stream Class
   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-writer/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-writer/stream.h>
  36 #include <babeltrace/ctf-ir/stream-class-internal.h>
  37 #include <babeltrace/ctf-ir/visitor-internal.h>
  38 #include <babeltrace/ctf-writer/functor-internal.h>
  39 #include <babeltrace/ctf-ir/utils.h>
  40 #include <babeltrace/ref.h>
  41 #include <babeltrace/compiler.h>
  42 #include <babeltrace/align.h>
  43 #include <babeltrace/endian.h>
  44
  45 static
  46 void bt_ctf_stream_class_destroy(struct bt_object *obj);
  47 static
  48 int init_event_header(struct bt_ctf_stream_class *stream_class);
  49 static
  50 int init_packet_context(struct bt_ctf_stream_class *stream_class);
  51
  52 struct bt_ctf_stream_class *bt_ctf_stream_class_create(const char *name)
  53 {
  54         int ret;
  55         struct bt_ctf_stream_class *stream_class = NULL;
  56
  57         if (name && bt_ctf_validate_identifier(name)) {
  58                 goto error;
  59         }
  60
  61         stream_class = g_new0(struct bt_ctf_stream_class, 1);
  62         if (!stream_class) {
  63                 goto error;
  64         }
  65
  66         stream_class->name = g_string_new(name);
  67         stream_class->event_classes = g_ptr_array_new_with_free_func(
  68                 (GDestroyNotify) bt_object_release);
  69         if (!stream_class->event_classes) {
  70                 goto error;
  71         }
  72
  73         ret = init_event_header(stream_class);
  74         if (ret) {
  75                 goto error;
  76         }
  77
  78         ret = init_packet_context(stream_class);
  79         if (ret) {
  80                 goto error;
  81         }
  82
  83         bt_object_init(stream_class, bt_ctf_stream_class_destroy);
  84         return stream_class;
  85
  86 error:
  87         BT_PUT(stream_class);
  88         return stream_class;
  89 }
  90
  91 struct bt_ctf_trace *bt_ctf_stream_class_get_trace(
  92                 struct bt_ctf_stream_class *stream_class)
  93 {
  94         return (struct bt_ctf_trace *) bt_object_get_parent(
  95                 stream_class);
  96 }
  97
  98 const char *bt_ctf_stream_class_get_name(
  99                 struct bt_ctf_stream_class *stream_class)
 100 {
 101         const char *name = NULL;
 102
 103         if (!stream_class) {
 104                 goto end;
 105         }
 106
 107         name = stream_class->name->str;
 108 end:
 109         return name;
 110 }
 111
 112 int bt_ctf_stream_class_set_name(struct bt_ctf_stream_class *stream_class,
 113                 const char *name)
 114 {
 115         int ret = 0;
 116
 117         if (!stream_class || stream_class->frozen) {
 118                 ret = -1;
 119                 goto end;
 120         }
 121
 122         g_string_assign(stream_class->name, name);
 123 end:
 124         return ret;
 125 }
 126
 127 struct bt_ctf_clock *bt_ctf_stream_class_get_clock(
 128                 struct bt_ctf_stream_class *stream_class)
 129 {
 130         struct bt_ctf_clock *clock = NULL;
 131
 132         if (!stream_class || !stream_class->clock) {
 133                 goto end;
 134         }
 135
 136         clock = stream_class->clock;
 137         bt_get(clock);
 138 end:
 139         return clock;
 140 }
 141
 142 int bt_ctf_stream_class_set_clock(struct bt_ctf_stream_class *stream_class,
 143                 struct bt_ctf_clock *clock)
 144 {
 145         int ret = 0;
 146         struct bt_ctf_field_type *timestamp_field = NULL;
 147
 148         if (!stream_class || !clock || stream_class->frozen) {
 149                 ret = -1;
 150                 goto end;
 151         }
 152
 153         /*
 154          * Look for a "timestamp" field in the stream class' event header type
 155          * and map the stream's clock to that field if no current mapping is
 156          * currently set.
 157          */
 158         timestamp_field = bt_ctf_field_type_structure_get_field_type_by_name(
 159                 stream_class->event_header_type, "timestamp");
 160         if (timestamp_field) {
 161                 struct bt_ctf_clock *mapped_clock;
 162
 163                 mapped_clock = bt_ctf_field_type_integer_get_mapped_clock(
 164                         timestamp_field);
 165                 if (mapped_clock) {
 166                         bt_put(mapped_clock);
 167                         goto end;
 168                 }
 169
 170                 ret = bt_ctf_field_type_integer_set_mapped_clock(
 171                         timestamp_field, clock);
 172                 if (ret) {
 173                         goto end;
 174                 }
 175         }
 176
 177         if (stream_class->clock) {
 178                 bt_put(stream_class->clock);
 179         }
 180
 181         stream_class->clock = clock;
 182         bt_get(clock);
 183 end:
 184         if (timestamp_field) {
 185                 bt_put(timestamp_field);
 186         }
 187         return ret;
 188 }
 189
 190 int64_t bt_ctf_stream_class_get_id(struct bt_ctf_stream_class *stream_class)
 191 {
 192         int64_t ret;
 193
 194         if (!stream_class || !stream_class->id_set) {
 195                 ret = -1;
 196                 goto end;
 197         }
 198
 199         ret = (int64_t) stream_class->id;
 200 end:
 201         return ret;
 202 }
 203
 204 BT_HIDDEN
 205 int _bt_ctf_stream_class_set_id(
 206                 struct bt_ctf_stream_class *stream_class, uint32_t id)
 207 {
 208         stream_class->id = id;
 209         stream_class->id_set = 1;
 210         return 0;
 211 }
 212
 213 struct event_class_set_stream_id_data {
 214         uint32_t stream_id;
 215         int ret;
 216 };
 217
 218 static
 219 void event_class_set_stream_id(gpointer event_class, gpointer data)
 220 {
 221         struct event_class_set_stream_id_data *typed_data = data;
 222
 223         typed_data->ret |= bt_ctf_event_class_set_stream_id(event_class,
 224                 typed_data->stream_id);
 225 }
 226
 227 BT_HIDDEN
 228 int bt_ctf_stream_class_set_id_no_check(
 229                 struct bt_ctf_stream_class *stream_class, uint32_t id)
 230 {
 231         int ret = 0;
 232         struct event_class_set_stream_id_data data =
 233                 { .stream_id = id, .ret = 0 };
 234
 235         /*
 236          * Make sure all event classes have their "stream_id" attribute
 237          * set to this value.
 238          */
 239         g_ptr_array_foreach(stream_class->event_classes,
 240                 event_class_set_stream_id, &data);
 241         ret = data.ret;
 242         if (ret) {
 243                 goto end;
 244         }
 245
 246         ret = _bt_ctf_stream_class_set_id(stream_class, id);
 247         if (ret) {
 248                 goto end;
 249         }
 250 end:
 251         return ret;
 252 }
 253
 254 int bt_ctf_stream_class_set_id(struct bt_ctf_stream_class *stream_class,
 255                 uint32_t id)
 256 {
 257         int ret = 0;
 258
 259         if (!stream_class || stream_class->frozen) {
 260                 ret = -1;
 261                 goto end;
 262         }
 263
 264         ret = bt_ctf_stream_class_set_id_no_check(stream_class, id);
 265 end:
 266         return ret;
 267 }
 268
 269 static
 270 void event_class_exists(gpointer element, gpointer query)
 271 {
 272         struct bt_ctf_event_class *event_class_a = element;
 273         struct search_query *search_query = query;
 274         struct bt_ctf_event_class *event_class_b = search_query->value;
 275         int64_t id_a, id_b;
 276
 277         if (search_query->value == element) {
 278                 search_query->found = 1;
 279                 goto end;
 280         }
 281
 282         /*
 283          * Two event classes cannot share the same name in a given
 284          * stream class.
 285          */
 286         if (!strcmp(bt_ctf_event_class_get_name(event_class_a),
 287                         bt_ctf_event_class_get_name(event_class_b))) {
 288                 search_query->found = 1;
 289                 goto end;
 290         }
 291
 292         /*
 293          * Two event classes cannot share the same ID in a given
 294          * stream class.
 295          */
 296         id_a = bt_ctf_event_class_get_id(event_class_a);
 297         id_b = bt_ctf_event_class_get_id(event_class_b);
 298
 299         if (id_a < 0 || id_b < 0) {
 300                 /* at least one ID is not set: will be automatically set later */
 301                 goto end;
 302         }
 303
 304         if (id_a == id_b) {
 305                 search_query->found = 1;
 306                 goto end;
 307         }
 308
 309 end:
 310         return;
 311 }
 312
 313 int bt_ctf_stream_class_add_event_class(
 314                 struct bt_ctf_stream_class *stream_class,
 315                 struct bt_ctf_event_class *event_class)
 316 {
 317         int ret = 0;
 318         int64_t event_id;
 319         struct bt_ctf_trace *trace = NULL;
 320         struct bt_ctf_stream_class *old_stream_class = NULL;
 321
 322         if (!stream_class || !event_class) {
 323                 ret = -1;
 324                 goto end;
 325         }
 326
 327         /* Check for duplicate event classes */
 328         struct search_query query = { .value = event_class, .found = 0 };
 329         g_ptr_array_foreach(stream_class->event_classes, event_class_exists,
 330                 &query);
 331         if (query.found) {
 332                 ret = -1;
 333                 goto end;
 334         }
 335
 336         old_stream_class = (struct bt_ctf_stream_class *) bt_object_get_parent(
 337                 event_class);
 338         if (old_stream_class) {
 339                 /* Event class is already associated to a stream class. */
 340                 ret = -1;
 341                 goto end;
 342         }
 343
 344         /*
 345          * Resolve the event's sequence length and variant tags if the
 346          * stream is already associated with a trace. Otherwise, this
 347          * validation will be performed once the stream is registered
 348          * to a trace.
 349          */
 350         trace = (struct bt_ctf_trace *) bt_object_get_parent(
 351                 stream_class);
 352         if (trace) {
 353                 ret = bt_ctf_event_class_resolve_types(event_class,
 354                         trace, stream_class);
 355                 if (ret) {
 356                         goto end;
 357                 }
 358         }
 359
 360         /* Only set an event id if none was explicitly set before */
 361         event_id = bt_ctf_event_class_get_id(event_class);
 362         if (event_id < 0) {
 363                 if (bt_ctf_event_class_set_id(event_class,
 364                         stream_class->next_event_id++)) {
 365                         ret = -1;
 366                         goto end;
 367                 }
 368         }
 369
 370         ret = bt_ctf_event_class_set_stream_id(event_class, stream_class->id);
 371         if (ret) {
 372                 goto end;
 373         }
 374
 375         bt_object_set_parent(event_class, stream_class);
 376         g_ptr_array_add(stream_class->event_classes, event_class);
 377         bt_ctf_event_class_freeze(event_class);
 378
 379         if (stream_class->byte_order) {
 380                 /*
 381                  * Only set native byte order if it has been initialized
 382                  * when the stream class was added to a trace.
 383                  *
 384                  * If not set here, this will be set when the stream
 385                  * classe will be added to a trace.
 386                  */
 387                 bt_ctf_event_class_set_native_byte_order(event_class,
 388                         stream_class->byte_order);
 389         }
 390 end:
 391         BT_PUT(trace);
 392         BT_PUT(old_stream_class);
 393         return ret;
 394 }
 395
 396 int bt_ctf_stream_class_get_event_class_count(
 397                 struct bt_ctf_stream_class *stream_class)
 398 {
 399         int ret;
 400
 401         if (!stream_class) {
 402                 ret = -1;
 403                 goto end;
 404         }
 405
 406         ret = (int) stream_class->event_classes->len;
 407 end:
 408         return ret;
 409 }
 410
 411 struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class(
 412                 struct bt_ctf_stream_class *stream_class, int index)
 413 {
 414         struct bt_ctf_event_class *event_class = NULL;
 415
 416         if (!stream_class || index < 0 ||
 417                 index >= stream_class->event_classes->len) {
 418                 goto end;
 419         }
 420
 421         event_class = g_ptr_array_index(stream_class->event_classes, index);
 422         bt_get(event_class);
 423 end:
 424         return event_class;
 425 }
 426
 427 struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class_by_name(
 428                 struct bt_ctf_stream_class *stream_class, const char *name)
 429 {
 430         size_t i;
 431         struct bt_ctf_event_class *event_class = NULL;
 432
 433         if (!stream_class || !name) {
 434                 goto end;
 435         }
 436
 437         for (i = 0; i < stream_class->event_classes->len; i++) {
 438                 struct bt_ctf_event_class *cur_event_class =
 439                         g_ptr_array_index(stream_class->event_classes, i);
 440                 const char *cur_event_class_name =
 441                         bt_ctf_event_class_get_name(cur_event_class);
 442
 443                 if (!strcmp(name, cur_event_class_name)) {
 444                         event_class = cur_event_class;
 445                         bt_get(event_class);
 446                         goto end;
 447                 }
 448         }
 449 end:
 450         return event_class;
 451 }
 452
 453 struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class_by_id(
 454                 struct bt_ctf_stream_class *stream_class, uint32_t id)
 455 {
 456         size_t i;
 457         struct bt_ctf_event_class *event_class = NULL;
 458
 459         if (!stream_class) {
 460                 goto end;
 461         }
 462
 463         for (i = 0; i < stream_class->event_classes->len; i++) {
 464                 struct bt_ctf_event_class *current_event_class =
 465                         g_ptr_array_index(stream_class->event_classes, i);
 466
 467                 if (bt_ctf_event_class_get_id(current_event_class) == id) {
 468                         event_class = current_event_class;
 469                         bt_get(event_class);
 470                         goto end;
 471                 }
 472         }
 473 end:
 474         return event_class;
 475 }
 476
 477 struct bt_ctf_field_type *bt_ctf_stream_class_get_packet_context_type(
 478                 struct bt_ctf_stream_class *stream_class)
 479 {
 480         struct bt_ctf_field_type *ret = NULL;
 481
 482         if (!stream_class) {
 483                 goto end;
 484         }
 485
 486         assert(stream_class->packet_context_type);
 487         bt_get(stream_class->packet_context_type);
 488         ret = stream_class->packet_context_type;
 489 end:
 490         return ret;
 491 }
 492
 493 int bt_ctf_stream_class_set_packet_context_type(
 494                 struct bt_ctf_stream_class *stream_class,
 495                 struct bt_ctf_field_type *packet_context_type)
 496 {
 497         int ret = 0;
 498
 499         if (!stream_class || !packet_context_type || stream_class->frozen) {
 500                 ret = -1;
 501                 goto end;
 502         }
 503
 504         assert(stream_class->packet_context_type);
 505         if (stream_class->packet_context_type == packet_context_type) {
 506                 goto end;
 507         }
 508         if (bt_ctf_field_type_get_type_id(packet_context_type) !=
 509                 CTF_TYPE_STRUCT) {
 510                 /* A packet context must be a structure */
 511                 ret = -1;
 512                 goto end;
 513         }
 514
 515         bt_put(stream_class->packet_context_type);
 516         bt_get(packet_context_type);
 517         stream_class->packet_context_type = packet_context_type;
 518 end:
 519         return ret;
 520 }
 521
 522 struct bt_ctf_field_type *bt_ctf_stream_class_get_event_header_type(
 523                 struct bt_ctf_stream_class *stream_class)
 524 {
 525         struct bt_ctf_field_type *ret = NULL;
 526
 527         if (!stream_class || !stream_class->event_header_type) {
 528                 goto end;
 529         }
 530
 531         assert(stream_class->event_header_type);
 532         bt_get(stream_class->event_header_type);
 533         ret = stream_class->event_header_type;
 534 end:
 535         return ret;
 536 }
 537
 538 int bt_ctf_stream_class_set_event_header_type(
 539                 struct bt_ctf_stream_class *stream_class,
 540                 struct bt_ctf_field_type *event_header_type)
 541 {
 542         int ret = 0;
 543
 544         if (!stream_class || !event_header_type || stream_class->frozen) {
 545                 ret = -1;
 546                 goto end;
 547         }
 548
 549         assert(stream_class->event_header_type);
 550         if (stream_class->event_header_type == event_header_type) {
 551                 goto end;
 552         }
 553         if (bt_ctf_field_type_get_type_id(event_header_type) !=
 554                 CTF_TYPE_STRUCT) {
 555                 /* An event header must be a structure */
 556                 ret = -1;
 557                 goto end;
 558         }
 559
 560         bt_put(stream_class->event_header_type);
 561         bt_get(event_header_type);
 562         stream_class->event_header_type = event_header_type;
 563 end:
 564         return ret;
 565 }
 566
 567 struct bt_ctf_field_type *bt_ctf_stream_class_get_event_context_type(
 568                 struct bt_ctf_stream_class *stream_class)
 569 {
 570         struct bt_ctf_field_type *ret = NULL;
 571
 572         if (!stream_class || !stream_class->event_context_type) {
 573                 goto end;
 574         }
 575
 576         assert(stream_class->event_context_type);
 577         bt_get(stream_class->event_context_type);
 578         ret = stream_class->event_context_type;
 579 end:
 580         return ret;
 581 }
 582
 583 int bt_ctf_stream_class_set_event_context_type(
 584                 struct bt_ctf_stream_class *stream_class,
 585                 struct bt_ctf_field_type *event_context_type)
 586 {
 587         int ret = 0;
 588
 589         if (!stream_class || !event_context_type || stream_class->frozen) {
 590                 ret = -1;
 591                 goto end;
 592         }
 593
 594         if (bt_ctf_field_type_get_type_id(event_context_type) !=
 595                 CTF_TYPE_STRUCT) {
 596                 /* A packet context must be a structure */
 597                 ret = -1;
 598                 goto end;
 599         }
 600
 601         bt_put(stream_class->event_context_type);
 602         bt_get(event_context_type);
 603         stream_class->event_context_type = event_context_type;
 604 end:
 605         return ret;
 606 }
 607
 608 void bt_ctf_stream_class_get(struct bt_ctf_stream_class *stream_class)
 609 {
 610         bt_get(stream_class);
 611 }
 612
 613 void bt_ctf_stream_class_put(struct bt_ctf_stream_class *stream_class)
 614 {
 615         bt_put(stream_class);
 616 }
 617
 618 BT_HIDDEN
 619 void bt_ctf_stream_class_freeze(struct bt_ctf_stream_class *stream_class)
 620 {
 621         if (!stream_class) {
 622                 return;
 623         }
 624
 625         stream_class->frozen = 1;
 626         bt_ctf_field_type_freeze(stream_class->event_header_type);
 627         bt_ctf_field_type_freeze(stream_class->packet_context_type);
 628         bt_ctf_field_type_freeze(stream_class->event_context_type);
 629         bt_ctf_clock_freeze(stream_class->clock);
 630 }
 631
 632 BT_HIDDEN
 633 int bt_ctf_stream_class_set_byte_order(struct bt_ctf_stream_class *stream_class,
 634         enum bt_ctf_byte_order byte_order)
 635 {
 636         int i, ret = 0;
 637         int internal_byte_order;
 638
 639         /* Note that "NATIVE" means the trace's endianness, not the host's. */
 640         if (!stream_class || byte_order <= BT_CTF_BYTE_ORDER_UNKNOWN ||
 641                 byte_order > BT_CTF_BYTE_ORDER_NETWORK) {
 642                 ret = -1;
 643                 goto end;
 644         }
 645
 646         switch (byte_order) {
 647         case BT_CTF_BYTE_ORDER_NETWORK:
 648         case BT_CTF_BYTE_ORDER_BIG_ENDIAN:
 649                 internal_byte_order = BIG_ENDIAN;
 650                 break;
 651         case BT_CTF_BYTE_ORDER_LITTLE_ENDIAN:
 652                 internal_byte_order = LITTLE_ENDIAN;
 653                 break;
 654         default:
 655                 ret = -1;
 656                 goto end;
 657         }
 658
 659         stream_class->byte_order = internal_byte_order;
 660
 661         /* Set native byte order to little or big endian */
 662         bt_ctf_field_type_set_native_byte_order(
 663                 stream_class->event_header_type, stream_class->byte_order);
 664         bt_ctf_field_type_set_native_byte_order(
 665                 stream_class->packet_context_type, stream_class->byte_order);
 666         bt_ctf_field_type_set_native_byte_order(
 667                 stream_class->event_context_type, stream_class->byte_order);
 668
 669         /* Set all events' native byte order */
 670         for (i = 0; i < stream_class->event_classes->len; i++) {
 671                 bt_ctf_event_class_set_native_byte_order(
 672                         g_ptr_array_index(stream_class->event_classes, i),
 673                         stream_class->byte_order);
 674                 bt_ctf_event_class_freeze(
 675                         g_ptr_array_index(stream_class->event_classes, i));
 676         }
 677 end:
 678         return ret;
 679 }
 680
 681 BT_HIDDEN
 682 int bt_ctf_stream_class_serialize(struct bt_ctf_stream_class *stream_class,
 683                 struct metadata_context *context)
 684 {
 685         int64_t ret = 0;
 686         size_t i;
 687
 688         g_string_assign(context->field_name, "");
 689         context->current_indentation_level = 1;
 690         if (!stream_class->id_set) {
 691                 ret = -1;
 692                 goto end;
 693         }
 694
 695         g_string_append_printf(context->string,
 696                 "stream {\n\tid = %" PRIu32 ";\n\tevent.header := ",
 697                 stream_class->id);
 698         ret = bt_ctf_field_type_serialize(stream_class->event_header_type,
 699                 context);
 700         if (ret) {
 701                 goto end;
 702         }
 703
 704         g_string_append(context->string, ";\n\n\tpacket.context := ");
 705         ret = bt_ctf_field_type_serialize(stream_class->packet_context_type,
 706                 context);
 707         if (ret) {
 708                 goto end;
 709         }
 710
 711         if (stream_class->event_context_type) {
 712                 g_string_append(context->string, ";\n\n\tevent.context := ");
 713                 ret = bt_ctf_field_type_serialize(
 714                         stream_class->event_context_type, context);
 715                 if (ret) {
 716                         goto end;
 717                 }
 718         }
 719
 720         g_string_append(context->string, ";\n};\n\n");
 721         for (i = 0; i < stream_class->event_classes->len; i++) {
 722                 struct bt_ctf_event_class *event_class =
 723                         stream_class->event_classes->pdata[i];
 724
 725                 ret = bt_ctf_event_class_serialize(event_class, context);
 726                 if (ret) {
 727                         goto end;
 728                 }
 729         }
 730 end:
 731         context->current_indentation_level = 0;
 732         return ret;
 733 }
 734
 735 static
 736 void bt_ctf_stream_class_destroy(struct bt_object *obj)
 737 {
 738         struct bt_ctf_stream_class *stream_class;
 739
 740         stream_class = container_of(obj, struct bt_ctf_stream_class, base);
 741         bt_put(stream_class->clock);
 742
 743         if (stream_class->event_classes) {
 744                 g_ptr_array_free(stream_class->event_classes, TRUE);
 745         }
 746
 747         if (stream_class->name) {
 748                 g_string_free(stream_class->name, TRUE);
 749         }
 750
 751         bt_put(stream_class->event_header_type);
 752         bt_put(stream_class->packet_context_type);
 753         bt_put(stream_class->event_context_type);
 754         g_free(stream_class);
 755 }
 756
 757 static
 758 int init_event_header(struct bt_ctf_stream_class *stream_class)
 759 {
 760         int ret = 0;
 761         struct bt_ctf_field_type *event_header_type =
 762                 bt_ctf_field_type_structure_create();
 763         struct bt_ctf_field_type *_uint32_t =
 764                 get_field_type(FIELD_TYPE_ALIAS_UINT32_T);
 765         struct bt_ctf_field_type *_uint64_t =
 766                 get_field_type(FIELD_TYPE_ALIAS_UINT64_T);
 767
 768         if (!event_header_type) {
 769                 ret = -1;
 770                 goto end;
 771         }
 772
 773         ret = bt_ctf_field_type_structure_add_field(event_header_type,
 774                 _uint32_t, "id");
 775         if (ret) {
 776                 goto end;
 777         }
 778
 779         ret = bt_ctf_field_type_structure_add_field(event_header_type,
 780                 _uint64_t, "timestamp");
 781         if (ret) {
 782                 goto end;
 783         }
 784
 785         if (stream_class->event_header_type) {
 786                 bt_put(stream_class->event_header_type);
 787         }
 788         stream_class->event_header_type = event_header_type;
 789 end:
 790         if (ret) {
 791                 bt_put(event_header_type);
 792         }
 793
 794         bt_put(_uint32_t);
 795         bt_put(_uint64_t);
 796         return ret;
 797 }
 798
 799 static
 800 int init_packet_context(struct bt_ctf_stream_class *stream_class)
 801 {
 802         int ret = 0;
 803         struct bt_ctf_field_type *packet_context_type =
 804                 bt_ctf_field_type_structure_create();
 805         struct bt_ctf_field_type *_uint64_t =
 806                 get_field_type(FIELD_TYPE_ALIAS_UINT64_T);
 807
 808         if (!packet_context_type) {
 809                 ret = -1;
 810                 goto end;
 811         }
 812
 813         /*
 814          * We create a stream packet context as proposed in the CTF
 815          * specification.
 816          */
 817         ret = bt_ctf_field_type_structure_add_field(packet_context_type,
 818                 _uint64_t, "timestamp_begin");
 819         if (ret) {
 820                 goto end;
 821         }
 822
 823         ret = bt_ctf_field_type_structure_add_field(packet_context_type,
 824                 _uint64_t, "timestamp_end");
 825         if (ret) {
 826                 goto end;
 827         }
 828
 829         ret = bt_ctf_field_type_structure_add_field(packet_context_type,
 830                 _uint64_t, "content_size");
 831         if (ret) {
 832                 goto end;
 833         }
 834
 835         ret = bt_ctf_field_type_structure_add_field(packet_context_type,
 836                 _uint64_t, "packet_size");
 837         if (ret) {
 838                 goto end;
 839         }
 840
 841         ret = bt_ctf_field_type_structure_add_field(packet_context_type,
 842                 _uint64_t, "events_discarded");
 843         if (ret) {
 844                 goto end;
 845         }
 846
 847         bt_put(stream_class->packet_context_type);
 848         stream_class->packet_context_type = packet_context_type;
 849 end:
 850         if (ret) {
 851                 bt_put(packet_context_type);
 852                 goto end;
 853         }
 854
 855         bt_put(_uint64_t);
 856         return ret;
 857 }