formats/ctf/ir/event.c

   1 /*
   2  * event.c
   3  *
   4  * Babeltrace CTF IR - Event
   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/event.h>
  30 #include <babeltrace/ctf-writer/event-types.h>
  31 #include <babeltrace/ctf-writer/event-fields.h>
  32 #include <babeltrace/ctf-ir/event-fields-internal.h>
  33 #include <babeltrace/ctf-ir/event-types-internal.h>
  34 #include <babeltrace/ctf-ir/event-internal.h>
  35 #include <babeltrace/ctf-ir/stream-class.h>
  36 #include <babeltrace/ctf-ir/stream-class-internal.h>
  37 #include <babeltrace/ctf-ir/trace-internal.h>
  38 #include <babeltrace/ctf-ir/validation-internal.h>
  39 #include <babeltrace/ctf-ir/utils.h>
  40 #include <babeltrace/ref.h>
  41 #include <babeltrace/ctf-ir/attributes-internal.h>
  42 #include <babeltrace/compiler.h>
  43
  44 static
  45 void bt_ctf_event_class_destroy(struct bt_object *obj);
  46 static
  47 void bt_ctf_event_destroy(struct bt_object *obj);
  48 static
  49 int set_integer_field_value(struct bt_ctf_field *field, uint64_t value);
  50
  51 struct bt_ctf_event_class *bt_ctf_event_class_create(const char *name)
  52 {
  53         int ret;
  54         struct bt_value *obj = NULL;
  55         struct bt_ctf_event_class *event_class = NULL;
  56
  57         if (bt_ctf_validate_identifier(name)) {
  58                 goto error;
  59         }
  60
  61         event_class = g_new0(struct bt_ctf_event_class, 1);
  62         if (!event_class) {
  63                 goto error;
  64         }
  65
  66         bt_object_init(event_class, bt_ctf_event_class_destroy);
  67         event_class->fields = bt_ctf_field_type_structure_create();
  68         if (!event_class->fields) {
  69                 goto error;
  70         }
  71
  72         event_class->attributes = bt_ctf_attributes_create();
  73         if (!event_class->attributes) {
  74                 goto error;
  75         }
  76
  77         obj = bt_value_integer_create_init(-1);
  78         if (!obj) {
  79                 goto error;
  80         }
  81
  82         ret = bt_ctf_attributes_set_field_value(event_class->attributes,
  83                 "id", obj);
  84         if (ret) {
  85                 goto error;
  86         }
  87
  88         BT_PUT(obj);
  89
  90         obj = bt_value_string_create_init(name);
  91         if (!obj) {
  92                 goto error;
  93         }
  94
  95         ret = bt_ctf_attributes_set_field_value(event_class->attributes,
  96                 "name", obj);
  97         if (ret) {
  98                 goto error;
  99         }
 100
 101         BT_PUT(obj);
 102
 103         return event_class;
 104
 105 error:
 106         BT_PUT(event_class);
 107         BT_PUT(obj);
 108         return event_class;
 109 }
 110
 111 const char *bt_ctf_event_class_get_name(struct bt_ctf_event_class *event_class)
 112 {
 113         struct bt_value *obj = NULL;
 114         const char *name = NULL;
 115
 116         if (!event_class) {
 117                 goto end;
 118         }
 119
 120         obj = bt_ctf_attributes_get_field_value(event_class->attributes,
 121                 BT_CTF_EVENT_CLASS_ATTR_NAME_INDEX);
 122         if (!obj) {
 123                 goto end;
 124         }
 125
 126         if (bt_value_string_get(obj, &name)) {
 127                 name = NULL;
 128         }
 129
 130 end:
 131         BT_PUT(obj);
 132         return name;
 133 }
 134
 135 int64_t bt_ctf_event_class_get_id(struct bt_ctf_event_class *event_class)
 136 {
 137         struct bt_value *obj = NULL;
 138         int64_t ret = 0;
 139
 140         if (!event_class) {
 141                 ret = -1;
 142                 goto end;
 143         }
 144
 145         obj = bt_ctf_attributes_get_field_value(event_class->attributes,
 146                 BT_CTF_EVENT_CLASS_ATTR_ID_INDEX);
 147         if (!obj) {
 148                 goto end;
 149         }
 150
 151         if (bt_value_integer_get(obj, &ret)) {
 152                 ret = -1;
 153         }
 154
 155         if (ret < 0) {
 156                 /* means ID is not set */
 157                 ret = -1;
 158                 goto end;
 159         }
 160
 161 end:
 162         BT_PUT(obj);
 163         return ret;
 164 }
 165
 166 int bt_ctf_event_class_set_id(struct bt_ctf_event_class *event_class,
 167                 uint32_t id)
 168 {
 169         int ret = 0;
 170         struct bt_value *obj = NULL;
 171         struct bt_ctf_stream_class *stream_class = NULL;
 172
 173
 174         if (!event_class) {
 175                 ret = -1;
 176                 goto end;
 177         }
 178
 179         stream_class = bt_ctf_event_class_get_stream_class(event_class);
 180         if (stream_class) {
 181                 /*
 182                  * We don't allow changing the id if the event class has already
 183                  * been added to a stream class.
 184                  */
 185                 ret = -1;
 186                 goto end;
 187         }
 188
 189         obj = bt_ctf_attributes_get_field_value(event_class->attributes,
 190                 BT_CTF_EVENT_CLASS_ATTR_ID_INDEX);
 191         if (!obj) {
 192                 goto end;
 193         }
 194
 195         if (bt_value_integer_set(obj, id)) {
 196                 ret = -1;
 197                 goto end;
 198         }
 199
 200 end:
 201         BT_PUT(obj);
 202         BT_PUT(stream_class);
 203         return ret;
 204 }
 205
 206 int bt_ctf_event_class_set_attribute(
 207                 struct bt_ctf_event_class *event_class, const char *name,
 208                 struct bt_value *value)
 209 {
 210         int ret = 0;
 211
 212         if (!event_class || !name || !value || event_class->frozen) {
 213                 ret = -1;
 214                 goto end;
 215         }
 216
 217         if (!strcmp(name, "id") || !strcmp(name, "loglevel")) {
 218                 if (!bt_value_is_integer(value)) {
 219                         ret = -1;
 220                         goto end;
 221                 }
 222         } else if (!strcmp(name, "name") || !strcmp(name, "model.emf.uri")) {
 223                 if (!bt_value_is_string(value)) {
 224                         ret = -1;
 225                         goto end;
 226                 }
 227         } else {
 228                 /* unknown attribute */
 229                 ret = -1;
 230                 goto end;
 231         }
 232
 233         /* "id" special case: >= 0 */
 234         if (!strcmp(name, "id")) {
 235                 int64_t val;
 236
 237                 ret = bt_value_integer_get(value, &val);
 238
 239                 if (ret) {
 240                         goto end;
 241                 }
 242
 243                 if (val < 0) {
 244                         ret = -1;
 245                         goto end;
 246                 }
 247         }
 248
 249         ret = bt_ctf_attributes_set_field_value(event_class->attributes,
 250                 name, value);
 251
 252 end:
 253         return ret;
 254 }
 255
 256 int bt_ctf_event_class_get_attribute_count(
 257                 struct bt_ctf_event_class *event_class)
 258 {
 259         int ret = 0;
 260
 261         if (!event_class) {
 262                 ret = -1;
 263                 goto end;
 264         }
 265
 266         ret = bt_ctf_attributes_get_count(event_class->attributes);
 267
 268 end:
 269         return ret;
 270 }
 271
 272 const char *
 273 bt_ctf_event_class_get_attribute_name(
 274                 struct bt_ctf_event_class *event_class, int index)
 275 {
 276         const char *ret;
 277
 278         if (!event_class) {
 279                 ret = NULL;
 280                 goto end;
 281         }
 282
 283         ret = bt_ctf_attributes_get_field_name(event_class->attributes, index);
 284
 285 end:
 286         return ret;
 287 }
 288
 289 struct bt_value *
 290 bt_ctf_event_class_get_attribute_value(struct bt_ctf_event_class *event_class,
 291                 int index)
 292 {
 293         struct bt_value *ret;
 294
 295         if (!event_class) {
 296                 ret = NULL;
 297                 goto end;
 298         }
 299
 300         ret = bt_ctf_attributes_get_field_value(event_class->attributes, index);
 301
 302 end:
 303         return ret;
 304 }
 305
 306 struct bt_value *
 307 bt_ctf_event_class_get_attribute_value_by_name(
 308                 struct bt_ctf_event_class *event_class, const char *name)
 309 {
 310         struct bt_value *ret;
 311
 312         if (!event_class || !name) {
 313                 ret = NULL;
 314                 goto end;
 315         }
 316
 317         ret = bt_ctf_attributes_get_field_value_by_name(event_class->attributes,
 318                 name);
 319
 320 end:
 321         return ret;
 322
 323 }
 324
 325 struct bt_ctf_stream_class *bt_ctf_event_class_get_stream_class(
 326                 struct bt_ctf_event_class *event_class)
 327 {
 328         return (struct bt_ctf_stream_class *) bt_object_get_parent(event_class);
 329 }
 330
 331 struct bt_ctf_field_type *bt_ctf_event_class_get_payload_type(
 332                 struct bt_ctf_event_class *event_class)
 333 {
 334         struct bt_ctf_field_type *payload = NULL;
 335
 336         if (!event_class) {
 337                 goto end;
 338         }
 339
 340         bt_get(event_class->fields);
 341         payload = event_class->fields;
 342 end:
 343         return payload;
 344 }
 345
 346 int bt_ctf_event_class_set_payload_type(struct bt_ctf_event_class *event_class,
 347                 struct bt_ctf_field_type *payload)
 348 {
 349         int ret = 0;
 350
 351         if (!event_class || !payload ||
 352                 bt_ctf_field_type_get_type_id(payload) != CTF_TYPE_STRUCT) {
 353                 ret = -1;
 354                 goto end;
 355         }
 356
 357         bt_get(payload);
 358         bt_put(event_class->fields);
 359         event_class->fields = payload;
 360 end:
 361         return ret;
 362 }
 363
 364 int bt_ctf_event_class_add_field(struct bt_ctf_event_class *event_class,
 365                 struct bt_ctf_field_type *type,
 366                 const char *name)
 367 {
 368         int ret = 0;
 369
 370         if (!event_class || !type || bt_ctf_validate_identifier(name) ||
 371                 event_class->frozen) {
 372                 ret = -1;
 373                 goto end;
 374         }
 375
 376         if (bt_ctf_field_type_get_type_id(event_class->fields) !=
 377                 CTF_TYPE_STRUCT) {
 378                 ret = -1;
 379                 goto end;
 380         }
 381
 382         ret = bt_ctf_field_type_structure_add_field(event_class->fields,
 383                 type, name);
 384 end:
 385         return ret;
 386 }
 387
 388 int bt_ctf_event_class_get_field_count(
 389                 struct bt_ctf_event_class *event_class)
 390 {
 391         int ret;
 392
 393         if (!event_class) {
 394                 ret = -1;
 395                 goto end;
 396         }
 397
 398         if (bt_ctf_field_type_get_type_id(event_class->fields) !=
 399                 CTF_TYPE_STRUCT) {
 400                 ret = -1;
 401                 goto end;
 402         }
 403
 404         ret = bt_ctf_field_type_structure_get_field_count(event_class->fields);
 405 end:
 406         return ret;
 407 }
 408
 409 int bt_ctf_event_class_get_field(struct bt_ctf_event_class *event_class,
 410                 const char **field_name, struct bt_ctf_field_type **field_type,
 411                 int index)
 412 {
 413         int ret;
 414
 415         if (!event_class || index < 0) {
 416                 ret = -1;
 417                 goto end;
 418         }
 419
 420         if (bt_ctf_field_type_get_type_id(event_class->fields) !=
 421                 CTF_TYPE_STRUCT) {
 422                 ret = -1;
 423                 goto end;
 424         }
 425
 426         ret = bt_ctf_field_type_structure_get_field(event_class->fields,
 427                 field_name, field_type, index);
 428 end:
 429         return ret;
 430 }
 431
 432 struct bt_ctf_field_type *bt_ctf_event_class_get_field_by_name(
 433                 struct bt_ctf_event_class *event_class, const char *name)
 434 {
 435         GQuark name_quark;
 436         struct bt_ctf_field_type *field_type = NULL;
 437
 438         if (!event_class || !name) {
 439                 goto end;
 440         }
 441
 442         if (bt_ctf_field_type_get_type_id(event_class->fields) !=
 443                 CTF_TYPE_STRUCT) {
 444                 goto end;
 445         }
 446
 447         name_quark = g_quark_try_string(name);
 448         if (!name_quark) {
 449                 goto end;
 450         }
 451
 452         /*
 453          * No need to increment field_type's reference count since getting it
 454          * from the structure already does.
 455          */
 456         field_type = bt_ctf_field_type_structure_get_field_type_by_name(
 457                 event_class->fields, name);
 458 end:
 459         return field_type;
 460 }
 461
 462 struct bt_ctf_field_type *bt_ctf_event_class_get_context_type(
 463                 struct bt_ctf_event_class *event_class)
 464 {
 465         struct bt_ctf_field_type *context_type = NULL;
 466
 467         if (!event_class || !event_class->context) {
 468                 goto end;
 469         }
 470
 471         bt_get(event_class->context);
 472         context_type = event_class->context;
 473 end:
 474         return context_type;
 475 }
 476
 477 int bt_ctf_event_class_set_context_type(
 478                 struct bt_ctf_event_class *event_class,
 479                 struct bt_ctf_field_type *context)
 480 {
 481         int ret = 0;
 482
 483         if (!event_class || !context || event_class->frozen) {
 484                 ret = -1;
 485                 goto end;
 486         }
 487
 488         if (bt_ctf_field_type_get_type_id(context) != CTF_TYPE_STRUCT) {
 489                 ret = -1;
 490                 goto end;
 491         }
 492
 493         bt_get(context);
 494         bt_put(event_class->context);
 495         event_class->context = context;
 496 end:
 497         return ret;
 498
 499 }
 500
 501 void bt_ctf_event_class_get(struct bt_ctf_event_class *event_class)
 502 {
 503         bt_get(event_class);
 504 }
 505
 506 void bt_ctf_event_class_put(struct bt_ctf_event_class *event_class)
 507 {
 508         bt_put(event_class);
 509 }
 510
 511 BT_HIDDEN
 512 int bt_ctf_event_class_set_stream_id(struct bt_ctf_event_class *event_class,
 513                 uint32_t stream_id)
 514 {
 515         int ret = 0;
 516         struct bt_value *obj;
 517
 518         obj = bt_value_integer_create_init(stream_id);
 519
 520         if (!obj) {
 521                 ret = -1;
 522                 goto end;
 523         }
 524
 525         ret = bt_ctf_attributes_set_field_value(event_class->attributes,
 526                 "stream_id", obj);
 527
 528         if (event_class->frozen) {
 529                 bt_ctf_attributes_freeze(event_class->attributes);
 530         }
 531
 532 end:
 533         BT_PUT(obj);
 534         return ret;
 535 }
 536
 537 struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class)
 538 {
 539         int ret;
 540         enum bt_ctf_validation_flag validation_flags =
 541                 BT_CTF_VALIDATION_FLAG_STREAM |
 542                 BT_CTF_VALIDATION_FLAG_EVENT;
 543         struct bt_ctf_event *event = NULL;
 544         struct bt_ctf_trace *trace = NULL;
 545         struct bt_ctf_stream_class *stream_class = NULL;
 546         struct bt_ctf_field_type *packet_header_type = NULL;
 547         struct bt_ctf_field_type *packet_context_type = NULL;
 548         struct bt_ctf_field_type *event_header_type = NULL;
 549         struct bt_ctf_field_type *stream_event_ctx_type = NULL;
 550         struct bt_ctf_field_type *event_context_type = NULL;
 551         struct bt_ctf_field_type *event_payload_type = NULL;
 552         struct bt_ctf_field *event_header = NULL;
 553         struct bt_ctf_field *event_context = NULL;
 554         struct bt_ctf_field *event_payload = NULL;
 555         struct bt_value *environment = NULL;
 556         struct bt_ctf_validation_output validation_output = { 0 };
 557         int trace_valid = 0;
 558
 559         if (!event_class) {
 560                 goto error;
 561         }
 562
 563         stream_class = bt_ctf_event_class_get_stream_class(event_class);
 564
 565         /*
 566          * We disallow the creation of an event if its event class has not been
 567          * associated to a stream class.
 568          */
 569         if (!stream_class) {
 570                 goto error;
 571         }
 572
 573         /* A stream class should always have an existing event header type */
 574         assert(stream_class->event_header_type);
 575
 576         /* The event class was frozen when added to its stream class */
 577         assert(event_class->frozen);
 578
 579         /* Validate the trace (if any), the stream class, and the event class */
 580         trace = bt_ctf_stream_class_get_trace(stream_class);
 581         if (trace) {
 582                 packet_header_type = bt_ctf_trace_get_packet_header_type(trace);
 583                 trace_valid = trace->valid;
 584                 assert(trace_valid);
 585                 environment = trace->environment;
 586         }
 587
 588         packet_context_type = bt_ctf_stream_class_get_packet_context_type(
 589                 stream_class);
 590         event_header_type = bt_ctf_stream_class_get_event_header_type(
 591                 stream_class);
 592         stream_event_ctx_type = bt_ctf_stream_class_get_event_context_type(
 593                 stream_class);
 594         event_context_type = bt_ctf_event_class_get_context_type(event_class);
 595         event_payload_type = bt_ctf_event_class_get_payload_type(event_class);
 596         ret = bt_ctf_validate_class_types(environment, packet_header_type,
 597                 packet_context_type, event_header_type, stream_event_ctx_type,
 598                 event_context_type, event_payload_type, trace_valid,
 599                 stream_class->valid, event_class->valid,
 600                 &validation_output, validation_flags);
 601         BT_PUT(packet_header_type);
 602         BT_PUT(packet_context_type);
 603         BT_PUT(event_header_type);
 604         BT_PUT(stream_event_ctx_type);
 605         BT_PUT(event_context_type);
 606         BT_PUT(event_payload_type);
 607
 608         if (ret) {
 609                 /*
 610                  * This means something went wrong during the validation
 611                  * process, not that the objects are invalid.
 612                  */
 613                 goto error;
 614         }
 615
 616         if ((validation_output.valid_flags & validation_flags) !=
 617                         validation_flags) {
 618                 /* Invalid trace/stream class/event class */
 619                 goto error;
 620         }
 621
 622         /*
 623          * At this point we know the trace (if associated to the stream
 624          * class), the stream class, and the event class, with their
 625          * current types, are valid. We may proceed with creating
 626          * the event.
 627          */
 628         event = g_new0(struct bt_ctf_event, 1);
 629         if (!event) {
 630                 goto error;
 631         }
 632
 633         bt_object_init(event, bt_ctf_event_destroy);
 634
 635         /*
 636          * event does not share a common ancestor with the event class; it has
 637          * to guarantee its existence by holding a reference. This reference
 638          * shall be released once the event is associated to a stream since,
 639          * from that point, the event and its class will share the same
 640          * lifetime.
 641          */
 642         event->event_class = bt_get(event_class);
 643         event_header =
 644                 bt_ctf_field_create(validation_output.event_header_type);
 645
 646         if (!event_header) {
 647                 goto error;
 648         }
 649
 650         if (validation_output.event_context_type) {
 651                 event_context = bt_ctf_field_create(
 652                         validation_output.event_context_type);
 653                 if (!event_context) {
 654                         goto error;
 655                 }
 656         }
 657
 658         if (validation_output.event_payload_type) {
 659                 event_payload = bt_ctf_field_create(
 660                         validation_output.event_payload_type);
 661                 if (!event_payload) {
 662                         goto error;
 663                 }
 664         }
 665
 666         /*
 667          * At this point all the fields are created, potentially from
 668          * validated copies of field types, so that the field types and
 669          * fields can be replaced in the trace, stream class,
 670          * event class, and created event.
 671          */
 672         bt_ctf_validation_replace_types(trace, stream_class,
 673                 event_class, &validation_output, validation_flags);
 674         BT_MOVE(event->event_header, event_header);
 675         BT_MOVE(event->context_payload, event_context);
 676         BT_MOVE(event->fields_payload, event_payload);
 677
 678         /*
 679          * Put what was not moved in bt_ctf_validation_replace_types().
 680          */
 681         bt_ctf_validation_output_put_types(&validation_output);
 682
 683         /*
 684          * Freeze the stream class since the event header must not be changed
 685          * anymore.
 686          */
 687         bt_ctf_stream_class_freeze(stream_class);
 688
 689         /*
 690          * Mark stream class, and event class as valid since
 691          * they're all frozen now.
 692          */
 693         stream_class->valid = 1;
 694         event_class->valid = 1;
 695
 696         /* Put stuff we borrowed from the event class */
 697         BT_PUT(stream_class);
 698         BT_PUT(trace);
 699
 700         return event;
 701
 702 error:
 703         bt_ctf_validation_output_put_types(&validation_output);
 704         BT_PUT(event);
 705         BT_PUT(stream_class);
 706         BT_PUT(trace);
 707         BT_PUT(event_header);
 708         BT_PUT(event_context);
 709         BT_PUT(event_payload);
 710         assert(!packet_header_type);
 711         assert(!packet_context_type);
 712         assert(!event_header_type);
 713         assert(!stream_event_ctx_type);
 714         assert(!event_context_type);
 715         assert(!event_payload_type);
 716
 717         return event;
 718 }
 719
 720 struct bt_ctf_event_class *bt_ctf_event_get_class(struct bt_ctf_event *event)
 721 {
 722         struct bt_ctf_event_class *event_class = NULL;
 723
 724         if (!event) {
 725                 goto end;
 726         }
 727
 728         event_class = event->event_class;
 729         bt_get(event_class);
 730 end:
 731         return event_class;
 732 }
 733
 734 struct bt_ctf_stream *bt_ctf_event_get_stream(struct bt_ctf_event *event)
 735 {
 736         return (struct bt_ctf_stream *) bt_object_get_parent(event);
 737 }
 738
 739 struct bt_ctf_clock *bt_ctf_event_get_clock(struct bt_ctf_event *event)
 740 {
 741         struct bt_ctf_clock *clock = NULL;
 742         struct bt_ctf_event_class *event_class;
 743         struct bt_ctf_stream_class *stream_class;
 744
 745         if (!event) {
 746                 goto end;
 747         }
 748
 749         event_class = bt_ctf_event_get_class(event);
 750         if (!event_class) {
 751                 goto end;
 752         }
 753
 754         stream_class = bt_ctf_event_class_get_stream_class(event_class);
 755         if (!stream_class) {
 756                 goto error_put_event_class;
 757         }
 758
 759         clock = bt_ctf_stream_class_get_clock(stream_class);
 760         if (!clock) {
 761                 goto error_put_stream_class;
 762         }
 763
 764 error_put_stream_class:
 765         bt_put(stream_class);
 766 error_put_event_class:
 767         bt_put(event_class);
 768 end:
 769         return clock;
 770 }
 771
 772 int bt_ctf_event_set_payload(struct bt_ctf_event *event,
 773                 const char *name,
 774                 struct bt_ctf_field *payload)
 775 {
 776         int ret = 0;
 777
 778         if (!event || !payload) {
 779                 ret = -1;
 780                 goto end;
 781         }
 782
 783         if (name) {
 784                 ret = bt_ctf_field_structure_set_field(event->fields_payload,
 785                         name, payload);
 786         } else {
 787                 struct bt_ctf_field_type *payload_type;
 788
 789                 payload_type = bt_ctf_field_get_type(payload);
 790
 791                 if (bt_ctf_field_type_compare(payload_type,
 792                                 event->event_class->fields) == 0) {
 793                         bt_put(event->fields_payload);
 794                         bt_get(payload);
 795                         event->fields_payload = payload;
 796                 } else {
 797                         ret = -1;
 798                 }
 799
 800                 bt_put(payload_type);
 801         }
 802 end:
 803         return ret;
 804 }
 805
 806 struct bt_ctf_field *bt_ctf_event_get_payload_field(struct bt_ctf_event *event)
 807 {
 808         struct bt_ctf_field *payload = NULL;
 809
 810         if (!event || !event->fields_payload) {
 811                 goto end;
 812         }
 813
 814         payload = event->fields_payload;
 815         bt_get(payload);
 816 end:
 817         return payload;
 818 }
 819
 820 int bt_ctf_event_set_payload_field(struct bt_ctf_event *event,
 821                 struct bt_ctf_field *payload)
 822 {
 823         int ret = 0;
 824         struct bt_ctf_field_type *payload_type = NULL;
 825
 826         if (!event || !payload) {
 827                 ret = -1;
 828                 goto end;
 829         }
 830
 831         payload_type = bt_ctf_field_get_type(payload);
 832         if (!payload_type) {
 833                 ret = -1;
 834                 goto end;
 835         }
 836
 837         if (bt_ctf_field_type_get_type_id(payload_type) != CTF_TYPE_STRUCT) {
 838                 ret = -1;
 839                 goto end;
 840         }
 841
 842         bt_get(payload);
 843         bt_put(event->fields_payload);
 844         event->fields_payload = payload;
 845
 846 end:
 847         bt_put(payload_type);
 848         return ret;
 849 }
 850
 851 struct bt_ctf_field *bt_ctf_event_get_payload(struct bt_ctf_event *event,
 852                 const char *name)
 853 {
 854         struct bt_ctf_field *field = NULL;
 855
 856         if (!event) {
 857                 goto end;
 858         }
 859
 860         if (name) {
 861                 field = bt_ctf_field_structure_get_field(event->fields_payload,
 862                         name);
 863         } else {
 864                 field = event->fields_payload;
 865                 bt_get(field);
 866         }
 867 end:
 868         return field;
 869 }
 870
 871 struct bt_ctf_field *bt_ctf_event_get_payload_by_index(
 872                 struct bt_ctf_event *event, int index)
 873 {
 874         struct bt_ctf_field *field = NULL;
 875
 876         if (!event || index < 0) {
 877                 goto end;
 878         }
 879
 880         field = bt_ctf_field_structure_get_field_by_index(event->fields_payload,
 881                 index);
 882 end:
 883         return field;
 884 }
 885
 886 struct bt_ctf_field *bt_ctf_event_get_header(
 887                 struct bt_ctf_event *event)
 888 {
 889         struct bt_ctf_field *header = NULL;
 890
 891         if (!event || !event->event_header) {
 892                 goto end;
 893         }
 894
 895         header = event->event_header;
 896         bt_get(header);
 897 end:
 898         return header;
 899 }
 900
 901 int bt_ctf_event_set_header(struct bt_ctf_event *event,
 902                 struct bt_ctf_field *header)
 903 {
 904         int ret = 0;
 905         struct bt_ctf_field_type *field_type = NULL;
 906         struct bt_ctf_stream_class *stream_class = NULL;
 907
 908         if (!event || !header) {
 909                 ret = -1;
 910                 goto end;
 911         }
 912
 913         stream_class = (struct bt_ctf_stream_class *) bt_object_get_parent(
 914                 event->event_class);
 915         /*
 916          * Ensure the provided header's type matches the one registered to the
 917          * stream class.
 918          */
 919         field_type = bt_ctf_field_get_type(header);
 920         if (bt_ctf_field_type_compare(field_type,
 921                         stream_class->event_header_type)) {
 922                 ret = -1;
 923                 goto end;
 924         }
 925
 926         bt_get(header);
 927         bt_put(event->event_header);
 928         event->event_header = header;
 929 end:
 930         bt_put(stream_class);
 931         bt_put(field_type);
 932         return ret;
 933 }
 934
 935 struct bt_ctf_field *bt_ctf_event_get_event_context(
 936                 struct bt_ctf_event *event)
 937 {
 938         struct bt_ctf_field *context = NULL;
 939
 940         if (!event || !event->context_payload) {
 941                 goto end;
 942         }
 943
 944         context = event->context_payload;
 945         bt_get(context);
 946 end:
 947         return context;
 948 }
 949
 950 int bt_ctf_event_set_event_context(struct bt_ctf_event *event,
 951                 struct bt_ctf_field *context)
 952 {
 953         int ret = 0;
 954         struct bt_ctf_field_type *field_type = NULL;
 955
 956         if (!event || !context) {
 957                 ret = -1;
 958                 goto end;
 959         }
 960
 961         field_type = bt_ctf_field_get_type(context);
 962         if (bt_ctf_field_type_compare(field_type,
 963                         event->event_class->context)) {
 964                 ret = -1;
 965                 goto end;
 966         }
 967
 968         bt_get(context);
 969         bt_put(event->context_payload);
 970         event->context_payload = context;
 971 end:
 972         bt_put(field_type);
 973         return ret;
 974 }
 975
 976 void bt_ctf_event_get(struct bt_ctf_event *event)
 977 {
 978         bt_get(event);
 979 }
 980
 981 void bt_ctf_event_put(struct bt_ctf_event *event)
 982 {
 983         bt_put(event);
 984 }
 985
 986 static
 987 void bt_ctf_event_class_destroy(struct bt_object *obj)
 988 {
 989         struct bt_ctf_event_class *event_class;
 990
 991         event_class = container_of(obj, struct bt_ctf_event_class, base);
 992         bt_ctf_attributes_destroy(event_class->attributes);
 993         bt_put(event_class->context);
 994         bt_put(event_class->fields);
 995         g_free(event_class);
 996 }
 997
 998 static
 999 void bt_ctf_event_destroy(struct bt_object *obj)
1000 {
1001         struct bt_ctf_event *event;
1002
1003         event = container_of(obj, struct bt_ctf_event, base);
1004         if (!event->base.parent) {
1005                 /*
1006                  * Event was keeping a reference to its class since it shared no
1007                  * common ancestor with it to guarantee they would both have the
1008                  * same lifetime.
1009                  */
1010                 bt_put(event->event_class);
1011         }
1012         bt_put(event->event_header);
1013         bt_put(event->context_payload);
1014         bt_put(event->fields_payload);
1015         g_free(event);
1016 }
1017
1018 static
1019 int set_integer_field_value(struct bt_ctf_field* field, uint64_t value)
1020 {
1021         int ret = 0;
1022         struct bt_ctf_field_type *field_type = NULL;
1023
1024         if (!field) {
1025                 ret = -1;
1026                 goto end;
1027         }
1028
1029         if (!bt_ctf_field_validate(field)) {
1030                 /* Payload already set, skip! (not an error) */
1031                 goto end;
1032         }
1033
1034         field_type = bt_ctf_field_get_type(field);
1035         assert(field_type);
1036
1037         if (bt_ctf_field_type_get_type_id(field_type) != CTF_TYPE_INTEGER) {
1038                 /* Not an integer and the value is unset, error. */
1039                 ret = -1;
1040                 goto end;
1041         }
1042
1043         if (bt_ctf_field_type_integer_get_signed(field_type)) {
1044                 ret = bt_ctf_field_signed_integer_set_value(field, (int64_t) value);
1045                 if (ret) {
1046                         /* Value is out of range, error. */
1047                         goto end;
1048                 }
1049         } else {
1050                 ret = bt_ctf_field_unsigned_integer_set_value(field, value);
1051                 if (ret) {
1052                         /* Value is out of range, error. */
1053                         goto end;
1054                 }
1055         }
1056 end:
1057         bt_put(field_type);
1058         return ret;
1059 }
1060
1061 BT_HIDDEN
1062 void bt_ctf_event_class_freeze(struct bt_ctf_event_class *event_class)
1063 {
1064         assert(event_class);
1065         event_class->frozen = 1;
1066         bt_ctf_field_type_freeze(event_class->context);
1067         bt_ctf_field_type_freeze(event_class->fields);
1068         bt_ctf_attributes_freeze(event_class->attributes);
1069 }
1070
1071 BT_HIDDEN
1072 int bt_ctf_event_class_serialize(struct bt_ctf_event_class *event_class,
1073                 struct metadata_context *context)
1074 {
1075         int i;
1076         int count;
1077         int ret = 0;
1078         struct bt_value *attr_value = NULL;
1079
1080         assert(event_class);
1081         assert(context);
1082
1083         context->current_indentation_level = 1;
1084         g_string_assign(context->field_name, "");
1085         g_string_append(context->string, "event {\n");
1086         count = bt_ctf_event_class_get_attribute_count(event_class);
1087
1088         if (count < 0) {
1089                 ret = -1;
1090                 goto end;
1091         }
1092
1093         for (i = 0; i < count; ++i) {
1094                 const char *attr_name = NULL;
1095
1096                 attr_name = bt_ctf_event_class_get_attribute_name(
1097                         event_class, i);
1098                 attr_value = bt_ctf_event_class_get_attribute_value(
1099                         event_class, i);
1100
1101                 if (!attr_name || !attr_value) {
1102                         ret = -1;
1103                         goto end;
1104                 }
1105
1106                 switch (bt_value_get_type(attr_value)) {
1107                 case BT_VALUE_TYPE_INTEGER:
1108                 {
1109                         int64_t value;
1110
1111                         ret = bt_value_integer_get(attr_value, &value);
1112
1113                         if (ret) {
1114                                 goto end;
1115                         }
1116
1117                         g_string_append_printf(context->string,
1118                                 "\t%s = %" PRId64 ";\n", attr_name, value);
1119                         break;
1120                 }
1121
1122                 case BT_VALUE_TYPE_STRING:
1123                 {
1124                         const char *value;
1125
1126                         ret = bt_value_string_get(attr_value, &value);
1127
1128                         if (ret) {
1129                                 goto end;
1130                         }
1131
1132                         g_string_append_printf(context->string,
1133                                 "\t%s = \"%s\";\n", attr_name, value);
1134                         break;
1135                 }
1136
1137                 default:
1138                         /* should never happen */
1139                         assert(false);
1140                         break;
1141                 }
1142
1143                 BT_PUT(attr_value);
1144         }
1145
1146         if (event_class->context) {
1147                 g_string_append(context->string, "\tcontext := ");
1148                 ret = bt_ctf_field_type_serialize(event_class->context,
1149                         context);
1150                 if (ret) {
1151                         goto end;
1152                 }
1153                 g_string_append(context->string, ";\n");
1154         }
1155
1156         if (event_class->fields) {
1157                 g_string_append(context->string, "\tfields := ");
1158                 ret = bt_ctf_field_type_serialize(event_class->fields, context);
1159                 if (ret) {
1160                         goto end;
1161                 }
1162                 g_string_append(context->string, ";\n");
1163         }
1164
1165         g_string_append(context->string, "};\n\n");
1166 end:
1167         context->current_indentation_level = 0;
1168         BT_PUT(attr_value);
1169         return ret;
1170 }
1171
1172 void bt_ctf_event_class_set_native_byte_order(
1173                 struct bt_ctf_event_class *event_class,
1174                 int byte_order)
1175 {
1176         if (!event_class) {
1177                 return;
1178         }
1179
1180         assert(byte_order == 0 || byte_order == LITTLE_ENDIAN ||
1181                 byte_order == BIG_ENDIAN);
1182
1183         bt_ctf_field_type_set_native_byte_order(event_class->context,
1184                 byte_order);
1185         bt_ctf_field_type_set_native_byte_order(event_class->fields,
1186                 byte_order);
1187 }
1188
1189 BT_HIDDEN
1190 int bt_ctf_event_validate(struct bt_ctf_event *event)
1191 {
1192         /* Make sure each field's payload has been set */
1193         int ret;
1194
1195         assert(event);
1196         ret = bt_ctf_field_validate(event->event_header);
1197         if (ret) {
1198                 goto end;
1199         }
1200
1201         ret = bt_ctf_field_validate(event->fields_payload);
1202         if (ret) {
1203                 goto end;
1204         }
1205
1206         if (event->event_class->context) {
1207                 ret = bt_ctf_field_validate(event->context_payload);
1208         }
1209 end:
1210         return ret;
1211 }
1212
1213 BT_HIDDEN
1214 int bt_ctf_event_serialize(struct bt_ctf_event *event,
1215                 struct ctf_stream_pos *pos)
1216 {
1217         int ret = 0;
1218
1219         assert(event);
1220         assert(pos);
1221         if (event->context_payload) {
1222                 ret = bt_ctf_field_serialize(event->context_payload, pos);
1223                 if (ret) {
1224                         goto end;
1225                 }
1226         }
1227
1228         if (event->fields_payload) {
1229                 ret = bt_ctf_field_serialize(event->fields_payload, pos);
1230                 if (ret) {
1231                         goto end;
1232                 }
1233         }
1234 end:
1235         return ret;
1236 }
1237
1238 BT_HIDDEN
1239 int bt_ctf_event_populate_event_header(struct bt_ctf_event *event)
1240 {
1241         int ret = 0;
1242         struct bt_ctf_field *id_field = NULL, *timestamp_field = NULL;
1243
1244         if (!event) {
1245                 ret = -1;
1246                 goto end;
1247         }
1248
1249         id_field = bt_ctf_field_structure_get_field(event->event_header, "id");
1250         if (id_field) {
1251                 ret = set_integer_field_value(id_field,
1252                         (uint64_t) bt_ctf_event_class_get_id(
1253                                 event->event_class));
1254                 if (ret) {
1255                         goto end;
1256                 }
1257         }
1258
1259         timestamp_field = bt_ctf_field_structure_get_field(event->event_header,
1260                 "timestamp");
1261         if (timestamp_field) {
1262                 struct bt_ctf_field_type *timestamp_field_type =
1263                         bt_ctf_field_get_type(timestamp_field);
1264                 struct bt_ctf_clock *mapped_clock;
1265
1266                 assert(timestamp_field_type);
1267                 mapped_clock = bt_ctf_field_type_integer_get_mapped_clock(
1268                         timestamp_field_type);
1269                 bt_put(timestamp_field_type);
1270                 if (mapped_clock) {
1271                         int64_t timestamp;
1272
1273                         ret = bt_ctf_clock_get_time(mapped_clock, &timestamp);
1274                         bt_put(mapped_clock);
1275                         if (ret) {
1276                                 goto end;
1277                         }
1278
1279                         ret = set_integer_field_value(timestamp_field,
1280                                 timestamp);
1281                         if (ret) {
1282                                 goto end;
1283                         }
1284                 }
1285         }
1286 end:
1287         bt_put(id_field);
1288         bt_put(timestamp_field);
1289         return ret;
1290 }
1291
1292 struct bt_ctf_event *bt_ctf_event_copy(struct bt_ctf_event *event)
1293 {
1294         struct bt_ctf_event *copy = NULL;
1295
1296         if (!event) {
1297                 goto error;
1298         }
1299
1300         copy = g_new0(struct bt_ctf_event, 1);
1301         if (!copy) {
1302                 goto error;
1303         }
1304
1305         bt_object_init(copy, bt_ctf_event_destroy);
1306         copy->event_class = bt_get(event->event_class);
1307
1308         if (event->event_header) {
1309                 copy->event_header = bt_ctf_field_copy(event->event_header);
1310
1311                 if (!copy->event_header) {
1312                         goto error;
1313                 }
1314         }
1315
1316         if (event->context_payload) {
1317                 copy->context_payload = bt_ctf_field_copy(
1318                         event->context_payload);
1319
1320                 if (!copy->context_payload) {
1321                         goto error;
1322                 }
1323         }
1324
1325         if (event->fields_payload) {
1326                 copy->fields_payload = bt_ctf_field_copy(event->fields_payload);
1327
1328                 if (!copy->fields_payload) {
1329                         goto error;
1330                 }
1331         }
1332
1333         return copy;
1334
1335 error:
1336         BT_PUT(copy);
1337         return copy;
1338 }