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

/*
 * packet.c
 *
 * Babeltrace CTF IR - Stream packet
 *
 * 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/ctf-ir/fields-internal.h>
#include <babeltrace/ctf-ir/packet.h>
#include <babeltrace/ctf-ir/packet-internal.h>
#include <babeltrace/ctf-ir/field-wrapper-internal.h>
#include <babeltrace/ctf-ir/trace.h>
#include <babeltrace/ctf-ir/stream-class-internal.h>
#include <babeltrace/ctf-ir/stream-class.h>
#include <babeltrace/ctf-ir/stream.h>
#include <babeltrace/ctf-ir/stream-internal.h>
#include <babeltrace/ctf-ir/clock-value-internal.h>
#include <babeltrace/ctf-ir/trace-internal.h>
#include <babeltrace/object-internal.h>
#include <babeltrace/ref.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_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_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;
}

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_put()
	 *    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_put(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_get(stream);
	trace = bt_stream_class_borrow_trace_inline(stream->class);
	BT_ASSERT(trace);

	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,
			trace->packet_header_ft);
		if (!packet->header_field) {
			BT_LOGE_STR("Cannot create packet header field wrapper.");
			goto error;
		}
	}

	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 (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_PUT(packet);

end:
	return packet;
}

struct bt_packet *bt_packet_create(struct bt_stream *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 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, "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_ft,
		"Trace has no packet header field type: %!+t",
		trace);
	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_field);
	recycle_header_field(packet->header_field, trace);

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

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, "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_ft,
		"Stream class has no packet context field type: %!+S",
		stream_class);
	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_field);
	recycle_context_field(packet->context_field, stream_class);

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

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

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

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

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