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 }