[babeltrace.git] / src / lib / graph / connection.c

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
 * Copyright 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 */

#define BT_LOG_TAG "LIB/CONNECTION"
#include "lib/logging.h"

#include "lib/assert-cond.h"
#include <babeltrace2/graph/connection.h>
#include "lib/object.h"
#include "compat/compiler.h"
#include <stdbool.h>
#include <stdlib.h>
#include <glib.h>

#include "component.h"
#include "connection.h"
#include "graph.h"
#include "iterator.h"
#include "port.h"

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

	BT_LIB_LOGI("Destroying connection: %!+x", connection);

	/*
	 * Make sure that each message iterator which was created for
	 * this connection is finalized before we destroy it. Once a
	 * message iterator is finalized, you cannot use it.
	 *
	 * Because connections are destroyed before components within a
	 * graph, this ensures that message iterators are always
	 * finalized before their upstream component.
	 *
	 * Ending the connection does exactly this. We pass `false` to
	 * bt_connection_end() here to avoid removing this connection
	 * from the graph: if we're here, we're already in the graph's
	 * destructor.
	 */
	bt_connection_end(connection, false);
	g_ptr_array_free(connection->iterators, TRUE);
	connection->iterators = NULL;

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

static
void try_remove_connection_from_graph(struct bt_connection *connection)
{
	void *graph = (void *) bt_object_borrow_parent(&connection->base);

	if (connection->base.ref_count > 0 ||
			connection->downstream_port ||
			connection->upstream_port ||
			connection->iterators->len > 0) {
		return;
	}

	/*
	 * At this point we know that:
	 *
	 * 1. The connection is ended (ports were disconnected).
	 * 2. All the message iterators that this connection
	 *    created, if any, are finalized.
	 * 3. The connection's reference count is 0, so only the
	 *    parent (graph) owns this connection after this call.
	 *
	 * In other words, no other object than the graph knows this
	 * connection.
	 *
	 * It is safe to remove the connection from the graph, therefore
	 * destroying it.
	 */
	BT_LIB_LOGD("Removing self from graph's connections: "
		"%![graph-]+g, %![conn-]+x", graph, connection);
	bt_graph_remove_connection(graph, connection);
}

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

	try_remove_connection_from_graph(connection);
}

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;

	BT_LIB_LOGI("Creating connection: "
		"%![graph-]+g, %![up-port-]+p, %![down-port-]+p",
		graph, upstream_port, downstream_port);
	connection = g_new0(struct bt_connection, 1);
	if (!connection) {
		BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one connection.");
		goto end;
	}

	bt_object_init_shared_with_parent(&connection->base,
		destroy_connection);
	bt_object_set_parent_is_owner_listener_func(&connection->base,
		parent_is_owner);
	connection->iterators = g_ptr_array_new();
	if (!connection->iterators) {
		BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GPtrArray.");
		BT_OBJECT_PUT_REF_AND_RESET(connection);
		goto end;
	}

	/* Weak references are taken, see comment in header. */
	connection->upstream_port = upstream_port;
	connection->downstream_port = downstream_port;
	BT_LIB_LOGD("Setting upstream port's connection: %!+p", upstream_port);
	bt_port_set_connection(upstream_port, connection);
	BT_LIB_LOGD("Setting downstream port's connection: %!+p",
		downstream_port);
	bt_port_set_connection(downstream_port, connection);
	bt_object_set_parent(&connection->base, &graph->base);
	BT_LIB_LOGI("Created connection: %!+x", connection);

end:
	return connection;
}

void bt_connection_end(struct bt_connection *conn, bool try_remove_from_graph)
{
	struct bt_port *downstream_port = conn->downstream_port;
	struct bt_port *upstream_port = conn->upstream_port;
	size_t i;

	BT_LIB_LOGI("Ending connection: %!+x, try-remove-from-graph=%d",
		conn, try_remove_from_graph);

	/*
	 * Any of the following message callback functions could
	 * remove one of the connection's ports from its component. To
	 * make sure that at least logging in called functions works
	 * with existing objects, get a local reference on both ports.
	 */
	bt_object_get_ref(downstream_port);
	bt_object_get_ref(upstream_port);

	if (downstream_port) {
		BT_LIB_LOGD("Disconnecting connection's downstream port: %!+p",
			downstream_port);
		bt_port_set_connection(downstream_port, NULL);
		conn->downstream_port = NULL;
	}

	if (upstream_port) {
		BT_LIB_LOGD("Disconnecting connection's upstream port: %!+p",
			upstream_port);
		bt_port_set_connection(upstream_port, NULL);
		conn->upstream_port = NULL;
	}

	/*
	 * It is safe to put the local port references now that we don't
	 * need them anymore. This could indeed destroy them.
	 */
	bt_object_put_ref(downstream_port);
	bt_object_put_ref(upstream_port);

	/*
	 * Because this connection is ended, finalize each message
	 * iterator created from it.
	 *
	 * In practice, this only happens when the connection is
	 * destroyed and not all its message iterators were finalized,
	 * which is on graph destruction.
	 */
	for (i = 0; i < conn->iterators->len; i++) {
		struct bt_message_iterator *iterator =
			g_ptr_array_index(conn->iterators, i);

		BT_LIB_LOGD("Finalizing message iterator created by "
			"this ended connection: %![iter-]+i", iterator);
		bt_message_iterator_try_finalize(
			iterator);

		/*
		 * Make sure this iterator does not try to remove itself
		 * from this connection's iterators on destruction
		 * because this connection won't exist anymore.
		 */
		bt_message_iterator_set_connection(
			iterator, NULL);
	}

	g_ptr_array_set_size(conn->iterators, 0);

	if (try_remove_from_graph) {
		try_remove_connection_from_graph(conn);
	}
}

BT_EXPORT
const struct bt_port_output *bt_connection_borrow_upstream_port_const(
		const struct bt_connection *connection)
{
	BT_ASSERT_PRE_DEV_CONN_NON_NULL(connection);
	return (void *) connection->upstream_port;
}

BT_EXPORT
const struct bt_port_input *bt_connection_borrow_downstream_port_const(
		const struct bt_connection *connection)
{
	BT_ASSERT_PRE_DEV_CONN_NON_NULL(connection);
	return (void *) connection->downstream_port;
}

void bt_connection_remove_iterator(struct bt_connection *conn,
		struct bt_message_iterator *iterator)
{
	g_ptr_array_remove(conn->iterators, iterator);
	BT_LIB_LOGD("Removed message iterator from connection: "
		"%![conn-]+x, %![iter-]+i", conn, iterator);
	try_remove_connection_from_graph(conn);
}

BT_EXPORT
void bt_connection_get_ref(const struct bt_connection *connection)
{
	bt_object_get_ref(connection);
}

BT_EXPORT
void bt_connection_put_ref(const struct bt_connection *connection)
{
	bt_object_put_ref(connection);
}
Commit	Line	Data
	1	/*
	2	* SPDX-License-Identifier: MIT
	3	*
	4	* Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
	5	* Copyright 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	6	*/
	7
	8	#define BT_LOG_TAG "LIB/CONNECTION"
	9	#include "lib/logging.h"
	10
	11	#include "lib/assert-cond.h"
	12	#include <babeltrace2/graph/connection.h>
	13	#include "lib/object.h"
	14	#include "compat/compiler.h"
	15	#include <stdbool.h>
	16	#include <stdlib.h>
	17	#include <glib.h>
	18
	19	#include "component.h"
	20	#include "connection.h"
	21	#include "graph.h"
	22	#include "iterator.h"
	23	#include "port.h"
	24
	25	static
	26	void destroy_connection(struct bt_object *obj)
	27	{
	28	struct bt_connection *connection = container_of(obj,
	29	struct bt_connection, base);
	30
	31	BT_LIB_LOGI("Destroying connection: %!+x", connection);
	32
	33	/*
	34	* Make sure that each message iterator which was created for
	35	* this connection is finalized before we destroy it. Once a
	36	* message iterator is finalized, you cannot use it.
	37	*
	38	* Because connections are destroyed before components within a
	39	* graph, this ensures that message iterators are always
	40	* finalized before their upstream component.
	41	*
	42	* Ending the connection does exactly this. We pass `false` to
	43	* bt_connection_end() here to avoid removing this connection
	44	* from the graph: if we're here, we're already in the graph's
	45	* destructor.
	46	*/
	47	bt_connection_end(connection, false);
	48	g_ptr_array_free(connection->iterators, TRUE);
	49	connection->iterators = NULL;
	50
	51	/*
	52	* No bt_object_put_ref on ports as a connection only holds _weak_
	53	* references to them.
	54	*/
	55	g_free(connection);
	56	}
	57
	58	static
	59	void try_remove_connection_from_graph(struct bt_connection *connection)
	60	{
	61	void graph = (void ) bt_object_borrow_parent(&connection->base);
	62
	63	if (connection->base.ref_count > 0 \|\|
	64	connection->downstream_port \|\|
	65	connection->upstream_port \|\|
	66	connection->iterators->len > 0) {
	67	return;
	68	}
	69
	70	/*
	71	* At this point we know that:
	72	*
	73	* 1. The connection is ended (ports were disconnected).
	74	* 2. All the message iterators that this connection
	75	* created, if any, are finalized.
	76	* 3. The connection's reference count is 0, so only the
	77	* parent (graph) owns this connection after this call.
	78	*
	79	* In other words, no other object than the graph knows this
	80	* connection.
	81	*
	82	* It is safe to remove the connection from the graph, therefore
	83	* destroying it.
	84	*/
	85	BT_LIB_LOGD("Removing self from graph's connections: "
	86	"%![graph-]+g, %![conn-]+x", graph, connection);
	87	bt_graph_remove_connection(graph, connection);
	88	}
	89
	90	static
	91	void parent_is_owner(struct bt_object *obj)
	92	{
	93	struct bt_connection *connection = container_of(obj,
	94	struct bt_connection, base);
	95
	96	try_remove_connection_from_graph(connection);
	97	}
	98
	99	struct bt_connection bt_connection_create(struct bt_graph graph,
	100	struct bt_port *upstream_port,
	101	struct bt_port *downstream_port)
	102	{
	103	struct bt_connection *connection = NULL;
	104
	105	BT_LIB_LOGI("Creating connection: "
	106	"%![graph-]+g, %![up-port-]+p, %![down-port-]+p",
	107	graph, upstream_port, downstream_port);
	108	connection = g_new0(struct bt_connection, 1);
	109	if (!connection) {
	110	BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one connection.");
	111	goto end;
	112	}
	113
	114	bt_object_init_shared_with_parent(&connection->base,
	115	destroy_connection);
	116	bt_object_set_parent_is_owner_listener_func(&connection->base,
	117	parent_is_owner);
	118	connection->iterators = g_ptr_array_new();
	119	if (!connection->iterators) {
	120	BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GPtrArray.");
	121	BT_OBJECT_PUT_REF_AND_RESET(connection);
	122	goto end;
	123	}
	124
	125	/* Weak references are taken, see comment in header. */
	126	connection->upstream_port = upstream_port;
	127	connection->downstream_port = downstream_port;
	128	BT_LIB_LOGD("Setting upstream port's connection: %!+p", upstream_port);
	129	bt_port_set_connection(upstream_port, connection);
	130	BT_LIB_LOGD("Setting downstream port's connection: %!+p",
	131	downstream_port);
	132	bt_port_set_connection(downstream_port, connection);
	133	bt_object_set_parent(&connection->base, &graph->base);
	134	BT_LIB_LOGI("Created connection: %!+x", connection);
	135
	136	end:
	137	return connection;
	138	}
	139
	140	void bt_connection_end(struct bt_connection *conn, bool try_remove_from_graph)
	141	{
	142	struct bt_port *downstream_port = conn->downstream_port;
	143	struct bt_port *upstream_port = conn->upstream_port;
	144	size_t i;
	145
	146	BT_LIB_LOGI("Ending connection: %!+x, try-remove-from-graph=%d",
	147	conn, try_remove_from_graph);
	148
	149	/*
	150	* Any of the following message callback functions could
	151	* remove one of the connection's ports from its component. To
	152	* make sure that at least logging in called functions works
	153	* with existing objects, get a local reference on both ports.
	154	*/
	155	bt_object_get_ref(downstream_port);
	156	bt_object_get_ref(upstream_port);
	157
	158	if (downstream_port) {
	159	BT_LIB_LOGD("Disconnecting connection's downstream port: %!+p",
	160	downstream_port);
	161	bt_port_set_connection(downstream_port, NULL);
	162	conn->downstream_port = NULL;
	163	}
	164
	165	if (upstream_port) {
	166	BT_LIB_LOGD("Disconnecting connection's upstream port: %!+p",
	167	upstream_port);
	168	bt_port_set_connection(upstream_port, NULL);
	169	conn->upstream_port = NULL;
	170	}
	171
	172	/*
	173	* It is safe to put the local port references now that we don't
	174	* need them anymore. This could indeed destroy them.
	175	*/
	176	bt_object_put_ref(downstream_port);
	177	bt_object_put_ref(upstream_port);
	178
	179	/*
	180	* Because this connection is ended, finalize each message
	181	* iterator created from it.
	182	*
	183	* In practice, this only happens when the connection is
	184	* destroyed and not all its message iterators were finalized,
	185	* which is on graph destruction.
	186	*/
	187	for (i = 0; i < conn->iterators->len; i++) {
	188	struct bt_message_iterator *iterator =
	189	g_ptr_array_index(conn->iterators, i);
	190
	191	BT_LIB_LOGD("Finalizing message iterator created by "
	192	"this ended connection: %![iter-]+i", iterator);
	193	bt_message_iterator_try_finalize(
	194	iterator);
	195
	196	/*
	197	* Make sure this iterator does not try to remove itself
	198	* from this connection's iterators on destruction
	199	* because this connection won't exist anymore.
	200	*/
	201	bt_message_iterator_set_connection(
	202	iterator, NULL);
	203	}
	204
	205	g_ptr_array_set_size(conn->iterators, 0);
	206
	207	if (try_remove_from_graph) {
	208	try_remove_connection_from_graph(conn);
	209	}
	210	}
	211
	212	BT_EXPORT
	213	const struct bt_port_output *bt_connection_borrow_upstream_port_const(
	214	const struct bt_connection *connection)
	215	{
	216	BT_ASSERT_PRE_DEV_CONN_NON_NULL(connection);
	217	return (void *) connection->upstream_port;
	218	}
	219
	220	BT_EXPORT
	221	const struct bt_port_input *bt_connection_borrow_downstream_port_const(
	222	const struct bt_connection *connection)
	223	{
	224	BT_ASSERT_PRE_DEV_CONN_NON_NULL(connection);
	225	return (void *) connection->downstream_port;
	226	}
	227
	228	void bt_connection_remove_iterator(struct bt_connection *conn,
	229	struct bt_message_iterator *iterator)
	230	{
	231	g_ptr_array_remove(conn->iterators, iterator);
	232	BT_LIB_LOGD("Removed message iterator from connection: "
	233	"%![conn-]+x, %![iter-]+i", conn, iterator);
	234	try_remove_connection_from_graph(conn);
	235	}
	236
	237	BT_EXPORT
	238	void bt_connection_get_ref(const struct bt_connection *connection)
	239	{
	240	bt_object_get_ref(connection);
	241	}
	242
	243	BT_EXPORT
	244	void bt_connection_put_ref(const struct bt_connection *connection)
	245	{
	246	bt_object_put_ref(connection);
	247	}