src/ctf-writer/event.c

   1 /*
   2  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   3  * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy
   6  * of this software and associated documentation files (the "Software"), to deal
   7  * in the Software without restriction, including without limitation the rights
   8  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9  * copies of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  */
  23
  24 #define BT_LOG_TAG "CTF-WRITER/EVENT"
  25 #include "logging.h"
  26
  27 #include <inttypes.h>
  28
  29 #include <babeltrace2-ctf-writer/event.h>
  30 #include <babeltrace2-ctf-writer/fields.h>
  31 #include <babeltrace2-ctf-writer/field-types.h>
  32 #include <babeltrace2-ctf-writer/object.h>
  33 #include <babeltrace2-ctf-writer/stream-class.h>
  34 #include <babeltrace2-ctf-writer/trace.h>
  35 #include <babeltrace2-ctf-writer/utils.h>
  36
  37 #include "common/assert.h"
  38 #include "compat/compiler.h"
  39
  40 #include "assert-pre.h"
  41 #include "attributes.h"
  42 #include "clock-class.h"
  43 #include "clock.h"
  44 #include "event-class.h"
  45 #include "event.h"
  46 #include "fields.h"
  47 #include "field-types.h"
  48 #include "stream-class.h"
  49 #include "stream.h"
  50 #include "trace.h"
  51 #include "validation.h"
  52
  53 static
  54 int bt_ctf_event_common_validate_types_for_create(
  55                 struct bt_ctf_event_class_common *event_class,
  56                 struct bt_ctf_validation_output *validation_output,
  57                 bt_ctf_validation_flag_copy_field_type_func copy_field_type_func)
  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_trace_common *trace = NULL;
  64         struct bt_ctf_stream_class_common *stream_class = NULL;
  65         struct bt_ctf_field_type_common *packet_header_type = NULL;
  66         struct bt_ctf_field_type_common *packet_context_type = NULL;
  67         struct bt_ctf_field_type_common *event_header_type = NULL;
  68         struct bt_ctf_field_type_common *stream_event_ctx_type = NULL;
  69         struct bt_ctf_field_type_common *event_context_type = NULL;
  70         struct bt_ctf_field_type_common *event_payload_type = NULL;
  71         int trace_valid = 0;
  72         struct bt_ctf_private_value *environment = NULL;
  73
  74         stream_class = bt_ctf_event_class_common_borrow_stream_class(event_class);
  75         BT_ASSERT_DBG(stream_class);
  76         trace = bt_ctf_stream_class_common_borrow_trace(stream_class);
  77         if (trace) {
  78                 BT_LOGD_STR("Event class is part of a trace.");
  79                 packet_header_type =
  80                         bt_ctf_trace_common_borrow_packet_header_field_type(trace);
  81                 trace_valid = trace->valid;
  82                 BT_ASSERT_DBG(trace_valid);
  83                 environment = trace->environment;
  84         }
  85
  86         packet_context_type =
  87                 bt_ctf_stream_class_common_borrow_packet_context_field_type(
  88                         stream_class);
  89         event_header_type =
  90                 bt_ctf_stream_class_common_borrow_event_header_field_type(
  91                         stream_class);
  92         stream_event_ctx_type =
  93                 bt_ctf_stream_class_common_borrow_event_context_field_type(
  94                         stream_class);
  95         event_context_type =
  96                 bt_ctf_event_class_common_borrow_context_field_type(event_class);
  97         event_payload_type =
  98                 bt_ctf_event_class_common_borrow_payload_field_type(event_class);
  99         ret = bt_ctf_validate_class_types(environment, packet_header_type,
 100                 packet_context_type, event_header_type, stream_event_ctx_type,
 101                 event_context_type, event_payload_type, trace_valid,
 102                 stream_class->valid, event_class->valid,
 103                 validation_output, validation_flags, copy_field_type_func);
 104         if (ret) {
 105                 /*
 106                  * This means something went wrong during the validation
 107                  * process, not that the objects are invalid.
 108                  */
 109                 BT_LOGE("Failed to validate event and parents: ret=%d", ret);
 110                 goto error;
 111         }
 112
 113         if ((validation_output->valid_flags & validation_flags) !=
 114                         validation_flags) {
 115                 /* Invalid trace/stream class/event class */
 116                 BT_LOGW("Invalid trace, stream class, or event class: "
 117                         "valid-flags=0x%x", validation_output->valid_flags);
 118                 goto error;
 119         }
 120
 121         goto end;
 122
 123 error:
 124         bt_ctf_validation_output_put_types(validation_output);
 125         ret = -1;
 126
 127 end:
 128         return ret;
 129 }
 130
 131 static
 132 int bt_ctf_event_common_create_fields(
 133                 struct bt_ctf_stream_class_common *stream_class,
 134                 struct bt_ctf_validation_output *validation_output,
 135                 create_field_func create_field_func,
 136                 release_field_func release_field_func,
 137                 create_header_field_func create_header_field_func,
 138                 release_header_field_func release_header_field_func,
 139                 struct bt_ctf_field_wrapper **header_field,
 140                 struct bt_ctf_field_common **stream_event_context_field,
 141                 struct bt_ctf_field_common **context_field,
 142                 struct bt_ctf_field_common **payload_field)
 143 {
 144         int ret = 0;
 145
 146         if (validation_output->event_header_type) {
 147                 BT_LOGD("Creating initial event header field: ft-addr=%p",
 148                         validation_output->event_header_type);
 149                 *header_field =
 150                         create_header_field_func(stream_class,
 151                                 validation_output->event_header_type);
 152                 if (!*header_field) {
 153                         BT_LOGE_STR("Cannot create initial event header field object.");
 154                         goto error;
 155                 }
 156         }
 157
 158         if (validation_output->stream_event_ctx_type) {
 159                 BT_LOGD("Creating initial stream event context field: ft-addr=%p",
 160                         validation_output->stream_event_ctx_type);
 161                 *stream_event_context_field = create_field_func(
 162                         validation_output->stream_event_ctx_type);
 163                 if (!*stream_event_context_field) {
 164                         BT_LOGE_STR("Cannot create initial stream event context field object.");
 165                         goto error;
 166                 }
 167         }
 168
 169         if (validation_output->event_context_type) {
 170                 BT_LOGD("Creating initial event context field: ft-addr=%p",
 171                         validation_output->event_context_type);
 172                 *context_field = create_field_func(
 173                         validation_output->event_context_type);
 174                 if (!*context_field) {
 175                         BT_LOGE_STR("Cannot create initial event context field object.");
 176                         goto error;
 177                 }
 178         }
 179
 180         if (validation_output->event_payload_type) {
 181                 BT_LOGD("Creating initial event payload field: ft-addr=%p",
 182                         validation_output->event_payload_type);
 183                 *payload_field = create_field_func(
 184                         validation_output->event_payload_type);
 185                 if (!*payload_field) {
 186                         BT_LOGE_STR("Cannot create initial event payload field object.");
 187                         goto error;
 188                 }
 189         }
 190
 191         goto end;
 192
 193 error:
 194         if (*header_field) {
 195                 release_header_field_func(*header_field, stream_class);
 196         }
 197
 198         if (*stream_event_context_field) {
 199                 release_field_func(*stream_event_context_field);
 200         }
 201
 202         if (*context_field) {
 203                 release_field_func(*context_field);
 204         }
 205
 206         if (*payload_field) {
 207                 release_field_func(*payload_field);
 208         }
 209
 210         ret = -1;
 211
 212 end:
 213         return ret;
 214 }
 215
 216 BT_HIDDEN
 217 int _bt_ctf_event_common_validate(struct bt_ctf_event_common *event)
 218 {
 219         int ret = 0;
 220         struct bt_ctf_stream_class_common *stream_class;
 221
 222         BT_ASSERT_DBG(event);
 223         if (event->header_field) {
 224                 ret = bt_ctf_field_common_validate_recursive(
 225                         event->header_field->field);
 226                 if (ret) {
 227                         BT_CTF_ASSERT_PRE_MSG("Invalid event's header field: "
 228                                 "event-addr=%p, field-addr=%p",
 229                                 event, event->header_field->field);
 230                         goto end;
 231                 }
 232         }
 233
 234         stream_class = bt_ctf_event_class_common_borrow_stream_class(event->class);
 235
 236         /*
 237          * We should not have been able to create the event without associating
 238          * the event class to a stream class.
 239          */
 240         BT_ASSERT_DBG(stream_class);
 241
 242         if (stream_class->event_context_field_type) {
 243                 ret = bt_ctf_field_common_validate_recursive(
 244                         event->stream_event_context_field);
 245                 if (ret) {
 246                         BT_CTF_ASSERT_PRE_MSG("Invalid event's stream event context field: "
 247                                 "event-addr=%p, field-addr=%p",
 248                                 event, event->stream_event_context_field);
 249                         goto end;
 250                 }
 251         }
 252
 253         if (event->class->context_field_type) {
 254                 ret = bt_ctf_field_common_validate_recursive(event->context_field);
 255                 if (ret) {
 256                         BT_CTF_ASSERT_PRE_MSG("Invalid event's payload field: "
 257                                 "event-addr=%p, field-addr=%p",
 258                                 event, event->context_field);
 259                         goto end;
 260                 }
 261         }
 262
 263         ret = bt_ctf_field_common_validate_recursive(event->payload_field);
 264         if (ret) {
 265                 BT_CTF_ASSERT_PRE_MSG("Invalid event's payload field: "
 266                         "event-addr=%p, field-addr=%p",
 267                         event, event->payload_field);
 268                 goto end;
 269         }
 270
 271 end:
 272         return ret;
 273 }
 274
 275 BT_HIDDEN
 276 void _bt_ctf_event_common_set_is_frozen(struct bt_ctf_event_common *event,
 277                 bool is_frozen)
 278 {
 279         BT_ASSERT_DBG(event);
 280         BT_LOGD("Freezing event: addr=%p, "
 281                 "event-class-name=\"%s\", event-class-id=%" PRId64,
 282                 event, bt_ctf_event_class_common_get_name(event->class),
 283                 bt_ctf_event_class_common_get_id(event->class));
 284
 285         if (event->header_field) {
 286                 BT_LOGD_STR("Freezing event's header field.");
 287                 bt_ctf_field_common_set_is_frozen_recursive(
 288                         event->header_field->field, is_frozen);
 289         }
 290
 291         if (event->stream_event_context_field) {
 292                 BT_LOGD_STR("Freezing event's stream event context field.");
 293                 bt_ctf_field_common_set_is_frozen_recursive(
 294                         event->stream_event_context_field, is_frozen);
 295         }
 296
 297         if (event->context_field) {
 298                 BT_LOGD_STR("Freezing event's context field.");
 299                 bt_ctf_field_common_set_is_frozen_recursive(event->context_field,
 300                         is_frozen);
 301         }
 302
 303         if (event->payload_field) {
 304                 BT_LOGD_STR("Freezing event's payload field.");
 305                 bt_ctf_field_common_set_is_frozen_recursive(event->payload_field,
 306                         is_frozen);
 307         }
 308
 309         event->frozen = is_frozen;
 310 }
 311
 312 BT_HIDDEN
 313 int bt_ctf_event_common_initialize(struct bt_ctf_event_common *event,
 314                 struct bt_ctf_event_class_common *event_class,
 315                 struct bt_ctf_clock_class *init_expected_clock_class,
 316                 bool is_shared_with_parent, bt_ctf_object_release_func release_func,
 317                 bt_ctf_validation_flag_copy_field_type_func field_type_copy_func,
 318                 bool must_be_in_trace,
 319                 int (*map_clock_classes_func)(struct bt_ctf_stream_class_common *stream_class,
 320                         struct bt_ctf_field_type_common *packet_context_field_type,
 321                         struct bt_ctf_field_type_common *event_header_field_type),
 322                 create_field_func create_field_func,
 323                 release_field_func release_field_func,
 324                 create_header_field_func create_header_field_func,
 325                 release_header_field_func release_header_field_func)
 326 {
 327         int ret;
 328         struct bt_ctf_trace_common *trace = NULL;
 329         struct bt_ctf_stream_class_common *stream_class = NULL;
 330         struct bt_ctf_field_wrapper *event_header = NULL;
 331         struct bt_ctf_field_common *stream_event_context = NULL;
 332         struct bt_ctf_field_common *event_context = NULL;
 333         struct bt_ctf_field_common *event_payload = NULL;
 334         struct bt_ctf_validation_output validation_output = { 0 };
 335         struct bt_ctf_clock_class *expected_clock_class =
 336                 init_expected_clock_class ? bt_ctf_object_get_ref(init_expected_clock_class) :
 337                 NULL;
 338
 339         BT_CTF_ASSERT_PRE_NON_NULL(event_class, "Event class");
 340         BT_LOGD("Initializing common event object: event-class-addr=%p, "
 341                 "event-class-name=\"%s\", event-class-id=%" PRId64,
 342                 event_class, bt_ctf_event_class_common_get_name(event_class),
 343                 bt_ctf_event_class_common_get_id(event_class));
 344
 345         stream_class = bt_ctf_event_class_common_borrow_stream_class(event_class);
 346         BT_CTF_ASSERT_PRE(stream_class,
 347                 "Event class is not part of a stream class: event-class-addr=%p",
 348                 event_class);
 349
 350         /* The event class was frozen when added to its stream class */
 351         BT_ASSERT_DBG(event_class->frozen);
 352         trace = bt_ctf_stream_class_common_borrow_trace(stream_class);
 353
 354         if (must_be_in_trace) {
 355                 BT_CTF_ASSERT_PRE(trace,
 356                         "Event class's stream class is not part of a trace: "
 357                         "ec-addr=%p, sc-addr=%p", event_class, stream_class);
 358         }
 359
 360         /*
 361          * This must be called before anything that can fail because on
 362          * failure, the caller releases the reference to `event` to
 363          * destroy it.
 364          */
 365         if (is_shared_with_parent) {
 366                 bt_ctf_object_init_shared_with_parent(&event->base, release_func);
 367         } else {
 368                 bt_ctf_object_init_unique(&event->base);
 369         }
 370
 371         if (!stream_class->frozen) {
 372                 /*
 373                  * Because this function freezes the stream class,
 374                  * validate that this stream class contains at most a
 375                  * single clock class so that we set its expected clock
 376                  * class for future checks.
 377                  */
 378                 ret = bt_ctf_stream_class_common_validate_single_clock_class(
 379                         stream_class, &expected_clock_class);
 380                 if (ret) {
 381                         BT_LOGW("Event class's stream class or one of its event "
 382                                 "classes contains a field type which is not "
 383                                 "recursively mapped to the expected "
 384                                 "clock class: "
 385                                 "stream-class-addr=%p, "
 386                                 "stream-class-id=%" PRId64 ", "
 387                                 "stream-class-name=\"%s\", "
 388                                 "expected-clock-class-addr=%p, "
 389                                 "expected-clock-class-name=\"%s\"",
 390                                 stream_class,
 391                                 bt_ctf_stream_class_common_get_id(stream_class),
 392                                 bt_ctf_stream_class_common_get_name(stream_class),
 393                                 expected_clock_class,
 394                                 expected_clock_class ?
 395                                         bt_ctf_clock_class_get_name(expected_clock_class) :
 396                                         NULL);
 397                         goto error;
 398                 }
 399         }
 400
 401         /* Validate the trace, the stream class, and the event class */
 402         ret = bt_ctf_event_common_validate_types_for_create(
 403                 event_class, &validation_output, field_type_copy_func);
 404         if (ret) {
 405                 /* bt_ctf_event_common_validate_types_for_create() logs errors */
 406                 goto error;
 407         }
 408
 409         if (map_clock_classes_func) {
 410                 /*
 411                  * Safe to automatically map selected fields to the
 412                  * stream's clock's class here because the stream class
 413                  * is about to be frozen.
 414                  */
 415                 if (map_clock_classes_func(stream_class,
 416                                 validation_output.packet_context_type,
 417                                 validation_output.event_header_type)) {
 418                         BT_LOGW_STR("Cannot automatically map selected stream class's "
 419                                 "field types to stream class's clock's class.");
 420                         goto error;
 421                 }
 422         }
 423
 424         /*
 425          * event does not share a common ancestor with the event class; it has
 426          * to guarantee its existence by holding a reference. This reference
 427          * shall be released once the event is associated to a stream since,
 428          * from that point, the event and its class will share the same
 429          * lifetime.
 430          */
 431         event->class = bt_ctf_object_get_ref(event_class);
 432
 433         ret = bt_ctf_event_common_create_fields(stream_class,
 434                 &validation_output,
 435                 create_field_func, release_field_func,
 436                 create_header_field_func, release_header_field_func,
 437                 &event_header, &stream_event_context, &event_context,
 438                 &event_payload);
 439         if (ret) {
 440                 /* bt_ctf_event_common_create_fields() logs errors */
 441                 goto error;
 442         }
 443
 444         /*
 445          * At this point all the fields are created, potentially from
 446          * validated copies of field types, so that the field types and
 447          * fields can be replaced in the trace, stream class,
 448          * event class, and created event.
 449          */
 450         bt_ctf_validation_replace_types(trace, stream_class, event_class,
 451                 &validation_output,
 452                 BT_CTF_VALIDATION_FLAG_STREAM | BT_CTF_VALIDATION_FLAG_EVENT);
 453         event->header_field = event_header;
 454         event_header = NULL;
 455         event->stream_event_context_field = stream_event_context;
 456         stream_event_context = NULL;
 457         event->context_field = event_context;
 458         event_context = NULL;
 459         event->payload_field = event_payload;
 460         event_payload = NULL;
 461
 462         /*
 463          * Put what was not moved in bt_ctf_validation_replace_types().
 464          */
 465         bt_ctf_validation_output_put_types(&validation_output);
 466
 467         /*
 468          * Freeze the stream class since the event header must not be changed
 469          * anymore.
 470          */
 471         bt_ctf_stream_class_common_freeze(stream_class);
 472
 473         /*
 474          * It is safe to set the stream class's unique clock class
 475          * now because the stream class is frozen.
 476          */
 477         if (expected_clock_class) {
 478                 BT_CTF_OBJECT_MOVE_REF(stream_class->clock_class, expected_clock_class);
 479         }
 480
 481         /*
 482          * Mark stream class, and event class as valid since
 483          * they're all frozen now.
 484          */
 485         stream_class->valid = 1;
 486         event_class->valid = 1;
 487
 488         /* Put stuff we borrowed from the event class */
 489         BT_LOGD("Initialized event object: addr=%p, event-class-name=\"%s\", "
 490                 "event-class-id=%" PRId64,
 491                 event, bt_ctf_event_class_common_get_name(event->class),
 492                 bt_ctf_event_class_common_get_id(event->class));
 493         goto end;
 494
 495 error:
 496         bt_ctf_validation_output_put_types(&validation_output);
 497         bt_ctf_object_put_ref(expected_clock_class);
 498
 499         if (event_header) {
 500                 release_header_field_func(event_header, stream_class);
 501         }
 502
 503         if (stream_event_context) {
 504                 release_field_func(stream_event_context);
 505         }
 506
 507         if (event_context) {
 508                 release_field_func(event_context);
 509         }
 510
 511         if (event_payload) {
 512                 release_field_func(event_payload);
 513         }
 514
 515         ret = -1;
 516
 517 end:
 518         return ret;
 519 }
 520
 521 int map_clock_classes_func(struct bt_ctf_stream_class_common *stream_class,
 522                 struct bt_ctf_field_type_common *packet_context_type,
 523                 struct bt_ctf_field_type_common *event_header_type)
 524 {
 525         int ret = bt_ctf_stream_class_map_clock_class(
 526                 BT_CTF_FROM_COMMON(stream_class),
 527                 BT_CTF_FROM_COMMON(packet_context_type),
 528                 BT_CTF_FROM_COMMON(event_header_type));
 529
 530         if (ret) {
 531                 BT_LOGW_STR("Cannot automatically map selected stream class's field types to stream class's clock's class.");
 532         }
 533
 534         return ret;
 535 }
 536
 537 static
 538 void destroy_event_header_field(struct bt_ctf_field_wrapper *field_wrapper,
 539                 struct bt_ctf_stream_class *stream_class)
 540 {
 541         BT_ASSERT_DBG(field_wrapper);
 542         bt_ctf_object_put_ref(field_wrapper->field);
 543         bt_ctf_field_wrapper_destroy(field_wrapper);
 544 }
 545
 546 static
 547 struct bt_ctf_field_wrapper *create_event_header_field(
 548                 struct bt_ctf_stream_class *stream_class,
 549                 struct bt_ctf_field_type_common *ft)
 550 {
 551         struct bt_ctf_field_wrapper *field_wrapper = NULL;
 552         struct bt_ctf_field *field = bt_ctf_field_create((void *) ft);
 553
 554         if (!field) {
 555                 goto error;
 556         }
 557
 558         field_wrapper = bt_ctf_field_wrapper_new(NULL);
 559         if (!field_wrapper) {
 560                 goto error;
 561         }
 562
 563         field_wrapper->field = (void *) field;
 564         field = NULL;
 565         goto end;
 566
 567 error:
 568         bt_ctf_object_put_ref(field);
 569
 570         if (field_wrapper) {
 571                 destroy_event_header_field(field_wrapper, stream_class);
 572                 field_wrapper = NULL;
 573         }
 574
 575 end:
 576         return field_wrapper;
 577 }
 578
 579 static
 580 void release_event_header_field(struct bt_ctf_field_wrapper *field_wrapper,
 581                 struct bt_ctf_event_common *event_common)
 582 {
 583         BT_ASSERT_DBG(field_wrapper);
 584         BT_CTF_OBJECT_PUT_REF_AND_RESET(field_wrapper->field);
 585         bt_ctf_field_wrapper_destroy(field_wrapper);
 586 }
 587
 588 static
 589 void bt_ctf_event_destroy(struct bt_ctf_object *obj)
 590 {
 591         bt_ctf_event_common_finalize(obj, (void *) bt_ctf_object_put_ref,
 592                 (void *) release_event_header_field);
 593         g_free(obj);
 594 }
 595
 596 struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class)
 597 {
 598         int ret;
 599         struct bt_ctf_event *event = NULL;
 600         struct bt_ctf_clock_class *expected_clock_class = NULL;
 601
 602         event = g_new0(struct bt_ctf_event, 1);
 603         if (!event) {
 604                 BT_LOGE_STR("Failed to allocate one CTF writer event.");
 605                 goto error;
 606         }
 607
 608         if (event_class) {
 609                 struct bt_ctf_stream_class *stream_class =
 610                         BT_CTF_FROM_COMMON(bt_ctf_event_class_common_borrow_stream_class(
 611                                 BT_CTF_TO_COMMON(event_class)));
 612
 613                 if (stream_class && stream_class->clock) {
 614                         expected_clock_class = stream_class->clock->clock_class;
 615                 }
 616         }
 617
 618         ret = bt_ctf_event_common_initialize(BT_CTF_TO_COMMON(event),
 619                 BT_CTF_TO_COMMON(event_class), expected_clock_class,
 620                 true, bt_ctf_event_destroy,
 621                 (bt_ctf_validation_flag_copy_field_type_func)
 622                         bt_ctf_field_type_copy,
 623                 false, map_clock_classes_func,
 624                 (create_field_func) bt_ctf_field_create,
 625                 (release_field_func) bt_ctf_object_put_ref,
 626                 (create_header_field_func) create_event_header_field,
 627                 (release_header_field_func) destroy_event_header_field);
 628         if (ret) {
 629                 /* bt_ctf_event_common_initialize() logs errors */
 630                 goto error;
 631         }
 632
 633         goto end;
 634
 635 error:
 636         BT_CTF_OBJECT_PUT_REF_AND_RESET(event);
 637
 638 end:
 639         return event;
 640 }
 641
 642 struct bt_ctf_event_class *bt_ctf_event_get_class(struct bt_ctf_event *event)
 643 {
 644         BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
 645         return bt_ctf_object_get_ref(bt_ctf_event_common_borrow_class(BT_CTF_TO_COMMON(event)));
 646 }
 647
 648 BT_HIDDEN
 649 struct bt_ctf_stream *bt_ctf_event_borrow_stream(struct bt_ctf_event *event)
 650 {
 651         BT_ASSERT_DBG(event);
 652         return (struct bt_ctf_stream *)
 653                 bt_ctf_object_borrow_parent(&BT_CTF_TO_COMMON(event)->base);
 654 }
 655
 656 struct bt_ctf_stream *bt_ctf_event_get_stream(struct bt_ctf_event *event)
 657 {
 658         BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
 659         return bt_ctf_object_get_ref(bt_ctf_event_borrow_stream(event));
 660 }
 661
 662 int bt_ctf_event_set_payload(struct bt_ctf_event *event, const char *name,
 663                 struct bt_ctf_field *field)
 664 {
 665         BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
 666         BT_CTF_ASSERT_PRE_NON_NULL(field, "Payload field");
 667         BT_CTF_ASSERT_PRE_EVENT_COMMON_HOT(BT_CTF_TO_COMMON(event), "Event");
 668         return bt_ctf_field_structure_set_field_by_name(
 669                 (void *) event->common.payload_field, name, field);
 670 }
 671
 672 struct bt_ctf_field *bt_ctf_event_get_payload(struct bt_ctf_event *event,
 673                 const char *name)
 674 {
 675         struct bt_ctf_field *field = NULL;
 676
 677         BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
 678
 679         if (name) {
 680                 field = bt_ctf_field_structure_get_field_by_name(
 681                         BT_CTF_FROM_COMMON(event->common.payload_field), name);
 682         } else {
 683                 field = BT_CTF_FROM_COMMON(event->common.payload_field);
 684                 bt_ctf_object_get_ref(field);
 685         }
 686
 687         return field;
 688 }
 689
 690 struct bt_ctf_field *bt_ctf_event_get_payload_field(
 691                 struct bt_ctf_event *event)
 692 {
 693         return bt_ctf_object_get_ref(bt_ctf_event_common_borrow_payload(BT_CTF_TO_COMMON(event)));
 694 }
 695
 696 struct bt_ctf_field *bt_ctf_event_get_header(struct bt_ctf_event *event)
 697 {
 698         return bt_ctf_object_get_ref(bt_ctf_event_common_borrow_header(BT_CTF_TO_COMMON(event)));
 699 }
 700
 701 struct bt_ctf_field *bt_ctf_event_get_context(struct bt_ctf_event *event)
 702 {
 703         return bt_ctf_object_get_ref(bt_ctf_event_common_borrow_context(BT_CTF_TO_COMMON(event)));
 704 }
 705
 706 struct bt_ctf_field *bt_ctf_event_get_stream_event_context(
 707                 struct bt_ctf_event *event)
 708 {
 709         return bt_ctf_object_get_ref(bt_ctf_event_common_borrow_stream_event_context(
 710                 BT_CTF_TO_COMMON(event)));
 711 }
 712
 713 BT_HIDDEN
 714 int bt_ctf_event_serialize(struct bt_ctf_event *event,
 715                 struct bt_ctfser *ctfser,
 716                 enum bt_ctf_byte_order native_byte_order)
 717 {
 718         int ret = 0;
 719
 720         BT_ASSERT_DBG(event);
 721         BT_ASSERT_DBG(ctfser);
 722
 723         BT_LOGT_STR("Serializing event's context field.");
 724         if (event->common.context_field) {
 725                 ret = bt_ctf_field_serialize_recursive(
 726                         (void *) event->common.context_field, ctfser,
 727                         native_byte_order);
 728                 if (ret) {
 729                         BT_LOGW("Cannot serialize event's context field: "
 730                                 "event-addr=%p, event-class-name=\"%s\", "
 731                                 "event-class-id=%" PRId64,
 732                                 event,
 733                                 bt_ctf_event_class_common_get_name(event->common.class),
 734                                 bt_ctf_event_class_common_get_id(event->common.class));
 735                         goto end;
 736                 }
 737         }
 738
 739         BT_LOGT_STR("Serializing event's payload field.");
 740         if (event->common.payload_field) {
 741                 ret = bt_ctf_field_serialize_recursive(
 742                         (void *) event->common.payload_field, ctfser,
 743                         native_byte_order);
 744                 if (ret) {
 745                         BT_LOGW("Cannot serialize event's payload field: "
 746                                 "event-addr=%p, event-class-name=\"%s\", "
 747                                 "event-class-id=%" PRId64,
 748                                 event,
 749                                 bt_ctf_event_class_common_get_name(event->common.class),
 750                                 bt_ctf_event_class_common_get_id(event->common.class));
 751                         goto end;
 752                 }
 753         }
 754
 755 end:
 756         return ret;
 757 }
 758
 759 BT_HIDDEN
 760 void _bt_ctf_event_freeze(struct bt_ctf_event *event)
 761 {
 762         _bt_ctf_event_common_set_is_frozen(BT_CTF_TO_COMMON(event), true);
 763 }
 764
 765 int bt_ctf_event_set_header(struct bt_ctf_event *event,
 766                 struct bt_ctf_field *header)
 767 {
 768         BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
 769         BT_CTF_ASSERT_PRE_EVENT_COMMON_HOT(BT_CTF_TO_COMMON(event), "Event");
 770
 771         /*
 772          * Ensure the provided header's type matches the one registered to the
 773          * stream class.
 774          */
 775         if (header) {
 776                 BT_CTF_ASSERT_PRE(bt_ctf_field_type_common_compare(
 777                         ((struct bt_ctf_field_common *) header)->type,
 778                         bt_ctf_event_class_common_borrow_stream_class(event->common.class)->event_header_field_type) == 0,
 779                         "Header field's type is different from the "
 780                         "expected field type: event-addr=%p, ft-addr=%p, "
 781                         "expected-ft-addr=%p",
 782                         event, ((struct bt_ctf_field_common *) header)->type,
 783                         bt_ctf_event_class_common_borrow_stream_class(event->common.class)->event_header_field_type);
 784         } else {
 785                 BT_CTF_ASSERT_PRE(!bt_ctf_event_class_common_borrow_stream_class(event->common.class)->event_header_field_type,
 786                         "Setting no event header field, "
 787                         "but event header field type is not NULL: "
 788                         "event-addr=%p, header-ft-addr=%p",
 789                         event,
 790                         bt_ctf_event_class_common_borrow_stream_class(event->common.class)->event_header_field_type);
 791         }
 792
 793         bt_ctf_object_put_ref(event->common.header_field->field);
 794         event->common.header_field->field = bt_ctf_object_get_ref(header);
 795         BT_LOGT("Set event's header field: event-addr=%p, "
 796                 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
 797                 "header-field-addr=%p",
 798                 event, bt_ctf_event_class_common_get_name(event->common.class),
 799                 bt_ctf_event_class_common_get_id(event->common.class), header);
 800         return 0;
 801 }
 802
 803 int bt_ctf_event_common_set_payload(struct bt_ctf_event *event,
 804                 struct bt_ctf_field *payload)
 805 {
 806         BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
 807         BT_CTF_ASSERT_PRE_EVENT_COMMON_HOT(BT_CTF_TO_COMMON(event), "Event");
 808
 809         if (payload) {
 810                 BT_CTF_ASSERT_PRE(bt_ctf_field_type_common_compare(
 811                         ((struct bt_ctf_field_common *) payload)->type,
 812                         event->common.class->payload_field_type) == 0,
 813                         "Payload field's type is different from the "
 814                         "expected field type: event-addr=%p, ft-addr=%p, "
 815                         "expected-ft-addr=%p",
 816                         event,
 817                         ((struct bt_ctf_field_common *) payload)->type,
 818                         event->common.class->payload_field_type);
 819         } else {
 820                 BT_CTF_ASSERT_PRE(!event->common.class->payload_field_type,
 821                         "Setting no event payload field, "
 822                         "but event payload field type is not NULL: "
 823                         "event-addr=%p, payload-ft-addr=%p",
 824                         event, event->common.class->payload_field_type);
 825         }
 826
 827         bt_ctf_object_put_ref(event->common.payload_field);
 828         event->common.payload_field = bt_ctf_object_get_ref(payload);
 829         BT_LOGT("Set event's payload field: event-addr=%p, "
 830                 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
 831                 "payload-field-addr=%p",
 832                 event, bt_ctf_event_class_common_get_name(event->common.class),
 833                 bt_ctf_event_class_common_get_id(event->common.class), payload);
 834         return 0;
 835 }
 836
 837 int bt_ctf_event_set_context(struct bt_ctf_event *event,
 838                 struct bt_ctf_field *context)
 839 {
 840         BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
 841         BT_CTF_ASSERT_PRE_EVENT_COMMON_HOT(BT_CTF_TO_COMMON(event), "Event");
 842
 843         if (context) {
 844                 BT_CTF_ASSERT_PRE(bt_ctf_field_type_common_compare(
 845                         ((struct bt_ctf_field_common *) context)->type,
 846                         event->common.class->context_field_type) == 0,
 847                         "Context field's type is different from the "
 848                         "expected field type: event-addr=%p, ft-addr=%p, "
 849                         "expected-ft-addr=%p",
 850                         event, ((struct bt_ctf_field_common *) context)->type,
 851                         event->common.class->context_field_type);
 852         } else {
 853                 BT_CTF_ASSERT_PRE(!event->common.class->context_field_type,
 854                         "Setting no event context field, "
 855                         "but event context field type is not NULL: "
 856                         "event-addr=%p, context-ft-addr=%p",
 857                         event, event->common.class->context_field_type);
 858         }
 859
 860         bt_ctf_object_put_ref(event->common.context_field);
 861         event->common.context_field = bt_ctf_object_get_ref(context);
 862         BT_LOGT("Set event's context field: event-addr=%p, "
 863                 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
 864                 "context-field-addr=%p",
 865                 event, bt_ctf_event_class_common_get_name(event->common.class),
 866                 bt_ctf_event_class_common_get_id(event->common.class), context);
 867         return 0;
 868 }
 869
 870 int bt_ctf_event_set_stream_event_context(struct bt_ctf_event *event,
 871                 struct bt_ctf_field *stream_event_context)
 872 {
 873         BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
 874         BT_CTF_ASSERT_PRE_EVENT_COMMON_HOT(BT_CTF_TO_COMMON(event), "Event");
 875
 876         if (stream_event_context) {
 877                 BT_CTF_ASSERT_PRE(bt_ctf_field_type_common_compare(
 878                         ((struct bt_ctf_field_common *) stream_event_context)->type,
 879                         bt_ctf_event_class_common_borrow_stream_class(event->common.class)->event_context_field_type) == 0,
 880                         "Stream event context field's type is different from the "
 881                         "expected field type: event-addr=%p, ft-addr=%p, "
 882                         "expected-ft-addr=%p",
 883                         event,
 884                         ((struct bt_ctf_field_common *) stream_event_context)->type,
 885                         bt_ctf_event_class_common_borrow_stream_class(event->common.class)->event_context_field_type);
 886         } else {
 887                 BT_CTF_ASSERT_PRE(!bt_ctf_event_class_common_borrow_stream_class(event->common.class)->event_context_field_type,
 888                         "Setting no stream event context field, "
 889                         "but stream event context field type is not NULL: "
 890                         "event-addr=%p, context-ft-addr=%p",
 891                         event,
 892                         bt_ctf_event_class_common_borrow_stream_class(event->common.class)->event_context_field_type);
 893         }
 894
 895         bt_ctf_object_put_ref(event->common.stream_event_context_field);
 896         event->common.stream_event_context_field = bt_ctf_object_get_ref(stream_event_context);
 897         BT_LOGT("Set event's stream event context field: event-addr=%p, "
 898                 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
 899                 "stream-event-context-field-addr=%p",
 900                 event, bt_ctf_event_class_common_get_name(event->common.class),
 901                 bt_ctf_event_class_common_get_id(event->common.class),
 902                 stream_event_context);
 903         return 0;
 904 }