src/lib/graph/graph.c

   1 /*
   2  * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
   3  * Copyright 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy
   6  * of this software and associated documentation files (the "Software"), to deal
   7  * in the Software without restriction, including without limitation the rights
   8  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9  * copies of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  */
  23
  24 #define BT_LOG_TAG "LIB/GRAPH"
  25 #include "lib/logging.h"
  26
  27 #include "common/assert.h"
  28 #include "lib/assert-pre.h"
  29 #include "lib/assert-post.h"
  30 #include <babeltrace2/graph/graph.h>
  31 #include <babeltrace2/graph/graph-const.h>
  32 #include <babeltrace2/graph/component-source-const.h>
  33 #include <babeltrace2/graph/component-filter-const.h>
  34 #include <babeltrace2/graph/port-const.h>
  35 #include "lib/graph/message/message.h"
  36 #include "compat/compiler.h"
  37 #include "common/common.h"
  38 #include <babeltrace2/types.h>
  39 #include <babeltrace2/value.h>
  40 #include <babeltrace2/value-const.h>
  41 #include "lib/value.h"
  42 #include <unistd.h>
  43 #include <stdbool.h>
  44 #include <glib.h>
  45
  46 #include "component-class-sink-simple.h"
  47 #include "component.h"
  48 #include "component-sink.h"
  49 #include "connection.h"
  50 #include "graph.h"
  51 #include "interrupter.h"
  52 #include "message/event.h"
  53 #include "message/packet.h"
  54
  55 typedef enum bt_graph_listener_func_status
  56 (*port_added_func_t)(const void *, const void *, void *);
  57
  58 typedef enum bt_component_class_initialize_method_status
  59 (*comp_init_method_t)(const void *, void *, const void *, void *);
  60
  61 struct bt_graph_listener_port_added {
  62         port_added_func_t func;
  63         void *data;
  64 };
  65
  66 #define INIT_LISTENERS_ARRAY(_type, _listeners)                         \
  67         do {                                                            \
  68                 _listeners = g_array_new(FALSE, TRUE, sizeof(_type));   \
  69                 if (!(_listeners)) {                                    \
  70                         BT_LIB_LOGE_APPEND_CAUSE(                       \
  71                                 "Failed to allocate one GArray.");      \
  72                 }                                                       \
  73         } while (0)
  74
  75 static
  76 void destroy_graph(struct bt_object *obj)
  77 {
  78         struct bt_graph *graph = container_of(obj, struct bt_graph, base);
  79
  80         /*
  81          * The graph's reference count is 0 if we're here. Increment
  82          * it to avoid a double-destroy (possibly infinitely recursive)
  83          * in this situation:
  84          *
  85          * 1. We put and destroy a connection.
  86          * 2. This connection's destructor finalizes its active message
  87          *    iterators.
  88          * 3. A message iterator's finalization function gets a new
  89          *    reference on its component (reference count goes from 0 to
  90          *    1).
  91          * 4. Since this component's reference count goes to 1, it takes
  92          *    a reference on its parent (this graph). This graph's
  93          *    reference count goes from 0 to 1.
  94          * 5. The message iterator's finalization function puts its
  95          *    component reference (reference count goes from 1 to 0).
  96          * 6. Since this component's reference count goes from 1 to 0,
  97          *    it puts its parent (this graph). This graph's reference
  98          *    count goes from 1 to 0.
  99          * 7. Since this graph's reference count goes from 1 to 0, its
 100          *    destructor is called (this function).
 101          *
 102          * With the incrementation below, the graph's reference count at
 103          * step 4 goes from 1 to 2, and from 2 to 1 at step 6. This
 104          * ensures that this function is not called two times.
 105          */
 106         BT_LIB_LOGI("Destroying graph: %!+g", graph);
 107         obj->ref_count++;
 108         graph->config_state = BT_GRAPH_CONFIGURATION_STATE_DESTROYING;
 109
 110         if (graph->messages) {
 111                 g_ptr_array_free(graph->messages, TRUE);
 112                 graph->messages = NULL;
 113         }
 114
 115         if (graph->connections) {
 116                 BT_LOGD_STR("Destroying connections.");
 117                 g_ptr_array_free(graph->connections, TRUE);
 118                 graph->connections = NULL;
 119         }
 120
 121         if (graph->components) {
 122                 BT_LOGD_STR("Destroying components.");
 123                 g_ptr_array_free(graph->components, TRUE);
 124                 graph->components = NULL;
 125         }
 126
 127         if (graph->interrupters) {
 128                 BT_LOGD_STR("Putting interrupters.");
 129                 g_ptr_array_free(graph->interrupters, TRUE);
 130                 graph->interrupters = NULL;
 131         }
 132
 133         BT_OBJECT_PUT_REF_AND_RESET(graph->default_interrupter);
 134
 135         if (graph->sinks_to_consume) {
 136                 g_queue_free(graph->sinks_to_consume);
 137                 graph->sinks_to_consume = NULL;
 138         }
 139
 140         if (graph->listeners.source_output_port_added) {
 141                 g_array_free(graph->listeners.source_output_port_added, TRUE);
 142                 graph->listeners.source_output_port_added = NULL;
 143         }
 144
 145         if (graph->listeners.filter_output_port_added) {
 146                 g_array_free(graph->listeners.filter_output_port_added, TRUE);
 147                 graph->listeners.filter_output_port_added = NULL;
 148         }
 149
 150         if (graph->listeners.filter_input_port_added) {
 151                 g_array_free(graph->listeners.filter_input_port_added, TRUE);
 152                 graph->listeners.filter_input_port_added = NULL;
 153         }
 154
 155         if (graph->listeners.sink_input_port_added) {
 156                 g_array_free(graph->listeners.sink_input_port_added, TRUE);
 157                 graph->listeners.sink_input_port_added = NULL;
 158         }
 159
 160         bt_object_pool_finalize(&graph->event_msg_pool);
 161         bt_object_pool_finalize(&graph->packet_begin_msg_pool);
 162         bt_object_pool_finalize(&graph->packet_end_msg_pool);
 163         g_free(graph);
 164 }
 165
 166 static
 167 void destroy_message_event(struct bt_message *msg,
 168                 struct bt_graph *graph)
 169 {
 170         bt_message_event_destroy(msg);
 171 }
 172
 173 static
 174 void destroy_message_packet_begin(struct bt_message *msg,
 175                 struct bt_graph *graph)
 176 {
 177         bt_message_packet_destroy(msg);
 178 }
 179
 180 static
 181 void destroy_message_packet_end(struct bt_message *msg,
 182                 struct bt_graph *graph)
 183 {
 184         bt_message_packet_destroy(msg);
 185 }
 186
 187 static
 188 void notify_message_graph_is_destroyed(struct bt_message *msg)
 189 {
 190         bt_message_unlink_graph(msg);
 191 }
 192
 193 struct bt_graph *bt_graph_create(uint64_t mip_version)
 194 {
 195         struct bt_graph *graph;
 196         int ret;
 197
 198         BT_ASSERT_PRE_NO_ERROR();
 199         BT_ASSERT_PRE(mip_version <= bt_get_maximal_mip_version(),
 200                 "Unknown MIP version: mip-version=%" PRIu64 ", "
 201                 "max-mip-version=%" PRIu64,
 202                 mip_version, bt_get_maximal_mip_version());
 203         BT_LOGI_STR("Creating graph object.");
 204         graph = g_new0(struct bt_graph, 1);
 205         if (!graph) {
 206                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one graph.");
 207                 goto end;
 208         }
 209
 210         bt_object_init_shared(&graph->base, destroy_graph);
 211         graph->mip_version = mip_version;
 212         graph->connections = g_ptr_array_new_with_free_func(
 213                 (GDestroyNotify) bt_object_try_spec_release);
 214         if (!graph->connections) {
 215                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one GPtrArray.");
 216                 goto error;
 217         }
 218         graph->components = g_ptr_array_new_with_free_func(
 219                 (GDestroyNotify) bt_object_try_spec_release);
 220         if (!graph->components) {
 221                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one GPtrArray.");
 222                 goto error;
 223         }
 224         graph->sinks_to_consume = g_queue_new();
 225         if (!graph->sinks_to_consume) {
 226                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one GQueue.");
 227                 goto error;
 228         }
 229
 230         bt_graph_set_can_consume(graph, true);
 231         INIT_LISTENERS_ARRAY(struct bt_graph_listener_port_added,
 232                 graph->listeners.source_output_port_added);
 233
 234         if (!graph->listeners.source_output_port_added) {
 235                 goto error;
 236         }
 237
 238         INIT_LISTENERS_ARRAY(struct bt_graph_listener_port_added,
 239                 graph->listeners.filter_output_port_added);
 240
 241         if (!graph->listeners.filter_output_port_added) {
 242                 goto error;
 243         }
 244
 245         INIT_LISTENERS_ARRAY(struct bt_graph_listener_port_added,
 246                 graph->listeners.filter_input_port_added);
 247
 248         if (!graph->listeners.filter_input_port_added) {
 249                 goto error;
 250         }
 251
 252         INIT_LISTENERS_ARRAY(struct bt_graph_listener_port_added,
 253                 graph->listeners.sink_input_port_added);
 254
 255         if (!graph->listeners.sink_input_port_added) {
 256                 goto error;
 257         }
 258
 259         graph->interrupters = g_ptr_array_new_with_free_func(
 260                 (GDestroyNotify) bt_object_put_ref_no_null_check);
 261         if (!graph->interrupters) {
 262                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one GPtrArray.");
 263                 goto error;
 264         }
 265
 266         graph->default_interrupter = bt_interrupter_create();
 267         if (!graph->default_interrupter) {
 268                 BT_LIB_LOGE_APPEND_CAUSE(
 269                         "Failed to create one interrupter object.");
 270                 goto error;
 271         }
 272
 273         bt_graph_add_interrupter(graph, graph->default_interrupter);
 274         ret = bt_object_pool_initialize(&graph->event_msg_pool,
 275                 (bt_object_pool_new_object_func) bt_message_event_new,
 276                 (bt_object_pool_destroy_object_func) destroy_message_event,
 277                 graph);
 278         if (ret) {
 279                 BT_LIB_LOGE_APPEND_CAUSE(
 280                         "Failed to initialize event message pool: ret=%d",
 281                         ret);
 282                 goto error;
 283         }
 284
 285         ret = bt_object_pool_initialize(&graph->packet_begin_msg_pool,
 286                 (bt_object_pool_new_object_func) bt_message_packet_beginning_new,
 287                 (bt_object_pool_destroy_object_func) destroy_message_packet_begin,
 288                 graph);
 289         if (ret) {
 290                 BT_LIB_LOGE_APPEND_CAUSE(
 291                         "Failed to initialize packet beginning message pool: ret=%d",
 292                         ret);
 293                 goto error;
 294         }
 295
 296         ret = bt_object_pool_initialize(&graph->packet_end_msg_pool,
 297                 (bt_object_pool_new_object_func) bt_message_packet_end_new,
 298                 (bt_object_pool_destroy_object_func) destroy_message_packet_end,
 299                 graph);
 300         if (ret) {
 301                 BT_LIB_LOGE_APPEND_CAUSE(
 302                         "Failed to initialize packet end message pool: ret=%d",
 303                         ret);
 304                 goto error;
 305         }
 306
 307         graph->messages = g_ptr_array_new_with_free_func(
 308                 (GDestroyNotify) notify_message_graph_is_destroyed);
 309         BT_LIB_LOGI("Created graph object: %!+g", graph);
 310
 311 end:
 312         return (void *) graph;
 313
 314 error:
 315         BT_OBJECT_PUT_REF_AND_RESET(graph);
 316         goto end;
 317 }
 318
 319 enum bt_graph_connect_ports_status bt_graph_connect_ports(
 320                 struct bt_graph *graph,
 321                 const struct bt_port_output *upstream_port_out,
 322                 const struct bt_port_input *downstream_port_in,
 323                 const struct bt_connection **user_connection)
 324 {
 325         enum bt_graph_connect_ports_status status = BT_FUNC_STATUS_OK;
 326         struct bt_connection *connection = NULL;
 327         struct bt_port *upstream_port = (void *) upstream_port_out;
 328         struct bt_port *downstream_port = (void *) downstream_port_in;
 329         struct bt_component *upstream_component = NULL;
 330         struct bt_component *downstream_component = NULL;
 331         enum bt_component_class_port_connected_method_status port_connected_status;
 332         bool init_can_consume;
 333
 334         BT_ASSERT_PRE_NO_ERROR();
 335         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
 336         BT_ASSERT_PRE_NON_NULL(upstream_port, "Upstream port");
 337         BT_ASSERT_PRE_NON_NULL(downstream_port, "Downstream port port");
 338         BT_ASSERT_PRE(
 339                 graph->config_state == BT_GRAPH_CONFIGURATION_STATE_CONFIGURING,
 340                 "Graph is not in the \"configuring\" state: %!+g", graph);
 341         BT_ASSERT_PRE(!bt_port_is_connected(upstream_port),
 342                 "Upstream port is already connected: %!+p", upstream_port);
 343         BT_ASSERT_PRE(!bt_port_is_connected(downstream_port),
 344                 "Downstream port is already connected: %!+p", downstream_port);
 345         BT_ASSERT_PRE(bt_port_borrow_component_inline((void *) upstream_port),
 346                 "Upstream port does not belong to a component: %!+p",
 347                 upstream_port);
 348         BT_ASSERT_PRE(bt_port_borrow_component_inline((void *) downstream_port),
 349                 "Downstream port does not belong to a component: %!+p",
 350                 downstream_port);
 351         init_can_consume = graph->can_consume;
 352         BT_LIB_LOGI("Connecting component ports within graph: "
 353                 "%![graph-]+g, %![up-port-]+p, %![down-port-]+p",
 354                 graph, upstream_port, downstream_port);
 355         bt_graph_set_can_consume(graph, false);
 356         upstream_component = bt_port_borrow_component_inline(
 357                 (void *) upstream_port);
 358         downstream_component = bt_port_borrow_component_inline(
 359                 (void *) downstream_port);
 360
 361         BT_LOGD_STR("Creating connection.");
 362         connection = bt_connection_create(graph, (void *) upstream_port,
 363                 (void *) downstream_port);
 364         if (!connection) {
 365                 BT_LIB_LOGE_APPEND_CAUSE("Cannot create connection object.");
 366                 status = BT_FUNC_STATUS_MEMORY_ERROR;
 367                 goto end;
 368         }
 369
 370         BT_LIB_LOGD("Connection object created: %!+x", connection);
 371
 372         /*
 373          * Ownership of upstream_component/downstream_component and of
 374          * the connection object is transferred to the graph.
 375          */
 376         g_ptr_array_add(graph->connections, connection);
 377
 378         /*
 379          * Notify both components that their port is connected.
 380          */
 381         BT_LIB_LOGD("Notifying upstream component that its port is connected: "
 382                 "%![comp-]+c, %![port-]+p", upstream_component, upstream_port);
 383         port_connected_status = bt_component_port_connected(upstream_component,
 384                 (void *) upstream_port, (void *) downstream_port);
 385         if (port_connected_status != BT_FUNC_STATUS_OK) {
 386                 if (port_connected_status < 0) {
 387                         BT_LIB_LOGW_APPEND_CAUSE(
 388                                 "Upstream component's \"port connected\" method failed: "
 389                                 "status=%s, %![graph-]+g, %![up-comp-]+c, "
 390                                 "%![down-comp-]+c, %![up-port-]+p, %![down-port-]+p",
 391                                 bt_common_func_status_string(
 392                                         port_connected_status),
 393                                 graph, upstream_component, downstream_component,
 394                                 upstream_port, downstream_port);
 395                 }
 396
 397                 bt_connection_end(connection, true);
 398                 status = (int) port_connected_status;
 399                 goto end;
 400         }
 401
 402         connection->notified_upstream_port_connected = true;
 403         BT_LIB_LOGD("Notifying downstream component that its port is connected: "
 404                 "%![comp-]+c, %![port-]+p", downstream_component,
 405                 downstream_port);
 406         port_connected_status = bt_component_port_connected(downstream_component,
 407                 (void *) downstream_port, (void *) upstream_port);
 408         if (port_connected_status != BT_FUNC_STATUS_OK) {
 409                 if (port_connected_status < 0) {
 410                         BT_LIB_LOGW_APPEND_CAUSE(
 411                                 "Downstream component's \"port connected\" method failed: "
 412                                 "status=%s, %![graph-]+g, %![up-comp-]+c, "
 413                                 "%![down-comp-]+c, %![up-port-]+p, %![down-port-]+p",
 414                                 bt_common_func_status_string(
 415                                         port_connected_status),
 416                                 graph, upstream_component, downstream_component,
 417                                 upstream_port, downstream_port);
 418                 }
 419
 420                 bt_connection_end(connection, true);
 421                 status = (int) port_connected_status;
 422                 goto end;
 423         }
 424
 425         connection->notified_downstream_port_connected = true;
 426
 427         BT_LIB_LOGI("Connected component ports within graph: "
 428                 "%![graph-]+g, %![up-comp-]+c, %![down-comp-]+c, "
 429                 "%![up-port-]+p, %![down-port-]+p",
 430                 graph, upstream_component, downstream_component,
 431                 upstream_port, downstream_port);
 432
 433         if (user_connection) {
 434                 /* Move reference to user */
 435                 *user_connection = connection;
 436                 connection = NULL;
 437         }
 438
 439 end:
 440         if (status != BT_FUNC_STATUS_OK) {
 441                 bt_graph_make_faulty(graph);
 442         }
 443
 444         bt_object_put_ref(connection);
 445         (void) init_can_consume;
 446         bt_graph_set_can_consume(graph, init_can_consume);
 447         return status;
 448 }
 449
 450 static inline
 451 int consume_graph_sink(struct bt_component_sink *comp)
 452 {
 453         enum bt_component_class_sink_consume_method_status consume_status;
 454         struct bt_component_class_sink *sink_class = NULL;
 455
 456         BT_ASSERT_DBG(comp);
 457         sink_class = (void *) comp->parent.class;
 458         BT_ASSERT_DBG(sink_class->methods.consume);
 459         BT_LIB_LOGD("Calling user's consume method: %!+c", comp);
 460         consume_status = sink_class->methods.consume((void *) comp);
 461         BT_LOGD("User method returned: status=%s",
 462                 bt_common_func_status_string(consume_status));
 463         BT_ASSERT_POST_DEV(consume_status == BT_FUNC_STATUS_OK ||
 464                 consume_status == BT_FUNC_STATUS_END ||
 465                 consume_status == BT_FUNC_STATUS_AGAIN ||
 466                 consume_status == BT_FUNC_STATUS_ERROR ||
 467                 consume_status == BT_FUNC_STATUS_MEMORY_ERROR,
 468                 "Invalid component status returned by consuming method: "
 469                 "status=%s", bt_common_func_status_string(consume_status));
 470         BT_ASSERT_POST_DEV_NO_ERROR_IF_NO_ERROR_STATUS(consume_status);
 471         if (consume_status) {
 472                 if (consume_status < 0) {
 473                         BT_LIB_LOGW_APPEND_CAUSE(
 474                                 "Component's \"consume\" method failed: "
 475                                 "status=%s, %![comp-]+c",
 476                                 bt_common_func_status_string(consume_status),
 477                                 comp);
 478                 }
 479
 480                 goto end;
 481         }
 482
 483         BT_LIB_LOGD("Consumed from sink: %![comp-]+c, status=%s",
 484                 comp, bt_common_func_status_string(consume_status));
 485
 486 end:
 487         return consume_status;
 488 }
 489
 490 /*
 491  * `node` is removed from the queue of sinks to consume when passed to
 492  * this function. This function adds it back to the queue if there's
 493  * still something to consume afterwards.
 494  */
 495 static inline
 496 int consume_sink_node(struct bt_graph *graph, GList *node)
 497 {
 498         int status;
 499         struct bt_component_sink *sink;
 500
 501         sink = node->data;
 502         status = consume_graph_sink(sink);
 503         if (G_UNLIKELY(status != BT_FUNC_STATUS_END)) {
 504                 g_queue_push_tail_link(graph->sinks_to_consume, node);
 505                 goto end;
 506         }
 507
 508         /* End reached, the node is not added back to the queue and free'd. */
 509         g_queue_delete_link(graph->sinks_to_consume, node);
 510
 511         /* Don't forward an END status if there are sinks left to consume. */
 512         if (!g_queue_is_empty(graph->sinks_to_consume)) {
 513                 status = BT_FUNC_STATUS_OK;
 514                 goto end;
 515         }
 516
 517 end:
 518         BT_LIB_LOGD("Consumed sink node: %![comp-]+c, status=%s",
 519                 sink, bt_common_func_status_string(status));
 520         return status;
 521 }
 522
 523 BT_HIDDEN
 524 int bt_graph_consume_sink_no_check(struct bt_graph *graph,
 525                 struct bt_component_sink *sink)
 526 {
 527         int status;
 528         GList *sink_node;
 529         int index;
 530
 531         BT_LIB_LOGD("Making specific sink consume: %![comp-]+c", sink);
 532         BT_ASSERT_DBG(bt_component_borrow_graph((void *) sink) == graph);
 533
 534         if (g_queue_is_empty(graph->sinks_to_consume)) {
 535                 BT_LOGD_STR("Graph's sink queue is empty: end of graph.");
 536                 status = BT_FUNC_STATUS_END;
 537                 goto end;
 538         }
 539
 540         index = g_queue_index(graph->sinks_to_consume, sink);
 541         if (index < 0) {
 542                 BT_LIB_LOGD("Sink component is not marked as consumable: "
 543                         "component sink is ended: %![comp-]+c", sink);
 544                 status = BT_FUNC_STATUS_END;
 545                 goto end;
 546         }
 547
 548         sink_node = g_queue_pop_nth_link(graph->sinks_to_consume, index);
 549         BT_ASSERT_DBG(sink_node);
 550         status = consume_sink_node(graph, sink_node);
 551
 552 end:
 553         return status;
 554 }
 555
 556 static inline
 557 int consume_no_check(struct bt_graph *graph)
 558 {
 559         int status = BT_FUNC_STATUS_OK;
 560         struct bt_component *sink;
 561         GList *current_node;
 562
 563         BT_ASSERT_PRE_DEV(graph->has_sink,
 564                 "Graph has no sink component: %!+g", graph);
 565         BT_LIB_LOGD("Making next sink component consume: %![graph-]+g", graph);
 566
 567         if (G_UNLIKELY(g_queue_is_empty(graph->sinks_to_consume))) {
 568                 BT_LOGD_STR("Graph's sink queue is empty: end of graph.");
 569                 status = BT_FUNC_STATUS_END;
 570                 goto end;
 571         }
 572
 573         current_node = g_queue_pop_head_link(graph->sinks_to_consume);
 574         sink = current_node->data;
 575         BT_LIB_LOGD("Chose next sink to consume: %!+c", sink);
 576         status = consume_sink_node(graph, current_node);
 577
 578 end:
 579         return status;
 580 }
 581
 582 enum bt_graph_run_once_status bt_graph_run_once(struct bt_graph *graph)
 583 {
 584         enum bt_graph_run_once_status status;
 585
 586         BT_ASSERT_PRE_NO_ERROR();
 587         BT_ASSERT_PRE_DEV_NON_NULL(graph, "Graph");
 588         BT_ASSERT_PRE_DEV(graph->can_consume,
 589                 "Cannot consume graph in its current state: %!+g", graph);
 590         BT_ASSERT_PRE_DEV(graph->config_state !=
 591                 BT_GRAPH_CONFIGURATION_STATE_FAULTY,
 592                 "Graph is in a faulty state: %!+g", graph);
 593         bt_graph_set_can_consume(graph, false);
 594         status = bt_graph_configure(graph);
 595         if (G_UNLIKELY(status)) {
 596                 /* bt_graph_configure() logs errors */
 597                 goto end;
 598         }
 599
 600         status = consume_no_check(graph);
 601         bt_graph_set_can_consume(graph, true);
 602
 603 end:
 604         return status;
 605 }
 606
 607 enum bt_graph_run_status bt_graph_run(struct bt_graph *graph)
 608 {
 609         enum bt_graph_run_status status;
 610
 611         BT_ASSERT_PRE_NO_ERROR();
 612         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
 613         BT_ASSERT_PRE(graph->can_consume,
 614                 "Cannot consume graph in its current state: %!+g", graph);
 615         BT_ASSERT_PRE(graph->config_state != BT_GRAPH_CONFIGURATION_STATE_FAULTY,
 616                 "Graph is in a faulty state: %!+g", graph);
 617         bt_graph_set_can_consume(graph, false);
 618         status = bt_graph_configure(graph);
 619         if (G_UNLIKELY(status)) {
 620                 /* bt_graph_configure() logs errors */
 621                 goto end;
 622         }
 623
 624         BT_LIB_LOGI("Running graph: %!+g", graph);
 625
 626         do {
 627                 /*
 628                  * Check if the graph is interrupted at each iteration.
 629                  * If the graph was interrupted by another thread or by
 630                  * a signal handler, this is NOT a warning nor an error;
 631                  * it was intentional: log with an INFO level only.
 632                  */
 633                 if (G_UNLIKELY(bt_graph_is_interrupted(graph))) {
 634                         BT_LIB_LOGI("Stopping the graph: "
 635                                 "graph was interrupted: %!+g", graph);
 636                         status = BT_FUNC_STATUS_AGAIN;
 637                         goto end;
 638                 }
 639
 640                 status = consume_no_check(graph);
 641                 if (G_UNLIKELY(status == BT_FUNC_STATUS_AGAIN)) {
 642                         /*
 643                          * If AGAIN is received and there are multiple
 644                          * sinks, go ahead and consume from the next
 645                          * sink.
 646                          *
 647                          * However, in the case where a single sink is
 648                          * left, the caller can decide to busy-wait and
 649                          * call bt_graph_run() continuously
 650                          * until the source is ready or it can decide to
 651                          * sleep for an arbitrary amount of time.
 652                          */
 653                         if (graph->sinks_to_consume->length > 1) {
 654                                 status = BT_FUNC_STATUS_OK;
 655                         }
 656                 }
 657         } while (status == BT_FUNC_STATUS_OK);
 658
 659         if (status == BT_FUNC_STATUS_END) {
 660                 /*
 661                  * The last call to consume_no_check() returned
 662                  * `BT_FUNC_STATUS_END`, but bt_graph_run() has no
 663                  * `BT_GRAPH_RUN_STATUS_END` status: replace with
 664                  * `BT_GRAPH_RUN_STATUS_OK` (success: graph ran
 665                  * completely).
 666                  */
 667                 status = BT_FUNC_STATUS_OK;
 668         }
 669
 670 end:
 671         BT_LIB_LOGI("Graph ran: %![graph-]+g, status=%s", graph,
 672                 bt_common_func_status_string(status));
 673         bt_graph_set_can_consume(graph, true);
 674         return status;
 675 }
 676
 677 enum bt_graph_add_listener_status
 678 bt_graph_add_source_component_output_port_added_listener(
 679                 struct bt_graph *graph,
 680                 bt_graph_source_component_output_port_added_listener_func func,
 681                 void *data, bt_listener_id *out_listener_id)
 682 {
 683         struct bt_graph_listener_port_added listener = {
 684                 .func = (port_added_func_t) func,
 685                 .data = data,
 686         };
 687         bt_listener_id listener_id;
 688
 689         BT_ASSERT_PRE_NO_ERROR();
 690         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
 691         BT_ASSERT_PRE_NON_NULL(func, "Listener");
 692         g_array_append_val(graph->listeners.source_output_port_added, listener);
 693         listener_id = graph->listeners.source_output_port_added->len - 1;
 694         BT_LIB_LOGD("Added \"source component output port added\" listener to graph: "
 695                 "%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
 696                 listener_id);
 697
 698         if (listener_id) {
 699                 *out_listener_id = listener_id;
 700         }
 701
 702         return BT_FUNC_STATUS_OK;
 703 }
 704
 705 enum bt_graph_add_listener_status
 706 bt_graph_add_filter_component_output_port_added_listener(
 707                 struct bt_graph *graph,
 708                 bt_graph_filter_component_output_port_added_listener_func func,
 709                 void *data, bt_listener_id *out_listener_id)
 710 {
 711         struct bt_graph_listener_port_added listener = {
 712                 .func = (port_added_func_t) func,
 713                 .data = data,
 714         };
 715         bt_listener_id listener_id;
 716
 717         BT_ASSERT_PRE_NO_ERROR();
 718         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
 719         BT_ASSERT_PRE_NON_NULL(func, "Listener");
 720         g_array_append_val(graph->listeners.filter_output_port_added, listener);
 721         listener_id = graph->listeners.filter_output_port_added->len - 1;
 722         BT_LIB_LOGD("Added \"filter component output port added\" listener to graph: "
 723                 "%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
 724                 listener_id);
 725
 726         if (listener_id) {
 727                 *out_listener_id = listener_id;
 728         }
 729
 730         return BT_FUNC_STATUS_OK;
 731 }
 732
 733 enum bt_graph_add_listener_status
 734 bt_graph_add_filter_component_input_port_added_listener(
 735                 struct bt_graph *graph,
 736                 bt_graph_filter_component_input_port_added_listener_func func,
 737                 void *data, bt_listener_id *out_listener_id)
 738 {
 739         struct bt_graph_listener_port_added listener = {
 740                 .func = (port_added_func_t) func,
 741                 .data = data,
 742         };
 743         bt_listener_id listener_id;
 744
 745         BT_ASSERT_PRE_NO_ERROR();
 746         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
 747         BT_ASSERT_PRE_NON_NULL(func, "Listener");
 748         g_array_append_val(graph->listeners.filter_input_port_added, listener);
 749         listener_id = graph->listeners.filter_input_port_added->len - 1;
 750         BT_LIB_LOGD("Added \"filter component input port added\" listener to graph: "
 751                 "%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
 752                 listener_id);
 753
 754         if (listener_id) {
 755                 *out_listener_id = listener_id;
 756         }
 757
 758         return BT_FUNC_STATUS_OK;
 759 }
 760
 761 enum bt_graph_add_listener_status
 762 bt_graph_add_sink_component_input_port_added_listener(
 763                 struct bt_graph *graph,
 764                 bt_graph_sink_component_input_port_added_listener_func func,
 765                 void *data, bt_listener_id *out_listener_id)
 766 {
 767         struct bt_graph_listener_port_added listener = {
 768                 .func = (port_added_func_t) func,
 769                 .data = data,
 770         };
 771         bt_listener_id listener_id;
 772
 773         BT_ASSERT_PRE_NO_ERROR();
 774         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
 775         BT_ASSERT_PRE_NON_NULL(func, "Listener");
 776         g_array_append_val(graph->listeners.sink_input_port_added, listener);
 777         listener_id = graph->listeners.sink_input_port_added->len - 1;
 778         BT_LIB_LOGD("Added \"sink component input port added\" listener to graph: "
 779                 "%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
 780                 listener_id);
 781
 782         if (listener_id) {
 783                 *out_listener_id = listener_id;
 784         }
 785
 786         return BT_FUNC_STATUS_OK;
 787 }
 788
 789 BT_HIDDEN
 790 enum bt_graph_listener_func_status bt_graph_notify_port_added(
 791                 struct bt_graph *graph, struct bt_port *port)
 792 {
 793         uint64_t i;
 794         GArray *listeners;
 795         struct bt_component *comp;
 796         enum bt_graph_listener_func_status status = BT_FUNC_STATUS_OK;
 797
 798         BT_ASSERT(graph);
 799         BT_ASSERT(port);
 800         BT_LIB_LOGD("Notifying graph listeners that a port was added: "
 801                 "%![graph-]+g, %![port-]+p", graph, port);
 802         comp = bt_port_borrow_component_inline(port);
 803         BT_ASSERT(comp);
 804
 805         switch (comp->class->type) {
 806         case BT_COMPONENT_CLASS_TYPE_SOURCE:
 807         {
 808                 switch (port->type) {
 809                 case BT_PORT_TYPE_OUTPUT:
 810                         listeners = graph->listeners.source_output_port_added;
 811                         break;
 812                 default:
 813                         bt_common_abort();
 814                 }
 815
 816                 break;
 817         }
 818         case BT_COMPONENT_CLASS_TYPE_FILTER:
 819         {
 820                 switch (port->type) {
 821                 case BT_PORT_TYPE_INPUT:
 822                         listeners = graph->listeners.filter_input_port_added;
 823                         break;
 824                 case BT_PORT_TYPE_OUTPUT:
 825                         listeners = graph->listeners.filter_output_port_added;
 826                         break;
 827                 default:
 828                         bt_common_abort();
 829                 }
 830
 831                 break;
 832         }
 833         case BT_COMPONENT_CLASS_TYPE_SINK:
 834         {
 835                 switch (port->type) {
 836                 case BT_PORT_TYPE_INPUT:
 837                         listeners = graph->listeners.sink_input_port_added;
 838                         break;
 839                 default:
 840                         bt_common_abort();
 841                 }
 842
 843                 break;
 844         }
 845         default:
 846                 bt_common_abort();
 847         }
 848
 849         for (i = 0; i < listeners->len; i++) {
 850                 struct bt_graph_listener_port_added *listener =
 851                         &g_array_index(listeners,
 852                                 struct bt_graph_listener_port_added, i);
 853
 854
 855                 BT_ASSERT(listener->func);
 856                 status = listener->func(comp, port, listener->data);
 857                 BT_ASSERT_POST_NO_ERROR_IF_NO_ERROR_STATUS(status);
 858                 if (status != BT_FUNC_STATUS_OK) {
 859                         goto end;
 860                 }
 861         }
 862
 863 end:
 864         return status;
 865 }
 866
 867 BT_HIDDEN
 868 void bt_graph_remove_connection(struct bt_graph *graph,
 869                 struct bt_connection *connection)
 870 {
 871         BT_ASSERT(graph);
 872         BT_ASSERT(connection);
 873         BT_LIB_LOGD("Removing graph's connection: %![graph-]+g, %![conn-]+x",
 874                 graph, connection);
 875         g_ptr_array_remove(graph->connections, connection);
 876 }
 877
 878 static inline
 879 bool component_name_exists(struct bt_graph *graph, const char *name)
 880 {
 881         bool exists = false;
 882         uint64_t i;
 883
 884         for (i = 0; i < graph->components->len; i++) {
 885                 struct bt_component *other_comp = graph->components->pdata[i];
 886
 887                 if (strcmp(name, bt_component_get_name(other_comp)) == 0) {
 888                         BT_ASSERT_PRE_MSG("Another component with the same name already exists in the graph: "
 889                                 "%![other-comp-]+c, name=\"%s\"",
 890                                 other_comp, name);
 891                         exists = true;
 892                         goto end;
 893                 }
 894         }
 895
 896 end:
 897         return exists;
 898 }
 899
 900 static
 901 int add_component_with_init_method_data(
 902                 struct bt_graph *graph,
 903                 struct bt_component_class *comp_cls,
 904                 comp_init_method_t init_method,
 905                 const char *name, const struct bt_value *params,
 906                 void *init_method_data, bt_logging_level log_level,
 907                 const struct bt_component **user_component)
 908 {
 909         int status = BT_FUNC_STATUS_OK;
 910         enum bt_component_class_initialize_method_status init_status;
 911         struct bt_component *component = NULL;
 912         int ret;
 913         bool init_can_consume;
 914         struct bt_value *new_params = NULL;
 915
 916         BT_ASSERT(comp_cls);
 917         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
 918         BT_ASSERT_PRE_NON_NULL(name, "Name");
 919         BT_ASSERT_PRE(
 920                 graph->config_state == BT_GRAPH_CONFIGURATION_STATE_CONFIGURING,
 921                 "Graph is not in the \"configuring\" state: %!+g", graph);
 922         BT_ASSERT_PRE(!component_name_exists(graph, name),
 923                 "Duplicate component name: %!+g, name=\"%s\"", graph, name);
 924         BT_ASSERT_PRE(!params || bt_value_is_map(params),
 925                 "Parameter value is not a map value: %!+v", params);
 926         init_can_consume = graph->can_consume;
 927         bt_graph_set_can_consume(graph, false);
 928         BT_LIB_LOGI("Adding component to graph: "
 929                 "%![graph-]+g, %![cc-]+C, name=\"%s\", log-level=%s, "
 930                 "%![params-]+v, init-method-data-addr=%p",
 931                 graph, comp_cls, name,
 932                 bt_common_logging_level_string(log_level), params,
 933                 init_method_data);
 934
 935         if (!params) {
 936                 new_params = bt_value_map_create();
 937                 if (!new_params) {
 938                         BT_LIB_LOGE_APPEND_CAUSE(
 939                                 "Cannot create empty map value object.");
 940                         status = BT_FUNC_STATUS_MEMORY_ERROR;
 941                         goto end;
 942                 }
 943
 944                 params = new_params;
 945         }
 946
 947         ret = bt_component_create(comp_cls, name, log_level, &component);
 948         if (ret) {
 949                 BT_LIB_LOGE_APPEND_CAUSE(
 950                         "Cannot create empty component object: ret=%d",
 951                         ret);
 952                 status = BT_FUNC_STATUS_MEMORY_ERROR;
 953                 goto end;
 954         }
 955
 956         /*
 957          * The user's initialization method needs to see that this
 958          * component is part of the graph. If the user method fails, we
 959          * immediately remove the component from the graph's components.
 960          */
 961         g_ptr_array_add(graph->components, component);
 962         bt_component_set_graph(component, graph);
 963         bt_value_freeze(params);
 964
 965         if (init_method) {
 966                 /*
 967                  * There is no use for config objects right now, so just pass
 968                  * NULL.
 969                  */
 970                 BT_LOGD_STR("Calling user's initialization method.");
 971                 init_status = init_method(component, NULL, params, init_method_data);
 972                 BT_LOGD("User method returned: status=%s",
 973                         bt_common_func_status_string(init_status));
 974                 BT_ASSERT_POST_DEV_NO_ERROR_IF_NO_ERROR_STATUS(init_status);
 975                 if (init_status != BT_FUNC_STATUS_OK) {
 976                         if (init_status < 0) {
 977                                 BT_LIB_LOGW_APPEND_CAUSE(
 978                                         "Component initialization method failed: "
 979                                         "status=%s, %![comp-]+c",
 980                                         bt_common_func_status_string(init_status),
 981                                         component);
 982                         }
 983
 984                         status = init_status;
 985                         bt_component_set_graph(component, NULL);
 986                         g_ptr_array_remove_fast(graph->components, component);
 987                         goto end;
 988                 }
 989         }
 990
 991         /*
 992          * Mark the component as initialized so that its finalization
 993          * method is called when it is destroyed.
 994          */
 995         component->initialized = true;
 996
 997         /*
 998          * If it's a sink component, it needs to be part of the graph's
 999          * sink queue to be consumed by bt_graph_run() or
1000          * bt_graph_run_once().
1001          */
1002         if (bt_component_is_sink(component)) {
1003                 graph->has_sink = true;
1004                 g_queue_push_tail(graph->sinks_to_consume, component);
1005         }
1006
1007         /*
1008          * Freeze the component class now that it's instantiated at
1009          * least once.
1010          */
1011         BT_LOGD_STR("Freezing component class.");
1012         bt_component_class_freeze(comp_cls);
1013         BT_LIB_LOGI("Added component to graph: "
1014                 "%![graph-]+g, %![cc-]+C, name=\"%s\", log-level=%s, "
1015                 "%![params-]+v, init-method-data-addr=%p, %![comp-]+c",
1016                 graph, comp_cls, name,
1017                 bt_common_logging_level_string(log_level), params,
1018                 init_method_data, component);
1019
1020         if (user_component) {
1021                 /* Move reference to user */
1022                 *user_component = component;
1023                 component = NULL;
1024         }
1025
1026 end:
1027         if (status != BT_FUNC_STATUS_OK) {
1028                 bt_graph_make_faulty(graph);
1029         }
1030
1031         bt_object_put_ref(component);
1032         bt_object_put_ref(new_params);
1033         (void) init_can_consume;
1034         bt_graph_set_can_consume(graph, init_can_consume);
1035         return status;
1036 }
1037
1038 enum bt_graph_add_component_status
1039 bt_graph_add_source_component_with_initialize_method_data(
1040                 struct bt_graph *graph,
1041                 const struct bt_component_class_source *comp_cls,
1042                 const char *name, const struct bt_value *params,
1043                 void *init_method_data, bt_logging_level log_level,
1044                 const struct bt_component_source **component)
1045 {
1046         BT_ASSERT_PRE_NO_ERROR();
1047         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
1048         return add_component_with_init_method_data(graph,
1049                 (void *) comp_cls, (comp_init_method_t) comp_cls->methods.init,
1050                 name, params, init_method_data, log_level, (void *) component);
1051 }
1052
1053 enum bt_graph_add_component_status bt_graph_add_source_component(
1054                 struct bt_graph *graph,
1055                 const struct bt_component_class_source *comp_cls,
1056                 const char *name, const struct bt_value *params,
1057                 enum bt_logging_level log_level,
1058                 const struct bt_component_source **component)
1059 {
1060         BT_ASSERT_PRE_NO_ERROR();
1061         return bt_graph_add_source_component_with_initialize_method_data(
1062                 graph, comp_cls, name, params, NULL, log_level, component);
1063 }
1064
1065 enum bt_graph_add_component_status
1066 bt_graph_add_filter_component_with_initialize_method_data(
1067                 struct bt_graph *graph,
1068                 const struct bt_component_class_filter *comp_cls,
1069                 const char *name, const struct bt_value *params,
1070                 void *init_method_data, enum bt_logging_level log_level,
1071                 const struct bt_component_filter **component)
1072 {
1073         BT_ASSERT_PRE_NO_ERROR();
1074         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
1075         return add_component_with_init_method_data(graph,
1076                 (void *) comp_cls, (comp_init_method_t) comp_cls->methods.init,
1077                 name, params, init_method_data, log_level, (void *) component);
1078 }
1079
1080 enum bt_graph_add_component_status bt_graph_add_filter_component(
1081                 struct bt_graph *graph,
1082                 const struct bt_component_class_filter *comp_cls,
1083                 const char *name, const struct bt_value *params,
1084                 enum bt_logging_level log_level,
1085                 const struct bt_component_filter **component)
1086 {
1087         BT_ASSERT_PRE_NO_ERROR();
1088         return bt_graph_add_filter_component_with_initialize_method_data(
1089                 graph, comp_cls, name, params, NULL, log_level, component);
1090 }
1091
1092 enum bt_graph_add_component_status
1093 bt_graph_add_sink_component_with_initialize_method_data(
1094                 struct bt_graph *graph,
1095                 const struct bt_component_class_sink *comp_cls,
1096                 const char *name, const struct bt_value *params,
1097                 void *init_method_data, enum bt_logging_level log_level,
1098                 const struct bt_component_sink **component)
1099 {
1100         BT_ASSERT_PRE_NO_ERROR();
1101         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
1102         return add_component_with_init_method_data(graph,
1103                 (void *) comp_cls, (comp_init_method_t) comp_cls->methods.init,
1104                 name, params, init_method_data, log_level, (void *) component);
1105 }
1106
1107 enum bt_graph_add_component_status bt_graph_add_sink_component(
1108                 struct bt_graph *graph,
1109                 const struct bt_component_class_sink *comp_cls,
1110                 const char *name, const struct bt_value *params,
1111                 enum bt_logging_level log_level,
1112                 const struct bt_component_sink **component)
1113 {
1114         BT_ASSERT_PRE_NO_ERROR();
1115         return bt_graph_add_sink_component_with_initialize_method_data(
1116                 graph, comp_cls, name, params, NULL, log_level, component);
1117 }
1118
1119 enum bt_graph_add_component_status
1120 bt_graph_add_simple_sink_component(struct bt_graph *graph, const char *name,
1121                 bt_graph_simple_sink_component_initialize_func init_func,
1122                 bt_graph_simple_sink_component_consume_func consume_func,
1123                 bt_graph_simple_sink_component_finalize_func finalize_func,
1124                 void *user_data, const bt_component_sink **component)
1125 {
1126         enum bt_graph_add_component_status status;
1127         struct bt_component_class_sink *comp_cls;
1128         struct simple_sink_init_method_data init_method_data = {
1129                 .init_func = init_func,
1130                 .consume_func = consume_func,
1131                 .finalize_func = finalize_func,
1132                 .user_data = user_data,
1133         };
1134
1135         BT_ASSERT_PRE_NO_ERROR();
1136
1137         /*
1138          * Other preconditions are checked by
1139          * bt_graph_add_sink_component_with_init_method_data().
1140          */
1141         BT_ASSERT_PRE_NON_NULL(consume_func, "Consume function");
1142
1143         comp_cls = bt_component_class_sink_simple_borrow();
1144         if (!comp_cls) {
1145                 BT_LIB_LOGE_APPEND_CAUSE(
1146                         "Cannot borrow simple sink component class.");
1147                 status = BT_FUNC_STATUS_MEMORY_ERROR;
1148                 goto end;
1149         }
1150
1151         status = bt_graph_add_sink_component_with_initialize_method_data(graph,
1152                 comp_cls, name, NULL, &init_method_data,
1153                 BT_LOGGING_LEVEL_NONE, component);
1154
1155 end:
1156         return status;
1157 }
1158
1159 BT_HIDDEN
1160 void bt_graph_add_message(struct bt_graph *graph,
1161                 struct bt_message *msg)
1162 {
1163         BT_ASSERT(graph);
1164         BT_ASSERT(msg);
1165
1166         /*
1167          * It's okay not to take a reference because, when a
1168          * message's reference count drops to 0, either:
1169          *
1170          * * It is recycled back to one of this graph's pool.
1171          * * It is destroyed because it doesn't have any link to any
1172          *   graph, which means the original graph is already destroyed.
1173          */
1174         g_ptr_array_add(graph->messages, msg);
1175 }
1176
1177 BT_HIDDEN
1178 bool bt_graph_is_interrupted(const struct bt_graph *graph)
1179 {
1180         BT_ASSERT_DBG(graph);
1181         return bt_interrupter_array_any_is_set(graph->interrupters);
1182 }
1183
1184 enum bt_graph_add_interrupter_status bt_graph_add_interrupter(
1185                 struct bt_graph *graph, const struct bt_interrupter *intr)
1186 {
1187         BT_ASSERT_PRE_NO_ERROR();
1188         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
1189         BT_ASSERT_PRE_NON_NULL(intr, "Interrupter");
1190         g_ptr_array_add(graph->interrupters, (void *) intr);
1191         bt_object_get_ref_no_null_check(intr);
1192         BT_LIB_LOGD("Added interrupter to graph: %![graph-]+g, %![intr-]+z",
1193                 graph, intr);
1194         return BT_FUNC_STATUS_OK;
1195 }
1196
1197 void bt_graph_interrupt(struct bt_graph *graph)
1198 {
1199         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
1200         bt_interrupter_set(graph->default_interrupter);
1201         BT_LIB_LOGI("Interrupted graph: %!+g", graph);
1202 }
1203
1204 void bt_graph_get_ref(const struct bt_graph *graph)
1205 {
1206         bt_object_get_ref(graph);
1207 }
1208
1209 void bt_graph_put_ref(const struct bt_graph *graph)
1210 {
1211         bt_object_put_ref(graph);
1212 }