[babeltrace.git] / lib / trace-ir / packet.c

/*
 * Copyright 2016 Philippe Proulx <pproulx@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#define BT_LOG_TAG "PACKET"
#include <babeltrace/lib-logging-internal.h>

#include <babeltrace/assert-pre-internal.h>
#include <babeltrace/trace-ir/fields-internal.h>
#include <babeltrace/trace-ir/private-packet.h>
#include <babeltrace/trace-ir/packet.h>
#include <babeltrace/trace-ir/packet-internal.h>
#include <babeltrace/trace-ir/field-wrapper-internal.h>
#include <babeltrace/trace-ir/trace.h>
#include <babeltrace/trace-ir/stream-class-internal.h>
#include <babeltrace/trace-ir/stream-class.h>
#include <babeltrace/trace-ir/stream.h>
#include <babeltrace/trace-ir/stream-internal.h>
#include <babeltrace/trace-ir/clock-value-internal.h>
#include <babeltrace/trace-ir/trace-internal.h>
#include <babeltrace/object-internal.h>
#include <babeltrace/object.h>
#include <babeltrace/assert-internal.h>
#include <inttypes.h>

#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_private_stream *bt_private_packet_borrow_stream(
		struct bt_private_packet *packet)
{
	return (void *) bt_packet_borrow_stream((void *) packet);
}

struct bt_field *bt_packet_borrow_header_field(struct bt_packet *packet)
{
	BT_ASSERT_PRE_NON_NULL(packet, "Packet");
	return packet->header_field ? packet->header_field->field : NULL;
}

struct bt_private_field *bt_private_packet_borrow_header_field(
		struct bt_private_packet *packet)
{
	return (void *) bt_packet_borrow_header_field((void *) packet);
}

struct bt_field *bt_packet_borrow_context_field(struct bt_packet *packet)
{
	BT_ASSERT_PRE_NON_NULL(packet, "Packet");
	return packet->context_field ? packet->context_field->field : NULL;
}

struct bt_private_field *bt_private_packet_borrow_context_field(
		struct bt_private_packet *packet)
{
	return (void *) bt_packet_borrow_context_field((void *) packet);
}

BT_HIDDEN
void _bt_packet_set_is_frozen(struct bt_packet *packet, bool is_frozen)
{
	if (!packet) {
		return;
	}

	BT_LIB_LOGD("Setting packet's frozen state: %![packet-]+a, "
		"is-frozen=%d", packet, is_frozen);

	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_field) {
		BT_LOGD_STR("Setting packet's context field's frozen state.");
		bt_field_set_is_frozen(packet->context_field->field,
			is_frozen);
	}

	packet->frozen = is_frozen;
}

static inline
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_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->default_end_cv) {
		bt_clock_value_reset(packet->default_end_cv);
	}

	reset_counter_snapshots(packet);
}

static
void recycle_header_field(struct bt_field_wrapper *header_field,
		struct bt_trace *trace)
{
	BT_ASSERT(header_field);
	BT_LIB_LOGD("Recycling packet header field: "
		"addr=%p, %![trace-]+t, %![field-]+f", header_field,
		trace, header_field->field);
	bt_object_pool_recycle_object(&trace->packet_header_field_pool,
		header_field);
}

static
void recycle_context_field(struct bt_field_wrapper *context_field,
		struct bt_stream_class *stream_class)
{
	BT_ASSERT(context_field);
	BT_LIB_LOGD("Recycling packet context field: "
		"addr=%p, %![sc-]+S, %![field-]+f", context_field,
		stream_class, context_field->field);
	bt_object_pool_recycle_object(&stream_class->packet_context_field_pool,
		context_field);
}

BT_HIDDEN
void bt_packet_recycle(struct bt_packet *packet)
{
	struct bt_stream *stream;

	BT_ASSERT(packet);
	BT_LIB_LOGD("Recycling packet: %!+a", packet);

	/*
	 * Those are the important ordered steps:
	 *
	 * 1. Reset the packet object (put any permanent reference it
	 *    has, unfreeze it and its fields in developer mode, etc.),
	 *    but do NOT put its stream's reference. This stream
	 *    contains the pool to which we're about to recycle this
	 *    packet object, so we must guarantee its existence thanks
	 *    to this existing reference.
	 *
	 * 2. Move the stream reference to our `stream`
	 *    variable so that we can set the packet's stream member
	 *    to NULL before recycling it. We CANNOT do this after
	 *    we put the stream reference because this bt_object_put_ref()
	 *    could destroy the stream, also destroying its
	 *    packet pool, thus also destroying our packet object (this
	 *    would result in an invalid write access).
	 *
	 * 3. Recycle the packet object.
	 *
	 * 4. Put our stream reference.
	 */
	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->base);
}

BT_HIDDEN
void bt_packet_destroy(struct bt_packet *packet)
{
	BT_LIB_LOGD("Destroying packet: %!+a", packet);

	if (packet->header_field) {
		if (packet->stream) {
			BT_LOGD_STR("Recycling packet's header field.");
			recycle_header_field(packet->header_field,
				bt_stream_class_borrow_trace_inline(
					packet->stream->class));
		} else {
			bt_field_wrapper_destroy(packet->header_field);
		}
	}

	if (packet->context_field) {
		if (packet->stream) {
			BT_LOGD_STR("Recycling packet's context field.");
			recycle_context_field(packet->context_field,
				packet->stream->class);
		} else {
			bt_field_wrapper_destroy(packet->context_field);
		}
	}

	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_object_put_ref(packet->stream);
	g_free(packet);
}

BT_HIDDEN
struct bt_packet *bt_packet_new(struct bt_stream *stream)
{
	struct bt_packet *packet = NULL;
	struct bt_trace *trace = NULL;

	BT_ASSERT(stream);
	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 error;
	}

	bt_object_init_shared(&packet->base,
		(bt_object_release_func) bt_packet_recycle);
	packet->stream = bt_object_get_ref(stream);
	trace = bt_stream_class_borrow_trace_inline(stream->class);
	BT_ASSERT(trace);

	if (trace->packet_header_fc) {
		BT_LOGD_STR("Creating initial packet header field.");
		packet->header_field = bt_field_wrapper_create(
			&trace->packet_header_field_pool,
			trace->packet_header_fc);
		if (!packet->header_field) {
			BT_LOGE_STR("Cannot create packet header field wrapper.");
			goto error;
		}
	}

	if (stream->class->packet_context_fc) {
		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_fc);
		if (!packet->context_field) {
			BT_LOGE_STR("Cannot create packet context field wrapper.");
			goto error;
		}
	}

	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 (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;
			}
		}
	}

	reset_counter_snapshots(packet);
	BT_LIB_LOGD("Created packet object: %!+a", packet);
	goto end;

error:
	BT_OBJECT_PUT_REF_AND_RESET(packet);

end:
	return packet;
}

struct bt_private_packet *bt_private_packet_create(
		struct bt_private_stream *priv_stream)
{
	struct bt_stream *stream = (void *) priv_stream;
	struct bt_packet *packet = NULL;

	BT_ASSERT_PRE_NON_NULL(stream, "Stream");
	packet = bt_object_pool_create_object(&stream->packet_pool);
	if (unlikely(!packet)) {
		BT_LIB_LOGE("Cannot allocate one packet from stream's packet pool: "
			"%![stream-]+s", stream);
		goto end;
	}

	if (likely(!packet->stream)) {
		packet->stream = stream;
		bt_object_get_no_null_check_no_parent_check(
			&packet->stream->base);
	}

end:
	return (void *) packet;
}

int bt_private_packet_move_header_field(
		struct bt_private_packet *priv_packet,
		struct bt_private_packet_header_field *header_field)
{
	struct bt_packet *packet = (void *) priv_packet;
	struct bt_trace *trace;
	struct bt_field_wrapper *field_wrapper = (void *) header_field;

	BT_ASSERT_PRE_NON_NULL(packet, "Packet");
	BT_ASSERT_PRE_NON_NULL(field_wrapper, "Header field");
	BT_ASSERT_PRE_PACKET_HOT(packet);
	trace = bt_stream_class_borrow_trace_inline(packet->stream->class);
	BT_ASSERT_PRE(trace->packet_header_fc,
		"Trace has no packet header field classe: %!+t",
		trace);
	BT_ASSERT_PRE(field_wrapper->field->class ==
		trace->packet_header_fc,
		"Unexpected packet header field's class: "
		"%![fc-]+F, %![expected-fc-]+F", field_wrapper->field->class,
		trace->packet_header_fc);

	/* Recycle current header field: always exists */
	BT_ASSERT(packet->header_field);
	recycle_header_field(packet->header_field, trace);

	/* Move new field */
	packet->header_field = field_wrapper;
	return 0;
}

int bt_private_packet_move_context_field(
		struct bt_private_packet *priv_packet,
		struct bt_private_packet_context_field *context_field)
{
	struct bt_packet *packet = (void *) priv_packet;
	struct bt_stream_class *stream_class;
	struct bt_field_wrapper *field_wrapper = (void *) context_field;

	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 = packet->stream->class;
	BT_ASSERT_PRE(stream_class->packet_context_fc,
		"Stream class has no packet context field classe: %!+S",
		stream_class);
	BT_ASSERT_PRE(field_wrapper->field->class ==
		stream_class->packet_context_fc,
		"Unexpected packet header field's class: "
		"%![fc-]+F, %![expected-fc-]+F", field_wrapper->field->class,
		stream_class->packet_context_fc);

	/* Recycle current context field: always exists */
	BT_ASSERT(packet->context_field);
	recycle_context_field(packet->context_field, stream_class);

	/* Move new field */
	packet->context_field = field_wrapper;
	return 0;
}

void bt_private_packet_set_default_beginning_clock_value(
		struct bt_private_packet *priv_packet,
		uint64_t value_cycles)
{
	struct bt_packet *packet = (void *) priv_packet;
	struct bt_stream_class *sc;

	BT_ASSERT_PRE_NON_NULL(packet, "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_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, packet, value_cycles);
}

enum bt_clock_value_status bt_packet_borrow_default_beginning_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_beginning_cv;
	return BT_CLOCK_VALUE_STATUS_KNOWN;
}

void bt_private_packet_set_default_end_clock_value(
		struct bt_private_packet *priv_packet,
		uint64_t value_cycles)
{
	struct bt_packet *packet = (void *) priv_packet;
	struct bt_stream_class *sc;

	BT_ASSERT_PRE_NON_NULL(packet, "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, packet, value_cycles);
}

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;
}

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(value, "Value (output)");
	*value = packet->discarded_event_counter_snapshot.value;
	return packet->discarded_event_counter_snapshot.base.avail;
}

void bt_private_packet_set_discarded_event_counter_snapshot(
		struct bt_private_packet *priv_packet, uint64_t value)
{
	struct bt_packet *packet = (void *) priv_packet;

	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);
}

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(value, "Value (output)");
	*value = packet->packet_counter_snapshot.value;
	return packet->packet_counter_snapshot.base.avail;
}

void bt_private_packet_set_packet_counter_snapshot(
		struct bt_private_packet *priv_packet, uint64_t value)
{
	struct bt_packet *packet = (void *) priv_packet;

	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);
}
Commit	Line	Data
f79cf0f0	1	/*
f79cf0f0 PP	2	* Copyright 2016 Philippe Proulx <pproulx@efficios.com>
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a copy
	5	* of this software and associated documentation files (the "Software"), to deal
	6	* in the Software without restriction, including without limitation the rights
	7	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	8	* copies of the Software, and to permit persons to whom the Software is
	9	* furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice shall be included in
	12	* all copies or substantial portions of the Software.
	13	*
	14	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	15	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	17	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	18	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	19	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	20	* SOFTWARE.
	21	*/
	22
8ea705f0	23	#define BT_LOG_TAG "PACKET"
be514b0c	24	#include <babeltrace/lib-logging-internal.h>
8ea705f0	25
3dca2276	26	#include <babeltrace/assert-pre-internal.h>
56e18c4c	27	#include <babeltrace/trace-ir/fields-internal.h>
e5be10ef	28	#include <babeltrace/trace-ir/private-packet.h>
56e18c4c PP	29	#include <babeltrace/trace-ir/packet.h>
	30	#include <babeltrace/trace-ir/packet-internal.h>
	31	#include <babeltrace/trace-ir/field-wrapper-internal.h>
	32	#include <babeltrace/trace-ir/trace.h>
	33	#include <babeltrace/trace-ir/stream-class-internal.h>
	34	#include <babeltrace/trace-ir/stream-class.h>
	35	#include <babeltrace/trace-ir/stream.h>
	36	#include <babeltrace/trace-ir/stream-internal.h>
	37	#include <babeltrace/trace-ir/clock-value-internal.h>
	38	#include <babeltrace/trace-ir/trace-internal.h>
f79cf0f0	39	#include <babeltrace/object-internal.h>
65300d60	40	#include <babeltrace/object.h>
f6ccaed9	41	#include <babeltrace/assert-internal.h>
be514b0c	42	#include <inttypes.h>
f79cf0f0	43
44c440bc PP	44	#define BT_ASSERT_PRE_PACKET_HOT(_packet) \
	45	BT_ASSERT_PRE_HOT((_packet), "Packet", ": %!+a", (_packet))
	46
094ff7c0	47	struct bt_stream bt_packet_borrow_stream(struct bt_packet packet)
f79cf0f0	48	{
f6ccaed9	49	BT_ASSERT_PRE_NON_NULL(packet, "Packet");
094ff7c0	50	return packet->stream;
f79cf0f0 PP	51	}
f79cf0f0 PP	52
28e6ca8b	53	struct bt_private_stream *bt_private_packet_borrow_stream(
e5be10ef PP	54	struct bt_private_packet *packet)
	55	{
	56	return (void ) bt_packet_borrow_stream((void ) packet);
	57	}
	58
44c440bc	59	struct bt_field bt_packet_borrow_header_field(struct bt_packet packet)
f79cf0f0	60	{
f6ccaed9	61	BT_ASSERT_PRE_NON_NULL(packet, "Packet");
44c440bc	62	return packet->header_field ? packet->header_field->field : NULL;
f79cf0f0 PP	63	}
f79cf0f0 PP	64
28e6ca8b	65	struct bt_private_field *bt_private_packet_borrow_header_field(
e5be10ef PP	66	struct bt_private_packet *packet)
	67	{
	68	return (void ) bt_packet_borrow_header_field((void ) packet);
	69	}
	70
44c440bc	71	struct bt_field bt_packet_borrow_context_field(struct bt_packet packet)
f79cf0f0	72	{
312c056a	73	BT_ASSERT_PRE_NON_NULL(packet, "Packet");
44c440bc	74	return packet->context_field ? packet->context_field->field : NULL;
312c056a	75	}
c5c82c6e	76
28e6ca8b	77	struct bt_private_field *bt_private_packet_borrow_context_field(
e5be10ef PP	78	struct bt_private_packet *packet)
	79	{
	80	return (void ) bt_packet_borrow_context_field((void ) packet);
	81	}
	82
312c056a	83	BT_HIDDEN
6c677fb5	84	void _bt_packet_set_is_frozen(struct bt_packet *packet, bool is_frozen)
312c056a	85	{
59e3c4db	86	if (!packet) {
312c056a	87	return;
c5c82c6e PP	88	}
c5c82c6e PP	89
44c440bc PP	90	BT_LIB_LOGD("Setting packet's frozen state: %![packet-]+a, "
44c440bc PP	91	"is-frozen=%d", packet, is_frozen);
312c056a	92
44c440bc PP	93	if (packet->header_field) {
	94	BT_LOGD_STR("Setting packet's header field's frozen state.");
	95	bt_field_set_is_frozen(packet->header_field->field,
6c677fb5	96	is_frozen);
f79cf0f0 PP	97	}
f79cf0f0 PP	98
44c440bc PP	99	if (packet->context_field) {
	100	BT_LOGD_STR("Setting packet's context field's frozen state.");
	101	bt_field_set_is_frozen(packet->context_field->field,
6c677fb5	102	is_frozen);
312c056a PP	103	}
312c056a PP	104
6c677fb5	105	packet->frozen = is_frozen;
f6ccaed9 PP	106	}
f6ccaed9 PP	107
ccf82993	108	static inline
44c440bc	109	void reset_counter_snapshots(struct bt_packet *packet)
ccf82993	110	{
44c440bc PP	111	packet->discarded_event_counter_snapshot.base.avail =
	112	BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE;
	113	packet->packet_counter_snapshot.base.avail =
	114	BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE;
ccf82993 PP	115	}
ccf82993 PP	116
312c056a	117	static inline
44c440bc	118	void reset_packet(struct bt_packet *packet)
f6ccaed9	119	{
312c056a	120	BT_ASSERT(packet);
44c440bc	121	BT_LIB_LOGD("Resetting packet: %!+a", packet);
6c677fb5	122	bt_packet_set_is_frozen(packet, false);
312c056a	123
44c440bc PP	124	if (packet->header_field) {
	125	bt_field_set_is_frozen(packet->header_field->field, false);
	126	bt_field_reset(packet->header_field->field);
312c056a PP	127	}
312c056a PP	128
44c440bc PP	129	if (packet->context_field) {
	130	bt_field_set_is_frozen(packet->context_field->field, false);
	131	bt_field_reset(packet->context_field->field);
312c056a	132	}
e22b45d0	133
44c440bc PP	134	if (packet->default_beginning_cv) {
	135	bt_clock_value_reset(packet->default_beginning_cv);
	136	}
ccf82993	137
44c440bc PP	138	if (packet->default_end_cv) {
44c440bc PP	139	bt_clock_value_reset(packet->default_end_cv);
ccf82993	140	}
44c440bc PP	141
44c440bc PP	142	reset_counter_snapshots(packet);
f79cf0f0 PP	143	}
f79cf0f0 PP	144
312c056a	145	static
44c440bc	146	void recycle_header_field(struct bt_field_wrapper *header_field,
312c056a	147	struct bt_trace *trace)
f79cf0f0	148	{
312c056a PP	149	BT_ASSERT(header_field);
	150	BT_LIB_LOGD("Recycling packet header field: "
	151	"addr=%p, %![trace-]+t, %![field-]+f", header_field,
	152	trace, header_field->field);
	153	bt_object_pool_recycle_object(&trace->packet_header_field_pool,
	154	header_field);
f79cf0f0 PP	155	}
f79cf0f0 PP	156
312c056a	157	static
44c440bc	158	void recycle_context_field(struct bt_field_wrapper *context_field,
312c056a	159	struct bt_stream_class *stream_class)
f79cf0f0	160	{
312c056a PP	161	BT_ASSERT(context_field);
	162	BT_LIB_LOGD("Recycling packet context field: "
	163	"addr=%p, %![sc-]+S, %![field-]+f", context_field,
	164	stream_class, context_field->field);
	165	bt_object_pool_recycle_object(&stream_class->packet_context_field_pool,
	166	context_field);
f79cf0f0 PP	167	}
	168
	169	BT_HIDDEN
312c056a	170	void bt_packet_recycle(struct bt_packet *packet)
f79cf0f0	171	{
312c056a	172	struct bt_stream *stream;
f79cf0f0	173
312c056a PP	174	BT_ASSERT(packet);
	175	BT_LIB_LOGD("Recycling packet: %!+a", packet);
	176
	177	/*
	178	* Those are the important ordered steps:
	179	*
	180	* 1. Reset the packet object (put any permanent reference it
	181	* has, unfreeze it and its fields in developer mode, etc.),
	182	* but do NOT put its stream's reference. This stream
	183	* contains the pool to which we're about to recycle this
	184	* packet object, so we must guarantee its existence thanks
	185	* to this existing reference.
	186	*
	187	* 2. Move the stream reference to our `stream`
	188	* variable so that we can set the packet's stream member
	189	* to NULL before recycling it. We CANNOT do this after
65300d60	190	* we put the stream reference because this bt_object_put_ref()
312c056a PP	191	* could destroy the stream, also destroying its
	192	* packet pool, thus also destroying our packet object (this
	193	* would result in an invalid write access).
	194	*
	195	* 3. Recycle the packet object.
	196	*
	197	* 4. Put our stream reference.
	198	*/
44c440bc	199	reset_packet(packet);
312c056a PP	200	stream = packet->stream;
	201	BT_ASSERT(stream);
	202	packet->stream = NULL;
	203	bt_object_pool_recycle_object(&stream->packet_pool, packet);
cb6f1f7d	204	bt_object_put_no_null_check(&stream->base);
f79cf0f0 PP	205	}
f79cf0f0 PP	206
312c056a PP	207	BT_HIDDEN
312c056a PP	208	void bt_packet_destroy(struct bt_packet *packet)
f79cf0f0	209	{
44c440bc	210	BT_LIB_LOGD("Destroying packet: %!+a", packet);
312c056a	211
44c440bc	212	if (packet->header_field) {
312c056a PP	213	if (packet->stream) {
312c056a PP	214	BT_LOGD_STR("Recycling packet's header field.");
44c440bc PP	215	recycle_header_field(packet->header_field,
	216	bt_stream_class_borrow_trace_inline(
	217	packet->stream->class));
312c056a	218	} else {
44c440bc	219	bt_field_wrapper_destroy(packet->header_field);
312c056a PP	220	}
	221	}
	222
44c440bc	223	if (packet->context_field) {
312c056a PP	224	if (packet->stream) {
312c056a PP	225	BT_LOGD_STR("Recycling packet's context field.");
44c440bc PP	226	recycle_context_field(packet->context_field,
44c440bc PP	227	packet->stream->class);
312c056a	228	} else {
44c440bc	229	bt_field_wrapper_destroy(packet->context_field);
312c056a PP	230	}
	231	}
	232
44c440bc PP	233	if (packet->default_beginning_cv) {
	234	BT_LOGD_STR("Recycling beginning clock value.");
	235	bt_clock_value_recycle(packet->default_beginning_cv);
	236	}
	237
	238	if (packet->default_end_cv) {
	239	BT_LOGD_STR("Recycling end clock value.");
	240	bt_clock_value_recycle(packet->default_end_cv);
	241	}
	242
d409daba	243	BT_LOGD_STR("Putting packet's stream.");
65300d60	244	bt_object_put_ref(packet->stream);
f79cf0f0 PP	245	g_free(packet);
	246	}
	247
312c056a PP	248	BT_HIDDEN
312c056a PP	249	struct bt_packet bt_packet_new(struct bt_stream stream)
f79cf0f0	250	{
50842bdc	251	struct bt_packet *packet = NULL;
50842bdc	252	struct bt_trace *trace = NULL;
f79cf0f0	253
312c056a	254	BT_ASSERT(stream);
44c440bc	255	BT_LIB_LOGD("Creating packet object: %![stream-]+s", stream);
50842bdc	256	packet = g_new0(struct bt_packet, 1);
f79cf0f0	257	if (!packet) {
8ea705f0	258	BT_LOGE_STR("Failed to allocate one packet object.");
44c440bc	259	goto error;
f79cf0f0 PP	260	}
f79cf0f0 PP	261
3fea54f6 PP	262	bt_object_init_shared(&packet->base,
3fea54f6 PP	263	(bt_object_release_func) bt_packet_recycle);
65300d60	264	packet->stream = bt_object_get_ref(stream);
44c440bc PP	265	trace = bt_stream_class_borrow_trace_inline(stream->class);
44c440bc PP	266	BT_ASSERT(trace);
be514b0c	267
5cd6d0e5	268	if (trace->packet_header_fc) {
44c440bc PP	269	BT_LOGD_STR("Creating initial packet header field.");
44c440bc PP	270	packet->header_field = bt_field_wrapper_create(
312c056a	271	&trace->packet_header_field_pool,
5cd6d0e5	272	trace->packet_header_fc);
44c440bc PP	273	if (!packet->header_field) {
	274	BT_LOGE_STR("Cannot create packet header field wrapper.");
	275	goto error;
be514b0c	276	}
f79cf0f0 PP	277	}
f79cf0f0 PP	278
5cd6d0e5	279	if (stream->class->packet_context_fc) {
44c440bc PP	280	BT_LOGD_STR("Creating initial packet context field.");
	281	packet->context_field = bt_field_wrapper_create(
	282	&stream->class->packet_context_field_pool,
5cd6d0e5	283	stream->class->packet_context_fc);
44c440bc PP	284	if (!packet->context_field) {
	285	BT_LOGE_STR("Cannot create packet context field wrapper.");
	286	goto error;
be514b0c	287	}
f79cf0f0 PP	288	}
f79cf0f0 PP	289
44c440bc PP	290	if (stream->class->default_clock_class) {
	291	if (stream->class->packets_have_default_beginning_cv) {
	292	packet->default_beginning_cv = bt_clock_value_create(
	293	stream->class->default_clock_class);
	294	if (!packet->default_beginning_cv) {
	295	/* bt_clock_value_create() logs errors */
	296	goto error;
	297	}
ccf82993 PP	298	}
ccf82993 PP	299
44c440bc PP	300	if (stream->class->packets_have_default_end_cv) {
	301	packet->default_end_cv = bt_clock_value_create(
	302	stream->class->default_clock_class);
	303	if (!packet->default_end_cv) {
	304	/* bt_clock_value_create() logs errors */
	305	goto error;
	306	}
ccf82993 PP	307	}
	308	}
	309
44c440bc PP	310	reset_counter_snapshots(packet);
	311	BT_LIB_LOGD("Created packet object: %!+a", packet);
	312	goto end;
ccf82993	313
44c440bc	314	error:
65300d60	315	BT_OBJECT_PUT_REF_AND_RESET(packet);
ccf82993 PP	316
ccf82993 PP	317	end:
44c440bc	318	return packet;
ccf82993 PP	319	}
ccf82993 PP	320
e5be10ef PP	321	struct bt_private_packet *bt_private_packet_create(
e5be10ef PP	322	struct bt_private_stream *priv_stream)
312c056a	323	{
e5be10ef	324	struct bt_stream stream = (void ) priv_stream;
312c056a PP	325	struct bt_packet *packet = NULL;
	326
	327	BT_ASSERT_PRE_NON_NULL(stream, "Stream");
	328	packet = bt_object_pool_create_object(&stream->packet_pool);
6c677fb5	329	if (unlikely(!packet)) {
312c056a PP	330	BT_LIB_LOGE("Cannot allocate one packet from stream's packet pool: "
312c056a PP	331	"%![stream-]+s", stream);
6c677fb5	332	goto end;
312c056a PP	333	}
312c056a PP	334
44c440bc	335	if (likely(!packet->stream)) {
6c677fb5 PP	336	packet->stream = stream;
6c677fb5 PP	337	bt_object_get_no_null_check_no_parent_check(
cb6f1f7d	338	&packet->stream->base);
312c056a PP	339	}
312c056a PP	340
312c056a	341	end:
e5be10ef	342	return (void *) packet;
312c056a PP	343	}
312c056a PP	344
28e6ca8b	345	int bt_private_packet_move_header_field(
e5be10ef PP	346	struct bt_private_packet *priv_packet,
e5be10ef PP	347	struct bt_private_packet_header_field *header_field)
312c056a	348	{
e5be10ef	349	struct bt_packet packet = (void ) priv_packet;
312c056a PP	350	struct bt_trace *trace;
	351	struct bt_field_wrapper field_wrapper = (void ) header_field;
	352
44c440bc	353	BT_ASSERT_PRE_NON_NULL(packet, "Packet");
312c056a	354	BT_ASSERT_PRE_NON_NULL(field_wrapper, "Header field");
44c440bc PP	355	BT_ASSERT_PRE_PACKET_HOT(packet);
44c440bc PP	356	trace = bt_stream_class_borrow_trace_inline(packet->stream->class);
5cd6d0e5 PP	357	BT_ASSERT_PRE(trace->packet_header_fc,
5cd6d0e5 PP	358	"Trace has no packet header field classe: %!+t",
312c056a	359	trace);
5cd6d0e5 PP	360	BT_ASSERT_PRE(field_wrapper->field->class ==
	361	trace->packet_header_fc,
	362	"Unexpected packet header field's class: "
	363	"%![fc-]+F, %![expected-fc-]+F", field_wrapper->field->class,
	364	trace->packet_header_fc);
312c056a PP	365
312c056a PP	366	/* Recycle current header field: always exists */
44c440bc PP	367	BT_ASSERT(packet->header_field);
44c440bc PP	368	recycle_header_field(packet->header_field, trace);
312c056a PP	369
312c056a PP	370	/* Move new field */
44c440bc	371	packet->header_field = field_wrapper;
312c056a PP	372	return 0;
	373	}
	374
28e6ca8b	375	int bt_private_packet_move_context_field(
e5be10ef PP	376	struct bt_private_packet *priv_packet,
e5be10ef PP	377	struct bt_private_packet_context_field *context_field)
312c056a	378	{
e5be10ef	379	struct bt_packet packet = (void ) priv_packet;
312c056a PP	380	struct bt_stream_class *stream_class;
	381	struct bt_field_wrapper field_wrapper = (void ) context_field;
	382
44c440bc	383	BT_ASSERT_PRE_NON_NULL(packet, "Packet");
312c056a	384	BT_ASSERT_PRE_NON_NULL(field_wrapper, "Context field");
e22b45d0	385	BT_ASSERT_PRE_HOT(packet, "Packet", ": %!+a", packet);
44c440bc	386	stream_class = packet->stream->class;
5cd6d0e5 PP	387	BT_ASSERT_PRE(stream_class->packet_context_fc,
5cd6d0e5 PP	388	"Stream class has no packet context field classe: %!+S",
312c056a	389	stream_class);
5cd6d0e5 PP	390	BT_ASSERT_PRE(field_wrapper->field->class ==
	391	stream_class->packet_context_fc,
	392	"Unexpected packet header field's class: "
	393	"%![fc-]+F, %![expected-fc-]+F", field_wrapper->field->class,
	394	stream_class->packet_context_fc);
312c056a PP	395
312c056a PP	396	/* Recycle current context field: always exists */
44c440bc PP	397	BT_ASSERT(packet->context_field);
44c440bc PP	398	recycle_context_field(packet->context_field, stream_class);
312c056a PP	399
312c056a PP	400	/* Move new field */
44c440bc	401	packet->context_field = field_wrapper;
312c056a PP	402	return 0;
312c056a PP	403	}
e22b45d0	404
140e6d94	405	void bt_private_packet_set_default_beginning_clock_value(
e5be10ef	406	struct bt_private_packet *priv_packet,
44c440bc	407	uint64_t value_cycles)
e22b45d0	408	{
e5be10ef	409	struct bt_packet packet = (void ) priv_packet;
44c440bc	410	struct bt_stream_class *sc;
ccf82993	411
e22b45d0	412	BT_ASSERT_PRE_NON_NULL(packet, "Packet");
44c440bc PP	413	BT_ASSERT_PRE_PACKET_HOT(packet);
	414	sc = packet->stream->class;
	415	BT_ASSERT(sc);
	416	BT_ASSERT_PRE(sc->default_clock_class,
	417	"Packet's stream class has no default clock class: "
	418	"%![packet-]+a, %![sc-]+S", packet, sc);
	419	BT_ASSERT_PRE(sc->packets_have_default_beginning_cv,
	420	"Packet's stream class indicates that its packets have "
	421	"no default beginning clock value: %![packet-]+a, %![sc-]+S",
	422	packet, sc);
	423	BT_ASSERT(packet->default_beginning_cv);
140e6d94 PP	424	bt_clock_value_set_value_inline(packet->default_beginning_cv,
140e6d94 PP	425	value_cycles);
44c440bc	426	BT_LIB_LOGV("Set packet's default beginning clock value: "
e5be10ef	427	"%![packet-]+a, value=%" PRIu64, packet, value_cycles);
e22b45d0 PP	428	}
e22b45d0 PP	429
44c440bc PP	430	enum bt_clock_value_status bt_packet_borrow_default_beginning_clock_value(
44c440bc PP	431	struct bt_packet packet, struct bt_clock_value *clock_value)
e22b45d0	432	{
e22b45d0	433	BT_ASSERT_PRE_NON_NULL(packet, "Packet");
44c440bc PP	434	BT_ASSERT_PRE_NON_NULL(clock_value, "Clock value (output)");
	435	*clock_value = packet->default_beginning_cv;
	436	return BT_CLOCK_VALUE_STATUS_KNOWN;
e22b45d0 PP	437	}
e22b45d0 PP	438
140e6d94	439	void bt_private_packet_set_default_end_clock_value(
e5be10ef	440	struct bt_private_packet *priv_packet,
44c440bc	441	uint64_t value_cycles)
e22b45d0	442	{
e5be10ef	443	struct bt_packet packet = (void ) priv_packet;
44c440bc PP	444	struct bt_stream_class *sc;
44c440bc PP	445
e22b45d0	446	BT_ASSERT_PRE_NON_NULL(packet, "Packet");
44c440bc PP	447	BT_ASSERT_PRE_PACKET_HOT(packet);
	448	sc = packet->stream->class;
	449	BT_ASSERT(sc);
	450	BT_ASSERT_PRE(sc->default_clock_class,
	451	"Packet's stream class has no default clock class: "
	452	"%![packet-]+a, %![sc-]+S", packet, sc);
	453	BT_ASSERT_PRE(sc->packets_have_default_end_cv,
	454	"Packet's stream class indicates that its packets have "
	455	"no default end clock value: %![packet-]+a, %![sc-]+S",
	456	packet, sc);
	457	BT_ASSERT(packet->default_end_cv);
	458	bt_clock_value_set_value_inline(packet->default_end_cv, value_cycles);
	459	BT_LIB_LOGV("Set packet's default end clock value: "
e5be10ef	460	"%![packet-]+a, value=%" PRIu64, packet, value_cycles);
ccf82993 PP	461	}
ccf82993 PP	462
44c440bc	463	enum bt_clock_value_status bt_packet_borrow_default_end_clock_value(
ccf82993 PP	464	struct bt_packet packet, struct bt_clock_value *clock_value)
	465	{
	466	BT_ASSERT_PRE_NON_NULL(packet, "Packet");
44c440bc PP	467	BT_ASSERT_PRE_NON_NULL(clock_value, "Clock value (output)");
	468	*clock_value = packet->default_end_cv;
	469	return BT_CLOCK_VALUE_STATUS_KNOWN;
e22b45d0 PP	470	}
e22b45d0 PP	471
44c440bc PP	472	enum bt_property_availability bt_packet_get_discarded_event_counter_snapshot(
44c440bc PP	473	struct bt_packet packet, uint64_t value)
e22b45d0	474	{
ccf82993	475	BT_ASSERT_PRE_NON_NULL(packet, "Packet");
44c440bc PP	476	BT_ASSERT_PRE_NON_NULL(value, "Value (output)");
	477	*value = packet->discarded_event_counter_snapshot.value;
	478	return packet->discarded_event_counter_snapshot.base.avail;
ccf82993	479	}
e22b45d0	480
140e6d94	481	void bt_private_packet_set_discarded_event_counter_snapshot(
e5be10ef	482	struct bt_private_packet *priv_packet, uint64_t value)
ccf82993	483	{
e5be10ef PP	484	struct bt_packet packet = (void ) priv_packet;
e5be10ef PP	485
e22b45d0	486	BT_ASSERT_PRE_NON_NULL(packet, "Packet");
44c440bc PP	487	BT_ASSERT_PRE_PACKET_HOT(packet);
	488	BT_ASSERT_PRE(packet->stream->class->packets_have_discarded_event_counter_snapshot,
	489	"Packet's stream's discarded event counter is not enabled: "
	490	"%![packet-]+a", packet);
	491	bt_property_uint_set(&packet->discarded_event_counter_snapshot, value);
ccf82993	492	}
e22b45d0	493
44c440bc PP	494	enum bt_property_availability bt_packet_get_packet_counter_snapshot(
44c440bc PP	495	struct bt_packet packet, uint64_t value)
ccf82993 PP	496	{
ccf82993 PP	497	BT_ASSERT_PRE_NON_NULL(packet, "Packet");
44c440bc PP	498	BT_ASSERT_PRE_NON_NULL(value, "Value (output)");
	499	*value = packet->packet_counter_snapshot.value;
	500	return packet->packet_counter_snapshot.base.avail;
ccf82993 PP	501	}
ccf82993 PP	502
140e6d94	503	void bt_private_packet_set_packet_counter_snapshot(
e5be10ef	504	struct bt_private_packet *priv_packet, uint64_t value)
ccf82993	505	{
e5be10ef PP	506	struct bt_packet packet = (void ) priv_packet;
e5be10ef PP	507
ccf82993	508	BT_ASSERT_PRE_NON_NULL(packet, "Packet");
44c440bc PP	509	BT_ASSERT_PRE_PACKET_HOT(packet);
	510	BT_ASSERT_PRE(packet->stream->class->packets_have_packet_counter_snapshot,
	511	"Packet's stream's packet counter is not enabled: "
	512	"%![packet-]+a", packet);
	513	bt_property_uint_set(&packet->packet_counter_snapshot, value);
e22b45d0	514	}