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