include/babeltrace/ctf-ir/event-internal.h

   1 #ifndef BABELTRACE_CTF_IR_EVENT_INTERNAL_H
   2 #define BABELTRACE_CTF_IR_EVENT_INTERNAL_H
   3
   4 /*
   5  * Babeltrace - CTF IR: Event internal
   6  *
   7  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   8  *
   9  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
  10  *
  11  * Permission is hereby granted, free of charge, to any person obtaining a copy
  12  * of this software and associated documentation files (the "Software"), to deal
  13  * in the Software without restriction, including without limitation the rights
  14  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  15  * copies of the Software, and to permit persons to whom the Software is
  16  * furnished to do so, subject to the following conditions:
  17  *
  18  * The above copyright notice and this permission notice shall be included in
  19  * all copies or substantial portions of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  24  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  25  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  26  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  27  * SOFTWARE.
  28  */
  29
  30 #include <babeltrace/assert-pre-internal.h>
  31 #include <babeltrace/babeltrace-internal.h>
  32 #include <babeltrace/values.h>
  33 #include <babeltrace/ctf-ir/stream-class.h>
  34 #include <babeltrace/ctf-ir/stream.h>
  35 #include <babeltrace/ctf-ir/stream-internal.h>
  36 #include <babeltrace/ctf-ir/packet.h>
  37 #include <babeltrace/ctf-ir/packet-internal.h>
  38 #include <babeltrace/ctf-ir/fields.h>
  39 #include <babeltrace/ctf-ir/fields-internal.h>
  40 #include <babeltrace/ctf-ir/event-class-internal.h>
  41 #include <babeltrace/ctf-ir/clock-value-set-internal.h>
  42 #include <babeltrace/ctf-ir/field-wrapper-internal.h>
  43 #include <babeltrace/ctf-ir/validation-internal.h>
  44 #include <babeltrace/object-internal.h>
  45 #include <babeltrace/assert-internal.h>
  46 #include <glib.h>
  47
  48 struct bt_stream_pos;
  49
  50 struct bt_event_common {
  51         struct bt_object base;
  52         struct bt_event_class_common *class;
  53         struct bt_field_wrapper *header_field;
  54         struct bt_field_common *stream_event_context_field;
  55         struct bt_field_common *context_field;
  56         struct bt_field_common *payload_field;
  57         int frozen;
  58 };
  59
  60 struct bt_event {
  61         struct bt_event_common common;
  62         struct bt_clock_value_set cv_set;
  63         struct bt_packet *packet;
  64 };
  65
  66 BT_HIDDEN
  67 int _bt_event_common_validate(struct bt_event_common *event);
  68
  69 BT_HIDDEN
  70 void _bt_event_common_set_is_frozen(struct bt_event_common *event,
  71                 bool is_frozen);
  72
  73 BT_HIDDEN
  74 void _bt_event_set_is_frozen(struct bt_event *event, bool is_frozen);
  75
  76 #ifdef BT_DEV_MODE
  77 # define bt_event_common_validate       _bt_event_common_validate
  78 # define bt_event_common_set_is_frozen  _bt_event_common_set_is_frozen
  79 # define bt_event_set_is_frozen         _bt_event_set_is_frozen
  80 #else
  81 # define bt_event_common_validate(_event)                       0
  82 # define bt_event_common_set_is_frozen(_event, _is_frozen)
  83 # define bt_event_set_is_frozen(_event, _is_frozen)
  84 #endif
  85
  86 #define BT_ASSERT_PRE_EVENT_COMMON_HOT(_event, _name)                   \
  87         BT_ASSERT_PRE_HOT((_event), (_name), ": %!+_e", (_event))
  88
  89 static inline
  90 struct bt_event_class_common *bt_event_common_borrow_class(
  91                 struct bt_event_common *event)
  92 {
  93         BT_ASSERT(event);
  94         return event->class;
  95 }
  96
  97 typedef void *(*create_field_func)(void *);
  98 typedef void (*release_field_func)(void *);
  99 typedef void *(*create_header_field_func)(void *, void *);
 100 typedef void (*release_header_field_func)(void *, void *);
 101
 102 BT_HIDDEN
 103 int bt_event_common_initialize(struct bt_event_common *event,
 104                 struct bt_event_class_common *event_class,
 105                 struct bt_clock_class *init_expected_clock_class,
 106                 bool is_shared_with_parent, bt_object_release_func release_func,
 107                 bt_validation_flag_copy_field_type_func field_type_copy_func,
 108                 bool must_be_in_trace,
 109                 int (*map_clock_classes_func)(struct bt_stream_class_common *stream_class,
 110                         struct bt_field_type_common *packet_context_field_type,
 111                         struct bt_field_type_common *event_header_field_type),
 112                 create_field_func create_field_func,
 113                 release_field_func release_field_func,
 114                 create_header_field_func create_header_field_func,
 115                 release_header_field_func release_header_field_func);
 116
 117 static inline
 118 struct bt_field_common *bt_event_common_borrow_payload(
 119                 struct bt_event_common *event)
 120 {
 121         struct bt_field_common *payload = NULL;
 122
 123         BT_ASSERT_PRE_NON_NULL(event, "Event");
 124
 125         if (!event->payload_field) {
 126                 BT_LOGV("Event has no current payload field: addr=%p, "
 127                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 128                         event, bt_event_class_common_get_name(event->class),
 129                         bt_event_class_common_get_id(event->class));
 130                 goto end;
 131         }
 132
 133         payload = event->payload_field;
 134
 135 end:
 136         return payload;
 137 }
 138
 139 static inline
 140 struct bt_field_common *bt_event_common_borrow_header(
 141                 struct bt_event_common *event)
 142 {
 143         struct bt_field_common *header = NULL;
 144
 145         BT_ASSERT_PRE_NON_NULL(event, "Event");
 146
 147         if (!event->header_field) {
 148                 BT_LOGV("Event has no current header field: addr=%p, "
 149                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 150                         event, bt_event_class_common_get_name(event->class),
 151                         bt_event_class_common_get_id(event->class));
 152                 goto end;
 153         }
 154
 155         header = event->header_field->field;
 156
 157 end:
 158         return header;
 159 }
 160
 161 static inline
 162 struct bt_field_common *bt_event_common_borrow_context(
 163                 struct bt_event_common *event)
 164 {
 165         struct bt_field_common *context = NULL;
 166
 167         BT_ASSERT_PRE_NON_NULL(event, "Event");
 168
 169         if (!event->context_field) {
 170                 BT_LOGV("Event has no current context field: addr=%p, "
 171                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 172                         event, bt_event_class_common_get_name(event->class),
 173                         bt_event_class_common_get_id(event->class));
 174                 goto end;
 175         }
 176
 177         context = event->context_field;
 178
 179 end:
 180         return context;
 181 }
 182
 183 static inline
 184 struct bt_field_common *bt_event_common_borrow_stream_event_context(
 185                 struct bt_event_common *event)
 186 {
 187         struct bt_field_common *stream_event_context = NULL;
 188
 189         BT_ASSERT_PRE_NON_NULL(event, "Event");
 190
 191         if (!event->stream_event_context_field) {
 192                 BT_LOGV("Event has no current stream event context field: addr=%p, "
 193                         "event-class-name=\"%s\", event-class-id=%" PRId64,
 194                         event, bt_event_class_common_get_name(event->class),
 195                         bt_event_class_common_get_id(event->class));
 196                 goto end;
 197         }
 198
 199         stream_event_context = event->stream_event_context_field;
 200
 201 end:
 202         return stream_event_context;
 203 }
 204
 205 static inline
 206 void bt_event_common_finalize(struct bt_object *obj,
 207                 void (*field_release_func)(void *),
 208                 void (*header_field_release_func)(void *, struct bt_event_common *))
 209 {
 210         struct bt_event_common *event = (void *) obj;
 211
 212         BT_LOGD("Destroying event: addr=%p, "
 213                 "event-class-name=\"%s\", event-class-id=%" PRId64,
 214                 event,
 215                 event->class ? bt_event_class_common_get_name(event->class) : NULL,
 216                 event->class ? bt_event_class_common_get_id(event->class) : INT64_C(-1));
 217
 218         if (event->header_field) {
 219                 BT_LOGD_STR("Releasing event's header field.");
 220                 header_field_release_func(event->header_field, event);
 221         }
 222
 223         if (event->stream_event_context_field) {
 224                 BT_LOGD_STR("Releasing event's stream event context field.");
 225                 field_release_func(event->stream_event_context_field);
 226         }
 227
 228         if (event->context_field) {
 229                 BT_LOGD_STR("Releasing event's context field.");
 230                 field_release_func(event->context_field);
 231         }
 232
 233         if (event->payload_field) {
 234                 BT_LOGD_STR("Releasing event's payload field.");
 235                 field_release_func(event->payload_field);
 236         }
 237
 238         /*
 239          * Leave this after calling header_field_release_func() because
 240          * this function receives the event object and could need its
 241          * class to perform some cleanup.
 242          */
 243         if (!event->base.parent) {
 244                 /*
 245                  * Event was keeping a reference to its class since it shared no
 246                  * common ancestor with it to guarantee they would both have the
 247                  * same lifetime.
 248                  */
 249                 bt_put(event->class);
 250         }
 251 }
 252
 253 BT_UNUSED
 254 static inline
 255 void _bt_event_reset_dev_mode(struct bt_event *event)
 256 {
 257         BT_ASSERT(event);
 258
 259         if (event->common.header_field) {
 260                 bt_field_common_set_is_frozen_recursive(
 261                         event->common.header_field->field, false);
 262                 bt_field_common_reset_recursive(
 263                         event->common.header_field->field);
 264         }
 265
 266         if (event->common.stream_event_context_field) {
 267                 bt_field_common_set_is_frozen_recursive(
 268                         event->common.stream_event_context_field, false);
 269                 bt_field_common_reset_recursive(
 270                         event->common.stream_event_context_field);
 271         }
 272
 273         if (event->common.context_field) {
 274                 bt_field_common_set_is_frozen_recursive(
 275                         event->common.context_field, false);
 276                 bt_field_common_reset_recursive(event->common.context_field);
 277         }
 278
 279         if (event->common.payload_field) {
 280                 bt_field_common_set_is_frozen_recursive(
 281                         event->common.payload_field, false);
 282                 bt_field_common_reset_recursive(event->common.payload_field);
 283         }
 284 }
 285
 286 #ifdef BT_DEV_MODE
 287 # define bt_event_reset_dev_mode        _bt_event_reset_dev_mode
 288 #else
 289 # define bt_event_reset_dev_mode(_x)
 290 #endif
 291
 292 BT_HIDDEN
 293 void bt_event_destroy(struct bt_event *event);
 294
 295 static inline
 296 void bt_event_reset(struct bt_event *event)
 297 {
 298         BT_ASSERT(event);
 299         bt_event_set_is_frozen(event, false);
 300         bt_clock_value_set_reset(&event->cv_set);
 301         bt_object_put_no_null_check(&event->packet->base);
 302         event->packet = NULL;
 303 }
 304
 305 static inline
 306 void bt_event_recycle(struct bt_event *event)
 307 {
 308         struct bt_event_class *event_class;
 309
 310         BT_ASSERT(event);
 311         BT_LIB_LOGD("Recycling event: %!+e", event);
 312
 313         /*
 314          * Those are the important ordered steps:
 315          *
 316          * 1. Reset the event object (put any permanent reference it
 317          *    has, unfreeze it and its fields in developer mode, etc.),
 318          *    but do NOT put its class's reference. This event class
 319          *    contains the pool to which we're about to recycle this
 320          *    event object, so we must guarantee its existence thanks
 321          *    to this existing reference.
 322          *
 323          * 2. Move the event class reference to our `event_class`
 324          *    variable so that we can set the event's class member
 325          *    to NULL before recycling it. We CANNOT do this after
 326          *    we put the event class reference because this bt_put()
 327          *    could destroy the event class, also destroying its
 328          *    event pool, thus also destroying our event object (this
 329          *    would result in an invalid write access).
 330          *
 331          * 3. Recycle the event object.
 332          *
 333          * 4. Put our event class reference.
 334          */
 335         bt_event_reset(event);
 336         event_class = BT_FROM_COMMON(event->common.class);
 337         BT_ASSERT(event_class);
 338         event->common.class = NULL;
 339         bt_object_pool_recycle_object(&event_class->event_pool, event);
 340         bt_object_put_no_null_check(&event_class->common.base);
 341 }
 342
 343 static inline
 344 void bt_event_set_packet(struct bt_event *event, struct bt_packet *packet)
 345 {
 346         BT_ASSERT_PRE_NON_NULL(event, "Event");
 347         BT_ASSERT_PRE_NON_NULL(packet, "Packet");
 348         BT_ASSERT_PRE_EVENT_COMMON_HOT(BT_TO_COMMON(event), "Event");
 349         BT_ASSERT_PRE(bt_event_class_borrow_stream_class(
 350                 BT_FROM_COMMON(event->common.class)) ==
 351                 BT_FROM_COMMON(packet->stream->common.stream_class),
 352                 "Packet's stream class and event's stream class differ: "
 353                 "%![event-]+e, %![packet-]+a",
 354                 event, packet);
 355
 356         BT_ASSERT(!event->packet);
 357         event->packet = packet;
 358         bt_object_get_no_null_check_no_parent_check(&event->packet->base);
 359         BT_LOGV("Set event's packet: event-addr=%p, "
 360                 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
 361                 "packet-addr=%p",
 362                 event, bt_event_class_common_get_name(event->common.class),
 363                 bt_event_class_common_get_id(event->common.class), packet);
 364 }
 365
 366 static inline
 367 struct bt_event *bt_event_create(struct bt_event_class *event_class,
 368                 struct bt_packet *packet)
 369 {
 370         struct bt_event *event = NULL;
 371
 372         BT_ASSERT(event_class);
 373         event = bt_object_pool_create_object(&event_class->event_pool);
 374         if (unlikely(!event)) {
 375                 BT_LIB_LOGE("Cannot allocate one event from event class's event pool: "
 376                         "%![event-class-]+E", event_class);
 377                 goto end;
 378         }
 379
 380         if (unlikely(!event->common.class)) {
 381                 event->common.class = BT_TO_COMMON(event_class);
 382                 bt_object_get_no_null_check(&event_class->common.base);
 383         }
 384
 385         BT_ASSERT(packet);
 386         bt_event_set_packet(event, packet);
 387         goto end;
 388
 389 end:
 390         return event;
 391 }
 392
 393 BT_HIDDEN
 394 struct bt_event *bt_event_new(struct bt_event_class *event_class);
 395
 396 #endif /* BABELTRACE_CTF_IR_EVENT_INTERNAL_H */