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 "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 }