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