X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=lib%2Fctf-ir%2Fpacket.c;h=d3fce47af34e1a872c653609ce9114f5aa5d7cc8;hp=43506ef8c1bc54404c5e67e178ed611b2771cfeb;hb=44c440bc5fe8219cc17d1b786d91fd83c4c9860a;hpb=c800eb3790218d2f33df01e77ec38cbd43cc02a1 diff --git a/lib/ctf-ir/packet.c b/lib/ctf-ir/packet.c index 43506ef8..d3fce47a 100644 --- a/lib/ctf-ir/packet.c +++ b/lib/ctf-ir/packet.c @@ -37,28 +37,32 @@ #include #include #include +#include #include #include #include #include #include +#define BT_ASSERT_PRE_PACKET_HOT(_packet) \ + BT_ASSERT_PRE_HOT((_packet), "Packet", ": %!+a", (_packet)) + struct bt_stream *bt_packet_borrow_stream(struct bt_packet *packet) { BT_ASSERT_PRE_NON_NULL(packet, "Packet"); return packet->stream; } -struct bt_field *bt_packet_borrow_header(struct bt_packet *packet) +struct bt_field *bt_packet_borrow_header_field(struct bt_packet *packet) { BT_ASSERT_PRE_NON_NULL(packet, "Packet"); - return packet->header ? (void *) packet->header->field : NULL; + return packet->header_field ? packet->header_field->field : NULL; } -struct bt_field *bt_packet_borrow_context(struct bt_packet *packet) +struct bt_field *bt_packet_borrow_context_field(struct bt_packet *packet) { BT_ASSERT_PRE_NON_NULL(packet, "Packet"); - return packet->context ? (void *) packet->context->field : NULL; + return packet->context_field ? packet->context_field->field : NULL; } BT_HIDDEN @@ -68,20 +72,18 @@ void _bt_packet_set_is_frozen(struct bt_packet *packet, bool is_frozen) return; } - BT_LOGD("Setting packet's frozen state: addr=%p, frozen=%d", - packet, is_frozen); + BT_LIB_LOGD("Setting packet's frozen state: %![packet-]+a, " + "is-frozen=%d", packet, is_frozen); - if (packet->header) { - BT_LOGD("Setting packet's header field's frozen state: " - "frozen=%d", is_frozen); - bt_field_set_is_frozen_recursive((void *) packet->header->field, + if (packet->header_field) { + BT_LOGD_STR("Setting packet's header field's frozen state."); + bt_field_set_is_frozen(packet->header_field->field, is_frozen); } - if (packet->context) { - BT_LOGD("Setting packet's context field's frozen state: " - "frozen=%d", is_frozen); - bt_field_set_is_frozen_recursive((void *) packet->context->field, + if (packet->context_field) { + BT_LOGD_STR("Setting packet's context field's frozen state."); + bt_field_set_is_frozen(packet->context_field->field, is_frozen); } @@ -89,62 +91,44 @@ void _bt_packet_set_is_frozen(struct bt_packet *packet, bool is_frozen) } static inline -void bt_packet_reset_avail(struct bt_packet *packet) +void reset_counter_snapshots(struct bt_packet *packet) { - /* Previous packet */ - packet->prev_packet_info.avail = - BT_PACKET_PREVIOUS_PACKET_AVAILABILITY_NOT_AVAILABLE; - packet->prev_packet_info.discarded_event_counter.avail = - BT_PACKET_PROPERTY_AVAILABILITY_NOT_AVAILABLE; - packet->prev_packet_info.seq_num.avail = - BT_PACKET_PROPERTY_AVAILABILITY_NOT_AVAILABLE; - packet->prev_packet_info.default_end_cv.avail = - BT_PACKET_PROPERTY_AVAILABILITY_NOT_AVAILABLE; - - /* Current packet */ - packet->discarded_event_counter.avail = - BT_PACKET_PROPERTY_AVAILABILITY_NOT_AVAILABLE; - packet->seq_num.avail = - BT_PACKET_PROPERTY_AVAILABILITY_NOT_AVAILABLE; - - /* Computed */ - packet->discarded_event_count.avail = - BT_PACKET_PROPERTY_AVAILABILITY_NOT_AVAILABLE; - packet->discarded_packet_count.avail = - BT_PACKET_PROPERTY_AVAILABILITY_NOT_AVAILABLE; + packet->discarded_event_counter_snapshot.base.avail = + BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE; + packet->packet_counter_snapshot.base.avail = + BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE; } static inline -void bt_packet_reset(struct bt_packet *packet) +void reset_packet(struct bt_packet *packet) { BT_ASSERT(packet); + BT_LIB_LOGD("Resetting packet: %!+a", packet); bt_packet_set_is_frozen(packet, false); - if (packet->header) { - bt_field_set_is_frozen_recursive( - (void *) packet->header->field, false); - bt_field_reset_recursive((void *) packet->header->field); + if (packet->header_field) { + bt_field_set_is_frozen(packet->header_field->field, false); + bt_field_reset(packet->header_field->field); } - if (packet->context) { - bt_field_set_is_frozen_recursive( - (void *) packet->context->field, false); - bt_field_reset_recursive((void *) packet->context->field); + if (packet->context_field) { + bt_field_set_is_frozen(packet->context_field->field, false); + bt_field_reset(packet->context_field->field); } - bt_clock_value_set_reset(&packet->begin_cv_set); - bt_clock_value_set_reset(&packet->end_cv_set); - bt_packet_reset_avail(packet); - bt_packet_invalidate_properties(packet); + if (packet->default_beginning_cv) { + bt_clock_value_reset(packet->default_beginning_cv); + } - if (packet->prev_packet_info.default_end_cv.cv) { - bt_clock_value_recycle(packet->prev_packet_info.default_end_cv.cv); - packet->prev_packet_info.default_end_cv.cv = NULL; + if (packet->default_end_cv) { + bt_clock_value_reset(packet->default_end_cv); } + + reset_counter_snapshots(packet); } static -void bt_packet_header_field_recycle(struct bt_field_wrapper *header_field, +void recycle_header_field(struct bt_field_wrapper *header_field, struct bt_trace *trace) { BT_ASSERT(header_field); @@ -156,7 +140,7 @@ void bt_packet_header_field_recycle(struct bt_field_wrapper *header_field, } static -void bt_packet_context_field_recycle(struct bt_field_wrapper *context_field, +void recycle_context_field(struct bt_field_wrapper *context_field, struct bt_stream_class *stream_class) { BT_ASSERT(context_field); @@ -197,7 +181,7 @@ void bt_packet_recycle(struct bt_packet *packet) * * 4. Put our stream reference. */ - bt_packet_reset(packet); + reset_packet(packet); stream = packet->stream; BT_ASSERT(stream); packet->stream = NULL; @@ -208,32 +192,39 @@ void bt_packet_recycle(struct bt_packet *packet) BT_HIDDEN void bt_packet_destroy(struct bt_packet *packet) { - BT_LOGD("Destroying packet: addr=%p", packet); - BT_LOGD_STR("Destroying packet's header field."); + BT_LIB_LOGD("Destroying packet: %!+a", packet); - if (packet->header) { + if (packet->header_field) { if (packet->stream) { BT_LOGD_STR("Recycling packet's header field."); - bt_packet_header_field_recycle(packet->header, - bt_stream_class_borrow_trace( - bt_stream_borrow_class(packet->stream))); + recycle_header_field(packet->header_field, + bt_stream_class_borrow_trace_inline( + packet->stream->class)); } else { - bt_field_wrapper_destroy(packet->header); + bt_field_wrapper_destroy(packet->header_field); } } - if (packet->context) { + if (packet->context_field) { if (packet->stream) { BT_LOGD_STR("Recycling packet's context field."); - bt_packet_context_field_recycle(packet->context, - bt_stream_borrow_class(packet->stream)); + recycle_context_field(packet->context_field, + packet->stream->class); } else { - bt_field_wrapper_destroy(packet->context); + bt_field_wrapper_destroy(packet->context_field); } } - bt_clock_value_set_finalize(&packet->begin_cv_set); - bt_clock_value_set_finalize(&packet->end_cv_set); + if (packet->default_beginning_cv) { + BT_LOGD_STR("Recycling beginning clock value."); + bt_clock_value_recycle(packet->default_beginning_cv); + } + + if (packet->default_end_cv) { + BT_LOGD_STR("Recycling end clock value."); + bt_clock_value_recycle(packet->default_end_cv); + } + BT_LOGD_STR("Putting packet's stream."); bt_put(packet->stream); g_free(packet); @@ -243,281 +234,80 @@ BT_HIDDEN struct bt_packet *bt_packet_new(struct bt_stream *stream) { struct bt_packet *packet = NULL; - struct bt_stream_class *stream_class = NULL; struct bt_trace *trace = NULL; BT_ASSERT(stream); - BT_LOGD("Creating packet object: stream-addr=%p, " - "stream-name=\"%s\", stream-class-addr=%p, " - "stream-class-name=\"%s\", stream-class-id=%" PRId64, - stream, bt_stream_get_name(stream), - stream->stream_class, - bt_stream_class_get_name(stream->stream_class), - bt_stream_class_get_id(stream->stream_class)); - stream_class = bt_stream_borrow_class(stream); - BT_ASSERT(stream_class); - trace = bt_stream_class_borrow_trace(stream_class); - BT_ASSERT(trace); + BT_LIB_LOGD("Creating packet object: %![stream-]+s", stream); packet = g_new0(struct bt_packet, 1); if (!packet) { BT_LOGE_STR("Failed to allocate one packet object."); - goto end; + goto error; } bt_object_init_shared(&packet->base, (bt_object_release_func) bt_packet_recycle); packet->stream = bt_get(stream); + trace = bt_stream_class_borrow_trace_inline(stream->class); + BT_ASSERT(trace); - if (trace->packet_header_field_type) { - BT_LOGD("Creating initial packet header field: ft-addr=%p", - trace->packet_header_field_type); - packet->header = bt_field_wrapper_create( + if (trace->packet_header_ft) { + BT_LOGD_STR("Creating initial packet header field."); + packet->header_field = bt_field_wrapper_create( &trace->packet_header_field_pool, - (void *) trace->packet_header_field_type); - if (!packet->header) { - BT_LOGE("Cannot create packet header field wrapper."); - BT_PUT(packet); - goto end; + trace->packet_header_ft); + if (!packet->header_field) { + BT_LOGE_STR("Cannot create packet header field wrapper."); + goto error; } } - if (stream->stream_class->packet_context_field_type) { - BT_LOGD("Creating initial packet context field: ft-addr=%p", - stream->stream_class->packet_context_field_type); - packet->context = bt_field_wrapper_create( - &stream_class->packet_context_field_pool, - (void *) stream->stream_class->packet_context_field_type); - if (!packet->context) { - BT_LOGE("Cannot create packet context field wrapper."); - BT_PUT(packet); - goto end; + if (stream->class->packet_context_ft) { + BT_LOGD_STR("Creating initial packet context field."); + packet->context_field = bt_field_wrapper_create( + &stream->class->packet_context_field_pool, + stream->class->packet_context_ft); + if (!packet->context_field) { + BT_LOGE_STR("Cannot create packet context field wrapper."); + goto error; } } - if (bt_clock_value_set_initialize(&packet->begin_cv_set)) { - BT_PUT(packet); - goto end; - } - - if (bt_clock_value_set_initialize(&packet->end_cv_set)) { - BT_PUT(packet); - goto end; - } - - bt_packet_reset_avail(packet); - BT_LOGD("Created packet object: addr=%p", packet); - -end: - return packet; -} - -static inline -uint64_t get_uint_field_value(struct bt_field *parent_field, const char *name) -{ - uint64_t val = UINT64_C(-1); - struct bt_field *field = bt_field_structure_borrow_field_by_name( - parent_field, name); - int ret; - - if (!field) { - goto end; - } - - BT_ASSERT(bt_field_is_integer(field)); - BT_ASSERT(!bt_field_type_integer_is_signed( - bt_field_borrow_type(field))); - ret = bt_field_integer_unsigned_get_value(field, &val); - BT_ASSERT(ret == 0); - -end: - return val; -} - -static inline -void set_packet_prop_uint64(struct bt_packet_prop_uint64 *prop, uint64_t val) -{ - BT_ASSERT(prop); - prop->value = val; - prop->avail = BT_PACKET_PROPERTY_AVAILABILITY_AVAILABLE; -} - -static inline -int set_packet_default_clock_value(struct bt_field *pkt_ctx_field, - const char *field_name, struct bt_clock_value_set *cv_set) -{ - int ret = 0; - uint64_t val = UINT64_C(-1); - struct bt_field *field = bt_field_structure_borrow_field_by_name( - pkt_ctx_field, field_name); - struct bt_clock_class *clock_class; - - if (!field) { - goto end; - } - - BT_ASSERT(bt_field_is_integer(field)); - BT_ASSERT(!bt_field_type_integer_is_signed( - bt_field_borrow_type(field))); - clock_class = bt_field_type_integer_borrow_mapped_clock_class( - bt_field_borrow_type(field)); - if (!clock_class) { - goto end; - } - - ret = bt_field_integer_unsigned_get_value(field, &val); - BT_ASSERT(ret == 0); - ret = bt_clock_value_set_set_clock_value(cv_set, clock_class, - val, true); - -end: - return ret; -} - -BT_HIDDEN -int bt_packet_set_properties(struct bt_packet *packet) -{ - struct bt_field *pkt_context_field; - uint64_t val; - int ret = 0; - - BT_ASSERT(!packet->props_are_set); - - pkt_context_field = bt_packet_borrow_context(packet); - if (!pkt_context_field) { - goto end; - } - - /* Discarded event counter */ - val = get_uint_field_value(pkt_context_field, "events_discarded"); - if (val != UINT64_C(-1)) { - set_packet_prop_uint64(&packet->discarded_event_counter, val); - } - - /* Sequence number */ - val = get_uint_field_value(pkt_context_field, "packet_seq_num"); - if (val != UINT64_C(-1)) { - set_packet_prop_uint64(&packet->seq_num, val); - } - - /* Beginning and end times */ - ret = set_packet_default_clock_value(pkt_context_field, - "timestamp_begin", &packet->begin_cv_set); - if (ret) { - goto end; - } - - ret = set_packet_default_clock_value(pkt_context_field, - "timestamp_end", &packet->end_cv_set); - if (ret) { - goto end; - } - - /* Information from previous packet */ - if (packet->prev_packet_info.avail == - BT_PACKET_PREVIOUS_PACKET_AVAILABILITY_AVAILABLE) { - /* Discarded event count */ - if (packet->prev_packet_info.discarded_event_counter.avail == - BT_PACKET_PROPERTY_AVAILABILITY_AVAILABLE) { - BT_ASSERT(packet->discarded_event_counter.avail == - BT_PACKET_PROPERTY_AVAILABILITY_AVAILABLE); - set_packet_prop_uint64(&packet->discarded_event_count, - packet->discarded_event_counter.value - - packet->prev_packet_info.discarded_event_counter.value); + if (stream->class->default_clock_class) { + if (stream->class->packets_have_default_beginning_cv) { + packet->default_beginning_cv = bt_clock_value_create( + stream->class->default_clock_class); + if (!packet->default_beginning_cv) { + /* bt_clock_value_create() logs errors */ + goto error; + } } - /* Discarded packet count */ - if (packet->prev_packet_info.seq_num.avail == - BT_PACKET_PROPERTY_AVAILABILITY_AVAILABLE) { - BT_ASSERT(packet->seq_num.avail == - BT_PACKET_PROPERTY_AVAILABILITY_AVAILABLE); - set_packet_prop_uint64(&packet->discarded_packet_count, - packet->seq_num.value - - packet->prev_packet_info.seq_num.value - 1); + if (stream->class->packets_have_default_end_cv) { + packet->default_end_cv = bt_clock_value_create( + stream->class->default_clock_class); + if (!packet->default_end_cv) { + /* bt_clock_value_create() logs errors */ + goto error; + } } } -end: - return ret; -} - -static -int snapshot_prev_packet_properties(struct bt_packet *packet, - enum bt_packet_previous_packet_availability prev_packet_avail, - struct bt_packet *prev_packet) -{ - int ret = 0; - struct bt_clock_value *prev_packet_default_end_cv; - - if (!prev_packet) { - goto end; - } - - if (!prev_packet->props_are_set) { - ret = bt_packet_set_properties(prev_packet); - if (ret) { - BT_LIB_LOGE("Cannot update previous packet's properties: " - "%![prev-packet-]+a", prev_packet); - goto end; - } - } - - packet->prev_packet_info.avail = prev_packet_avail; - prev_packet_default_end_cv = prev_packet->end_cv_set.default_cv; - - /* End time */ - if (prev_packet_default_end_cv) { - /* Copy clock value */ - packet->prev_packet_info.default_end_cv.cv = - bt_clock_value_create( - prev_packet_default_end_cv->clock_class); - if (!packet->prev_packet_info.default_end_cv.cv) { - BT_LIB_LOGE("Cannot create a clock value from a clock class: " - "%![cc-]+K", - prev_packet_default_end_cv->clock_class); - ret = -1; - goto end; - } - - bt_clock_value_set_raw_value( - packet->prev_packet_info.default_end_cv.cv, - prev_packet_default_end_cv->value); - packet->prev_packet_info.default_end_cv.avail = - BT_PACKET_PROPERTY_AVAILABILITY_AVAILABLE; - } - - /* Discarded event counter */ - packet->prev_packet_info.discarded_event_counter = - prev_packet->discarded_event_counter; + reset_counter_snapshots(packet); + BT_LIB_LOGD("Created packet object: %!+a", packet); + goto end; - /* Sequence number */ - packet->prev_packet_info.seq_num = prev_packet->seq_num; +error: + BT_PUT(packet); end: - return ret; + return packet; } -struct bt_packet *bt_packet_create(struct bt_stream *stream, - enum bt_packet_previous_packet_availability prev_packet_avail, - struct bt_packet *prev_packet) +struct bt_packet *bt_packet_create(struct bt_stream *stream) { struct bt_packet *packet = NULL; - int ret; BT_ASSERT_PRE_NON_NULL(stream, "Stream"); - BT_ASSERT_PRE(!prev_packet || prev_packet->stream == stream, - "New packet's and previous packet's stream are not the same: " - "%![new-packet-stream-]+s, %![prev-packet]+a, " - "%![prev-packet-stream]+s", stream, prev_packet, - prev_packet->stream); - BT_ASSERT_PRE( - prev_packet_avail == BT_PACKET_PREVIOUS_PACKET_AVAILABILITY_AVAILABLE || - prev_packet_avail == BT_PACKET_PREVIOUS_PACKET_AVAILABILITY_NOT_AVAILABLE || - prev_packet_avail == BT_PACKET_PREVIOUS_PACKET_AVAILABILITY_NONE, - "Invalid previous packet availability value: val=%d", - prev_packet_avail); - BT_ASSERT_PRE(!prev_packet || - prev_packet_avail == BT_PACKET_PREVIOUS_PACKET_AVAILABILITY_AVAILABLE, - "Previous packet is available, but previous packet is NULL."); packet = bt_object_pool_create_object(&stream->packet_pool); if (unlikely(!packet)) { BT_LIB_LOGE("Cannot allocate one packet from stream's packet pool: " @@ -525,166 +315,174 @@ struct bt_packet *bt_packet_create(struct bt_stream *stream, goto end; } - if (unlikely(!packet->stream)) { + if (likely(!packet->stream)) { packet->stream = stream; bt_object_get_no_null_check_no_parent_check( &packet->stream->base); } - ret = snapshot_prev_packet_properties(packet, prev_packet_avail, - prev_packet); - if (ret) { - /* Recycle */ - BT_PUT(packet); - goto end; - } - - if (prev_packet) { - bt_packet_validate_properties(prev_packet); - bt_packet_set_is_frozen(prev_packet, true); - } - - goto end; - end: return packet; } -int bt_packet_move_header(struct bt_packet *packet, +int bt_packet_move_header_field(struct bt_packet *packet, struct bt_packet_header_field *header_field) { struct bt_trace *trace; struct bt_field_wrapper *field_wrapper = (void *) header_field; - BT_ASSERT_PRE_NON_NULL(packet, "Event"); + BT_ASSERT_PRE_NON_NULL(packet, "Packet"); BT_ASSERT_PRE_NON_NULL(field_wrapper, "Header field"); - BT_ASSERT_PRE_HOT(packet, "Packet", ": %!+a", packet); - trace = bt_stream_class_borrow_trace( - bt_stream_borrow_class(packet->stream)); - BT_ASSERT_PRE(trace->packet_header_field_type, + BT_ASSERT_PRE_PACKET_HOT(packet); + trace = bt_stream_class_borrow_trace_inline(packet->stream->class); + BT_ASSERT_PRE(trace->packet_header_ft, "Trace has no packet header field type: %!+t", trace); - - /* TODO: compare field types (precondition) */ + BT_ASSERT_PRE(field_wrapper->field->type == + trace->packet_header_ft, + "Unexpected packet header field's type: " + "%![ft-]+F, %![expected-ft-]+F", field_wrapper->field->type, + trace->packet_header_ft); /* Recycle current header field: always exists */ - BT_ASSERT(packet->header); - bt_packet_header_field_recycle(packet->header, trace); + BT_ASSERT(packet->header_field); + recycle_header_field(packet->header_field, trace); /* Move new field */ - packet->header = field_wrapper; + packet->header_field = field_wrapper; return 0; } -int bt_packet_move_context(struct bt_packet *packet, +int bt_packet_move_context_field(struct bt_packet *packet, struct bt_packet_context_field *context_field) { struct bt_stream_class *stream_class; struct bt_field_wrapper *field_wrapper = (void *) context_field; - BT_ASSERT_PRE_NON_NULL(packet, "Event"); + BT_ASSERT_PRE_NON_NULL(packet, "Packet"); BT_ASSERT_PRE_NON_NULL(field_wrapper, "Context field"); BT_ASSERT_PRE_HOT(packet, "Packet", ": %!+a", packet); - stream_class = bt_stream_borrow_class(packet->stream); - BT_ASSERT_PRE(stream_class->packet_context_field_type, + stream_class = packet->stream->class; + BT_ASSERT_PRE(stream_class->packet_context_ft, "Stream class has no packet context field type: %!+S", stream_class); - - /* TODO: compare field types (precondition) */ + BT_ASSERT_PRE(field_wrapper->field->type == + stream_class->packet_context_ft, + "Unexpected packet header field's type: " + "%![ft-]+F, %![expected-ft-]+F", field_wrapper->field->type, + stream_class->packet_context_ft); /* Recycle current context field: always exists */ - BT_ASSERT(packet->context); - bt_packet_context_field_recycle(packet->context, stream_class); + BT_ASSERT(packet->context_field); + recycle_context_field(packet->context_field, stream_class); /* Move new field */ - packet->context = field_wrapper; + packet->context_field = field_wrapper; return 0; } -enum bt_packet_property_availability -bt_packet_borrow_default_beginning_clock_value(struct bt_packet *packet, - struct bt_clock_value **clock_value) +int bt_packet_set_default_beginning_clock_value(struct bt_packet *packet, + uint64_t value_cycles) { - enum bt_packet_property_availability avail = - BT_PACKET_PROPERTY_AVAILABILITY_AVAILABLE; + struct bt_stream_class *sc; BT_ASSERT_PRE_NON_NULL(packet, "Packet"); - BT_ASSERT_PRE_NON_NULL(clock_value, "Clock value"); - *clock_value = packet->begin_cv_set.default_cv; - if (!*clock_value) { - avail = BT_PACKET_PROPERTY_AVAILABILITY_NOT_AVAILABLE; - } - - return avail; + BT_ASSERT_PRE_PACKET_HOT(packet); + sc = packet->stream->class; + BT_ASSERT(sc); + BT_ASSERT_PRE(sc->default_clock_class, + "Packet's stream class has no default clock class: " + "%![packet-]+a, %![sc-]+S", packet, sc); + BT_ASSERT_PRE(sc->packets_have_default_beginning_cv, + "Packet's stream class indicates that its packets have " + "no default beginning clock value: %![packet-]+a, %![sc-]+S", + packet, sc); + BT_ASSERT(packet->default_beginning_cv); + bt_clock_value_set_value_inline(packet->default_beginning_cv, value_cycles); + BT_LIB_LOGV("Set packet's default beginning clock value: " + "%![packet-]+a, value=%" PRIu64, value_cycles); + return 0; } -enum bt_packet_property_availability -bt_packet_borrow_default_end_clock_value(struct bt_packet *packet, - struct bt_clock_value **clock_value) +enum bt_clock_value_status bt_packet_borrow_default_beginning_clock_value( + struct bt_packet *packet, struct bt_clock_value **clock_value) { - enum bt_packet_property_availability avail = - BT_PACKET_PROPERTY_AVAILABILITY_AVAILABLE; - BT_ASSERT_PRE_NON_NULL(packet, "Packet"); - BT_ASSERT_PRE_NON_NULL(clock_value, "Clock value"); - *clock_value = packet->end_cv_set.default_cv; - if (!*clock_value) { - avail = BT_PACKET_PROPERTY_AVAILABILITY_NOT_AVAILABLE; - } - - return avail; + BT_ASSERT_PRE_NON_NULL(clock_value, "Clock value (output)"); + *clock_value = packet->default_beginning_cv; + return BT_CLOCK_VALUE_STATUS_KNOWN; } -enum bt_packet_previous_packet_availability -bt_packet_get_previous_packet_availability(struct bt_packet *packet) +int bt_packet_set_default_end_clock_value(struct bt_packet *packet, + uint64_t value_cycles) { + struct bt_stream_class *sc; + BT_ASSERT_PRE_NON_NULL(packet, "Packet"); - return packet->prev_packet_info.avail; + BT_ASSERT_PRE_PACKET_HOT(packet); + sc = packet->stream->class; + BT_ASSERT(sc); + BT_ASSERT_PRE(sc->default_clock_class, + "Packet's stream class has no default clock class: " + "%![packet-]+a, %![sc-]+S", packet, sc); + BT_ASSERT_PRE(sc->packets_have_default_end_cv, + "Packet's stream class indicates that its packets have " + "no default end clock value: %![packet-]+a, %![sc-]+S", + packet, sc); + BT_ASSERT(packet->default_end_cv); + bt_clock_value_set_value_inline(packet->default_end_cv, value_cycles); + BT_LIB_LOGV("Set packet's default end clock value: " + "%![packet-]+a, value=%" PRIu64, value_cycles); + return 0; } -enum bt_packet_property_availability -bt_packet_borrow_previous_packet_default_end_clock_value( +enum bt_clock_value_status bt_packet_borrow_default_end_clock_value( struct bt_packet *packet, struct bt_clock_value **clock_value) { BT_ASSERT_PRE_NON_NULL(packet, "Packet"); - BT_ASSERT_PRE_NON_NULL(clock_value, "Clock value"); - *clock_value = packet->prev_packet_info.default_end_cv.cv; - return packet->prev_packet_info.default_end_cv.avail; + BT_ASSERT_PRE_NON_NULL(clock_value, "Clock value (output)"); + *clock_value = packet->default_end_cv; + return BT_CLOCK_VALUE_STATUS_KNOWN; } -enum bt_packet_property_availability bt_packet_get_discarded_event_counter( - struct bt_packet *packet, uint64_t *counter) +enum bt_property_availability bt_packet_get_discarded_event_counter_snapshot( + struct bt_packet *packet, uint64_t *value) { BT_ASSERT_PRE_NON_NULL(packet, "Packet"); - BT_ASSERT_PRE_NON_NULL(counter, "Counter"); - *counter = packet->discarded_event_counter.value; - return packet->discarded_event_counter.avail; + BT_ASSERT_PRE_NON_NULL(value, "Value (output)"); + *value = packet->discarded_event_counter_snapshot.value; + return packet->discarded_event_counter_snapshot.base.avail; } -enum bt_packet_property_availability bt_packet_get_sequence_number( - struct bt_packet *packet, uint64_t *sequence_number) +int bt_packet_set_discarded_event_counter_snapshot(struct bt_packet *packet, + uint64_t value) { BT_ASSERT_PRE_NON_NULL(packet, "Packet"); - BT_ASSERT_PRE_NON_NULL(sequence_number, "Sequence number"); - *sequence_number = packet->seq_num.value; - return packet->seq_num.avail; + BT_ASSERT_PRE_PACKET_HOT(packet); + BT_ASSERT_PRE(packet->stream->class->packets_have_discarded_event_counter_snapshot, + "Packet's stream's discarded event counter is not enabled: " + "%![packet-]+a", packet); + bt_property_uint_set(&packet->discarded_event_counter_snapshot, value); + return 0; } -enum bt_packet_property_availability bt_packet_get_discarded_event_count( - struct bt_packet *packet, uint64_t *count) +enum bt_property_availability bt_packet_get_packet_counter_snapshot( + struct bt_packet *packet, uint64_t *value) { BT_ASSERT_PRE_NON_NULL(packet, "Packet"); - BT_ASSERT_PRE_NON_NULL(count, "Count"); - *count = packet->discarded_event_count.value; - return packet->discarded_event_count.avail; + BT_ASSERT_PRE_NON_NULL(value, "Value (output)"); + *value = packet->packet_counter_snapshot.value; + return packet->packet_counter_snapshot.base.avail; } -enum bt_packet_property_availability bt_packet_get_discarded_packet_count( - struct bt_packet *packet, uint64_t *count) +int bt_packet_set_packet_counter_snapshot(struct bt_packet *packet, + uint64_t value) { BT_ASSERT_PRE_NON_NULL(packet, "Packet"); - BT_ASSERT_PRE_NON_NULL(count, "Count"); - *count = packet->discarded_packet_count.value; - return packet->discarded_packet_count.avail; + BT_ASSERT_PRE_PACKET_HOT(packet); + BT_ASSERT_PRE(packet->stream->class->packets_have_packet_counter_snapshot, + "Packet's stream's packet counter is not enabled: " + "%![packet-]+a", packet); + bt_property_uint_set(&packet->packet_counter_snapshot, value); + return 0; } -