formats/ctf/ir/trace.c

   1 /*
   2  * trace.c
   3  *
   4  * Babeltrace CTF IR - Trace
   5  *
   6  * Copyright 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  *
   8  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  */
  28
  29 #include <babeltrace/ctf-ir/trace-internal.h>
  30 #include <babeltrace/ctf-ir/clock-internal.h>
  31 #include <babeltrace/ctf-ir/stream-internal.h>
  32 #include <babeltrace/ctf-ir/stream-class-internal.h>
  33 #include <babeltrace/ctf-ir/event-internal.h>
  34 #include <babeltrace/ctf-ir/event-class.h>
  35 #include <babeltrace/ctf-ir/event-class-internal.h>
  36 #include <babeltrace/ctf-writer/functor-internal.h>
  37 #include <babeltrace/ctf-ir/field-types-internal.h>
  38 #include <babeltrace/ctf-ir/attributes-internal.h>
  39 #include <babeltrace/ctf-ir/validation-internal.h>
  40 #include <babeltrace/ctf-ir/visitor-internal.h>
  41 #include <babeltrace/ctf-ir/utils.h>
  42 #include <babeltrace/plugin/notification/schema.h>
  43 #include <babeltrace/compiler.h>
  44 #include <babeltrace/values.h>
  45 #include <babeltrace/ref.h>
  46 #include <babeltrace/endian.h>
  47
  48 #define DEFAULT_IDENTIFIER_SIZE 128
  49 #define DEFAULT_METADATA_STRING_SIZE 4096
  50
  51 struct listener_wrapper {
  52         bt_ctf_listener_cb listener;
  53         void *data;
  54 };
  55
  56 static
  57 void bt_ctf_trace_destroy(struct bt_object *obj);
  58 static
  59 int init_trace_packet_header(struct bt_ctf_trace *trace);
  60 static
  61 void bt_ctf_trace_freeze(struct bt_ctf_trace *trace);
  62
  63 static
  64 const unsigned int field_type_aliases_alignments[] = {
  65         [FIELD_TYPE_ALIAS_UINT5_T] = 1,
  66         [FIELD_TYPE_ALIAS_UINT8_T ... FIELD_TYPE_ALIAS_UINT16_T] = 8,
  67         [FIELD_TYPE_ALIAS_UINT27_T] = 1,
  68         [FIELD_TYPE_ALIAS_UINT32_T ... FIELD_TYPE_ALIAS_UINT64_T] = 8,
  69 };
  70
  71 static
  72 const unsigned int field_type_aliases_sizes[] = {
  73         [FIELD_TYPE_ALIAS_UINT5_T] = 5,
  74         [FIELD_TYPE_ALIAS_UINT8_T] = 8,
  75         [FIELD_TYPE_ALIAS_UINT16_T] = 16,
  76         [FIELD_TYPE_ALIAS_UINT27_T] = 27,
  77         [FIELD_TYPE_ALIAS_UINT32_T] = 32,
  78         [FIELD_TYPE_ALIAS_UINT64_T] = 64,
  79 };
  80
  81 struct bt_ctf_trace *bt_ctf_trace_create(void)
  82 {
  83         struct bt_ctf_trace *trace = NULL;
  84
  85         trace = g_new0(struct bt_ctf_trace, 1);
  86         if (!trace) {
  87                 goto error;
  88         }
  89
  90         bt_ctf_trace_set_byte_order(trace, BT_CTF_BYTE_ORDER_NATIVE);
  91         bt_object_init(trace, bt_ctf_trace_destroy);
  92         trace->clocks = g_ptr_array_new_with_free_func(
  93                 (GDestroyNotify) bt_put);
  94         trace->streams = g_ptr_array_new_with_free_func(
  95                 (GDestroyNotify) bt_object_release);
  96         trace->stream_classes = g_ptr_array_new_with_free_func(
  97                 (GDestroyNotify) bt_object_release);
  98         if (!trace->clocks || !trace->stream_classes || !trace->streams) {
  99                 goto error;
 100         }
 101
 102         /* Generate a trace UUID */
 103         uuid_generate(trace->uuid);
 104         if (init_trace_packet_header(trace)) {
 105                 goto error;
 106         }
 107
 108         /* Create the environment array object */
 109         trace->environment = bt_ctf_attributes_create();
 110         if (!trace->environment) {
 111                 goto error;
 112         }
 113
 114         return trace;
 115
 116 error:
 117         BT_PUT(trace);
 118         return trace;
 119 }
 120
 121 void bt_ctf_trace_destroy(struct bt_object *obj)
 122 {
 123         struct bt_ctf_trace *trace;
 124
 125         trace = container_of(obj, struct bt_ctf_trace, base);
 126         if (trace->environment) {
 127                 bt_ctf_attributes_destroy(trace->environment);
 128         }
 129
 130         if (trace->clocks) {
 131                 g_ptr_array_free(trace->clocks, TRUE);
 132         }
 133
 134         if (trace->streams) {
 135                 g_ptr_array_free(trace->streams, TRUE);
 136         }
 137
 138         if (trace->stream_classes) {
 139                 g_ptr_array_free(trace->stream_classes, TRUE);
 140         }
 141
 142         bt_put(trace->packet_header_type);
 143         g_free(trace);
 144 }
 145
 146 int bt_ctf_trace_set_environment_field(struct bt_ctf_trace *trace,
 147                 const char *name, struct bt_value *value)
 148 {
 149         int ret = 0;
 150
 151         if (!trace || !name || !value ||
 152                 bt_ctf_validate_identifier(name) ||
 153                 !(bt_value_is_integer(value) || bt_value_is_string(value))) {
 154                 ret = -1;
 155                 goto end;
 156         }
 157
 158         if (strchr(name, ' ')) {
 159                 ret = -1;
 160                 goto end;
 161         }
 162
 163         if (trace->frozen) {
 164                 /*
 165                  * New environment fields may be added to a frozen trace,
 166                  * but existing fields may not be changed.
 167                  *
 168                  * The object passed is frozen like all other attributes.
 169                  */
 170                 struct bt_value *attribute =
 171                         bt_ctf_attributes_get_field_value_by_name(
 172                                 trace->environment, name);
 173
 174                 if (attribute) {
 175                         BT_PUT(attribute);
 176                         ret = -1;
 177                         goto end;
 178                 }
 179
 180                 bt_value_freeze(value);
 181         }
 182
 183         ret = bt_ctf_attributes_set_field_value(trace->environment, name,
 184                 value);
 185
 186 end:
 187         return ret;
 188 }
 189
 190 int bt_ctf_trace_set_environment_field_string(struct bt_ctf_trace *trace,
 191                 const char *name, const char *value)
 192 {
 193         int ret = 0;
 194         struct bt_value *env_value_string_obj = NULL;
 195
 196         if (!trace || !name || !value) {
 197                 ret = -1;
 198                 goto end;
 199         }
 200
 201         if (trace->frozen) {
 202                 /*
 203                  * New environment fields may be added to a frozen trace,
 204                  * but existing fields may not be changed.
 205                  */
 206                 struct bt_value *attribute =
 207                         bt_ctf_attributes_get_field_value_by_name(
 208                                 trace->environment, name);
 209
 210                 if (attribute) {
 211                         BT_PUT(attribute);
 212                         ret = -1;
 213                         goto end;
 214                 }
 215         }
 216
 217         env_value_string_obj = bt_value_string_create_init(value);
 218
 219         if (!env_value_string_obj) {
 220                 ret = -1;
 221                 goto end;
 222         }
 223
 224         if (trace->frozen) {
 225                 bt_value_freeze(env_value_string_obj);
 226         }
 227         ret = bt_ctf_trace_set_environment_field(trace, name,
 228                 env_value_string_obj);
 229
 230 end:
 231         BT_PUT(env_value_string_obj);
 232         return ret;
 233 }
 234
 235 int bt_ctf_trace_set_environment_field_integer(struct bt_ctf_trace *trace,
 236                 const char *name, int64_t value)
 237 {
 238         int ret = 0;
 239         struct bt_value *env_value_integer_obj = NULL;
 240
 241         if (!trace || !name) {
 242                 ret = -1;
 243                 goto end;
 244         }
 245
 246         if (trace->frozen) {
 247                 /*
 248                  * New environment fields may be added to a frozen trace,
 249                  * but existing fields may not be changed.
 250                  */
 251                 struct bt_value *attribute =
 252                         bt_ctf_attributes_get_field_value_by_name(
 253                                 trace->environment, name);
 254
 255                 if (attribute) {
 256                         BT_PUT(attribute);
 257                         ret = -1;
 258                         goto end;
 259                 }
 260         }
 261
 262         env_value_integer_obj = bt_value_integer_create_init(value);
 263         if (!env_value_integer_obj) {
 264                 ret = -1;
 265                 goto end;
 266         }
 267
 268         ret = bt_ctf_trace_set_environment_field(trace, name,
 269                 env_value_integer_obj);
 270         if (trace->frozen) {
 271                 bt_value_freeze(env_value_integer_obj);
 272         }
 273 end:
 274         BT_PUT(env_value_integer_obj);
 275         return ret;
 276 }
 277
 278 int bt_ctf_trace_get_environment_field_count(struct bt_ctf_trace *trace)
 279 {
 280         int ret = 0;
 281
 282         if (!trace) {
 283                 ret = -1;
 284                 goto end;
 285         }
 286
 287         ret = bt_ctf_attributes_get_count(trace->environment);
 288
 289 end:
 290         return ret;
 291 }
 292
 293 const char *
 294 bt_ctf_trace_get_environment_field_name(struct bt_ctf_trace *trace,
 295                 int index)
 296 {
 297         const char *ret = NULL;
 298
 299         if (!trace) {
 300                 goto end;
 301         }
 302
 303         ret = bt_ctf_attributes_get_field_name(trace->environment, index);
 304
 305 end:
 306         return ret;
 307 }
 308
 309 struct bt_value *bt_ctf_trace_get_environment_field_value(
 310                 struct bt_ctf_trace *trace, int index)
 311 {
 312         struct bt_value *ret = NULL;
 313
 314         if (!trace) {
 315                 goto end;
 316         }
 317
 318         ret = bt_ctf_attributes_get_field_value(trace->environment, index);
 319
 320 end:
 321         return ret;
 322 }
 323
 324 struct bt_value *bt_ctf_trace_get_environment_field_value_by_name(
 325                 struct bt_ctf_trace *trace, const char *name)
 326 {
 327         struct bt_value *ret = NULL;
 328
 329         if (!trace || !name) {
 330                 goto end;
 331         }
 332
 333         ret = bt_ctf_attributes_get_field_value_by_name(trace->environment,
 334                 name);
 335
 336 end:
 337         return ret;
 338 }
 339
 340 int bt_ctf_trace_add_clock(struct bt_ctf_trace *trace,
 341                 struct bt_ctf_clock *clock)
 342 {
 343         int ret = 0;
 344         struct search_query query = { .value = clock, .found = 0 };
 345
 346         if (!trace || !clock) {
 347                 ret = -1;
 348                 goto end;
 349         }
 350
 351         /* Check for duplicate clocks */
 352         g_ptr_array_foreach(trace->clocks, value_exists, &query);
 353         if (query.found) {
 354                 ret = -1;
 355                 goto end;
 356         }
 357
 358         bt_get(clock);
 359         g_ptr_array_add(trace->clocks, clock);
 360
 361         if (!trace->is_created_by_writer) {
 362                 /*
 363                  * Non-writer mode trace: disable clock value functions
 364                  * because clock values are per-stream in that
 365                  * situation.
 366                  */
 367                 clock->has_value = 0;
 368         }
 369
 370         if (trace->frozen) {
 371                 bt_ctf_clock_freeze(clock);
 372         }
 373 end:
 374         return ret;
 375 }
 376
 377 int bt_ctf_trace_get_clock_count(struct bt_ctf_trace *trace)
 378 {
 379         int ret = -1;
 380
 381         if (!trace) {
 382                 goto end;
 383         }
 384
 385         ret = trace->clocks->len;
 386 end:
 387         return ret;
 388 }
 389
 390 struct bt_ctf_clock *bt_ctf_trace_get_clock(struct bt_ctf_trace *trace,
 391                 int index)
 392 {
 393         struct bt_ctf_clock *clock = NULL;
 394
 395         if (!trace || index < 0 || index >= trace->clocks->len) {
 396                 goto end;
 397         }
 398
 399         clock = g_ptr_array_index(trace->clocks, index);
 400         bt_get(clock);
 401 end:
 402         return clock;
 403 }
 404
 405 int bt_ctf_trace_add_stream_class(struct bt_ctf_trace *trace,
 406                 struct bt_ctf_stream_class *stream_class)
 407 {
 408         int ret, i;
 409         int64_t stream_id;
 410         struct bt_ctf_validation_output trace_sc_validation_output = { 0 };
 411         struct bt_ctf_validation_output *ec_validation_outputs = NULL;
 412         const enum bt_ctf_validation_flag trace_sc_validation_flags =
 413                 BT_CTF_VALIDATION_FLAG_TRACE |
 414                 BT_CTF_VALIDATION_FLAG_STREAM;
 415         const enum bt_ctf_validation_flag ec_validation_flags =
 416                 BT_CTF_VALIDATION_FLAG_EVENT;
 417         struct bt_ctf_field_type *packet_header_type = NULL;
 418         struct bt_ctf_field_type *packet_context_type = NULL;
 419         struct bt_ctf_field_type *event_header_type = NULL;
 420         struct bt_ctf_field_type *stream_event_ctx_type = NULL;
 421         int event_class_count;
 422         struct bt_ctf_clock *clock_to_add_to_trace = NULL;
 423
 424         if (!trace || !stream_class) {
 425                 ret = -1;
 426                 goto end;
 427         }
 428
 429         event_class_count =
 430                 bt_ctf_stream_class_get_event_class_count(stream_class);
 431         assert(event_class_count >= 0);
 432
 433         /* Check for duplicate stream classes */
 434         for (i = 0; i < trace->stream_classes->len; i++) {
 435                 if (trace->stream_classes->pdata[i] == stream_class) {
 436                         /* Stream class already registered to the trace */
 437                         ret = -1;
 438                         goto end;
 439                 }
 440         }
 441
 442         /*
 443          * If the stream class has a clock, register this clock to this
 444          * trace if not already done.
 445          */
 446         if (stream_class->clock) {
 447                 const char *clock_name =
 448                         bt_ctf_clock_get_name(stream_class->clock);
 449                 struct bt_ctf_clock *trace_clock;
 450
 451                 assert(clock_name);
 452                 trace_clock = bt_ctf_trace_get_clock_by_name(trace, clock_name);
 453                 bt_put(trace_clock);
 454                 if (trace_clock) {
 455                         if (trace_clock != stream_class->clock) {
 456                                 /*
 457                                  * Error: two different clocks in the
 458                                  * trace would share the same name.
 459                                  */
 460                                 ret = -1;
 461                                 goto end;
 462                         }
 463                 } else {
 464                         clock_to_add_to_trace = bt_get(stream_class->clock);
 465                 }
 466         }
 467
 468         /*
 469          * We're about to freeze both the trace and the stream class.
 470          * Also, each event class contained in this stream class are
 471          * already frozen.
 472          *
 473          * This trace, this stream class, and all its event classes
 474          * should be valid at this point.
 475          *
 476          * Validate trace and stream class first, then each event
 477          * class of this stream class can be validated individually.
 478          */
 479         packet_header_type =
 480                 bt_ctf_trace_get_packet_header_type(trace);
 481         packet_context_type =
 482                 bt_ctf_stream_class_get_packet_context_type(stream_class);
 483         event_header_type =
 484                 bt_ctf_stream_class_get_event_header_type(stream_class);
 485         stream_event_ctx_type =
 486                 bt_ctf_stream_class_get_event_context_type(stream_class);
 487         ret = bt_ctf_validate_class_types(trace->environment,
 488                 packet_header_type, packet_context_type, event_header_type,
 489                 stream_event_ctx_type, NULL, NULL, trace->valid,
 490                 stream_class->valid, 1, &trace_sc_validation_output,
 491                 trace_sc_validation_flags);
 492         BT_PUT(packet_header_type);
 493         BT_PUT(packet_context_type);
 494         BT_PUT(event_header_type);
 495         BT_PUT(stream_event_ctx_type);
 496
 497         if (ret) {
 498                 /*
 499                  * This means something went wrong during the validation
 500                  * process, not that the objects are invalid.
 501                  */
 502                 goto end;
 503         }
 504
 505         if ((trace_sc_validation_output.valid_flags &
 506                         trace_sc_validation_flags) !=
 507                         trace_sc_validation_flags) {
 508                 /* Invalid trace/stream class */
 509                 ret = -1;
 510                 goto end;
 511         }
 512
 513         if (event_class_count > 0) {
 514                 ec_validation_outputs = g_new0(struct bt_ctf_validation_output,
 515                         event_class_count);
 516                 if (!ec_validation_outputs) {
 517                         ret = -1;
 518                         goto end;
 519                 }
 520         }
 521
 522         /* Validate each event class individually */
 523         for (i = 0; i < event_class_count; i++) {
 524                 struct bt_ctf_event_class *event_class =
 525                         bt_ctf_stream_class_get_event_class(stream_class, i);
 526                 struct bt_ctf_field_type *event_context_type = NULL;
 527                 struct bt_ctf_field_type *event_payload_type = NULL;
 528
 529                 event_context_type =
 530                         bt_ctf_event_class_get_context_type(event_class);
 531                 event_payload_type =
 532                         bt_ctf_event_class_get_payload_type(event_class);
 533
 534                 /*
 535                  * It is important to use the field types returned by
 536                  * the previous trace and stream class validation here
 537                  * because copies could have been made.
 538                  */
 539                 ret = bt_ctf_validate_class_types(trace->environment,
 540                         trace_sc_validation_output.packet_header_type,
 541                         trace_sc_validation_output.packet_context_type,
 542                         trace_sc_validation_output.event_header_type,
 543                         trace_sc_validation_output.stream_event_ctx_type,
 544                         event_context_type, event_payload_type,
 545                         1, 1, event_class->valid, &ec_validation_outputs[i],
 546                         ec_validation_flags);
 547                 BT_PUT(event_context_type);
 548                 BT_PUT(event_payload_type);
 549                 BT_PUT(event_class);
 550
 551                 if (ret) {
 552                         goto end;
 553                 }
 554
 555                 if ((ec_validation_outputs[i].valid_flags &
 556                                 ec_validation_flags) != ec_validation_flags) {
 557                         /* Invalid event class */
 558                         ret = -1;
 559                         goto end;
 560                 }
 561         }
 562
 563         stream_id = bt_ctf_stream_class_get_id(stream_class);
 564         if (stream_id < 0) {
 565                 stream_id = trace->next_stream_id++;
 566
 567                 /* Try to assign a new stream id */
 568                 for (i = 0; i < trace->stream_classes->len; i++) {
 569                         if (stream_id == bt_ctf_stream_class_get_id(
 570                                 trace->stream_classes->pdata[i])) {
 571                                 /* Duplicate stream id found */
 572                                 ret = -1;
 573                                 goto end;
 574                         }
 575                 }
 576
 577                 if (bt_ctf_stream_class_set_id_no_check(stream_class,
 578                         stream_id)) {
 579                         /* TODO Should retry with a different stream id */
 580                         ret = -1;
 581                         goto end;
 582                 }
 583         }
 584
 585         bt_object_set_parent(stream_class, trace);
 586         g_ptr_array_add(trace->stream_classes, stream_class);
 587
 588         /*
 589          * At this point we know that the function will be successful.
 590          * Therefore we can replace the trace and stream class field
 591          * types with what's in their validation output structure and
 592          * mark them as valid. We can also replace the field types of
 593          * all the event classes of the stream class and mark them as
 594          * valid.
 595          */
 596         bt_ctf_validation_replace_types(trace, stream_class, NULL,
 597                 &trace_sc_validation_output, trace_sc_validation_flags);
 598         trace->valid = 1;
 599         stream_class->valid = 1;
 600
 601         /*
 602          * Put what was not moved in bt_ctf_validation_replace_types().
 603          */
 604         bt_ctf_validation_output_put_types(&trace_sc_validation_output);
 605
 606         for (i = 0; i < event_class_count; i++) {
 607                 struct bt_ctf_event_class *event_class =
 608                         bt_ctf_stream_class_get_event_class(stream_class, i);
 609
 610                 bt_ctf_validation_replace_types(NULL, NULL, event_class,
 611                         &ec_validation_outputs[i], ec_validation_flags);
 612                 event_class->valid = 1;
 613                 BT_PUT(event_class);
 614
 615                 /*
 616                  * Put what was not moved in
 617                  * bt_ctf_validation_replace_types().
 618                  */
 619                 bt_ctf_validation_output_put_types(&ec_validation_outputs[i]);
 620         }
 621
 622         /*
 623          * All field type byte orders set as "native" byte ordering can now be
 624          * safely set to trace's own endianness, including the stream class'.
 625          */
 626         bt_ctf_field_type_set_native_byte_order(trace->packet_header_type,
 627                 trace->byte_order);
 628         bt_ctf_stream_class_set_byte_order(stream_class, trace->byte_order);
 629
 630         /* Add stream class's clock if it exists */
 631         if (clock_to_add_to_trace) {
 632                 int add_clock_ret =
 633                         bt_ctf_trace_add_clock(trace, clock_to_add_to_trace);
 634                 assert(add_clock_ret == 0);
 635         }
 636
 637         /*
 638          * Freeze the trace and the stream class.
 639          */
 640         bt_ctf_stream_class_freeze(stream_class);
 641         bt_ctf_trace_freeze(trace);
 642
 643 end:
 644         if (ret) {
 645                 bt_object_set_parent(stream_class, NULL);
 646
 647                 if (ec_validation_outputs) {
 648                         for (i = 0; i < event_class_count; i++) {
 649                                 bt_ctf_validation_output_put_types(
 650                                         &ec_validation_outputs[i]);
 651                         }
 652                 }
 653         }
 654
 655         g_free(ec_validation_outputs);
 656         bt_ctf_validation_output_put_types(&trace_sc_validation_output);
 657         BT_PUT(clock_to_add_to_trace);
 658         assert(!packet_header_type);
 659         assert(!packet_context_type);
 660         assert(!event_header_type);
 661         assert(!stream_event_ctx_type);
 662
 663         return ret;
 664 }
 665
 666 int bt_ctf_trace_get_stream_class_count(struct bt_ctf_trace *trace)
 667 {
 668         int ret;
 669
 670         if (!trace) {
 671                 ret = -1;
 672                 goto end;
 673         }
 674
 675         ret = trace->stream_classes->len;
 676 end:
 677         return ret;
 678 }
 679
 680 struct bt_ctf_stream_class *bt_ctf_trace_get_stream_class(
 681                 struct bt_ctf_trace *trace, int index)
 682 {
 683         struct bt_ctf_stream_class *stream_class = NULL;
 684
 685         if (!trace || index < 0 || index >= trace->stream_classes->len) {
 686                 goto end;
 687         }
 688
 689         stream_class = g_ptr_array_index(trace->stream_classes, index);
 690         bt_get(stream_class);
 691 end:
 692         return stream_class;
 693 }
 694
 695 struct bt_ctf_stream_class *bt_ctf_trace_get_stream_class_by_id(
 696                 struct bt_ctf_trace *trace, uint32_t id)
 697 {
 698         int i;
 699         struct bt_ctf_stream_class *stream_class = NULL;
 700
 701         if (!trace) {
 702                 goto end;
 703         }
 704
 705         for (i = 0; i < trace->stream_classes->len; i++) {
 706                 struct bt_ctf_stream_class *stream_class_candidate;
 707
 708                 stream_class_candidate =
 709                         g_ptr_array_index(trace->stream_classes, i);
 710
 711                 if (bt_ctf_stream_class_get_id(stream_class_candidate) ==
 712                                 (int64_t) id) {
 713                         stream_class = stream_class_candidate;
 714                         bt_get(stream_class);
 715                         goto end;
 716                 }
 717         }
 718
 719 end:
 720         return stream_class;
 721 }
 722
 723 struct bt_ctf_clock *bt_ctf_trace_get_clock_by_name(
 724                 struct bt_ctf_trace *trace, const char *name)
 725 {
 726         size_t i;
 727         struct bt_ctf_clock *clock = NULL;
 728
 729         if (!trace || !name) {
 730                 goto end;
 731         }
 732
 733         for (i = 0; i < trace->clocks->len; i++) {
 734                 struct bt_ctf_clock *cur_clk =
 735                         g_ptr_array_index(trace->clocks, i);
 736                 const char *cur_clk_name = bt_ctf_clock_get_name(cur_clk);
 737
 738                 if (!cur_clk_name) {
 739                         goto end;
 740                 }
 741
 742                 if (!strcmp(cur_clk_name, name)) {
 743                         clock = cur_clk;
 744                         bt_get(clock);
 745                         goto end;
 746                 }
 747         }
 748
 749 end:
 750         return clock;
 751 }
 752
 753 BT_HIDDEN
 754 const char *get_byte_order_string(int byte_order)
 755 {
 756         const char *string;
 757
 758         switch (byte_order) {
 759         case LITTLE_ENDIAN:
 760                 string = "le";
 761                 break;
 762         case BIG_ENDIAN:
 763                 string = "be";
 764                 break;
 765         default:
 766                 string = "unknown";
 767                 break;
 768         }
 769
 770         return string;
 771 }
 772
 773 static
 774 int append_trace_metadata(struct bt_ctf_trace *trace,
 775                 struct metadata_context *context)
 776 {
 777         unsigned char *uuid = trace->uuid;
 778         int ret;
 779
 780         g_string_append(context->string, "trace {\n");
 781
 782         g_string_append(context->string, "\tmajor = 1;\n");
 783         g_string_append(context->string, "\tminor = 8;\n");
 784
 785         g_string_append_printf(context->string,
 786                 "\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n",
 787                 uuid[0], uuid[1], uuid[2], uuid[3],
 788                 uuid[4], uuid[5], uuid[6], uuid[7],
 789                 uuid[8], uuid[9], uuid[10], uuid[11],
 790                 uuid[12], uuid[13], uuid[14], uuid[15]);
 791         g_string_append_printf(context->string, "\tbyte_order = %s;\n",
 792                 get_byte_order_string(trace->byte_order));
 793
 794         g_string_append(context->string, "\tpacket.header := ");
 795         context->current_indentation_level++;
 796         g_string_assign(context->field_name, "");
 797         ret = bt_ctf_field_type_serialize(trace->packet_header_type,
 798                 context);
 799         if (ret) {
 800                 goto end;
 801         }
 802         context->current_indentation_level--;
 803
 804         g_string_append(context->string, ";\n};\n\n");
 805 end:
 806         return ret;
 807 }
 808
 809 static
 810 void append_env_metadata(struct bt_ctf_trace *trace,
 811                 struct metadata_context *context)
 812 {
 813         int i;
 814         int env_size;
 815
 816         env_size = bt_ctf_attributes_get_count(trace->environment);
 817
 818         if (env_size <= 0) {
 819                 return;
 820         }
 821
 822         g_string_append(context->string, "env {\n");
 823
 824         for (i = 0; i < env_size; i++) {
 825                 struct bt_value *env_field_value_obj = NULL;
 826                 const char *entry_name;
 827
 828                 entry_name = bt_ctf_attributes_get_field_name(
 829                         trace->environment, i);
 830                 env_field_value_obj = bt_ctf_attributes_get_field_value(
 831                         trace->environment, i);
 832
 833                 if (!entry_name || !env_field_value_obj) {
 834                         goto loop_next;
 835                 }
 836
 837                 switch (bt_value_get_type(env_field_value_obj)) {
 838                 case BT_VALUE_TYPE_INTEGER:
 839                 {
 840                         int ret;
 841                         int64_t int_value;
 842
 843                         ret = bt_value_integer_get(env_field_value_obj,
 844                                 &int_value);
 845
 846                         if (ret) {
 847                                 goto loop_next;
 848                         }
 849
 850                         g_string_append_printf(context->string,
 851                                 "\t%s = %" PRId64 ";\n", entry_name,
 852                                 int_value);
 853                         break;
 854                 }
 855                 case BT_VALUE_TYPE_STRING:
 856                 {
 857                         int ret;
 858                         const char *str_value;
 859                         char *escaped_str = NULL;
 860
 861                         ret = bt_value_string_get(env_field_value_obj,
 862                                 &str_value);
 863
 864                         if (ret) {
 865                                 goto loop_next;
 866                         }
 867
 868                         escaped_str = g_strescape(str_value, NULL);
 869
 870                         if (!escaped_str) {
 871                                 goto loop_next;
 872                         }
 873
 874                         g_string_append_printf(context->string,
 875                                 "\t%s = \"%s\";\n", entry_name, escaped_str);
 876                         free(escaped_str);
 877                         break;
 878                 }
 879
 880                 default:
 881                         goto loop_next;
 882                 }
 883
 884 loop_next:
 885                 BT_PUT(env_field_value_obj);
 886         }
 887
 888         g_string_append(context->string, "};\n\n");
 889 }
 890
 891 char *bt_ctf_trace_get_metadata_string(struct bt_ctf_trace *trace)
 892 {
 893         char *metadata = NULL;
 894         struct metadata_context *context = NULL;
 895         int err = 0;
 896         size_t i;
 897
 898         if (!trace) {
 899                 goto end;
 900         }
 901
 902         context = g_new0(struct metadata_context, 1);
 903         if (!context) {
 904                 goto end;
 905         }
 906
 907         context->field_name = g_string_sized_new(DEFAULT_IDENTIFIER_SIZE);
 908         context->string = g_string_sized_new(DEFAULT_METADATA_STRING_SIZE);
 909         g_string_append(context->string, "/* CTF 1.8 */\n\n");
 910         if (append_trace_metadata(trace, context)) {
 911                 goto error;
 912         }
 913         append_env_metadata(trace, context);
 914         g_ptr_array_foreach(trace->clocks,
 915                 (GFunc)bt_ctf_clock_serialize, context);
 916
 917         for (i = 0; i < trace->stream_classes->len; i++) {
 918                 err = bt_ctf_stream_class_serialize(
 919                         trace->stream_classes->pdata[i], context);
 920                 if (err) {
 921                         goto error;
 922                 }
 923         }
 924
 925         metadata = context->string->str;
 926 error:
 927         g_string_free(context->string, err ? TRUE : FALSE);
 928         g_string_free(context->field_name, TRUE);
 929         g_free(context);
 930 end:
 931         return metadata;
 932 }
 933
 934 enum bt_ctf_byte_order bt_ctf_trace_get_byte_order(struct bt_ctf_trace *trace)
 935 {
 936         enum bt_ctf_byte_order ret = BT_CTF_BYTE_ORDER_UNKNOWN;
 937
 938         if (!trace) {
 939                 goto end;
 940         }
 941
 942         switch (trace->byte_order) {
 943         case BIG_ENDIAN:
 944                 ret = BT_CTF_BYTE_ORDER_BIG_ENDIAN;
 945                 break;
 946         case LITTLE_ENDIAN:
 947                 ret = BT_CTF_BYTE_ORDER_LITTLE_ENDIAN;
 948                 break;
 949         default:
 950                 break;
 951         }
 952 end:
 953         return ret;
 954 }
 955
 956 int bt_ctf_trace_set_byte_order(struct bt_ctf_trace *trace,
 957                 enum bt_ctf_byte_order byte_order)
 958 {
 959         int ret = 0;
 960         int internal_byte_order;
 961
 962         if (!trace || trace->frozen) {
 963                 ret = -1;
 964                 goto end;
 965         }
 966
 967         switch (byte_order) {
 968         case BT_CTF_BYTE_ORDER_NATIVE:
 969                 /*
 970                  * This doesn't make sense since the CTF specification defines
 971                  * the "native" byte order as "the byte order described in the
 972                  * trace description". However, this behavior had been
 973                  * implemented as part of v1.2 and is kept to maintain
 974                  * compatibility.
 975                  *
 976                  * This may be changed on a major version bump only.
 977                  */
 978                 internal_byte_order = (G_BYTE_ORDER == G_LITTLE_ENDIAN) ?
 979                         LITTLE_ENDIAN : BIG_ENDIAN;
 980                 break;
 981         case BT_CTF_BYTE_ORDER_LITTLE_ENDIAN:
 982                 internal_byte_order = LITTLE_ENDIAN;
 983                 break;
 984         case BT_CTF_BYTE_ORDER_BIG_ENDIAN:
 985         case BT_CTF_BYTE_ORDER_NETWORK:
 986                 internal_byte_order = BIG_ENDIAN;
 987                 break;
 988         default:
 989                 ret = -1;
 990                 goto end;
 991         }
 992
 993         trace->byte_order = internal_byte_order;
 994 end:
 995         return ret;
 996 }
 997
 998 struct bt_ctf_field_type *bt_ctf_trace_get_packet_header_type(
 999                 struct bt_ctf_trace *trace)
1000 {
1001         struct bt_ctf_field_type *field_type = NULL;
1002
1003         if (!trace) {
1004                 goto end;
1005         }
1006
1007         bt_get(trace->packet_header_type);
1008         field_type = trace->packet_header_type;
1009 end:
1010         return field_type;
1011 }
1012
1013 int bt_ctf_trace_set_packet_header_type(struct bt_ctf_trace *trace,
1014                 struct bt_ctf_field_type *packet_header_type)
1015 {
1016         int ret = 0;
1017
1018         if (!trace || !packet_header_type || trace->frozen) {
1019                 ret = -1;
1020                 goto end;
1021         }
1022
1023         /* packet_header_type must be a structure */
1024         if (bt_ctf_field_type_get_type_id(packet_header_type) !=
1025                 BT_CTF_TYPE_ID_STRUCT) {
1026                 ret = -1;
1027                 goto end;
1028         }
1029
1030         bt_get(packet_header_type);
1031         bt_put(trace->packet_header_type);
1032         trace->packet_header_type = packet_header_type;
1033 end:
1034         return ret;
1035 }
1036
1037 static
1038 int get_stream_class_count(void *element)
1039 {
1040         return bt_ctf_trace_get_stream_class_count(
1041                         (struct bt_ctf_trace *) element);
1042 }
1043
1044 static
1045 void *get_stream_class(void *element, int i)
1046 {
1047         return bt_ctf_trace_get_stream_class(
1048                         (struct bt_ctf_trace *) element, i);
1049 }
1050
1051 static
1052 int visit_stream_class(void *element, bt_ctf_ir_visitor visitor,void *data)
1053 {
1054         return bt_ctf_stream_class_visit(element, visitor, data);
1055 }
1056
1057 int bt_ctf_trace_visit(struct bt_ctf_trace *trace,
1058                 bt_ctf_ir_visitor visitor, void *data)
1059 {
1060         int ret;
1061         struct bt_ctf_ir_element element =
1062                         { .element = trace, .type = BT_CTF_IR_TYPE_TRACE };
1063
1064         if (!trace || !visitor) {
1065                 ret = -1;
1066                 goto end;
1067         }
1068
1069         ret = visitor_helper(&element, get_stream_class_count,
1070                         get_stream_class, visit_stream_class, visitor, data);
1071 end:
1072         return ret;
1073 }
1074
1075 static
1076 int ir_visitor(struct bt_ctf_ir_element *element, void *data)
1077 {
1078         int ret = 0;
1079
1080         switch (element->type) {
1081         case BT_CTF_IR_TYPE_TRACE:
1082         {
1083                 break;
1084         }
1085         case BT_CTF_IR_TYPE_STREAM_CLASS:
1086         {
1087                 break;
1088         }
1089         case BT_CTF_IR_TYPE_EVENT_CLASS:
1090         {
1091                 break;
1092         }
1093         default:
1094                 assert(0);
1095                 ret = -1;
1096                 goto end;
1097         }
1098 end:
1099         return ret;
1100 }
1101
1102 int bt_ctf_trace_add_listener(struct bt_ctf_trace *trace,
1103                 bt_ctf_listener_cb listener, void *listener_data)
1104 {
1105         int ret = 0;
1106         struct listener_wrapper *listener_wrapper =
1107                         g_new0(struct listener_wrapper, 1);
1108
1109         if (!trace || !listener || !listener_wrapper) {
1110                 ret = -1;
1111                 goto error;
1112         }
1113
1114         listener_wrapper->listener = listener;
1115         listener_wrapper->data = listener_data;
1116
1117         /* Visit the current schema. */
1118         ret = bt_ctf_trace_visit(trace, ir_visitor, listener_wrapper);
1119         if (ret) {
1120                 goto error;
1121         }
1122
1123         /*
1124          * Add listener to the array of callbacks which will be invoked on
1125          * schema changes.
1126          */
1127         g_ptr_array_add(trace->listeners, listener_wrapper);
1128         return ret;
1129 error:
1130         g_free(listener_wrapper);
1131         return ret;
1132 }
1133
1134 BT_HIDDEN
1135 struct bt_ctf_field_type *get_field_type(enum field_type_alias alias)
1136 {
1137         int ret;
1138         unsigned int alignment, size;
1139         struct bt_ctf_field_type *field_type = NULL;
1140
1141         if (alias >= NR_FIELD_TYPE_ALIAS) {
1142                 goto end;
1143         }
1144
1145         alignment = field_type_aliases_alignments[alias];
1146         size = field_type_aliases_sizes[alias];
1147         field_type = bt_ctf_field_type_integer_create(size);
1148         ret = bt_ctf_field_type_set_alignment(field_type, alignment);
1149         if (ret) {
1150                 BT_PUT(field_type);
1151         }
1152 end:
1153         return field_type;
1154 }
1155
1156 static
1157 void bt_ctf_trace_freeze(struct bt_ctf_trace *trace)
1158 {
1159         int i;
1160
1161         bt_ctf_field_type_freeze(trace->packet_header_type);
1162         bt_ctf_attributes_freeze(trace->environment);
1163
1164         for (i = 0; i < trace->clocks->len; i++) {
1165                 struct bt_ctf_clock *clock =
1166                         g_ptr_array_index(trace->clocks, i);
1167
1168                 bt_ctf_clock_freeze(clock);
1169         }
1170
1171         trace->frozen = 1;
1172 }
1173
1174 static
1175 int init_trace_packet_header(struct bt_ctf_trace *trace)
1176 {
1177         int ret = 0;
1178         struct bt_ctf_field *magic = NULL, *uuid_array = NULL;
1179         struct bt_ctf_field_type *_uint32_t =
1180                 get_field_type(FIELD_TYPE_ALIAS_UINT32_T);
1181         struct bt_ctf_field_type *_uint8_t =
1182                 get_field_type(FIELD_TYPE_ALIAS_UINT8_T);
1183         struct bt_ctf_field_type *trace_packet_header_type =
1184                 bt_ctf_field_type_structure_create();
1185         struct bt_ctf_field_type *uuid_array_type =
1186                 bt_ctf_field_type_array_create(_uint8_t, 16);
1187
1188         if (!trace_packet_header_type || !uuid_array_type) {
1189                 ret = -1;
1190                 goto end;
1191         }
1192
1193         ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
1194                 _uint32_t, "magic");
1195         if (ret) {
1196                 goto end;
1197         }
1198
1199         ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
1200                 uuid_array_type, "uuid");
1201         if (ret) {
1202                 goto end;
1203         }
1204
1205         ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
1206                 _uint32_t, "stream_id");
1207         if (ret) {
1208                 goto end;
1209         }
1210
1211         ret = bt_ctf_trace_set_packet_header_type(trace,
1212                 trace_packet_header_type);
1213         if (ret) {
1214                 goto end;
1215         }
1216 end:
1217         bt_put(uuid_array_type);
1218         bt_put(_uint32_t);
1219         bt_put(_uint8_t);
1220         bt_put(magic);
1221         bt_put(uuid_array);
1222         bt_put(trace_packet_header_type);
1223         return ret;
1224 }