X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Flib%2Fgraph%2Fgraph.c;h=f40c61047078efdc8abcf4ad573dd44bc4e7cd6a;hb=d5b13b9b6a434797f856547be1ca6a59f70ba530;hp=62175cf98b8413eb59be2dd3b5399ac983ce0595;hpb=f6f301d78f17061caca68a882f25bff0a53d00b3;p=babeltrace.git diff --git a/src/lib/graph/graph.c b/src/lib/graph/graph.c index 62175cf9..f40c6104 100644 --- a/src/lib/graph/graph.c +++ b/src/lib/graph/graph.c @@ -1,100 +1,54 @@ /* + * SPDX-License-Identifier: MIT + * * Copyright 2017-2018 Philippe Proulx * Copyright 2017 Jérémie Galarneau - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. */ #define BT_LOG_TAG "LIB/GRAPH" #include "lib/logging.h" #include "common/assert.h" -#include "lib/assert-pre.h" -#include "lib/assert-post.h" +#include "lib/assert-cond.h" #include -#include -#include -#include -#include +#include +#include #include "lib/graph/message/message.h" #include "compat/compiler.h" #include "common/common.h" #include #include -#include #include "lib/value.h" #include +#include #include +#include "component-class-sink-simple.h" #include "component.h" #include "component-sink.h" #include "connection.h" #include "graph.h" +#include "interrupter.h" #include "message/event.h" #include "message/packet.h" -typedef enum bt_graph_listener_status (*port_added_func_t)( - const void *, const void *, void *); +typedef enum bt_graph_listener_func_status +(*port_added_func_t)(const void *, const void *, void *); -typedef enum bt_graph_listener_status (*ports_connected_func_t)( - const void *, const void *, const void *, const void *, void *); - -typedef enum bt_self_component_status (*comp_init_method_t)(const void *, - const void *, void *); - -struct bt_graph_listener { - bt_graph_listener_removed_func removed; - void *data; -}; +typedef enum bt_component_class_initialize_method_status +(*comp_init_method_t)(const void *, void *, const void *, void *); struct bt_graph_listener_port_added { - struct bt_graph_listener base; port_added_func_t func; -}; - -struct bt_graph_listener_ports_connected { - struct bt_graph_listener base; - ports_connected_func_t func; + void *data; }; #define INIT_LISTENERS_ARRAY(_type, _listeners) \ do { \ _listeners = g_array_new(FALSE, TRUE, sizeof(_type)); \ if (!(_listeners)) { \ - BT_LOGE_STR("Failed to allocate one GArray."); \ - } \ - } while (0) - -#define CALL_REMOVE_LISTENERS(_type, _listeners) \ - do { \ - size_t i; \ - \ - if (!_listeners) { \ - break; \ - } \ - for (i = 0; i < (_listeners)->len; i++) { \ - _type *listener = \ - &g_array_index((_listeners), _type, i); \ - \ - if (listener->base.removed) { \ - listener->base.removed(listener->base.data); \ - } \ + BT_LIB_LOGE_APPEND_CAUSE( \ + "Failed to allocate one GArray."); \ } \ } while (0) @@ -131,30 +85,7 @@ void destroy_graph(struct bt_object *obj) */ BT_LIB_LOGI("Destroying graph: %!+g", graph); obj->ref_count++; - - /* - * Cancel the graph to disallow some operations, like creating - * message iterators and adding ports to components. - */ - (void) bt_graph_cancel((void *) graph); - - /* Call all remove listeners */ - CALL_REMOVE_LISTENERS(struct bt_graph_listener_port_added, - graph->listeners.source_output_port_added); - CALL_REMOVE_LISTENERS(struct bt_graph_listener_port_added, - graph->listeners.filter_output_port_added); - CALL_REMOVE_LISTENERS(struct bt_graph_listener_port_added, - graph->listeners.filter_input_port_added); - CALL_REMOVE_LISTENERS(struct bt_graph_listener_port_added, - graph->listeners.sink_input_port_added); - CALL_REMOVE_LISTENERS(struct bt_graph_listener_ports_connected, - graph->listeners.source_filter_ports_connected); - CALL_REMOVE_LISTENERS(struct bt_graph_listener_ports_connected, - graph->listeners.filter_filter_ports_connected); - CALL_REMOVE_LISTENERS(struct bt_graph_listener_ports_connected, - graph->listeners.source_sink_ports_connected); - CALL_REMOVE_LISTENERS(struct bt_graph_listener_ports_connected, - graph->listeners.filter_sink_ports_connected); + graph->config_state = BT_GRAPH_CONFIGURATION_STATE_DESTROYING; if (graph->messages) { g_ptr_array_free(graph->messages, TRUE); @@ -173,6 +104,14 @@ void destroy_graph(struct bt_object *obj) graph->components = NULL; } + if (graph->interrupters) { + BT_LOGD_STR("Putting interrupters."); + g_ptr_array_free(graph->interrupters, TRUE); + graph->interrupters = NULL; + } + + BT_OBJECT_PUT_REF_AND_RESET(graph->default_interrupter); + if (graph->sinks_to_consume) { g_queue_free(graph->sinks_to_consume); graph->sinks_to_consume = NULL; @@ -198,30 +137,6 @@ void destroy_graph(struct bt_object *obj) graph->listeners.sink_input_port_added = NULL; } - if (graph->listeners.source_filter_ports_connected) { - g_array_free(graph->listeners.source_filter_ports_connected, - TRUE); - graph->listeners.source_filter_ports_connected = NULL; - } - - if (graph->listeners.filter_filter_ports_connected) { - g_array_free(graph->listeners.filter_filter_ports_connected, - TRUE); - graph->listeners.filter_filter_ports_connected = NULL; - } - - if (graph->listeners.source_sink_ports_connected) { - g_array_free(graph->listeners.source_sink_ports_connected, - TRUE); - graph->listeners.source_sink_ports_connected = NULL; - } - - if (graph->listeners.filter_sink_ports_connected) { - g_array_free(graph->listeners.filter_sink_ports_connected, - TRUE); - graph->listeners.filter_sink_ports_connected = NULL; - } - bt_object_pool_finalize(&graph->event_msg_pool); bt_object_pool_finalize(&graph->packet_begin_msg_pool); bt_object_pool_finalize(&graph->packet_end_msg_pool); @@ -255,34 +170,40 @@ void notify_message_graph_is_destroyed(struct bt_message *msg) bt_message_unlink_graph(msg); } -struct bt_graph *bt_graph_create(void) +struct bt_graph *bt_graph_create(uint64_t mip_version) { struct bt_graph *graph; int ret; + BT_ASSERT_PRE_NO_ERROR(); + BT_ASSERT_PRE(mip_version <= bt_get_maximal_mip_version(), + "Unknown MIP version: mip-version=%" PRIu64 ", " + "max-mip-version=%" PRIu64, + mip_version, bt_get_maximal_mip_version()); BT_LOGI_STR("Creating graph object."); graph = g_new0(struct bt_graph, 1); if (!graph) { - BT_LOGE_STR("Failed to allocate one graph."); + BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one graph."); goto end; } bt_object_init_shared(&graph->base, destroy_graph); + graph->mip_version = mip_version; graph->connections = g_ptr_array_new_with_free_func( (GDestroyNotify) bt_object_try_spec_release); if (!graph->connections) { - BT_LOGE_STR("Failed to allocate one GPtrArray."); + BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one GPtrArray."); goto error; } graph->components = g_ptr_array_new_with_free_func( (GDestroyNotify) bt_object_try_spec_release); if (!graph->components) { - BT_LOGE_STR("Failed to allocate one GPtrArray."); + BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one GPtrArray."); goto error; } graph->sinks_to_consume = g_queue_new(); if (!graph->sinks_to_consume) { - BT_LOGE_STR("Failed to allocate one GQueue."); + BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one GQueue."); goto error; } @@ -291,7 +212,6 @@ struct bt_graph *bt_graph_create(void) graph->listeners.source_output_port_added); if (!graph->listeners.source_output_port_added) { - ret = -1; goto error; } @@ -299,7 +219,6 @@ struct bt_graph *bt_graph_create(void) graph->listeners.filter_output_port_added); if (!graph->listeners.filter_output_port_added) { - ret = -1; goto error; } @@ -307,7 +226,6 @@ struct bt_graph *bt_graph_create(void) graph->listeners.filter_input_port_added); if (!graph->listeners.filter_input_port_added) { - ret = -1; goto error; } @@ -315,48 +233,31 @@ struct bt_graph *bt_graph_create(void) graph->listeners.sink_input_port_added); if (!graph->listeners.sink_input_port_added) { - ret = -1; goto error; } - INIT_LISTENERS_ARRAY(struct bt_graph_listener_ports_connected, - graph->listeners.source_filter_ports_connected); - - if (!graph->listeners.source_filter_ports_connected) { - ret = -1; + graph->interrupters = g_ptr_array_new_with_free_func( + (GDestroyNotify) bt_object_put_ref_no_null_check); + if (!graph->interrupters) { + BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one GPtrArray."); goto error; } - INIT_LISTENERS_ARRAY(struct bt_graph_listener_ports_connected, - graph->listeners.source_sink_ports_connected); - - if (!graph->listeners.source_sink_ports_connected) { - ret = -1; - goto error; - } - - INIT_LISTENERS_ARRAY(struct bt_graph_listener_ports_connected, - graph->listeners.filter_filter_ports_connected); - - if (!graph->listeners.filter_filter_ports_connected) { - ret = -1; - goto error; - } - - INIT_LISTENERS_ARRAY(struct bt_graph_listener_ports_connected, - graph->listeners.filter_sink_ports_connected); - - if (!graph->listeners.filter_sink_ports_connected) { - ret = -1; + graph->default_interrupter = bt_interrupter_create(); + if (!graph->default_interrupter) { + BT_LIB_LOGE_APPEND_CAUSE( + "Failed to create one interrupter object."); goto error; } + bt_graph_add_interrupter(graph, graph->default_interrupter); ret = bt_object_pool_initialize(&graph->event_msg_pool, (bt_object_pool_new_object_func) bt_message_event_new, (bt_object_pool_destroy_object_func) destroy_message_event, graph); if (ret) { - BT_LOGE("Failed to initialize event message pool: ret=%d", + BT_LIB_LOGE_APPEND_CAUSE( + "Failed to initialize event message pool: ret=%d", ret); goto error; } @@ -366,7 +267,8 @@ struct bt_graph *bt_graph_create(void) (bt_object_pool_destroy_object_func) destroy_message_packet_begin, graph); if (ret) { - BT_LOGE("Failed to initialize packet beginning message pool: ret=%d", + BT_LIB_LOGE_APPEND_CAUSE( + "Failed to initialize packet beginning message pool: ret=%d", ret); goto error; } @@ -376,7 +278,8 @@ struct bt_graph *bt_graph_create(void) (bt_object_pool_destroy_object_func) destroy_message_packet_end, graph); if (ret) { - BT_LOGE("Failed to initialize packet end message pool: ret=%d", + BT_LIB_LOGE_APPEND_CAUSE( + "Failed to initialize packet end message pool: ret=%d", ret); goto error; } @@ -393,26 +296,25 @@ error: goto end; } -enum bt_graph_status bt_graph_connect_ports( +enum bt_graph_connect_ports_status bt_graph_connect_ports( struct bt_graph *graph, const struct bt_port_output *upstream_port_out, const struct bt_port_input *downstream_port_in, const struct bt_connection **user_connection) { - enum bt_graph_status status = BT_GRAPH_STATUS_OK; - enum bt_graph_listener_status listener_status; + enum bt_graph_connect_ports_status status = BT_FUNC_STATUS_OK; struct bt_connection *connection = NULL; struct bt_port *upstream_port = (void *) upstream_port_out; struct bt_port *downstream_port = (void *) downstream_port_in; struct bt_component *upstream_component = NULL; struct bt_component *downstream_component = NULL; - enum bt_self_component_status component_status; + enum bt_component_class_port_connected_method_status port_connected_status; bool init_can_consume; - BT_ASSERT_PRE_NON_NULL(graph, "Graph"); + BT_ASSERT_PRE_NO_ERROR(); + BT_ASSERT_PRE_GRAPH_NON_NULL(graph); BT_ASSERT_PRE_NON_NULL(upstream_port, "Upstream port"); BT_ASSERT_PRE_NON_NULL(downstream_port, "Downstream port port"); - BT_ASSERT_PRE(!graph->canceled, "Graph is canceled: %!+g", graph); BT_ASSERT_PRE( graph->config_state == BT_GRAPH_CONFIGURATION_STATE_CONFIGURING, "Graph is not in the \"configuring\" state: %!+g", graph); @@ -440,8 +342,8 @@ enum bt_graph_status bt_graph_connect_ports( connection = bt_connection_create(graph, (void *) upstream_port, (void *) downstream_port); if (!connection) { - BT_LOGW("Cannot create connection object."); - status = BT_GRAPH_STATUS_NOMEM; + BT_LIB_LOGE_APPEND_CAUSE("Cannot create connection object."); + status = BT_FUNC_STATUS_MEMORY_ERROR; goto end; } @@ -458,17 +360,22 @@ enum bt_graph_status bt_graph_connect_ports( */ BT_LIB_LOGD("Notifying upstream component that its port is connected: " "%![comp-]+c, %![port-]+p", upstream_component, upstream_port); - component_status = bt_component_port_connected(upstream_component, + port_connected_status = bt_component_port_connected(upstream_component, (void *) upstream_port, (void *) downstream_port); - if (component_status != BT_SELF_COMPONENT_STATUS_OK) { - BT_LIB_LOGW("Error while notifying upstream component that its port is connected: " - "status=%s, %![graph-]+g, %![up-comp-]+c, " - "%![down-comp-]+c, %![up-port-]+p, %![down-port-]+p", - bt_self_component_status_string(component_status), - graph, upstream_component, downstream_component, - upstream_port, downstream_port); + if (port_connected_status != BT_FUNC_STATUS_OK) { + if (port_connected_status < 0) { + BT_LIB_LOGW_APPEND_CAUSE( + "Upstream component's \"port connected\" method failed: " + "status=%s, %![graph-]+g, %![up-comp-]+c, " + "%![down-comp-]+c, %![up-port-]+p, %![down-port-]+p", + bt_common_func_status_string( + port_connected_status), + graph, upstream_component, downstream_component, + upstream_port, downstream_port); + } + bt_connection_end(connection, true); - status = (int) component_status; + status = (int) port_connected_status; goto end; } @@ -476,33 +383,27 @@ enum bt_graph_status bt_graph_connect_ports( BT_LIB_LOGD("Notifying downstream component that its port is connected: " "%![comp-]+c, %![port-]+p", downstream_component, downstream_port); - component_status = bt_component_port_connected(downstream_component, + port_connected_status = bt_component_port_connected(downstream_component, (void *) downstream_port, (void *) upstream_port); - if (component_status != BT_SELF_COMPONENT_STATUS_OK) { - BT_LIB_LOGW("Error while notifying downstream component that its port is connected: " - "status=%s, %![graph-]+g, %![up-comp-]+c, " - "%![down-comp-]+c, %![up-port-]+p, %![down-port-]+p", - bt_self_component_status_string(component_status), - graph, upstream_component, downstream_component, - upstream_port, downstream_port); + if (port_connected_status != BT_FUNC_STATUS_OK) { + if (port_connected_status < 0) { + BT_LIB_LOGW_APPEND_CAUSE( + "Downstream component's \"port connected\" method failed: " + "status=%s, %![graph-]+g, %![up-comp-]+c, " + "%![down-comp-]+c, %![up-port-]+p, %![down-port-]+p", + bt_common_func_status_string( + port_connected_status), + graph, upstream_component, downstream_component, + upstream_port, downstream_port); + } + bt_connection_end(connection, true); - status = (int) component_status; + status = (int) port_connected_status; goto end; } connection->notified_downstream_port_connected = true; - /* - * Notify the graph's creator that both ports are connected. - */ - BT_LOGD_STR("Notifying graph's user that new component ports are connected."); - listener_status = bt_graph_notify_ports_connected(graph, upstream_port, downstream_port); - if (listener_status != BT_GRAPH_LISTENER_STATUS_OK) { - status = (int) listener_status; - goto end; - } - - connection->notified_graph_ports_connected = true; BT_LIB_LOGI("Connected component ports within graph: " "%![graph-]+g, %![up-comp-]+c, %![down-comp-]+c, " "%![up-port-]+p, %![down-port-]+p", @@ -512,11 +413,10 @@ enum bt_graph_status bt_graph_connect_ports( if (user_connection) { /* Move reference to user */ *user_connection = connection; - connection = NULL; } end: - if (status != BT_GRAPH_STATUS_OK) { + if (status != BT_FUNC_STATUS_OK) { bt_graph_make_faulty(graph); } @@ -527,35 +427,43 @@ end: } static inline -enum bt_graph_status consume_graph_sink(struct bt_component_sink *comp) +int consume_graph_sink(struct bt_component_sink *comp) { - enum bt_self_component_status comp_status; + enum bt_component_class_sink_consume_method_status consume_status; struct bt_component_class_sink *sink_class = NULL; - BT_ASSERT(comp); + BT_ASSERT_DBG(comp); sink_class = (void *) comp->parent.class; - BT_ASSERT(sink_class->methods.consume); + BT_ASSERT_DBG(sink_class->methods.consume); BT_LIB_LOGD("Calling user's consume method: %!+c", comp); - comp_status = sink_class->methods.consume((void *) comp); + consume_status = sink_class->methods.consume((void *) comp); BT_LOGD("User method returned: status=%s", - bt_self_component_status_string(comp_status)); - BT_ASSERT_POST(comp_status == BT_SELF_COMPONENT_STATUS_OK || - comp_status == BT_SELF_COMPONENT_STATUS_END || - comp_status == BT_SELF_COMPONENT_STATUS_AGAIN || - comp_status == BT_SELF_COMPONENT_STATUS_ERROR || - comp_status == BT_SELF_COMPONENT_STATUS_NOMEM, + bt_common_func_status_string(consume_status)); + BT_ASSERT_POST_DEV(consume_status == BT_FUNC_STATUS_OK || + consume_status == BT_FUNC_STATUS_END || + consume_status == BT_FUNC_STATUS_AGAIN || + consume_status == BT_FUNC_STATUS_ERROR || + consume_status == BT_FUNC_STATUS_MEMORY_ERROR, "Invalid component status returned by consuming method: " - "status=%s", bt_self_component_status_string(comp_status)); - if (comp_status < 0) { - BT_LOGW_STR("Consume method failed."); + "status=%s", bt_common_func_status_string(consume_status)); + BT_ASSERT_POST_DEV_NO_ERROR_IF_NO_ERROR_STATUS(consume_status); + if (consume_status) { + if (consume_status < 0) { + BT_LIB_LOGW_APPEND_CAUSE( + "Component's \"consume\" method failed: " + "status=%s, %![comp-]+c", + bt_common_func_status_string(consume_status), + comp); + } + goto end; } BT_LIB_LOGD("Consumed from sink: %![comp-]+c, status=%s", - comp, bt_self_component_status_string(comp_status)); + comp, bt_common_func_status_string(consume_status)); end: - return (int) comp_status; + return consume_status; } /* @@ -564,14 +472,14 @@ end: * still something to consume afterwards. */ static inline -enum bt_graph_status consume_sink_node(struct bt_graph *graph, GList *node) +int consume_sink_node(struct bt_graph *graph, GList *node) { - enum bt_graph_status status; + int status; struct bt_component_sink *sink; sink = node->data; status = consume_graph_sink(sink); - if (G_UNLIKELY(status != BT_GRAPH_STATUS_END)) { + if (G_UNLIKELY(status != BT_FUNC_STATUS_END)) { g_queue_push_tail_link(graph->sinks_to_consume, node); goto end; } @@ -581,30 +489,30 @@ enum bt_graph_status consume_sink_node(struct bt_graph *graph, GList *node) /* Don't forward an END status if there are sinks left to consume. */ if (!g_queue_is_empty(graph->sinks_to_consume)) { - status = BT_GRAPH_STATUS_OK; + status = BT_FUNC_STATUS_OK; goto end; } end: BT_LIB_LOGD("Consumed sink node: %![comp-]+c, status=%s", - sink, bt_graph_status_string(status)); + sink, bt_common_func_status_string(status)); return status; } BT_HIDDEN -enum bt_graph_status bt_graph_consume_sink_no_check(struct bt_graph *graph, +int bt_graph_consume_sink_no_check(struct bt_graph *graph, struct bt_component_sink *sink) { - enum bt_graph_status status; + int status; GList *sink_node; int index; BT_LIB_LOGD("Making specific sink consume: %![comp-]+c", sink); - BT_ASSERT(bt_component_borrow_graph((void *) sink) == graph); + BT_ASSERT_DBG(bt_component_borrow_graph((void *) sink) == graph); if (g_queue_is_empty(graph->sinks_to_consume)) { BT_LOGD_STR("Graph's sink queue is empty: end of graph."); - status = BT_GRAPH_STATUS_END; + status = BT_FUNC_STATUS_END; goto end; } @@ -612,12 +520,12 @@ enum bt_graph_status bt_graph_consume_sink_no_check(struct bt_graph *graph, if (index < 0) { BT_LIB_LOGD("Sink component is not marked as consumable: " "component sink is ended: %![comp-]+c", sink); - status = BT_GRAPH_STATUS_END; + status = BT_FUNC_STATUS_END; goto end; } sink_node = g_queue_pop_nth_link(graph->sinks_to_consume, index); - BT_ASSERT(sink_node); + BT_ASSERT_DBG(sink_node); status = consume_sink_node(graph, sink_node); end: @@ -625,19 +533,19 @@ end: } static inline -enum bt_graph_status consume_no_check(struct bt_graph *graph) +int consume_no_check(struct bt_graph *graph) { - enum bt_graph_status status = BT_GRAPH_STATUS_OK; + int status = BT_FUNC_STATUS_OK; struct bt_component *sink; GList *current_node; - BT_ASSERT_PRE(graph->has_sink, + BT_ASSERT_PRE_DEV(graph->has_sink, "Graph has no sink component: %!+g", graph); BT_LIB_LOGD("Making next sink component consume: %![graph-]+g", graph); if (G_UNLIKELY(g_queue_is_empty(graph->sinks_to_consume))) { BT_LOGD_STR("Graph's sink queue is empty: end of graph."); - status = BT_GRAPH_STATUS_END; + status = BT_FUNC_STATUS_END; goto end; } @@ -650,20 +558,92 @@ end: return status; } -enum bt_graph_status bt_graph_consume(struct bt_graph *graph) +static +int configure_graph(struct bt_graph *graph) +{ + int status = BT_FUNC_STATUS_OK; + uint64_t i; + + BT_ASSERT_DBG(graph->config_state != + BT_GRAPH_CONFIGURATION_STATE_FAULTY); + + if (G_LIKELY(graph->config_state == + BT_GRAPH_CONFIGURATION_STATE_CONFIGURED)) { + goto end; + } + + BT_ASSERT_PRE(graph->has_sink, "Graph has no sink component: %!+g", graph); + graph->config_state = BT_GRAPH_CONFIGURATION_STATE_PARTIALLY_CONFIGURED; + + for (i = 0; i < graph->components->len; i++) { + struct bt_component *comp = graph->components->pdata[i]; + struct bt_component_sink *comp_sink = (void *) comp; + struct bt_component_class_sink *comp_cls_sink = + (void *) comp->class; + + if (comp->class->type != BT_COMPONENT_CLASS_TYPE_SINK) { + continue; + } + + if (comp_sink->graph_is_configured_method_called) { + continue; + } + + if (comp_cls_sink->methods.graph_is_configured) { + enum bt_component_class_sink_graph_is_configured_method_status comp_status; + + BT_LIB_LOGD("Calling user's \"graph is configured\" method: " + "%![graph-]+g, %![comp-]+c", + graph, comp); + comp_status = comp_cls_sink->methods.graph_is_configured( + (void *) comp_sink); + BT_LIB_LOGD("User method returned: status=%s", + bt_common_func_status_string(comp_status)); + BT_ASSERT_POST(comp_status == BT_FUNC_STATUS_OK || + comp_status == BT_FUNC_STATUS_ERROR || + comp_status == BT_FUNC_STATUS_MEMORY_ERROR, + "Unexpected returned status: status=%s", + bt_common_func_status_string(comp_status)); + BT_ASSERT_POST_NO_ERROR_IF_NO_ERROR_STATUS(comp_status); + if (comp_status != BT_FUNC_STATUS_OK) { + if (comp_status < 0) { + BT_LIB_LOGW_APPEND_CAUSE( + "Component's \"graph is configured\" method failed: " + "%![comp-]+c, status=%s", + comp, + bt_common_func_status_string( + comp_status)); + } + + status = comp_status; + goto end; + } + } + + comp_sink->graph_is_configured_method_called = true; + } + + graph->config_state = BT_GRAPH_CONFIGURATION_STATE_CONFIGURED; + +end: + return status; +} + +enum bt_graph_run_once_status bt_graph_run_once(struct bt_graph *graph) { - enum bt_graph_status status; + enum bt_graph_run_once_status status; - BT_ASSERT_PRE_NON_NULL(graph, "Graph"); - BT_ASSERT_PRE(!graph->canceled, "Graph is canceled: %!+g", graph); - BT_ASSERT_PRE(graph->can_consume, + BT_ASSERT_PRE_NO_ERROR(); + BT_ASSERT_PRE_DEV_GRAPH_NON_NULL(graph); + BT_ASSERT_PRE_DEV(graph->can_consume, "Cannot consume graph in its current state: %!+g", graph); - BT_ASSERT_PRE(graph->config_state != BT_GRAPH_CONFIGURATION_STATE_FAULTY, + BT_ASSERT_PRE_DEV(graph->config_state != + BT_GRAPH_CONFIGURATION_STATE_FAULTY, "Graph is in a faulty state: %!+g", graph); bt_graph_set_can_consume(graph, false); - status = bt_graph_configure(graph); + status = configure_graph(graph); if (G_UNLIKELY(status)) { - /* bt_graph_configure() logs errors */ + /* configure_graph() logs errors */ goto end; } @@ -674,20 +654,20 @@ end: return status; } -enum bt_graph_status bt_graph_run(struct bt_graph *graph) +enum bt_graph_run_status bt_graph_run(struct bt_graph *graph) { - enum bt_graph_status status; + enum bt_graph_run_status status; - BT_ASSERT_PRE_NON_NULL(graph, "Graph"); - BT_ASSERT_PRE(!graph->canceled, "Graph is canceled: %!+g", graph); + BT_ASSERT_PRE_NO_ERROR(); + BT_ASSERT_PRE_GRAPH_NON_NULL(graph); BT_ASSERT_PRE(graph->can_consume, "Cannot consume graph in its current state: %!+g", graph); BT_ASSERT_PRE(graph->config_state != BT_GRAPH_CONFIGURATION_STATE_FAULTY, "Graph is in a faulty state: %!+g", graph); bt_graph_set_can_consume(graph, false); - status = bt_graph_configure(graph); + status = configure_graph(graph); if (G_UNLIKELY(status)) { - /* bt_graph_configure() logs errors */ + /* configure_graph() logs errors */ goto end; } @@ -695,20 +675,20 @@ enum bt_graph_status bt_graph_run(struct bt_graph *graph) do { /* - * Check if the graph is canceled at each iteration. If - * the graph was canceled by another thread or by a - * signal handler, this is not a warning nor an error, - * it was intentional: log with a DEBUG level only. + * Check if the graph is interrupted at each iteration. + * If the graph was interrupted by another thread or by + * a signal handler, this is NOT a warning nor an error; + * it was intentional: log with an INFO level only. */ - if (G_UNLIKELY(graph->canceled)) { - BT_LIB_LOGI("Stopping the graph: graph is canceled: " - "%!+g", graph); - status = BT_GRAPH_STATUS_CANCELED; + if (G_UNLIKELY(bt_graph_is_interrupted(graph))) { + BT_LIB_LOGI("Stopping the graph: " + "graph was interrupted: %!+g", graph); + status = BT_FUNC_STATUS_AGAIN; goto end; } status = consume_no_check(graph); - if (G_UNLIKELY(status == BT_GRAPH_STATUS_AGAIN)) { + if (G_UNLIKELY(status == BT_FUNC_STATUS_AGAIN)) { /* * If AGAIN is received and there are multiple * sinks, go ahead and consume from the next @@ -721,44 +701,44 @@ enum bt_graph_status bt_graph_run(struct bt_graph *graph) * sleep for an arbitrary amount of time. */ if (graph->sinks_to_consume->length > 1) { - status = BT_GRAPH_STATUS_OK; + status = BT_FUNC_STATUS_OK; } } - } while (status == BT_GRAPH_STATUS_OK); + } while (status == BT_FUNC_STATUS_OK); - if (g_queue_is_empty(graph->sinks_to_consume)) { - status = BT_GRAPH_STATUS_END; + if (status == BT_FUNC_STATUS_END) { + /* + * The last call to consume_no_check() returned + * `BT_FUNC_STATUS_END`, but bt_graph_run() has no + * `BT_GRAPH_RUN_STATUS_END` status: replace with + * `BT_GRAPH_RUN_STATUS_OK` (success: graph ran + * completely). + */ + status = BT_FUNC_STATUS_OK; } end: BT_LIB_LOGI("Graph ran: %![graph-]+g, status=%s", graph, - bt_graph_status_string(status)); + bt_common_func_status_string(status)); bt_graph_set_can_consume(graph, true); return status; } -enum bt_graph_status +enum bt_graph_add_listener_status bt_graph_add_source_component_output_port_added_listener( struct bt_graph *graph, bt_graph_source_component_output_port_added_listener_func func, - bt_graph_listener_removed_func listener_removed, void *data, - int *out_listener_id) + void *data, bt_listener_id *out_listener_id) { struct bt_graph_listener_port_added listener = { - .base = { - .removed = listener_removed, - .data = data, - }, .func = (port_added_func_t) func, + .data = data, }; - int listener_id; - - BT_ASSERT_PRE_NON_NULL(graph, "Graph"); - BT_ASSERT_PRE_NON_NULL(func, "Listener"); - BT_ASSERT_PRE_NON_NULL(func, "\"Listener removed\" listener"); - BT_ASSERT_PRE(!graph->in_remove_listener, - "Graph currently executing a \"listener removed\" listener: " - "%!+g", graph); + bt_listener_id listener_id; + + BT_ASSERT_PRE_NO_ERROR(); + BT_ASSERT_PRE_GRAPH_NON_NULL(graph); + BT_ASSERT_PRE_LISTENER_FUNC_NON_NULL(func); g_array_append_val(graph->listeners.source_output_port_added, listener); listener_id = graph->listeners.source_output_port_added->len - 1; BT_LIB_LOGD("Added \"source component output port added\" listener to graph: " @@ -769,31 +749,24 @@ bt_graph_add_source_component_output_port_added_listener( *out_listener_id = listener_id; } - return BT_GRAPH_STATUS_OK; + return BT_FUNC_STATUS_OK; } -enum bt_graph_status +enum bt_graph_add_listener_status bt_graph_add_filter_component_output_port_added_listener( struct bt_graph *graph, bt_graph_filter_component_output_port_added_listener_func func, - bt_graph_listener_removed_func listener_removed, void *data, - int *out_listener_id) + void *data, bt_listener_id *out_listener_id) { struct bt_graph_listener_port_added listener = { - .base = { - .removed = listener_removed, - .data = data, - }, .func = (port_added_func_t) func, + .data = data, }; - int listener_id; - - BT_ASSERT_PRE_NON_NULL(graph, "Graph"); - BT_ASSERT_PRE_NON_NULL(func, "Listener"); - BT_ASSERT_PRE_NON_NULL(func, "\"Listener removed\" listener"); - BT_ASSERT_PRE(!graph->in_remove_listener, - "Graph currently executing a \"listener removed\" listener: " - "%!+g", graph); + bt_listener_id listener_id; + + BT_ASSERT_PRE_NO_ERROR(); + BT_ASSERT_PRE_GRAPH_NON_NULL(graph); + BT_ASSERT_PRE_LISTENER_FUNC_NON_NULL(func); g_array_append_val(graph->listeners.filter_output_port_added, listener); listener_id = graph->listeners.filter_output_port_added->len - 1; BT_LIB_LOGD("Added \"filter component output port added\" listener to graph: " @@ -804,31 +777,24 @@ bt_graph_add_filter_component_output_port_added_listener( *out_listener_id = listener_id; } - return BT_GRAPH_STATUS_OK; + return BT_FUNC_STATUS_OK; } -enum bt_graph_status +enum bt_graph_add_listener_status bt_graph_add_filter_component_input_port_added_listener( struct bt_graph *graph, bt_graph_filter_component_input_port_added_listener_func func, - bt_graph_listener_removed_func listener_removed, void *data, - int *out_listener_id) + void *data, bt_listener_id *out_listener_id) { struct bt_graph_listener_port_added listener = { - .base = { - .removed = listener_removed, - .data = data, - }, .func = (port_added_func_t) func, + .data = data, }; - int listener_id; - - BT_ASSERT_PRE_NON_NULL(graph, "Graph"); - BT_ASSERT_PRE_NON_NULL(func, "Listener"); - BT_ASSERT_PRE_NON_NULL(func, "\"Listener removed\" listener"); - BT_ASSERT_PRE(!graph->in_remove_listener, - "Graph currently executing a \"listener removed\" listener: " - "%!+g", graph); + bt_listener_id listener_id; + + BT_ASSERT_PRE_NO_ERROR(); + BT_ASSERT_PRE_GRAPH_NON_NULL(graph); + BT_ASSERT_PRE_LISTENER_FUNC_NON_NULL(func); g_array_append_val(graph->listeners.filter_input_port_added, listener); listener_id = graph->listeners.filter_input_port_added->len - 1; BT_LIB_LOGD("Added \"filter component input port added\" listener to graph: " @@ -839,31 +805,24 @@ bt_graph_add_filter_component_input_port_added_listener( *out_listener_id = listener_id; } - return BT_GRAPH_STATUS_OK; + return BT_FUNC_STATUS_OK; } -enum bt_graph_status +enum bt_graph_add_listener_status bt_graph_add_sink_component_input_port_added_listener( struct bt_graph *graph, bt_graph_sink_component_input_port_added_listener_func func, - bt_graph_listener_removed_func listener_removed, void *data, - int *out_listener_id) + void *data, bt_listener_id *out_listener_id) { struct bt_graph_listener_port_added listener = { - .base = { - .removed = listener_removed, - .data = data, - }, .func = (port_added_func_t) func, + .data = data, }; - int listener_id; - - BT_ASSERT_PRE_NON_NULL(graph, "Graph"); - BT_ASSERT_PRE_NON_NULL(func, "Listener"); - BT_ASSERT_PRE_NON_NULL(func, "\"Listener removed\" listener"); - BT_ASSERT_PRE(!graph->in_remove_listener, - "Graph currently executing a \"listener removed\" listener: " - "%!+g", graph); + bt_listener_id listener_id; + + BT_ASSERT_PRE_NO_ERROR(); + BT_ASSERT_PRE_GRAPH_NON_NULL(graph); + BT_ASSERT_PRE_LISTENER_FUNC_NON_NULL(func); g_array_append_val(graph->listeners.sink_input_port_added, listener); listener_id = graph->listeners.sink_input_port_added->len - 1; BT_LIB_LOGD("Added \"sink component input port added\" listener to graph: " @@ -874,161 +833,17 @@ bt_graph_add_sink_component_input_port_added_listener( *out_listener_id = listener_id; } - return BT_GRAPH_STATUS_OK; -} - -enum bt_graph_status -bt_graph_add_source_filter_component_ports_connected_listener( - struct bt_graph *graph, - bt_graph_source_filter_component_ports_connected_listener_func func, - bt_graph_listener_removed_func listener_removed, void *data, - int *out_listener_id) -{ - struct bt_graph_listener_ports_connected listener = { - .base = { - .removed = listener_removed, - .data = data, - }, - .func = (ports_connected_func_t) func, - }; - int listener_id; - - BT_ASSERT_PRE_NON_NULL(graph, "Graph"); - BT_ASSERT_PRE_NON_NULL(func, "Listener"); - BT_ASSERT_PRE_NON_NULL(func, "\"Listener removed\" listener"); - BT_ASSERT_PRE(!graph->in_remove_listener, - "Graph currently executing a \"listener removed\" listener: " - "%!+g", graph); - g_array_append_val(graph->listeners.source_filter_ports_connected, - listener); - listener_id = graph->listeners.source_filter_ports_connected->len - 1; - BT_LIB_LOGD("Added \"source to filter component ports connected\" listener to graph: " - "%![graph-]+g, listener-addr=%p, id=%d", graph, listener, - listener_id); - - if (listener_id) { - *out_listener_id = listener_id; - } - - return BT_GRAPH_STATUS_OK; -} - -enum bt_graph_status -bt_graph_add_source_sink_component_ports_connected_listener( - struct bt_graph *graph, - bt_graph_source_sink_component_ports_connected_listener_func func, - bt_graph_listener_removed_func listener_removed, void *data, - int *out_listener_id) -{ - struct bt_graph_listener_ports_connected listener = { - .base = { - .removed = listener_removed, - .data = data, - }, - .func = (ports_connected_func_t) func, - }; - int listener_id; - - BT_ASSERT_PRE_NON_NULL(graph, "Graph"); - BT_ASSERT_PRE_NON_NULL(func, "Listener"); - BT_ASSERT_PRE_NON_NULL(func, "\"Listener removed\" listener"); - BT_ASSERT_PRE(!graph->in_remove_listener, - "Graph currently executing a \"listener removed\" listener: " - "%!+g", graph); - g_array_append_val(graph->listeners.source_sink_ports_connected, - listener); - listener_id = graph->listeners.source_sink_ports_connected->len - 1; - BT_LIB_LOGD("Added \"source to sink component ports connected\" listener to graph: " - "%![graph-]+g, listener-addr=%p, id=%d", graph, listener, - listener_id); - - if (listener_id) { - *out_listener_id = listener_id; - } - - return BT_GRAPH_STATUS_OK; -} - -enum bt_graph_status -bt_graph_add_filter_filter_component_ports_connected_listener( - struct bt_graph *graph, - bt_graph_filter_filter_component_ports_connected_listener_func func, - bt_graph_listener_removed_func listener_removed, void *data, - int *out_listener_id) -{ - struct bt_graph_listener_ports_connected listener = { - .base = { - .removed = listener_removed, - .data = data, - }, - .func = (ports_connected_func_t) func, - }; - int listener_id; - - BT_ASSERT_PRE_NON_NULL(graph, "Graph"); - BT_ASSERT_PRE_NON_NULL(func, "Listener"); - BT_ASSERT_PRE_NON_NULL(func, "\"Listener removed\" listener"); - BT_ASSERT_PRE(!graph->in_remove_listener, - "Graph currently executing a \"listener removed\" listener: " - "%!+g", graph); - g_array_append_val(graph->listeners.filter_filter_ports_connected, - listener); - listener_id = graph->listeners.filter_filter_ports_connected->len - 1; - BT_LIB_LOGD("Added \"filter to filter component ports connected\" listener to graph: " - "%![graph-]+g, listener-addr=%p, id=%d", graph, listener, - listener_id); - - if (listener_id) { - *out_listener_id = listener_id; - } - - return BT_GRAPH_STATUS_OK; -} - -enum bt_graph_status -bt_graph_add_filter_sink_component_ports_connected_listener( - struct bt_graph *graph, - bt_graph_filter_sink_component_ports_connected_listener_func func, - bt_graph_listener_removed_func listener_removed, void *data, - int *out_listener_id) -{ - struct bt_graph_listener_ports_connected listener = { - .base = { - .removed = listener_removed, - .data = data, - }, - .func = (ports_connected_func_t) func, - }; - int listener_id; - - BT_ASSERT_PRE_NON_NULL(graph, "Graph"); - BT_ASSERT_PRE_NON_NULL(func, "Listener"); - BT_ASSERT_PRE_NON_NULL(func, "\"Listener removed\" listener"); - BT_ASSERT_PRE(!graph->in_remove_listener, - "Graph currently executing a \"listener removed\" listener: " - "%!+g", graph); - g_array_append_val(graph->listeners.filter_sink_ports_connected, - listener); - listener_id = graph->listeners.filter_sink_ports_connected->len - 1; - BT_LIB_LOGD("Added \"filter to sink component ports connected\" listener to graph: " - "%![graph-]+g, listener-addr=%p, id=%d", graph, listener, - listener_id); - - if (listener_id) { - *out_listener_id = listener_id; - } - - return BT_GRAPH_STATUS_OK; + return BT_FUNC_STATUS_OK; } BT_HIDDEN -enum bt_graph_listener_status bt_graph_notify_port_added( +enum bt_graph_listener_func_status bt_graph_notify_port_added( struct bt_graph *graph, struct bt_port *port) { uint64_t i; GArray *listeners; struct bt_component *comp; - enum bt_graph_listener_status status = BT_GRAPH_LISTENER_STATUS_OK; + enum bt_graph_listener_func_status status = BT_FUNC_STATUS_OK; BT_ASSERT(graph); BT_ASSERT(port); @@ -1045,7 +860,7 @@ enum bt_graph_listener_status bt_graph_notify_port_added( listeners = graph->listeners.source_output_port_added; break; default: - abort(); + bt_common_abort(); } break; @@ -1060,7 +875,7 @@ enum bt_graph_listener_status bt_graph_notify_port_added( listeners = graph->listeners.filter_output_port_added; break; default: - abort(); + bt_common_abort(); } break; @@ -1072,13 +887,13 @@ enum bt_graph_listener_status bt_graph_notify_port_added( listeners = graph->listeners.sink_input_port_added; break; default: - abort(); + bt_common_abort(); } break; } default: - abort(); + bt_common_abort(); } for (i = 0; i < listeners->len; i++) { @@ -1088,86 +903,9 @@ enum bt_graph_listener_status bt_graph_notify_port_added( BT_ASSERT(listener->func); - status = listener->func(comp, port, listener->base.data); - if (status != BT_GRAPH_LISTENER_STATUS_OK) { - goto end; - } - } - -end: - return status; -} - -BT_HIDDEN -enum bt_graph_listener_status bt_graph_notify_ports_connected( - struct bt_graph *graph, struct bt_port *upstream_port, - struct bt_port *downstream_port) -{ - uint64_t i; - GArray *listeners; - struct bt_component *upstream_comp; - struct bt_component *downstream_comp; - enum bt_graph_listener_status status = BT_GRAPH_LISTENER_STATUS_OK; - - BT_ASSERT(graph); - BT_ASSERT(upstream_port); - BT_ASSERT(downstream_port); - BT_LIB_LOGD("Notifying graph listeners that ports were connected: " - "%![graph-]+g, %![up-port-]+p, %![down-port-]+p", - graph, upstream_port, downstream_port); - upstream_comp = bt_port_borrow_component_inline(upstream_port); - BT_ASSERT(upstream_comp); - downstream_comp = bt_port_borrow_component_inline(downstream_port); - BT_ASSERT(downstream_comp); - - switch (upstream_comp->class->type) { - case BT_COMPONENT_CLASS_TYPE_SOURCE: - { - switch (downstream_comp->class->type) { - case BT_COMPONENT_CLASS_TYPE_FILTER: - listeners = - graph->listeners.source_filter_ports_connected; - break; - case BT_COMPONENT_CLASS_TYPE_SINK: - listeners = - graph->listeners.source_sink_ports_connected; - break; - default: - abort(); - } - - break; - } - case BT_COMPONENT_CLASS_TYPE_FILTER: - { - switch (downstream_comp->class->type) { - case BT_COMPONENT_CLASS_TYPE_FILTER: - listeners = - graph->listeners.filter_filter_ports_connected; - break; - case BT_COMPONENT_CLASS_TYPE_SINK: - listeners = - graph->listeners.filter_sink_ports_connected; - break; - default: - abort(); - } - - break; - } - default: - abort(); - } - - for (i = 0; i < listeners->len; i++) { - struct bt_graph_listener_ports_connected *listener = - &g_array_index(listeners, - struct bt_graph_listener_ports_connected, i); - - BT_ASSERT(listener->func); - status = listener->func(upstream_comp, downstream_comp, - upstream_port, downstream_port, listener->base.data); - if (status != BT_GRAPH_LISTENER_STATUS_OK) { + status = listener->func(comp, port, listener->data); + BT_ASSERT_POST_NO_ERROR_IF_NO_ERROR_STATUS(status); + if (status != BT_FUNC_STATUS_OK) { goto end; } } @@ -1176,21 +914,6 @@ end: return status; } -enum bt_graph_status bt_graph_cancel(struct bt_graph *graph) -{ - - BT_ASSERT_PRE_NON_NULL(graph, "Graph"); - graph->canceled = true; - BT_LIB_LOGI("Canceled graph: %!+i", graph); - return BT_GRAPH_STATUS_OK; -} - -bt_bool bt_graph_is_canceled(const struct bt_graph *graph) -{ - BT_ASSERT_PRE_NON_NULL(graph, "Graph"); - return graph->canceled ? BT_TRUE : BT_FALSE; -} - BT_HIDDEN void bt_graph_remove_connection(struct bt_graph *graph, struct bt_connection *connection) @@ -1202,7 +925,6 @@ void bt_graph_remove_connection(struct bt_graph *graph, g_ptr_array_remove(graph->connections, connection); } -BT_ASSERT_PRE_FUNC static inline bool component_name_exists(struct bt_graph *graph, const char *name) { @@ -1213,7 +935,7 @@ bool component_name_exists(struct bt_graph *graph, const char *name) struct bt_component *other_comp = graph->components->pdata[i]; if (strcmp(name, bt_component_get_name(other_comp)) == 0) { - BT_ASSERT_PRE_MSG("Another component with the same name already exists in the graph: " + BT_ASSERT_COND_MSG("Another component with the same name already exists in the graph: " "%![other-comp-]+c, name=\"%s\"", other_comp, name); exists = true; @@ -1226,32 +948,30 @@ end: } static -enum bt_graph_status add_component_with_init_method_data( +int add_component_with_init_method_data( struct bt_graph *graph, struct bt_component_class *comp_cls, comp_init_method_t init_method, const char *name, const struct bt_value *params, void *init_method_data, bt_logging_level log_level, - struct bt_component **user_component) + const struct bt_component **user_component) { - enum bt_graph_status graph_status = BT_GRAPH_STATUS_OK; - enum bt_self_component_status comp_status; + int status = BT_FUNC_STATUS_OK; + enum bt_component_class_initialize_method_status init_status; struct bt_component *component = NULL; int ret; bool init_can_consume; struct bt_value *new_params = NULL; BT_ASSERT(comp_cls); - BT_ASSERT_PRE_NON_NULL(graph, "Graph"); - BT_ASSERT_PRE_NON_NULL(name, "Name"); - BT_ASSERT_PRE(!graph->canceled, "Graph is canceled: %!+g", graph); + BT_ASSERT_PRE_GRAPH_NON_NULL(graph); + BT_ASSERT_PRE_NAME_NON_NULL(name); BT_ASSERT_PRE( graph->config_state == BT_GRAPH_CONFIGURATION_STATE_CONFIGURING, "Graph is not in the \"configuring\" state: %!+g", graph); BT_ASSERT_PRE(!component_name_exists(graph, name), "Duplicate component name: %!+g, name=\"%s\"", graph, name); - BT_ASSERT_PRE(!params || bt_value_is_map(params), - "Parameter value is not a map value: %!+v", params); + BT_ASSERT_PRE_PARAM_VALUE_IS_MAP(params); init_can_consume = graph->can_consume; bt_graph_set_can_consume(graph, false); BT_LIB_LOGI("Adding component to graph: " @@ -1264,8 +984,9 @@ enum bt_graph_status add_component_with_init_method_data( if (!params) { new_params = bt_value_map_create(); if (!new_params) { - BT_LOGE_STR("Cannot create empty map value object."); - graph_status = BT_GRAPH_STATUS_NOMEM; + BT_LIB_LOGE_APPEND_CAUSE( + "Cannot create empty map value object."); + status = BT_FUNC_STATUS_MEMORY_ERROR; goto end; } @@ -1274,9 +995,10 @@ enum bt_graph_status add_component_with_init_method_data( ret = bt_component_create(comp_cls, name, log_level, &component); if (ret) { - BT_LOGE("Cannot create empty component object: ret=%d", + BT_LIB_LOGE_APPEND_CAUSE( + "Cannot create empty component object: ret=%d", ret); - graph_status = BT_GRAPH_STATUS_NOMEM; + status = BT_FUNC_STATUS_MEMORY_ERROR; goto end; } @@ -1290,13 +1012,25 @@ enum bt_graph_status add_component_with_init_method_data( bt_value_freeze(params); if (init_method) { + /* + * There is no use for config objects right now, so just pass + * NULL. + */ BT_LOGD_STR("Calling user's initialization method."); - comp_status = init_method(component, params, init_method_data); + init_status = init_method(component, NULL, params, init_method_data); BT_LOGD("User method returned: status=%s", - bt_self_component_status_string(comp_status)); - if (comp_status != BT_SELF_COMPONENT_STATUS_OK) { - BT_LOGW_STR("Initialization method failed."); - graph_status = (int) comp_status; + bt_common_func_status_string(init_status)); + BT_ASSERT_POST_DEV_NO_ERROR_IF_NO_ERROR_STATUS(init_status); + if (init_status != BT_FUNC_STATUS_OK) { + if (init_status < 0) { + BT_LIB_LOGW_APPEND_CAUSE( + "Component initialization method failed: " + "status=%s, %![comp-]+c", + bt_common_func_status_string(init_status), + component); + } + + status = init_status; bt_component_set_graph(component, NULL); g_ptr_array_remove_fast(graph->components, component); goto end; @@ -1311,7 +1045,8 @@ enum bt_graph_status add_component_with_init_method_data( /* * If it's a sink component, it needs to be part of the graph's - * sink queue to be consumed by bt_graph_consume(). + * sink queue to be consumed by bt_graph_run() or + * bt_graph_run_once(). */ if (bt_component_is_sink(component)) { graph->has_sink = true; @@ -1334,11 +1069,10 @@ enum bt_graph_status add_component_with_init_method_data( if (user_component) { /* Move reference to user */ *user_component = component; - component = NULL; } end: - if (graph_status != BT_GRAPH_STATUS_OK) { + if (status != BT_FUNC_STATUS_OK) { bt_graph_make_faulty(graph); } @@ -1346,157 +1080,128 @@ end: bt_object_put_ref(new_params); (void) init_can_consume; bt_graph_set_can_consume(graph, init_can_consume); - return graph_status; + return status; } -enum bt_graph_status -bt_graph_add_source_component_with_init_method_data( +enum bt_graph_add_component_status +bt_graph_add_source_component_with_initialize_method_data( struct bt_graph *graph, const struct bt_component_class_source *comp_cls, const char *name, const struct bt_value *params, void *init_method_data, bt_logging_level log_level, const struct bt_component_source **component) { - BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class"); + BT_ASSERT_PRE_NO_ERROR(); + BT_ASSERT_PRE_COMP_CLS_NON_NULL(comp_cls); return add_component_with_init_method_data(graph, (void *) comp_cls, (comp_init_method_t) comp_cls->methods.init, name, params, init_method_data, log_level, (void *) component); } -enum bt_graph_status bt_graph_add_source_component( +enum bt_graph_add_component_status bt_graph_add_source_component( struct bt_graph *graph, const struct bt_component_class_source *comp_cls, const char *name, const struct bt_value *params, - bt_logging_level log_level, + enum bt_logging_level log_level, const struct bt_component_source **component) { - return bt_graph_add_source_component_with_init_method_data( + BT_ASSERT_PRE_NO_ERROR(); + return bt_graph_add_source_component_with_initialize_method_data( graph, comp_cls, name, params, NULL, log_level, component); } -enum bt_graph_status -bt_graph_add_filter_component_with_init_method_data( +enum bt_graph_add_component_status +bt_graph_add_filter_component_with_initialize_method_data( struct bt_graph *graph, const struct bt_component_class_filter *comp_cls, const char *name, const struct bt_value *params, - void *init_method_data, bt_logging_level log_level, + void *init_method_data, enum bt_logging_level log_level, const struct bt_component_filter **component) { - BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class"); + BT_ASSERT_PRE_NO_ERROR(); + BT_ASSERT_PRE_COMP_CLS_NON_NULL(comp_cls); return add_component_with_init_method_data(graph, (void *) comp_cls, (comp_init_method_t) comp_cls->methods.init, name, params, init_method_data, log_level, (void *) component); } -enum bt_graph_status bt_graph_add_filter_component( +enum bt_graph_add_component_status bt_graph_add_filter_component( struct bt_graph *graph, const struct bt_component_class_filter *comp_cls, const char *name, const struct bt_value *params, - bt_logging_level log_level, + enum bt_logging_level log_level, const struct bt_component_filter **component) { - return bt_graph_add_filter_component_with_init_method_data( + BT_ASSERT_PRE_NO_ERROR(); + return bt_graph_add_filter_component_with_initialize_method_data( graph, comp_cls, name, params, NULL, log_level, component); } -enum bt_graph_status -bt_graph_add_sink_component_with_init_method_data( +enum bt_graph_add_component_status +bt_graph_add_sink_component_with_initialize_method_data( struct bt_graph *graph, const struct bt_component_class_sink *comp_cls, const char *name, const struct bt_value *params, - void *init_method_data, bt_logging_level log_level, + void *init_method_data, enum bt_logging_level log_level, const struct bt_component_sink **component) { - BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class"); + BT_ASSERT_PRE_NO_ERROR(); + BT_ASSERT_PRE_COMP_CLS_NON_NULL(comp_cls); return add_component_with_init_method_data(graph, (void *) comp_cls, (comp_init_method_t) comp_cls->methods.init, name, params, init_method_data, log_level, (void *) component); } -enum bt_graph_status bt_graph_add_sink_component( +enum bt_graph_add_component_status bt_graph_add_sink_component( struct bt_graph *graph, const struct bt_component_class_sink *comp_cls, const char *name, const struct bt_value *params, - bt_logging_level log_level, + enum bt_logging_level log_level, const struct bt_component_sink **component) { - return bt_graph_add_sink_component_with_init_method_data( + BT_ASSERT_PRE_NO_ERROR(); + return bt_graph_add_sink_component_with_initialize_method_data( graph, comp_cls, name, params, NULL, log_level, component); } -BT_HIDDEN -int bt_graph_remove_unconnected_component(struct bt_graph *graph, - struct bt_component *component) +enum bt_graph_add_component_status +bt_graph_add_simple_sink_component(struct bt_graph *graph, const char *name, + bt_graph_simple_sink_component_initialize_func init_func, + bt_graph_simple_sink_component_consume_func consume_func, + bt_graph_simple_sink_component_finalize_func finalize_func, + void *user_data, const bt_component_sink **component) { - bool init_can_consume; - uint64_t count; - uint64_t i; - int ret = 0; - - BT_ASSERT(graph); - BT_ASSERT(component); - BT_ASSERT(component->base.ref_count == 0); - BT_ASSERT(bt_component_borrow_graph(component) == graph); - - init_can_consume = graph->can_consume; - count = bt_component_get_input_port_count(component); - - for (i = 0; i < count; i++) { - struct bt_port *port = (void *) - bt_component_borrow_input_port_by_index(component, i); - - BT_ASSERT(port); - - if (bt_port_is_connected(port)) { - BT_LIB_LOGW("Cannot remove component from graph: " - "an input port is connected: " - "%![graph-]+g, %![comp-]+c, %![port-]+p", - graph, component, port); - goto error; - } - } - - count = bt_component_get_output_port_count(component); - - for (i = 0; i < count; i++) { - struct bt_port *port = (void *) - bt_component_borrow_output_port_by_index(component, i); - - BT_ASSERT(port); - - if (bt_port_is_connected(port)) { - BT_LIB_LOGW("Cannot remove component from graph: " - "an output port is connected: " - "%![graph-]+g, %![comp-]+c, %![port-]+p", - graph, component, port); - goto error; - } - } - - bt_graph_set_can_consume(graph, false); - - /* Possibly remove from sinks to consume */ - (void) g_queue_remove(graph->sinks_to_consume, component); + enum bt_graph_add_component_status status; + struct bt_component_class_sink *comp_cls; + struct simple_sink_init_method_data init_method_data = { + .init_func = init_func, + .consume_func = consume_func, + .finalize_func = finalize_func, + .user_data = user_data, + }; - if (graph->sinks_to_consume->length == 0) { - graph->has_sink = false; - } + BT_ASSERT_PRE_NO_ERROR(); /* - * This calls bt_object_try_spec_release() on the component, and - * since its reference count is 0, its destructor is called. Its - * destructor calls the user's finalization method (if set). + * Other preconditions are checked by + * bt_graph_add_sink_component_with_init_method_data(). */ - g_ptr_array_remove(graph->components, component); - goto end; + BT_ASSERT_PRE_NON_NULL(consume_func, "Consume function"); -error: - ret = -1; + comp_cls = bt_component_class_sink_simple_borrow(); + if (!comp_cls) { + BT_LIB_LOGE_APPEND_CAUSE( + "Cannot borrow simple sink component class."); + status = BT_FUNC_STATUS_MEMORY_ERROR; + goto end; + } + + status = bt_graph_add_sink_component_with_initialize_method_data(graph, + comp_cls, name, NULL, &init_method_data, + BT_LOGGING_LEVEL_NONE, component); end: - (void) init_can_consume; - bt_graph_set_can_consume(graph, init_can_consume); - return ret; + return status; } BT_HIDDEN @@ -1517,6 +1222,32 @@ void bt_graph_add_message(struct bt_graph *graph, g_ptr_array_add(graph->messages, msg); } +BT_HIDDEN +bool bt_graph_is_interrupted(const struct bt_graph *graph) +{ + BT_ASSERT_DBG(graph); + return bt_interrupter_array_any_is_set(graph->interrupters); +} + +enum bt_graph_add_interrupter_status bt_graph_add_interrupter( + struct bt_graph *graph, const struct bt_interrupter *intr) +{ + BT_ASSERT_PRE_NO_ERROR(); + BT_ASSERT_PRE_GRAPH_NON_NULL(graph); + BT_ASSERT_PRE_INTR_NON_NULL(intr); + g_ptr_array_add(graph->interrupters, (void *) intr); + bt_object_get_ref_no_null_check(intr); + BT_LIB_LOGD("Added interrupter to graph: %![graph-]+g, %![intr-]+z", + graph, intr); + return BT_FUNC_STATUS_OK; +} + +struct bt_interrupter *bt_graph_borrow_default_interrupter(bt_graph *graph) +{ + BT_ASSERT_PRE_GRAPH_NON_NULL(graph); + return graph->default_interrupter; +} + void bt_graph_get_ref(const struct bt_graph *graph) { bt_object_get_ref(graph);