X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=lib%2Fgraph%2Fconnection.c;h=91d130edcf6c9147bcfac3f36ae69bde57bcc8b9;hb=5c5632787fc9cafa602c89a28966bcfd01ec0204;hp=feed59556247c562c40d2149cf38cae7e20263f7;hpb=bd14d76835630e092320c8a04300088242dcdc99;p=babeltrace.git diff --git a/lib/graph/connection.c b/lib/graph/connection.c index feed5955..91d130ed 100644 --- a/lib/graph/connection.c +++ b/lib/graph/connection.c @@ -26,6 +26,9 @@ * SOFTWARE. */ +#define BT_LOG_TAG "CONNECTION" +#include + #include #include #include @@ -36,6 +39,8 @@ #include #include #include +#include +#include #include static @@ -43,7 +48,8 @@ void bt_connection_destroy(struct bt_object *obj) { struct bt_connection *connection = container_of(obj, struct bt_connection, base); - size_t i; + + BT_LOGD("Destroying connection: addr=%p", connection); /* * Make sure that each notification iterator which was created @@ -54,38 +60,67 @@ void bt_connection_destroy(struct bt_object *obj) * Because connections are destroyed before components within a * graph, this ensures that notification 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. */ - if (connection->iterators) { - for (i = 0; i < connection->iterators->len; i++) { - struct bt_notification_iterator *iterator = - g_ptr_array_index(connection->iterators, i); - - bt_notification_iterator_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_notification_iterator_set_connection(iterator, - NULL); - } + bt_connection_end(connection, false); + g_ptr_array_free(connection->iterators, TRUE); + + /* + * No bt_put on ports as a connection only holds _weak_ + * references to them. + */ + g_free(connection); +} - g_ptr_array_free(connection->iterators, TRUE); +static +void bt_connection_try_remove_from_graph(struct bt_connection *connection) +{ + void *graph = bt_object_borrow_parent(&connection->base); + + if (connection->base.ref_count.count > 0 || + connection->downstream_port || + connection->upstream_port || + connection->iterators->len > 0) { + return; } /* - * No bt_put on ports as a connection only holds _weak_ references - * to them. + * At this point we know that: + * + * 1. The connection is ended (ports were disconnected). + * 2. All the notification 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. */ - g_free(connection); + BT_LOGD("Removing self from graph's connections: " + "graph-addr=%p, conn-addr=%p", graph, connection); + bt_graph_remove_connection(graph, connection); } -struct bt_connection *bt_connection_from_private_connection( +static +void bt_connection_parent_is_owner(struct bt_object *obj) +{ + struct bt_connection *connection = container_of(obj, + struct bt_connection, base); + + bt_connection_try_remove_from_graph(connection); +} + +struct bt_connection *bt_connection_borrow_from_private( struct bt_private_connection *private_connection) { - return bt_get(bt_connection_from_private(private_connection)); + return (void *) private_connection; } BT_HIDDEN @@ -97,20 +132,31 @@ struct bt_connection *bt_connection_create( struct bt_connection *connection = NULL; if (bt_port_get_type(upstream_port) != BT_PORT_TYPE_OUTPUT) { + BT_LOGW_STR("Invalid parameter: upstream port is not an output port."); goto end; } if (bt_port_get_type(downstream_port) != BT_PORT_TYPE_INPUT) { + BT_LOGW_STR("Invalid parameter: downstream port is not an input port."); goto end; } + BT_LOGD("Creating connection: " + "graph-addr=%p, upstream-port-addr=%p, uptream-port-name=\"%s\", " + "downstream-port-addr=%p, downstream-port-name=\"%s\"", + graph, upstream_port, bt_port_get_name(upstream_port), + downstream_port, bt_port_get_name(downstream_port)); connection = g_new0(struct bt_connection, 1); if (!connection) { + BT_LOGE_STR("Failed to allocate one connection."); goto end; } bt_object_init(connection, bt_connection_destroy); + bt_object_set_parent_is_owner_listener(connection, + bt_connection_parent_is_owner); connection->iterators = g_ptr_array_new(); if (!connection->iterators) { + BT_LOGE_STR("Failed to allocate a GPtrArray."); BT_PUT(connection); goto end; } @@ -118,49 +164,99 @@ struct bt_connection *bt_connection_create( /* Weak references are taken, see comment in header. */ connection->upstream_port = upstream_port; connection->downstream_port = downstream_port; + BT_LOGD_STR("Setting upstream port's connection."); bt_port_set_connection(upstream_port, connection); + BT_LOGD_STR("Setting downstream port's connection."); bt_port_set_connection(downstream_port, connection); bt_object_set_parent(connection, &graph->base); + BT_LOGD("Created connection: " + "graph-addr=%p, upstream-port-addr=%p, uptream-port-name=\"%s\", " + "downstream-port-addr=%p, downstream-port-name=\"%s\", " + "conn-addr=%p", + graph, upstream_port, bt_port_get_name(upstream_port), + downstream_port, bt_port_get_name(downstream_port), + connection); + end: return connection; } BT_HIDDEN -void bt_connection_disconnect_ports(struct bt_connection *conn) +void bt_connection_end(struct bt_connection *conn, + bool try_remove_from_graph) { 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); + struct bt_graph *graph = bt_connection_borrow_graph(conn); + size_t i; + + BT_LOGD("Ending connection: conn-addr=%p, try-remove-from-graph=%d", + conn, try_remove_from_graph); if (downstream_port) { + BT_LOGD("Disconnecting connection's downstream port: " + "port-addr=%p, port-name=\"%s\"", + downstream_port, bt_port_get_name(downstream_port)); downstream_comp = bt_port_get_component(downstream_port); bt_port_set_connection(downstream_port, NULL); conn->downstream_port = NULL; } if (upstream_port) { + BT_LOGD("Disconnecting connection's upstream port: " + "port-addr=%p, port-name=\"%s\"", + upstream_port, bt_port_get_name(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() logs details */ bt_component_port_disconnected(downstream_comp, downstream_port); } if (upstream_comp) { + /* bt_component_port_disconnected() logs details */ bt_component_port_disconnected(upstream_comp, upstream_port); } - assert(graph); + BT_ASSERT(graph); + /* bt_graph_notify_ports_disconnected() logs details */ 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); + + /* + * Because this connection is ended, finalize (cancel) each + * notification iterator created from it. + */ + for (i = 0; i < conn->iterators->len; i++) { + struct bt_notification_iterator_private_connection *iterator = + g_ptr_array_index(conn->iterators, i); + + BT_LOGD("Finalizing notification iterator created by this ended connection: " + "conn-addr=%p, iter-addr=%p", conn, iterator); + bt_private_connection_notification_iterator_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_private_connection_notification_iterator_set_connection( + iterator, NULL); + } + + g_ptr_array_set_size(conn->iterators, 0); + + if (try_remove_from_graph) { + bt_connection_try_remove_from_graph(conn); + } } struct bt_port *bt_connection_get_upstream_port( @@ -175,59 +271,77 @@ struct bt_port *bt_connection_get_downstream_port( return connection ? bt_get(connection->downstream_port) : NULL; } -struct bt_notification_iterator * +enum bt_connection_status bt_private_connection_create_notification_iterator( struct bt_private_connection *private_connection, - const enum bt_notification_type *notification_types) + struct bt_notification_iterator **user_iterator) { - enum bt_notification_iterator_status ret_iterator; enum bt_component_class_type upstream_comp_class_type; - struct bt_notification_iterator *iterator = NULL; + struct bt_notification_iterator_private_connection *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; - static const enum bt_notification_type all_notif_types[] = { - BT_NOTIFICATION_TYPE_ALL, - BT_NOTIFICATION_TYPE_SENTINEL, - }; + enum bt_connection_status status; if (!private_connection) { - goto error; + BT_LOGW_STR("Invalid parameter: private connection is NULL."); + status = BT_CONNECTION_STATUS_INVALID; + goto end; + } + + if (!user_iterator) { + BT_LOGW_STR("Invalid parameter: notification iterator pointer is NULL."); + status = BT_CONNECTION_STATUS_INVALID; + goto end; } - if (!notification_types) { - notification_types = all_notif_types; + connection = bt_connection_borrow_from_private(private_connection); + + if (bt_graph_is_canceled(bt_connection_borrow_graph(connection))) { + BT_LOGW("Cannot create notification iterator from connection: " + "connection's graph is canceled: " + "conn-addr=%p, upstream-port-addr=%p, " + "upstream-port-name=\"%s\", upstream-comp-addr=%p, " + "upstream-comp-name=\"%s\", graph-addr=%p", + connection, connection->upstream_port, + bt_port_get_name(connection->upstream_port), + upstream_component, + bt_component_get_name(upstream_component), + bt_connection_borrow_graph(connection)); + status = BT_CONNECTION_STATUS_GRAPH_IS_CANCELED; + goto end; } - connection = bt_connection_from_private(private_connection); - if (!connection->upstream_port || !connection->downstream_port) { - goto error; + if (bt_connection_is_ended(connection)) { + BT_LOGW("Invalid parameter: connection is ended: " + "conn-addr=%p", connection); + status = BT_CONNECTION_STATUS_IS_ENDED; + goto end; } upstream_port = connection->upstream_port; - assert(upstream_port); + BT_ASSERT(upstream_port); upstream_component = bt_port_get_component(upstream_port); - assert(upstream_component); + BT_ASSERT(upstream_component); upstream_comp_class = upstream_component->class; - - if (!upstream_component) { - goto error; - } - + BT_LOGD("Creating notification iterator from connection: " + "conn-addr=%p, upstream-port-addr=%p, " + "upstream-port-name=\"%s\", upstream-comp-addr=%p, " + "upstream-comp-name=\"%s\"", + connection, connection->upstream_port, + bt_port_get_name(connection->upstream_port), + upstream_component, bt_component_get_name(upstream_component)); 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, - upstream_port, notification_types, connection); - if (!iterator) { - goto error; + BT_ASSERT(upstream_comp_class_type == BT_COMPONENT_CLASS_TYPE_SOURCE || + upstream_comp_class_type == BT_COMPONENT_CLASS_TYPE_FILTER); + status = bt_private_connection_notification_iterator_create(upstream_component, + upstream_port, connection, &iterator); + if (status != BT_CONNECTION_STATUS_OK) { + BT_LOGW("Cannot create notification iterator from connection."); + goto end; } switch (upstream_comp_class_type) { @@ -249,37 +363,61 @@ bt_private_connection_create_notification_iterator( } default: /* Unreachable. */ - assert(0); + BT_LOGF("Unknown component class type: type=%d", + upstream_comp_class_type); + abort(); } if (init_method) { - enum bt_notification_iterator_status status = init_method( - bt_private_notification_iterator_from_notification_iterator(iterator), + enum bt_notification_iterator_status iter_status; + + BT_LOGD("Calling user's initialization method: iter-addr=%p", + iterator); + iter_status = init_method( + bt_private_connection_private_notification_iterator_from_notification_iterator((void *) iterator), bt_private_port_from_port(upstream_port)); - if (status < 0) { - goto error; + BT_LOGD("User method returned: status=%s", + bt_notification_iterator_status_string(iter_status)); + if (iter_status != BT_NOTIFICATION_ITERATOR_STATUS_OK) { + BT_LOGW_STR("Initialization method failed."); + status = bt_connection_status_from_notification_iterator_status( + iter_status); + goto end; } } - ret_iterator = bt_notification_iterator_validate(iterator); - if (ret_iterator != BT_NOTIFICATION_ITERATOR_STATUS_OK) { - goto error; - } - + iterator->state = BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_ACTIVE; g_ptr_array_add(connection->iterators, iterator); - goto end; - -error: - BT_PUT(iterator); + BT_LOGD("Created notification iterator from connection: " + "conn-addr=%p, upstream-port-addr=%p, " + "upstream-port-name=\"%s\", upstream-comp-addr=%p, " + "upstream-comp-name=\"%s\", iter-addr=%p", + connection, connection->upstream_port, + bt_port_get_name(connection->upstream_port), + upstream_component, bt_component_get_name(upstream_component), + iterator); + + /* Move reference to user */ + *user_iterator = (void *) iterator; + iterator = NULL; end: bt_put(upstream_component); - return iterator; + bt_put(iterator); + return status; } BT_HIDDEN void bt_connection_remove_iterator(struct bt_connection *conn, - struct bt_notification_iterator *iterator) + struct bt_notification_iterator_private_connection *iterator) { g_ptr_array_remove(conn->iterators, iterator); + BT_LOGV("Removed notification iterator from connection: " + "conn-addr=%p, iter-addr=%p", conn, iterator); + bt_connection_try_remove_from_graph(conn); +} + +bt_bool bt_connection_is_ended(struct bt_connection *connection) +{ + return !connection->downstream_port && !connection->upstream_port; }