lib/ctf-ir/event.c

   1 /*
   2  * event.c
   3  *
   4  * Babeltrace CTF IR - Event
   5  *
   6  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  *
   8  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  */
  28
  29 #define BT_LOG_TAG "EVENT"
  30 #include <babeltrace/lib-logging-internal.h>
  31
  32 #include <babeltrace/assert-pre-internal.h>
  33 #include <babeltrace/ctf-ir/fields-internal.h>
  34 #include <babeltrace/ctf-ir/field-types-internal.h>
  35 #include <babeltrace/ctf-ir/clock-class.h>
  36 #include <babeltrace/ctf-ir/clock-value.h>
  37 #include <babeltrace/ctf-ir/clock-value-internal.h>
  38 #include <babeltrace/ctf-ir/clock-class-internal.h>
  39 #include <babeltrace/ctf-ir/event-internal.h>
  40 #include <babeltrace/ctf-ir/event-class.h>
  41 #include <babeltrace/ctf-ir/event-class-internal.h>
  42 #include <babeltrace/ctf-ir/stream-class.h>
  43 #include <babeltrace/ctf-ir/stream-class-internal.h>
  44 #include <babeltrace/ctf-ir/stream-internal.h>
  45 #include <babeltrace/ctf-ir/packet.h>
  46 #include <babeltrace/ctf-ir/packet-internal.h>
  47 #include <babeltrace/ctf-ir/trace.h>
  48 #include <babeltrace/ctf-ir/trace-internal.h>
  49 #include <babeltrace/ctf-ir/packet-internal.h>
  50 #include <babeltrace/ref.h>
  51 #include <babeltrace/ctf-ir/attributes-internal.h>
  52 #include <babeltrace/compiler-internal.h>
  53 #include <babeltrace/assert-internal.h>
  54 #include <inttypes.h>
  55
  56 BT_HIDDEN
  57 void _bt_event_set_is_frozen(struct bt_event *event, bool is_frozen)
  58 {
  59         BT_ASSERT(event);
  60         BT_LIB_LOGD("Setting event's frozen state: %!+e, is-frozen=%d",
  61                 event, is_frozen);
  62
  63         if (event->header_field) {
  64                 BT_LOGD_STR("Setting event's header field's frozen state.");
  65                 bt_field_set_is_frozen(
  66                         event->header_field->field, is_frozen);
  67         }
  68
  69         if (event->common_context_field) {
  70                 BT_LOGD_STR("Setting event's common context field's frozen state.");
  71                 bt_field_set_is_frozen(
  72                         event->common_context_field, is_frozen);
  73         }
  74
  75         if (event->specific_context_field) {
  76                 BT_LOGD_STR("Setting event's specific context field's frozen state.");
  77                 bt_field_set_is_frozen(event->specific_context_field,
  78                         is_frozen);
  79         }
  80
  81         if (event->payload_field) {
  82                 BT_LOGD_STR("Setting event's payload field's frozen state.");
  83                 bt_field_set_is_frozen(event->payload_field,
  84                         is_frozen);
  85         }
  86
  87         event->frozen = is_frozen;
  88         BT_LOGD_STR("Setting event's packet's frozen state.");
  89         bt_packet_set_is_frozen(event->packet, is_frozen);
  90 }
  91
  92 static
  93 void recycle_event_header_field(struct bt_field_wrapper *field_wrapper,
  94                 struct bt_stream_class *stream_class)
  95 {
  96         BT_ASSERT(field_wrapper);
  97         BT_LIB_LOGD("Recycling event header field: "
  98                 "addr=%p, %![sc-]+S, %![field-]+f", field_wrapper,
  99                 stream_class, field_wrapper->field);
 100         bt_object_pool_recycle_object(
 101                 &stream_class->event_header_field_pool,
 102                 field_wrapper);
 103 }
 104
 105 static inline
 106 struct bt_field_wrapper *create_event_header_field(
 107                 struct bt_stream_class *stream_class)
 108 {
 109         struct bt_field_wrapper *field_wrapper = NULL;
 110
 111         field_wrapper = bt_field_wrapper_create(
 112                 &stream_class->event_header_field_pool,
 113                 bt_stream_class_borrow_event_header_field_type(stream_class));
 114         if (!field_wrapper) {
 115                 goto error;
 116         }
 117
 118         goto end;
 119
 120 error:
 121         if (field_wrapper) {
 122                 recycle_event_header_field(field_wrapper, stream_class);
 123                 field_wrapper = NULL;
 124         }
 125
 126 end:
 127         return field_wrapper;
 128 }
 129
 130 BT_HIDDEN
 131 struct bt_event *bt_event_new(struct bt_event_class *event_class)
 132 {
 133         struct bt_event *event = NULL;
 134         struct bt_stream_class *stream_class;
 135         struct bt_field_type *ft;
 136
 137         BT_ASSERT(event_class);
 138         event = g_new0(struct bt_event, 1);
 139         if (!event) {
 140                 BT_LOGE_STR("Failed to allocate one event.");
 141                 goto error;
 142         }
 143
 144         bt_object_init_unique(&event->base);
 145         stream_class = bt_event_class_borrow_stream_class(event_class);
 146         BT_ASSERT(stream_class);
 147
 148         if (bt_stream_class_borrow_event_header_field_type(stream_class)) {
 149                 event->header_field = create_event_header_field(stream_class);
 150                 if (!event->header_field) {
 151                         BT_LOGE_STR("Cannot create event header field.");
 152                         goto error;
 153                 }
 154         }
 155
 156         ft = bt_stream_class_borrow_event_common_context_field_type(
 157                 stream_class);
 158         if (ft) {
 159                 event->common_context_field = bt_field_create(ft);
 160                 if (!event->common_context_field) {
 161                         /* bt_field_create() logs errors */
 162                         goto error;
 163                 }
 164         }
 165
 166         ft = bt_event_class_borrow_specific_context_field_type(event_class);
 167         if (ft) {
 168                 event->specific_context_field = bt_field_create(ft);
 169                 if (!event->specific_context_field) {
 170                         /* bt_field_create() logs errors */
 171                         goto error;
 172                 }
 173         }
 174
 175         ft = bt_event_class_borrow_payload_field_type(event_class);
 176         if (ft) {
 177                 event->payload_field = bt_field_create(ft);
 178                 if (!event->payload_field) {
 179                         /* bt_field_create() logs errors */
 180                         goto error;
 181                 }
 182         }
 183
 184         if (stream_class->default_clock_class) {
 185                 event->default_cv = bt_clock_value_create(
 186                         stream_class->default_clock_class);
 187                 if (!event->default_cv) {
 188                         /* bt_clock_value_create() logs errors */
 189                         goto error;
 190                 }
 191         }
 192
 193         goto end;
 194
 195 error:
 196         if (event) {
 197                 bt_event_destroy(event);
 198                 event = NULL;
 199         }
 200
 201 end:
 202         return event;
 203 }
 204
 205 struct bt_event_class *bt_event_borrow_class(struct bt_event *event)
 206 {
 207         BT_ASSERT_PRE_NON_NULL(event, "Event");
 208         return event->class;
 209 }
 210
 211 struct bt_stream *bt_event_borrow_stream(struct bt_event *event)
 212 {
 213         BT_ASSERT_PRE_NON_NULL(event, "Event");
 214         return event->packet ? event->packet->stream : NULL;
 215 }
 216
 217 struct bt_field *bt_event_borrow_header_field(struct bt_event *event)
 218 {
 219         BT_ASSERT_PRE_NON_NULL(event, "Event");
 220         return event->header_field ? event->header_field->field : NULL;
 221 }
 222
 223 struct bt_field *bt_event_borrow_common_context_field(struct bt_event *event)
 224 {
 225         BT_ASSERT_PRE_NON_NULL(event, "Event");
 226         return event->common_context_field;
 227 }
 228
 229 struct bt_field *bt_event_borrow_specific_context_field(struct bt_event *event)
 230 {
 231         BT_ASSERT_PRE_NON_NULL(event, "Event");
 232         return event->specific_context_field;
 233 }
 234
 235 struct bt_field *bt_event_borrow_payload_field(struct bt_event *event)
 236 {
 237         BT_ASSERT_PRE_NON_NULL(event, "Event");
 238         return event->payload_field;
 239 }
 240
 241 static
 242 void release_event_header_field(struct bt_field_wrapper *field_wrapper,
 243                 struct bt_event *event)
 244 {
 245         if (!event->class) {
 246                 bt_field_wrapper_destroy(field_wrapper);
 247         } else {
 248                 struct bt_stream_class *stream_class =
 249                         bt_event_class_borrow_stream_class(event->class);
 250
 251                 BT_ASSERT(stream_class);
 252                 recycle_event_header_field(field_wrapper, stream_class);
 253         }
 254 }
 255
 256 BT_HIDDEN
 257 void bt_event_destroy(struct bt_event *event)
 258 {
 259         BT_ASSERT(event);
 260         BT_LIB_LOGD("Destroying event: %!+e", event);
 261
 262         if (event->header_field) {
 263                 BT_LOGD_STR("Releasing event's header field.");
 264                 release_event_header_field(event->header_field, event);
 265         }
 266
 267         if (event->common_context_field) {
 268                 BT_LOGD_STR("Destroying event's stream event context field.");
 269                 bt_field_destroy(event->common_context_field);
 270         }
 271
 272         if (event->specific_context_field) {
 273                 BT_LOGD_STR("Destroying event's context field.");
 274                 bt_field_destroy(event->specific_context_field);
 275         }
 276
 277         if (event->payload_field) {
 278                 BT_LOGD_STR("Destroying event's payload field.");
 279                 bt_field_destroy(event->payload_field);
 280         }
 281
 282         BT_LOGD_STR("Putting event's class.");
 283         bt_put(event->class);
 284
 285         if (event->default_cv) {
 286                 bt_clock_value_recycle(event->default_cv);
 287         }
 288
 289         BT_LOGD_STR("Putting event's packet.");
 290         bt_put(event->packet);
 291         g_free(event);
 292 }
 293
 294 int bt_event_set_default_clock_value(struct bt_event *event,
 295                 uint64_t value_cycles)
 296 {
 297         struct bt_stream_class *sc;
 298
 299         BT_ASSERT_PRE_NON_NULL(event, "Event");
 300         BT_ASSERT_PRE_EVENT_HOT(event);
 301         sc = bt_event_class_borrow_stream_class_inline(event->class);
 302         BT_ASSERT(sc);
 303         BT_ASSERT_PRE(sc->default_clock_class,
 304                 "Event's stream class has no default clock class: "
 305                 "%![ev-]+e, %![sc-]+S", event, sc);
 306         BT_ASSERT(event->default_cv);
 307         bt_clock_value_set_value_inline(event->default_cv, value_cycles);
 308         BT_LIB_LOGV("Set event's default clock value: %![event-]+e, "
 309                 "value=%" PRIu64, event, value_cycles);
 310         return 0;
 311 }
 312
 313 enum bt_clock_value_status bt_event_borrow_default_clock_value(
 314                 struct bt_event *event, struct bt_clock_value **clock_value)
 315 {
 316         BT_ASSERT_PRE_NON_NULL(event, "Event");
 317         BT_ASSERT_PRE_NON_NULL(clock_value, "Clock value (output)");
 318         *clock_value = event->default_cv;
 319         return BT_CLOCK_VALUE_STATUS_KNOWN;
 320 }
 321
 322 struct bt_packet *bt_event_borrow_packet(struct bt_event *event)
 323 {
 324         BT_ASSERT_PRE_NON_NULL(event, "Event");
 325         return event->packet;
 326 }
 327
 328 int bt_event_move_header(struct bt_event *event,
 329                 struct bt_event_header_field *header_field)
 330 {
 331         struct bt_stream_class *stream_class;
 332         struct bt_field_wrapper *field_wrapper = (void *) header_field;
 333
 334         BT_ASSERT_PRE_NON_NULL(event, "Event");
 335         BT_ASSERT_PRE_NON_NULL(field_wrapper, "Header field");
 336         BT_ASSERT_PRE_EVENT_HOT(event);
 337         stream_class = bt_event_class_borrow_stream_class_inline(event->class);
 338         BT_ASSERT_PRE(stream_class->event_header_ft,
 339                 "Stream class has no event header field type: %!+S",
 340                 stream_class);
 341
 342         /* Recycle current header field: always exists */
 343         BT_ASSERT(event->header_field);
 344         recycle_event_header_field(event->header_field, stream_class);
 345
 346         /* Move new field */
 347         event->header_field = field_wrapper;
 348         return 0;
 349 }