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 BT_HIDDEN
  48 int _bt_ctf_event_common_validate(struct bt_ctf_event_common *event);
  49
  50 BT_HIDDEN
  51 void _bt_ctf_event_common_set_is_frozen(struct bt_ctf_event_common *event,
  52                 bool is_frozen);
  53
  54 #ifdef BT_DEV_MODE
  55 # define bt_ctf_event_common_validate   _bt_ctf_event_common_validate
  56 # define bt_ctf_event_common_set_is_frozen      _bt_ctf_event_common_set_is_frozen
  57 #else
  58 # define bt_ctf_event_common_validate(_event)                   0
  59 # define bt_ctf_event_common_set_is_frozen(_event, _is_frozen)
  60 #endif
  61
  62 #define BT_CTF_ASSERT_PRE_EVENT_COMMON_HOT(_event, _name)                       \
  63         BT_CTF_ASSERT_PRE_HOT((_event), (_name), ": event-addr=%p", (_event))
  64
  65 static inline
  66 struct bt_ctf_event_class_common *bt_ctf_event_common_borrow_class(
  67                 struct bt_ctf_event_common *event)
  68 {
  69         BT_ASSERT_DBG(event);
  70         return event->class;
  71 }
  72
  73 typedef void *(*create_field_func_type)(void *);
  74 typedef void (*release_field_func_type)(void *);
  75 typedef void *(*create_header_field_func_type)(void *, void *);
  76 typedef void (*release_header_field_func_type)(void *, void *);
  77
  78 BT_HIDDEN
  79 int bt_ctf_event_common_initialize(struct bt_ctf_event_common *event,
  80                 struct bt_ctf_event_class_common *event_class,
  81                 struct bt_ctf_clock_class *init_expected_clock_class,
  82                 bool is_shared_with_parent, bt_ctf_object_release_func release_func,
  83                 bt_ctf_validation_flag_copy_field_type_func field_type_copy_func,
  84                 bool must_be_in_trace,
  85                 int (*map_clock_classes_func)(struct bt_ctf_stream_class_common *stream_class,
  86                         struct bt_ctf_field_type_common *packet_context_field_type,
  87                         struct bt_ctf_field_type_common *event_header_field_type),
  88                 create_field_func_type create_field_func,
  89                 release_field_func_type release_field_func,
  90                 create_header_field_func_type create_header_field_func,
  91                 release_header_field_func_type release_header_field_func);
  92
  93 BT_HIDDEN
  94 int bt_ctf_event_common_set_payload(struct bt_ctf_event *event,
  95                 struct bt_ctf_field *payload);
  96
  97 static inline
  98 struct bt_ctf_field_common *bt_ctf_event_common_borrow_payload(
  99                 struct bt_ctf_event_common *event)
 100 {
 101         struct bt_ctf_field_common *payload = NULL;
 102
 103         BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
 104
 105         if (!event->payload_field) {
 106                 BT_LOGT("Event has no current payload field: addr=%p, "
 107                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 108                         event, bt_ctf_event_class_common_get_name(event->class),
 109                         bt_ctf_event_class_common_get_id(event->class));
 110                 goto end;
 111         }
 112
 113         payload = event->payload_field;
 114
 115 end:
 116         return payload;
 117 }
 118
 119 static inline
 120 struct bt_ctf_field_common *bt_ctf_event_common_borrow_header(
 121                 struct bt_ctf_event_common *event)
 122 {
 123         struct bt_ctf_field_common *header = NULL;
 124
 125         BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
 126
 127         if (!event->header_field) {
 128                 BT_LOGT("Event has no current header field: addr=%p, "
 129                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 130                         event, bt_ctf_event_class_common_get_name(event->class),
 131                         bt_ctf_event_class_common_get_id(event->class));
 132                 goto end;
 133         }
 134
 135         header = event->header_field->field;
 136
 137 end:
 138         return header;
 139 }
 140
 141 static inline
 142 struct bt_ctf_field_common *bt_ctf_event_common_borrow_context(
 143                 struct bt_ctf_event_common *event)
 144 {
 145         struct bt_ctf_field_common *context = NULL;
 146
 147         BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
 148
 149         if (!event->context_field) {
 150                 BT_LOGT("Event has no current context field: addr=%p, "
 151                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 152                         event, bt_ctf_event_class_common_get_name(event->class),
 153                         bt_ctf_event_class_common_get_id(event->class));
 154                 goto end;
 155         }
 156
 157         context = event->context_field;
 158
 159 end:
 160         return context;
 161 }
 162
 163 static inline
 164 struct bt_ctf_field_common *bt_ctf_event_common_borrow_stream_event_context(
 165                 struct bt_ctf_event_common *event)
 166 {
 167         struct bt_ctf_field_common *stream_event_context = NULL;
 168
 169         BT_CTF_ASSERT_PRE_NON_NULL(event, "Event");
 170
 171         if (!event->stream_event_context_field) {
 172                 BT_LOGT("Event has no current stream event context field: addr=%p, "
 173                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 174                         event, bt_ctf_event_class_common_get_name(event->class),
 175                         bt_ctf_event_class_common_get_id(event->class));
 176                 goto end;
 177         }
 178
 179         stream_event_context = event->stream_event_context_field;
 180
 181 end:
 182         return stream_event_context;
 183 }
 184
 185 static inline
 186 void bt_ctf_event_common_finalize(struct bt_ctf_object *obj,
 187                 void (*field_release_func)(void *),
 188                 void (*header_field_release_func)(void *, struct bt_ctf_event_common *))
 189 {
 190         struct bt_ctf_event_common *event = (void *) obj;
 191
 192         BT_LOGD("Destroying event: addr=%p, "
 193                 "event-class-name=\"%s\", event-class-id=%" PRId64,
 194                 event,
 195                 event->class ? bt_ctf_event_class_common_get_name(event->class) : NULL,
 196                 event->class ? bt_ctf_event_class_common_get_id(event->class) : INT64_C(-1));
 197
 198         if (event->header_field) {
 199                 BT_LOGD_STR("Releasing event's header field.");
 200                 header_field_release_func(event->header_field, event);
 201         }
 202
 203         if (event->stream_event_context_field) {
 204                 BT_LOGD_STR("Releasing event's stream event context field.");
 205                 field_release_func(event->stream_event_context_field);
 206         }
 207
 208         if (event->context_field) {
 209                 BT_LOGD_STR("Releasing event's context field.");
 210                 field_release_func(event->context_field);
 211         }
 212
 213         if (event->payload_field) {
 214                 BT_LOGD_STR("Releasing event's payload field.");
 215                 field_release_func(event->payload_field);
 216         }
 217
 218         /*
 219          * Leave this after calling header_field_release_func() because
 220          * this function receives the event object and could need its
 221          * class to perform some cleanup.
 222          */
 223         if (!event->base.parent) {
 224                 /*
 225                  * Event was keeping a reference to its class since it shared no
 226                  * common ancestor with it to guarantee they would both have the
 227                  * same lifetime.
 228                  */
 229                 bt_ctf_object_put_ref(event->class);
 230         }
 231 }
 232
 233 struct bt_ctf_event {
 234         struct bt_ctf_event_common common;
 235 };
 236
 237 struct bt_ctf_event_class {
 238         struct bt_ctf_event_class_common common;
 239 };
 240
 241 BT_HIDDEN
 242 int bt_ctf_event_class_serialize(struct bt_ctf_event_class *event_class,
 243                 struct metadata_context *context);
 244
 245 BT_HIDDEN
 246 int bt_ctf_event_serialize(struct bt_ctf_event *event,
 247                 struct bt_ctfser *pos,
 248                 enum bt_ctf_byte_order native_byte_order);
 249
 250 static inline
 251 struct bt_ctf_stream_class *bt_ctf_event_class_borrow_stream_class(
 252                 struct bt_ctf_event_class *event_class)
 253 {
 254         return BT_CTF_FROM_COMMON(bt_ctf_event_class_common_borrow_stream_class(
 255                 BT_CTF_TO_COMMON(event_class)));
 256 }
 257
 258 #endif /* BABELTRACE_CTF_WRITER_EVENT_INTERNAL_H */