src/ctf-writer/event.h

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   5  *
   6  * The Common Trace Format (CTF) Specification is available at
   7  * http://www.efficios.com/ctf
   8  */
   9
  10 #ifndef BABELTRACE_CTF_WRITER_EVENT_INTERNAL_H
  11 #define BABELTRACE_CTF_WRITER_EVENT_INTERNAL_H
  12
  13 #include <stdbool.h>
  14
  15 #include "common/assert.h"
  16 #include "common/macros.h"
  17 #include <babeltrace2-ctf-writer/field-types.h>
  18 #include <babeltrace2-ctf-writer/fields.h>
  19 #include <babeltrace2-ctf-writer/stream-class.h>
  20 #include <babeltrace2-ctf-writer/stream.h>
  21 #include "ctfser/ctfser.h"
  22
  23 #include "assert-pre.h"
  24 #include "event-class.h"
  25 #include "event.h"
  26 #include "fields.h"
  27 #include "field-wrapper.h"
  28 #include "object.h"
  29 #include "stream.h"
  30 #include "validation.h"
  31 #include "values.h"
  32
  33 struct bt_ctf_stream_class;
  34 struct bt_ctf_stream_pos;
  35 struct metadata_context;
  36
  37 struct bt_ctf_event_common {
  38         struct bt_ctf_object base;
  39         struct bt_ctf_event_class_common *class;
  40         struct bt_ctf_field_wrapper *header_field;
  41         struct bt_ctf_field_common *stream_event_context_field;
  42         struct bt_ctf_field_common *context_field;
  43         struct bt_ctf_field_common *payload_field;
  44         int frozen;
  45 };
  46
  47 int _bt_ctf_event_common_validate(struct bt_ctf_event_common *event);
  48
  49 void _bt_ctf_event_common_set_is_frozen(struct bt_ctf_event_common *event,
  50                 bool is_frozen);
  51
  52 #ifdef BT_DEV_MODE
  53 # define bt_ctf_event_common_validate   _bt_ctf_event_common_validate
  54 # define bt_ctf_event_common_set_is_frozen      _bt_ctf_event_common_set_is_frozen
  55 #else
  56 # define bt_ctf_event_common_validate(_event)                   0
  57 # define bt_ctf_event_common_set_is_frozen(_event, _is_frozen)
  58 #endif
  59
  60 #define BT_CTF_ASSERT_PRE_EVENT_COMMON_HOT(_event, _name)                       \
  61         BT_CTF_ASSERT_PRE_HOT((_event), (_name), ": event-addr=%p", (_event))
  62
  63 static inline
  64 struct bt_ctf_event_class_common *bt_ctf_event_common_borrow_class(
  65                 struct bt_ctf_event_common *event)
  66 {
  67         BT_ASSERT_DBG(event);
  68         return event->class;
  69 }
  70
  71 typedef void *(*create_field_func_type)(void *);
  72 typedef void (*release_field_func_type)(void *);
  73 typedef void *(*create_header_field_func_type)(void *, void *);
  74 typedef void (*release_header_field_func_type)(void *, void *);
  75
  76 int bt_ctf_event_common_initialize(struct bt_ctf_event_common *event,
  77                 struct bt_ctf_event_class_common *event_class,
  78                 struct bt_ctf_clock_class *init_expected_clock_class,
  79                 bool is_shared_with_parent, bt_ctf_object_release_func release_func,
  80                 bt_ctf_validation_flag_copy_field_type_func field_type_copy_func,
  81                 bool must_be_in_trace,
  82                 int (*map_clock_classes_func)(struct bt_ctf_stream_class_common *stream_class,
  83                         struct bt_ctf_field_type_common *packet_context_field_type,
  84                         struct bt_ctf_field_type_common *event_header_field_type),
  85                 create_field_func_type create_field_func,
  86                 release_field_func_type release_field_func,
  87                 create_header_field_func_type create_header_field_func,
  88                 release_header_field_func_type release_header_field_func);
  89
  90 int bt_ctf_event_common_set_payload(struct bt_ctf_event *event,
  91                 struct bt_ctf_field *payload);
  92
  93 static inline
  94 struct bt_ctf_field_common *bt_ctf_event_common_borrow_payload(
  95                 struct bt_ctf_event_common *event)
  96 {
  97         struct bt_ctf_field_common *payload = NULL;
  98
  99         BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
 100
 101         if (!event->payload_field) {
 102                 BT_LOGT("Event has no current payload field: addr=%p, "
 103                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 104                         event, bt_ctf_event_class_common_get_name(event->class),
 105                         bt_ctf_event_class_common_get_id(event->class));
 106                 goto end;
 107         }
 108
 109         payload = event->payload_field;
 110
 111 end:
 112         return payload;
 113 }
 114
 115 static inline
 116 struct bt_ctf_field_common *bt_ctf_event_common_borrow_header(
 117                 struct bt_ctf_event_common *event)
 118 {
 119         struct bt_ctf_field_common *header = NULL;
 120
 121         BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
 122
 123         if (!event->header_field) {
 124                 BT_LOGT("Event has no current header field: addr=%p, "
 125                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 126                         event, bt_ctf_event_class_common_get_name(event->class),
 127                         bt_ctf_event_class_common_get_id(event->class));
 128                 goto end;
 129         }
 130
 131         header = event->header_field->field;
 132
 133 end:
 134         return header;
 135 }
 136
 137 static inline
 138 struct bt_ctf_field_common *bt_ctf_event_common_borrow_context(
 139                 struct bt_ctf_event_common *event)
 140 {
 141         struct bt_ctf_field_common *context = NULL;
 142
 143         BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
 144
 145         if (!event->context_field) {
 146                 BT_LOGT("Event has no current context field: addr=%p, "
 147                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 148                         event, bt_ctf_event_class_common_get_name(event->class),
 149                         bt_ctf_event_class_common_get_id(event->class));
 150                 goto end;
 151         }
 152
 153         context = event->context_field;
 154
 155 end:
 156         return context;
 157 }
 158
 159 static inline
 160 struct bt_ctf_field_common *bt_ctf_event_common_borrow_stream_event_context(
 161                 struct bt_ctf_event_common *event)
 162 {
 163         struct bt_ctf_field_common *stream_event_context = NULL;
 164
 165         BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
 166
 167         if (!event->stream_event_context_field) {
 168                 BT_LOGT("Event has no current stream event context field: addr=%p, "
 169                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 170                         event, bt_ctf_event_class_common_get_name(event->class),
 171                         bt_ctf_event_class_common_get_id(event->class));
 172                 goto end;
 173         }
 174
 175         stream_event_context = event->stream_event_context_field;
 176
 177 end:
 178         return stream_event_context;
 179 }
 180
 181 static inline
 182 void bt_ctf_event_common_finalize(struct bt_ctf_object *obj,
 183                 void (*field_release_func)(void *),
 184                 void (*header_field_release_func)(void *, struct bt_ctf_event_common *))
 185 {
 186         struct bt_ctf_event_common *event = (void *) obj;
 187
 188         BT_LOGD("Destroying event: addr=%p, "
 189                 "event-class-name=\"%s\", event-class-id=%" PRId64,
 190                 event,
 191                 event->class ? bt_ctf_event_class_common_get_name(event->class) : NULL,
 192                 event->class ? bt_ctf_event_class_common_get_id(event->class) : INT64_C(-1));
 193
 194         if (event->header_field) {
 195                 BT_LOGD_STR("Releasing event's header field.");
 196                 header_field_release_func(event->header_field, event);
 197         }
 198
 199         if (event->stream_event_context_field) {
 200                 BT_LOGD_STR("Releasing event's stream event context field.");
 201                 field_release_func(event->stream_event_context_field);
 202         }
 203
 204         if (event->context_field) {
 205                 BT_LOGD_STR("Releasing event's context field.");
 206                 field_release_func(event->context_field);
 207         }
 208
 209         if (event->payload_field) {
 210                 BT_LOGD_STR("Releasing event's payload field.");
 211                 field_release_func(event->payload_field);
 212         }
 213
 214         /*
 215          * Leave this after calling header_field_release_func() because
 216          * this function receives the event object and could need its
 217          * class to perform some cleanup.
 218          */
 219         if (!event->base.parent) {
 220                 /*
 221                  * Event was keeping a reference to its class since it shared no
 222                  * common ancestor with it to guarantee they would both have the
 223                  * same lifetime.
 224                  */
 225                 bt_ctf_object_put_ref(event->class);
 226         }
 227 }
 228
 229 struct bt_ctf_event {
 230         struct bt_ctf_event_common common;
 231 };
 232
 233 struct bt_ctf_event_class {
 234         struct bt_ctf_event_class_common common;
 235 };
 236
 237 int bt_ctf_event_class_serialize(struct bt_ctf_event_class *event_class,
 238                 struct metadata_context *context);
 239
 240 int bt_ctf_event_serialize(struct bt_ctf_event *event,
 241                 struct bt_ctfser *pos,
 242                 enum bt_ctf_byte_order native_byte_order);
 243
 244 static inline
 245 struct bt_ctf_stream_class *bt_ctf_event_class_borrow_stream_class(
 246                 struct bt_ctf_event_class *event_class)
 247 {
 248         return BT_CTF_FROM_COMMON(bt_ctf_event_class_common_borrow_stream_class(
 249                 BT_CTF_TO_COMMON(event_class)));
 250 }
 251
 252 #endif /* BABELTRACE_CTF_WRITER_EVENT_INTERNAL_H */