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         }
 437
 438 end:
 439         if (status != BT_FUNC_STATUS_OK) {
 440                 bt_graph_make_faulty(graph);
 441         }
 442
 443         bt_object_put_ref(connection);
 444         (void) init_can_consume;
 445         bt_graph_set_can_consume(graph, init_can_consume);
 446         return status;
 447 }
 448
 449 static inline
 450 int consume_graph_sink(struct bt_component_sink *comp)
 451 {
 452         enum bt_component_class_sink_consume_method_status consume_status;
 453         struct bt_component_class_sink *sink_class = NULL;
 454
 455         BT_ASSERT_DBG(comp);
 456         sink_class = (void *) comp->parent.class;
 457         BT_ASSERT_DBG(sink_class->methods.consume);
 458         BT_LIB_LOGD("Calling user's consume method: %!+c", comp);
 459         consume_status = sink_class->methods.consume((void *) comp);
 460         BT_LOGD("User method returned: status=%s",
 461                 bt_common_func_status_string(consume_status));
 462         BT_ASSERT_POST_DEV(consume_status == BT_FUNC_STATUS_OK ||
 463                 consume_status == BT_FUNC_STATUS_END ||
 464                 consume_status == BT_FUNC_STATUS_AGAIN ||
 465                 consume_status == BT_FUNC_STATUS_ERROR ||
 466                 consume_status == BT_FUNC_STATUS_MEMORY_ERROR,
 467                 "Invalid component status returned by consuming method: "
 468                 "status=%s", bt_common_func_status_string(consume_status));
 469         BT_ASSERT_POST_DEV_NO_ERROR_IF_NO_ERROR_STATUS(consume_status);
 470         if (consume_status) {
 471                 if (consume_status < 0) {
 472                         BT_LIB_LOGW_APPEND_CAUSE(
 473                                 "Component's \"consume\" method failed: "
 474                                 "status=%s, %![comp-]+c",
 475                                 bt_common_func_status_string(consume_status),
 476                                 comp);
 477                 }
 478
 479                 goto end;
 480         }
 481
 482         BT_LIB_LOGD("Consumed from sink: %![comp-]+c, status=%s",
 483                 comp, bt_common_func_status_string(consume_status));
 484
 485 end:
 486         return consume_status;
 487 }
 488
 489 /*
 490  * `node` is removed from the queue of sinks to consume when passed to
 491  * this function. This function adds it back to the queue if there's
 492  * still something to consume afterwards.
 493  */
 494 static inline
 495 int consume_sink_node(struct bt_graph *graph, GList *node)
 496 {
 497         int status;
 498         struct bt_component_sink *sink;
 499
 500         sink = node->data;
 501         status = consume_graph_sink(sink);
 502         if (G_UNLIKELY(status != BT_FUNC_STATUS_END)) {
 503                 g_queue_push_tail_link(graph->sinks_to_consume, node);
 504                 goto end;
 505         }
 506
 507         /* End reached, the node is not added back to the queue and free'd. */
 508         g_queue_delete_link(graph->sinks_to_consume, node);
 509
 510         /* Don't forward an END status if there are sinks left to consume. */
 511         if (!g_queue_is_empty(graph->sinks_to_consume)) {
 512                 status = BT_FUNC_STATUS_OK;
 513                 goto end;
 514         }
 515
 516 end:
 517         BT_LIB_LOGD("Consumed sink node: %![comp-]+c, status=%s",
 518                 sink, bt_common_func_status_string(status));
 519         return status;
 520 }
 521
 522 BT_HIDDEN
 523 int bt_graph_consume_sink_no_check(struct bt_graph *graph,
 524                 struct bt_component_sink *sink)
 525 {
 526         int status;
 527         GList *sink_node;
 528         int index;
 529
 530         BT_LIB_LOGD("Making specific sink consume: %![comp-]+c", sink);
 531         BT_ASSERT_DBG(bt_component_borrow_graph((void *) sink) == graph);
 532
 533         if (g_queue_is_empty(graph->sinks_to_consume)) {
 534                 BT_LOGD_STR("Graph's sink queue is empty: end of graph.");
 535                 status = BT_FUNC_STATUS_END;
 536                 goto end;
 537         }
 538
 539         index = g_queue_index(graph->sinks_to_consume, sink);
 540         if (index < 0) {
 541                 BT_LIB_LOGD("Sink component is not marked as consumable: "
 542                         "component sink is ended: %![comp-]+c", sink);
 543                 status = BT_FUNC_STATUS_END;
 544                 goto end;
 545         }
 546
 547         sink_node = g_queue_pop_nth_link(graph->sinks_to_consume, index);
 548         BT_ASSERT_DBG(sink_node);
 549         status = consume_sink_node(graph, sink_node);
 550
 551 end:
 552         return status;
 553 }
 554
 555 static inline
 556 int consume_no_check(struct bt_graph *graph)
 557 {
 558         int status = BT_FUNC_STATUS_OK;
 559         struct bt_component *sink;
 560         GList *current_node;
 561
 562         BT_ASSERT_PRE_DEV(graph->has_sink,
 563                 "Graph has no sink component: %!+g", graph);
 564         BT_LIB_LOGD("Making next sink component consume: %![graph-]+g", graph);
 565
 566         if (G_UNLIKELY(g_queue_is_empty(graph->sinks_to_consume))) {
 567                 BT_LOGD_STR("Graph's sink queue is empty: end of graph.");
 568                 status = BT_FUNC_STATUS_END;
 569                 goto end;
 570         }
 571
 572         current_node = g_queue_pop_head_link(graph->sinks_to_consume);
 573         sink = current_node->data;
 574         BT_LIB_LOGD("Chose next sink to consume: %!+c", sink);
 575         status = consume_sink_node(graph, current_node);
 576
 577 end:
 578         return status;
 579 }
 580
 581 enum bt_graph_run_once_status bt_graph_run_once(struct bt_graph *graph)
 582 {
 583         enum bt_graph_run_once_status status;
 584
 585         BT_ASSERT_PRE_NO_ERROR();
 586         BT_ASSERT_PRE_DEV_NON_NULL(graph, "Graph");
 587         BT_ASSERT_PRE_DEV(graph->can_consume,
 588                 "Cannot consume graph in its current state: %!+g", graph);
 589         BT_ASSERT_PRE_DEV(graph->config_state !=
 590                 BT_GRAPH_CONFIGURATION_STATE_FAULTY,
 591                 "Graph is in a faulty state: %!+g", graph);
 592         bt_graph_set_can_consume(graph, false);
 593         status = bt_graph_configure(graph);
 594         if (G_UNLIKELY(status)) {
 595                 /* bt_graph_configure() logs errors */
 596                 goto end;
 597         }
 598
 599         status = consume_no_check(graph);
 600         bt_graph_set_can_consume(graph, true);
 601
 602 end:
 603         return status;
 604 }
 605
 606 enum bt_graph_run_status bt_graph_run(struct bt_graph *graph)
 607 {
 608         enum bt_graph_run_status status;
 609
 610         BT_ASSERT_PRE_NO_ERROR();
 611         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
 612         BT_ASSERT_PRE(graph->can_consume,
 613                 "Cannot consume graph in its current state: %!+g", graph);
 614         BT_ASSERT_PRE(graph->config_state != BT_GRAPH_CONFIGURATION_STATE_FAULTY,
 615                 "Graph is in a faulty state: %!+g", graph);
 616         bt_graph_set_can_consume(graph, false);
 617         status = bt_graph_configure(graph);
 618         if (G_UNLIKELY(status)) {
 619                 /* bt_graph_configure() logs errors */
 620                 goto end;
 621         }
 622
 623         BT_LIB_LOGI("Running graph: %!+g", graph);
 624
 625         do {
 626                 /*
 627                  * Check if the graph is interrupted at each iteration.
 628                  * If the graph was interrupted by another thread or by
 629                  * a signal handler, this is NOT a warning nor an error;
 630                  * it was intentional: log with an INFO level only.
 631                  */
 632                 if (G_UNLIKELY(bt_graph_is_interrupted(graph))) {
 633                         BT_LIB_LOGI("Stopping the graph: "
 634                                 "graph was interrupted: %!+g", graph);
 635                         status = BT_FUNC_STATUS_AGAIN;
 636                         goto end;
 637                 }
 638
 639                 status = consume_no_check(graph);
 640                 if (G_UNLIKELY(status == BT_FUNC_STATUS_AGAIN)) {
 641                         /*
 642                          * If AGAIN is received and there are multiple
 643                          * sinks, go ahead and consume from the next
 644                          * sink.
 645                          *
 646                          * However, in the case where a single sink is
 647                          * left, the caller can decide to busy-wait and
 648                          * call bt_graph_run() continuously
 649                          * until the source is ready or it can decide to
 650                          * sleep for an arbitrary amount of time.
 651                          */
 652                         if (graph->sinks_to_consume->length > 1) {
 653                                 status = BT_FUNC_STATUS_OK;
 654                         }
 655                 }
 656         } while (status == BT_FUNC_STATUS_OK);
 657
 658         if (status == BT_FUNC_STATUS_END) {
 659                 /*
 660                  * The last call to consume_no_check() returned
 661                  * `BT_FUNC_STATUS_END`, but bt_graph_run() has no
 662                  * `BT_GRAPH_RUN_STATUS_END` status: replace with
 663                  * `BT_GRAPH_RUN_STATUS_OK` (success: graph ran
 664                  * completely).
 665                  */
 666                 status = BT_FUNC_STATUS_OK;
 667         }
 668
 669 end:
 670         BT_LIB_LOGI("Graph ran: %![graph-]+g, status=%s", graph,
 671                 bt_common_func_status_string(status));
 672         bt_graph_set_can_consume(graph, true);
 673         return status;
 674 }
 675
 676 enum bt_graph_add_listener_status
 677 bt_graph_add_source_component_output_port_added_listener(
 678                 struct bt_graph *graph,
 679                 bt_graph_source_component_output_port_added_listener_func func,
 680                 void *data, bt_listener_id *out_listener_id)
 681 {
 682         struct bt_graph_listener_port_added listener = {
 683                 .func = (port_added_func_t) func,
 684                 .data = data,
 685         };
 686         bt_listener_id listener_id;
 687
 688         BT_ASSERT_PRE_NO_ERROR();
 689         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
 690         BT_ASSERT_PRE_NON_NULL(func, "Listener");
 691         g_array_append_val(graph->listeners.source_output_port_added, listener);
 692         listener_id = graph->listeners.source_output_port_added->len - 1;
 693         BT_LIB_LOGD("Added \"source component output port added\" listener to graph: "
 694                 "%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
 695                 listener_id);
 696
 697         if (listener_id) {
 698                 *out_listener_id = listener_id;
 699         }
 700
 701         return BT_FUNC_STATUS_OK;
 702 }
 703
 704 enum bt_graph_add_listener_status
 705 bt_graph_add_filter_component_output_port_added_listener(
 706                 struct bt_graph *graph,
 707                 bt_graph_filter_component_output_port_added_listener_func func,
 708                 void *data, bt_listener_id *out_listener_id)
 709 {
 710         struct bt_graph_listener_port_added listener = {
 711                 .func = (port_added_func_t) func,
 712                 .data = data,
 713         };
 714         bt_listener_id listener_id;
 715
 716         BT_ASSERT_PRE_NO_ERROR();
 717         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
 718         BT_ASSERT_PRE_NON_NULL(func, "Listener");
 719         g_array_append_val(graph->listeners.filter_output_port_added, listener);
 720         listener_id = graph->listeners.filter_output_port_added->len - 1;
 721         BT_LIB_LOGD("Added \"filter component output port added\" listener to graph: "
 722                 "%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
 723                 listener_id);
 724
 725         if (listener_id) {
 726                 *out_listener_id = listener_id;
 727         }
 728
 729         return BT_FUNC_STATUS_OK;
 730 }
 731
 732 enum bt_graph_add_listener_status
 733 bt_graph_add_filter_component_input_port_added_listener(
 734                 struct bt_graph *graph,
 735                 bt_graph_filter_component_input_port_added_listener_func func,
 736                 void *data, bt_listener_id *out_listener_id)
 737 {
 738         struct bt_graph_listener_port_added listener = {
 739                 .func = (port_added_func_t) func,
 740                 .data = data,
 741         };
 742         bt_listener_id listener_id;
 743
 744         BT_ASSERT_PRE_NO_ERROR();
 745         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
 746         BT_ASSERT_PRE_NON_NULL(func, "Listener");
 747         g_array_append_val(graph->listeners.filter_input_port_added, listener);
 748         listener_id = graph->listeners.filter_input_port_added->len - 1;
 749         BT_LIB_LOGD("Added \"filter component input port added\" listener to graph: "
 750                 "%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
 751                 listener_id);
 752
 753         if (listener_id) {
 754                 *out_listener_id = listener_id;
 755         }
 756
 757         return BT_FUNC_STATUS_OK;
 758 }
 759
 760 enum bt_graph_add_listener_status
 761 bt_graph_add_sink_component_input_port_added_listener(
 762                 struct bt_graph *graph,
 763                 bt_graph_sink_component_input_port_added_listener_func func,
 764                 void *data, bt_listener_id *out_listener_id)
 765 {
 766         struct bt_graph_listener_port_added listener = {
 767                 .func = (port_added_func_t) func,
 768                 .data = data,
 769         };
 770         bt_listener_id listener_id;
 771
 772         BT_ASSERT_PRE_NO_ERROR();
 773         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
 774         BT_ASSERT_PRE_NON_NULL(func, "Listener");
 775         g_array_append_val(graph->listeners.sink_input_port_added, listener);
 776         listener_id = graph->listeners.sink_input_port_added->len - 1;
 777         BT_LIB_LOGD("Added \"sink component input port added\" listener to graph: "
 778                 "%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
 779                 listener_id);
 780
 781         if (listener_id) {
 782                 *out_listener_id = listener_id;
 783         }
 784
 785         return BT_FUNC_STATUS_OK;
 786 }
 787
 788 BT_HIDDEN
 789 enum bt_graph_listener_func_status bt_graph_notify_port_added(
 790                 struct bt_graph *graph, struct bt_port *port)
 791 {
 792         uint64_t i;
 793         GArray *listeners;
 794         struct bt_component *comp;
 795         enum bt_graph_listener_func_status status = BT_FUNC_STATUS_OK;
 796
 797         BT_ASSERT(graph);
 798         BT_ASSERT(port);
 799         BT_LIB_LOGD("Notifying graph listeners that a port was added: "
 800                 "%![graph-]+g, %![port-]+p", graph, port);
 801         comp = bt_port_borrow_component_inline(port);
 802         BT_ASSERT(comp);
 803
 804         switch (comp->class->type) {
 805         case BT_COMPONENT_CLASS_TYPE_SOURCE:
 806         {
 807                 switch (port->type) {
 808                 case BT_PORT_TYPE_OUTPUT:
 809                         listeners = graph->listeners.source_output_port_added;
 810                         break;
 811                 default:
 812                         bt_common_abort();
 813                 }
 814
 815                 break;
 816         }
 817         case BT_COMPONENT_CLASS_TYPE_FILTER:
 818         {
 819                 switch (port->type) {
 820                 case BT_PORT_TYPE_INPUT:
 821                         listeners = graph->listeners.filter_input_port_added;
 822                         break;
 823                 case BT_PORT_TYPE_OUTPUT:
 824                         listeners = graph->listeners.filter_output_port_added;
 825                         break;
 826                 default:
 827                         bt_common_abort();
 828                 }
 829
 830                 break;
 831         }
 832         case BT_COMPONENT_CLASS_TYPE_SINK:
 833         {
 834                 switch (port->type) {
 835                 case BT_PORT_TYPE_INPUT:
 836                         listeners = graph->listeners.sink_input_port_added;
 837                         break;
 838                 default:
 839                         bt_common_abort();
 840                 }
 841
 842                 break;
 843         }
 844         default:
 845                 bt_common_abort();
 846         }
 847
 848         for (i = 0; i < listeners->len; i++) {
 849                 struct bt_graph_listener_port_added *listener =
 850                         &g_array_index(listeners,
 851                                 struct bt_graph_listener_port_added, i);
 852
 853
 854                 BT_ASSERT(listener->func);
 855                 status = listener->func(comp, port, listener->data);
 856                 BT_ASSERT_POST_NO_ERROR_IF_NO_ERROR_STATUS(status);
 857                 if (status != BT_FUNC_STATUS_OK) {
 858                         goto end;
 859                 }
 860         }
 861
 862 end:
 863         return status;
 864 }
 865
 866 BT_HIDDEN
 867 void bt_graph_remove_connection(struct bt_graph *graph,
 868                 struct bt_connection *connection)
 869 {
 870         BT_ASSERT(graph);
 871         BT_ASSERT(connection);
 872         BT_LIB_LOGD("Removing graph's connection: %![graph-]+g, %![conn-]+x",
 873                 graph, connection);
 874         g_ptr_array_remove(graph->connections, connection);
 875 }
 876
 877 static inline
 878 bool component_name_exists(struct bt_graph *graph, const char *name)
 879 {
 880         bool exists = false;
 881         uint64_t i;
 882
 883         for (i = 0; i < graph->components->len; i++) {
 884                 struct bt_component *other_comp = graph->components->pdata[i];
 885
 886                 if (strcmp(name, bt_component_get_name(other_comp)) == 0) {
 887                         BT_ASSERT_PRE_MSG("Another component with the same name already exists in the graph: "
 888                                 "%![other-comp-]+c, name=\"%s\"",
 889                                 other_comp, name);
 890                         exists = true;
 891                         goto end;
 892                 }
 893         }
 894
 895 end:
 896         return exists;
 897 }
 898
 899 static
 900 int add_component_with_init_method_data(
 901                 struct bt_graph *graph,
 902                 struct bt_component_class *comp_cls,
 903                 comp_init_method_t init_method,
 904                 const char *name, const struct bt_value *params,
 905                 void *init_method_data, bt_logging_level log_level,
 906                 const struct bt_component **user_component)
 907 {
 908         int status = BT_FUNC_STATUS_OK;
 909         enum bt_component_class_initialize_method_status init_status;
 910         struct bt_component *component = NULL;
 911         int ret;
 912         bool init_can_consume;
 913         struct bt_value *new_params = NULL;
 914
 915         BT_ASSERT(comp_cls);
 916         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
 917         BT_ASSERT_PRE_NON_NULL(name, "Name");
 918         BT_ASSERT_PRE(
 919                 graph->config_state == BT_GRAPH_CONFIGURATION_STATE_CONFIGURING,
 920                 "Graph is not in the \"configuring\" state: %!+g", graph);
 921         BT_ASSERT_PRE(!component_name_exists(graph, name),
 922                 "Duplicate component name: %!+g, name=\"%s\"", graph, name);
 923         BT_ASSERT_PRE(!params || bt_value_is_map(params),
 924                 "Parameter value is not a map value: %!+v", params);
 925         init_can_consume = graph->can_consume;
 926         bt_graph_set_can_consume(graph, false);
 927         BT_LIB_LOGI("Adding component to graph: "
 928                 "%![graph-]+g, %![cc-]+C, name=\"%s\", log-level=%s, "
 929                 "%![params-]+v, init-method-data-addr=%p",
 930                 graph, comp_cls, name,
 931                 bt_common_logging_level_string(log_level), params,
 932                 init_method_data);
 933
 934         if (!params) {
 935                 new_params = bt_value_map_create();
 936                 if (!new_params) {
 937                         BT_LIB_LOGE_APPEND_CAUSE(
 938                                 "Cannot create empty map value object.");
 939                         status = BT_FUNC_STATUS_MEMORY_ERROR;
 940                         goto end;
 941                 }
 942
 943                 params = new_params;
 944         }
 945
 946         ret = bt_component_create(comp_cls, name, log_level, &component);
 947         if (ret) {
 948                 BT_LIB_LOGE_APPEND_CAUSE(
 949                         "Cannot create empty component object: ret=%d",
 950                         ret);
 951                 status = BT_FUNC_STATUS_MEMORY_ERROR;
 952                 goto end;
 953         }
 954
 955         /*
 956          * The user's initialization method needs to see that this
 957          * component is part of the graph. If the user method fails, we
 958          * immediately remove the component from the graph's components.
 959          */
 960         g_ptr_array_add(graph->components, component);
 961         bt_component_set_graph(component, graph);
 962         bt_value_freeze(params);
 963
 964         if (init_method) {
 965                 /*
 966                  * There is no use for config objects right now, so just pass
 967                  * NULL.
 968                  */
 969                 BT_LOGD_STR("Calling user's initialization method.");
 970                 init_status = init_method(component, NULL, params, init_method_data);
 971                 BT_LOGD("User method returned: status=%s",
 972                         bt_common_func_status_string(init_status));
 973                 BT_ASSERT_POST_DEV_NO_ERROR_IF_NO_ERROR_STATUS(init_status);
 974                 if (init_status != BT_FUNC_STATUS_OK) {
 975                         if (init_status < 0) {
 976                                 BT_LIB_LOGW_APPEND_CAUSE(
 977                                         "Component initialization method failed: "
 978                                         "status=%s, %![comp-]+c",
 979                                         bt_common_func_status_string(init_status),
 980                                         component);
 981                         }
 982
 983                         status = init_status;
 984                         bt_component_set_graph(component, NULL);
 985                         g_ptr_array_remove_fast(graph->components, component);
 986                         goto end;
 987                 }
 988         }
 989
 990         /*
 991          * Mark the component as initialized so that its finalization
 992          * method is called when it is destroyed.
 993          */
 994         component->initialized = true;
 995
 996         /*
 997          * If it's a sink component, it needs to be part of the graph's
 998          * sink queue to be consumed by bt_graph_run() or
 999          * bt_graph_run_once().
1000          */
1001         if (bt_component_is_sink(component)) {
1002                 graph->has_sink = true;
1003                 g_queue_push_tail(graph->sinks_to_consume, component);
1004         }
1005
1006         /*
1007          * Freeze the component class now that it's instantiated at
1008          * least once.
1009          */
1010         BT_LOGD_STR("Freezing component class.");
1011         bt_component_class_freeze(comp_cls);
1012         BT_LIB_LOGI("Added component to graph: "
1013                 "%![graph-]+g, %![cc-]+C, name=\"%s\", log-level=%s, "
1014                 "%![params-]+v, init-method-data-addr=%p, %![comp-]+c",
1015                 graph, comp_cls, name,
1016                 bt_common_logging_level_string(log_level), params,
1017                 init_method_data, component);
1018
1019         if (user_component) {
1020                 /* Move reference to user */
1021                 *user_component = component;
1022         }
1023
1024 end:
1025         if (status != BT_FUNC_STATUS_OK) {
1026                 bt_graph_make_faulty(graph);
1027         }
1028
1029         bt_object_put_ref(component);
1030         bt_object_put_ref(new_params);
1031         (void) init_can_consume;
1032         bt_graph_set_can_consume(graph, init_can_consume);
1033         return status;
1034 }
1035
1036 enum bt_graph_add_component_status
1037 bt_graph_add_source_component_with_initialize_method_data(
1038                 struct bt_graph *graph,
1039                 const struct bt_component_class_source *comp_cls,
1040                 const char *name, const struct bt_value *params,
1041                 void *init_method_data, bt_logging_level log_level,
1042                 const struct bt_component_source **component)
1043 {
1044         BT_ASSERT_PRE_NO_ERROR();
1045         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
1046         return add_component_with_init_method_data(graph,
1047                 (void *) comp_cls, (comp_init_method_t) comp_cls->methods.init,
1048                 name, params, init_method_data, log_level, (void *) component);
1049 }
1050
1051 enum bt_graph_add_component_status bt_graph_add_source_component(
1052                 struct bt_graph *graph,
1053                 const struct bt_component_class_source *comp_cls,
1054                 const char *name, const struct bt_value *params,
1055                 enum bt_logging_level log_level,
1056                 const struct bt_component_source **component)
1057 {
1058         BT_ASSERT_PRE_NO_ERROR();
1059         return bt_graph_add_source_component_with_initialize_method_data(
1060                 graph, comp_cls, name, params, NULL, log_level, component);
1061 }
1062
1063 enum bt_graph_add_component_status
1064 bt_graph_add_filter_component_with_initialize_method_data(
1065                 struct bt_graph *graph,
1066                 const struct bt_component_class_filter *comp_cls,
1067                 const char *name, const struct bt_value *params,
1068                 void *init_method_data, enum bt_logging_level log_level,
1069                 const struct bt_component_filter **component)
1070 {
1071         BT_ASSERT_PRE_NO_ERROR();
1072         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
1073         return add_component_with_init_method_data(graph,
1074                 (void *) comp_cls, (comp_init_method_t) comp_cls->methods.init,
1075                 name, params, init_method_data, log_level, (void *) component);
1076 }
1077
1078 enum bt_graph_add_component_status bt_graph_add_filter_component(
1079                 struct bt_graph *graph,
1080                 const struct bt_component_class_filter *comp_cls,
1081                 const char *name, const struct bt_value *params,
1082                 enum bt_logging_level log_level,
1083                 const struct bt_component_filter **component)
1084 {
1085         BT_ASSERT_PRE_NO_ERROR();
1086         return bt_graph_add_filter_component_with_initialize_method_data(
1087                 graph, comp_cls, name, params, NULL, log_level, component);
1088 }
1089
1090 enum bt_graph_add_component_status
1091 bt_graph_add_sink_component_with_initialize_method_data(
1092                 struct bt_graph *graph,
1093                 const struct bt_component_class_sink *comp_cls,
1094                 const char *name, const struct bt_value *params,
1095                 void *init_method_data, enum bt_logging_level log_level,
1096                 const struct bt_component_sink **component)
1097 {
1098         BT_ASSERT_PRE_NO_ERROR();
1099         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
1100         return add_component_with_init_method_data(graph,
1101                 (void *) comp_cls, (comp_init_method_t) comp_cls->methods.init,
1102                 name, params, init_method_data, log_level, (void *) component);
1103 }
1104
1105 enum bt_graph_add_component_status bt_graph_add_sink_component(
1106                 struct bt_graph *graph,
1107                 const struct bt_component_class_sink *comp_cls,
1108                 const char *name, const struct bt_value *params,
1109                 enum bt_logging_level log_level,
1110                 const struct bt_component_sink **component)
1111 {
1112         BT_ASSERT_PRE_NO_ERROR();
1113         return bt_graph_add_sink_component_with_initialize_method_data(
1114                 graph, comp_cls, name, params, NULL, log_level, component);
1115 }
1116
1117 enum bt_graph_add_component_status
1118 bt_graph_add_simple_sink_component(struct bt_graph *graph, const char *name,
1119                 bt_graph_simple_sink_component_initialize_func init_func,
1120                 bt_graph_simple_sink_component_consume_func consume_func,
1121                 bt_graph_simple_sink_component_finalize_func finalize_func,
1122                 void *user_data, const bt_component_sink **component)
1123 {
1124         enum bt_graph_add_component_status status;
1125         struct bt_component_class_sink *comp_cls;
1126         struct simple_sink_init_method_data init_method_data = {
1127                 .init_func = init_func,
1128                 .consume_func = consume_func,
1129                 .finalize_func = finalize_func,
1130                 .user_data = user_data,
1131         };
1132
1133         BT_ASSERT_PRE_NO_ERROR();
1134
1135         /*
1136          * Other preconditions are checked by
1137          * bt_graph_add_sink_component_with_init_method_data().
1138          */
1139         BT_ASSERT_PRE_NON_NULL(consume_func, "Consume function");
1140
1141         comp_cls = bt_component_class_sink_simple_borrow();
1142         if (!comp_cls) {
1143                 BT_LIB_LOGE_APPEND_CAUSE(
1144                         "Cannot borrow simple sink component class.");
1145                 status = BT_FUNC_STATUS_MEMORY_ERROR;
1146                 goto end;
1147         }
1148
1149         status = bt_graph_add_sink_component_with_initialize_method_data(graph,
1150                 comp_cls, name, NULL, &init_method_data,
1151                 BT_LOGGING_LEVEL_NONE, component);
1152
1153 end:
1154         return status;
1155 }
1156
1157 BT_HIDDEN
1158 void bt_graph_add_message(struct bt_graph *graph,
1159                 struct bt_message *msg)
1160 {
1161         BT_ASSERT(graph);
1162         BT_ASSERT(msg);
1163
1164         /*
1165          * It's okay not to take a reference because, when a
1166          * message's reference count drops to 0, either:
1167          *
1168          * * It is recycled back to one of this graph's pool.
1169          * * It is destroyed because it doesn't have any link to any
1170          *   graph, which means the original graph is already destroyed.
1171          */
1172         g_ptr_array_add(graph->messages, msg);
1173 }
1174
1175 BT_HIDDEN
1176 bool bt_graph_is_interrupted(const struct bt_graph *graph)
1177 {
1178         BT_ASSERT_DBG(graph);
1179         return bt_interrupter_array_any_is_set(graph->interrupters);
1180 }
1181
1182 enum bt_graph_add_interrupter_status bt_graph_add_interrupter(
1183                 struct bt_graph *graph, const struct bt_interrupter *intr)
1184 {
1185         BT_ASSERT_PRE_NO_ERROR();
1186         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
1187         BT_ASSERT_PRE_NON_NULL(intr, "Interrupter");
1188         g_ptr_array_add(graph->interrupters, (void *) intr);
1189         bt_object_get_ref_no_null_check(intr);
1190         BT_LIB_LOGD("Added interrupter to graph: %![graph-]+g, %![intr-]+z",
1191                 graph, intr);
1192         return BT_FUNC_STATUS_OK;
1193 }
1194
1195 struct bt_interrupter *bt_graph_borrow_default_interrupter(bt_graph *graph)
1196 {
1197         BT_ASSERT_PRE_NON_NULL(graph, "Graph");
1198         return graph->default_interrupter;
1199 }
1200
1201 void bt_graph_get_ref(const struct bt_graph *graph)
1202 {
1203         bt_object_get_ref(graph);
1204 }
1205
1206 void bt_graph_put_ref(const struct bt_graph *graph)
1207 {
1208         bt_object_put_ref(graph);
1209 }