X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=lib%2Fctf-ir%2Fpacket.c;h=d3fce47af34e1a872c653609ce9114f5aa5d7cc8;hb=7b33a0e0d8f23d90285ea7c7820a725bcbd96c6b;hp=ad09416bc52af2209b2fe1fd24f759c5dfcb6da8;hpb=8fc063a27ce18a902d8d5d3255bc31c9f44c64c2;p=babeltrace.git diff --git a/lib/ctf-ir/packet.c b/lib/ctf-ir/packet.c index ad09416b..d3fce47a 100644 --- a/lib/ctf-ir/packet.c +++ b/lib/ctf-ir/packet.c @@ -37,48 +37,53 @@ #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 void _bt_packet_set_is_frozen(struct bt_packet *packet, bool is_frozen) { - if (!packet || packet->frozen) { + if (!packet) { return; } - BT_LOGD("Freezing packet: addr=%p", packet); + BT_LIB_LOGD("Setting packet's frozen state: %![packet-]+a, " + "is-frozen=%d", packet, is_frozen); - if (packet->header) { - BT_LOGD_STR("Freezing packet's header field."); - 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_STR("Freezing packet's context field."); - 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); } @@ -86,29 +91,44 @@ void _bt_packet_set_is_frozen(struct bt_packet *packet, bool is_frozen) } static inline -void bt_packet_reset(struct bt_packet *packet) +void reset_counter_snapshots(struct bt_packet *packet) +{ + 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 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_field) { + bt_field_set_is_frozen(packet->context_field->field, false); + bt_field_reset(packet->context_field->field); + } + + if (packet->default_beginning_cv) { + bt_clock_value_reset(packet->default_beginning_cv); } - if (packet->context) { - bt_field_set_is_frozen_recursive( - (void *) packet->context->field, false); - bt_field_reset_recursive((void *) packet->context->field); + if (packet->default_end_cv) { + bt_clock_value_reset(packet->default_end_cv); } - bt_clock_value_set_reset(&packet->begin_cv_set); - bt_clock_value_set_reset(&packet->end_cv_set); + 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); @@ -120,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); @@ -161,43 +181,50 @@ 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; bt_object_pool_recycle_object(&stream->packet_pool, packet); - bt_object_put_no_null_check(&stream->common.base); + bt_object_put_no_null_check(&stream->base); } 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); @@ -207,68 +234,70 @@ 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->common.stream_class, - bt_stream_class_common_get_name(stream->common.stream_class), - bt_stream_class_common_get_id(stream->common.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->common.packet_header_field_type) { - BT_LOGD("Creating initial packet header field: ft-addr=%p", - trace->common.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->common.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->common.stream_class->packet_context_field_type) { - BT_LOGD("Creating initial packet context field: ft-addr=%p", - stream->common.stream_class->packet_context_field_type); - packet->context = bt_field_wrapper_create( - &stream_class->packet_context_field_pool, - (void *) stream->common.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 (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; + } + } - if (bt_clock_value_set_initialize(&packet->end_cv_set)) { - BT_PUT(packet); - goto end; + 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; + } + } } - BT_LOGD("Created packet object: addr=%p", packet); + reset_counter_snapshots(packet); + BT_LIB_LOGD("Created packet object: %!+a", packet); + goto end; + +error: + BT_PUT(packet); end: return packet; @@ -286,119 +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->common.base); + &packet->stream->base); } - 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->common.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->common.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; } -int bt_packet_set_beginning_clock_value(struct bt_packet *packet, - struct bt_clock_class *clock_class, uint64_t raw_value, - bt_bool is_default) +int bt_packet_set_default_beginning_clock_value(struct bt_packet *packet, + uint64_t value_cycles) { + struct bt_stream_class *sc; + BT_ASSERT_PRE_NON_NULL(packet, "Packet"); - BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class"); - BT_ASSERT_PRE_HOT(packet, "Packet", ": %!+a", packet); - BT_ASSERT_PRE(is_default, - "You can only set a default clock value as of this version."); - return bt_clock_value_set_set_clock_value(&packet->begin_cv_set, - clock_class, raw_value, is_default); + 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; } -struct bt_clock_value *bt_packet_borrow_default_begin_clock_value( - struct bt_packet *packet) +enum bt_clock_value_status bt_packet_borrow_default_beginning_clock_value( + struct bt_packet *packet, struct bt_clock_value **clock_value) { - struct bt_clock_value *clock_value = NULL; + BT_ASSERT_PRE_NON_NULL(packet, "Packet"); + BT_ASSERT_PRE_NON_NULL(clock_value, "Clock value (output)"); + *clock_value = packet->default_beginning_cv; + return BT_CLOCK_VALUE_STATUS_KNOWN; +} + +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"); - clock_value = packet->begin_cv_set.default_cv; - if (!clock_value) { - BT_LIB_LOGV("No default clock value: %![packet-]+a", packet); - } + 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; +} - return 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 (output)"); + *clock_value = packet->default_end_cv; + return BT_CLOCK_VALUE_STATUS_KNOWN; } -int bt_packet_set_end_clock_value(struct bt_packet *packet, - struct bt_clock_class *clock_class, uint64_t raw_value, - bt_bool is_default) +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(clock_class, "Clock class"); - BT_ASSERT_PRE_HOT(packet, "Packet", ": %!+a", packet); - BT_ASSERT_PRE(is_default, - "You can only set a default clock value as of this version."); - return bt_clock_value_set_set_clock_value(&packet->end_cv_set, - clock_class, raw_value, is_default); + BT_ASSERT_PRE_NON_NULL(value, "Value (output)"); + *value = packet->discarded_event_counter_snapshot.value; + return packet->discarded_event_counter_snapshot.base.avail; } -struct bt_clock_value *bt_packet_borrow_default_end_clock_value( - struct bt_packet *packet) +int bt_packet_set_discarded_event_counter_snapshot(struct bt_packet *packet, + uint64_t value) { - struct bt_clock_value *clock_value = NULL; + BT_ASSERT_PRE_NON_NULL(packet, "Packet"); + 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_property_availability bt_packet_get_packet_counter_snapshot( + struct bt_packet *packet, uint64_t *value) +{ BT_ASSERT_PRE_NON_NULL(packet, "Packet"); - clock_value = packet->end_cv_set.default_cv; - if (!clock_value) { - BT_LIB_LOGV("No default clock value: %![packet-]+a", packet); - } + BT_ASSERT_PRE_NON_NULL(value, "Value (output)"); + *value = packet->packet_counter_snapshot.value; + return packet->packet_counter_snapshot.base.avail; +} - return clock_value; +int bt_packet_set_packet_counter_snapshot(struct bt_packet *packet, + uint64_t value) +{ + BT_ASSERT_PRE_NON_NULL(packet, "Packet"); + 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; }