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-ir/fields-internal.h>
  30 #include <babeltrace/ctf-ir/field-types-internal.h>
  31 #include <babeltrace/ctf-ir/event-internal.h>
  32 #include <babeltrace/ctf-ir/event-class.h>
  33 #include <babeltrace/ctf-ir/event-class-internal.h>
  34 #include <babeltrace/ctf-ir/stream-class.h>
  35 #include <babeltrace/ctf-ir/stream-class-internal.h>
  36 #include <babeltrace/ctf-ir/stream-internal.h>
  37 #include <babeltrace/ctf-ir/packet.h>
  38 #include <babeltrace/ctf-ir/packet-internal.h>
  39 #include <babeltrace/ctf-ir/trace-internal.h>
  40 #include <babeltrace/ctf-ir/validation-internal.h>
  41 #include <babeltrace/ctf-ir/packet-internal.h>
  42 #include <babeltrace/ctf-ir/utils.h>
  43 #include <babeltrace/ref.h>
  44 #include <babeltrace/ctf-ir/attributes-internal.h>
  45 #include <babeltrace/compiler.h>
  46
  47 static
  48 void bt_ctf_event_destroy(struct bt_object *obj);
  49 static
  50 int set_integer_field_value(struct bt_ctf_field *field, uint64_t value);
  51
  52 struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class)
  53 {
  54         int ret;
  55         enum bt_ctf_validation_flag validation_flags =
  56                 BT_CTF_VALIDATION_FLAG_STREAM |
  57                 BT_CTF_VALIDATION_FLAG_EVENT;
  58         struct bt_ctf_event *event = NULL;
  59         struct bt_ctf_trace *trace = NULL;
  60         struct bt_ctf_stream_class *stream_class = NULL;
  61         struct bt_ctf_field_type *packet_header_type = NULL;
  62         struct bt_ctf_field_type *packet_context_type = NULL;
  63         struct bt_ctf_field_type *event_header_type = NULL;
  64         struct bt_ctf_field_type *stream_event_ctx_type = NULL;
  65         struct bt_ctf_field_type *event_context_type = NULL;
  66         struct bt_ctf_field_type *event_payload_type = NULL;
  67         struct bt_ctf_field *event_header = NULL;
  68         struct bt_ctf_field *stream_event_context = NULL;
  69         struct bt_ctf_field *event_context = NULL;
  70         struct bt_ctf_field *event_payload = NULL;
  71         struct bt_value *environment = NULL;
  72         struct bt_ctf_validation_output validation_output = { 0 };
  73         int trace_valid = 0;
  74
  75         if (!event_class) {
  76                 goto error;
  77         }
  78
  79         stream_class = bt_ctf_event_class_get_stream_class(event_class);
  80
  81         /*
  82          * We disallow the creation of an event if its event class has not been
  83          * associated to a stream class.
  84          */
  85         if (!stream_class) {
  86                 goto error;
  87         }
  88
  89         /* A stream class should always have an existing event header type */
  90         assert(stream_class->event_header_type);
  91
  92         /* The event class was frozen when added to its stream class */
  93         assert(event_class->frozen);
  94
  95         /* Validate the trace (if any), the stream class, and the event class */
  96         trace = bt_ctf_stream_class_get_trace(stream_class);
  97         if (trace) {
  98                 packet_header_type = bt_ctf_trace_get_packet_header_type(trace);
  99                 trace_valid = trace->valid;
 100                 assert(trace_valid);
 101                 environment = trace->environment;
 102         }
 103
 104         packet_context_type = bt_ctf_stream_class_get_packet_context_type(
 105                 stream_class);
 106         event_header_type = bt_ctf_stream_class_get_event_header_type(
 107                 stream_class);
 108         stream_event_ctx_type = bt_ctf_stream_class_get_event_context_type(
 109                 stream_class);
 110         event_context_type = bt_ctf_event_class_get_context_type(event_class);
 111         event_payload_type = bt_ctf_event_class_get_payload_type(event_class);
 112         ret = bt_ctf_validate_class_types(environment, packet_header_type,
 113                 packet_context_type, event_header_type, stream_event_ctx_type,
 114                 event_context_type, event_payload_type, trace_valid,
 115                 stream_class->valid, event_class->valid,
 116                 &validation_output, validation_flags);
 117         BT_PUT(packet_header_type);
 118         BT_PUT(packet_context_type);
 119         BT_PUT(event_header_type);
 120         BT_PUT(stream_event_ctx_type);
 121         BT_PUT(event_context_type);
 122         BT_PUT(event_payload_type);
 123         if (ret) {
 124                 /*
 125                  * This means something went wrong during the validation
 126                  * process, not that the objects are invalid.
 127                  */
 128                 goto error;
 129         }
 130
 131         if ((validation_output.valid_flags & validation_flags) !=
 132                         validation_flags) {
 133                 /* Invalid trace/stream class/event class */
 134                 goto error;
 135         }
 136
 137         /*
 138          * At this point we know the trace (if associated to the stream
 139          * class), the stream class, and the event class, with their
 140          * current types, are valid. We may proceed with creating
 141          * the event.
 142          */
 143         event = g_new0(struct bt_ctf_event, 1);
 144         if (!event) {
 145                 goto error;
 146         }
 147
 148         bt_object_init(event, bt_ctf_event_destroy);
 149
 150         /*
 151          * event does not share a common ancestor with the event class; it has
 152          * to guarantee its existence by holding a reference. This reference
 153          * shall be released once the event is associated to a stream since,
 154          * from that point, the event and its class will share the same
 155          * lifetime.
 156          */
 157         event->event_class = bt_get(event_class);
 158         event->clock_values = g_hash_table_new_full(g_direct_hash,
 159                 g_direct_equal, NULL, g_free);
 160         event_header =
 161                 bt_ctf_field_create(validation_output.event_header_type);
 162         if (!event_header) {
 163                 goto error;
 164         }
 165
 166         if (validation_output.stream_event_ctx_type) {
 167                 stream_event_context = bt_ctf_field_create(
 168                         validation_output.stream_event_ctx_type);
 169                 if (!stream_event_context) {
 170                         goto error;
 171                 }
 172         }
 173
 174         if (validation_output.event_context_type) {
 175                 event_context = bt_ctf_field_create(
 176                         validation_output.event_context_type);
 177                 if (!event_context) {
 178                         goto error;
 179                 }
 180         }
 181
 182         if (validation_output.event_payload_type) {
 183                 event_payload = bt_ctf_field_create(
 184                         validation_output.event_payload_type);
 185                 if (!event_payload) {
 186                         goto error;
 187                 }
 188         }
 189
 190         /*
 191          * At this point all the fields are created, potentially from
 192          * validated copies of field types, so that the field types and
 193          * fields can be replaced in the trace, stream class,
 194          * event class, and created event.
 195          */
 196         bt_ctf_validation_replace_types(trace, stream_class,
 197                 event_class, &validation_output, validation_flags);
 198         BT_MOVE(event->event_header, event_header);
 199         BT_MOVE(event->stream_event_context, stream_event_context);
 200         BT_MOVE(event->context_payload, event_context);
 201         BT_MOVE(event->fields_payload, event_payload);
 202
 203         /*
 204          * Put what was not moved in bt_ctf_validation_replace_types().
 205          */
 206         bt_ctf_validation_output_put_types(&validation_output);
 207
 208         /*
 209          * Freeze the stream class since the event header must not be changed
 210          * anymore.
 211          */
 212         bt_ctf_stream_class_freeze(stream_class);
 213
 214         /*
 215          * Mark stream class, and event class as valid since
 216          * they're all frozen now.
 217          */
 218         stream_class->valid = 1;
 219         event_class->valid = 1;
 220
 221         /* Put stuff we borrowed from the event class */
 222         BT_PUT(stream_class);
 223         BT_PUT(trace);
 224
 225         return event;
 226
 227 error:
 228         bt_ctf_validation_output_put_types(&validation_output);
 229         BT_PUT(event);
 230         BT_PUT(stream_class);
 231         BT_PUT(trace);
 232         BT_PUT(event_header);
 233         BT_PUT(stream_event_context);
 234         BT_PUT(event_context);
 235         BT_PUT(event_payload);
 236         assert(!packet_header_type);
 237         assert(!packet_context_type);
 238         assert(!event_header_type);
 239         assert(!stream_event_ctx_type);
 240         assert(!event_context_type);
 241         assert(!event_payload_type);
 242
 243         return event;
 244 }
 245
 246 struct bt_ctf_event_class *bt_ctf_event_get_class(struct bt_ctf_event *event)
 247 {
 248         struct bt_ctf_event_class *event_class = NULL;
 249
 250         if (!event) {
 251                 goto end;
 252         }
 253
 254         event_class = event->event_class;
 255         bt_get(event_class);
 256 end:
 257         return event_class;
 258 }
 259
 260 struct bt_ctf_stream *bt_ctf_event_get_stream(struct bt_ctf_event *event)
 261 {
 262         struct bt_ctf_stream *stream = NULL;
 263
 264         if (!event) {
 265                 goto end;
 266         }
 267
 268         /*
 269          * If the event has a parent, then this is its (writer) stream.
 270          * If the event has no parent, then if it has a packet, this
 271          * is its (non-writer) stream.
 272          */
 273         if (event->base.parent) {
 274                 stream = (struct bt_ctf_stream *) bt_object_get_parent(event);
 275         } else {
 276                 if (event->packet) {
 277                         stream = bt_get(event->packet->stream);
 278                 }
 279         }
 280
 281 end:
 282         return stream;
 283 }
 284
 285 struct bt_ctf_clock *bt_ctf_event_get_clock(struct bt_ctf_event *event)
 286 {
 287         struct bt_ctf_clock *clock = NULL;
 288         struct bt_ctf_event_class *event_class;
 289         struct bt_ctf_stream_class *stream_class;
 290
 291         if (!event) {
 292                 goto end;
 293         }
 294
 295         event_class = bt_ctf_event_get_class(event);
 296         if (!event_class) {
 297                 goto end;
 298         }
 299
 300         stream_class = bt_ctf_event_class_get_stream_class(event_class);
 301         if (!stream_class) {
 302                 goto error_put_event_class;
 303         }
 304
 305         clock = bt_ctf_stream_class_get_clock(stream_class);
 306         if (!clock) {
 307                 goto error_put_stream_class;
 308         }
 309
 310 error_put_stream_class:
 311         bt_put(stream_class);
 312 error_put_event_class:
 313         bt_put(event_class);
 314 end:
 315         return clock;
 316 }
 317
 318 int bt_ctf_event_set_payload(struct bt_ctf_event *event,
 319                 const char *name,
 320                 struct bt_ctf_field *payload)
 321 {
 322         int ret = 0;
 323
 324         if (!event || !payload || event->frozen) {
 325                 ret = -1;
 326                 goto end;
 327         }
 328
 329         if (name) {
 330                 ret = bt_ctf_field_structure_set_field(event->fields_payload,
 331                         name, payload);
 332         } else {
 333                 struct bt_ctf_field_type *payload_type;
 334
 335                 payload_type = bt_ctf_field_get_type(payload);
 336
 337                 if (bt_ctf_field_type_compare(payload_type,
 338                                 event->event_class->fields) == 0) {
 339                         bt_put(event->fields_payload);
 340                         bt_get(payload);
 341                         event->fields_payload = payload;
 342                 } else {
 343                         ret = -1;
 344                 }
 345
 346                 bt_put(payload_type);
 347         }
 348 end:
 349         return ret;
 350 }
 351
 352 struct bt_ctf_field *bt_ctf_event_get_payload_field(struct bt_ctf_event *event)
 353 {
 354         struct bt_ctf_field *payload = NULL;
 355
 356         if (!event || !event->fields_payload) {
 357                 goto end;
 358         }
 359
 360         payload = event->fields_payload;
 361         bt_get(payload);
 362 end:
 363         return payload;
 364 }
 365
 366 int bt_ctf_event_set_payload_field(struct bt_ctf_event *event,
 367                 struct bt_ctf_field *payload)
 368 {
 369         int ret = 0;
 370         struct bt_ctf_field_type *payload_type = NULL;
 371
 372         if (!event || !payload || event->frozen) {
 373                 ret = -1;
 374                 goto end;
 375         }
 376
 377         payload_type = bt_ctf_field_get_type(payload);
 378         if (!payload_type) {
 379                 ret = -1;
 380                 goto end;
 381         }
 382
 383         if (bt_ctf_field_type_get_type_id(payload_type) !=
 384                         BT_CTF_TYPE_ID_STRUCT) {
 385                 ret = -1;
 386                 goto end;
 387         }
 388
 389         bt_get(payload);
 390         bt_put(event->fields_payload);
 391         event->fields_payload = payload;
 392
 393 end:
 394         bt_put(payload_type);
 395         return ret;
 396 }
 397
 398 struct bt_ctf_field *bt_ctf_event_get_payload(struct bt_ctf_event *event,
 399                 const char *name)
 400 {
 401         struct bt_ctf_field *field = NULL;
 402
 403         if (!event) {
 404                 goto end;
 405         }
 406
 407         if (name) {
 408                 field = bt_ctf_field_structure_get_field(event->fields_payload,
 409                         name);
 410         } else {
 411                 field = event->fields_payload;
 412                 bt_get(field);
 413         }
 414 end:
 415         return field;
 416 }
 417
 418 struct bt_ctf_field *bt_ctf_event_get_payload_by_index(
 419                 struct bt_ctf_event *event, int index)
 420 {
 421         struct bt_ctf_field *field = NULL;
 422
 423         if (!event || index < 0) {
 424                 goto end;
 425         }
 426
 427         field = bt_ctf_field_structure_get_field_by_index(event->fields_payload,
 428                 index);
 429 end:
 430         return field;
 431 }
 432
 433 struct bt_ctf_field *bt_ctf_event_get_header(
 434                 struct bt_ctf_event *event)
 435 {
 436         struct bt_ctf_field *header = NULL;
 437
 438         if (!event || !event->event_header) {
 439                 goto end;
 440         }
 441
 442         header = event->event_header;
 443         bt_get(header);
 444 end:
 445         return header;
 446 }
 447
 448 int bt_ctf_event_set_header(struct bt_ctf_event *event,
 449                 struct bt_ctf_field *header)
 450 {
 451         int ret = 0;
 452         struct bt_ctf_field_type *field_type = NULL;
 453         struct bt_ctf_stream_class *stream_class = NULL;
 454
 455         if (!event || !header || event->frozen) {
 456                 ret = -1;
 457                 goto end;
 458         }
 459
 460         stream_class = (struct bt_ctf_stream_class *) bt_object_get_parent(
 461                 event->event_class);
 462         /*
 463          * Ensure the provided header's type matches the one registered to the
 464          * stream class.
 465          */
 466         field_type = bt_ctf_field_get_type(header);
 467         if (bt_ctf_field_type_compare(field_type,
 468                         stream_class->event_header_type)) {
 469                 ret = -1;
 470                 goto end;
 471         }
 472
 473         bt_get(header);
 474         bt_put(event->event_header);
 475         event->event_header = header;
 476 end:
 477         bt_put(stream_class);
 478         bt_put(field_type);
 479         return ret;
 480 }
 481
 482 struct bt_ctf_field *bt_ctf_event_get_event_context(
 483                 struct bt_ctf_event *event)
 484 {
 485         struct bt_ctf_field *context = NULL;
 486
 487         if (!event || !event->context_payload) {
 488                 goto end;
 489         }
 490
 491         context = event->context_payload;
 492         bt_get(context);
 493 end:
 494         return context;
 495 }
 496
 497 int bt_ctf_event_set_event_context(struct bt_ctf_event *event,
 498                 struct bt_ctf_field *context)
 499 {
 500         int ret = 0;
 501         struct bt_ctf_field_type *field_type = NULL;
 502
 503         if (!event || !context || event->frozen) {
 504                 ret = -1;
 505                 goto end;
 506         }
 507
 508         field_type = bt_ctf_field_get_type(context);
 509         if (bt_ctf_field_type_compare(field_type,
 510                         event->event_class->context)) {
 511                 ret = -1;
 512                 goto end;
 513         }
 514
 515         bt_get(context);
 516         bt_put(event->context_payload);
 517         event->context_payload = context;
 518 end:
 519         bt_put(field_type);
 520         return ret;
 521 }
 522
 523 struct bt_ctf_field *bt_ctf_event_get_stream_event_context(
 524                 struct bt_ctf_event *event)
 525 {
 526         struct bt_ctf_field *stream_event_context = NULL;
 527
 528         if (!event || !event->stream_event_context) {
 529                 goto end;
 530         }
 531
 532         stream_event_context = event->stream_event_context;
 533 end:
 534         return bt_get(stream_event_context);
 535 }
 536
 537 int bt_ctf_event_set_stream_event_context(struct bt_ctf_event *event,
 538                 struct bt_ctf_field *stream_event_context)
 539 {
 540         int ret = 0;
 541         struct bt_ctf_field_type *field_type = NULL;
 542         struct bt_ctf_stream_class *stream_class = NULL;
 543
 544         if (!event || !stream_event_context || event->frozen) {
 545                 ret = -1;
 546                 goto end;
 547         }
 548
 549         stream_class = bt_ctf_event_class_get_stream_class(event->event_class);
 550         /*
 551          * We should not have been able to create the event without associating
 552          * the event class to a stream class.
 553          */
 554         assert(stream_class);
 555
 556         field_type = bt_ctf_field_get_type(stream_event_context);
 557         if (bt_ctf_field_type_compare(field_type,
 558                         stream_class->event_context_type)) {
 559                 ret = -1;
 560                 goto end;
 561         }
 562
 563         bt_get(stream_event_context);
 564         BT_MOVE(event->stream_event_context, stream_event_context);
 565 end:
 566         BT_PUT(stream_class);
 567         bt_put(field_type);
 568         return ret;
 569 }
 570
 571 void bt_ctf_event_get(struct bt_ctf_event *event)
 572 {
 573         bt_get(event);
 574 }
 575
 576 void bt_ctf_event_put(struct bt_ctf_event *event)
 577 {
 578         bt_put(event);
 579 }
 580
 581 void bt_ctf_event_destroy(struct bt_object *obj)
 582 {
 583         struct bt_ctf_event *event;
 584
 585         event = container_of(obj, struct bt_ctf_event, base);
 586         if (!event->base.parent) {
 587                 /*
 588                  * Event was keeping a reference to its class since it shared no
 589                  * common ancestor with it to guarantee they would both have the
 590                  * same lifetime.
 591                  */
 592                 bt_put(event->event_class);
 593         }
 594         g_hash_table_destroy(event->clock_values);
 595         bt_put(event->event_header);
 596         bt_put(event->stream_event_context);
 597         bt_put(event->context_payload);
 598         bt_put(event->fields_payload);
 599         bt_put(event->packet);
 600         g_free(event);
 601 }
 602
 603 static
 604 int set_integer_field_value(struct bt_ctf_field* field, uint64_t value)
 605 {
 606         int ret = 0;
 607         struct bt_ctf_field_type *field_type = NULL;
 608
 609         if (!field) {
 610                 ret = -1;
 611                 goto end;
 612         }
 613
 614         if (!bt_ctf_field_validate(field)) {
 615                 /* Payload already set, skip! (not an error) */
 616                 goto end;
 617         }
 618
 619         field_type = bt_ctf_field_get_type(field);
 620         assert(field_type);
 621
 622         if (bt_ctf_field_type_get_type_id(field_type) !=
 623                         BT_CTF_TYPE_ID_INTEGER) {
 624                 /* Not an integer and the value is unset, error. */
 625                 ret = -1;
 626                 goto end;
 627         }
 628
 629         if (bt_ctf_field_type_integer_get_signed(field_type)) {
 630                 ret = bt_ctf_field_signed_integer_set_value(field, (int64_t) value);
 631                 if (ret) {
 632                         /* Value is out of range, error. */
 633                         goto end;
 634                 }
 635         } else {
 636                 ret = bt_ctf_field_unsigned_integer_set_value(field, value);
 637                 if (ret) {
 638                         /* Value is out of range, error. */
 639                         goto end;
 640                 }
 641         }
 642 end:
 643         bt_put(field_type);
 644         return ret;
 645 }
 646
 647 BT_HIDDEN
 648 int bt_ctf_event_validate(struct bt_ctf_event *event)
 649 {
 650         /* Make sure each field's payload has been set */
 651         int ret;
 652         struct bt_ctf_stream_class *stream_class = NULL;
 653
 654         assert(event);
 655         ret = bt_ctf_field_validate(event->event_header);
 656         if (ret) {
 657                 goto end;
 658         }
 659
 660         stream_class = bt_ctf_event_class_get_stream_class(event->event_class);
 661         /*
 662          * We should not have been able to create the event without associating
 663          * the event class to a stream class.
 664          */
 665         assert(stream_class);
 666         if (stream_class->event_context_type) {
 667                 ret = bt_ctf_field_validate(event->stream_event_context);
 668                 if (ret) {
 669                         goto end;
 670                 }
 671         }
 672
 673         ret = bt_ctf_field_validate(event->fields_payload);
 674         if (ret) {
 675                 goto end;
 676         }
 677
 678         if (event->event_class->context) {
 679                 ret = bt_ctf_field_validate(event->context_payload);
 680         }
 681 end:
 682         bt_put(stream_class);
 683         return ret;
 684 }
 685
 686 BT_HIDDEN
 687 int bt_ctf_event_serialize(struct bt_ctf_event *event,
 688                 struct ctf_stream_pos *pos)
 689 {
 690         int ret = 0;
 691
 692         assert(event);
 693         assert(pos);
 694         if (event->context_payload) {
 695                 ret = bt_ctf_field_serialize(event->context_payload, pos);
 696                 if (ret) {
 697                         goto end;
 698                 }
 699         }
 700
 701         if (event->fields_payload) {
 702                 ret = bt_ctf_field_serialize(event->fields_payload, pos);
 703                 if (ret) {
 704                         goto end;
 705                 }
 706         }
 707 end:
 708         return ret;
 709 }
 710
 711 BT_HIDDEN
 712 int bt_ctf_event_populate_event_header(struct bt_ctf_event *event)
 713 {
 714         int ret = 0;
 715         struct bt_ctf_field *id_field = NULL, *timestamp_field = NULL;
 716
 717         if (!event || event->frozen) {
 718                 ret = -1;
 719                 goto end;
 720         }
 721
 722         id_field = bt_ctf_field_structure_get_field(event->event_header, "id");
 723         if (id_field) {
 724                 ret = set_integer_field_value(id_field,
 725                         (uint64_t) bt_ctf_event_class_get_id(
 726                                 event->event_class));
 727                 if (ret) {
 728                         goto end;
 729                 }
 730         }
 731
 732         timestamp_field = bt_ctf_field_structure_get_field(event->event_header,
 733                 "timestamp");
 734         if (timestamp_field) {
 735                 struct bt_ctf_field_type *timestamp_field_type =
 736                         bt_ctf_field_get_type(timestamp_field);
 737                 struct bt_ctf_clock *mapped_clock;
 738
 739                 assert(timestamp_field_type);
 740                 mapped_clock = bt_ctf_field_type_integer_get_mapped_clock(
 741                         timestamp_field_type);
 742                 bt_put(timestamp_field_type);
 743                 if (mapped_clock) {
 744                         int64_t timestamp;
 745
 746                         ret = bt_ctf_clock_get_time(mapped_clock, &timestamp);
 747                         bt_put(mapped_clock);
 748                         if (ret) {
 749                                 goto end;
 750                         }
 751
 752                         ret = set_integer_field_value(timestamp_field,
 753                                 timestamp);
 754                         if (ret) {
 755                                 goto end;
 756                         }
 757                 }
 758         }
 759 end:
 760         bt_put(id_field);
 761         bt_put(timestamp_field);
 762         return ret;
 763 }
 764
 765 int bt_ctf_event_set_packet(struct bt_ctf_event *event,
 766                 struct bt_ctf_packet *packet)
 767 {
 768         struct bt_ctf_stream_class *event_stream_class = NULL;
 769         struct bt_ctf_stream_class *packet_stream_class = NULL;
 770         struct bt_ctf_stream *stream = NULL;
 771         int ret = 0;
 772
 773         if (!event || !packet || event->frozen) {
 774                 ret = -1;
 775                 goto end;
 776         }
 777
 778         /*
 779          * Make sure the new packet was created by this event's
 780          * stream, if it is set.
 781          */
 782         stream = bt_ctf_event_get_stream(event);
 783         if (stream) {
 784                 if (packet->stream != stream) {
 785                         ret = -1;
 786                         goto end;
 787                 }
 788         } else {
 789                 event_stream_class =
 790                         bt_ctf_event_class_get_stream_class(event->event_class);
 791                 packet_stream_class =
 792                         bt_ctf_stream_get_class(packet->stream);
 793
 794                 assert(event_stream_class);
 795                 assert(packet_stream_class);
 796
 797                 if (event_stream_class != packet_stream_class) {
 798                         ret = -1;
 799                         goto end;
 800                 }
 801         }
 802
 803         bt_get(packet);
 804         BT_MOVE(event->packet, packet);
 805
 806 end:
 807         BT_PUT(stream);
 808         BT_PUT(event_stream_class);
 809         BT_PUT(packet_stream_class);
 810
 811         return ret;
 812 }
 813
 814 BT_HIDDEN
 815 void bt_ctf_event_freeze(struct bt_ctf_event *event)
 816 {
 817         assert(event);
 818         bt_ctf_packet_freeze(event->packet);
 819         bt_ctf_field_freeze(event->event_header);
 820         bt_ctf_field_freeze(event->stream_event_context);
 821         bt_ctf_field_freeze(event->context_payload);
 822         bt_ctf_field_freeze(event->fields_payload);
 823         event->frozen = 1;
 824 }
 825
 826 static
 827 void insert_stream_clock_value_into_event_clock_values(gpointer key,
 828                 gpointer value,
 829                 gpointer data)
 830 {
 831         struct bt_ctf_event *event = data;
 832         uint64_t *clock_value;
 833
 834         assert(event);
 835
 836         /* Copy clock value because it belongs to the hash table */
 837         clock_value = g_new0(uint64_t, 1);
 838         *clock_value = *((uint64_t *) value);
 839
 840         /* Insert copy into event clock values */
 841         g_hash_table_insert(event->clock_values, key, clock_value);
 842 }
 843
 844 BT_HIDDEN
 845 int bt_ctf_event_register_stream_clock_values(struct bt_ctf_event *event)
 846 {
 847         int ret = 0;
 848         struct bt_ctf_stream *stream;
 849
 850         stream = bt_ctf_event_get_stream(event);
 851         assert(stream);
 852         g_hash_table_remove_all(event->clock_values);
 853         g_hash_table_foreach(stream->clock_values,
 854                 insert_stream_clock_value_into_event_clock_values, event);
 855         BT_PUT(stream);
 856
 857         return ret;
 858 }
 859
 860 uint64_t bt_ctf_event_get_clock_value(struct bt_ctf_event *event,
 861                 struct bt_ctf_clock *clock)
 862 {
 863         uint64_t ret = -1ULL;
 864         uint64_t *clock_value;
 865
 866         if (!event || !clock) {
 867                 goto end;
 868         }
 869
 870         clock_value = g_hash_table_lookup(event->clock_values, clock);
 871         if (!clock_value) {
 872                 goto end;
 873         }
 874
 875         ret = *clock_value;
 876
 877 end:
 878         return ret;
 879 }