[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/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/lib-logging-internal.h>
#include <babeltrace/object-internal.h>
#include <babeltrace/ref.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;

	BT_LOGD("Creating packet object: stream-addr=%p", stream);

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

	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);
	packet->header = bt_ctf_field_create(trace->packet_header_type);
	if (!packet->header && trace->packet_header_type) {
		BT_LOGE_STR("Cannot create initial packet header field object.");
		BT_PUT(packet);
		goto end;
	}

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