Refuse to add port to component when parent graph is canceled
[babeltrace.git] / lib / graph / graph.c
1 /*
2 * graph.c
3 *
4 * Babeltrace Plugin Component Graph
5 *
6 * Copyright 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
7 * Copyright 2017 Philippe Proulx <pproulx@efficios.com>
8 *
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:
15 *
16 * The above copyright notice and this permission notice shall be included in
17 * all copies or substantial portions of the Software.
18 *
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
25 * SOFTWARE.
26 */
27
28 #define BT_LOG_TAG "GRAPH"
29 #include <babeltrace/lib-logging-internal.h>
30
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/compiler-internal.h>
39 #include <babeltrace/types.h>
40 #include <unistd.h>
41 #include <glib.h>
42
43 struct bt_graph_listener {
44 void *func;
45 void *data;
46 };
47
48 static
49 void bt_graph_destroy(struct bt_object *obj)
50 {
51 struct bt_graph *graph = container_of(obj,
52 struct bt_graph, base);
53
54 /*
55 * The graph's reference count is 0 if we're here. Increment
56 * it to avoid a double-destroy (possibly infinitely recursive)
57 * in this situation:
58 *
59 * 1. We put and destroy a connection.
60 * 2. This connection's destructor finalizes its active
61 * notification iterators.
62 * 3. A notification iterator's finalization function gets a
63 * new reference on its component (reference count goes from
64 * 0 to 1).
65 * 4. Since this component's reference count goes to 1, it takes
66 * a reference on its parent (this graph). This graph's
67 * reference count goes from 0 to 1.
68 * 5. The notification iterator's finalization function puts its
69 * component reference (reference count goes from 1 to 0).
70 * 6. Since this component's reference count goes from 1 to 0,
71 * it puts its parent (this graph). This graph's reference
72 * count goes from 1 to 0.
73 * 7. Since this graph's reference count goes from 1 to 0,
74 * its destructor is called (this function).
75 *
76 * With the incrementation below, the graph's reference count at
77 * step 4 goes from 1 to 2, and from 2 to 1 at step 6. This
78 * ensures that this function is not called two times.
79 */
80 BT_LOGD("Destroying graph: addr=%p", graph);
81 obj->ref_count.count++;
82
83 if (graph->connections) {
84 BT_LOGD_STR("Destroying connections.");
85 g_ptr_array_free(graph->connections, TRUE);
86 }
87 if (graph->components) {
88 BT_LOGD_STR("Destroying components.");
89 g_ptr_array_free(graph->components, TRUE);
90 }
91 if (graph->sinks_to_consume) {
92 g_queue_free(graph->sinks_to_consume);
93 }
94
95 if (graph->listeners.port_added) {
96 g_array_free(graph->listeners.port_added, TRUE);
97 }
98
99 if (graph->listeners.port_removed) {
100 g_array_free(graph->listeners.port_removed, TRUE);
101 }
102
103 if (graph->listeners.ports_connected) {
104 g_array_free(graph->listeners.ports_connected, TRUE);
105 }
106
107 if (graph->listeners.ports_disconnected) {
108 g_array_free(graph->listeners.ports_disconnected, TRUE);
109 }
110
111 g_free(graph);
112 }
113
114 static
115 int init_listeners_array(GArray **listeners)
116 {
117 int ret = 0;
118
119 assert(listeners);
120 *listeners = g_array_new(FALSE, TRUE, sizeof(struct bt_graph_listener));
121 if (!*listeners) {
122 BT_LOGE_STR("Failed to allocate one GArray.");
123 ret = -1;
124 goto end;
125 }
126
127 end:
128 return ret;
129 }
130
131 struct bt_graph *bt_graph_create(void)
132 {
133 struct bt_graph *graph;
134 int ret;
135
136 BT_LOGD_STR("Creating graph object.");
137 graph = g_new0(struct bt_graph, 1);
138 if (!graph) {
139 BT_LOGE_STR("Failed to allocate one graph.");
140 goto end;
141 }
142
143 bt_object_init(graph, bt_graph_destroy);
144
145 graph->connections = g_ptr_array_new_with_free_func(bt_object_release);
146 if (!graph->connections) {
147 BT_LOGE_STR("Failed to allocate one GPtrArray.");
148 goto error;
149 }
150 graph->components = g_ptr_array_new_with_free_func(bt_object_release);
151 if (!graph->components) {
152 BT_LOGE_STR("Failed to allocate one GPtrArray.");
153 goto error;
154 }
155 graph->sinks_to_consume = g_queue_new();
156 if (!graph->sinks_to_consume) {
157 BT_LOGE_STR("Failed to allocate one GQueue.");
158 goto error;
159 }
160
161 ret = init_listeners_array(&graph->listeners.port_added);
162 if (ret) {
163 BT_LOGE_STR("Cannot create the \"port added\" listener array.");
164 goto error;
165 }
166
167 ret = init_listeners_array(&graph->listeners.port_removed);
168 if (ret) {
169 BT_LOGE_STR("Cannot create the \"port removed\" listener array.");
170 goto error;
171 }
172
173 ret = init_listeners_array(&graph->listeners.ports_connected);
174 if (ret) {
175 BT_LOGE_STR("Cannot create the \"port connected\" listener array.");
176 goto error;
177 }
178
179 ret = init_listeners_array(&graph->listeners.ports_disconnected);
180 if (ret) {
181 BT_LOGE_STR("Cannot create the \"port disconneted\" listener array.");
182 goto error;
183 }
184
185 BT_LOGD("Created graph object: addr=%p", graph);
186
187 end:
188 return graph;
189 error:
190 BT_PUT(graph);
191 goto end;
192 }
193
194 enum bt_graph_status bt_graph_connect_ports(struct bt_graph *graph,
195 struct bt_port *upstream_port, struct bt_port *downstream_port,
196 struct bt_connection **user_connection)
197 {
198 enum bt_graph_status status = BT_GRAPH_STATUS_OK;
199 struct bt_connection *connection = NULL;
200 struct bt_graph *upstream_graph = NULL;
201 struct bt_graph *downstream_graph = NULL;
202 struct bt_component *upstream_component = NULL;
203 struct bt_component *downstream_component = NULL;
204 enum bt_component_status component_status;
205 bt_bool upstream_was_already_in_graph;
206 bt_bool downstream_was_already_in_graph;
207
208 if (!graph) {
209 BT_LOGW_STR("Invalid parameter: graph is NULL.");
210 status = BT_GRAPH_STATUS_INVALID;
211 goto end;
212 }
213
214 if (!upstream_port) {
215 BT_LOGW_STR("Invalid parameter: upstream port is NULL.");
216 status = BT_GRAPH_STATUS_INVALID;
217 goto end;
218 }
219
220 if (!downstream_port) {
221 BT_LOGW_STR("Invalid parameter: downstream port is NULL.");
222 status = BT_GRAPH_STATUS_INVALID;
223 goto end;
224 }
225
226 BT_LOGD("Connecting component ports within graph: "
227 "graph-addr=%p, "
228 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
229 "downstream-port-addr=%p, downstream-port-name=\"%s\"",
230 graph, upstream_port, bt_port_get_name(upstream_port),
231 downstream_port, bt_port_get_name(downstream_port));
232
233 if (graph->canceled) {
234 BT_LOGW_STR("Invalid parameter: graph is canceled.");
235 status = BT_GRAPH_STATUS_CANCELED;
236 goto end;
237 }
238
239 /* Ensure appropriate types for upstream and downstream ports. */
240 if (bt_port_get_type(upstream_port) != BT_PORT_TYPE_OUTPUT) {
241 BT_LOGW_STR("Invalid parameter: upstream port is not an output port.");
242 status = BT_GRAPH_STATUS_INVALID;
243 goto end;
244 }
245 if (bt_port_get_type(downstream_port) != BT_PORT_TYPE_INPUT) {
246 BT_LOGW_STR("Invalid parameter: downstream port is not an input port.");
247 status = BT_GRAPH_STATUS_INVALID;
248 goto end;
249 }
250
251 /* Ensure that both ports are currently unconnected. */
252 if (bt_port_is_connected(upstream_port)) {
253 BT_LOGW_STR("Invalid parameter: upstream port is already connected.");
254 status = BT_GRAPH_STATUS_INVALID;
255 goto end;
256 }
257
258 if (bt_port_is_connected(downstream_port)) {
259 BT_LOGW_STR("Invalid parameter: downstream port is already connected.");
260 status = BT_GRAPH_STATUS_INVALID;
261 goto end;
262 }
263
264 /*
265 * Ensure that both ports are still attached to their creating
266 * component.
267 */
268 upstream_component = bt_port_get_component(upstream_port);
269 if (!upstream_component) {
270 BT_LOGW_STR("Invalid parameter: upstream port is loose (does not belong to a component)");
271 status = BT_GRAPH_STATUS_INVALID;
272 goto end;
273 }
274
275 downstream_component = bt_port_get_component(downstream_port);
276 if (!downstream_component) {
277 BT_LOGW_STR("Invalid parameter: downstream port is loose (does not belong to a component)");
278 status = BT_GRAPH_STATUS_INVALID;
279 goto end;
280 }
281
282 BT_LOGD("Connecting component ports: "
283 "upstream-comp-addr=%p, upstream-comp-name=\"%s\", "
284 "downstream-comp-addr=%p, downstream-comp-name=\"%s\"",
285 upstream_component, bt_component_get_name(upstream_component),
286 downstream_component, bt_component_get_name(downstream_component));
287
288 /* Ensure the components are not already part of another graph. */
289 upstream_graph = bt_component_get_graph(upstream_component);
290 if (upstream_graph && (graph != upstream_graph)) {
291 BT_LOGW("Invalid parameter: upstream port's component is already part of another graph: "
292 "other-graph-addr=%p", upstream_graph);
293 status = BT_GRAPH_STATUS_ALREADY_IN_A_GRAPH;
294 goto end;
295 }
296 upstream_was_already_in_graph = (graph == upstream_graph);
297 downstream_graph = bt_component_get_graph(downstream_component);
298 if (downstream_graph && (graph != downstream_graph)) {
299 BT_LOGW("Invalid parameter: downstream port's component is already part of another graph: "
300 "other-graph-addr=%p", downstream_graph);
301 status = BT_GRAPH_STATUS_ALREADY_IN_A_GRAPH;
302 goto end;
303 }
304 downstream_was_already_in_graph = (graph == downstream_graph);
305
306 /*
307 * At this point the ports are not connected yet. Both
308 * components need to accept an eventual connection to their
309 * port by the other port before we continue.
310 */
311 BT_LOGD_STR("Asking upstream component to accept the connection.");
312 component_status = bt_component_accept_port_connection(
313 upstream_component, upstream_port, downstream_port);
314 if (component_status != BT_COMPONENT_STATUS_OK) {
315 if (component_status == BT_COMPONENT_STATUS_REFUSE_PORT_CONNECTION) {
316 BT_LOGD_STR("Upstream component refused the connection.");
317 } else {
318 BT_LOGW("Cannot ask upstream component to accept the connection: "
319 "status=%s", bt_component_status_string(component_status));
320 }
321
322 status = bt_graph_status_from_component_status(
323 component_status);
324 goto end;
325 }
326
327 BT_LOGD_STR("Asking downstream component to accept the connection.");
328 component_status = bt_component_accept_port_connection(
329 downstream_component, downstream_port, upstream_port);
330 if (component_status != BT_COMPONENT_STATUS_OK) {
331 if (component_status == BT_COMPONENT_STATUS_REFUSE_PORT_CONNECTION) {
332 BT_LOGD_STR("Downstream component refused the connection.");
333 } else {
334 BT_LOGW("Cannot ask downstream component to accept the connection: "
335 "status=%s", bt_component_status_string(component_status));
336 }
337
338 status = bt_graph_status_from_component_status(
339 component_status);
340 goto end;
341 }
342
343 BT_LOGD_STR("Creating connection.");
344 connection = bt_connection_create(graph, upstream_port,
345 downstream_port);
346 if (!connection) {
347 BT_LOGW("Cannot create connection object.");
348 status = BT_GRAPH_STATUS_NOMEM;
349 goto end;
350 }
351
352 BT_LOGD("Connection object created: conn-addr=%p", connection);
353
354 /*
355 * Ownership of upstream_component/downstream_component and of
356 * the connection object is transferred to the graph.
357 */
358 g_ptr_array_add(graph->connections, connection);
359
360 if (!upstream_was_already_in_graph) {
361 g_ptr_array_add(graph->components, upstream_component);
362 bt_component_set_graph(upstream_component, graph);
363 }
364 if (!downstream_was_already_in_graph) {
365 g_ptr_array_add(graph->components, downstream_component);
366 bt_component_set_graph(downstream_component, graph);
367 if (bt_component_get_class_type(downstream_component) ==
368 BT_COMPONENT_CLASS_TYPE_SINK) {
369 g_queue_push_tail(graph->sinks_to_consume,
370 downstream_component);
371 }
372 }
373
374 /*
375 * The graph is now the parent of these components which
376 * garantees their existence for the duration of the graph's
377 * lifetime.
378 */
379
380 /*
381 * Notify both components that their port is connected.
382 */
383 BT_LOGD_STR("Notifying upstream component that its port is connected.");
384 bt_component_port_connected(upstream_component, upstream_port,
385 downstream_port);
386 BT_LOGD_STR("Notifying downstream component that its port is connected.");
387 bt_component_port_connected(downstream_component, downstream_port,
388 upstream_port);
389
390 /*
391 * Notify the graph's creator that both ports are connected.
392 */
393 BT_LOGD_STR("Notifying graph's user that new component ports are connected.");
394 bt_graph_notify_ports_connected(graph, upstream_port, downstream_port);
395 BT_LOGD("Connected component ports within graph: "
396 "graph-addr=%p, "
397 "upstream-comp-addr=%p, upstream-comp-name=\"%s\", "
398 "downstream-comp-addr=%p, downstream-comp-name=\"%s\", "
399 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
400 "downstream-port-addr=%p, downstream-port-name=\"%s\"",
401 graph,
402 upstream_component, bt_component_get_name(upstream_component),
403 downstream_component, bt_component_get_name(downstream_component),
404 upstream_port, bt_port_get_name(upstream_port),
405 downstream_port, bt_port_get_name(downstream_port));
406
407 if (user_connection) {
408 BT_MOVE(*user_connection, connection);
409 }
410
411 end:
412 bt_put(upstream_graph);
413 bt_put(downstream_graph);
414 bt_put(upstream_component);
415 bt_put(downstream_component);
416 bt_put(connection);
417 return status;
418 }
419
420 static
421 enum bt_graph_status bt_graph_consume_no_check(struct bt_graph *graph)
422 {
423 struct bt_component *sink;
424 enum bt_graph_status status = BT_GRAPH_STATUS_OK;
425 enum bt_component_status comp_status;
426 GList *current_node;
427
428 BT_LOGV("Making next sink consume: addr=%p", graph);
429
430 if (g_queue_is_empty(graph->sinks_to_consume)) {
431 BT_LOGV_STR("Graph's sink queue is empty: end of graph.");
432 status = BT_GRAPH_STATUS_END;
433 goto end;
434 }
435
436 current_node = g_queue_pop_head_link(graph->sinks_to_consume);
437 sink = current_node->data;
438 BT_LOGV("Chose next sink to consume: comp-addr=%p, comp-name=\"%s\"",
439 sink, bt_component_get_name(sink));
440 comp_status = bt_component_sink_consume(sink);
441 BT_LOGV("Consumed from sink: status=%s",
442 bt_component_status_string(comp_status));
443 switch (comp_status) {
444 case BT_COMPONENT_STATUS_OK:
445 break;
446 case BT_COMPONENT_STATUS_END:
447 status = BT_GRAPH_STATUS_END;
448 break;
449 case BT_COMPONENT_STATUS_AGAIN:
450 status = BT_GRAPH_STATUS_AGAIN;
451 break;
452 case BT_COMPONENT_STATUS_INVALID:
453 status = BT_GRAPH_STATUS_INVALID;
454 break;
455 default:
456 status = BT_GRAPH_STATUS_ERROR;
457 break;
458 }
459
460 if (status != BT_GRAPH_STATUS_END) {
461 g_queue_push_tail_link(graph->sinks_to_consume, current_node);
462 goto end;
463 }
464
465 /* End reached, the node is not added back to the queue and free'd. */
466 g_queue_delete_link(graph->sinks_to_consume, current_node);
467
468 /* Don't forward an END status if there are sinks left to consume. */
469 if (!g_queue_is_empty(graph->sinks_to_consume)) {
470 status = BT_GRAPH_STATUS_OK;
471 goto end;
472 }
473 end:
474 BT_LOGV("Graph consumed: status=%s", bt_graph_status_string(status));
475 return status;
476 }
477
478 enum bt_graph_status bt_graph_consume(struct bt_graph *graph)
479 {
480 enum bt_graph_status status = BT_GRAPH_STATUS_OK;
481
482 if (!graph) {
483 BT_LOGW_STR("Invalid parameter: graph is NULL.");
484 status = BT_GRAPH_STATUS_INVALID;
485 goto end;
486 }
487
488 if (graph->canceled) {
489 BT_LOGW("Invalid parameter: graph is canceled: "
490 "graph-addr=%p", graph);
491 status = BT_GRAPH_STATUS_CANCELED;
492 goto end;
493 }
494
495 status = bt_graph_consume_no_check(graph);
496
497 end:
498 return status;
499 }
500
501 enum bt_graph_status bt_graph_run(struct bt_graph *graph)
502 {
503 enum bt_graph_status status = BT_GRAPH_STATUS_OK;
504
505 if (!graph) {
506 BT_LOGW_STR("Invalid parameter: graph is NULL.");
507 status = BT_GRAPH_STATUS_INVALID;
508 goto end;
509 }
510
511 if (graph->canceled) {
512 BT_LOGW("Invalid parameter: graph is canceled: "
513 "graph-addr=%p", graph);
514 status = BT_GRAPH_STATUS_CANCELED;
515 goto end;
516 }
517
518 BT_LOGV("Running graph: addr=%p", graph);
519
520 do {
521 /*
522 * Check if the graph is canceled at each iteration. If
523 * the graph was canceled by another thread or by a
524 * signal, this is not a warning nor an error, it was
525 * intentional: log with a DEBUG level only.
526 */
527 if (graph->canceled) {
528 BT_LOGD("Stopping the graph: graph is canceled: "
529 "graph-addr=%p", graph);
530 status = BT_GRAPH_STATUS_CANCELED;
531 goto end;
532 }
533
534 status = bt_graph_consume(graph);
535 if (status == BT_GRAPH_STATUS_AGAIN) {
536 /*
537 * If AGAIN is received and there are multiple
538 * sinks, go ahead and consume from the next
539 * sink.
540 *
541 * However, in the case where a single sink is
542 * left, the caller can decide to busy-wait and
543 * call bt_graph_run() continuously until the
544 * source is ready or it can decide to sleep for
545 * an arbitrary amount of time.
546 */
547 if (graph->sinks_to_consume->length > 1) {
548 status = BT_GRAPH_STATUS_OK;
549 }
550 }
551 } while (status == BT_GRAPH_STATUS_OK);
552
553 if (g_queue_is_empty(graph->sinks_to_consume)) {
554 status = BT_GRAPH_STATUS_END;
555 }
556
557 end:
558 BT_LOGV("Graph ran: status=%s", bt_graph_status_string(status));
559 return status;
560 }
561
562 static
563 int add_listener(GArray *listeners, void *func, void *data)
564 {
565 struct bt_graph_listener listener = {
566 .func = func,
567 .data = data,
568 };
569
570 g_array_append_val(listeners, listener);
571 return listeners->len - 1;
572 }
573
574 int bt_graph_add_port_added_listener(
575 struct bt_graph *graph,
576 bt_graph_port_added_listener listener, void *data)
577 {
578 int ret;
579
580 if (!graph) {
581 BT_LOGW_STR("Invalid parameter: graph is NULL.");
582 ret = -1;
583 goto end;
584 }
585
586 if (!listener) {
587 BT_LOGW_STR("Invalid parameter: listener is NULL.");
588 ret = -1;
589 goto end;
590 }
591
592 ret = add_listener(graph->listeners.port_added, listener, data);
593 BT_LOGV("Added \"port added\" listener to graph: "
594 "graph-addr=%p, listener-addr=%p, pos=%d",
595 graph, listener, ret);
596
597 end:
598 return ret;
599 }
600
601 int bt_graph_add_port_removed_listener(
602 struct bt_graph *graph,
603 bt_graph_port_removed_listener listener, void *data)
604 {
605 int ret;
606
607 if (!graph) {
608 BT_LOGW_STR("Invalid parameter: graph is NULL.");
609 ret = -1;
610 goto end;
611 }
612
613 if (!listener) {
614 BT_LOGW_STR("Invalid parameter: listener is NULL.");
615 ret = -1;
616 goto end;
617 }
618
619 ret = add_listener(graph->listeners.port_removed, listener, data);
620 BT_LOGV("Added \"port removed\" listener to graph: "
621 "graph-addr=%p, listener-addr=%p, pos=%d",
622 graph, listener, ret);
623
624 end:
625 return ret;
626 }
627
628 int bt_graph_add_ports_connected_listener(
629 struct bt_graph *graph,
630 bt_graph_ports_connected_listener listener, void *data)
631 {
632 int ret;
633
634 if (!graph) {
635 BT_LOGW_STR("Invalid parameter: graph is NULL.");
636 ret = -1;
637 goto end;
638 }
639
640 if (!listener) {
641 BT_LOGW_STR("Invalid parameter: listener is NULL.");
642 ret = -1;
643 goto end;
644 }
645
646 ret = add_listener(graph->listeners.ports_connected, listener, data);
647 BT_LOGV("Added \"port connected\" listener to graph: "
648 "graph-addr=%p, listener-addr=%p, pos=%d",
649 graph, listener, ret);
650
651 end:
652 return ret;
653 }
654
655 int bt_graph_add_ports_disconnected_listener(
656 struct bt_graph *graph,
657 bt_graph_ports_disconnected_listener listener, void *data)
658 {
659 int ret;
660
661 if (!graph) {
662 BT_LOGW_STR("Invalid parameter: graph is NULL.");
663 ret = -1;
664 goto end;
665 }
666
667 if (!listener) {
668 BT_LOGW_STR("Invalid parameter: listener is NULL.");
669 ret = -1;
670 goto end;
671 }
672
673 ret = add_listener(graph->listeners.ports_disconnected, listener, data);
674 BT_LOGV("Added \"port disconnected\" listener to graph: "
675 "graph-addr=%p, listener-addr=%p, pos=%d",
676 graph, listener, ret);
677
678 end:
679 return ret;
680 }
681
682 BT_HIDDEN
683 void bt_graph_notify_port_added(struct bt_graph *graph, struct bt_port *port)
684 {
685 size_t i;
686
687 BT_LOGV("Notifying graph listeners that a port was added: "
688 "graph-addr=%p, port-addr=%p, port-name=\"%s\"",
689 graph, port, bt_port_get_name(port));
690
691 for (i = 0; i < graph->listeners.port_added->len; i++) {
692 struct bt_graph_listener listener =
693 g_array_index(graph->listeners.port_added,
694 struct bt_graph_listener, i);
695 bt_graph_port_added_listener func = listener.func;
696
697 assert(func);
698 func(port, listener.data);
699 }
700 }
701
702 BT_HIDDEN
703 void bt_graph_notify_port_removed(struct bt_graph *graph,
704 struct bt_component *comp, struct bt_port *port)
705 {
706 size_t i;
707
708 BT_LOGV("Notifying graph listeners that a port was removed: "
709 "graph-addr=%p, port-addr=%p, port-name=\"%s\"",
710 graph, port, bt_port_get_name(port));
711
712 for (i = 0; i < graph->listeners.port_removed->len; i++) {
713 struct bt_graph_listener listener =
714 g_array_index(graph->listeners.port_removed,
715 struct bt_graph_listener, i);
716 bt_graph_port_removed_listener func = listener.func;
717
718 assert(func);
719 func(comp, port, listener.data);
720 }
721 }
722
723 BT_HIDDEN
724 void bt_graph_notify_ports_connected(struct bt_graph *graph,
725 struct bt_port *upstream_port, struct bt_port *downstream_port)
726 {
727 size_t i;
728
729 BT_LOGV("Notifying graph listeners that two ports were connected: "
730 "graph-addr=%p, "
731 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
732 "downstream-port-addr=%p, downstream-port-name=\"%s\"",
733 graph, upstream_port, bt_port_get_name(upstream_port),
734 downstream_port, bt_port_get_name(downstream_port));
735
736 for (i = 0; i < graph->listeners.ports_connected->len; i++) {
737 struct bt_graph_listener listener =
738 g_array_index(graph->listeners.ports_connected,
739 struct bt_graph_listener, i);
740 bt_graph_ports_connected_listener func = listener.func;
741
742 assert(func);
743 func(upstream_port, downstream_port, listener.data);
744 }
745 }
746
747 BT_HIDDEN
748 void bt_graph_notify_ports_disconnected(struct bt_graph *graph,
749 struct bt_component *upstream_comp,
750 struct bt_component *downstream_comp,
751 struct bt_port *upstream_port, struct bt_port *downstream_port)
752 {
753 size_t i;
754
755 BT_LOGV("Notifying graph listeners that two ports were disconnected: "
756 "graph-addr=%p, "
757 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
758 "downstream-port-addr=%p, downstream-port-name=\"%s\"",
759 graph, upstream_port, bt_port_get_name(upstream_port),
760 downstream_port, bt_port_get_name(downstream_port));
761
762 for (i = 0; i < graph->listeners.ports_disconnected->len; i++) {
763 struct bt_graph_listener listener =
764 g_array_index(graph->listeners.ports_disconnected,
765 struct bt_graph_listener, i);
766 bt_graph_ports_disconnected_listener func = listener.func;
767
768 assert(func);
769 func(upstream_comp, downstream_comp, upstream_port,
770 downstream_port, listener.data);
771 }
772 }
773
774 extern enum bt_graph_status bt_graph_cancel(struct bt_graph *graph)
775 {
776 enum bt_graph_status ret = BT_GRAPH_STATUS_OK;
777
778 if (!graph) {
779 BT_LOGW_STR("Invalid parameter: graph is NULL.");
780 ret = BT_GRAPH_STATUS_INVALID;
781 goto end;
782 }
783
784 graph->canceled = BT_TRUE;
785 BT_LOGV("Canceled graph: addr=%p", graph);
786
787 end:
788 return ret;
789 }
790
791 extern bt_bool bt_graph_is_canceled(struct bt_graph *graph)
792 {
793 return graph ? graph->canceled : BT_FALSE;
794 }
795
796 BT_HIDDEN
797 void bt_graph_remove_connection(struct bt_graph *graph,
798 struct bt_connection *connection)
799 {
800 assert(graph);
801 assert(connection);
802 BT_LOGV("Removing graph's connection: graph-addr=%p, conn-addr=%p",
803 graph, connection);
804 g_ptr_array_remove(graph->connections, connection);
805 }
This page took 0.053195 seconds and 4 git commands to generate.