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