src/lib/graph/message/event.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
   5  * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   6  */
   7
   8 #define BT_LOG_TAG "LIB/MSG-EVENT"
   9 #include "lib/logging.h"
  10
  11 #include "common/assert.h"
  12 #include "lib/assert-cond.h"
  13 #include "compat/compiler.h"
  14 #include "lib/object.h"
  15 #include <babeltrace2/trace-ir/event.h>
  16 #include "lib/trace-ir/event.h"
  17 #include "lib/trace-ir/event-class.h"
  18 #include "lib/trace-ir/stream-class.h"
  19 #include <babeltrace2/trace-ir/trace.h>
  20 #include "lib/trace-ir/clock-snapshot.h"
  21 #include "lib/graph/graph.h"
  22 #include <babeltrace2/graph/message.h>
  23 #include <babeltrace2/types.h>
  24 #include <stdbool.h>
  25 #include <inttypes.h>
  26
  27 #include "event.h"
  28
  29 #define BT_ASSERT_PRE_DEV_MSG_IS_EVENT(_msg)                            \
  30         BT_ASSERT_PRE_DEV_MSG_HAS_TYPE("message", (_msg), "event",      \
  31                 BT_MESSAGE_TYPE_EVENT)
  32
  33 BT_HIDDEN
  34 struct bt_message *bt_message_event_new(
  35                 struct bt_graph *graph)
  36 {
  37         struct bt_message_event *message = NULL;
  38
  39         message = g_new0(struct bt_message_event, 1);
  40         if (!message) {
  41                 BT_LIB_LOGE_APPEND_CAUSE(
  42                         "Failed to allocate one event message.");
  43                 goto error;
  44         }
  45
  46         bt_message_init(&message->parent, BT_MESSAGE_TYPE_EVENT,
  47                 (bt_object_release_func) bt_message_event_recycle, graph);
  48         goto end;
  49
  50 error:
  51         BT_OBJECT_PUT_REF_AND_RESET(message);
  52
  53 end:
  54         return (void *) message;
  55 }
  56
  57 static
  58 struct bt_event *create_event(struct bt_event_class *event_class,
  59                 struct bt_packet *packet, struct bt_stream *stream,
  60                 const char *api_func)
  61 {
  62         struct bt_event *event = NULL;
  63
  64         BT_ASSERT_DBG(event_class);
  65         BT_ASSERT_DBG(stream);
  66         event = bt_object_pool_create_object(&event_class->event_pool);
  67         if (G_UNLIKELY(!event)) {
  68                 BT_LIB_LOGE_APPEND_CAUSE(
  69                         "Cannot allocate one event from event class's event pool: "
  70                         "%![ec-]+E", event_class);
  71                 goto end;
  72         }
  73
  74         if (G_LIKELY(!event->class)) {
  75                 event->class = event_class;
  76                 bt_object_get_ref_no_null_check(&event_class->base);
  77         }
  78
  79         BT_ASSERT_DBG(!event->stream);
  80         event->stream = stream;
  81         bt_object_get_ref_no_null_check_no_parent_check(&event->stream->base);
  82         BT_LIB_LOGD("Set event's stream: %![event-]+e, %![stream-]+s",
  83                 event, stream);
  84
  85         if (packet) {
  86                 BT_ASSERT_PRE_DEV_FROM_FUNC(api_func,
  87                         "packet-stream-class-is-event-class-stream-class",
  88                         bt_event_class_borrow_stream_class(
  89                                 event_class) == packet->stream->class,
  90                         "Packet's stream class and event class's stream class differ: "
  91                         "%![ec-]+E, %![packet-]+a", event, packet);
  92                 BT_ASSERT_DBG(event->stream->class->supports_packets);
  93                 BT_ASSERT_DBG(!event->packet);
  94                 event->packet = packet;
  95                 bt_object_get_ref_no_null_check_no_parent_check(&event->packet->base);
  96                 BT_LIB_LOGD("Set event's packet: %![event-]+e, %![packet-]+a",
  97                         event, packet);
  98         }
  99
 100 end:
 101         return event;
 102 }
 103
 104 static inline
 105 struct bt_message *create_event_message(
 106                 struct bt_self_message_iterator *self_msg_iter,
 107                 const struct bt_event_class *c_event_class,
 108                 const struct bt_packet *c_packet,
 109                 const struct bt_stream *c_stream, bool with_cs,
 110                 uint64_t raw_value, const char *api_func)
 111 {
 112         struct bt_message_iterator *msg_iter =
 113                 (void *) self_msg_iter;
 114         struct bt_message_event *message = NULL;
 115         struct bt_event_class *event_class = (void *) c_event_class;
 116         struct bt_stream_class *stream_class;
 117         struct bt_packet *packet = (void *) c_packet;
 118         struct bt_stream *stream = (void *) c_stream;
 119         struct bt_event *event;
 120
 121         BT_ASSERT_DBG(stream);
 122         BT_ASSERT_PRE_MSG_ITER_NON_NULL_FROM_FUNC(api_func, msg_iter);
 123         BT_ASSERT_PRE_EC_NON_NULL_FROM_FUNC(api_func, event_class);
 124         stream_class = bt_event_class_borrow_stream_class_inline(event_class);
 125         BT_ASSERT_PRE_FROM_FUNC(api_func,
 126                 "stream-class-is-event-class-stream-class",
 127                 bt_event_class_borrow_stream_class(event_class) ==
 128                         stream->class,
 129                 "Stream's class and event's stream class differ: "
 130                 "%![ec-]+E, %![stream-]+s", event_class, stream);
 131         BT_ASSERT_DBG(stream_class);
 132         BT_ASSERT_PRE_FROM_FUNC(api_func,
 133                 "with-default-clock-snapshot-if-stream-class-has-default-clock-class",
 134                 (with_cs && stream_class->default_clock_class) ||
 135                 (!with_cs && !stream_class->default_clock_class),
 136                 "Creating an event message with a default clock snapshot, but without "
 137                 "a default clock class, or without a default clock snapshot, "
 138                 "but with a default clock class: ",
 139                 "%![ec-]+E, %![sc-]+S, with-cs=%d, "
 140                 "cs-val=%" PRIu64,
 141                 event_class, stream_class, with_cs, raw_value);
 142         BT_LIB_LOGD("Creating event message object: %![ec-]+E", event_class);
 143         event = create_event(event_class, packet, stream, api_func);
 144         if (G_UNLIKELY(!event)) {
 145                 BT_LIB_LOGE_APPEND_CAUSE(
 146                         "Cannot create event from event class: "
 147                         "%![ec-]+E", event_class);
 148                 goto error;
 149         }
 150
 151         /*
 152          * Create message from pool _after_ we have everything
 153          * (in this case, a valid event object) so that we never have an
 154          * error condition with a non-NULL message object.
 155          * Otherwise:
 156          *
 157          * * We cannot recycle the message on error because
 158          *   bt_message_event_recycle() expects a complete
 159          *   message (and the event or clock class priority map
 160          *   object could be unset).
 161          *
 162          * * We cannot destroy the message because we would need
 163          *   to notify the graph (pool owner) so that it removes the
 164          *   message from its message array.
 165          */
 166         message = (void *) bt_message_create_from_pool(
 167                 &msg_iter->graph->event_msg_pool, msg_iter->graph);
 168         if (G_UNLIKELY(!message)) {
 169                 /* bt_message_create_from_pool() logs errors */
 170                 goto error;
 171         }
 172
 173         if (with_cs) {
 174                 BT_ASSERT_DBG(stream_class->default_clock_class);
 175                 message->default_cs = bt_clock_snapshot_create(
 176                         stream_class->default_clock_class);
 177                 if (!message->default_cs) {
 178                         goto error;
 179                 }
 180
 181                 bt_clock_snapshot_set_raw_value(message->default_cs, raw_value);
 182         }
 183
 184         BT_ASSERT_DBG(!message->event);
 185         message->event = event;
 186
 187         if (packet) {
 188                 bt_packet_set_is_frozen(packet, true);
 189         }
 190
 191         bt_stream_freeze(stream);
 192         bt_event_class_freeze(event_class);
 193         BT_LIB_LOGD("Created event message object: "
 194                 "%![msg-]+n, %![event-]+e", message, event);
 195         goto end;
 196
 197 error:
 198         BT_ASSERT(!message);
 199         bt_event_destroy(event);
 200
 201 end:
 202         return (void *) message;
 203 }
 204
 205 struct bt_message *bt_message_event_create(
 206                 struct bt_self_message_iterator *msg_iter,
 207                 const struct bt_event_class *event_class,
 208                 const struct bt_stream *stream)
 209 {
 210         BT_ASSERT_PRE_DEV_NO_ERROR();
 211         BT_ASSERT_PRE_STREAM_NON_NULL(stream);
 212         return create_event_message(msg_iter, event_class, NULL, stream,
 213                 false, 0, __func__);
 214 }
 215
 216 struct bt_message *bt_message_event_create_with_packet(
 217                 struct bt_self_message_iterator *msg_iter,
 218                 const struct bt_event_class *event_class,
 219                 const struct bt_packet *packet)
 220 {
 221         BT_ASSERT_PRE_DEV_NO_ERROR();
 222         BT_ASSERT_PRE_PACKET_NON_NULL(packet);
 223         return create_event_message(msg_iter, event_class, packet,
 224                 packet->stream, false, 0, __func__);
 225 }
 226
 227 struct bt_message *bt_message_event_create_with_default_clock_snapshot(
 228                 struct bt_self_message_iterator *msg_iter,
 229                 const struct bt_event_class *event_class,
 230                 const struct bt_stream *stream,
 231                 uint64_t raw_value)
 232 {
 233         BT_ASSERT_PRE_DEV_NO_ERROR();
 234         BT_ASSERT_PRE_STREAM_NON_NULL(stream);
 235         return create_event_message(msg_iter, event_class, NULL, stream,
 236                 true, raw_value, __func__);
 237 }
 238
 239 struct bt_message *
 240 bt_message_event_create_with_packet_and_default_clock_snapshot(
 241                 struct bt_self_message_iterator *msg_iter,
 242                 const struct bt_event_class *event_class,
 243                 const struct bt_packet *packet,
 244                 uint64_t raw_value)
 245 {
 246         BT_ASSERT_PRE_DEV_NO_ERROR();
 247         BT_ASSERT_PRE_PACKET_NON_NULL(packet);
 248         return create_event_message(msg_iter, event_class, packet,
 249                 packet->stream, true, raw_value, __func__);
 250 }
 251
 252 BT_HIDDEN
 253 void bt_message_event_destroy(struct bt_message *msg)
 254 {
 255         struct bt_message_event *event_msg = (void *) msg;
 256
 257         BT_LIB_LOGD("Destroying event message: %!+n", msg);
 258
 259         if (event_msg->event) {
 260                 BT_LIB_LOGD("Recycling event: %!+e", event_msg->event);
 261                 bt_event_recycle(event_msg->event);
 262                 event_msg->event = NULL;
 263         }
 264
 265         if (event_msg->default_cs) {
 266                 bt_clock_snapshot_recycle(event_msg->default_cs);
 267                 event_msg->default_cs = NULL;
 268         }
 269
 270         g_free(msg);
 271 }
 272
 273 BT_HIDDEN
 274 void bt_message_event_recycle(struct bt_message *msg)
 275 {
 276         struct bt_message_event *event_msg = (void *) msg;
 277         struct bt_graph *graph;
 278
 279         BT_ASSERT_DBG(event_msg);
 280
 281         if (G_UNLIKELY(!msg->graph)) {
 282                 bt_message_event_destroy(msg);
 283                 return;
 284         }
 285
 286         BT_LIB_LOGD("Recycling event message: %![msg-]+n, %![event-]+e",
 287                 msg, event_msg->event);
 288         bt_message_reset(msg);
 289         BT_ASSERT_DBG(event_msg->event);
 290         bt_event_recycle(event_msg->event);
 291         event_msg->event = NULL;
 292
 293         if (event_msg->default_cs) {
 294                 bt_clock_snapshot_recycle(event_msg->default_cs);
 295                 event_msg->default_cs = NULL;
 296         }
 297
 298         graph = msg->graph;
 299         msg->graph = NULL;
 300         bt_object_pool_recycle_object(&graph->event_msg_pool, msg);
 301 }
 302
 303 #define BT_ASSERT_PRE_DEV_FOR_BORROW_EVENTS(_msg)                       \
 304         do {                                                            \
 305                 BT_ASSERT_PRE_DEV_MSG_NON_NULL(_msg);                   \
 306                 BT_ASSERT_PRE_DEV_MSG_IS_EVENT(_msg);                   \
 307         } while (0)
 308
 309 static inline
 310 struct bt_event *borrow_event(struct bt_message *message)
 311 {
 312         struct bt_message_event *event_message;
 313
 314         event_message = container_of(message,
 315                         struct bt_message_event, parent);
 316         return event_message->event;
 317 }
 318
 319 struct bt_event *bt_message_event_borrow_event(
 320                 struct bt_message *message)
 321 {
 322         BT_ASSERT_PRE_DEV_FOR_BORROW_EVENTS(message);
 323         return borrow_event(message);
 324 }
 325
 326 const struct bt_event *bt_message_event_borrow_event_const(
 327                 const struct bt_message *message)
 328 {
 329         BT_ASSERT_PRE_DEV_FOR_BORROW_EVENTS(message);
 330         return borrow_event((void *) message);
 331 }
 332
 333 const struct bt_clock_snapshot *
 334 bt_message_event_borrow_default_clock_snapshot_const(
 335                 const struct bt_message *msg)
 336 {
 337         struct bt_message_event *event_msg = (void *) msg;
 338         struct bt_stream_class *stream_class;
 339
 340         BT_ASSERT_PRE_DEV_MSG_NON_NULL(msg);
 341         BT_ASSERT_PRE_DEV_MSG_IS_EVENT(msg);
 342         stream_class = bt_event_class_borrow_stream_class_inline(
 343                 event_msg->event->class);
 344         BT_ASSERT_DBG(stream_class);
 345         BT_ASSERT_PRE_DEV_MSG_SC_DEF_CLK_CLS(msg, stream_class);
 346         return event_msg->default_cs;
 347 }
 348
 349 const bt_clock_class *
 350 bt_message_event_borrow_stream_class_default_clock_class_const(
 351                 const bt_message *msg)
 352 {
 353         struct bt_message_event *event_msg = (void *) msg;
 354         struct bt_stream_class *stream_class;
 355
 356         BT_ASSERT_PRE_DEV_MSG_NON_NULL(msg);
 357         BT_ASSERT_PRE_DEV_MSG_IS_EVENT(msg);
 358         stream_class = bt_event_class_borrow_stream_class_inline(
 359                 event_msg->event->class);
 360         BT_ASSERT_DBG(stream_class);
 361         return stream_class->default_clock_class;
 362 }