src/lib/trace-ir/event.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
   5  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   6  */
   7
   8 #define BT_LOG_TAG "LIB/EVENT"
   9 #include "lib/logging.h"
  10
  11 #include "lib/assert-cond.h"
  12 #include <babeltrace2/trace-ir/event.h>
  13 #include <babeltrace2/trace-ir/event-class.h>
  14 #include <babeltrace2/trace-ir/stream-class.h>
  15 #include <babeltrace2/trace-ir/packet.h>
  16 #include <babeltrace2/trace-ir/trace.h>
  17 #include "common/assert.h"
  18 #include "compat/compiler.h"
  19 #include <inttypes.h>
  20 #include <stdbool.h>
  21
  22 #include "field.h"
  23 #include "field-class.h"
  24 #include "event.h"
  25 #include "stream-class.h"
  26 #include "stream.h"
  27 #include "packet.h"
  28 #include "trace.h"
  29 #include "packet.h"
  30 #include "attributes.h"
  31 #include "event-class.h"
  32
  33 void _bt_event_set_is_frozen(const struct bt_event *event, bool is_frozen)
  34 {
  35         BT_ASSERT_DBG(event);
  36         BT_LIB_LOGD("Setting event's frozen state: %!+e, is-frozen=%d",
  37                 event, is_frozen);
  38
  39         if (event->common_context_field) {
  40                 BT_LOGD_STR("Setting event's common context field's frozen state.");
  41                 bt_field_set_is_frozen(
  42                         event->common_context_field, is_frozen);
  43         }
  44
  45         if (event->specific_context_field) {
  46                 BT_LOGD_STR("Setting event's specific context field's frozen state.");
  47                 bt_field_set_is_frozen(event->specific_context_field,
  48                         is_frozen);
  49         }
  50
  51         if (event->payload_field) {
  52                 BT_LOGD_STR("Setting event's payload field's frozen state.");
  53                 bt_field_set_is_frozen(event->payload_field,
  54                         is_frozen);
  55         }
  56
  57         ((struct bt_event *) event)->frozen = is_frozen;
  58
  59         if (event->packet) {
  60                 BT_LOGD_STR("Setting event's packet's frozen state.");
  61                 bt_packet_set_is_frozen(event->packet, is_frozen);
  62         }
  63 }
  64
  65 struct bt_event *bt_event_new(struct bt_event_class *event_class)
  66 {
  67         struct bt_event *event = NULL;
  68         struct bt_stream_class *stream_class;
  69         struct bt_field_class *fc;
  70
  71         BT_ASSERT(event_class);
  72         event = g_new0(struct bt_event, 1);
  73         if (!event) {
  74                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one event.");
  75                 goto error;
  76         }
  77
  78         bt_object_init_unique(&event->base);
  79         stream_class = bt_event_class_borrow_stream_class(event_class);
  80         BT_ASSERT(stream_class);
  81         fc = stream_class->event_common_context_fc;
  82         if (fc) {
  83                 event->common_context_field = bt_field_create(fc);
  84                 if (!event->common_context_field) {
  85                         /* bt_field_create() logs errors */
  86                         goto error;
  87                 }
  88         }
  89
  90         fc = event_class->specific_context_fc;
  91         if (fc) {
  92                 event->specific_context_field = bt_field_create(fc);
  93                 if (!event->specific_context_field) {
  94                         /* bt_field_create() logs errors */
  95                         goto error;
  96                 }
  97         }
  98
  99         fc = event_class->payload_fc;
 100         if (fc) {
 101                 event->payload_field = bt_field_create(fc);
 102                 if (!event->payload_field) {
 103                         /* bt_field_create() logs errors */
 104                         goto error;
 105                 }
 106         }
 107
 108         goto end;
 109
 110 error:
 111         if (event) {
 112                 bt_event_destroy(event);
 113                 event = NULL;
 114         }
 115
 116 end:
 117         return event;
 118 }
 119
 120 BT_EXPORT
 121 struct bt_event_class *bt_event_borrow_class(struct bt_event *event)
 122 {
 123         BT_ASSERT_PRE_DEV_EVENT_NON_NULL(event);
 124         return event->class;
 125 }
 126
 127 BT_EXPORT
 128 const struct bt_event_class *bt_event_borrow_class_const(
 129                 const struct bt_event *event)
 130 {
 131         return bt_event_borrow_class((void *) event);
 132 }
 133
 134 BT_EXPORT
 135 struct bt_stream *bt_event_borrow_stream(struct bt_event *event)
 136 {
 137         BT_ASSERT_PRE_DEV_EVENT_NON_NULL(event);
 138         return event->stream;
 139 }
 140
 141 BT_EXPORT
 142 const struct bt_stream *bt_event_borrow_stream_const(
 143                 const struct bt_event *event)
 144 {
 145         return bt_event_borrow_stream((void *) event);
 146 }
 147
 148 BT_EXPORT
 149 struct bt_field *bt_event_borrow_common_context_field(struct bt_event *event)
 150 {
 151         BT_ASSERT_PRE_DEV_EVENT_NON_NULL(event);
 152         return event->common_context_field;
 153 }
 154
 155 BT_EXPORT
 156 const struct bt_field *bt_event_borrow_common_context_field_const(
 157                 const struct bt_event *event)
 158 {
 159         BT_ASSERT_PRE_DEV_EVENT_NON_NULL(event);
 160         return event->common_context_field;
 161 }
 162
 163 BT_EXPORT
 164 struct bt_field *bt_event_borrow_specific_context_field(struct bt_event *event)
 165 {
 166         BT_ASSERT_PRE_DEV_EVENT_NON_NULL(event);
 167         return event->specific_context_field;
 168 }
 169
 170 BT_EXPORT
 171 const struct bt_field *bt_event_borrow_specific_context_field_const(
 172                 const struct bt_event *event)
 173 {
 174         BT_ASSERT_PRE_DEV_EVENT_NON_NULL(event);
 175         return event->specific_context_field;
 176 }
 177
 178 BT_EXPORT
 179 struct bt_field *bt_event_borrow_payload_field(struct bt_event *event)
 180 {
 181         BT_ASSERT_PRE_DEV_EVENT_NON_NULL(event);
 182         return event->payload_field;
 183 }
 184
 185 BT_EXPORT
 186 const struct bt_field *bt_event_borrow_payload_field_const(
 187                 const struct bt_event *event)
 188 {
 189         BT_ASSERT_PRE_DEV_EVENT_NON_NULL(event);
 190         return event->payload_field;
 191 }
 192
 193 void bt_event_destroy(struct bt_event *event)
 194 {
 195         BT_ASSERT(event);
 196         BT_LIB_LOGD("Destroying event: %!+e", event);
 197
 198         if (event->common_context_field) {
 199                 BT_LOGD_STR("Destroying event's stream event context field.");
 200                 bt_field_destroy(event->common_context_field);
 201                 event->common_context_field = NULL;
 202         }
 203
 204         if (event->specific_context_field) {
 205                 BT_LOGD_STR("Destroying event's context field.");
 206                 bt_field_destroy(event->specific_context_field);
 207                 event->specific_context_field = NULL;
 208         }
 209
 210         if (event->payload_field) {
 211                 BT_LOGD_STR("Destroying event's payload field.");
 212                 bt_field_destroy(event->payload_field);
 213                 event->payload_field = NULL;
 214         }
 215
 216         BT_LOGD_STR("Putting event's class.");
 217         bt_object_put_ref(event->class);
 218         BT_LOGD_STR("Putting event's packet.");
 219         BT_OBJECT_PUT_REF_AND_RESET(event->packet);
 220         BT_LOGD_STR("Putting event's stream.");
 221         BT_OBJECT_PUT_REF_AND_RESET(event->stream);
 222         g_free(event);
 223 }
 224
 225 BT_EXPORT
 226 struct bt_packet *bt_event_borrow_packet(struct bt_event *event)
 227 {
 228         BT_ASSERT_PRE_DEV_EVENT_NON_NULL(event);
 229         return event->packet;
 230 }
 231
 232 BT_EXPORT
 233 const struct bt_packet *bt_event_borrow_packet_const(
 234                 const struct bt_event *event)
 235 {
 236         return bt_event_borrow_packet((void *) event);
 237 }