[babeltrace.git] / lib / component / connection.c

/*
 * connection.c
 *
 * Babeltrace Connection
 *
 * Copyright 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * Author: Jérémie Galarneau <jeremie.galarneau@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.
 */

#include <babeltrace/graph/notification-iterator-internal.h>
#include <babeltrace/graph/component-internal.h>
#include <babeltrace/graph/component-source-internal.h>
#include <babeltrace/graph/component-filter-internal.h>
#include <babeltrace/graph/connection-internal.h>
#include <babeltrace/graph/private-connection.h>
#include <babeltrace/graph/graph-internal.h>
#include <babeltrace/graph/port-internal.h>
#include <babeltrace/object-internal.h>
#include <babeltrace/compiler-internal.h>
#include <glib.h>

static
void bt_connection_destroy(struct bt_object *obj)
{
	struct bt_connection *connection = container_of(obj,
			struct bt_connection, base);

	/*
	 * No bt_put on ports as a connection only holds _weak_ references
	 * to them.
	 */
	g_free(connection);
}

struct bt_connection *bt_connection_from_private_connection(
		struct bt_private_connection *private_connection)
{
	return bt_get(bt_connection_from_private(private_connection));
}

BT_HIDDEN
struct bt_connection *bt_connection_create(
		struct bt_graph *graph,
		struct bt_port *upstream_port,
		struct bt_port *downstream_port)
{
	struct bt_connection *connection = NULL;

	if (bt_port_get_type(upstream_port) != BT_PORT_TYPE_OUTPUT) {
		goto end;
	}
	if (bt_port_get_type(downstream_port) != BT_PORT_TYPE_INPUT) {
		goto end;
	}

	connection = g_new0(struct bt_connection, 1);
	if (!connection) {
		goto end;
	}

	bt_object_init(connection, bt_connection_destroy);
	/* Weak references are taken, see comment in header. */
	connection->upstream_port = upstream_port;
	connection->downstream_port = downstream_port;
	bt_port_set_connection(upstream_port, connection);
	bt_port_set_connection(downstream_port, connection);
	bt_object_set_parent(connection, &graph->base);
end:
	return connection;
}

BT_HIDDEN
void bt_connection_disconnect_ports(struct bt_connection *conn)
{
	struct bt_component *downstream_comp = NULL;
	struct bt_component *upstream_comp = NULL;
	struct bt_port *downstream_port = conn->downstream_port;
	struct bt_port *upstream_port = conn->upstream_port;
	struct bt_graph *graph = (void *) bt_object_get_parent(conn);

	if (downstream_port) {
		downstream_comp = bt_port_get_component(downstream_port);
		bt_port_set_connection(downstream_port, NULL);
		conn->downstream_port = NULL;
	}

	if (upstream_port) {
		upstream_comp = bt_port_get_component(upstream_port);
		bt_port_set_connection(upstream_port, NULL);
		conn->upstream_port = NULL;
	}

	if (downstream_comp) {
		bt_component_port_disconnected(downstream_comp,
			downstream_port);
	}

	if (upstream_comp) {
		bt_component_port_disconnected(upstream_comp, upstream_port);
	}

	assert(graph);
	bt_graph_notify_ports_disconnected(graph, upstream_comp,
		downstream_comp, upstream_port, downstream_port);
	bt_put(downstream_comp);
	bt_put(upstream_comp);
	bt_put(graph);
}

struct bt_port *bt_connection_get_upstream_port(
		struct bt_connection *connection)
{
	return connection ? bt_get(connection->upstream_port) : NULL;
}

struct bt_port *bt_connection_get_downstream_port(
		struct bt_connection *connection)
{
	return connection ? bt_get(connection->downstream_port) : NULL;
}

struct bt_notification_iterator *
bt_private_connection_create_notification_iterator(
		struct bt_private_connection *private_connection)
{
	enum bt_notification_iterator_status ret_iterator;
	enum bt_component_class_type upstream_comp_class_type;
	struct bt_notification_iterator *iterator = NULL;
	struct bt_port *upstream_port = NULL;
	struct bt_component *upstream_component = NULL;
	struct bt_component_class *upstream_comp_class = NULL;
	struct bt_connection *connection = NULL;
	bt_component_class_notification_iterator_init_method init_method = NULL;

	if (!private_connection) {
		goto error;
	}

	connection = bt_connection_from_private(private_connection);

	if (!connection->upstream_port || !connection->downstream_port) {
		goto error;
	}

	upstream_port = connection->upstream_port;
	assert(upstream_port);
	upstream_component = bt_port_get_component(upstream_port);
	assert(upstream_component);
	upstream_comp_class = upstream_component->class;

	if (!upstream_component) {
		goto error;
	}

	upstream_comp_class_type =
		bt_component_get_class_type(upstream_component);
	if (upstream_comp_class_type != BT_COMPONENT_CLASS_TYPE_SOURCE &&
			upstream_comp_class_type != BT_COMPONENT_CLASS_TYPE_FILTER) {
		/* Unsupported operation. */
		goto error;
	}

	iterator = bt_notification_iterator_create(upstream_component);
	if (!iterator) {
		goto error;
	}

	switch (upstream_comp_class_type) {
	case BT_COMPONENT_CLASS_TYPE_SOURCE:
	{
		struct bt_component_class_source *source_class =
			container_of(upstream_comp_class,
				struct bt_component_class_source, parent);
		init_method = source_class->methods.iterator.init;
		break;
	}
	case BT_COMPONENT_CLASS_TYPE_FILTER:
	{
		struct bt_component_class_filter *filter_class =
			container_of(upstream_comp_class,
				struct bt_component_class_filter, parent);
		init_method = filter_class->methods.iterator.init;
		break;
	}
	default:
		/* Unreachable. */
		assert(0);
	}

	if (init_method) {
		enum bt_notification_iterator_status status = init_method(
			bt_private_notification_iterator_from_notification_iterator(iterator),
			bt_private_port_from_port(upstream_port));
		if (status < 0) {
			goto error;
		}
	}

	ret_iterator = bt_notification_iterator_validate(iterator);
	if (ret_iterator != BT_NOTIFICATION_ITERATOR_STATUS_OK) {
		goto error;
	}

	goto end;

error:
	BT_PUT(iterator);

end:
	bt_put(upstream_component);
	return iterator;
}
Commit	Line	Data
784cdc68	1	/*
7d55361f	2	* connection.c
784cdc68 JG	3	*
	4	* Babeltrace Connection
	5	*
	6	* Copyright 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	7	*
	8	* Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
	9	*
	10	* Permission is hereby granted, free of charge, to any person obtaining a copy
	11	* of this software and associated documentation files (the "Software"), to deal
	12	* in the Software without restriction, including without limitation the rights
	13	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	14	* copies of the Software, and to permit persons to whom the Software is
	15	* furnished to do so, subject to the following conditions:
	16	*
	17	* The above copyright notice and this permission notice shall be included in
	18	* all copies or substantial portions of the Software.
	19	*
	20	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	21	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	23	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	24	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	25	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	26	* SOFTWARE.
	27	*/
	28
b2e0c907 PP	29	#include <babeltrace/graph/notification-iterator-internal.h>
	30	#include <babeltrace/graph/component-internal.h>
	31	#include <babeltrace/graph/component-source-internal.h>
	32	#include <babeltrace/graph/component-filter-internal.h>
	33	#include <babeltrace/graph/connection-internal.h>
	34	#include <babeltrace/graph/private-connection.h>
	35	#include <babeltrace/graph/graph-internal.h>
	36	#include <babeltrace/graph/port-internal.h>
784cdc68	37	#include <babeltrace/object-internal.h>
3d9990ac	38	#include <babeltrace/compiler-internal.h>
784cdc68 JG	39	#include <glib.h>
	40
	41	static
	42	void bt_connection_destroy(struct bt_object *obj)
	43	{
	44	struct bt_connection *connection = container_of(obj,
	45	struct bt_connection, base);
	46
	47	/*
	48	* No bt_put on ports as a connection only holds _weak_ references
	49	* to them.
	50	*/
	51	g_free(connection);
	52	}
	53
890882ef PP	54	struct bt_connection *bt_connection_from_private_connection(
	55	struct bt_private_connection *private_connection)
	56	{
	57	return bt_get(bt_connection_from_private(private_connection));
	58	}
	59
784cdc68 JG	60	BT_HIDDEN
	61	struct bt_connection *bt_connection_create(
	62	struct bt_graph *graph,
72b913fb PP	63	struct bt_port *upstream_port,
72b913fb PP	64	struct bt_port *downstream_port)
784cdc68 JG	65	{
	66	struct bt_connection *connection = NULL;
	67
72b913fb	68	if (bt_port_get_type(upstream_port) != BT_PORT_TYPE_OUTPUT) {
784cdc68 JG	69	goto end;
784cdc68 JG	70	}
72b913fb	71	if (bt_port_get_type(downstream_port) != BT_PORT_TYPE_INPUT) {
784cdc68 JG	72	goto end;
	73	}
	74
	75	connection = g_new0(struct bt_connection, 1);
	76	if (!connection) {
	77	goto end;
	78	}
	79
	80	bt_object_init(connection, bt_connection_destroy);
	81	/* Weak references are taken, see comment in header. */
72b913fb PP	82	connection->upstream_port = upstream_port;
	83	connection->downstream_port = downstream_port;
	84	bt_port_set_connection(upstream_port, connection);
	85	bt_port_set_connection(downstream_port, connection);
784cdc68 JG	86	bt_object_set_parent(connection, &graph->base);
	87	end:
	88	return connection;
	89	}
	90
72b913fb	91	BT_HIDDEN
2038affb	92	void bt_connection_disconnect_ports(struct bt_connection *conn)
72b913fb PP	93	{
	94	struct bt_component *downstream_comp = NULL;
	95	struct bt_component *upstream_comp = NULL;
	96	struct bt_port *downstream_port = conn->downstream_port;
	97	struct bt_port *upstream_port = conn->upstream_port;
f345f8bb	98	struct bt_graph graph = (void ) bt_object_get_parent(conn);
72b913fb PP	99
	100	if (downstream_port) {
	101	downstream_comp = bt_port_get_component(downstream_port);
	102	bt_port_set_connection(downstream_port, NULL);
	103	conn->downstream_port = NULL;
	104	}
	105
	106	if (upstream_port) {
	107	upstream_comp = bt_port_get_component(upstream_port);
	108	bt_port_set_connection(upstream_port, NULL);
	109	conn->upstream_port = NULL;
	110	}
	111
2038affb	112	if (downstream_comp) {
72b913fb PP	113	bt_component_port_disconnected(downstream_comp,
	114	downstream_port);
	115	}
	116
2038affb	117	if (upstream_comp) {
72b913fb PP	118	bt_component_port_disconnected(upstream_comp, upstream_port);
	119	}
	120
f345f8bb PP	121	assert(graph);
	122	bt_graph_notify_ports_disconnected(graph, upstream_comp,
	123	downstream_comp, upstream_port, downstream_port);
72b913fb PP	124	bt_put(downstream_comp);
72b913fb PP	125	bt_put(upstream_comp);
f345f8bb	126	bt_put(graph);
72b913fb PP	127	}
	128
	129	struct bt_port *bt_connection_get_upstream_port(
784cdc68 JG	130	struct bt_connection *connection)
784cdc68 JG	131	{
72b913fb	132	return connection ? bt_get(connection->upstream_port) : NULL;
784cdc68 JG	133	}
784cdc68 JG	134
72b913fb	135	struct bt_port *bt_connection_get_downstream_port(
784cdc68 JG	136	struct bt_connection *connection)
784cdc68 JG	137	{
72b913fb	138	return connection ? bt_get(connection->downstream_port) : NULL;
784cdc68 JG	139	}
	140
	141	struct bt_notification_iterator *
890882ef PP	142	bt_private_connection_create_notification_iterator(
890882ef PP	143	struct bt_private_connection *private_connection)
784cdc68	144	{
890882ef PP	145	enum bt_notification_iterator_status ret_iterator;
	146	enum bt_component_class_type upstream_comp_class_type;
	147	struct bt_notification_iterator *iterator = NULL;
	148	struct bt_port *upstream_port = NULL;
784cdc68	149	struct bt_component *upstream_component = NULL;
890882ef PP	150	struct bt_component_class *upstream_comp_class = NULL;
	151	struct bt_connection *connection = NULL;
	152	bt_component_class_notification_iterator_init_method init_method = NULL;
784cdc68	153
890882ef PP	154	if (!private_connection) {
890882ef PP	155	goto error;
784cdc68 JG	156	}
784cdc68 JG	157
890882ef PP	158	connection = bt_connection_from_private(private_connection);
890882ef PP	159
72b913fb	160	if (!connection->upstream_port \|\| !connection->downstream_port) {
890882ef	161	goto error;
72b913fb PP	162	}
72b913fb PP	163
890882ef PP	164	upstream_port = connection->upstream_port;
	165	assert(upstream_port);
	166	upstream_component = bt_port_get_component(upstream_port);
784cdc68	167	assert(upstream_component);
890882ef PP	168	upstream_comp_class = upstream_component->class;
	169
	170	if (!upstream_component) {
	171	goto error;
	172	}
	173
	174	upstream_comp_class_type =
	175	bt_component_get_class_type(upstream_component);
	176	if (upstream_comp_class_type != BT_COMPONENT_CLASS_TYPE_SOURCE &&
	177	upstream_comp_class_type != BT_COMPONENT_CLASS_TYPE_FILTER) {
	178	/* Unsupported operation. */
	179	goto error;
	180	}
784cdc68	181
890882ef PP	182	iterator = bt_notification_iterator_create(upstream_component);
	183	if (!iterator) {
	184	goto error;
	185	}
	186
	187	switch (upstream_comp_class_type) {
784cdc68	188	case BT_COMPONENT_CLASS_TYPE_SOURCE:
890882ef PP	189	{
	190	struct bt_component_class_source *source_class =
	191	container_of(upstream_comp_class,
	192	struct bt_component_class_source, parent);
	193	init_method = source_class->methods.iterator.init;
784cdc68	194	break;
890882ef	195	}
784cdc68	196	case BT_COMPONENT_CLASS_TYPE_FILTER:
890882ef PP	197	{
	198	struct bt_component_class_filter *filter_class =
	199	container_of(upstream_comp_class,
	200	struct bt_component_class_filter, parent);
	201	init_method = filter_class->methods.iterator.init;
784cdc68	202	break;
890882ef	203	}
784cdc68	204	default:
890882ef PP	205	/* Unreachable. */
	206	assert(0);
	207	}
	208
	209	if (init_method) {
	210	enum bt_notification_iterator_status status = init_method(
91457551 PP	211	bt_private_notification_iterator_from_notification_iterator(iterator),
91457551 PP	212	bt_private_port_from_port(upstream_port));
890882ef PP	213	if (status < 0) {
	214	goto error;
	215	}
	216	}
	217
	218	ret_iterator = bt_notification_iterator_validate(iterator);
	219	if (ret_iterator != BT_NOTIFICATION_ITERATOR_STATUS_OK) {
	220	goto error;
784cdc68	221	}
890882ef PP	222
	223	goto end;
	224
	225	error:
	226	BT_PUT(iterator);
	227
784cdc68 JG	228	end:
784cdc68 JG	229	bt_put(upstream_component);
890882ef	230	return iterator;
784cdc68	231	}