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