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 = event ? bt_get(bt_ctf_event_borrow_event_class(event)) :
 288                 NULL;
 289 end:
 290         return event_class;
 291 }
 292
 293 struct bt_ctf_stream *bt_ctf_event_get_stream(struct bt_ctf_event *event)
 294 {
 295         struct bt_ctf_stream *stream = NULL;
 296
 297         if (!event) {
 298                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 299                 goto end;
 300         }
 301
 302         /*
 303          * If the event has a parent, then this is its (writer) stream.
 304          * If the event has no parent, then if it has a packet, this
 305          * is its (non-writer) stream.
 306          */
 307         if (event->base.parent) {
 308                 stream = (struct bt_ctf_stream *) bt_object_get_parent(event);
 309         } else {
 310                 if (event->packet) {
 311                         stream = bt_get(event->packet->stream);
 312                 }
 313         }
 314
 315 end:
 316         return stream;
 317 }
 318
 319 int bt_ctf_event_set_payload(struct bt_ctf_event *event,
 320                 const char *name,
 321                 struct bt_ctf_field *payload)
 322 {
 323         int ret = 0;
 324
 325         if (!event || !payload) {
 326                 BT_LOGW("Invalid parameter: event or payload field is NULL: "
 327                         "event-addr=%p, payload-field-addr=%p",
 328                         event, payload);
 329                 ret = -1;
 330                 goto end;
 331         }
 332
 333         if (event->frozen) {
 334                 BT_LOGW("Invalid parameter: event is frozen: addr=%p, "
 335                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 336                         event, bt_ctf_event_class_get_name(event->event_class),
 337                         bt_ctf_event_class_get_id(event->event_class));
 338                 ret = -1;
 339                 goto end;
 340         }
 341
 342         if (name) {
 343                 ret = bt_ctf_field_structure_set_field(event->fields_payload,
 344                         name, payload);
 345         } else {
 346                 struct bt_ctf_field_type *payload_type;
 347
 348                 payload_type = bt_ctf_field_get_type(payload);
 349
 350                 if (bt_ctf_field_type_compare(payload_type,
 351                                 event->event_class->fields) == 0) {
 352                         bt_put(event->fields_payload);
 353                         bt_get(payload);
 354                         event->fields_payload = payload;
 355                 } else {
 356                         BT_LOGW("Invalid parameter: payload field type is different from the expected field type: "
 357                                 "event-addr=%p, event-class-name=\"%s\", "
 358                                 "event-class-id=%" PRId64,
 359                                 event,
 360                                 bt_ctf_event_class_get_name(event->event_class),
 361                                 bt_ctf_event_class_get_id(event->event_class));
 362                         ret = -1;
 363                 }
 364
 365                 bt_put(payload_type);
 366         }
 367
 368         if (ret) {
 369                 BT_LOGW("Failed to set event's payload field: event-addr=%p, "
 370                         "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
 371                         "payload-field-name=\"%s\", payload-field-addr=%p",
 372                         event, bt_ctf_event_class_get_name(event->event_class),
 373                         bt_ctf_event_class_get_id(event->event_class),
 374                         name, payload);
 375         } else {
 376                 BT_LOGV("Set event's payload field: event-addr=%p, "
 377                         "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
 378                         "payload-field-name=\"%s\", payload-field-addr=%p",
 379                         event, bt_ctf_event_class_get_name(event->event_class),
 380                         bt_ctf_event_class_get_id(event->event_class),
 381                         name, payload);
 382         }
 383
 384 end:
 385         return ret;
 386 }
 387
 388 struct bt_ctf_field *bt_ctf_event_get_event_payload(struct bt_ctf_event *event)
 389 {
 390         struct bt_ctf_field *payload = NULL;
 391
 392         if (!event) {
 393                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 394                 goto end;
 395         }
 396
 397         if (!event->fields_payload) {
 398                 BT_LOGV("Event has no current payload field: addr=%p, "
 399                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 400                         event, bt_ctf_event_class_get_name(event->event_class),
 401                         bt_ctf_event_class_get_id(event->event_class));
 402                 goto end;
 403         }
 404
 405         payload = event->fields_payload;
 406         bt_get(payload);
 407 end:
 408         return payload;
 409 }
 410
 411 int bt_ctf_event_set_event_payload(struct bt_ctf_event *event,
 412                 struct bt_ctf_field *payload)
 413 {
 414         return bt_ctf_event_set_payload(event, NULL, payload);
 415 }
 416
 417 struct bt_ctf_field *bt_ctf_event_get_payload(struct bt_ctf_event *event,
 418                 const char *name)
 419 {
 420         struct bt_ctf_field *field = NULL;
 421
 422         if (!event) {
 423                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 424                 goto end;
 425         }
 426
 427         if (name) {
 428                 field = bt_ctf_field_structure_get_field(event->fields_payload,
 429                         name);
 430         } else {
 431                 field = event->fields_payload;
 432                 bt_get(field);
 433         }
 434 end:
 435         return field;
 436 }
 437
 438 struct bt_ctf_field *bt_ctf_event_get_payload_by_index(
 439                 struct bt_ctf_event *event, uint64_t index)
 440 {
 441         struct bt_ctf_field *field = NULL;
 442
 443         if (!event) {
 444                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 445                 goto end;
 446         }
 447
 448         field = bt_ctf_field_structure_get_field_by_index(event->fields_payload,
 449                 index);
 450 end:
 451         return field;
 452 }
 453
 454 struct bt_ctf_field *bt_ctf_event_get_header(
 455                 struct bt_ctf_event *event)
 456 {
 457         struct bt_ctf_field *header = NULL;
 458
 459         if (!event) {
 460                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 461                 goto end;
 462         }
 463
 464         if (!event->event_header) {
 465                 BT_LOGV("Event has no current header field: addr=%p, "
 466                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 467                         event, bt_ctf_event_class_get_name(event->event_class),
 468                         bt_ctf_event_class_get_id(event->event_class));
 469                 goto end;
 470         }
 471
 472         header = event->event_header;
 473         bt_get(header);
 474 end:
 475         return header;
 476 }
 477
 478 int bt_ctf_event_set_header(struct bt_ctf_event *event,
 479                 struct bt_ctf_field *header)
 480 {
 481         int ret = 0;
 482         struct bt_ctf_field_type *field_type = NULL;
 483         struct bt_ctf_stream_class *stream_class = NULL;
 484
 485         if (!event) {
 486                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 487                 ret = -1;
 488                 goto end;
 489         }
 490
 491         if (event->frozen) {
 492                 BT_LOGW("Invalid parameter: event is frozen: addr=%p, "
 493                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 494                         event, bt_ctf_event_class_get_name(event->event_class),
 495                         bt_ctf_event_class_get_id(event->event_class));
 496                 ret = -1;
 497                 goto end;
 498         }
 499
 500         stream_class = (struct bt_ctf_stream_class *) bt_object_get_parent(
 501                         event->event_class);
 502         /*
 503          * Ensure the provided header's type matches the one registered to the
 504          * stream class.
 505          */
 506         if (header) {
 507                 field_type = bt_ctf_field_get_type(header);
 508                 if (bt_ctf_field_type_compare(field_type,
 509                                 stream_class->event_header_type)) {
 510                         BT_LOGW("Invalid parameter: header field type is different from the expected field type: "
 511                                 "event-addr=%p, event-class-name=\"%s\", "
 512                                 "event-class-id=%" PRId64,
 513                                 event,
 514                                 bt_ctf_event_class_get_name(event->event_class),
 515                                 bt_ctf_event_class_get_id(event->event_class));
 516                         ret = -1;
 517                         goto end;
 518                 }
 519         } else {
 520                 if (stream_class->event_header_type) {
 521                         BT_LOGW("Invalid parameter: setting no event header but event header field type is not NULL: "
 522                                 "event-addr=%p, event-class-name=\"%s\", "
 523                                 "event-class-id=%" PRId64 ", "
 524                                 "event-header-ft-addr=%p",
 525                                 event,
 526                                 bt_ctf_event_class_get_name(event->event_class),
 527                                 bt_ctf_event_class_get_id(event->event_class),
 528                                 stream_class->event_header_type);
 529                         ret = -1;
 530                         goto end;
 531                 }
 532         }
 533
 534         bt_put(event->event_header);
 535         event->event_header = bt_get(header);
 536         BT_LOGV("Set event's header field: event-addr=%p, "
 537                 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
 538                 "header-field-addr=%p",
 539                 event, bt_ctf_event_class_get_name(event->event_class),
 540                 bt_ctf_event_class_get_id(event->event_class), header);
 541 end:
 542         bt_put(stream_class);
 543         bt_put(field_type);
 544         return ret;
 545 }
 546
 547 struct bt_ctf_field *bt_ctf_event_get_event_context(
 548                 struct bt_ctf_event *event)
 549 {
 550         struct bt_ctf_field *context = NULL;
 551
 552         if (!event) {
 553                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 554                 goto end;
 555         }
 556
 557         if (!event->context_payload) {
 558                 BT_LOGV("Event has no current context field: addr=%p, "
 559                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 560                         event, bt_ctf_event_class_get_name(event->event_class),
 561                         bt_ctf_event_class_get_id(event->event_class));
 562                 goto end;
 563         }
 564
 565         context = event->context_payload;
 566         bt_get(context);
 567 end:
 568         return context;
 569 }
 570
 571 int bt_ctf_event_set_event_context(struct bt_ctf_event *event,
 572                 struct bt_ctf_field *context)
 573 {
 574         int ret = 0;
 575         struct bt_ctf_field_type *field_type = NULL;
 576
 577         if (!event) {
 578                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 579                 ret = -1;
 580                 goto end;
 581         }
 582
 583         if (event->frozen) {
 584                 BT_LOGW("Invalid parameter: event is frozen: addr=%p, "
 585                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 586                         event, bt_ctf_event_class_get_name(event->event_class),
 587                         bt_ctf_event_class_get_id(event->event_class));
 588                 ret = -1;
 589                 goto end;
 590         }
 591
 592         if (context) {
 593                 field_type = bt_ctf_field_get_type(context);
 594
 595                 if (bt_ctf_field_type_compare(field_type,
 596                                 event->event_class->context)) {
 597                         BT_LOGW("Invalid parameter: context field type is different from the expected field type: "
 598                                 "event-addr=%p, event-class-name=\"%s\", "
 599                                 "event-class-id=%" PRId64,
 600                                 event,
 601                                 bt_ctf_event_class_get_name(event->event_class),
 602                                 bt_ctf_event_class_get_id(event->event_class));
 603                         ret = -1;
 604                         goto end;
 605                 }
 606         } else {
 607                 if (event->event_class->context) {
 608                         BT_LOGW("Invalid parameter: setting no event context but event context field type is not NULL: "
 609                                 "event-addr=%p, event-class-name=\"%s\", "
 610                                 "event-class-id=%" PRId64 ", "
 611                                 "event-context-ft-addr=%p",
 612                                 event,
 613                                 bt_ctf_event_class_get_name(event->event_class),
 614                                 bt_ctf_event_class_get_id(event->event_class),
 615                                 event->event_class->context);
 616                         ret = -1;
 617                         goto end;
 618                 }
 619         }
 620
 621         bt_put(event->context_payload);
 622         event->context_payload = bt_get(context);
 623         BT_LOGV("Set event's context field: event-addr=%p, "
 624                 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
 625                 "context-field-addr=%p",
 626                 event, bt_ctf_event_class_get_name(event->event_class),
 627                 bt_ctf_event_class_get_id(event->event_class), context);
 628 end:
 629         bt_put(field_type);
 630         return ret;
 631 }
 632
 633 struct bt_ctf_field *bt_ctf_event_get_stream_event_context(
 634                 struct bt_ctf_event *event)
 635 {
 636         struct bt_ctf_field *stream_event_context = NULL;
 637
 638         if (!event) {
 639                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 640                 goto end;
 641         }
 642
 643         if (!event->stream_event_context) {
 644                 BT_LOGV("Event has no current stream event context field: addr=%p, "
 645                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 646                         event, bt_ctf_event_class_get_name(event->event_class),
 647                         bt_ctf_event_class_get_id(event->event_class));
 648                 goto end;
 649         }
 650
 651         stream_event_context = event->stream_event_context;
 652 end:
 653         return bt_get(stream_event_context);
 654 }
 655
 656 int bt_ctf_event_set_stream_event_context(struct bt_ctf_event *event,
 657                 struct bt_ctf_field *stream_event_context)
 658 {
 659         int ret = 0;
 660         struct bt_ctf_field_type *field_type = NULL;
 661         struct bt_ctf_stream_class *stream_class = NULL;
 662
 663         if (!event) {
 664                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 665                 ret = -1;
 666                 goto end;
 667         }
 668
 669         if (event->frozen) {
 670                 BT_LOGW("Invalid parameter: event is frozen: addr=%p, "
 671                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 672                         event, bt_ctf_event_class_get_name(event->event_class),
 673                         bt_ctf_event_class_get_id(event->event_class));
 674                 ret = -1;
 675                 goto end;
 676         }
 677
 678         stream_class = bt_ctf_event_class_get_stream_class(event->event_class);
 679         /*
 680          * We should not have been able to create the event without associating
 681          * the event class to a stream class.
 682          */
 683         assert(stream_class);
 684
 685         if (stream_event_context) {
 686                 field_type = bt_ctf_field_get_type(stream_event_context);
 687                 if (bt_ctf_field_type_compare(field_type,
 688                                 stream_class->event_context_type)) {
 689                         BT_LOGW("Invalid parameter: stream event context field type is different from the expected field type: "
 690                                 "event-addr=%p, event-class-name=\"%s\", "
 691                                 "event-class-id=%" PRId64,
 692                                 event,
 693                                 bt_ctf_event_class_get_name(event->event_class),
 694                                 bt_ctf_event_class_get_id(event->event_class));
 695                         ret = -1;
 696                         goto end;
 697                 }
 698         } else {
 699                 if (stream_class->event_context_type) {
 700                         BT_LOGW("Invalid parameter: setting no stream event context but stream event context field type is not NULL: "
 701                                 "event-addr=%p, event-class-name=\"%s\", "
 702                                 "event-class-id=%" PRId64 ", "
 703                                 "stream-event-context-ft-addr=%p",
 704                                 event,
 705                                 bt_ctf_event_class_get_name(event->event_class),
 706                                 bt_ctf_event_class_get_id(event->event_class),
 707                                 stream_class->event_context_type);
 708                         ret = -1;
 709                         goto end;
 710                 }
 711         }
 712
 713         bt_get(stream_event_context);
 714         BT_MOVE(event->stream_event_context, stream_event_context);
 715         BT_LOGV("Set event's stream event context field: event-addr=%p, "
 716                 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
 717                 "stream-event-context-field-addr=%p",
 718                 event, bt_ctf_event_class_get_name(event->event_class),
 719                 bt_ctf_event_class_get_id(event->event_class),
 720                 stream_event_context);
 721 end:
 722         BT_PUT(stream_class);
 723         bt_put(field_type);
 724         return ret;
 725 }
 726
 727 /* Pre-2.0 CTF writer backward compatibility */
 728 void bt_ctf_event_get(struct bt_ctf_event *event)
 729 {
 730         bt_get(event);
 731 }
 732
 733 /* Pre-2.0 CTF writer backward compatibility */
 734 void bt_ctf_event_put(struct bt_ctf_event *event)
 735 {
 736         bt_put(event);
 737 }
 738
 739 void bt_ctf_event_destroy(struct bt_object *obj)
 740 {
 741         struct bt_ctf_event *event;
 742
 743         event = container_of(obj, struct bt_ctf_event, base);
 744         BT_LOGD("Destroying event: addr=%p, "
 745                 "event-class-name=\"%s\", event-class-id=%" PRId64,
 746                 event, bt_ctf_event_class_get_name(event->event_class),
 747                 bt_ctf_event_class_get_id(event->event_class));
 748
 749         if (!event->base.parent) {
 750                 /*
 751                  * Event was keeping a reference to its class since it shared no
 752                  * common ancestor with it to guarantee they would both have the
 753                  * same lifetime.
 754                  */
 755                 bt_put(event->event_class);
 756         }
 757         g_hash_table_destroy(event->clock_values);
 758         BT_LOGD_STR("Putting event's header field.");
 759         bt_put(event->event_header);
 760         BT_LOGD_STR("Putting event's stream event context field.");
 761         bt_put(event->stream_event_context);
 762         BT_LOGD_STR("Putting event's context field.");
 763         bt_put(event->context_payload);
 764         BT_LOGD_STR("Putting event's payload field.");
 765         bt_put(event->fields_payload);
 766         BT_LOGD_STR("Putting event's packet.");
 767         bt_put(event->packet);
 768         g_free(event);
 769 }
 770
 771 struct bt_ctf_clock_value *bt_ctf_event_get_clock_value(
 772                 struct bt_ctf_event *event, struct bt_ctf_clock_class *clock_class)
 773 {
 774         struct bt_ctf_clock_value *clock_value = NULL;
 775
 776         if (!event || !clock_class) {
 777                 BT_LOGW("Invalid parameter: event or clock class is NULL: "
 778                         "event-addr=%p, clock-class-addr=%p",
 779                         event, clock_class);
 780                 goto end;
 781         }
 782
 783         clock_value = g_hash_table_lookup(event->clock_values, clock_class);
 784         if (!clock_value) {
 785                 BT_LOGV("No clock value associated to the given clock class: "
 786                         "event-addr=%p, event-class-name=\"%s\", "
 787                         "event-class-id=%" PRId64 ", clock-class-addr=%p, "
 788                         "clock-class-name=\"%s\"", event,
 789                         bt_ctf_event_class_get_name(event->event_class),
 790                         bt_ctf_event_class_get_id(event->event_class),
 791                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 792                 goto end;
 793         }
 794
 795         bt_get(clock_value);
 796 end:
 797         return clock_value;
 798 }
 799
 800 int bt_ctf_event_set_clock_value(struct bt_ctf_event *event,
 801                 struct bt_ctf_clock_value *value)
 802 {
 803         int ret = 0;
 804         struct bt_ctf_trace *trace;
 805         struct bt_ctf_stream_class *stream_class;
 806         struct bt_ctf_event_class *event_class;
 807         struct bt_ctf_clock_class *clock_class = NULL;
 808
 809         if (!event || !value) {
 810                 BT_LOGW("Invalid parameter: event or clock value is NULL: "
 811                         "event-addr=%p, clock-value-addr=%p",
 812                         event, value);
 813                 ret = -1;
 814                 goto end;
 815         }
 816
 817         if (event->frozen) {
 818                 BT_LOGW("Invalid parameter: event is frozen: addr=%p, "
 819                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 820                         event, bt_ctf_event_class_get_name(event->event_class),
 821                         bt_ctf_event_class_get_id(event->event_class));
 822                 ret = -1;
 823                 goto end;
 824         }
 825
 826         clock_class = bt_ctf_clock_value_get_class(value);
 827         event_class = bt_ctf_event_borrow_event_class(event);
 828         assert(event_class);
 829         stream_class = bt_ctf_event_class_borrow_stream_class(event_class);
 830         assert(stream_class);
 831         trace = bt_ctf_stream_class_borrow_trace(stream_class);
 832         assert(trace);
 833
 834         if (!bt_ctf_trace_has_clock_class(trace, clock_class)) {
 835                 BT_LOGW("Invalid parameter: clock class is not part of event's trace: "
 836                         "event-addr=%p, event-class-name=\"%s\", "
 837                         "event-class-id=%" PRId64 ", clock-class-addr=%p, "
 838                         "clock-class-name=\"%s\"",
 839                         event, bt_ctf_event_class_get_name(event->event_class),
 840                         bt_ctf_event_class_get_id(event->event_class),
 841                         clock_class, bt_ctf_clock_class_get_name(clock_class));
 842                 ret = -1;
 843                 goto end;
 844         }
 845
 846         g_hash_table_insert(event->clock_values, clock_class, bt_get(value));
 847         BT_LOGV("Set event's clock value: "
 848                 "event-addr=%p, event-class-name=\"%s\", "
 849                 "event-class-id=%" PRId64 ", clock-class-addr=%p, "
 850                 "clock-class-name=\"%s\", clock-value-addr=%p, "
 851                 "clock-value-cycles=%" PRIu64,
 852                 event, bt_ctf_event_class_get_name(event->event_class),
 853                 bt_ctf_event_class_get_id(event->event_class),
 854                 clock_class, bt_ctf_clock_class_get_name(clock_class),
 855                 value, value->value);
 856         clock_class = NULL;
 857
 858 end:
 859         bt_put(clock_class);
 860         return ret;
 861 }
 862
 863 BT_HIDDEN
 864 int bt_ctf_event_validate(struct bt_ctf_event *event)
 865 {
 866         /* Make sure each field's payload has been set */
 867         int ret;
 868         struct bt_ctf_stream_class *stream_class = NULL;
 869
 870         assert(event);
 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         stream_class = bt_ctf_event_class_get_stream_class(event->event_class);
 882         /*
 883          * We should not have been able to create the event without associating
 884          * the event class to a stream class.
 885          */
 886         assert(stream_class);
 887         if (stream_class->event_context_type) {
 888                 ret = bt_ctf_field_validate(event->stream_event_context);
 889                 if (ret) {
 890                         BT_LOGD("Invalid event's stream event context field: "
 891                                 "event-addr=%p, event-class-name=\"%s\", "
 892                                 "event-class-id=%" PRId64,
 893                                 event,
 894                                 bt_ctf_event_class_get_name(event->event_class),
 895                                 bt_ctf_event_class_get_id(event->event_class));
 896                         goto end;
 897                 }
 898         }
 899
 900         ret = bt_ctf_field_validate(event->fields_payload);
 901         if (ret) {
 902                 BT_LOGD("Invalid event's payload field: "
 903                         "event-addr=%p, event-class-name=\"%s\", "
 904                         "event-class-id=%" PRId64,
 905                         event,
 906                         bt_ctf_event_class_get_name(event->event_class),
 907                         bt_ctf_event_class_get_id(event->event_class));
 908                 goto end;
 909         }
 910
 911         if (event->event_class->context) {
 912                 BT_LOGD("Invalid event's context field: "
 913                         "event-addr=%p, event-class-name=\"%s\", "
 914                         "event-class-id=%" PRId64,
 915                         event,
 916                         bt_ctf_event_class_get_name(event->event_class),
 917                         bt_ctf_event_class_get_id(event->event_class));
 918                 ret = bt_ctf_field_validate(event->context_payload);
 919         }
 920 end:
 921         bt_put(stream_class);
 922         return ret;
 923 }
 924
 925 BT_HIDDEN
 926 int bt_ctf_event_serialize(struct bt_ctf_event *event,
 927                 struct bt_ctf_stream_pos *pos,
 928                 enum bt_ctf_byte_order native_byte_order)
 929 {
 930         int ret = 0;
 931
 932         assert(event);
 933         assert(pos);
 934
 935         BT_LOGV_STR("Serializing event's context field.");
 936         if (event->context_payload) {
 937                 ret = bt_ctf_field_serialize(event->context_payload, pos,
 938                         native_byte_order);
 939                 if (ret) {
 940                         BT_LOGW("Cannot serialize event's context field: "
 941                                 "event-addr=%p, event-class-name=\"%s\", "
 942                                 "event-class-id=%" PRId64,
 943                                 event,
 944                                 bt_ctf_event_class_get_name(event->event_class),
 945                                 bt_ctf_event_class_get_id(event->event_class));
 946                         goto end;
 947                 }
 948         }
 949
 950         BT_LOGV_STR("Serializing event's payload field.");
 951         if (event->fields_payload) {
 952                 ret = bt_ctf_field_serialize(event->fields_payload, pos,
 953                         native_byte_order);
 954                 if (ret) {
 955                         BT_LOGW("Cannot serialize event's payload field: "
 956                                 "event-addr=%p, event-class-name=\"%s\", "
 957                                 "event-class-id=%" PRId64,
 958                                 event,
 959                                 bt_ctf_event_class_get_name(event->event_class),
 960                                 bt_ctf_event_class_get_id(event->event_class));
 961                         goto end;
 962                 }
 963         }
 964 end:
 965         return ret;
 966 }
 967
 968 struct bt_ctf_packet *bt_ctf_event_get_packet(struct bt_ctf_event *event)
 969 {
 970         struct bt_ctf_packet *packet = NULL;
 971
 972         if (!event) {
 973                 BT_LOGW_STR("Invalid parameter: event is NULL.");
 974                 goto end;
 975         }
 976
 977         if (!event->packet) {
 978                 BT_LOGV("Event has no current packet: addr=%p, "
 979                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 980                         event, bt_ctf_event_class_get_name(event->event_class),
 981                         bt_ctf_event_class_get_id(event->event_class));
 982                 goto end;
 983         }
 984
 985         packet = bt_get(event->packet);
 986 end:
 987         return packet;
 988 }
 989
 990 int bt_ctf_event_set_packet(struct bt_ctf_event *event,
 991                 struct bt_ctf_packet *packet)
 992 {
 993         struct bt_ctf_stream_class *event_stream_class = NULL;
 994         struct bt_ctf_stream_class *packet_stream_class = NULL;
 995         struct bt_ctf_stream *stream = NULL;
 996         int ret = 0;
 997
 998         if (!event || !packet) {
 999                 BT_LOGW("Invalid parameter: event or packet is NULL: "
1000                         "event-addr=%p, packet-addr=%p",
1001                         event, packet);
1002                 ret = -1;
1003                 goto end;
1004         }
1005
1006         if (event->frozen) {
1007                 BT_LOGW("Invalid parameter: event is frozen: addr=%p, "
1008                         "event-class-name=\"%s\", event-class-id=%" PRId64,
1009                         event, bt_ctf_event_class_get_name(event->event_class),
1010                         bt_ctf_event_class_get_id(event->event_class));
1011                 ret = -1;
1012                 goto end;
1013         }
1014
1015         /*
1016          * Make sure the new packet was created by this event's
1017          * stream, if it is set.
1018          */
1019         stream = bt_ctf_event_get_stream(event);
1020         if (stream) {
1021                 if (packet->stream != stream) {
1022                         BT_LOGW("Invalid parameter: packet's stream and event's stream differ: "
1023                                 "event-addr=%p, event-class-name=\"%s\", "
1024                                 "event-class-id=%" PRId64 ", packet-stream-addr=%p, "
1025                                 "event-stream-addr=%p",
1026                                 event, bt_ctf_event_class_get_name(event->event_class),
1027                                 bt_ctf_event_class_get_id(event->event_class),
1028                                 packet->stream, stream);
1029                         ret = -1;
1030                         goto end;
1031                 }
1032         } else {
1033                 event_stream_class =
1034                         bt_ctf_event_class_get_stream_class(event->event_class);
1035                 packet_stream_class =
1036                         bt_ctf_stream_get_class(packet->stream);
1037
1038                 assert(event_stream_class);
1039                 assert(packet_stream_class);
1040
1041                 if (event_stream_class != packet_stream_class) {
1042                         BT_LOGW("Invalid parameter: packet's stream class and event's stream class differ: "
1043                                 "event-addr=%p, event-class-name=\"%s\", "
1044                                 "event-class-id=%" PRId64 ", packet-stream-class-addr=%p, "
1045                                 "event-stream-class-addr=%p",
1046                                 event, bt_ctf_event_class_get_name(event->event_class),
1047                                 bt_ctf_event_class_get_id(event->event_class),
1048                                 packet_stream_class, event_stream_class);
1049                         ret = -1;
1050                         goto end;
1051                 }
1052         }
1053
1054         bt_get(packet);
1055         BT_MOVE(event->packet, packet);
1056         BT_LOGV("Set event's packet: event-addr=%p, "
1057                 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
1058                 "packet-addr=%p",
1059                 event, bt_ctf_event_class_get_name(event->event_class),
1060                 bt_ctf_event_class_get_id(event->event_class), packet);
1061
1062 end:
1063         BT_PUT(stream);
1064         BT_PUT(event_stream_class);
1065         BT_PUT(packet_stream_class);
1066
1067         return ret;
1068 }
1069
1070 BT_HIDDEN
1071 void bt_ctf_event_freeze(struct bt_ctf_event *event)
1072 {
1073         assert(event);
1074
1075         if (event->frozen) {
1076                 return;
1077         }
1078
1079         BT_LOGD("Freezing event: addr=%p, "
1080                 "event-class-name=\"%s\", event-class-id=%" PRId64,
1081                 event, bt_ctf_event_class_get_name(event->event_class),
1082                 bt_ctf_event_class_get_id(event->event_class));
1083         bt_ctf_packet_freeze(event->packet);
1084         BT_LOGD_STR("Freezing event's header field.");
1085         bt_ctf_field_freeze(event->event_header);
1086         BT_LOGD_STR("Freezing event's stream event context field.");
1087         bt_ctf_field_freeze(event->stream_event_context);
1088         BT_LOGD_STR("Freezing event's context field.");
1089         bt_ctf_field_freeze(event->context_payload);
1090         BT_LOGD_STR("Freezing event's payload field.");
1091         bt_ctf_field_freeze(event->fields_payload);
1092         event->frozen = 1;
1093 }