src/lib/graph/message/discarded-items.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2019 Philippe Proulx <pproulx@efficios.com>
   5  */
   6
   7 #define BT_LOG_TAG "LIB/MSG-DISCARDED-ITEMS"
   8 #include "lib/logging.h"
   9
  10 #include <stdbool.h>
  11
  12 #include "lib/assert-pre.h"
  13 #include "lib/object.h"
  14 #include "compat/compiler.h"
  15 #include <babeltrace2/trace-ir/clock-class.h>
  16 #include "lib/trace-ir/clock-snapshot.h"
  17 #include "lib/trace-ir/stream-class.h"
  18 #include "lib/trace-ir/stream.h"
  19 #include "lib/property.h"
  20 #include "lib/graph/message/message.h"
  21
  22 #include "discarded-items.h"
  23
  24 static
  25 void destroy_discarded_items_message(struct bt_object *obj)
  26 {
  27         struct bt_message_discarded_items *message = (void *) obj;
  28
  29         BT_LIB_LOGD("Destroying discarded items message: %!+n", message);
  30         BT_LIB_LOGD("Putting stream: %!+s", message->stream);
  31         BT_OBJECT_PUT_REF_AND_RESET(message->stream);
  32
  33         if (message->default_begin_cs) {
  34                 bt_clock_snapshot_recycle(message->default_begin_cs);
  35                 message->default_begin_cs = NULL;
  36         }
  37
  38         if (message->default_end_cs) {
  39                 bt_clock_snapshot_recycle(message->default_end_cs);
  40                 message->default_end_cs = NULL;
  41         }
  42
  43         g_free(message);
  44 }
  45
  46 static inline
  47 struct bt_message *create_discarded_items_message(
  48                 struct bt_self_message_iterator *self_msg_iter,
  49                 enum bt_message_type type, struct bt_stream *stream,
  50                 bool with_cs,
  51                 uint64_t beginning_raw_value, uint64_t end_raw_value)
  52 {
  53         struct bt_message_discarded_items *message;
  54         struct bt_stream_class *stream_class;
  55         bool has_support;
  56         bool need_cs;
  57
  58         BT_ASSERT_PRE_NON_NULL(self_msg_iter, "Message iterator");
  59         BT_ASSERT_PRE_NON_NULL(stream, "Stream");
  60         stream_class = bt_stream_borrow_class(stream);
  61         BT_ASSERT(stream_class);
  62
  63         if (type == BT_MESSAGE_TYPE_DISCARDED_EVENTS) {
  64                 has_support = stream_class->supports_discarded_events;
  65                 need_cs = stream_class->discarded_events_have_default_clock_snapshots;
  66         } else {
  67                 has_support = stream_class->supports_discarded_packets;
  68                 need_cs = stream_class->discarded_packets_have_default_clock_snapshots;
  69         }
  70
  71         BT_ASSERT_PRE(has_support,
  72                 "Stream class does not support discarded events or packets: "
  73                 "type=%s, %![stream-]+s, %![sc-]+S",
  74                 bt_message_type_string(type), stream, stream_class);
  75         BT_ASSERT_PRE(need_cs ? with_cs : true,
  76                 "Unexpected stream class configuration when creating "
  77                 "a discarded events or discarded packets message: "
  78                 "default clock snapshots are needed, but none was provided: "
  79                 "type=%s, %![stream-]+s, %![sc-]+S, with-cs=%d, "
  80                 "cs-begin-val=%" PRIu64 ", cs-end-val=%" PRIu64,
  81                 bt_message_type_string(type), stream, stream_class,
  82                 with_cs, beginning_raw_value, end_raw_value);
  83         BT_ASSERT_PRE(!need_cs ? !with_cs : true,
  84                 "Unexpected stream class configuration when creating "
  85                 "a discarded events or discarded packets message: "
  86                 "no default clock snapshots are needed, but two were provided: "
  87                 "type=%s, %![stream-]+s, %![sc-]+S, with-cs=%d, "
  88                 "cs-begin-val=%" PRIu64 ", cs-end-val=%" PRIu64,
  89                 bt_message_type_string(type), stream, stream_class,
  90                 with_cs, beginning_raw_value, end_raw_value);
  91         BT_LIB_LOGD("Creating discarded items message object: "
  92                 "type=%s, %![stream-]+s, %![sc-]+S, with-cs=%d, "
  93                 "cs-begin-val=%" PRIu64 ", cs-end-val=%" PRIu64,
  94                 bt_message_type_string(type), stream, stream_class,
  95                 with_cs, beginning_raw_value, end_raw_value);
  96         message = g_new0(struct bt_message_discarded_items, 1);
  97         if (!message) {
  98                 BT_LIB_LOGE_APPEND_CAUSE(
  99                         "Failed to allocate one discarded items message.");
 100                 goto error;
 101         }
 102
 103         bt_message_init(&message->parent, type,
 104                 destroy_discarded_items_message, NULL);
 105         message->stream = stream;
 106         bt_object_get_ref_no_null_check(message->stream);
 107
 108         if (with_cs) {
 109                 BT_ASSERT(stream_class->default_clock_class);
 110                 message->default_begin_cs = bt_clock_snapshot_create(
 111                         stream_class->default_clock_class);
 112                 if (!message->default_begin_cs) {
 113                         goto error;
 114                 }
 115
 116                 bt_clock_snapshot_set_raw_value(message->default_begin_cs,
 117                         beginning_raw_value);
 118
 119                 message->default_end_cs = bt_clock_snapshot_create(
 120                         stream_class->default_clock_class);
 121                 if (!message->default_end_cs) {
 122                         goto error;
 123                 }
 124
 125                 bt_clock_snapshot_set_raw_value(message->default_end_cs,
 126                         end_raw_value);
 127         }
 128
 129         bt_property_uint_init(&message->count,
 130                 BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE, 0);
 131         BT_LIB_LOGD("Created discarded items message object: "
 132                 "%![msg-]+n, %![stream-]+s, %![sc-]+S", message,
 133                 stream, stream_class);
 134
 135         return (void *) &message->parent;
 136
 137 error:
 138         return NULL;
 139 }
 140
 141 static inline
 142 struct bt_stream *borrow_discarded_items_message_stream(
 143                 struct bt_message *message)
 144 {
 145         struct bt_message_discarded_items *disc_items_msg = (void *) message;
 146
 147         BT_ASSERT_DBG(message);
 148         return disc_items_msg->stream;
 149 }
 150
 151 static inline
 152 void set_discarded_items_message_count(struct bt_message *message,
 153                 uint64_t count)
 154 {
 155         struct bt_message_discarded_items *disc_items_msg = (void *) message;
 156
 157         BT_ASSERT(message);
 158         BT_ASSERT_PRE_DEV_HOT(message, "Message", ": %!+n", message);
 159         bt_property_uint_set(&disc_items_msg->count, count);
 160 }
 161
 162 static inline
 163 enum bt_property_availability get_discarded_items_message_count(
 164                 const struct bt_message *message, uint64_t *count)
 165 {
 166         struct bt_message_discarded_items *disc_items_msg = (void *) message;
 167
 168         BT_ASSERT_PRE_DEV_NON_NULL(count, "Count (output)");
 169         BT_ASSERT_DBG(message);
 170         *count = disc_items_msg->count.value;
 171         return disc_items_msg->count.base.avail;
 172 }
 173
 174 static inline
 175 const struct bt_clock_snapshot *
 176 borrow_discarded_items_message_beginning_default_clock_snapshot_const(
 177                 const struct bt_message *message)
 178 {
 179         struct bt_message_discarded_items *disc_items_msg = (void *) message;
 180
 181         BT_ASSERT_DBG(message);
 182         BT_ASSERT_PRE_DEV(disc_items_msg->stream->class->default_clock_class,
 183                 "Message's stream's class has no default clock class: "
 184                 "%![msg-]+n, %![sc-]+S",
 185                 message, disc_items_msg->stream->class);
 186         return disc_items_msg->default_begin_cs;
 187 }
 188
 189 static inline
 190 const struct bt_clock_snapshot *
 191 borrow_discarded_items_message_end_default_clock_snapshot_const(
 192                 const struct bt_message *message)
 193 {
 194         struct bt_message_discarded_items *disc_items_msg = (void *) message;
 195
 196         BT_ASSERT_DBG(message);
 197         BT_ASSERT_PRE_DEV(disc_items_msg->stream->class->default_clock_class,
 198                 "Message's stream's class has no default clock class: "
 199                 "%![msg-]+n, %![sc-]+S",
 200                 message, disc_items_msg->stream->class);
 201         return disc_items_msg->default_end_cs;
 202 }
 203
 204 struct bt_message *bt_message_discarded_events_create(
 205                 struct bt_self_message_iterator *message_iterator,
 206                 const struct bt_stream *stream)
 207 {
 208         BT_ASSERT_PRE_DEV_NO_ERROR();
 209
 210         return create_discarded_items_message(message_iterator,
 211                 BT_MESSAGE_TYPE_DISCARDED_EVENTS, (void *) stream,
 212                 false, 0, 0);
 213 }
 214
 215 struct bt_message *bt_message_discarded_events_create_with_default_clock_snapshots(
 216                 struct bt_self_message_iterator *message_iterator,
 217                 const struct bt_stream *stream, uint64_t beginning_raw_value,
 218                 uint64_t end_raw_value)
 219 {
 220         BT_ASSERT_PRE_DEV_NO_ERROR();
 221         BT_ASSERT_PRE_BEGIN_LE_END(message_iterator, beginning_raw_value, end_raw_value);
 222
 223         return create_discarded_items_message(message_iterator,
 224                 BT_MESSAGE_TYPE_DISCARDED_EVENTS, (void *) stream,
 225                 true, beginning_raw_value, end_raw_value);
 226 }
 227
 228 struct bt_stream *bt_message_discarded_events_borrow_stream(
 229                 struct bt_message *message)
 230 {
 231         BT_ASSERT_PRE_DEV_NON_NULL(message, "Message");
 232         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(message, BT_MESSAGE_TYPE_DISCARDED_EVENTS);
 233         return borrow_discarded_items_message_stream(message);
 234 }
 235
 236 void bt_message_discarded_events_set_count(struct bt_message *message,
 237                 uint64_t count)
 238 {
 239         BT_ASSERT_PRE_NON_NULL(message, "Message");
 240         BT_ASSERT_PRE_MSG_IS_TYPE(message, BT_MESSAGE_TYPE_DISCARDED_EVENTS);
 241         set_discarded_items_message_count(message, count);
 242 }
 243
 244 const struct bt_clock_snapshot *
 245 bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(
 246                 const struct bt_message *msg)
 247 {
 248         BT_ASSERT_PRE_DEV_NON_NULL(msg, "Message");
 249         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_EVENTS);
 250         return borrow_discarded_items_message_beginning_default_clock_snapshot_const(
 251                 msg);
 252 }
 253
 254 const struct bt_clock_snapshot *
 255 bt_message_discarded_events_borrow_end_default_clock_snapshot_const(
 256                 const struct bt_message *msg)
 257 {
 258         BT_ASSERT_PRE_DEV_NON_NULL(msg, "Message");
 259         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_EVENTS);
 260         return borrow_discarded_items_message_end_default_clock_snapshot_const(
 261                 msg);
 262 }
 263
 264 const struct bt_stream *
 265 bt_message_discarded_events_borrow_stream_const(const struct bt_message *message)
 266 {
 267         return (void *) bt_message_discarded_events_borrow_stream(
 268                 (void *) message);
 269 }
 270
 271 enum bt_property_availability bt_message_discarded_events_get_count(
 272                 const struct bt_message *message, uint64_t *count)
 273 {
 274         BT_ASSERT_PRE_DEV_NON_NULL(message, "Message");
 275         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(message,
 276                 BT_MESSAGE_TYPE_DISCARDED_EVENTS);
 277         return get_discarded_items_message_count(message, count);
 278 }
 279
 280 struct bt_message *bt_message_discarded_packets_create(
 281                 struct bt_self_message_iterator *message_iterator,
 282                 const struct bt_stream *stream)
 283 {
 284         BT_ASSERT_PRE_DEV_NO_ERROR();
 285
 286         return create_discarded_items_message(message_iterator,
 287                 BT_MESSAGE_TYPE_DISCARDED_PACKETS, (void *) stream,
 288                 false, 0, 0);
 289 }
 290
 291 struct bt_message *bt_message_discarded_packets_create_with_default_clock_snapshots(
 292                 struct bt_self_message_iterator *message_iterator,
 293                 const struct bt_stream *stream, uint64_t beginning_raw_value,
 294                 uint64_t end_raw_value)
 295 {
 296         BT_ASSERT_PRE_DEV_NO_ERROR();
 297         BT_ASSERT_PRE_BEGIN_LE_END(message_iterator, beginning_raw_value, end_raw_value);
 298
 299         return create_discarded_items_message(message_iterator,
 300                 BT_MESSAGE_TYPE_DISCARDED_PACKETS, (void *) stream,
 301                 true, beginning_raw_value, end_raw_value);
 302 }
 303
 304 struct bt_stream *bt_message_discarded_packets_borrow_stream(
 305                 struct bt_message *message)
 306 {
 307         BT_ASSERT_PRE_DEV_NON_NULL(message, "Message");
 308         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(message,
 309                 BT_MESSAGE_TYPE_DISCARDED_PACKETS);
 310         return borrow_discarded_items_message_stream(message);
 311 }
 312
 313 void bt_message_discarded_packets_set_count(struct bt_message *message,
 314                 uint64_t count)
 315 {
 316         BT_ASSERT_PRE_NON_NULL(message, "Message");
 317         BT_ASSERT_PRE_MSG_IS_TYPE(message, BT_MESSAGE_TYPE_DISCARDED_PACKETS);
 318         set_discarded_items_message_count(message, count);
 319 }
 320
 321 const struct bt_clock_snapshot *
 322 bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(
 323                 const struct bt_message *msg)
 324 {
 325         BT_ASSERT_PRE_DEV_NON_NULL(msg, "Message");
 326         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_PACKETS);
 327         return borrow_discarded_items_message_beginning_default_clock_snapshot_const(
 328                 msg);
 329 }
 330
 331 const struct bt_clock_snapshot *
 332 bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(
 333                 const struct bt_message *msg)
 334 {
 335         BT_ASSERT_PRE_DEV_NON_NULL(msg, "Message");
 336         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_PACKETS);
 337         return borrow_discarded_items_message_end_default_clock_snapshot_const(
 338                 msg);
 339 }
 340
 341 const struct bt_stream *
 342 bt_message_discarded_packets_borrow_stream_const(const struct bt_message *message)
 343 {
 344         return (void *) bt_message_discarded_packets_borrow_stream(
 345                 (void *) message);
 346 }
 347
 348 enum bt_property_availability bt_message_discarded_packets_get_count(
 349                 const struct bt_message *message, uint64_t *count)
 350 {
 351         BT_ASSERT_PRE_DEV_NON_NULL(message, "Message");
 352         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(message,
 353                 BT_MESSAGE_TYPE_DISCARDED_PACKETS);
 354         return get_discarded_items_message_count(message, count);
 355 }
 356
 357 static inline
 358 const struct bt_clock_class *
 359 borrow_discarded_items_message_stream_class_default_clock_class(
 360                 const struct bt_message *msg)
 361 {
 362         struct bt_message_discarded_items *disc_items_msg = (void *) msg;
 363
 364         BT_ASSERT_DBG(msg);
 365         return disc_items_msg->stream->class->default_clock_class;
 366 }
 367
 368 const struct bt_clock_class *
 369 bt_message_discarded_events_borrow_stream_class_default_clock_class_const(
 370                 const struct bt_message *msg)
 371 {
 372         BT_ASSERT_PRE_DEV_NON_NULL(msg, "Message");
 373         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_EVENTS);
 374         return borrow_discarded_items_message_stream_class_default_clock_class(
 375                 msg);
 376 }
 377
 378 const struct bt_clock_class *
 379 bt_message_discarded_packets_borrow_stream_class_default_clock_class_const(
 380                 const struct bt_message *msg)
 381 {
 382         BT_ASSERT_PRE_DEV_NON_NULL(msg, "Message");
 383         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_PACKETS);
 384         return borrow_discarded_items_message_stream_class_default_clock_class(
 385                 msg);
 386 }