[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/ctf-ir/fields-internal.h>
#include <babeltrace/ctf-ir/packet.h>
#include <babeltrace/ctf-ir/packet-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/trace-internal.h>
#include <babeltrace/object-internal.h>
#include <babeltrace/ref.h>
#include <inttypes.h>

struct bt_ctf_stream *bt_ctf_packet_get_stream(struct bt_ctf_packet *packet)
{
	return packet ? bt_get(packet->stream) : NULL;
}

struct bt_ctf_field *bt_ctf_packet_get_header(
		struct bt_ctf_packet *packet)
{
	return packet ? bt_get(packet->header) : NULL;
}

int bt_ctf_packet_set_header(struct bt_ctf_packet *packet,
		struct bt_ctf_field *header)
{
	int ret = 0;
	struct bt_ctf_trace *trace = NULL;
	struct bt_ctf_stream_class *stream_class = NULL;
	struct bt_ctf_field_type *header_field_type = NULL;
	struct bt_ctf_field_type *expected_header_field_type = NULL;

	if (!packet) {
		BT_LOGW_STR("Invalid parameter: packet is NULL.");
		ret = -1;
		goto end;
	}

	if (packet->frozen) {
		BT_LOGW("Invalid parameter: packet is frozen: addr=%p",
			packet);
		ret = -1;
		goto end;
	}

	stream_class = bt_ctf_stream_get_class(packet->stream);
	assert(stream_class);
	trace = bt_ctf_stream_class_get_trace(stream_class);
	assert(trace);
	expected_header_field_type = bt_ctf_trace_get_packet_header_type(trace);

	if (!header) {
		if (expected_header_field_type) {
			BT_LOGW("Invalid parameter: setting no packet header but packet header field type is not NULL: "
				"packet-addr=%p, packet-header-ft-addr=%p",
				packet, expected_header_field_type);
			ret = -1;
			goto end;
		}

		goto skip_validation;
	}

	header_field_type = bt_ctf_field_get_type(header);
	assert(header_field_type);

	if (bt_ctf_field_type_compare(header_field_type,
			expected_header_field_type)) {
		BT_LOGW("Invalid parameter: packet header's field type is different from the trace's packet header field type: "
			"packet-addr=%p, packet-header-addr=%p",
			packet, header);
		ret = -1;
		goto end;
	}

skip_validation:
	bt_put(packet->header);
	packet->header = bt_get(header);
	BT_LOGV("Set packet's header field: packet-addr=%p, packet-header-addr=%p",
		packet, header);

end:
	BT_PUT(trace);
	BT_PUT(stream_class);
	BT_PUT(header_field_type);
	BT_PUT(expected_header_field_type);

	return ret;
}

struct bt_ctf_field *bt_ctf_packet_get_context(
		struct bt_ctf_packet *packet)
{
	return packet ? bt_get(packet->context) : NULL;
}

int bt_ctf_packet_set_context(struct bt_ctf_packet *packet,
		struct bt_ctf_field *context)
{
	int ret = 0;
	struct bt_ctf_stream_class *stream_class = NULL;
	struct bt_ctf_field_type *context_field_type = NULL;
	struct bt_ctf_field_type *expected_context_field_type = NULL;

	if (!packet) {
		BT_LOGW_STR("Invalid parameter: packet is NULL.");
		ret = -1;
		goto end;
	}

	if (packet->frozen) {
		BT_LOGW("Invalid parameter: packet is frozen: addr=%p",
			packet);
		ret = -1;
		goto end;
	}

	stream_class = bt_ctf_stream_get_class(packet->stream);
	assert(stream_class);
	expected_context_field_type =
		bt_ctf_stream_class_get_packet_context_type(stream_class);

	if (!context) {
		if (expected_context_field_type) {
			BT_LOGW("Invalid parameter: setting no packet context but packet context field type is not NULL: "
				"packet-addr=%p, packet-context-ft-addr=%p",
				packet, expected_context_field_type);
			ret = -1;
			goto end;
		}

		goto skip_validation;
	}

	context_field_type = bt_ctf_field_get_type(context);
	assert(context_field_type);

	if (bt_ctf_field_type_compare(context_field_type,
			expected_context_field_type)) {
		BT_LOGW("Invalid parameter: packet context's field type is different from the stream class's packet context field type: "
			"packet-addr=%p, packet-context-addr=%p",
			packet, context);
		ret = -1;
		goto end;
	}

skip_validation:
	bt_put(packet->context);
	packet->context = bt_get(context);
	BT_LOGV("Set packet's context field: packet-addr=%p, packet-context-addr=%p",
		packet, context);

end:
	BT_PUT(stream_class);
	BT_PUT(context_field_type);
	BT_PUT(expected_context_field_type);
	return ret;
}

BT_HIDDEN
void bt_ctf_packet_freeze(struct bt_ctf_packet *packet)
{
	if (!packet || packet->frozen) {
		return;
	}

	BT_LOGD("Freezing packet: addr=%p", packet);
	BT_LOGD_STR("Freezing packet's header field.");
	bt_ctf_field_freeze(packet->header);
	BT_LOGD_STR("Freezing packet's context field.");
	bt_ctf_field_freeze(packet->context);
	packet->frozen = 1;
}

static
void bt_ctf_packet_destroy(struct bt_object *obj)
{
	struct bt_ctf_packet *packet;

	packet = container_of(obj, struct bt_ctf_packet, base);
	BT_LOGD("Destroying packet: addr=%p", packet);
	BT_LOGD_STR("Putting packet's header field.");
	bt_put(packet->header);
	BT_LOGD_STR("Putting packet's context field.");
	bt_put(packet->context);
	BT_LOGD_STR("Putting packet's stream.");
	bt_put(packet->stream);
	g_free(packet);
}

struct bt_ctf_packet *bt_ctf_packet_create(
		struct bt_ctf_stream *stream)
{
	struct bt_ctf_packet *packet = NULL;
	struct bt_ctf_stream_class *stream_class = NULL;
	struct bt_ctf_trace *trace = NULL;

	if (!stream) {
		BT_LOGW_STR("Invalid parameter: stream is NULL.");
		goto end;
	}

	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_ctf_stream_get_name(stream),
		stream->stream_class,
		bt_ctf_stream_class_get_name(stream->stream_class),
		bt_ctf_stream_class_get_id(stream->stream_class));

	if (stream->pos.fd >= 0) {
		BT_LOGW_STR("Invalid parameter: stream is a CTF writer stream.");
		goto end;
	}

	stream_class = bt_ctf_stream_get_class(stream);
	assert(stream_class);
	trace = bt_ctf_stream_class_get_trace(stream_class);
	assert(trace);
	packet = g_new0(struct bt_ctf_packet, 1);
	if (!packet) {
		BT_LOGE_STR("Failed to allocate one packet object.");
		goto end;
	}

	bt_object_init(packet, bt_ctf_packet_destroy);
	packet->stream = bt_get(stream);

	if (trace->packet_header_type) {
		BT_LOGD("Creating initial packet header field: ft-addr=%p",
			trace->packet_header_type);
		packet->header = bt_ctf_field_create(trace->packet_header_type);
		if (!packet->header) {
			BT_LOGE_STR("Cannot create initial packet header field object.");
			BT_PUT(packet);
			goto end;
		}
	}

	if (stream->stream_class->packet_context_type) {
		BT_LOGD("Creating initial packet context field: ft-addr=%p",
			stream->stream_class->packet_context_type);
		packet->context = bt_ctf_field_create(
			stream->stream_class->packet_context_type);
		if (!packet->context) {
			BT_LOGE_STR("Cannot create initial packet header field object.");
			BT_PUT(packet);
			goto end;
		}
	}

	BT_LOGD("Created packet object: addr=%p", packet);

end:
	BT_PUT(trace);
	BT_PUT(stream_class);

	return packet;
}
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
f79cf0f0 PP	30	#include <babeltrace/ctf-ir/fields-internal.h>
	31	#include <babeltrace/ctf-ir/packet.h>
	32	#include <babeltrace/ctf-ir/packet-internal.h>
	33	#include <babeltrace/ctf-ir/trace.h>
	34	#include <babeltrace/ctf-ir/stream-class-internal.h>
	35	#include <babeltrace/ctf-ir/stream-class.h>
	36	#include <babeltrace/ctf-ir/stream.h>
	37	#include <babeltrace/ctf-ir/stream-internal.h>
	38	#include <babeltrace/ctf-ir/trace-internal.h>
	39	#include <babeltrace/object-internal.h>
	40	#include <babeltrace/ref.h>
be514b0c	41	#include <inttypes.h>
f79cf0f0 PP	42
	43	struct bt_ctf_stream bt_ctf_packet_get_stream(struct bt_ctf_packet packet)
	44	{
	45	return packet ? bt_get(packet->stream) : NULL;
	46	}
	47
	48	struct bt_ctf_field *bt_ctf_packet_get_header(
	49	struct bt_ctf_packet *packet)
	50	{
	51	return packet ? bt_get(packet->header) : NULL;
	52	}
	53
	54	int bt_ctf_packet_set_header(struct bt_ctf_packet *packet,
	55	struct bt_ctf_field *header)
	56	{
	57	int ret = 0;
	58	struct bt_ctf_trace *trace = NULL;
	59	struct bt_ctf_stream_class *stream_class = NULL;
	60	struct bt_ctf_field_type *header_field_type = NULL;
	61	struct bt_ctf_field_type *expected_header_field_type = NULL;
	62
8ea705f0 PP	63	if (!packet) {
	64	BT_LOGW_STR("Invalid parameter: packet is NULL.");
	65	ret = -1;
	66	goto end;
	67	}
	68
	69	if (packet->frozen) {
	70	BT_LOGW("Invalid parameter: packet is frozen: addr=%p",
	71	packet);
f79cf0f0 PP	72	ret = -1;
	73	goto end;
	74	}
	75
	76	stream_class = bt_ctf_stream_get_class(packet->stream);
	77	assert(stream_class);
	78	trace = bt_ctf_stream_class_get_trace(stream_class);
	79	assert(trace);
c5c82c6e PP	80	expected_header_field_type = bt_ctf_trace_get_packet_header_type(trace);
	81
	82	if (!header) {
	83	if (expected_header_field_type) {
	84	BT_LOGW("Invalid parameter: setting no packet header but packet header field type is not NULL: "
	85	"packet-addr=%p, packet-header-ft-addr=%p",
	86	packet, expected_header_field_type);
	87	ret = -1;
	88	goto end;
	89	}
	90
	91	goto skip_validation;
	92	}
	93
f79cf0f0 PP	94	header_field_type = bt_ctf_field_get_type(header);
f79cf0f0 PP	95	assert(header_field_type);
f79cf0f0 PP	96
	97	if (bt_ctf_field_type_compare(header_field_type,
	98	expected_header_field_type)) {
8ea705f0 PP	99	BT_LOGW("Invalid parameter: packet header's field type is different from the trace's packet header field type: "
	100	"packet-addr=%p, packet-header-addr=%p",
	101	packet, header);
f79cf0f0 PP	102	ret = -1;
	103	goto end;
	104	}
	105
03bc92d4	106	skip_validation:
f79cf0f0 PP	107	bt_put(packet->header);
f79cf0f0 PP	108	packet->header = bt_get(header);
8ea705f0 PP	109	BT_LOGV("Set packet's header field: packet-addr=%p, packet-header-addr=%p",
8ea705f0 PP	110	packet, header);
f79cf0f0 PP	111
	112	end:
	113	BT_PUT(trace);
	114	BT_PUT(stream_class);
	115	BT_PUT(header_field_type);
	116	BT_PUT(expected_header_field_type);
	117
	118	return ret;
	119	}
	120
	121	struct bt_ctf_field *bt_ctf_packet_get_context(
	122	struct bt_ctf_packet *packet)
	123	{
	124	return packet ? bt_get(packet->context) : NULL;
	125	}
	126
	127	int bt_ctf_packet_set_context(struct bt_ctf_packet *packet,
	128	struct bt_ctf_field *context)
	129	{
	130	int ret = 0;
	131	struct bt_ctf_stream_class *stream_class = NULL;
	132	struct bt_ctf_field_type *context_field_type = NULL;
	133	struct bt_ctf_field_type *expected_context_field_type = NULL;
	134
8ea705f0 PP	135	if (!packet) {
	136	BT_LOGW_STR("Invalid parameter: packet is NULL.");
	137	ret = -1;
	138	goto end;
	139	}
	140
	141	if (packet->frozen) {
	142	BT_LOGW("Invalid parameter: packet is frozen: addr=%p",
	143	packet);
f79cf0f0 PP	144	ret = -1;
	145	goto end;
	146	}
	147
c5c82c6e PP	148	stream_class = bt_ctf_stream_get_class(packet->stream);
	149	assert(stream_class);
	150	expected_context_field_type =
	151	bt_ctf_stream_class_get_packet_context_type(stream_class);
	152
03bc92d4	153	if (!context) {
c5c82c6e PP	154	if (expected_context_field_type) {
	155	BT_LOGW("Invalid parameter: setting no packet context but packet context field type is not NULL: "
	156	"packet-addr=%p, packet-context-ft-addr=%p",
	157	packet, expected_context_field_type);
	158	ret = -1;
	159	goto end;
	160	}
	161
03bc92d4 JG	162	goto skip_validation;
	163	}
	164
f79cf0f0 PP	165	context_field_type = bt_ctf_field_get_type(context);
f79cf0f0 PP	166	assert(context_field_type);
f79cf0f0 PP	167
	168	if (bt_ctf_field_type_compare(context_field_type,
	169	expected_context_field_type)) {
8ea705f0 PP	170	BT_LOGW("Invalid parameter: packet context's field type is different from the stream class's packet context field type: "
	171	"packet-addr=%p, packet-context-addr=%p",
	172	packet, context);
f79cf0f0 PP	173	ret = -1;
	174	goto end;
	175	}
	176
03bc92d4	177	skip_validation:
f79cf0f0 PP	178	bt_put(packet->context);
f79cf0f0 PP	179	packet->context = bt_get(context);
8ea705f0 PP	180	BT_LOGV("Set packet's context field: packet-addr=%p, packet-context-addr=%p",
8ea705f0 PP	181	packet, context);
f79cf0f0 PP	182
	183	end:
	184	BT_PUT(stream_class);
	185	BT_PUT(context_field_type);
	186	BT_PUT(expected_context_field_type);
f79cf0f0 PP	187	return ret;
	188	}
	189
	190	BT_HIDDEN
	191	void bt_ctf_packet_freeze(struct bt_ctf_packet *packet)
	192	{
8ea705f0	193	if (!packet \|\| packet->frozen) {
5c3b707d	194	return;
f79cf0f0 PP	195	}
f79cf0f0 PP	196
8ea705f0	197	BT_LOGD("Freezing packet: addr=%p", packet);
d409daba	198	BT_LOGD_STR("Freezing packet's header field.");
918be005	199	bt_ctf_field_freeze(packet->header);
d409daba	200	BT_LOGD_STR("Freezing packet's context field.");
918be005	201	bt_ctf_field_freeze(packet->context);
f79cf0f0	202	packet->frozen = 1;
f79cf0f0 PP	203	}
	204
	205	static
	206	void bt_ctf_packet_destroy(struct bt_object *obj)
	207	{
	208	struct bt_ctf_packet *packet;
	209
	210	packet = container_of(obj, struct bt_ctf_packet, base);
8ea705f0	211	BT_LOGD("Destroying packet: addr=%p", packet);
d409daba	212	BT_LOGD_STR("Putting packet's header field.");
f79cf0f0	213	bt_put(packet->header);
d409daba	214	BT_LOGD_STR("Putting packet's context field.");
f79cf0f0	215	bt_put(packet->context);
d409daba	216	BT_LOGD_STR("Putting packet's stream.");
f79cf0f0 PP	217	bt_put(packet->stream);
	218	g_free(packet);
	219	}
	220
5c3b707d	221	struct bt_ctf_packet *bt_ctf_packet_create(
f79cf0f0 PP	222	struct bt_ctf_stream *stream)
	223	{
	224	struct bt_ctf_packet *packet = NULL;
	225	struct bt_ctf_stream_class *stream_class = NULL;
	226	struct bt_ctf_trace *trace = NULL;
	227
8ea705f0 PP	228	if (!stream) {
	229	BT_LOGW_STR("Invalid parameter: stream is NULL.");
	230	goto end;
	231	}
	232
be514b0c PP	233	BT_LOGD("Creating packet object: stream-addr=%p, "
	234	"stream-name=\"%s\", stream-class-addr=%p, "
	235	"stream-class-name=\"%s\", stream-class-id=%" PRId64,
	236	stream, bt_ctf_stream_get_name(stream),
	237	stream->stream_class,
	238	bt_ctf_stream_class_get_name(stream->stream_class),
	239	bt_ctf_stream_class_get_id(stream->stream_class));
	240
8ea705f0 PP	241	if (stream->pos.fd >= 0) {
8ea705f0 PP	242	BT_LOGW_STR("Invalid parameter: stream is a CTF writer stream.");
f79cf0f0 PP	243	goto end;
	244	}
	245
	246	stream_class = bt_ctf_stream_get_class(stream);
	247	assert(stream_class);
	248	trace = bt_ctf_stream_class_get_trace(stream_class);
	249	assert(trace);
	250	packet = g_new0(struct bt_ctf_packet, 1);
	251	if (!packet) {
8ea705f0	252	BT_LOGE_STR("Failed to allocate one packet object.");
f79cf0f0 PP	253	goto end;
	254	}
	255
	256	bt_object_init(packet, bt_ctf_packet_destroy);
	257	packet->stream = bt_get(stream);
be514b0c PP	258
	259	if (trace->packet_header_type) {
	260	BT_LOGD("Creating initial packet header field: ft-addr=%p",
	261	trace->packet_header_type);
	262	packet->header = bt_ctf_field_create(trace->packet_header_type);
	263	if (!packet->header) {
	264	BT_LOGE_STR("Cannot create initial packet header field object.");
	265	BT_PUT(packet);
	266	goto end;
	267	}
f79cf0f0 PP	268	}
f79cf0f0 PP	269
be514b0c PP	270	if (stream->stream_class->packet_context_type) {
	271	BT_LOGD("Creating initial packet context field: ft-addr=%p",
	272	stream->stream_class->packet_context_type);
	273	packet->context = bt_ctf_field_create(
	274	stream->stream_class->packet_context_type);
	275	if (!packet->context) {
	276	BT_LOGE_STR("Cannot create initial packet header field object.");
	277	BT_PUT(packet);
	278	goto end;
	279	}
f79cf0f0 PP	280	}
f79cf0f0 PP	281
8ea705f0 PP	282	BT_LOGD("Created packet object: addr=%p", packet);
8ea705f0 PP	283
f79cf0f0 PP	284	end:
	285	BT_PUT(trace);
	286	BT_PUT(stream_class);
	287
	288	return packet;
	289	}