4 * Babeltrace Plugin Component Graph
6 * Copyright 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
7 * Copyright 2017 Philippe Proulx <pproulx@efficios.com>
9 * Permission is hereby granted, free of charge, to any person obtaining a copy
10 * of this software and associated documentation files (the "Software"), to deal
11 * in the Software without restriction, including without limitation the rights
12 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 * copies of the Software, and to permit persons to whom the Software is
14 * furnished to do so, subject to the following conditions:
16 * The above copyright notice and this permission notice shall be included in
17 * all copies or substantial portions of the Software.
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
28 #define BT_LOG_TAG "GRAPH"
29 #include <babeltrace/lib-logging-internal.h>
31 #include <babeltrace/graph/component-internal.h>
32 #include <babeltrace/graph/graph-internal.h>
33 #include <babeltrace/graph/connection-internal.h>
34 #include <babeltrace/graph/component-sink-internal.h>
35 #include <babeltrace/graph/component-source.h>
36 #include <babeltrace/graph/component-filter.h>
37 #include <babeltrace/graph/port.h>
38 #include <babeltrace/graph/notification-internal.h>
39 #include <babeltrace/graph/notification-event-internal.h>
40 #include <babeltrace/graph/notification-packet-internal.h>
41 #include <babeltrace/compiler-internal.h>
42 #include <babeltrace/types.h>
43 #include <babeltrace/values.h>
44 #include <babeltrace/values-internal.h>
45 #include <babeltrace/assert-internal.h>
46 #include <babeltrace/assert-pre-internal.h>
50 struct bt_graph_listener
{
52 bt_graph_listener_removed removed
;
57 int init_listeners_array(GArray
**listeners
)
62 *listeners
= g_array_new(FALSE
, TRUE
, sizeof(struct bt_graph_listener
));
64 BT_LOGE_STR("Failed to allocate one GArray.");
74 void call_remove_listeners(GArray
*listeners
)
78 for (i
= 0; i
< listeners
->len
; i
++) {
79 struct bt_graph_listener listener
=
80 g_array_index(listeners
, struct bt_graph_listener
, i
);
82 if (listener
.removed
) {
83 listener
.removed(listener
.data
);
89 void bt_graph_destroy(struct bt_object
*obj
)
91 struct bt_graph
*graph
= container_of(obj
,
92 struct bt_graph
, base
);
95 * The graph's reference count is 0 if we're here. Increment
96 * it to avoid a double-destroy (possibly infinitely recursive)
99 * 1. We put and destroy a connection.
100 * 2. This connection's destructor finalizes its active
101 * notification iterators.
102 * 3. A notification iterator's finalization function gets a
103 * new reference on its component (reference count goes from
105 * 4. Since this component's reference count goes to 1, it takes
106 * a reference on its parent (this graph). This graph's
107 * reference count goes from 0 to 1.
108 * 5. The notification iterator's finalization function puts its
109 * component reference (reference count goes from 1 to 0).
110 * 6. Since this component's reference count goes from 1 to 0,
111 * it puts its parent (this graph). This graph's reference
112 * count goes from 1 to 0.
113 * 7. Since this graph's reference count goes from 1 to 0,
114 * its destructor is called (this function).
116 * With the incrementation below, the graph's reference count at
117 * step 4 goes from 1 to 2, and from 2 to 1 at step 6. This
118 * ensures that this function is not called two times.
120 BT_LOGD("Destroying graph: addr=%p", graph
);
124 * Cancel the graph to disallow some operations, like creating
125 * notification iterators and adding ports to components.
127 (void) bt_graph_cancel(graph
);
129 /* Call all remove listeners */
130 call_remove_listeners(graph
->listeners
.port_added
);
131 call_remove_listeners(graph
->listeners
.port_removed
);
132 call_remove_listeners(graph
->listeners
.ports_connected
);
133 call_remove_listeners(graph
->listeners
.ports_disconnected
);
135 if (graph
->notifications
) {
136 g_ptr_array_free(graph
->notifications
, TRUE
);
139 if (graph
->connections
) {
140 BT_LOGD_STR("Destroying connections.");
141 g_ptr_array_free(graph
->connections
, TRUE
);
144 if (graph
->components
) {
145 BT_LOGD_STR("Destroying components.");
146 g_ptr_array_free(graph
->components
, TRUE
);
149 if (graph
->sinks_to_consume
) {
150 g_queue_free(graph
->sinks_to_consume
);
153 if (graph
->listeners
.port_added
) {
154 g_array_free(graph
->listeners
.port_added
, TRUE
);
157 if (graph
->listeners
.port_removed
) {
158 g_array_free(graph
->listeners
.port_removed
, TRUE
);
161 if (graph
->listeners
.ports_connected
) {
162 g_array_free(graph
->listeners
.ports_connected
, TRUE
);
165 if (graph
->listeners
.ports_disconnected
) {
166 g_array_free(graph
->listeners
.ports_disconnected
, TRUE
);
169 bt_object_pool_finalize(&graph
->event_notif_pool
);
170 bt_object_pool_finalize(&graph
->packet_begin_notif_pool
);
171 bt_object_pool_finalize(&graph
->packet_end_notif_pool
);
176 void destroy_notification_event(struct bt_notification
*notif
,
177 struct bt_graph
*graph
)
179 bt_notification_event_destroy(notif
);
183 void destroy_notification_packet_begin(struct bt_notification
*notif
,
184 struct bt_graph
*graph
)
186 bt_notification_packet_begin_destroy(notif
);
190 void destroy_notification_packet_end(struct bt_notification
*notif
,
191 struct bt_graph
*graph
)
193 bt_notification_packet_end_destroy(notif
);
197 void notify_notification_graph_is_destroyed(struct bt_notification
*notif
)
199 bt_notification_unlink_graph(notif
);
202 struct bt_graph
*bt_graph_create(void)
204 struct bt_graph
*graph
;
207 BT_LOGD_STR("Creating graph object.");
208 graph
= g_new0(struct bt_graph
, 1);
210 BT_LOGE_STR("Failed to allocate one graph.");
214 bt_object_init_shared(&graph
->base
, bt_graph_destroy
);
215 graph
->connections
= g_ptr_array_new_with_free_func(
216 (GDestroyNotify
) bt_object_try_spec_release
);
217 if (!graph
->connections
) {
218 BT_LOGE_STR("Failed to allocate one GPtrArray.");
221 graph
->components
= g_ptr_array_new_with_free_func(
222 (GDestroyNotify
) bt_object_try_spec_release
);
223 if (!graph
->components
) {
224 BT_LOGE_STR("Failed to allocate one GPtrArray.");
227 graph
->sinks_to_consume
= g_queue_new();
228 if (!graph
->sinks_to_consume
) {
229 BT_LOGE_STR("Failed to allocate one GQueue.");
233 bt_graph_set_can_consume(graph
, BT_TRUE
);
234 ret
= init_listeners_array(&graph
->listeners
.port_added
);
236 BT_LOGE_STR("Cannot create the \"port added\" listener array.");
240 ret
= init_listeners_array(&graph
->listeners
.port_removed
);
242 BT_LOGE_STR("Cannot create the \"port removed\" listener array.");
246 ret
= init_listeners_array(&graph
->listeners
.ports_connected
);
248 BT_LOGE_STR("Cannot create the \"port connected\" listener array.");
252 ret
= init_listeners_array(&graph
->listeners
.ports_disconnected
);
254 BT_LOGE_STR("Cannot create the \"port disconneted\" listener array.");
258 ret
= bt_object_pool_initialize(&graph
->event_notif_pool
,
259 (bt_object_pool_new_object_func
) bt_notification_event_new
,
260 (bt_object_pool_destroy_object_func
) destroy_notification_event
,
263 BT_LOGE("Failed to initialize event notification pool: ret=%d",
268 ret
= bt_object_pool_initialize(&graph
->packet_begin_notif_pool
,
269 (bt_object_pool_new_object_func
) bt_notification_packet_begin_new
,
270 (bt_object_pool_destroy_object_func
) destroy_notification_packet_begin
,
273 BT_LOGE("Failed to initialize packet beginning notification pool: ret=%d",
278 ret
= bt_object_pool_initialize(&graph
->packet_end_notif_pool
,
279 (bt_object_pool_new_object_func
) bt_notification_packet_end_new
,
280 (bt_object_pool_destroy_object_func
) destroy_notification_packet_end
,
283 BT_LOGE("Failed to initialize packet end notification pool: ret=%d",
288 graph
->notifications
= g_ptr_array_new_with_free_func(
289 (GDestroyNotify
) notify_notification_graph_is_destroyed
);
290 BT_LOGD("Created graph object: addr=%p", graph
);
299 enum bt_graph_status
bt_graph_connect_ports(struct bt_graph
*graph
,
300 struct bt_port
*upstream_port
, struct bt_port
*downstream_port
,
301 struct bt_connection
**user_connection
)
303 enum bt_graph_status status
= BT_GRAPH_STATUS_OK
;
304 struct bt_connection
*connection
= NULL
;
305 struct bt_graph
*upstream_graph
= NULL
;
306 struct bt_graph
*downstream_graph
= NULL
;
307 struct bt_component
*upstream_component
= NULL
;
308 struct bt_component
*downstream_component
= NULL
;
309 enum bt_component_status component_status
;
310 bt_bool init_can_consume
;
313 BT_LOGW_STR("Invalid parameter: graph is NULL.");
314 status
= BT_GRAPH_STATUS_INVALID
;
317 init_can_consume
= graph
->can_consume
;
319 if (!upstream_port
) {
320 BT_LOGW_STR("Invalid parameter: upstream port is NULL.");
321 status
= BT_GRAPH_STATUS_INVALID
;
325 if (!downstream_port
) {
326 BT_LOGW_STR("Invalid parameter: downstream port is NULL.");
327 status
= BT_GRAPH_STATUS_INVALID
;
331 BT_LOGD("Connecting component ports within graph: "
333 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
334 "downstream-port-addr=%p, downstream-port-name=\"%s\"",
335 graph
, upstream_port
, bt_port_get_name(upstream_port
),
336 downstream_port
, bt_port_get_name(downstream_port
));
338 if (graph
->canceled
) {
339 BT_LOGW_STR("Invalid parameter: graph is canceled.");
340 status
= BT_GRAPH_STATUS_CANCELED
;
344 bt_graph_set_can_consume(graph
, BT_FALSE
);
346 /* Ensure appropriate types for upstream and downstream ports. */
347 if (bt_port_get_type(upstream_port
) != BT_PORT_TYPE_OUTPUT
) {
348 BT_LOGW_STR("Invalid parameter: upstream port is not an output port.");
349 status
= BT_GRAPH_STATUS_INVALID
;
352 if (bt_port_get_type(downstream_port
) != BT_PORT_TYPE_INPUT
) {
353 BT_LOGW_STR("Invalid parameter: downstream port is not an input port.");
354 status
= BT_GRAPH_STATUS_INVALID
;
358 /* Ensure that both ports are currently unconnected. */
359 if (bt_port_is_connected(upstream_port
)) {
360 BT_LOGW_STR("Invalid parameter: upstream port is already connected.");
361 status
= BT_GRAPH_STATUS_INVALID
;
365 if (bt_port_is_connected(downstream_port
)) {
366 BT_LOGW_STR("Invalid parameter: downstream port is already connected.");
367 status
= BT_GRAPH_STATUS_INVALID
;
372 * Ensure that both ports are still attached to their creating
375 upstream_component
= bt_port_get_component(upstream_port
);
376 if (!upstream_component
) {
377 BT_LOGW_STR("Invalid parameter: upstream port is loose (does not belong to a component)");
378 status
= BT_GRAPH_STATUS_INVALID
;
382 downstream_component
= bt_port_get_component(downstream_port
);
383 if (!downstream_component
) {
384 BT_LOGW_STR("Invalid parameter: downstream port is loose (does not belong to a component)");
385 status
= BT_GRAPH_STATUS_INVALID
;
389 BT_LOGD("Connecting component ports: "
390 "upstream-comp-addr=%p, upstream-comp-name=\"%s\", "
391 "downstream-comp-addr=%p, downstream-comp-name=\"%s\"",
392 upstream_component
, bt_component_get_name(upstream_component
),
393 downstream_component
, bt_component_get_name(downstream_component
));
396 * At this point the ports are not connected yet. Both
397 * components need to accept an eventual connection to their
398 * port by the other port before we continue.
400 BT_LOGD_STR("Asking upstream component to accept the connection.");
401 component_status
= bt_component_accept_port_connection(
402 upstream_component
, upstream_port
, downstream_port
);
403 if (component_status
!= BT_COMPONENT_STATUS_OK
) {
404 if (component_status
== BT_COMPONENT_STATUS_REFUSE_PORT_CONNECTION
) {
405 BT_LOGD_STR("Upstream component refused the connection.");
407 BT_LOGW("Cannot ask upstream component to accept the connection: "
408 "status=%s", bt_component_status_string(component_status
));
411 status
= bt_graph_status_from_component_status(
416 BT_LOGD_STR("Asking downstream component to accept the connection.");
417 component_status
= bt_component_accept_port_connection(
418 downstream_component
, downstream_port
, upstream_port
);
419 if (component_status
!= BT_COMPONENT_STATUS_OK
) {
420 if (component_status
== BT_COMPONENT_STATUS_REFUSE_PORT_CONNECTION
) {
421 BT_LOGD_STR("Downstream component refused the connection.");
423 BT_LOGW("Cannot ask downstream component to accept the connection: "
424 "status=%s", bt_component_status_string(component_status
));
427 status
= bt_graph_status_from_component_status(
432 BT_LOGD_STR("Creating connection.");
433 connection
= bt_connection_create(graph
, upstream_port
,
436 BT_LOGW("Cannot create connection object.");
437 status
= BT_GRAPH_STATUS_NOMEM
;
441 BT_LOGD("Connection object created: conn-addr=%p", connection
);
444 * Ownership of upstream_component/downstream_component and of
445 * the connection object is transferred to the graph.
447 g_ptr_array_add(graph
->connections
, connection
);
450 * Notify both components that their port is connected.
452 BT_LOGD_STR("Notifying upstream component that its port is connected.");
453 bt_component_port_connected(upstream_component
, upstream_port
,
455 BT_LOGD_STR("Notifying downstream component that its port is connected.");
456 bt_component_port_connected(downstream_component
, downstream_port
,
460 * Notify the graph's creator that both ports are connected.
462 BT_LOGD_STR("Notifying graph's user that new component ports are connected.");
463 bt_graph_notify_ports_connected(graph
, upstream_port
, downstream_port
);
464 BT_LOGD("Connected component ports within graph: "
466 "upstream-comp-addr=%p, upstream-comp-name=\"%s\", "
467 "downstream-comp-addr=%p, downstream-comp-name=\"%s\", "
468 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
469 "downstream-port-addr=%p, downstream-port-name=\"%s\"",
471 upstream_component
, bt_component_get_name(upstream_component
),
472 downstream_component
, bt_component_get_name(downstream_component
),
473 upstream_port
, bt_port_get_name(upstream_port
),
474 downstream_port
, bt_port_get_name(downstream_port
));
476 if (user_connection
) {
477 /* Move reference to user */
478 *user_connection
= connection
;
483 bt_put(upstream_graph
);
484 bt_put(downstream_graph
);
485 bt_put(upstream_component
);
486 bt_put(downstream_component
);
489 (void) init_can_consume
;
490 bt_graph_set_can_consume(graph
, init_can_consume
);
496 enum bt_graph_status
consume_graph_sink(struct bt_component
*sink
)
498 enum bt_component_status comp_status
;
501 comp_status
= bt_component_sink_consume(sink
);
502 BT_LOGV("Consumed from sink: addr=%p, name=\"%s\", status=%s",
503 sink
, bt_component_get_name(sink
),
504 bt_component_status_string(comp_status
));
505 BT_ASSERT_PRE(comp_status
== BT_COMPONENT_STATUS_OK
||
506 comp_status
== BT_COMPONENT_STATUS_END
||
507 comp_status
== BT_COMPONENT_STATUS_AGAIN
||
508 comp_status
== BT_COMPONENT_STATUS_ERROR
||
509 comp_status
== BT_COMPONENT_STATUS_NOMEM
,
510 "Invalid component status returned by consuming function: "
511 "status=%s", bt_component_status_string(comp_status
));
512 return (enum bt_graph_status
) comp_status
;
516 * `node` is removed from the queue of sinks to consume when passed to
517 * this function. This function adds it back to the queue if there's
518 * still something to consume afterwards.
521 enum bt_graph_status
consume_sink_node(struct bt_graph
*graph
,
524 enum bt_graph_status status
;
525 struct bt_component
*sink
;
528 status
= consume_graph_sink(sink
);
529 if (unlikely(status
!= BT_GRAPH_STATUS_END
)) {
530 g_queue_push_tail_link(graph
->sinks_to_consume
, node
);
534 /* End reached, the node is not added back to the queue and free'd. */
535 g_queue_delete_link(graph
->sinks_to_consume
, node
);
537 /* Don't forward an END status if there are sinks left to consume. */
538 if (!g_queue_is_empty(graph
->sinks_to_consume
)) {
539 status
= BT_GRAPH_STATUS_OK
;
544 BT_LOGV("Consumed sink node: status=%s", bt_graph_status_string(status
));
549 enum bt_graph_status
bt_graph_consume_sink_no_check(struct bt_graph
*graph
,
550 struct bt_component
*sink
)
552 enum bt_graph_status status
;
556 BT_LOGV("Making specific sink consume: addr=%p, "
557 "comp-addr=%p, comp-name=\"%s\"",
558 graph
, sink
, bt_component_get_name(sink
));
560 BT_ASSERT(bt_component_borrow_graph(sink
) == graph
);
562 if (g_queue_is_empty(graph
->sinks_to_consume
)) {
563 BT_LOGV_STR("Graph's sink queue is empty: end of graph.");
564 status
= BT_GRAPH_STATUS_END
;
568 index
= g_queue_index(graph
->sinks_to_consume
, sink
);
570 BT_LOGV_STR("Sink is not marked as consumable: sink is ended.");
571 status
= BT_GRAPH_STATUS_END
;
575 sink_node
= g_queue_pop_nth_link(graph
->sinks_to_consume
, index
);
576 BT_ASSERT(sink_node
);
577 status
= consume_sink_node(graph
, sink_node
);
584 enum bt_graph_status
bt_graph_consume_no_check(struct bt_graph
*graph
)
586 enum bt_graph_status status
= BT_GRAPH_STATUS_OK
;
587 struct bt_component
*sink
;
590 BT_LOGV("Making next sink consume: addr=%p", graph
);
591 BT_ASSERT_PRE(graph
->has_sink
,
592 "Graph has no sink component: %!+g", graph
);
594 if (unlikely(g_queue_is_empty(graph
->sinks_to_consume
))) {
595 BT_LOGV_STR("Graph's sink queue is empty: end of graph.");
596 status
= BT_GRAPH_STATUS_END
;
600 current_node
= g_queue_pop_head_link(graph
->sinks_to_consume
);
601 sink
= current_node
->data
;
602 BT_LOGV("Chose next sink to consume: comp-addr=%p, comp-name=\"%s\"",
603 sink
, bt_component_get_name(sink
));
604 status
= consume_sink_node(graph
, current_node
);
610 enum bt_graph_status
bt_graph_consume(struct bt_graph
*graph
)
612 enum bt_graph_status status
;
614 BT_ASSERT_PRE_NON_NULL(graph
, "Graph");
615 BT_ASSERT_PRE(!graph
->canceled
, "Graph is canceled: %!+g", graph
);
616 BT_ASSERT_PRE(graph
->can_consume
,
617 "Cannot consume graph in its current state: %!+g", graph
);
618 bt_graph_set_can_consume(graph
, BT_FALSE
);
619 status
= bt_graph_consume_no_check(graph
);
620 bt_graph_set_can_consume(graph
, BT_TRUE
);
624 enum bt_graph_status
bt_graph_run(struct bt_graph
*graph
)
626 enum bt_graph_status status
= BT_GRAPH_STATUS_OK
;
629 BT_LOGW_STR("Invalid parameter: graph is NULL.");
630 status
= BT_GRAPH_STATUS_INVALID
;
634 if (graph
->canceled
) {
635 BT_LOGW("Invalid parameter: graph is canceled: "
636 "graph-addr=%p", graph
);
637 status
= BT_GRAPH_STATUS_CANCELED
;
641 BT_ASSERT_PRE(graph
->can_consume
,
642 "Cannot consume graph in its current state: %!+g", graph
);
643 bt_graph_set_can_consume(graph
, BT_FALSE
);
644 BT_LOGV("Running graph: addr=%p", graph
);
648 * Check if the graph is canceled at each iteration. If
649 * the graph was canceled by another thread or by a
650 * signal, this is not a warning nor an error, it was
651 * intentional: log with a DEBUG level only.
653 if (unlikely(graph
->canceled
)) {
654 BT_LOGD("Stopping the graph: graph is canceled: "
655 "graph-addr=%p", graph
);
656 status
= BT_GRAPH_STATUS_CANCELED
;
660 status
= bt_graph_consume_no_check(graph
);
661 if (unlikely(status
== BT_GRAPH_STATUS_AGAIN
)) {
663 * If AGAIN is received and there are multiple
664 * sinks, go ahead and consume from the next
667 * However, in the case where a single sink is
668 * left, the caller can decide to busy-wait and
669 * call bt_graph_run() continuously until the
670 * source is ready or it can decide to sleep for
671 * an arbitrary amount of time.
673 if (graph
->sinks_to_consume
->length
> 1) {
674 status
= BT_GRAPH_STATUS_OK
;
676 } else if (status
== BT_GRAPH_STATUS_NO_SINK
) {
679 } while (status
== BT_GRAPH_STATUS_OK
);
681 if (g_queue_is_empty(graph
->sinks_to_consume
)) {
682 status
= BT_GRAPH_STATUS_END
;
686 BT_LOGV("Graph ran: status=%s", bt_graph_status_string(status
));
688 bt_graph_set_can_consume(graph
, BT_TRUE
);
694 int add_listener(GArray
*listeners
, void *func
, void *removed
, void *data
)
696 struct bt_graph_listener listener
= {
702 g_array_append_val(listeners
, listener
);
703 return listeners
->len
- 1;
706 int bt_graph_add_port_added_listener(
707 struct bt_graph
*graph
,
708 bt_graph_port_added_listener listener
,
709 bt_graph_listener_removed listener_removed
, void *data
)
714 BT_LOGW_STR("Invalid parameter: graph is NULL.");
719 if (graph
->in_remove_listener
) {
720 BT_LOGW("Cannot call this function during the execution of a remove listener: "
727 BT_LOGW_STR("Invalid parameter: listener is NULL.");
732 ret
= add_listener(graph
->listeners
.port_added
, listener
,
733 listener_removed
, data
);
734 BT_LOGV("Added \"port added\" listener to graph: "
735 "graph-addr=%p, listener-addr=%p, pos=%d",
736 graph
, listener
, ret
);
742 int bt_graph_add_port_removed_listener(
743 struct bt_graph
*graph
,
744 bt_graph_port_removed_listener listener
,
745 bt_graph_listener_removed listener_removed
, void *data
)
750 BT_LOGW_STR("Invalid parameter: graph is NULL.");
755 if (graph
->in_remove_listener
) {
756 BT_LOGW("Cannot call this function during the execution of a remove listener: "
763 BT_LOGW_STR("Invalid parameter: listener is NULL.");
768 ret
= add_listener(graph
->listeners
.port_removed
, listener
,
769 listener_removed
, data
);
770 BT_LOGV("Added \"port removed\" listener to graph: "
771 "graph-addr=%p, listener-addr=%p, pos=%d",
772 graph
, listener
, ret
);
778 int bt_graph_add_ports_connected_listener(
779 struct bt_graph
*graph
,
780 bt_graph_ports_connected_listener listener
,
781 bt_graph_listener_removed listener_removed
, void *data
)
786 BT_LOGW_STR("Invalid parameter: graph is NULL.");
791 if (graph
->in_remove_listener
) {
792 BT_LOGW("Cannot call this function during the execution of a remove listener: "
799 BT_LOGW_STR("Invalid parameter: listener is NULL.");
804 ret
= add_listener(graph
->listeners
.ports_connected
, listener
,
805 listener_removed
, data
);
806 BT_LOGV("Added \"port connected\" listener to graph: "
807 "graph-addr=%p, listener-addr=%p, pos=%d",
808 graph
, listener
, ret
);
814 int bt_graph_add_ports_disconnected_listener(
815 struct bt_graph
*graph
,
816 bt_graph_ports_disconnected_listener listener
,
817 bt_graph_listener_removed listener_removed
, void *data
)
822 BT_LOGW_STR("Invalid parameter: graph is NULL.");
827 if (graph
->in_remove_listener
) {
828 BT_LOGW("Cannot call this function during the execution of a remove listener: "
835 BT_LOGW_STR("Invalid parameter: listener is NULL.");
840 ret
= add_listener(graph
->listeners
.ports_disconnected
, listener
,
841 listener_removed
, data
);
842 BT_LOGV("Added \"port disconnected\" listener to graph: "
843 "graph-addr=%p, listener-addr=%p, pos=%d",
844 graph
, listener
, ret
);
851 void bt_graph_notify_port_added(struct bt_graph
*graph
, struct bt_port
*port
)
855 BT_LOGV("Notifying graph listeners that a port was added: "
856 "graph-addr=%p, port-addr=%p, port-name=\"%s\"",
857 graph
, port
, bt_port_get_name(port
));
859 for (i
= 0; i
< graph
->listeners
.port_added
->len
; i
++) {
860 struct bt_graph_listener listener
=
861 g_array_index(graph
->listeners
.port_added
,
862 struct bt_graph_listener
, i
);
863 bt_graph_port_added_listener func
= listener
.func
;
866 func(port
, listener
.data
);
871 void bt_graph_notify_port_removed(struct bt_graph
*graph
,
872 struct bt_component
*comp
, struct bt_port
*port
)
876 BT_LOGV("Notifying graph listeners that a port was removed: "
877 "graph-addr=%p, port-addr=%p, port-name=\"%s\"",
878 graph
, port
, bt_port_get_name(port
));
880 for (i
= 0; i
< graph
->listeners
.port_removed
->len
; i
++) {
881 struct bt_graph_listener listener
=
882 g_array_index(graph
->listeners
.port_removed
,
883 struct bt_graph_listener
, i
);
884 bt_graph_port_removed_listener func
= listener
.func
;
887 func(comp
, port
, listener
.data
);
892 void bt_graph_notify_ports_connected(struct bt_graph
*graph
,
893 struct bt_port
*upstream_port
, struct bt_port
*downstream_port
)
897 BT_LOGV("Notifying graph listeners that two ports were connected: "
899 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
900 "downstream-port-addr=%p, downstream-port-name=\"%s\"",
901 graph
, upstream_port
, bt_port_get_name(upstream_port
),
902 downstream_port
, bt_port_get_name(downstream_port
));
904 for (i
= 0; i
< graph
->listeners
.ports_connected
->len
; i
++) {
905 struct bt_graph_listener listener
=
906 g_array_index(graph
->listeners
.ports_connected
,
907 struct bt_graph_listener
, i
);
908 bt_graph_ports_connected_listener func
= listener
.func
;
911 func(upstream_port
, downstream_port
, listener
.data
);
916 void bt_graph_notify_ports_disconnected(struct bt_graph
*graph
,
917 struct bt_component
*upstream_comp
,
918 struct bt_component
*downstream_comp
,
919 struct bt_port
*upstream_port
, struct bt_port
*downstream_port
)
923 BT_LOGV("Notifying graph listeners that two ports were disconnected: "
925 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
926 "downstream-port-addr=%p, downstream-port-name=\"%s\"",
927 graph
, upstream_port
, bt_port_get_name(upstream_port
),
928 downstream_port
, bt_port_get_name(downstream_port
));
930 for (i
= 0; i
< graph
->listeners
.ports_disconnected
->len
; i
++) {
931 struct bt_graph_listener listener
=
932 g_array_index(graph
->listeners
.ports_disconnected
,
933 struct bt_graph_listener
, i
);
934 bt_graph_ports_disconnected_listener func
= listener
.func
;
937 func(upstream_comp
, downstream_comp
, upstream_port
,
938 downstream_port
, listener
.data
);
942 enum bt_graph_status
bt_graph_cancel(struct bt_graph
*graph
)
944 enum bt_graph_status ret
= BT_GRAPH_STATUS_OK
;
947 BT_LOGW_STR("Invalid parameter: graph is NULL.");
948 ret
= BT_GRAPH_STATUS_INVALID
;
952 graph
->canceled
= BT_TRUE
;
953 BT_LOGV("Canceled graph: addr=%p", graph
);
959 bt_bool
bt_graph_is_canceled(struct bt_graph
*graph
)
961 bt_bool canceled
= BT_FALSE
;
964 BT_LOGW_STR("Invalid parameter: graph is NULL.");
968 canceled
= graph
->canceled
;
975 void bt_graph_remove_connection(struct bt_graph
*graph
,
976 struct bt_connection
*connection
)
979 BT_ASSERT(connection
);
980 BT_LOGV("Removing graph's connection: graph-addr=%p, conn-addr=%p",
982 g_ptr_array_remove(graph
->connections
, connection
);
985 enum bt_graph_status
bt_graph_add_component_with_init_method_data(
986 struct bt_graph
*graph
,
987 struct bt_component_class
*component_class
,
988 const char *name
, struct bt_value
*params
,
989 void *init_method_data
,
990 struct bt_component
**user_component
)
992 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
993 enum bt_component_status comp_status
;
994 struct bt_component
*component
= NULL
;
995 enum bt_component_class_type type
;
997 bt_bool init_can_consume
;
1002 BT_LOGW_STR("Invalid parameter: graph is NULL.");
1003 graph_status
= BT_GRAPH_STATUS_INVALID
;
1006 init_can_consume
= graph
->can_consume
;
1008 if (!component_class
) {
1009 BT_LOGW_STR("Invalid parameter: component class is NULL.");
1010 graph_status
= BT_GRAPH_STATUS_INVALID
;
1014 graph
->can_consume
= BT_FALSE
;
1015 type
= bt_component_class_get_type(component_class
);
1016 BT_LOGD("Adding component to graph: "
1017 "graph-addr=%p, comp-cls-addr=%p, "
1018 "comp-cls-type=%s, name=\"%s\", params-addr=%p, "
1019 "init-method-data-addr=%p",
1020 graph
, component_class
, bt_component_class_type_string(type
),
1021 name
, params
, init_method_data
);
1024 BT_LOGW_STR("Invalid parameter: name is NULL.");
1025 graph_status
= BT_GRAPH_STATUS_INVALID
;
1029 if (graph
->canceled
) {
1030 BT_LOGW_STR("Invalid parameter: graph is canceled.");
1031 graph_status
= BT_GRAPH_STATUS_CANCELED
;
1035 if (type
!= BT_COMPONENT_CLASS_TYPE_SOURCE
&&
1036 type
!= BT_COMPONENT_CLASS_TYPE_FILTER
&&
1037 type
!= BT_COMPONENT_CLASS_TYPE_SINK
) {
1038 BT_LOGW("Invalid parameter: unknown component class type: "
1040 graph_status
= BT_GRAPH_STATUS_INVALID
;
1044 for (i
= 0; i
< graph
->components
->len
; i
++) {
1045 void *other_comp
= graph
->components
->pdata
[i
];
1047 if (strcmp(name
, bt_component_get_name(other_comp
)) == 0) {
1048 BT_LOGW("Invalid parameter: another component with the same name already exists in the graph: "
1049 "other-comp-addr=%p, name=\"%s\"",
1051 graph_status
= BT_GRAPH_STATUS_INVALID
;
1057 * Parameters must be a map value, but we create a convenient
1058 * empty one if it's NULL.
1061 if (!bt_value_is_map(params
)) {
1062 BT_LOGW("Invalid parameter: initialization parameters must be a map value: "
1064 bt_value_type_string(bt_value_get_type(params
)));
1065 graph_status
= BT_GRAPH_STATUS_INVALID
;
1069 params
= bt_value_map_create();
1071 BT_LOGE_STR("Cannot create map value object.");
1072 graph_status
= BT_GRAPH_STATUS_NOMEM
;
1077 comp_status
= bt_component_create(component_class
, name
, &component
);
1078 if (comp_status
!= BT_COMPONENT_STATUS_OK
) {
1079 BT_LOGE("Cannot create empty component object: status=%s",
1080 bt_component_status_string(comp_status
));
1081 graph_status
= bt_graph_status_from_component_status(
1087 * The user's initialization method needs to see that this
1088 * component is part of the graph. If the user method fails, we
1089 * immediately remove the component from the graph's components.
1091 g_ptr_array_add(graph
->components
, component
);
1092 bt_component_set_graph(component
, graph
);
1094 if (component_class
->methods
.init
) {
1095 BT_LOGD_STR("Calling user's initialization method.");
1096 comp_status
= component_class
->methods
.init(
1097 bt_private_component_from_component(component
), params
,
1099 BT_LOGD("User method returned: status=%s",
1100 bt_component_status_string(comp_status
));
1101 if (comp_status
!= BT_COMPONENT_STATUS_OK
) {
1102 BT_LOGW_STR("Initialization method failed.");
1103 graph_status
= bt_graph_status_from_component_status(
1105 bt_component_set_graph(component
, NULL
);
1106 g_ptr_array_remove_fast(graph
->components
, component
);
1112 * Mark the component as initialized so that its finalization
1113 * method is called when it is destroyed.
1115 component
->initialized
= true;
1118 * If it's a sink component, it needs to be part of the graph's
1119 * sink queue to be consumed by bt_graph_consume().
1121 if (bt_component_is_sink(component
)) {
1122 graph
->has_sink
= BT_TRUE
;
1123 g_queue_push_tail(graph
->sinks_to_consume
, component
);
1127 * Freeze the component class now that it's instantiated at
1130 BT_LOGD_STR("Freezing component class.");
1131 bt_component_class_freeze(component
->class);
1132 BT_LOGD("Added component to graph: "
1133 "graph-addr=%p, comp-cls-addr=%p, "
1134 "comp-cls-type=%s, name=\"%s\", params-addr=%p, "
1135 "init-method-data-addr=%p, comp-addr=%p",
1136 graph
, component_class
, bt_component_class_type_string(type
),
1137 name
, params
, init_method_data
, component
);
1139 if (user_component
) {
1140 /* Move reference to user */
1141 *user_component
= component
;
1149 graph
->can_consume
= init_can_consume
;
1151 return graph_status
;
1154 enum bt_graph_status
bt_graph_add_component(
1155 struct bt_graph
*graph
,
1156 struct bt_component_class
*component_class
,
1157 const char *name
, struct bt_value
*params
,
1158 struct bt_component
**component
)
1160 return bt_graph_add_component_with_init_method_data(graph
,
1161 component_class
, name
, params
, NULL
, component
);
1165 int bt_graph_remove_unconnected_component(struct bt_graph
*graph
,
1166 struct bt_component
*component
)
1168 bt_bool init_can_consume
;
1174 BT_ASSERT(component
);
1175 BT_ASSERT(component
->base
.ref_count
== 0);
1176 BT_ASSERT(bt_component_borrow_graph(component
) == graph
);
1178 init_can_consume
= graph
->can_consume
;
1179 count
= bt_component_get_input_port_count(component
);
1181 for (i
= 0; i
< count
; i
++) {
1182 struct bt_port
*port
=
1183 bt_component_get_input_port_by_index(component
, i
);
1188 if (bt_port_is_connected(port
)) {
1189 BT_LOGW("Cannot remove component from graph: "
1190 "an input port is connected: "
1191 "graph-addr=%p, comp-addr=%p, "
1192 "comp-name=\"%s\", connected-port-addr=%p, "
1193 "connected-port-name=\"%s\"",
1195 bt_component_get_name(component
),
1196 port
, bt_port_get_name(port
));
1201 count
= bt_component_get_output_port_count(component
);
1203 for (i
= 0; i
< count
; i
++) {
1204 struct bt_port
*port
=
1205 bt_component_get_output_port_by_index(component
, i
);
1210 if (bt_port_is_connected(port
)) {
1211 BT_LOGW("Cannot remove component from graph: "
1212 "an output port is connected: "
1213 "graph-addr=%p, comp-addr=%p, "
1214 "comp-name=\"%s\", connected-port-addr=%p, "
1215 "connected-port-name=\"%s\"",
1217 bt_component_get_name(component
),
1218 port
, bt_port_get_name(port
));
1223 graph
->can_consume
= BT_FALSE
;
1225 /* Possibly remove from sinks to consume */
1226 (void) g_queue_remove(graph
->sinks_to_consume
, component
);
1228 if (graph
->sinks_to_consume
->length
== 0) {
1229 graph
->has_sink
= BT_FALSE
;
1233 * This calls bt_object_try_spec_release() on the component, and
1234 * since its reference count is 0, its destructor is called. Its
1235 * destructor calls the user's finalization method (if set).
1237 g_ptr_array_remove(graph
->components
, component
);
1244 graph
->can_consume
= init_can_consume
;
1249 void bt_graph_add_notification(struct bt_graph
*graph
,
1250 struct bt_notification
*notif
)
1256 * It's okay not to take a reference because, when a
1257 * notification's reference count drops to 0, either:
1259 * * It is recycled back to one of this graph's pool.
1260 * * It is destroyed because it doesn't have any link to any
1261 * graph, which means the original graph is already destroyed.
1263 g_ptr_array_add(graph
->notifications
, notif
);