src/lib/trace-ir/stream-class.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
   5  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   6  */
   7
   8 #define BT_LOG_TAG "LIB/STREAM-CLASS"
   9 #include "lib/logging.h"
  10
  11 #include "lib/assert-cond.h"
  12 #include <babeltrace2/trace-ir/trace.h>
  13 #include "compat/compiler.h"
  14 #include "common/align.h"
  15 #include "compat/endian.h"
  16 #include "common/assert.h"
  17 #include "lib/property.h"
  18 #include <inttypes.h>
  19 #include <stdint.h>
  20 #include <stdbool.h>
  21
  22 #include "clock-class.h"
  23 #include "event-class.h"
  24 #include "field-class.h"
  25 #include "field.h"
  26 #include "field-wrapper.h"
  27 #include "resolve-field-path.h"
  28 #include "stream-class.h"
  29 #include "trace.h"
  30 #include "utils.h"
  31 #include "lib/value.h"
  32 #include "lib/func-status.h"
  33
  34 #define BT_ASSERT_PRE_DEV_STREAM_CLASS_HOT(_sc)                         \
  35         BT_ASSERT_PRE_DEV_HOT("stream-class", (_sc), "Stream class",    \
  36                 ": %!+S", (_sc))
  37
  38 static
  39 void destroy_stream_class(struct bt_object *obj)
  40 {
  41         struct bt_stream_class *stream_class = (void *) obj;
  42
  43         BT_LIB_LOGD("Destroying stream class: %!+S", stream_class);
  44         BT_LOGD_STR("Putting default clock class.");
  45         BT_OBJECT_PUT_REF_AND_RESET(stream_class->user_attributes);
  46         BT_OBJECT_PUT_REF_AND_RESET(stream_class->default_clock_class);
  47
  48         if (stream_class->event_classes) {
  49                 BT_LOGD_STR("Destroying event classes.");
  50                 g_ptr_array_free(stream_class->event_classes, TRUE);
  51                 stream_class->event_classes = NULL;
  52         }
  53
  54         if (stream_class->name.str) {
  55                 g_string_free(stream_class->name.str, TRUE);
  56                 stream_class->name.str = NULL;
  57                 stream_class->name.value = NULL;
  58         }
  59
  60         BT_LOGD_STR("Putting packet context field class.");
  61         BT_OBJECT_PUT_REF_AND_RESET(stream_class->packet_context_fc);
  62         BT_LOGD_STR("Putting event common context field class.");
  63         BT_OBJECT_PUT_REF_AND_RESET(stream_class->event_common_context_fc);
  64         bt_object_pool_finalize(&stream_class->packet_context_field_pool);
  65         g_free(stream_class);
  66 }
  67
  68 static
  69 void free_field_wrapper(struct bt_field_wrapper *field_wrapper,
  70                 struct bt_stream_class *stream_class)
  71 {
  72         bt_field_wrapper_destroy((void *) field_wrapper);
  73 }
  74
  75 static
  76 bool stream_class_id_is_unique(const struct bt_trace_class *tc, uint64_t id)
  77 {
  78         uint64_t i;
  79         bool is_unique = true;
  80
  81         for (i = 0; i < tc->stream_classes->len; i++) {
  82                 const struct bt_stream_class *sc =
  83                         tc->stream_classes->pdata[i];
  84
  85                 if (sc->id == id) {
  86                         is_unique = false;
  87                         goto end;
  88                 }
  89         }
  90
  91 end:
  92         return is_unique;
  93 }
  94
  95 static
  96 struct bt_stream_class *create_stream_class_with_id(
  97                 struct bt_trace_class *tc, uint64_t id)
  98 {
  99         struct bt_stream_class *stream_class = NULL;
 100         int ret;
 101
 102         BT_ASSERT(tc);
 103         BT_ASSERT_PRE("stream-class-id-is-unique",
 104                 stream_class_id_is_unique(tc, id),
 105                 "Duplicate stream class ID: %![tc-]+T, id=%" PRIu64, tc, id);
 106         BT_LIB_LOGD("Creating stream class object: %![tc-]+T, id=%" PRIu64,
 107                 tc, id);
 108         stream_class = g_new0(struct bt_stream_class, 1);
 109         if (!stream_class) {
 110                 BT_LIB_LOGE_APPEND_CAUSE(
 111                         "Failed to allocate one stream class.");
 112                 goto error;
 113         }
 114
 115         bt_object_init_shared_with_parent(&stream_class->base,
 116                 destroy_stream_class);
 117         stream_class->user_attributes = bt_value_map_create();
 118         if (!stream_class->user_attributes) {
 119                 BT_LIB_LOGE_APPEND_CAUSE(
 120                         "Failed to create a map value object.");
 121                 goto error;
 122         }
 123
 124         stream_class->name.str = g_string_new(NULL);
 125         if (!stream_class->name.str) {
 126                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString.");
 127                 goto error;
 128         }
 129
 130         stream_class->id = id;
 131         stream_class->assigns_automatic_event_class_id = true;
 132         stream_class->assigns_automatic_stream_id = true;
 133         stream_class->event_classes = g_ptr_array_new_with_free_func(
 134                 (GDestroyNotify) bt_object_try_spec_release);
 135         if (!stream_class->event_classes) {
 136                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GPtrArray.");
 137                 goto error;
 138         }
 139
 140         ret = bt_object_pool_initialize(&stream_class->packet_context_field_pool,
 141                 (bt_object_pool_new_object_func) bt_field_wrapper_new,
 142                 (bt_object_pool_destroy_object_func) free_field_wrapper,
 143                 stream_class);
 144         if (ret) {
 145                 BT_LIB_LOGE_APPEND_CAUSE(
 146                         "Failed to initialize packet context field pool: ret=%d",
 147                         ret);
 148                 goto error;
 149         }
 150
 151         bt_object_set_parent(&stream_class->base, &tc->base);
 152         g_ptr_array_add(tc->stream_classes, stream_class);
 153         bt_trace_class_freeze(tc);
 154         BT_LIB_LOGD("Created stream class object: %!+S", stream_class);
 155         goto end;
 156
 157 error:
 158         BT_OBJECT_PUT_REF_AND_RESET(stream_class);
 159
 160 end:
 161         return stream_class;
 162 }
 163
 164 struct bt_stream_class *bt_stream_class_create(struct bt_trace_class *tc)
 165 {
 166         BT_ASSERT_PRE_NO_ERROR();
 167         BT_ASSERT_PRE_TC_NON_NULL(tc);
 168         BT_ASSERT_PRE("trace-class-automatically-assigns-stream-class-ids",
 169                 tc->assigns_automatic_stream_class_id,
 170                 "Trace class does not automatically assigns stream class IDs: "
 171                 "%![sc-]+T", tc);
 172         return create_stream_class_with_id(tc,
 173                 (uint64_t) tc->stream_classes->len);
 174 }
 175
 176 struct bt_stream_class *bt_stream_class_create_with_id(
 177                 struct bt_trace_class *tc, uint64_t id)
 178 {
 179         BT_ASSERT_PRE_NO_ERROR();
 180         BT_ASSERT_PRE_TC_NON_NULL(tc);
 181         BT_ASSERT_PRE(
 182                 "trace-class-does-not-automatically-assigns-stream-class-ids",
 183                 !tc->assigns_automatic_stream_class_id,
 184                 "Trace class automatically assigns stream class IDs: "
 185                 "%![sc-]+T", tc);
 186         return create_stream_class_with_id(tc, id);
 187 }
 188
 189 struct bt_trace_class *bt_stream_class_borrow_trace_class(
 190                 struct bt_stream_class *stream_class)
 191 {
 192         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 193         return bt_stream_class_borrow_trace_class_inline(stream_class);
 194 }
 195
 196 const struct bt_trace_class *bt_stream_class_borrow_trace_class_const(
 197                 const struct bt_stream_class *stream_class)
 198 {
 199         return bt_stream_class_borrow_trace_class((void *) stream_class);
 200 }
 201
 202 const char *bt_stream_class_get_name(const struct bt_stream_class *stream_class)
 203 {
 204         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 205         return stream_class->name.value;
 206 }
 207
 208 enum bt_stream_class_set_name_status bt_stream_class_set_name(
 209                 struct bt_stream_class *stream_class,
 210                 const char *name)
 211 {
 212         BT_ASSERT_PRE_NO_ERROR();
 213         BT_ASSERT_PRE_SC_NON_NULL(stream_class);
 214         BT_ASSERT_PRE_NAME_NON_NULL(name);
 215         BT_ASSERT_PRE_DEV_STREAM_CLASS_HOT(stream_class);
 216         g_string_assign(stream_class->name.str, name);
 217         stream_class->name.value = stream_class->name.str->str;
 218         BT_LIB_LOGD("Set stream class's name: %!+S", stream_class);
 219         return BT_FUNC_STATUS_OK;
 220 }
 221
 222 uint64_t bt_stream_class_get_id(const struct bt_stream_class *stream_class)
 223 {
 224         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 225         return stream_class->id;
 226 }
 227
 228 uint64_t bt_stream_class_get_event_class_count(
 229                 const struct bt_stream_class *stream_class)
 230 {
 231         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 232         return (uint64_t) stream_class->event_classes->len;
 233 }
 234
 235 struct bt_event_class *bt_stream_class_borrow_event_class_by_index(
 236                 struct bt_stream_class *stream_class, uint64_t index)
 237 {
 238         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 239         BT_ASSERT_PRE_DEV_VALID_INDEX(index, stream_class->event_classes->len);
 240         return g_ptr_array_index(stream_class->event_classes, index);
 241 }
 242
 243 const struct bt_event_class *
 244 bt_stream_class_borrow_event_class_by_index_const(
 245                 const struct bt_stream_class *stream_class, uint64_t index)
 246 {
 247         return bt_stream_class_borrow_event_class_by_index(
 248                 (void *) stream_class, index);
 249 }
 250
 251 struct bt_event_class *bt_stream_class_borrow_event_class_by_id(
 252                 struct bt_stream_class *stream_class, uint64_t id)
 253 {
 254         struct bt_event_class *event_class = NULL;
 255         uint64_t i;
 256
 257         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 258
 259         for (i = 0; i < stream_class->event_classes->len; i++) {
 260                 struct bt_event_class *event_class_candidate =
 261                         g_ptr_array_index(stream_class->event_classes, i);
 262
 263                 if (event_class_candidate->id == id) {
 264                         event_class = event_class_candidate;
 265                         goto end;
 266                 }
 267         }
 268
 269 end:
 270         return event_class;
 271 }
 272
 273 const struct bt_event_class *
 274 bt_stream_class_borrow_event_class_by_id_const(
 275                 const struct bt_stream_class *stream_class, uint64_t id)
 276 {
 277         return bt_stream_class_borrow_event_class_by_id(
 278                 (void *) stream_class, id);
 279 }
 280
 281 const struct bt_field_class *
 282 bt_stream_class_borrow_packet_context_field_class_const(
 283                 const struct bt_stream_class *stream_class)
 284 {
 285         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 286         return stream_class->packet_context_fc;
 287 }
 288
 289 struct bt_field_class *
 290 bt_stream_class_borrow_packet_context_field_class(
 291                 struct bt_stream_class *stream_class)
 292 {
 293         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 294         return stream_class->packet_context_fc;
 295 }
 296
 297 enum bt_stream_class_set_field_class_status
 298 bt_stream_class_set_packet_context_field_class(
 299                 struct bt_stream_class *stream_class,
 300                 struct bt_field_class *field_class)
 301 {
 302         int ret;
 303         struct bt_resolve_field_path_context resolve_ctx = {
 304                 .packet_context = field_class,
 305                 .event_common_context = NULL,
 306                 .event_specific_context = NULL,
 307                 .event_payload = NULL,
 308         };
 309
 310         BT_ASSERT_PRE_NO_ERROR();
 311         BT_ASSERT_PRE_SC_NON_NULL(stream_class);
 312         BT_ASSERT_PRE("supports-packets",
 313                 stream_class->supports_packets,
 314                 "Stream class does not support packets: %![sc-]+S",
 315                 stream_class);
 316         BT_ASSERT_PRE_FC_NON_NULL(field_class);
 317         BT_ASSERT_PRE_DEV_STREAM_CLASS_HOT(stream_class);
 318         BT_ASSERT_PRE_FC_IS_STRUCT("field-class", field_class,
 319                 "Packet context field class");
 320         ret = bt_resolve_field_paths(field_class, &resolve_ctx, __func__);
 321         if (ret) {
 322                 /*
 323                  * This is the only reason for which
 324                  * bt_resolve_field_paths() can fail: anything else
 325                  * would be because a precondition is not satisfied.
 326                  */
 327                 ret = BT_FUNC_STATUS_MEMORY_ERROR;
 328                 goto end;
 329         }
 330
 331         bt_field_class_make_part_of_trace_class(field_class);
 332         bt_object_put_ref(stream_class->packet_context_fc);
 333         stream_class->packet_context_fc = field_class;
 334         bt_object_get_ref_no_null_check(stream_class->packet_context_fc);
 335         bt_field_class_freeze(field_class);
 336         BT_LIB_LOGD("Set stream class's packet context field class: %!+S",
 337                 stream_class);
 338
 339 end:
 340         return ret;
 341 }
 342
 343 const struct bt_field_class *
 344 bt_stream_class_borrow_event_common_context_field_class_const(
 345                 const struct bt_stream_class *stream_class)
 346 {
 347         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 348         return stream_class->event_common_context_fc;
 349 }
 350
 351 struct bt_field_class *
 352 bt_stream_class_borrow_event_common_context_field_class(
 353                 struct bt_stream_class *stream_class)
 354 {
 355         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 356         return stream_class->event_common_context_fc;
 357 }
 358
 359 enum bt_stream_class_set_field_class_status
 360 bt_stream_class_set_event_common_context_field_class(
 361                 struct bt_stream_class *stream_class,
 362                 struct bt_field_class *field_class)
 363 {
 364         int ret;
 365         struct bt_resolve_field_path_context resolve_ctx = {
 366                 .packet_context = NULL,
 367                 .event_common_context = field_class,
 368                 .event_specific_context = NULL,
 369                 .event_payload = NULL,
 370         };
 371
 372         BT_ASSERT_PRE_NO_ERROR();
 373         BT_ASSERT_PRE_SC_NON_NULL(stream_class);
 374         BT_ASSERT_PRE_FC_NON_NULL(field_class);
 375         BT_ASSERT_PRE_DEV_STREAM_CLASS_HOT(stream_class);
 376         BT_ASSERT_PRE_FC_IS_STRUCT("field-class", field_class,
 377                 "Event common context field class");
 378         resolve_ctx.packet_context = stream_class->packet_context_fc;
 379         ret = bt_resolve_field_paths(field_class, &resolve_ctx, __func__);
 380         if (ret) {
 381                 /*
 382                  * This is the only reason for which
 383                  * bt_resolve_field_paths() can fail: anything else
 384                  * would be because a precondition is not satisfied.
 385                  */
 386                 ret = BT_FUNC_STATUS_MEMORY_ERROR;
 387                 goto end;
 388         }
 389
 390         bt_field_class_make_part_of_trace_class(field_class);
 391         bt_object_put_ref(stream_class->event_common_context_fc);
 392         stream_class->event_common_context_fc = field_class;
 393         bt_object_get_ref_no_null_check(stream_class->event_common_context_fc);
 394         bt_field_class_freeze(field_class);
 395         BT_LIB_LOGD("Set stream class's event common context field class: %!+S",
 396                 stream_class);
 397
 398 end:
 399         return ret;
 400 }
 401
 402 BT_HIDDEN
 403 void _bt_stream_class_freeze(const struct bt_stream_class *stream_class)
 404 {
 405         /* The field classes and default clock class are already frozen */
 406         BT_ASSERT(stream_class);
 407         BT_LIB_LOGD("Freezing stream class's user attributes: %!+v",
 408                 stream_class->user_attributes);
 409         bt_value_freeze(stream_class->user_attributes);
 410         BT_LIB_LOGD("Freezing stream class: %!+S", stream_class);
 411         ((struct bt_stream_class *) stream_class)->frozen = true;
 412 }
 413
 414 enum bt_stream_class_set_default_clock_class_status
 415 bt_stream_class_set_default_clock_class(
 416                 struct bt_stream_class *stream_class,
 417                 struct bt_clock_class *clock_class)
 418 {
 419         BT_ASSERT_PRE_NO_ERROR();
 420         BT_ASSERT_PRE_SC_NON_NULL(stream_class);
 421         BT_ASSERT_PRE_CLK_CLS_NON_NULL(clock_class);
 422         BT_ASSERT_PRE_DEV_STREAM_CLASS_HOT(stream_class);
 423         bt_object_put_ref(stream_class->default_clock_class);
 424         stream_class->default_clock_class = clock_class;
 425         bt_object_get_ref_no_null_check(stream_class->default_clock_class);
 426         bt_clock_class_freeze(clock_class);
 427         BT_LIB_LOGD("Set stream class's default clock class: %!+S",
 428                 stream_class);
 429         return BT_FUNC_STATUS_OK;
 430 }
 431
 432 struct bt_clock_class *bt_stream_class_borrow_default_clock_class(
 433                 struct bt_stream_class *stream_class)
 434 {
 435         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 436         return stream_class->default_clock_class;
 437 }
 438
 439 const struct bt_clock_class *bt_stream_class_borrow_default_clock_class_const(
 440                 const struct bt_stream_class *stream_class)
 441 {
 442         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 443         return stream_class->default_clock_class;
 444 }
 445
 446 bt_bool bt_stream_class_assigns_automatic_event_class_id(
 447                 const struct bt_stream_class *stream_class)
 448 {
 449         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 450         return (bt_bool) stream_class->assigns_automatic_event_class_id;
 451 }
 452
 453 void bt_stream_class_set_assigns_automatic_event_class_id(
 454                 struct bt_stream_class *stream_class,
 455                 bt_bool value)
 456 {
 457         BT_ASSERT_PRE_SC_NON_NULL(stream_class);
 458         BT_ASSERT_PRE_DEV_STREAM_CLASS_HOT(stream_class);
 459         stream_class->assigns_automatic_event_class_id = (bool) value;
 460         BT_LIB_LOGD("Set stream class's automatic event class ID "
 461                 "assignment property: %!+S", stream_class);
 462 }
 463
 464 bt_bool bt_stream_class_assigns_automatic_stream_id(
 465                 const struct bt_stream_class *stream_class)
 466 {
 467         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 468         return (bt_bool) stream_class->assigns_automatic_stream_id;
 469 }
 470
 471 void bt_stream_class_set_supports_discarded_events(
 472                 struct bt_stream_class *stream_class,
 473                 bt_bool supports_discarded_events,
 474                 bt_bool with_default_clock_snapshots)
 475 {
 476         BT_ASSERT_PRE_SC_NON_NULL(stream_class);
 477         BT_ASSERT_PRE_DEV_STREAM_CLASS_HOT(stream_class);
 478         BT_ASSERT_PRE("supports-discarded-events-for-default-clock-snapshots",
 479                 supports_discarded_events ||
 480                         !with_default_clock_snapshots,
 481                 "Discarded events cannot have default clock snapshots when "
 482                 "not supported: %!+S", stream_class);
 483         BT_ASSERT_PRE("has-default-clock-class-for-default-clock-snapshots",
 484                 !with_default_clock_snapshots ||
 485                         stream_class->default_clock_class,
 486                 "Stream class has no default clock class: %!+S", stream_class);
 487         stream_class->supports_discarded_events =
 488                 (bool) supports_discarded_events;
 489         stream_class->discarded_events_have_default_clock_snapshots =
 490                 (bool) with_default_clock_snapshots;
 491         BT_LIB_LOGD("Set stream class's discarded events support property: "
 492                 "%!+S", stream_class);
 493 }
 494
 495 bt_bool bt_stream_class_supports_discarded_events(
 496                 const struct bt_stream_class *stream_class)
 497 {
 498         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 499         return (bt_bool) stream_class->supports_discarded_events;
 500 }
 501
 502 bt_bool bt_stream_class_discarded_events_have_default_clock_snapshots(
 503                 const struct bt_stream_class *stream_class)
 504 {
 505         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 506         return (bt_bool) stream_class->discarded_events_have_default_clock_snapshots;
 507 }
 508
 509 void bt_stream_class_set_supports_discarded_packets(
 510                 struct bt_stream_class *stream_class,
 511                 bt_bool supports_discarded_packets,
 512                 bt_bool with_default_clock_snapshots)
 513 {
 514         BT_ASSERT_PRE_SC_NON_NULL(stream_class);
 515         BT_ASSERT_PRE_DEV_STREAM_CLASS_HOT(stream_class);
 516         BT_ASSERT_PRE("supports-packets-for-discarded-packets-support",
 517                 !supports_discarded_packets ||
 518                         stream_class->supports_packets,
 519                 "Stream class does not support packets: %!+S",
 520                 stream_class);
 521         BT_ASSERT_PRE("supports-discarded-packets-for-default-clock-snapshots",
 522                 supports_discarded_packets ||
 523                         !with_default_clock_snapshots,
 524                 "Discarded packets cannot have default clock snapshots when "
 525                 "not supported: %!+S", stream_class);
 526         BT_ASSERT_PRE("has-default-clock-class-for-default-clock-snapshots",
 527                 !with_default_clock_snapshots ||
 528                         stream_class->default_clock_class,
 529                 "Stream class has no default clock class: %!+S", stream_class);
 530         stream_class->supports_discarded_packets =
 531                 (bool) supports_discarded_packets;
 532         stream_class->discarded_packets_have_default_clock_snapshots =
 533                 (bool) with_default_clock_snapshots;
 534         BT_LIB_LOGD("Set stream class's discarded packets support property: "
 535                 "%!+S", stream_class);
 536 }
 537
 538 bt_bool bt_stream_class_supports_discarded_packets(
 539                 const struct bt_stream_class *stream_class)
 540 {
 541         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 542         return (bt_bool) stream_class->supports_discarded_packets;
 543 }
 544
 545 bt_bool bt_stream_class_discarded_packets_have_default_clock_snapshots(
 546                 const struct bt_stream_class *stream_class)
 547 {
 548         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 549         return (bt_bool) stream_class->discarded_packets_have_default_clock_snapshots;
 550 }
 551
 552 void bt_stream_class_set_supports_packets(
 553                 struct bt_stream_class *stream_class,
 554                 bt_bool supports_packets,
 555                 bt_bool with_beginning_default_clock_snapshot,
 556                 bt_bool with_end_default_clock_snapshot)
 557 {
 558         bt_bool with_default_clock_snapshot =
 559                 with_beginning_default_clock_snapshot ||
 560                 with_end_default_clock_snapshot;
 561         BT_ASSERT_PRE_SC_NON_NULL(stream_class);
 562         BT_ASSERT_PRE_DEV_STREAM_CLASS_HOT(stream_class);
 563         BT_ASSERT_PRE("supports-packets-for-default-clock-snapshot",
 564                 supports_packets ||
 565                         !with_default_clock_snapshot,
 566                 "Packets cannot have default clock snapshots when "
 567                 "not supported: %!+S", stream_class);
 568         BT_ASSERT_PRE("has-default-clock-class-for-default-clock-snapshot",
 569                 !with_default_clock_snapshot ||
 570                         stream_class->default_clock_class,
 571                 "Stream class has no default clock class: %!+S", stream_class);
 572         BT_ASSERT_PRE("supports-packets-for-packet-context-field-class",
 573                 supports_packets || !stream_class->packet_context_fc,
 574                 "Stream class already has a packet context field class: %!+S",
 575                 stream_class);
 576         BT_ASSERT_PRE("supports-packets-for-discarded-packets-support",
 577                 supports_packets || !stream_class->supports_discarded_packets,
 578                 "Stream class already supports discarded packets: %!+S",
 579                 stream_class);
 580         stream_class->supports_packets = (bool) supports_packets;
 581         stream_class->packets_have_beginning_default_clock_snapshot =
 582                 (bool) with_beginning_default_clock_snapshot;
 583         stream_class->packets_have_end_default_clock_snapshot =
 584                 (bool) with_end_default_clock_snapshot;
 585         BT_LIB_LOGD("Set stream class's packets support property: %!+S",
 586                 stream_class);
 587 }
 588
 589 bt_bool bt_stream_class_supports_packets(
 590                 const struct bt_stream_class *stream_class)
 591 {
 592         BT_ASSERT_PRE_SC_NON_NULL(stream_class);
 593         return (bt_bool) stream_class->supports_packets;
 594 }
 595
 596 bt_bool bt_stream_class_packets_have_beginning_default_clock_snapshot(
 597                 const struct bt_stream_class *stream_class)
 598 {
 599         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 600         return (bt_bool) stream_class->packets_have_beginning_default_clock_snapshot;
 601 }
 602
 603 bt_bool bt_stream_class_packets_have_end_default_clock_snapshot(
 604                 const struct bt_stream_class *stream_class)
 605 {
 606         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 607         return (bt_bool) stream_class->packets_have_end_default_clock_snapshot;
 608 }
 609
 610 void bt_stream_class_set_assigns_automatic_stream_id(
 611                 struct bt_stream_class *stream_class,
 612                 bt_bool value)
 613 {
 614         BT_ASSERT_PRE_SC_NON_NULL(stream_class);
 615         BT_ASSERT_PRE_DEV_STREAM_CLASS_HOT(stream_class);
 616         stream_class->assigns_automatic_stream_id = (bool) value;
 617         BT_LIB_LOGD("Set stream class's automatic stream ID "
 618                 "assignment property: %!+S", stream_class);
 619 }
 620
 621 const struct bt_value *bt_stream_class_borrow_user_attributes_const(
 622                 const struct bt_stream_class *stream_class)
 623 {
 624         BT_ASSERT_PRE_DEV_SC_NON_NULL(stream_class);
 625         return stream_class->user_attributes;
 626 }
 627
 628 struct bt_value *bt_stream_class_borrow_user_attributes(
 629                 struct bt_stream_class *stream_class)
 630 {
 631         return (void *) bt_stream_class_borrow_user_attributes_const(
 632                 (void *) stream_class);
 633 }
 634
 635 void bt_stream_class_set_user_attributes(
 636                 struct bt_stream_class *stream_class,
 637                 const struct bt_value *user_attributes)
 638 {
 639         BT_ASSERT_PRE_SC_NON_NULL(stream_class);
 640         BT_ASSERT_PRE_USER_ATTRS_NON_NULL(user_attributes);
 641         BT_ASSERT_PRE_USER_ATTRS_IS_MAP(user_attributes);
 642         BT_ASSERT_PRE_DEV_STREAM_CLASS_HOT(stream_class);
 643         bt_object_put_ref_no_null_check(stream_class->user_attributes);
 644         stream_class->user_attributes = (void *) user_attributes;
 645         bt_object_get_ref_no_null_check(stream_class->user_attributes);
 646 }
 647
 648 void bt_stream_class_get_ref(const struct bt_stream_class *stream_class)
 649 {
 650         bt_object_get_ref(stream_class);
 651 }
 652
 653 void bt_stream_class_put_ref(const struct bt_stream_class *stream_class)
 654 {
 655         bt_object_put_ref(stream_class);
 656 }