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 #define BT_ASSERT_PRE_MSG_IS_DISC_EVENTS(_msg)                          \
  25         BT_ASSERT_PRE_MSG_HAS_TYPE("message", (_msg),                   \
  26                 "discarded-events", BT_MESSAGE_TYPE_DISCARDED_EVENTS);
  27
  28 #define BT_ASSERT_PRE_DEV_MSG_IS_DISC_EVENTS(_msg)                      \
  29         BT_ASSERT_PRE_DEV_MSG_HAS_TYPE("message", (_msg),               \
  30                 "discarded-events", BT_MESSAGE_TYPE_DISCARDED_EVENTS);
  31
  32 #define BT_ASSERT_PRE_MSG_IS_DISC_PACKETS(_msg)                         \
  33         BT_ASSERT_PRE_MSG_HAS_TYPE("message", (_msg),                   \
  34                 "discarded-packets", BT_MESSAGE_TYPE_DISCARDED_PACKETS);
  35
  36 #define BT_ASSERT_PRE_DEV_MSG_IS_DISC_PACKETS(_msg)                     \
  37         BT_ASSERT_PRE_DEV_MSG_HAS_TYPE("message", (_msg),               \
  38                 "discarded-packets", BT_MESSAGE_TYPE_DISCARDED_PACKETS);
  39
  40 #define BT_ASSERT_PRE_DEV_COUNT_OUTPUT_NON_NULL(_count)                 \
  41         BT_ASSERT_PRE_DEV_NON_NULL("count-output", count,               \
  42                 "Count (output)");
  43
  44 static
  45 void destroy_discarded_items_message(struct bt_object *obj)
  46 {
  47         struct bt_message_discarded_items *message = (void *) obj;
  48
  49         BT_LIB_LOGD("Destroying discarded items message: %!+n", message);
  50         BT_LIB_LOGD("Putting stream: %!+s", message->stream);
  51         BT_OBJECT_PUT_REF_AND_RESET(message->stream);
  52
  53         if (message->default_begin_cs) {
  54                 bt_clock_snapshot_recycle(message->default_begin_cs);
  55                 message->default_begin_cs = NULL;
  56         }
  57
  58         if (message->default_end_cs) {
  59                 bt_clock_snapshot_recycle(message->default_end_cs);
  60                 message->default_end_cs = NULL;
  61         }
  62
  63         g_free(message);
  64 }
  65
  66 static inline
  67 struct bt_message *create_discarded_items_message(
  68                 struct bt_self_message_iterator *self_msg_iter,
  69                 enum bt_message_type type, struct bt_stream *stream,
  70                 bool with_cs,
  71                 uint64_t beginning_raw_value, uint64_t end_raw_value,
  72                 const char *api_func,
  73                 const char *sc_supports_disc_precond_id)
  74 {
  75         struct bt_message_discarded_items *message;
  76         struct bt_stream_class *stream_class;
  77         bool has_support;
  78         bool need_cs;
  79
  80         BT_ASSERT_PRE_MSG_ITER_NON_NULL_FROM_FUNC(api_func, self_msg_iter);
  81         BT_ASSERT_PRE_STREAM_NON_NULL_FROM_FUNC(api_func, stream);
  82         stream_class = bt_stream_borrow_class(stream);
  83         BT_ASSERT(stream_class);
  84
  85         if (type == BT_MESSAGE_TYPE_DISCARDED_EVENTS) {
  86                 has_support = stream_class->supports_discarded_events;
  87                 need_cs = stream_class->discarded_events_have_default_clock_snapshots;
  88         } else {
  89                 has_support = stream_class->supports_discarded_packets;
  90                 need_cs = stream_class->discarded_packets_have_default_clock_snapshots;
  91         }
  92
  93         BT_ASSERT_PRE_FROM_FUNC(api_func, sc_supports_disc_precond_id,
  94                 has_support,
  95                 "Stream class does not support discarded events or packets: "
  96                 "type=%s, %![stream-]+s, %![sc-]+S",
  97                 bt_common_message_type_string(type), stream, stream_class);
  98         BT_ASSERT_PRE_FROM_FUNC(api_func, "with-default-clock-snapshots",
  99                 need_cs ? with_cs : true,
 100                 "Unexpected stream class configuration when creating "
 101                 "a discarded events or discarded packets message: "
 102                 "default clock snapshots are needed, but none was provided: "
 103                 "type=%s, %![stream-]+s, %![sc-]+S, with-cs=%d, "
 104                 "cs-begin-val=%" PRIu64 ", cs-end-val=%" PRIu64,
 105                 bt_common_message_type_string(type), stream, stream_class,
 106                 with_cs, beginning_raw_value, end_raw_value);
 107         BT_ASSERT_PRE_FROM_FUNC(api_func, "without-default-clock-snapshots",
 108                 !need_cs ? !with_cs : true,
 109                 "Unexpected stream class configuration when creating "
 110                 "a discarded events or discarded packets message: "
 111                 "no default clock snapshots are needed, but two were provided: "
 112                 "type=%s, %![stream-]+s, %![sc-]+S, with-cs=%d, "
 113                 "cs-begin-val=%" PRIu64 ", cs-end-val=%" PRIu64,
 114                 bt_common_message_type_string(type), stream, stream_class,
 115                 with_cs, beginning_raw_value, end_raw_value);
 116         BT_LIB_LOGD("Creating discarded items message object: "
 117                 "type=%s, %![stream-]+s, %![sc-]+S, with-cs=%d, "
 118                 "cs-begin-val=%" PRIu64 ", cs-end-val=%" PRIu64,
 119                 bt_common_message_type_string(type), stream, stream_class,
 120                 with_cs, beginning_raw_value, end_raw_value);
 121         message = g_new0(struct bt_message_discarded_items, 1);
 122         if (!message) {
 123                 BT_LIB_LOGE_APPEND_CAUSE(
 124                         "Failed to allocate one discarded items message.");
 125                 goto error;
 126         }
 127
 128         bt_message_init(&message->parent, type,
 129                 destroy_discarded_items_message, NULL);
 130         message->stream = stream;
 131         bt_object_get_ref_no_null_check(message->stream);
 132
 133         if (with_cs) {
 134                 BT_ASSERT(stream_class->default_clock_class);
 135                 message->default_begin_cs = bt_clock_snapshot_create(
 136                         stream_class->default_clock_class);
 137                 if (!message->default_begin_cs) {
 138                         goto error;
 139                 }
 140
 141                 bt_clock_snapshot_set_raw_value(message->default_begin_cs,
 142                         beginning_raw_value);
 143
 144                 message->default_end_cs = bt_clock_snapshot_create(
 145                         stream_class->default_clock_class);
 146                 if (!message->default_end_cs) {
 147                         goto error;
 148                 }
 149
 150                 bt_clock_snapshot_set_raw_value(message->default_end_cs,
 151                         end_raw_value);
 152         }
 153
 154         bt_property_uint_init(&message->count,
 155                 BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE, 0);
 156         BT_LIB_LOGD("Created discarded items message object: "
 157                 "%![msg-]+n, %![stream-]+s, %![sc-]+S", message,
 158                 stream, stream_class);
 159
 160         return (void *) &message->parent;
 161
 162 error:
 163         return NULL;
 164 }
 165
 166 static inline
 167 struct bt_stream *borrow_discarded_items_message_stream(
 168                 struct bt_message *message)
 169 {
 170         struct bt_message_discarded_items *disc_items_msg = (void *) message;
 171
 172         BT_ASSERT_DBG(message);
 173         return disc_items_msg->stream;
 174 }
 175
 176 static inline
 177 void set_discarded_items_message_count(struct bt_message *message,
 178                 uint64_t count)
 179 {
 180         struct bt_message_discarded_items *disc_items_msg = (void *) message;
 181
 182         BT_ASSERT(message);
 183         bt_property_uint_set(&disc_items_msg->count, count);
 184 }
 185
 186 static inline
 187 enum bt_property_availability get_discarded_items_message_count(
 188                 const struct bt_message *message, uint64_t *count)
 189 {
 190         struct bt_message_discarded_items *disc_items_msg = (void *) message;
 191
 192         BT_ASSERT_DBG(message);
 193         BT_ASSERT_DBG(count);
 194         *count = disc_items_msg->count.value;
 195         return disc_items_msg->count.base.avail;
 196 }
 197
 198 static inline
 199 const struct bt_clock_snapshot *
 200 borrow_discarded_items_message_beginning_default_clock_snapshot_const(
 201                 const struct bt_message *message, const char *api_func)
 202 {
 203         struct bt_message_discarded_items *disc_items_msg = (void *) message;
 204
 205         BT_ASSERT_DBG(message);
 206         BT_ASSERT_PRE_DEV_MSG_SC_DEF_CLK_CLS_FROM_FUNC(api_func, message,
 207                 disc_items_msg->stream->class);
 208         return disc_items_msg->default_begin_cs;
 209 }
 210
 211 static inline
 212 const struct bt_clock_snapshot *
 213 borrow_discarded_items_message_end_default_clock_snapshot_const(
 214                 const struct bt_message *message, const char *api_func)
 215 {
 216         struct bt_message_discarded_items *disc_items_msg = (void *) message;
 217
 218         BT_ASSERT_DBG(message);
 219         BT_ASSERT_PRE_DEV_MSG_SC_DEF_CLK_CLS_FROM_FUNC(api_func, message,
 220                 disc_items_msg->stream->class);
 221         return disc_items_msg->default_end_cs;
 222 }
 223
 224 #define SC_SUPPORTS_DISC_PRECOND_ID(_item_type)                         \
 225         "stream-class-supports-discarded-" _item_type
 226
 227 BT_EXPORT
 228 struct bt_message *bt_message_discarded_events_create(
 229                 struct bt_self_message_iterator *message_iterator,
 230                 const struct bt_stream *stream)
 231 {
 232         BT_ASSERT_PRE_DEV_NO_ERROR();
 233
 234         return create_discarded_items_message(message_iterator,
 235                 BT_MESSAGE_TYPE_DISCARDED_EVENTS, (void *) stream,
 236                 false, 0, 0, __func__,
 237                 SC_SUPPORTS_DISC_PRECOND_ID("events"));
 238 }
 239
 240 BT_EXPORT
 241 struct bt_message *bt_message_discarded_events_create_with_default_clock_snapshots(
 242                 struct bt_self_message_iterator *message_iterator,
 243                 const struct bt_stream *stream, uint64_t beginning_raw_value,
 244                 uint64_t end_raw_value)
 245 {
 246         BT_ASSERT_PRE_DEV_NO_ERROR();
 247         BT_ASSERT_PRE_MSG_CS_BEGIN_LE_END(message_iterator,
 248                 beginning_raw_value, end_raw_value);
 249
 250         return create_discarded_items_message(message_iterator,
 251                 BT_MESSAGE_TYPE_DISCARDED_EVENTS, (void *) stream,
 252                 true, beginning_raw_value, end_raw_value, __func__,
 253                 SC_SUPPORTS_DISC_PRECOND_ID("events"));
 254 }
 255
 256 BT_EXPORT
 257 struct bt_stream *bt_message_discarded_events_borrow_stream(
 258                 struct bt_message *message)
 259 {
 260         BT_ASSERT_PRE_DEV_MSG_NON_NULL(message);
 261         BT_ASSERT_PRE_DEV_MSG_IS_DISC_EVENTS(message);
 262         return borrow_discarded_items_message_stream(message);
 263 }
 264
 265 BT_EXPORT
 266 void bt_message_discarded_events_set_count(struct bt_message *message,
 267                 uint64_t count)
 268 {
 269         BT_ASSERT_PRE_MSG_NON_NULL(message);
 270         BT_ASSERT_PRE_MSG_IS_DISC_EVENTS(message);
 271         BT_ASSERT_PRE_DEV_MSG_HOT(message);
 272         BT_ASSERT_PRE("count-gt-0", count > 0, "Discarded event count is 0.");
 273         set_discarded_items_message_count(message, count);
 274 }
 275
 276 BT_EXPORT
 277 const struct bt_clock_snapshot *
 278 bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(
 279                 const struct bt_message *msg)
 280 {
 281         BT_ASSERT_PRE_DEV_MSG_NON_NULL(msg);
 282         BT_ASSERT_PRE_DEV_MSG_IS_DISC_EVENTS(msg);
 283         return borrow_discarded_items_message_beginning_default_clock_snapshot_const(
 284                 msg, __func__);
 285 }
 286
 287 BT_EXPORT
 288 const struct bt_clock_snapshot *
 289 bt_message_discarded_events_borrow_end_default_clock_snapshot_const(
 290                 const struct bt_message *msg)
 291 {
 292         BT_ASSERT_PRE_DEV_MSG_NON_NULL(msg);
 293         BT_ASSERT_PRE_DEV_MSG_IS_DISC_EVENTS(msg);
 294         return borrow_discarded_items_message_end_default_clock_snapshot_const(
 295                 msg, __func__);
 296 }
 297
 298 BT_EXPORT
 299 const struct bt_stream *
 300 bt_message_discarded_events_borrow_stream_const(const struct bt_message *message)
 301 {
 302         return (void *) bt_message_discarded_events_borrow_stream(
 303                 (void *) message);
 304 }
 305
 306 BT_EXPORT
 307 enum bt_property_availability bt_message_discarded_events_get_count(
 308                 const struct bt_message *message, uint64_t *count)
 309 {
 310         BT_ASSERT_PRE_DEV_MSG_NON_NULL(message);
 311         BT_ASSERT_PRE_DEV_MSG_IS_DISC_EVENTS(message);
 312         BT_ASSERT_PRE_DEV_COUNT_OUTPUT_NON_NULL(count);
 313         return get_discarded_items_message_count(message, count);
 314 }
 315
 316 BT_EXPORT
 317 struct bt_message *bt_message_discarded_packets_create(
 318                 struct bt_self_message_iterator *message_iterator,
 319                 const struct bt_stream *stream)
 320 {
 321         BT_ASSERT_PRE_DEV_NO_ERROR();
 322
 323         return create_discarded_items_message(message_iterator,
 324                 BT_MESSAGE_TYPE_DISCARDED_PACKETS, (void *) stream,
 325                 false, 0, 0, __func__, SC_SUPPORTS_DISC_PRECOND_ID("packets"));
 326 }
 327
 328 BT_EXPORT
 329 struct bt_message *bt_message_discarded_packets_create_with_default_clock_snapshots(
 330                 struct bt_self_message_iterator *message_iterator,
 331                 const struct bt_stream *stream, uint64_t beginning_raw_value,
 332                 uint64_t end_raw_value)
 333 {
 334         BT_ASSERT_PRE_DEV_NO_ERROR();
 335         BT_ASSERT_PRE_MSG_CS_BEGIN_LE_END(message_iterator,
 336                 beginning_raw_value, end_raw_value);
 337
 338         return create_discarded_items_message(message_iterator,
 339                 BT_MESSAGE_TYPE_DISCARDED_PACKETS, (void *) stream,
 340                 true, beginning_raw_value, end_raw_value, __func__,
 341                 SC_SUPPORTS_DISC_PRECOND_ID("packets"));
 342 }
 343
 344 BT_EXPORT
 345 struct bt_stream *bt_message_discarded_packets_borrow_stream(
 346                 struct bt_message *message)
 347 {
 348         BT_ASSERT_PRE_DEV_MSG_NON_NULL(message);
 349         BT_ASSERT_PRE_DEV_MSG_IS_DISC_PACKETS(message);
 350         return borrow_discarded_items_message_stream(message);
 351 }
 352
 353 BT_EXPORT
 354 void bt_message_discarded_packets_set_count(struct bt_message *message,
 355                 uint64_t count)
 356 {
 357         BT_ASSERT_PRE_MSG_NON_NULL(message);
 358         BT_ASSERT_PRE_MSG_IS_DISC_PACKETS(message);
 359         BT_ASSERT_PRE_DEV_MSG_HOT(message);
 360         BT_ASSERT_PRE("count-gt-0", count > 0, "Discarded packet count is 0.");
 361         set_discarded_items_message_count(message, count);
 362 }
 363
 364 BT_EXPORT
 365 const struct bt_clock_snapshot *
 366 bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(
 367                 const struct bt_message *msg)
 368 {
 369         BT_ASSERT_PRE_DEV_MSG_NON_NULL(msg);
 370         BT_ASSERT_PRE_DEV_MSG_IS_DISC_PACKETS(msg);
 371         return borrow_discarded_items_message_beginning_default_clock_snapshot_const(
 372                 msg, __func__);
 373 }
 374
 375 BT_EXPORT
 376 const struct bt_clock_snapshot *
 377 bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(
 378                 const struct bt_message *msg)
 379 {
 380         BT_ASSERT_PRE_DEV_MSG_NON_NULL(msg);
 381         BT_ASSERT_PRE_DEV_MSG_IS_DISC_PACKETS(msg);
 382         return borrow_discarded_items_message_end_default_clock_snapshot_const(
 383                 msg, __func__);
 384 }
 385
 386 BT_EXPORT
 387 const struct bt_stream *
 388 bt_message_discarded_packets_borrow_stream_const(const struct bt_message *message)
 389 {
 390         return (void *) bt_message_discarded_packets_borrow_stream(
 391                 (void *) message);
 392 }
 393
 394 BT_EXPORT
 395 enum bt_property_availability bt_message_discarded_packets_get_count(
 396                 const struct bt_message *message, uint64_t *count)
 397 {
 398         BT_ASSERT_PRE_DEV_MSG_NON_NULL(message);
 399         BT_ASSERT_PRE_DEV_MSG_IS_DISC_PACKETS(message);
 400         BT_ASSERT_PRE_DEV_COUNT_OUTPUT_NON_NULL(count);
 401         return get_discarded_items_message_count(message, count);
 402 }
 403
 404 static inline
 405 const struct bt_clock_class *
 406 borrow_discarded_items_message_stream_class_default_clock_class(
 407                 const struct bt_message *msg)
 408 {
 409         struct bt_message_discarded_items *disc_items_msg = (void *) msg;
 410
 411         BT_ASSERT_DBG(msg);
 412         return disc_items_msg->stream->class->default_clock_class;
 413 }
 414
 415 BT_EXPORT
 416 const struct bt_clock_class *
 417 bt_message_discarded_events_borrow_stream_class_default_clock_class_const(
 418                 const struct bt_message *msg)
 419 {
 420         BT_ASSERT_PRE_DEV_MSG_NON_NULL(msg);
 421         BT_ASSERT_PRE_DEV_MSG_IS_DISC_EVENTS(msg);
 422         return borrow_discarded_items_message_stream_class_default_clock_class(
 423                 msg);
 424 }
 425
 426 BT_EXPORT
 427 const struct bt_clock_class *
 428 bt_message_discarded_packets_borrow_stream_class_default_clock_class_const(
 429                 const struct bt_message *msg)
 430 {
 431         BT_ASSERT_PRE_DEV_MSG_NON_NULL(msg);
 432         BT_ASSERT_PRE_DEV_MSG_IS_DISC_PACKETS(msg);
 433         return borrow_discarded_items_message_stream_class_default_clock_class(
 434                 msg);
 435 }