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
  26 #include "event.h"
  27
  28 #define BT_ASSERT_PRE_DEV_MSG_IS_EVENT(_msg)                            \
  29         BT_ASSERT_PRE_DEV_MSG_HAS_TYPE("message", (_msg), "event",      \
  30                 BT_MESSAGE_TYPE_EVENT)
  31
  32 struct bt_message *bt_message_event_new(
  33                 struct bt_graph *graph)
  34 {
  35         struct bt_message_event *message = NULL;
  36
  37         message = g_new0(struct bt_message_event, 1);
  38         if (!message) {
  39                 BT_LIB_LOGE_APPEND_CAUSE(
  40                         "Failed to allocate one event message.");
  41                 goto error;
  42         }
  43
  44         bt_message_init(&message->parent, BT_MESSAGE_TYPE_EVENT,
  45                 (bt_object_release_func) bt_message_event_recycle, graph);
  46         goto end;
  47
  48 error:
  49         BT_OBJECT_PUT_REF_AND_RESET(message);
  50
  51 end:
  52         return (void *) message;
  53 }
  54
  55 static
  56 struct bt_event *create_event(struct bt_event_class *event_class,
  57                 struct bt_packet *packet, struct bt_stream *stream,
  58                 const char *api_func)
  59 {
  60         struct bt_event *event = NULL;
  61
  62         BT_ASSERT_DBG(event_class);
  63         BT_ASSERT_DBG(stream);
  64         event = bt_object_pool_create_object(&event_class->event_pool);
  65         if (G_UNLIKELY(!event)) {
  66                 BT_LIB_LOGE_APPEND_CAUSE(
  67                         "Cannot allocate one event from event class's event pool: "
  68                         "%![ec-]+E", event_class);
  69                 goto end;
  70         }
  71
  72         if (G_LIKELY(!event->class)) {
  73                 event->class = event_class;
  74                 bt_object_get_ref_no_null_check(&event_class->base);
  75         }
  76
  77         BT_ASSERT_DBG(!event->stream);
  78         event->stream = stream;
  79         bt_object_get_ref_no_null_check_no_parent_check(&event->stream->base);
  80         BT_LIB_LOGD("Set event's stream: %![event-]+e, %![stream-]+s",
  81                 event, stream);
  82
  83         if (packet) {
  84                 BT_ASSERT_PRE_DEV_FROM_FUNC(api_func,
  85                         "packet-stream-class-is-event-class-stream-class",
  86                         bt_event_class_borrow_stream_class(
  87                                 event_class) == packet->stream->class,
  88                         "Packet's stream class and event class's stream class differ: "
  89                         "%![ec-]+E, %![packet-]+a", event, packet);
  90                 BT_ASSERT_DBG(event->stream->class->supports_packets);
  91                 BT_ASSERT_DBG(!event->packet);
  92                 event->packet = packet;
  93                 bt_object_get_ref_no_null_check_no_parent_check(&event->packet->base);
  94                 BT_LIB_LOGD("Set event's packet: %![event-]+e, %![packet-]+a",
  95                         event, packet);
  96         }
  97
  98 end:
  99         return event;
 100 }
 101
 102 static inline
 103 struct bt_message *create_event_message(
 104                 struct bt_self_message_iterator *self_msg_iter,
 105                 const struct bt_event_class *c_event_class,
 106                 const struct bt_packet *c_packet,
 107                 const struct bt_stream *c_stream, bool with_cs,
 108                 uint64_t raw_value, const char *api_func)
 109 {
 110         struct bt_message_iterator *msg_iter =
 111                 (void *) self_msg_iter;
 112         struct bt_message_event *message = NULL;
 113         struct bt_event_class *event_class = (void *) c_event_class;
 114         struct bt_stream_class *stream_class;
 115         struct bt_packet *packet = (void *) c_packet;
 116         struct bt_stream *stream = (void *) c_stream;
 117         struct bt_event *event;
 118
 119         BT_ASSERT_DBG(stream);
 120         BT_ASSERT_PRE_MSG_ITER_NON_NULL_FROM_FUNC(api_func, msg_iter);
 121         BT_ASSERT_PRE_EC_NON_NULL_FROM_FUNC(api_func, event_class);
 122         stream_class = bt_event_class_borrow_stream_class_inline(event_class);
 123         BT_ASSERT_PRE_FROM_FUNC(api_func,
 124                 "stream-class-is-event-class-stream-class",
 125                 bt_event_class_borrow_stream_class(event_class) ==
 126                         stream->class,
 127                 "Stream's class and event's stream class differ: "
 128                 "%![ec-]+E, %![stream-]+s", event_class, stream);
 129         BT_ASSERT_DBG(stream_class);
 130         BT_ASSERT_PRE_FROM_FUNC(api_func,
 131                 "with-default-clock-snapshot-if-stream-class-has-default-clock-class",
 132                 (with_cs && stream_class->default_clock_class) ||
 133                 (!with_cs && !stream_class->default_clock_class),
 134                 "Creating an event message with a default clock snapshot, but without "
 135                 "a default clock class, or without a default clock snapshot, "
 136                 "but with a default clock class: ",
 137                 "%![ec-]+E, %![sc-]+S, with-cs=%d, "
 138                 "cs-val=%" PRIu64,
 139                 event_class, stream_class, with_cs, raw_value);
 140         BT_LIB_LOGD("Creating event message object: %![ec-]+E", event_class);
 141         event = create_event(event_class, packet, stream, api_func);
 142         if (G_UNLIKELY(!event)) {
 143                 BT_LIB_LOGE_APPEND_CAUSE(
 144                         "Cannot create event from event class: "
 145                         "%![ec-]+E", event_class);
 146                 goto error;
 147         }
 148
 149         /*
 150          * Create message from pool _after_ we have everything
 151          * (in this case, a valid event object) so that we never have an
 152          * error condition with a non-NULL message object.
 153          * Otherwise:
 154          *
 155          * * We cannot recycle the message on error because
 156          *   bt_message_event_recycle() expects a complete
 157          *   message (and the event or clock class priority map
 158          *   object could be unset).
 159          *
 160          * * We cannot destroy the message because we would need
 161          *   to notify the graph (pool owner) so that it removes the
 162          *   message from its message array.
 163          */
 164         message = (void *) bt_message_create_from_pool(
 165                 &msg_iter->graph->event_msg_pool, msg_iter->graph);
 166         if (G_UNLIKELY(!message)) {
 167                 /* bt_message_create_from_pool() logs errors */
 168                 goto error;
 169         }
 170
 171         if (with_cs) {
 172                 BT_ASSERT_DBG(stream_class->default_clock_class);
 173                 message->default_cs = bt_clock_snapshot_create(
 174                         stream_class->default_clock_class);
 175                 if (!message->default_cs) {
 176                         goto error;
 177                 }
 178
 179                 bt_clock_snapshot_set_raw_value(message->default_cs, raw_value);
 180         }
 181
 182         BT_ASSERT_DBG(!message->event);
 183         message->event = event;
 184
 185         if (packet) {
 186                 bt_packet_set_is_frozen(packet, true);
 187         }
 188
 189         bt_stream_freeze(stream);
 190         bt_event_class_freeze(event_class);
 191         BT_LIB_LOGD("Created event message object: "
 192                 "%![msg-]+n, %![event-]+e", message, event);
 193         goto end;
 194
 195 error:
 196         BT_ASSERT(!message);
 197         bt_event_destroy(event);
 198
 199 end:
 200         return (void *) message;
 201 }
 202
 203 BT_EXPORT
 204 struct bt_message *bt_message_event_create(
 205                 struct bt_self_message_iterator *msg_iter,
 206                 const struct bt_event_class *event_class,
 207                 const struct bt_stream *stream)
 208 {
 209         BT_ASSERT_PRE_DEV_NO_ERROR();
 210         BT_ASSERT_PRE_STREAM_NON_NULL(stream);
 211         return create_event_message(msg_iter, event_class, NULL, stream,
 212                 false, 0, __func__);
 213 }
 214
 215 BT_EXPORT
 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 BT_EXPORT
 228 struct bt_message *bt_message_event_create_with_default_clock_snapshot(
 229                 struct bt_self_message_iterator *msg_iter,
 230                 const struct bt_event_class *event_class,
 231                 const struct bt_stream *stream,
 232                 uint64_t raw_value)
 233 {
 234         BT_ASSERT_PRE_DEV_NO_ERROR();
 235         BT_ASSERT_PRE_STREAM_NON_NULL(stream);
 236         return create_event_message(msg_iter, event_class, NULL, stream,
 237                 true, raw_value, __func__);
 238 }
 239
 240 BT_EXPORT
 241 struct bt_message *
 242 bt_message_event_create_with_packet_and_default_clock_snapshot(
 243                 struct bt_self_message_iterator *msg_iter,
 244                 const struct bt_event_class *event_class,
 245                 const struct bt_packet *packet,
 246                 uint64_t raw_value)
 247 {
 248         BT_ASSERT_PRE_DEV_NO_ERROR();
 249         BT_ASSERT_PRE_PACKET_NON_NULL(packet);
 250         return create_event_message(msg_iter, event_class, packet,
 251                 packet->stream, true, raw_value, __func__);
 252 }
 253
 254 void bt_message_event_destroy(struct bt_message *msg)
 255 {
 256         struct bt_message_event *event_msg = (void *) msg;
 257
 258         BT_LIB_LOGD("Destroying event message: %!+n", msg);
 259
 260         if (event_msg->event) {
 261                 BT_LIB_LOGD("Recycling event: %!+e", event_msg->event);
 262                 bt_event_recycle(event_msg->event);
 263                 event_msg->event = NULL;
 264         }
 265
 266         if (event_msg->default_cs) {
 267                 bt_clock_snapshot_recycle(event_msg->default_cs);
 268                 event_msg->default_cs = NULL;
 269         }
 270
 271         g_free(msg);
 272 }
 273
 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 BT_EXPORT
 320 struct bt_event *bt_message_event_borrow_event(
 321                 struct bt_message *message)
 322 {
 323         BT_ASSERT_PRE_DEV_FOR_BORROW_EVENTS(message);
 324         return borrow_event(message);
 325 }
 326
 327 BT_EXPORT
 328 const struct bt_event *bt_message_event_borrow_event_const(
 329                 const struct bt_message *message)
 330 {
 331         BT_ASSERT_PRE_DEV_FOR_BORROW_EVENTS(message);
 332         return borrow_event((void *) message);
 333 }
 334
 335 BT_EXPORT
 336 const struct bt_clock_snapshot *
 337 bt_message_event_borrow_default_clock_snapshot_const(
 338                 const struct bt_message *msg)
 339 {
 340         struct bt_message_event *event_msg = (void *) msg;
 341         struct bt_stream_class *stream_class;
 342
 343         BT_ASSERT_PRE_DEV_MSG_NON_NULL(msg);
 344         BT_ASSERT_PRE_DEV_MSG_IS_EVENT(msg);
 345         stream_class = bt_event_class_borrow_stream_class_inline(
 346                 event_msg->event->class);
 347         BT_ASSERT_DBG(stream_class);
 348         BT_ASSERT_PRE_DEV_MSG_SC_DEF_CLK_CLS(msg, stream_class);
 349         return event_msg->default_cs;
 350 }
 351
 352 BT_EXPORT
 353 const bt_clock_class *
 354 bt_message_event_borrow_stream_class_default_clock_class_const(
 355                 const bt_message *msg)
 356 {
 357         struct bt_message_event *event_msg = (void *) msg;
 358         struct bt_stream_class *stream_class;
 359
 360         BT_ASSERT_PRE_DEV_MSG_NON_NULL(msg);
 361         BT_ASSERT_PRE_DEV_MSG_IS_EVENT(msg);
 362         stream_class = bt_event_class_borrow_stream_class_inline(
 363                 event_msg->event->class);
 364         BT_ASSERT_DBG(stream_class);
 365         return stream_class->default_clock_class;
 366 }