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-cond.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         BT_ASSERT_PRE(count > 0, "Discarded event count is 0.");
 242         set_discarded_items_message_count(message, count);
 243 }
 244
 245 const struct bt_clock_snapshot *
 246 bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(
 247                 const struct bt_message *msg)
 248 {
 249         BT_ASSERT_PRE_DEV_NON_NULL(msg, "Message");
 250         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_EVENTS);
 251         return borrow_discarded_items_message_beginning_default_clock_snapshot_const(
 252                 msg);
 253 }
 254
 255 const struct bt_clock_snapshot *
 256 bt_message_discarded_events_borrow_end_default_clock_snapshot_const(
 257                 const struct bt_message *msg)
 258 {
 259         BT_ASSERT_PRE_DEV_NON_NULL(msg, "Message");
 260         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_EVENTS);
 261         return borrow_discarded_items_message_end_default_clock_snapshot_const(
 262                 msg);
 263 }
 264
 265 const struct bt_stream *
 266 bt_message_discarded_events_borrow_stream_const(const struct bt_message *message)
 267 {
 268         return (void *) bt_message_discarded_events_borrow_stream(
 269                 (void *) message);
 270 }
 271
 272 enum bt_property_availability bt_message_discarded_events_get_count(
 273                 const struct bt_message *message, uint64_t *count)
 274 {
 275         BT_ASSERT_PRE_DEV_NON_NULL(message, "Message");
 276         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(message,
 277                 BT_MESSAGE_TYPE_DISCARDED_EVENTS);
 278         return get_discarded_items_message_count(message, count);
 279 }
 280
 281 struct bt_message *bt_message_discarded_packets_create(
 282                 struct bt_self_message_iterator *message_iterator,
 283                 const struct bt_stream *stream)
 284 {
 285         BT_ASSERT_PRE_DEV_NO_ERROR();
 286
 287         return create_discarded_items_message(message_iterator,
 288                 BT_MESSAGE_TYPE_DISCARDED_PACKETS, (void *) stream,
 289                 false, 0, 0);
 290 }
 291
 292 struct bt_message *bt_message_discarded_packets_create_with_default_clock_snapshots(
 293                 struct bt_self_message_iterator *message_iterator,
 294                 const struct bt_stream *stream, uint64_t beginning_raw_value,
 295                 uint64_t end_raw_value)
 296 {
 297         BT_ASSERT_PRE_DEV_NO_ERROR();
 298         BT_ASSERT_PRE_BEGIN_LE_END(message_iterator, beginning_raw_value, end_raw_value);
 299
 300         return create_discarded_items_message(message_iterator,
 301                 BT_MESSAGE_TYPE_DISCARDED_PACKETS, (void *) stream,
 302                 true, beginning_raw_value, end_raw_value);
 303 }
 304
 305 struct bt_stream *bt_message_discarded_packets_borrow_stream(
 306                 struct bt_message *message)
 307 {
 308         BT_ASSERT_PRE_DEV_NON_NULL(message, "Message");
 309         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(message,
 310                 BT_MESSAGE_TYPE_DISCARDED_PACKETS);
 311         return borrow_discarded_items_message_stream(message);
 312 }
 313
 314 void bt_message_discarded_packets_set_count(struct bt_message *message,
 315                 uint64_t count)
 316 {
 317         BT_ASSERT_PRE_NON_NULL(message, "Message");
 318         BT_ASSERT_PRE_MSG_IS_TYPE(message, BT_MESSAGE_TYPE_DISCARDED_PACKETS);
 319         BT_ASSERT_PRE(count > 0, "Discarded packet count is 0.");
 320         set_discarded_items_message_count(message, count);
 321 }
 322
 323 const struct bt_clock_snapshot *
 324 bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(
 325                 const struct bt_message *msg)
 326 {
 327         BT_ASSERT_PRE_DEV_NON_NULL(msg, "Message");
 328         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_PACKETS);
 329         return borrow_discarded_items_message_beginning_default_clock_snapshot_const(
 330                 msg);
 331 }
 332
 333 const struct bt_clock_snapshot *
 334 bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(
 335                 const struct bt_message *msg)
 336 {
 337         BT_ASSERT_PRE_DEV_NON_NULL(msg, "Message");
 338         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_PACKETS);
 339         return borrow_discarded_items_message_end_default_clock_snapshot_const(
 340                 msg);
 341 }
 342
 343 const struct bt_stream *
 344 bt_message_discarded_packets_borrow_stream_const(const struct bt_message *message)
 345 {
 346         return (void *) bt_message_discarded_packets_borrow_stream(
 347                 (void *) message);
 348 }
 349
 350 enum bt_property_availability bt_message_discarded_packets_get_count(
 351                 const struct bt_message *message, uint64_t *count)
 352 {
 353         BT_ASSERT_PRE_DEV_NON_NULL(message, "Message");
 354         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(message,
 355                 BT_MESSAGE_TYPE_DISCARDED_PACKETS);
 356         return get_discarded_items_message_count(message, count);
 357 }
 358
 359 static inline
 360 const struct bt_clock_class *
 361 borrow_discarded_items_message_stream_class_default_clock_class(
 362                 const struct bt_message *msg)
 363 {
 364         struct bt_message_discarded_items *disc_items_msg = (void *) msg;
 365
 366         BT_ASSERT_DBG(msg);
 367         return disc_items_msg->stream->class->default_clock_class;
 368 }
 369
 370 const struct bt_clock_class *
 371 bt_message_discarded_events_borrow_stream_class_default_clock_class_const(
 372                 const struct bt_message *msg)
 373 {
 374         BT_ASSERT_PRE_DEV_NON_NULL(msg, "Message");
 375         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_EVENTS);
 376         return borrow_discarded_items_message_stream_class_default_clock_class(
 377                 msg);
 378 }
 379
 380 const struct bt_clock_class *
 381 bt_message_discarded_packets_borrow_stream_class_default_clock_class_const(
 382                 const struct bt_message *msg)
 383 {
 384         BT_ASSERT_PRE_DEV_NON_NULL(msg, "Message");
 385         BT_ASSERT_PRE_DEV_MSG_IS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_PACKETS);
 386         return borrow_discarded_items_message_stream_class_default_clock_class(
 387                 msg);
 388 }