lib/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 #define BT_LOG_TAG "EVENT"
  30 #include <babeltrace/lib-logging-internal.h>
  31
  32 #include <babeltrace/ctf-ir/fields-internal.h>
  33 #include <babeltrace/ctf-ir/field-types-internal.h>
  34 #include <babeltrace/ctf-ir/clock-class.h>
  35 #include <babeltrace/ctf-ir/clock-class-internal.h>
  36 #include <babeltrace/ctf-ir/event-internal.h>
  37 #include <babeltrace/ctf-ir/event-class.h>
  38 #include <babeltrace/ctf-ir/event-class-internal.h>
  39 #include <babeltrace/ctf-ir/stream-class.h>
  40 #include <babeltrace/ctf-ir/stream-class-internal.h>
  41 #include <babeltrace/ctf-ir/stream-internal.h>
  42 #include <babeltrace/ctf-ir/packet.h>
  43 #include <babeltrace/ctf-ir/packet-internal.h>
  44 #include <babeltrace/ctf-ir/trace-internal.h>
  45 #include <babeltrace/ctf-ir/validation-internal.h>
  46 #include <babeltrace/ctf-ir/packet-internal.h>
  47 #include <babeltrace/ctf-ir/utils.h>
  48 #include <babeltrace/ctf-writer/serialize-internal.h>
  49 #include <babeltrace/ref.h>
  50 #include <babeltrace/ctf-ir/attributes-internal.h>
  51 #include <babeltrace/compiler-internal.h>
  52 #include <inttypes.h>
  53
  54 static
  55 void bt_ctf_event_destroy(struct bt_object *obj);
  56
  57 struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class)
  58 {
  59         int ret;
  60         enum bt_ctf_validation_flag validation_flags =
  61                 BT_CTF_VALIDATION_FLAG_STREAM |
  62                 BT_CTF_VALIDATION_FLAG_EVENT;
  63         struct bt_ctf_event *event = NULL;
  64         struct bt_ctf_trace *trace = NULL;
  65         struct bt_ctf_stream_class *stream_class = NULL;
  66         struct bt_ctf_field_type *packet_header_type = NULL;
  67         struct bt_ctf_field_type *packet_context_type = NULL;
  68         struct bt_ctf_field_type *event_header_type = NULL;
  69         struct bt_ctf_field_type *stream_event_ctx_type = NULL;
  70         struct bt_ctf_field_type *event_context_type = NULL;
  71         struct bt_ctf_field_type *event_payload_type = NULL;
  72         struct bt_ctf_field *event_header = NULL;
  73         struct bt_ctf_field *stream_event_context = NULL;
  74         struct bt_ctf_field *event_context = NULL;
  75         struct bt_ctf_field *event_payload = NULL;
  76         struct bt_value *environment = NULL;
  77         struct bt_ctf_validation_output validation_output = { 0 };
  78         int trace_valid = 0;
  79
  80         BT_LOGD("Creating event object: event-class-addr=%p, "
  81                 "event-class-name=\"%s\", event-class-id=%" PRId64,
  82                 event_class, bt_ctf_event_class_get_name(event_class),
  83                 bt_ctf_event_class_get_id(event_class));
  84
  85         if (!event_class) {
  86                 BT_LOGW_STR("Invalid parameter: event class is NULL.");
  87                 goto error;
  88         }
  89
  90         stream_class = bt_ctf_event_class_get_stream_class(event_class);
  91
  92         /*
  93          * We disallow the creation of an event if its event class has not been
  94          * associated to a stream class.
  95          */
  96         if (!stream_class) {
  97                 BT_LOGW_STR("Event class is not part of a stream class.");
  98                 goto error;
  99         }
 100
 101         /* A stream class should always have an existing event header type */
 102         assert(stream_class->event_header_type);
 103
 104         /* The event class was frozen when added to its stream class */
 105         assert(event_class->frozen);
 106
 107         /* Validate the trace (if any), the stream class, and the event class */
 108         trace = bt_ctf_stream_class_get_trace(stream_class);
 109         if (trace) {
 110                 BT_LOGD_STR("Event's class is part of a trace.");
 111                 packet_header_type = bt_ctf_trace_get_packet_header_type(trace);
 112                 trace_valid = trace->valid;
 113                 assert(trace_valid);
 114                 environment = trace->environment;
 115         }
 116
 117         packet_context_type = bt_ctf_stream_class_get_packet_context_type(
 118                 stream_class);
 119         event_header_type = bt_ctf_stream_class_get_event_header_type(
 120                 stream_class);
 121         stream_event_ctx_type = bt_ctf_stream_class_get_event_context_type(
 122                 stream_class);
 123         event_context_type = bt_ctf_event_class_get_context_type(event_class);
 124         event_payload_type = bt_ctf_event_class_get_payload_type(event_class);
 125         ret = bt_ctf_validate_class_types(environment, packet_header_type,
 126                 packet_context_type, event_header_type, stream_event_ctx_type,
 127                 event_context_type, event_payload_type, trace_valid,
 128                 stream_class->valid, event_class->valid,
 129                 &validation_output, validation_flags);
 130         BT_PUT(packet_header_type);
 131         BT_PUT(packet_context_type);
 132         BT_PUT(event_header_type);
 133         BT_PUT(stream_event_ctx_type);
 134         BT_PUT(event_context_type);
 135         BT_PUT(event_payload_type);
 136         if (ret) {
 137                 /*
 138                  * This means something went wrong during the validation
 139                  * process, not that the objects are invalid.
 140                  */
 141                 BT_LOGE("Failed to validate event and parents: ret=%d", ret);
 142                 goto error;
 143         }
 144
 145         if ((validation_output.valid_flags & validation_flags) !=
 146                         validation_flags) {
 147                 /* Invalid trace/stream class/event class */
 148                 BT_LOGE("Invalid trace, stream class, or event class: "
 149                         "valid-flags=0x%x", validation_output.valid_flags);
 150                 goto error;
 151         }
 152
 153         /*
 154          * At this point we know the trace (if associated to the stream
 155          * class), the stream class, and the event class, with their
 156          * current types, are valid. We may proceed with creating
 157          * the event.
 158          */
 159         event = g_new0(struct bt_ctf_event, 1);
 160         if (!event) {
 161                 BT_LOGE_STR("Failed to allocate one event.");
 162                 goto error;
 163         }
 164
 165         bt_object_init(event, bt_ctf_event_destroy);
 166
 167         /*
 168          * event does not share a common ancestor with the event class; it has
 169          * to guarantee its existence by holding a reference. This reference
 170          * shall be released once the event is associated to a stream since,
 171          * from that point, the event and its class will share the same
 172          * lifetime.
 173          */
 174         event->event_class = bt_get(event_class);
 175         event->clock_values = g_hash_table_new_full(g_direct_hash,
 176                         g_direct_equal, bt_put, bt_put);
 177         event_header =
 178                 bt_ctf_field_create(validation_output.event_header_type);
 179         if (!event_header) {
 180                 BT_LOGE_STR("Cannot create initial event header field object.");
 181                 goto error;
 182         }
 183
 184         if (validation_output.stream_event_ctx_type) {
 185                 stream_event_context = bt_ctf_field_create(
 186                         validation_output.stream_event_ctx_type);
 187                 if (!stream_event_context) {
 188                         BT_LOGE_STR("Cannot create initial stream event context field object.");
 189                         goto error;
 190                 }
 191         }
 192
 193         if (validation_output.event_context_type) {
 194                 event_context = bt_ctf_field_create(
 195                         validation_output.event_context_type);
 196                 if (!event_context) {
 197                         BT_LOGE_STR("Cannot create initial event context field object.");
 198                         goto error;
 199                 }
 200         }
 201
 202         if (validation_output.event_payload_type) {
 203                 event_payload = bt_ctf_field_create(
 204                         validation_output.event_payload_type);
 205                 if (!event_payload) {
 206                         BT_LOGE_STR("Cannot create initial event payload field object.");
 207                         goto error;
 208                 }
 209         }
 210
 211         /*
 212          * At this point all the fields are created, potentially from
 213          * validated copies of field types, so that the field types and
 214          * fields can be replaced in the trace, stream class,
 215          * event class, and created event.
 216          */
 217         bt_ctf_validation_replace_types(trace, stream_class,
 218                 event_class, &validation_output, validation_flags);
 219         BT_MOVE(event->event_header, event_header);
 220         BT_MOVE(event->stream_event_context, stream_event_context);
 221         BT_MOVE(event->context_payload, event_context);
 222         BT_MOVE(event->fields_payload, event_payload);
 223
 224         /*
 225          * Put what was not moved in bt_ctf_validation_replace_types().
 226          */
 227         bt_ctf_validation_output_put_types(&validation_output);
 228
 229         /*
 230          * Freeze the stream class since the event header must not be changed
 231          * anymore.
 232          */
 233         bt_ctf_stream_class_freeze(stream_class);
 234
 235         /*
 236          * Mark stream class, and event class as valid since
 237          * they're all frozen now.
 238          */
 239         stream_class->valid = 1;
 240         event_class->valid = 1;
 241
 242         /* Put stuff we borrowed from the event class */
 243         BT_PUT(stream_class);
 244         BT_PUT(trace);
 245         BT_LOGD("Created event object: addr=%p, event-class-name=\"%s\", "
 246                 "event-class-id=%" PRId64,
 247                 event, bt_ctf_event_class_get_name(event->event_class),
 248                 bt_ctf_event_class_get_id(event_class));
 249         return event;
 250
 251 error:
 252         bt_ctf_validation_output_put_types(&validation_output);
 253         BT_PUT(event);
 254         BT_PUT(stream_class);
 255         BT_PUT(trace);
 256         BT_PUT(event_header);
 257         BT_PUT(stream_event_context);
 258         BT_PUT(event_context);
 259         BT_PUT(event_payload);
 260         assert(!packet_header_type);
 261         assert(!packet_context_type);
 262         assert(!event_header_type);
 263         assert(!stream_event_ctx_type);
 264         assert(!event_context_type);
 265         assert(!event_payload_type);
 266
 267         return event;
 268 }
 269
 270 struct bt_ctf_event_class *bt_ctf_event_get_class(struct bt_ctf_event *event)
 271 {
 272         struct bt_ctf_event_class *event_class = NULL;
 273
 274         if (!event) {
 275                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 276                 goto end;
 277         }
 278
 279         event_class = event ? bt_get(bt_ctf_event_borrow_event_class(event)) :
 280                 NULL;
 281 end:
 282         return event_class;
 283 }
 284
 285 struct bt_ctf_stream *bt_ctf_event_get_stream(struct bt_ctf_event *event)
 286 {
 287         struct bt_ctf_stream *stream = NULL;
 288
 289         if (!event) {
 290                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 291                 goto end;
 292         }
 293
 294         /*
 295          * If the event has a parent, then this is its (writer) stream.
 296          * If the event has no parent, then if it has a packet, this
 297          * is its (non-writer) stream.
 298          */
 299         if (event->base.parent) {
 300                 stream = (struct bt_ctf_stream *) bt_object_get_parent(event);
 301         } else {
 302                 if (event->packet) {
 303                         stream = bt_get(event->packet->stream);
 304                 }
 305         }
 306
 307 end:
 308         return stream;
 309 }
 310
 311 int bt_ctf_event_set_payload(struct bt_ctf_event *event,
 312                 const char *name,
 313                 struct bt_ctf_field *payload)
 314 {
 315         int ret = 0;
 316
 317         if (!event || !payload) {
 318                 BT_LOGW("Invalid parameter: event or payload field is NULL: "
 319                         "event-addr=%p, payload-field-addr=%p",
 320                         event, payload);
 321                 ret = -1;
 322                 goto end;
 323         }
 324
 325         if (event->frozen) {
 326                 BT_LOGW("Invalid parameter: event is frozen: addr=%p, "
 327                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 328                         event, bt_ctf_event_class_get_name(event->event_class),
 329                         bt_ctf_event_class_get_id(event->event_class));
 330                 ret = -1;
 331                 goto end;
 332         }
 333
 334         if (name) {
 335                 ret = bt_ctf_field_structure_set_field(event->fields_payload,
 336                         name, payload);
 337         } else {
 338                 struct bt_ctf_field_type *payload_type;
 339
 340                 payload_type = bt_ctf_field_get_type(payload);
 341
 342                 if (bt_ctf_field_type_compare(payload_type,
 343                                 event->event_class->fields) == 0) {
 344                         bt_put(event->fields_payload);
 345                         bt_get(payload);
 346                         event->fields_payload = payload;
 347                 } else {
 348                         BT_LOGW("Invalid parameter: payload field type is different from the expected field type: "
 349                                 "event-addr=%p, event-class-name=\"%s\", "
 350                                 "event-class-id=%" PRId64,
 351                                 event,
 352                                 bt_ctf_event_class_get_name(event->event_class),
 353                                 bt_ctf_event_class_get_id(event->event_class));
 354                         ret = -1;
 355                 }
 356
 357                 bt_put(payload_type);
 358         }
 359
 360         if (ret) {
 361                 BT_LOGW("Failed to set event's payload field: event-addr=%p, "
 362                         "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
 363                         "payload-field-name=\"%s\", payload-field-addr=%p",
 364                         event, bt_ctf_event_class_get_name(event->event_class),
 365                         bt_ctf_event_class_get_id(event->event_class),
 366                         name, payload);
 367         } else {
 368                 BT_LOGV("Set event's payload field: event-addr=%p, "
 369                         "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
 370                         "payload-field-name=\"%s\", payload-field-addr=%p",
 371                         event, bt_ctf_event_class_get_name(event->event_class),
 372                         bt_ctf_event_class_get_id(event->event_class),
 373                         name, payload);
 374         }
 375
 376 end:
 377         return ret;
 378 }
 379
 380 struct bt_ctf_field *bt_ctf_event_get_event_payload(struct bt_ctf_event *event)
 381 {
 382         struct bt_ctf_field *payload = NULL;
 383
 384         if (!event) {
 385                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 386                 goto end;
 387         }
 388
 389         if (!event->fields_payload) {
 390                 BT_LOGV("Event has no current payload field: addr=%p, "
 391                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 392                         event, bt_ctf_event_class_get_name(event->event_class),
 393                         bt_ctf_event_class_get_id(event->event_class));
 394                 goto end;
 395         }
 396
 397         payload = event->fields_payload;
 398         bt_get(payload);
 399 end:
 400         return payload;
 401 }
 402
 403 int bt_ctf_event_set_event_payload(struct bt_ctf_event *event,
 404                 struct bt_ctf_field *payload)
 405 {
 406         return bt_ctf_event_set_payload(event, NULL, payload);
 407 }
 408
 409 struct bt_ctf_field *bt_ctf_event_get_payload(struct bt_ctf_event *event,
 410                 const char *name)
 411 {
 412         struct bt_ctf_field *field = NULL;
 413
 414         if (!event) {
 415                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 416                 goto end;
 417         }
 418
 419         if (name) {
 420                 field = bt_ctf_field_structure_get_field(event->fields_payload,
 421                         name);
 422         } else {
 423                 field = event->fields_payload;
 424                 bt_get(field);
 425         }
 426 end:
 427         return field;
 428 }
 429
 430 struct bt_ctf_field *bt_ctf_event_get_payload_by_index(
 431                 struct bt_ctf_event *event, uint64_t index)
 432 {
 433         struct bt_ctf_field *field = NULL;
 434
 435         if (!event) {
 436                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 437                 goto end;
 438         }
 439
 440         field = bt_ctf_field_structure_get_field_by_index(event->fields_payload,
 441                 index);
 442 end:
 443         return field;
 444 }
 445
 446 struct bt_ctf_field *bt_ctf_event_get_header(
 447                 struct bt_ctf_event *event)
 448 {
 449         struct bt_ctf_field *header = NULL;
 450
 451         if (!event) {
 452                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 453                 goto end;
 454         }
 455
 456         if (!event->event_header) {
 457                 BT_LOGV("Event has no current header field: addr=%p, "
 458                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 459                         event, bt_ctf_event_class_get_name(event->event_class),
 460                         bt_ctf_event_class_get_id(event->event_class));
 461                 goto end;
 462         }
 463
 464         header = event->event_header;
 465         bt_get(header);
 466 end:
 467         return header;
 468 }
 469
 470 int bt_ctf_event_set_header(struct bt_ctf_event *event,
 471                 struct bt_ctf_field *header)
 472 {
 473         int ret = 0;
 474         struct bt_ctf_field_type *field_type = NULL;
 475         struct bt_ctf_stream_class *stream_class = NULL;
 476
 477         if (!event) {
 478                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 479                 ret = -1;
 480                 goto end;
 481         }
 482
 483         if (event->frozen) {
 484                 BT_LOGW("Invalid parameter: event is frozen: addr=%p, "
 485                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 486                         event, bt_ctf_event_class_get_name(event->event_class),
 487                         bt_ctf_event_class_get_id(event->event_class));
 488                 ret = -1;
 489                 goto end;
 490         }
 491
 492         stream_class = (struct bt_ctf_stream_class *) bt_object_get_parent(
 493                         event->event_class);
 494         /*
 495          * Ensure the provided header's type matches the one registered to the
 496          * stream class.
 497          */
 498         field_type = bt_ctf_field_get_type(header);
 499         if (bt_ctf_field_type_compare(field_type,
 500                         stream_class->event_header_type)) {
 501                 BT_LOGW("Invalid parameter: header field type is different from the expected field type: "
 502                         "event-addr=%p, event-class-name=\"%s\", "
 503                         "event-class-id=%" PRId64,
 504                         event,
 505                         bt_ctf_event_class_get_name(event->event_class),
 506                         bt_ctf_event_class_get_id(event->event_class));
 507                 ret = -1;
 508                 goto end;
 509         }
 510
 511         bt_put(event->event_header);
 512         event->event_header = bt_get(header);
 513         BT_LOGV("Set event's header field: event-addr=%p, "
 514                 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
 515                 "header-field-addr=%p",
 516                 event, bt_ctf_event_class_get_name(event->event_class),
 517                 bt_ctf_event_class_get_id(event->event_class), header);
 518 end:
 519         bt_put(stream_class);
 520         bt_put(field_type);
 521         return ret;
 522 }
 523
 524 struct bt_ctf_field *bt_ctf_event_get_event_context(
 525                 struct bt_ctf_event *event)
 526 {
 527         struct bt_ctf_field *context = NULL;
 528
 529         if (!event) {
 530                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 531                 goto end;
 532         }
 533
 534         if (!event->context_payload) {
 535                 BT_LOGV("Event has no current context field: addr=%p, "
 536                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 537                         event, bt_ctf_event_class_get_name(event->event_class),
 538                         bt_ctf_event_class_get_id(event->event_class));
 539                 goto end;
 540         }
 541
 542         context = event->context_payload;
 543         bt_get(context);
 544 end:
 545         return context;
 546 }
 547
 548 int bt_ctf_event_set_event_context(struct bt_ctf_event *event,
 549                 struct bt_ctf_field *context)
 550 {
 551         int ret = 0;
 552         struct bt_ctf_field_type *field_type = NULL;
 553
 554         if (!event) {
 555                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 556                 ret = -1;
 557                 goto end;
 558         }
 559
 560         if (event->frozen) {
 561                 BT_LOGW("Invalid parameter: event is frozen: addr=%p, "
 562                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 563                         event, bt_ctf_event_class_get_name(event->event_class),
 564                         bt_ctf_event_class_get_id(event->event_class));
 565                 ret = -1;
 566                 goto end;
 567         }
 568
 569         field_type = bt_ctf_field_get_type(context);
 570         if (bt_ctf_field_type_compare(field_type,
 571                         event->event_class->context)) {
 572                 BT_LOGW("Invalid parameter: context field type is different from the expected field type: "
 573                         "event-addr=%p, event-class-name=\"%s\", "
 574                         "event-class-id=%" PRId64,
 575                         event,
 576                         bt_ctf_event_class_get_name(event->event_class),
 577                         bt_ctf_event_class_get_id(event->event_class));
 578                 ret = -1;
 579                 goto end;
 580         }
 581
 582         bt_put(event->context_payload);
 583         event->context_payload = bt_get(context);
 584         BT_LOGV("Set event's context field: event-addr=%p, "
 585                 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
 586                 "context-field-addr=%p",
 587                 event, bt_ctf_event_class_get_name(event->event_class),
 588                 bt_ctf_event_class_get_id(event->event_class), context);
 589 end:
 590         bt_put(field_type);
 591         return ret;
 592 }
 593
 594 struct bt_ctf_field *bt_ctf_event_get_stream_event_context(
 595                 struct bt_ctf_event *event)
 596 {
 597         struct bt_ctf_field *stream_event_context = NULL;
 598
 599         if (!event) {
 600                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 601                 goto end;
 602         }
 603
 604         if (!event->stream_event_context) {
 605                 BT_LOGV("Event has no current stream event context field: addr=%p, "
 606                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 607                         event, bt_ctf_event_class_get_name(event->event_class),
 608                         bt_ctf_event_class_get_id(event->event_class));
 609                 goto end;
 610         }
 611
 612         stream_event_context = event->stream_event_context;
 613 end:
 614         return bt_get(stream_event_context);
 615 }
 616
 617 int bt_ctf_event_set_stream_event_context(struct bt_ctf_event *event,
 618                 struct bt_ctf_field *stream_event_context)
 619 {
 620         int ret = 0;
 621         struct bt_ctf_field_type *field_type = NULL;
 622         struct bt_ctf_stream_class *stream_class = NULL;
 623
 624         if (!event) {
 625                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 626                 ret = -1;
 627                 goto end;
 628         }
 629
 630         if (event->frozen) {
 631                 BT_LOGW("Invalid parameter: event is frozen: addr=%p, "
 632                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 633                         event, bt_ctf_event_class_get_name(event->event_class),
 634                         bt_ctf_event_class_get_id(event->event_class));
 635                 ret = -1;
 636                 goto end;
 637         }
 638
 639         stream_class = bt_ctf_event_class_get_stream_class(event->event_class);
 640         /*
 641          * We should not have been able to create the event without associating
 642          * the event class to a stream class.
 643          */
 644         assert(stream_class);
 645
 646         field_type = bt_ctf_field_get_type(stream_event_context);
 647         if (bt_ctf_field_type_compare(field_type,
 648                         stream_class->event_context_type)) {
 649                 BT_LOGW("Invalid parameter: stream event context field type is different from the expected field type: "
 650                         "event-addr=%p, event-class-name=\"%s\", "
 651                         "event-class-id=%" PRId64,
 652                         event,
 653                         bt_ctf_event_class_get_name(event->event_class),
 654                         bt_ctf_event_class_get_id(event->event_class));
 655                 ret = -1;
 656                 goto end;
 657         }
 658
 659         bt_get(stream_event_context);
 660         BT_MOVE(event->stream_event_context, stream_event_context);
 661         BT_LOGV("Set event's stream event context field: event-addr=%p, "
 662                 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
 663                 "stream-event-context-field-addr=%p",
 664                 event, bt_ctf_event_class_get_name(event->event_class),
 665                 bt_ctf_event_class_get_id(event->event_class),
 666                 stream_event_context);
 667 end:
 668         BT_PUT(stream_class);
 669         bt_put(field_type);
 670         return ret;
 671 }
 672
 673 /* Pre-2.0 CTF writer backward compatibility */
 674 void bt_ctf_event_get(struct bt_ctf_event *event)
 675 {
 676         bt_get(event);
 677 }
 678
 679 /* Pre-2.0 CTF writer backward compatibility */
 680 void bt_ctf_event_put(struct bt_ctf_event *event)
 681 {
 682         bt_put(event);
 683 }
 684
 685 void bt_ctf_event_destroy(struct bt_object *obj)
 686 {
 687         struct bt_ctf_event *event;
 688
 689         event = container_of(obj, struct bt_ctf_event, base);
 690         BT_LOGD("Destroying event: addr=%p, "
 691                 "event-class-name=\"%s\", event-class-id=%" PRId64,
 692                 event, bt_ctf_event_class_get_name(event->event_class),
 693                 bt_ctf_event_class_get_id(event->event_class));
 694
 695         if (!event->base.parent) {
 696                 /*
 697                  * Event was keeping a reference to its class since it shared no
 698                  * common ancestor with it to guarantee they would both have the
 699                  * same lifetime.
 700                  */
 701                 bt_put(event->event_class);
 702         }
 703         g_hash_table_destroy(event->clock_values);
 704         BT_LOGD_STR("Putting event's header field.");
 705         bt_put(event->event_header);
 706         BT_LOGD_STR("Putting event's stream event context field.");
 707         bt_put(event->stream_event_context);
 708         BT_LOGD_STR("Putting event's context field.");
 709         bt_put(event->context_payload);
 710         BT_LOGD_STR("Putting event's payload field.");
 711         bt_put(event->fields_payload);
 712         BT_LOGD_STR("Putting event's packet.");
 713         bt_put(event->packet);
 714         g_free(event);
 715 }
 716
 717 struct bt_ctf_clock_value *bt_ctf_event_get_clock_value(
 718                 struct bt_ctf_event *event, struct bt_ctf_clock_class *clock_class)
 719 {
 720         struct bt_ctf_clock_value *clock_value = NULL;
 721
 722         if (!event || !clock_class) {
 723                 BT_LOGW("Invalid parameter: event or clock class is NULL: "
 724                         "event-addr=%p, clock-class-addr=%p",
 725                         event, clock_class);
 726                 goto end;
 727         }
 728
 729         clock_value = g_hash_table_lookup(event->clock_values, clock_class);
 730         if (!clock_value) {
 731                 BT_LOGV("No clock value associated to the given clock class: "
 732                         "event-addr=%p, event-class-name=\"%s\", "
 733                         "event-class-id=%" PRId64 ", clock-class-addr=%p, "
 734                         "clock-class-name=\"%s\"", event,
 735                         bt_ctf_event_class_get_name(event->event_class),
 736                         bt_ctf_event_class_get_id(event->event_class),
 737                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 738                 goto end;
 739         }
 740
 741         bt_get(clock_value);
 742 end:
 743         return clock_value;
 744 }
 745
 746 int bt_ctf_event_set_clock_value(struct bt_ctf_event *event,
 747                 struct bt_ctf_clock_value *value)
 748 {
 749         int ret = 0;
 750         struct bt_ctf_trace *trace;
 751         struct bt_ctf_stream_class *stream_class;
 752         struct bt_ctf_event_class *event_class;
 753         struct bt_ctf_clock_class *clock_class = NULL;
 754
 755         if (!event || !value) {
 756                 BT_LOGW("Invalid parameter: event or clock value is NULL: "
 757                         "event-addr=%p, clock-value-addr=%p",
 758                         event, value);
 759                 ret = -1;
 760                 goto end;
 761         }
 762
 763         if (event->frozen) {
 764                 BT_LOGW("Invalid parameter: event is frozen: addr=%p, "
 765                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 766                         event, bt_ctf_event_class_get_name(event->event_class),
 767                         bt_ctf_event_class_get_id(event->event_class));
 768                 ret = -1;
 769                 goto end;
 770         }
 771
 772         clock_class = bt_ctf_clock_value_get_class(value);
 773         event_class = bt_ctf_event_borrow_event_class(event);
 774         assert(event_class);
 775         stream_class = bt_ctf_event_class_borrow_stream_class(event_class);
 776         assert(stream_class);
 777         trace = bt_ctf_stream_class_borrow_trace(stream_class);
 778         assert(trace);
 779
 780         if (!bt_ctf_trace_has_clock_class(trace, clock_class)) {
 781                 BT_LOGW("Invalid parameter: clock class is not part of event's trace: "
 782                         "event-addr=%p, event-class-name=\"%s\", "
 783                         "event-class-id=%" PRId64 ", clock-class-addr=%p, "
 784                         "clock-class-name=\"%s\"",
 785                         event, bt_ctf_event_class_get_name(event->event_class),
 786                         bt_ctf_event_class_get_id(event->event_class),
 787                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 788                 ret = -1;
 789                 goto end;
 790         }
 791
 792         g_hash_table_insert(event->clock_values, clock_class, bt_get(value));
 793         BT_LOGV("Set event's clock value: "
 794                 "event-addr=%p, event-class-name=\"%s\", "
 795                 "event-class-id=%" PRId64 ", clock-class-addr=%p, "
 796                 "clock-class-name=\"%s\", clock-value-addr=%p, "
 797                 "clock-value-cycles=%" PRIu64,
 798                 event, bt_ctf_event_class_get_name(event->event_class),
 799                 bt_ctf_event_class_get_id(event->event_class),
 800                 clock_class, bt_ctf_clock_class_get_name(clock_class),
 801                 value, value->value);
 802         clock_class = NULL;
 803
 804 end:
 805         bt_put(clock_class);
 806         return ret;
 807 }
 808
 809 BT_HIDDEN
 810 int bt_ctf_event_validate(struct bt_ctf_event *event)
 811 {
 812         /* Make sure each field's payload has been set */
 813         int ret;
 814         struct bt_ctf_stream_class *stream_class = NULL;
 815
 816         assert(event);
 817         ret = bt_ctf_field_validate(event->event_header);
 818         if (ret) {
 819                 BT_LOGD("Invalid event's header field: "
 820                         "event-addr=%p, event-class-name=\"%s\", "
 821                         "event-class-id=%" PRId64,
 822                         event, bt_ctf_event_class_get_name(event->event_class),
 823                         bt_ctf_event_class_get_id(event->event_class));
 824                 goto end;
 825         }
 826
 827         stream_class = bt_ctf_event_class_get_stream_class(event->event_class);
 828         /*
 829          * We should not have been able to create the event without associating
 830          * the event class to a stream class.
 831          */
 832         assert(stream_class);
 833         if (stream_class->event_context_type) {
 834                 ret = bt_ctf_field_validate(event->stream_event_context);
 835                 if (ret) {
 836                         BT_LOGD("Invalid event's stream event context field: "
 837                                 "event-addr=%p, event-class-name=\"%s\", "
 838                                 "event-class-id=%" PRId64,
 839                                 event,
 840                                 bt_ctf_event_class_get_name(event->event_class),
 841                                 bt_ctf_event_class_get_id(event->event_class));
 842                         goto end;
 843                 }
 844         }
 845
 846         ret = bt_ctf_field_validate(event->fields_payload);
 847         if (ret) {
 848                 BT_LOGD("Invalid event's payload field: "
 849                         "event-addr=%p, event-class-name=\"%s\", "
 850                         "event-class-id=%" PRId64,
 851                         event,
 852                         bt_ctf_event_class_get_name(event->event_class),
 853                         bt_ctf_event_class_get_id(event->event_class));
 854                 goto end;
 855         }
 856
 857         if (event->event_class->context) {
 858                 BT_LOGD("Invalid event's context field: "
 859                         "event-addr=%p, event-class-name=\"%s\", "
 860                         "event-class-id=%" PRId64,
 861                         event,
 862                         bt_ctf_event_class_get_name(event->event_class),
 863                         bt_ctf_event_class_get_id(event->event_class));
 864                 ret = bt_ctf_field_validate(event->context_payload);
 865         }
 866 end:
 867         bt_put(stream_class);
 868         return ret;
 869 }
 870
 871 BT_HIDDEN
 872 int bt_ctf_event_serialize(struct bt_ctf_event *event,
 873                 struct bt_ctf_stream_pos *pos,
 874                 enum bt_ctf_byte_order native_byte_order)
 875 {
 876         int ret = 0;
 877
 878         assert(event);
 879         assert(pos);
 880
 881         BT_LOGV("Serializing event: "
 882                 "event-addr=%p, event-class-name=\"%s\", "
 883                 "event-class-id=%" PRId64 ", pos-offset=%" PRId64 ", "
 884                 "native-bo=%s",
 885                 event, bt_ctf_event_class_get_name(event->event_class),
 886                 bt_ctf_event_class_get_id(event->event_class),
 887                 pos->offset, bt_ctf_byte_order_string(native_byte_order));
 888
 889         BT_LOGV_STR("Serializing context field.");
 890         if (event->context_payload) {
 891                 ret = bt_ctf_field_serialize(event->context_payload, pos,
 892                         native_byte_order);
 893                 if (ret) {
 894                         BT_LOGE("Cannot serialize event's context field: "
 895                                 "event-addr=%p, event-class-name=\"%s\", "
 896                                 "event-class-id=%" PRId64,
 897                                 event,
 898                                 bt_ctf_event_class_get_name(event->event_class),
 899                                 bt_ctf_event_class_get_id(event->event_class));
 900                         goto end;
 901                 }
 902         }
 903
 904         BT_LOGV_STR("Serializing payload field.");
 905         if (event->fields_payload) {
 906                 ret = bt_ctf_field_serialize(event->fields_payload, pos,
 907                         native_byte_order);
 908                 if (ret) {
 909                         BT_LOGE("Cannot serialize event's payload field: "
 910                                 "event-addr=%p, event-class-name=\"%s\", "
 911                                 "event-class-id=%" PRId64,
 912                                 event,
 913                                 bt_ctf_event_class_get_name(event->event_class),
 914                                 bt_ctf_event_class_get_id(event->event_class));
 915                         goto end;
 916                 }
 917         }
 918 end:
 919         return ret;
 920 }
 921
 922 struct bt_ctf_packet *bt_ctf_event_get_packet(struct bt_ctf_event *event)
 923 {
 924         struct bt_ctf_packet *packet = NULL;
 925
 926         if (!event) {
 927                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 928                 goto end;
 929         }
 930
 931         if (!event->packet) {
 932                 BT_LOGV("Event has no current packet: addr=%p, "
 933                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 934                         event, bt_ctf_event_class_get_name(event->event_class),
 935                         bt_ctf_event_class_get_id(event->event_class));
 936                 goto end;
 937         }
 938
 939         packet = bt_get(event->packet);
 940 end:
 941         return packet;
 942 }
 943
 944 int bt_ctf_event_set_packet(struct bt_ctf_event *event,
 945                 struct bt_ctf_packet *packet)
 946 {
 947         struct bt_ctf_stream_class *event_stream_class = NULL;
 948         struct bt_ctf_stream_class *packet_stream_class = NULL;
 949         struct bt_ctf_stream *stream = NULL;
 950         int ret = 0;
 951
 952         if (!event || !packet) {
 953                 BT_LOGW("Invalid parameter: event or packet is NULL: "
 954                         "event-addr=%p, packet-addr=%p",
 955                         event, packet);
 956                 ret = -1;
 957                 goto end;
 958         }
 959
 960         if (event->frozen) {
 961                 BT_LOGW("Invalid parameter: event is frozen: addr=%p, "
 962                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 963                         event, bt_ctf_event_class_get_name(event->event_class),
 964                         bt_ctf_event_class_get_id(event->event_class));
 965                 ret = -1;
 966                 goto end;
 967         }
 968
 969         /*
 970          * Make sure the new packet was created by this event's
 971          * stream, if it is set.
 972          */
 973         stream = bt_ctf_event_get_stream(event);
 974         if (stream) {
 975                 if (packet->stream != stream) {
 976                         BT_LOGW("Invalid parameter: packet's stream and event's stream differ: "
 977                                 "event-addr=%p, event-class-name=\"%s\", "
 978                                 "event-class-id=%" PRId64 ", packet-stream-addr=%p, "
 979                                 "event-stream-addr=%p",
 980                                 event, bt_ctf_event_class_get_name(event->event_class),
 981                                 bt_ctf_event_class_get_id(event->event_class),
 982                                 packet->stream, stream);
 983                         ret = -1;
 984                         goto end;
 985                 }
 986         } else {
 987                 event_stream_class =
 988                         bt_ctf_event_class_get_stream_class(event->event_class);
 989                 packet_stream_class =
 990                         bt_ctf_stream_get_class(packet->stream);
 991
 992                 assert(event_stream_class);
 993                 assert(packet_stream_class);
 994
 995                 if (event_stream_class != packet_stream_class) {
 996                         BT_LOGW("Invalid parameter: packet's stream class and event's stream class differ: "
 997                                 "event-addr=%p, event-class-name=\"%s\", "
 998                                 "event-class-id=%" PRId64 ", packet-stream-class-addr=%p, "
 999                                 "event-stream-class-addr=%p",
1000                                 event, bt_ctf_event_class_get_name(event->event_class),
1001                                 bt_ctf_event_class_get_id(event->event_class),
1002                                 packet_stream_class, event_stream_class);
1003                         ret = -1;
1004                         goto end;
1005                 }
1006         }
1007
1008         bt_get(packet);
1009         BT_MOVE(event->packet, packet);
1010         BT_LOGV("Set event's packet: event-addr=%p, "
1011                 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
1012                 "packet-addr=%p",
1013                 event, bt_ctf_event_class_get_name(event->event_class),
1014                 bt_ctf_event_class_get_id(event->event_class), packet);
1015
1016 end:
1017         BT_PUT(stream);
1018         BT_PUT(event_stream_class);
1019         BT_PUT(packet_stream_class);
1020
1021         return ret;
1022 }
1023
1024 BT_HIDDEN
1025 void bt_ctf_event_freeze(struct bt_ctf_event *event)
1026 {
1027         assert(event);
1028
1029         if (event->frozen) {
1030                 return;
1031         }
1032
1033         BT_LOGD("Freezing event: addr=%p, "
1034                 "event-class-name=\"%s\", event-class-id=%" PRId64,
1035                 event, bt_ctf_event_class_get_name(event->event_class),
1036                 bt_ctf_event_class_get_id(event->event_class));
1037         bt_ctf_packet_freeze(event->packet);
1038         BT_LOGD_STR("Freezing event's header field.");
1039         bt_ctf_field_freeze(event->event_header);
1040         BT_LOGD_STR("Freezing event's stream event context field.");
1041         bt_ctf_field_freeze(event->stream_event_context);
1042         BT_LOGD_STR("Freezing event's context field.");
1043         bt_ctf_field_freeze(event->context_payload);
1044         BT_LOGD_STR("Freezing event's payload field.");
1045         bt_ctf_field_freeze(event->fields_payload);
1046         event->frozen = 1;
1047 }