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