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         assert(stream_class->packet_context_type);
 585         bt_get(stream_class->packet_context_type);
 586         ret = stream_class->packet_context_type;
 587 end:
 588         return ret;
 589 }
 590
 591 int bt_ctf_stream_class_set_packet_context_type(
 592                 struct bt_ctf_stream_class *stream_class,
 593                 struct bt_ctf_field_type *packet_context_type)
 594 {
 595         int ret = 0;
 596
 597         if (!stream_class || !packet_context_type || stream_class->frozen) {
 598                 ret = -1;
 599                 goto end;
 600         }
 601
 602         assert(stream_class->packet_context_type);
 603         if (stream_class->packet_context_type == packet_context_type) {
 604                 goto end;
 605         }
 606         if (bt_ctf_field_type_get_type_id(packet_context_type) !=
 607                 BT_CTF_TYPE_ID_STRUCT) {
 608                 /* A packet context must be a structure */
 609                 ret = -1;
 610                 goto end;
 611         }
 612
 613         bt_put(stream_class->packet_context_type);
 614         bt_get(packet_context_type);
 615         stream_class->packet_context_type = packet_context_type;
 616 end:
 617         return ret;
 618 }
 619
 620 struct bt_ctf_field_type *bt_ctf_stream_class_get_event_header_type(
 621                 struct bt_ctf_stream_class *stream_class)
 622 {
 623         struct bt_ctf_field_type *ret = NULL;
 624
 625         if (!stream_class || !stream_class->event_header_type) {
 626                 goto end;
 627         }
 628
 629         assert(stream_class->event_header_type);
 630         bt_get(stream_class->event_header_type);
 631         ret = stream_class->event_header_type;
 632 end:
 633         return ret;
 634 }
 635
 636 int bt_ctf_stream_class_set_event_header_type(
 637                 struct bt_ctf_stream_class *stream_class,
 638                 struct bt_ctf_field_type *event_header_type)
 639 {
 640         int ret = 0;
 641
 642         if (!stream_class || !event_header_type || stream_class->frozen) {
 643                 ret = -1;
 644                 goto end;
 645         }
 646
 647         assert(stream_class->event_header_type);
 648         if (stream_class->event_header_type == event_header_type) {
 649                 goto end;
 650         }
 651         if (bt_ctf_field_type_get_type_id(event_header_type) !=
 652                 BT_CTF_TYPE_ID_STRUCT) {
 653                 /* An event header must be a structure */
 654                 ret = -1;
 655                 goto end;
 656         }
 657
 658         bt_put(stream_class->event_header_type);
 659         bt_get(event_header_type);
 660         stream_class->event_header_type = event_header_type;
 661 end:
 662         return ret;
 663 }
 664
 665 struct bt_ctf_field_type *bt_ctf_stream_class_get_event_context_type(
 666                 struct bt_ctf_stream_class *stream_class)
 667 {
 668         struct bt_ctf_field_type *ret = NULL;
 669
 670         if (!stream_class || !stream_class->event_context_type) {
 671                 goto end;
 672         }
 673
 674         assert(stream_class->event_context_type);
 675         bt_get(stream_class->event_context_type);
 676         ret = stream_class->event_context_type;
 677 end:
 678         return ret;
 679 }
 680
 681 int bt_ctf_stream_class_set_event_context_type(
 682                 struct bt_ctf_stream_class *stream_class,
 683                 struct bt_ctf_field_type *event_context_type)
 684 {
 685         int ret = 0;
 686
 687         if (!stream_class || !event_context_type || stream_class->frozen) {
 688                 ret = -1;
 689                 goto end;
 690         }
 691
 692         if (bt_ctf_field_type_get_type_id(event_context_type) !=
 693                 BT_CTF_TYPE_ID_STRUCT) {
 694                 /* A packet context must be a structure */
 695                 ret = -1;
 696                 goto end;
 697         }
 698
 699         bt_put(stream_class->event_context_type);
 700         bt_get(event_context_type);
 701         stream_class->event_context_type = event_context_type;
 702 end:
 703         return ret;
 704 }
 705
 706 void bt_ctf_stream_class_get(struct bt_ctf_stream_class *stream_class)
 707 {
 708         bt_get(stream_class);
 709 }
 710
 711 void bt_ctf_stream_class_put(struct bt_ctf_stream_class *stream_class)
 712 {
 713         bt_put(stream_class);
 714 }
 715
 716 static
 717 int get_event_class_count(void *element)
 718 {
 719         return bt_ctf_stream_class_get_event_class_count(
 720                         (struct bt_ctf_stream_class *) element);
 721 }
 722
 723 static
 724 void *get_event_class(void *element, int i)
 725 {
 726         return bt_ctf_stream_class_get_event_class(
 727                         (struct bt_ctf_stream_class *) element, i);
 728 }
 729
 730 static
 731 int visit_event_class(void *object, bt_ctf_visitor visitor,void *data)
 732 {
 733         struct bt_ctf_object obj =
 734                         { .object = object,
 735                         .type = BT_CTF_OBJECT_TYPE_EVENT_CLASS };
 736
 737         return visitor(&obj, data);
 738 }
 739
 740 int bt_ctf_stream_class_visit(struct bt_ctf_stream_class *stream_class,
 741                 bt_ctf_visitor visitor, void *data)
 742 {
 743         int ret;
 744         struct bt_ctf_object obj =
 745                         { .object = stream_class,
 746                         .type = BT_CTF_OBJECT_TYPE_STREAM_CLASS };
 747
 748         if (!stream_class || !visitor) {
 749                 ret = -1;
 750                 goto end;
 751         }
 752
 753         ret = visitor_helper(&obj, get_event_class_count,
 754                         get_event_class,
 755                         visit_event_class, visitor, data);
 756 end:
 757         return ret;
 758 }
 759
 760 BT_HIDDEN
 761 void bt_ctf_stream_class_freeze(struct bt_ctf_stream_class *stream_class)
 762 {
 763         if (!stream_class) {
 764                 return;
 765         }
 766
 767         stream_class->frozen = 1;
 768         bt_ctf_field_type_freeze(stream_class->event_header_type);
 769         bt_ctf_field_type_freeze(stream_class->packet_context_type);
 770         bt_ctf_field_type_freeze(stream_class->event_context_type);
 771         bt_ctf_clock_freeze(stream_class->clock);
 772 }
 773
 774 BT_HIDDEN
 775 void bt_ctf_stream_class_set_byte_order(
 776         struct bt_ctf_stream_class *stream_class, int byte_order)
 777 {
 778         int i;
 779
 780         assert(stream_class);
 781         assert(byte_order == LITTLE_ENDIAN || byte_order == BIG_ENDIAN);
 782         stream_class->byte_order = byte_order;
 783
 784         /* Set native byte order to little or big endian */
 785         bt_ctf_field_type_set_native_byte_order(
 786                 stream_class->event_header_type, byte_order);
 787         bt_ctf_field_type_set_native_byte_order(
 788                 stream_class->packet_context_type, byte_order);
 789         bt_ctf_field_type_set_native_byte_order(
 790                 stream_class->event_context_type, byte_order);
 791
 792         /* Set all events' native byte order */
 793         for (i = 0; i < stream_class->event_classes->len; i++) {
 794                 struct bt_ctf_event_class *event_class =
 795                         g_ptr_array_index(stream_class->event_classes, i);
 796
 797                 bt_ctf_event_class_set_native_byte_order(event_class,
 798                         byte_order);
 799         }
 800 }
 801
 802 BT_HIDDEN
 803 int bt_ctf_stream_class_serialize(struct bt_ctf_stream_class *stream_class,
 804                 struct metadata_context *context)
 805 {
 806         int64_t ret = 0;
 807         size_t i;
 808
 809         g_string_assign(context->field_name, "");
 810         context->current_indentation_level = 1;
 811         if (!stream_class->id_set) {
 812                 ret = -1;
 813                 goto end;
 814         }
 815
 816         g_string_append_printf(context->string,
 817                 "stream {\n\tid = %" PRIu32 ";\n\tevent.header := ",
 818                 stream_class->id);
 819         ret = bt_ctf_field_type_serialize(stream_class->event_header_type,
 820                 context);
 821         if (ret) {
 822                 goto end;
 823         }
 824
 825         g_string_append(context->string, ";\n\n\tpacket.context := ");
 826         ret = bt_ctf_field_type_serialize(stream_class->packet_context_type,
 827                 context);
 828         if (ret) {
 829                 goto end;
 830         }
 831
 832         if (stream_class->event_context_type) {
 833                 g_string_append(context->string, ";\n\n\tevent.context := ");
 834                 ret = bt_ctf_field_type_serialize(
 835                         stream_class->event_context_type, context);
 836                 if (ret) {
 837                         goto end;
 838                 }
 839         }
 840
 841         g_string_append(context->string, ";\n};\n\n");
 842         for (i = 0; i < stream_class->event_classes->len; i++) {
 843                 struct bt_ctf_event_class *event_class =
 844                         stream_class->event_classes->pdata[i];
 845
 846                 ret = bt_ctf_event_class_serialize(event_class, context);
 847                 if (ret) {
 848                         goto end;
 849                 }
 850         }
 851 end:
 852         context->current_indentation_level = 0;
 853         return ret;
 854 }
 855
 856 static
 857 void bt_ctf_stream_class_destroy(struct bt_object *obj)
 858 {
 859         struct bt_ctf_stream_class *stream_class;
 860
 861         stream_class = container_of(obj, struct bt_ctf_stream_class, base);
 862         bt_put(stream_class->clock);
 863
 864         if (stream_class->event_classes_ht) {
 865                 g_hash_table_destroy(stream_class->event_classes_ht);
 866         }
 867         if (stream_class->event_classes) {
 868                 g_ptr_array_free(stream_class->event_classes, TRUE);
 869         }
 870
 871         if (stream_class->name) {
 872                 g_string_free(stream_class->name, TRUE);
 873         }
 874
 875         bt_put(stream_class->event_header_type);
 876         bt_put(stream_class->packet_context_type);
 877         bt_put(stream_class->event_context_type);
 878         g_free(stream_class);
 879 }
 880
 881 static
 882 int init_event_header(struct bt_ctf_stream_class *stream_class)
 883 {
 884         int ret = 0;
 885         struct bt_ctf_field_type *event_header_type =
 886                 bt_ctf_field_type_structure_create();
 887         struct bt_ctf_field_type *_uint32_t =
 888                 get_field_type(FIELD_TYPE_ALIAS_UINT32_T);
 889         struct bt_ctf_field_type *_uint64_t =
 890                 get_field_type(FIELD_TYPE_ALIAS_UINT64_T);
 891
 892         if (!event_header_type) {
 893                 ret = -1;
 894                 goto end;
 895         }
 896
 897         ret = bt_ctf_field_type_structure_add_field(event_header_type,
 898                 _uint32_t, "id");
 899         if (ret) {
 900                 goto end;
 901         }
 902
 903         ret = bt_ctf_field_type_structure_add_field(event_header_type,
 904                 _uint64_t, "timestamp");
 905         if (ret) {
 906                 goto end;
 907         }
 908
 909         if (stream_class->event_header_type) {
 910                 bt_put(stream_class->event_header_type);
 911         }
 912         stream_class->event_header_type = event_header_type;
 913 end:
 914         if (ret) {
 915                 bt_put(event_header_type);
 916         }
 917
 918         bt_put(_uint32_t);
 919         bt_put(_uint64_t);
 920         return ret;
 921 }
 922
 923 static
 924 int init_packet_context(struct bt_ctf_stream_class *stream_class)
 925 {
 926         int ret = 0;
 927         struct bt_ctf_field_type *packet_context_type =
 928                 bt_ctf_field_type_structure_create();
 929         struct bt_ctf_field_type *_uint64_t =
 930                 get_field_type(FIELD_TYPE_ALIAS_UINT64_T);
 931
 932         if (!packet_context_type) {
 933                 ret = -1;
 934                 goto end;
 935         }
 936
 937         /*
 938          * We create a stream packet context as proposed in the CTF
 939          * specification.
 940          */
 941         ret = bt_ctf_field_type_structure_add_field(packet_context_type,
 942                 _uint64_t, "timestamp_begin");
 943         if (ret) {
 944                 goto end;
 945         }
 946
 947         ret = bt_ctf_field_type_structure_add_field(packet_context_type,
 948                 _uint64_t, "timestamp_end");
 949         if (ret) {
 950                 goto end;
 951         }
 952
 953         ret = bt_ctf_field_type_structure_add_field(packet_context_type,
 954                 _uint64_t, "content_size");
 955         if (ret) {
 956                 goto end;
 957         }
 958
 959         ret = bt_ctf_field_type_structure_add_field(packet_context_type,
 960                 _uint64_t, "packet_size");
 961         if (ret) {
 962                 goto end;
 963         }
 964
 965         ret = bt_ctf_field_type_structure_add_field(packet_context_type,
 966                 _uint64_t, "events_discarded");
 967         if (ret) {
 968                 goto end;
 969         }
 970
 971         bt_put(stream_class->packet_context_type);
 972         stream_class->packet_context_type = packet_context_type;
 973 end:
 974         if (ret) {
 975                 bt_put(packet_context_type);
 976                 goto end;
 977         }
 978
 979         bt_put(_uint64_t);
 980         return ret;
 981 }