Add query executor
[babeltrace.git] / lib / graph / graph.c
CommitLineData
c0418dd9 1/*
7d55361f 2 * graph.c
c0418dd9
JG
3 *
4 * Babeltrace Plugin Component Graph
5 *
f60c8b34 6 * Copyright 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
262e5473 7 * Copyright 2017 Philippe Proulx <pproulx@efficios.com>
c0418dd9
JG
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
262e5473
PP
28#define BT_LOG_TAG "GRAPH"
29#include <babeltrace/lib-logging-internal.h>
30
b2e0c907
PP
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>
3d9990ac 38#include <babeltrace/compiler-internal.h>
c55a9f58 39#include <babeltrace/types.h>
36712f1d
PP
40#include <babeltrace/values.h>
41#include <babeltrace/values-internal.h>
f60c8b34 42#include <unistd.h>
1bf957a0
PP
43#include <glib.h>
44
45struct bt_graph_listener {
46 void *func;
eb87cce7 47 bt_graph_listener_removed removed;
1bf957a0
PP
48 void *data;
49};
c0418dd9 50
eb87cce7
PP
51static
52int init_listeners_array(GArray **listeners)
53{
54 int ret = 0;
55
56 assert(listeners);
57 *listeners = g_array_new(FALSE, TRUE, sizeof(struct bt_graph_listener));
58 if (!*listeners) {
59 BT_LOGE_STR("Failed to allocate one GArray.");
60 ret = -1;
61 goto end;
62 }
63
64end:
65 return ret;
66}
67
68static
69void call_remove_listeners(GArray *listeners)
70{
71 size_t i;
72
73 for (i = 0; i < listeners->len; i++) {
74 struct bt_graph_listener listener =
75 g_array_index(listeners, struct bt_graph_listener, i);
76
77 if (listener.removed) {
78 listener.removed(listener.data);
79 }
80 }
81}
82
f60c8b34
JG
83static
84void bt_graph_destroy(struct bt_object *obj)
c0418dd9 85{
f60c8b34
JG
86 struct bt_graph *graph = container_of(obj,
87 struct bt_graph, base);
c0418dd9 88
bd14d768
PP
89 /*
90 * The graph's reference count is 0 if we're here. Increment
91 * it to avoid a double-destroy (possibly infinitely recursive)
92 * in this situation:
93 *
94 * 1. We put and destroy a connection.
95 * 2. This connection's destructor finalizes its active
96 * notification iterators.
97 * 3. A notification iterator's finalization function gets a
98 * new reference on its component (reference count goes from
99 * 0 to 1).
100 * 4. Since this component's reference count goes to 1, it takes
101 * a reference on its parent (this graph). This graph's
102 * reference count goes from 0 to 1.
103 * 5. The notification iterator's finalization function puts its
104 * component reference (reference count goes from 1 to 0).
105 * 6. Since this component's reference count goes from 1 to 0,
106 * it puts its parent (this graph). This graph's reference
107 * count goes from 1 to 0.
108 * 7. Since this graph's reference count goes from 1 to 0,
109 * its destructor is called (this function).
110 *
111 * With the incrementation below, the graph's reference count at
112 * step 4 goes from 1 to 2, and from 2 to 1 at step 6. This
113 * ensures that this function is not called two times.
114 */
262e5473 115 BT_LOGD("Destroying graph: addr=%p", graph);
bd14d768
PP
116 obj->ref_count.count++;
117
49682acd
PP
118 /*
119 * Cancel the graph to disallow some operations, like creating
120 * notification iterators and adding ports to components.
121 */
122 (void) bt_graph_cancel(graph);
123
eb87cce7
PP
124 /* Call all remove listeners */
125 call_remove_listeners(graph->listeners.port_added);
126 call_remove_listeners(graph->listeners.port_removed);
127 call_remove_listeners(graph->listeners.ports_connected);
128 call_remove_listeners(graph->listeners.ports_disconnected);
129
c0418dd9 130 if (graph->connections) {
262e5473 131 BT_LOGD_STR("Destroying connections.");
c0418dd9
JG
132 g_ptr_array_free(graph->connections, TRUE);
133 }
bd14d768 134 if (graph->components) {
262e5473 135 BT_LOGD_STR("Destroying components.");
bd14d768
PP
136 g_ptr_array_free(graph->components, TRUE);
137 }
f60c8b34
JG
138 if (graph->sinks_to_consume) {
139 g_queue_free(graph->sinks_to_consume);
c0418dd9 140 }
1bf957a0
PP
141
142 if (graph->listeners.port_added) {
143 g_array_free(graph->listeners.port_added, TRUE);
144 }
145
146 if (graph->listeners.port_removed) {
147 g_array_free(graph->listeners.port_removed, TRUE);
148 }
149
f345f8bb
PP
150 if (graph->listeners.ports_connected) {
151 g_array_free(graph->listeners.ports_connected, TRUE);
1bf957a0
PP
152 }
153
f345f8bb
PP
154 if (graph->listeners.ports_disconnected) {
155 g_array_free(graph->listeners.ports_disconnected, TRUE);
1bf957a0
PP
156 }
157
c0418dd9
JG
158 g_free(graph);
159}
160
f60c8b34 161struct bt_graph *bt_graph_create(void)
c0418dd9 162{
f60c8b34 163 struct bt_graph *graph;
1bf957a0 164 int ret;
c0418dd9 165
262e5473 166 BT_LOGD_STR("Creating graph object.");
f60c8b34 167 graph = g_new0(struct bt_graph, 1);
c0418dd9 168 if (!graph) {
262e5473 169 BT_LOGE_STR("Failed to allocate one graph.");
c0418dd9
JG
170 goto end;
171 }
172
f60c8b34 173 bt_object_init(graph, bt_graph_destroy);
c0418dd9 174
f60c8b34 175 graph->connections = g_ptr_array_new_with_free_func(bt_object_release);
c0418dd9 176 if (!graph->connections) {
262e5473 177 BT_LOGE_STR("Failed to allocate one GPtrArray.");
c0418dd9
JG
178 goto error;
179 }
f60c8b34
JG
180 graph->components = g_ptr_array_new_with_free_func(bt_object_release);
181 if (!graph->components) {
262e5473 182 BT_LOGE_STR("Failed to allocate one GPtrArray.");
f60c8b34
JG
183 goto error;
184 }
185 graph->sinks_to_consume = g_queue_new();
186 if (!graph->sinks_to_consume) {
262e5473 187 BT_LOGE_STR("Failed to allocate one GQueue.");
c0418dd9
JG
188 goto error;
189 }
1bf957a0
PP
190
191 ret = init_listeners_array(&graph->listeners.port_added);
192 if (ret) {
262e5473 193 BT_LOGE_STR("Cannot create the \"port added\" listener array.");
1bf957a0
PP
194 goto error;
195 }
196
197 ret = init_listeners_array(&graph->listeners.port_removed);
198 if (ret) {
262e5473 199 BT_LOGE_STR("Cannot create the \"port removed\" listener array.");
1bf957a0
PP
200 goto error;
201 }
202
f345f8bb 203 ret = init_listeners_array(&graph->listeners.ports_connected);
1bf957a0 204 if (ret) {
262e5473 205 BT_LOGE_STR("Cannot create the \"port connected\" listener array.");
1bf957a0
PP
206 goto error;
207 }
208
f345f8bb 209 ret = init_listeners_array(&graph->listeners.ports_disconnected);
1bf957a0 210 if (ret) {
262e5473 211 BT_LOGE_STR("Cannot create the \"port disconneted\" listener array.");
1bf957a0
PP
212 goto error;
213 }
214
262e5473
PP
215 BT_LOGD("Created graph object: addr=%p", graph);
216
c0418dd9
JG
217end:
218 return graph;
219error:
220 BT_PUT(graph);
221 goto end;
222}
223
a256a42d
PP
224enum bt_graph_status bt_graph_connect_ports(struct bt_graph *graph,
225 struct bt_port *upstream_port, struct bt_port *downstream_port,
226 struct bt_connection **user_connection)
f60c8b34 227{
a256a42d 228 enum bt_graph_status status = BT_GRAPH_STATUS_OK;
f60c8b34
JG
229 struct bt_connection *connection = NULL;
230 struct bt_graph *upstream_graph = NULL;
231 struct bt_graph *downstream_graph = NULL;
232 struct bt_component *upstream_component = NULL;
233 struct bt_component *downstream_component = NULL;
234 enum bt_component_status component_status;
f60c8b34 235
262e5473
PP
236 if (!graph) {
237 BT_LOGW_STR("Invalid parameter: graph is NULL.");
a256a42d 238 status = BT_GRAPH_STATUS_INVALID;
262e5473
PP
239 goto end;
240 }
241
242 if (!upstream_port) {
243 BT_LOGW_STR("Invalid parameter: upstream port is NULL.");
a256a42d 244 status = BT_GRAPH_STATUS_INVALID;
262e5473
PP
245 goto end;
246 }
247
248 if (!downstream_port) {
249 BT_LOGW_STR("Invalid parameter: downstream port is NULL.");
a256a42d 250 status = BT_GRAPH_STATUS_INVALID;
f60c8b34
JG
251 goto end;
252 }
253
262e5473
PP
254 BT_LOGD("Connecting component ports within graph: "
255 "graph-addr=%p, "
256 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
257 "downstream-port-addr=%p, downstream-port-name=\"%s\"",
258 graph, upstream_port, bt_port_get_name(upstream_port),
259 downstream_port, bt_port_get_name(downstream_port));
260
202a3a13 261 if (graph->canceled) {
262e5473 262 BT_LOGW_STR("Invalid parameter: graph is canceled.");
a256a42d 263 status = BT_GRAPH_STATUS_CANCELED;
202a3a13
PP
264 goto end;
265 }
266
72b913fb 267 /* Ensure appropriate types for upstream and downstream ports. */
f60c8b34 268 if (bt_port_get_type(upstream_port) != BT_PORT_TYPE_OUTPUT) {
262e5473 269 BT_LOGW_STR("Invalid parameter: upstream port is not an output port.");
a256a42d 270 status = BT_GRAPH_STATUS_INVALID;
f60c8b34
JG
271 goto end;
272 }
273 if (bt_port_get_type(downstream_port) != BT_PORT_TYPE_INPUT) {
262e5473 274 BT_LOGW_STR("Invalid parameter: downstream port is not an input port.");
a256a42d 275 status = BT_GRAPH_STATUS_INVALID;
f60c8b34
JG
276 goto end;
277 }
278
72b913fb 279 /* Ensure that both ports are currently unconnected. */
0d8b4d8e 280 if (bt_port_is_connected(upstream_port)) {
262e5473 281 BT_LOGW_STR("Invalid parameter: upstream port is already connected.");
a256a42d 282 status = BT_GRAPH_STATUS_INVALID;
72b913fb
PP
283 goto end;
284 }
285
0d8b4d8e 286 if (bt_port_is_connected(downstream_port)) {
262e5473 287 BT_LOGW_STR("Invalid parameter: downstream port is already connected.");
a256a42d 288 status = BT_GRAPH_STATUS_INVALID;
72b913fb
PP
289 goto end;
290 }
291
292 /*
293 * Ensure that both ports are still attached to their creating
294 * component.
295 */
f60c8b34 296 upstream_component = bt_port_get_component(upstream_port);
72b913fb 297 if (!upstream_component) {
262e5473 298 BT_LOGW_STR("Invalid parameter: upstream port is loose (does not belong to a component)");
a256a42d 299 status = BT_GRAPH_STATUS_INVALID;
72b913fb
PP
300 goto end;
301 }
302
303 downstream_component = bt_port_get_component(downstream_port);
304 if (!downstream_component) {
262e5473 305 BT_LOGW_STR("Invalid parameter: downstream port is loose (does not belong to a component)");
a256a42d 306 status = BT_GRAPH_STATUS_INVALID;
72b913fb
PP
307 goto end;
308 }
309
262e5473
PP
310 BT_LOGD("Connecting component ports: "
311 "upstream-comp-addr=%p, upstream-comp-name=\"%s\", "
312 "downstream-comp-addr=%p, downstream-comp-name=\"%s\"",
313 upstream_component, bt_component_get_name(upstream_component),
314 downstream_component, bt_component_get_name(downstream_component));
315
0d8b4d8e
PP
316 /*
317 * At this point the ports are not connected yet. Both
318 * components need to accept an eventual connection to their
319 * port by the other port before we continue.
320 */
262e5473 321 BT_LOGD_STR("Asking upstream component to accept the connection.");
0d8b4d8e
PP
322 component_status = bt_component_accept_port_connection(
323 upstream_component, upstream_port, downstream_port);
324 if (component_status != BT_COMPONENT_STATUS_OK) {
262e5473
PP
325 if (component_status == BT_COMPONENT_STATUS_REFUSE_PORT_CONNECTION) {
326 BT_LOGD_STR("Upstream component refused the connection.");
327 } else {
328 BT_LOGW("Cannot ask upstream component to accept the connection: "
329 "status=%s", bt_component_status_string(component_status));
330 }
331
a256a42d
PP
332 status = bt_graph_status_from_component_status(
333 component_status);
334 goto end;
0d8b4d8e 335 }
262e5473
PP
336
337 BT_LOGD_STR("Asking downstream component to accept the connection.");
0d8b4d8e
PP
338 component_status = bt_component_accept_port_connection(
339 downstream_component, downstream_port, upstream_port);
340 if (component_status != BT_COMPONENT_STATUS_OK) {
262e5473
PP
341 if (component_status == BT_COMPONENT_STATUS_REFUSE_PORT_CONNECTION) {
342 BT_LOGD_STR("Downstream component refused the connection.");
343 } else {
344 BT_LOGW("Cannot ask downstream component to accept the connection: "
345 "status=%s", bt_component_status_string(component_status));
346 }
347
a256a42d
PP
348 status = bt_graph_status_from_component_status(
349 component_status);
350 goto end;
0d8b4d8e
PP
351 }
352
262e5473 353 BT_LOGD_STR("Creating connection.");
f60c8b34
JG
354 connection = bt_connection_create(graph, upstream_port,
355 downstream_port);
356 if (!connection) {
262e5473 357 BT_LOGW("Cannot create connection object.");
a256a42d
PP
358 status = BT_GRAPH_STATUS_NOMEM;
359 goto end;
f60c8b34
JG
360 }
361
262e5473
PP
362 BT_LOGD("Connection object created: conn-addr=%p", connection);
363
f60c8b34 364 /*
72b913fb
PP
365 * Ownership of upstream_component/downstream_component and of
366 * the connection object is transferred to the graph.
f60c8b34
JG
367 */
368 g_ptr_array_add(graph->connections, connection);
ffeb0eed 369
f60c8b34 370 /*
0d8b4d8e 371 * Notify both components that their port is connected.
f60c8b34 372 */
262e5473 373 BT_LOGD_STR("Notifying upstream component that its port is connected.");
0d8b4d8e
PP
374 bt_component_port_connected(upstream_component, upstream_port,
375 downstream_port);
262e5473 376 BT_LOGD_STR("Notifying downstream component that its port is connected.");
0d8b4d8e
PP
377 bt_component_port_connected(downstream_component, downstream_port,
378 upstream_port);
1bf957a0
PP
379
380 /*
0d8b4d8e 381 * Notify the graph's creator that both ports are connected.
1bf957a0 382 */
262e5473 383 BT_LOGD_STR("Notifying graph's user that new component ports are connected.");
f345f8bb 384 bt_graph_notify_ports_connected(graph, upstream_port, downstream_port);
262e5473
PP
385 BT_LOGD("Connected component ports within graph: "
386 "graph-addr=%p, "
387 "upstream-comp-addr=%p, upstream-comp-name=\"%s\", "
388 "downstream-comp-addr=%p, downstream-comp-name=\"%s\", "
389 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
390 "downstream-port-addr=%p, downstream-port-name=\"%s\"",
391 graph,
392 upstream_component, bt_component_get_name(upstream_component),
393 downstream_component, bt_component_get_name(downstream_component),
394 upstream_port, bt_port_get_name(upstream_port),
395 downstream_port, bt_port_get_name(downstream_port));
1bf957a0 396
a256a42d 397 if (user_connection) {
1a6a376a
PP
398 /* Move reference to user */
399 *user_connection = connection;
400 connection = NULL;
a256a42d
PP
401 }
402
f60c8b34
JG
403end:
404 bt_put(upstream_graph);
405 bt_put(downstream_graph);
3eeacbb9
JG
406 bt_put(upstream_component);
407 bt_put(downstream_component);
a256a42d
PP
408 bt_put(connection);
409 return status;
f60c8b34
JG
410}
411
851b70bd
PP
412static
413enum bt_graph_status bt_graph_consume_no_check(struct bt_graph *graph)
c0418dd9 414{
f60c8b34 415 struct bt_component *sink;
72b913fb
PP
416 enum bt_graph_status status = BT_GRAPH_STATUS_OK;
417 enum bt_component_status comp_status;
f60c8b34
JG
418 GList *current_node;
419
851b70bd 420 BT_LOGV("Making next sink consume: addr=%p", graph);
202a3a13 421
aebb2750
PP
422 if (!graph->has_sink) {
423 BT_LOGW_STR("Graph has no sink component.");
424 status = BT_GRAPH_STATUS_NO_SINK;
425 goto end;
426 }
427
f60c8b34 428 if (g_queue_is_empty(graph->sinks_to_consume)) {
262e5473 429 BT_LOGV_STR("Graph's sink queue is empty: end of graph.");
72b913fb 430 status = BT_GRAPH_STATUS_END;
f60c8b34
JG
431 goto end;
432 }
433
434 current_node = g_queue_pop_head_link(graph->sinks_to_consume);
435 sink = current_node->data;
262e5473
PP
436 BT_LOGV("Chose next sink to consume: comp-addr=%p, comp-name=\"%s\"",
437 sink, bt_component_get_name(sink));
72b913fb 438 comp_status = bt_component_sink_consume(sink);
262e5473
PP
439 BT_LOGV("Consumed from sink: status=%s",
440 bt_component_status_string(comp_status));
72b913fb
PP
441 switch (comp_status) {
442 case BT_COMPONENT_STATUS_OK:
443 break;
444 case BT_COMPONENT_STATUS_END:
445 status = BT_GRAPH_STATUS_END;
446 break;
447 case BT_COMPONENT_STATUS_AGAIN:
448 status = BT_GRAPH_STATUS_AGAIN;
449 break;
450 case BT_COMPONENT_STATUS_INVALID:
451 status = BT_GRAPH_STATUS_INVALID;
452 break;
453 default:
454 status = BT_GRAPH_STATUS_ERROR;
455 break;
456 }
457
458 if (status != BT_GRAPH_STATUS_END) {
f60c8b34
JG
459 g_queue_push_tail_link(graph->sinks_to_consume, current_node);
460 goto end;
461 }
462
463 /* End reached, the node is not added back to the queue and free'd. */
464 g_queue_delete_link(graph->sinks_to_consume, current_node);
465
466 /* Don't forward an END status if there are sinks left to consume. */
467 if (!g_queue_is_empty(graph->sinks_to_consume)) {
468 status = BT_GRAPH_STATUS_OK;
469 goto end;
470 }
471end:
262e5473 472 BT_LOGV("Graph consumed: status=%s", bt_graph_status_string(status));
f60c8b34 473 return status;
c0418dd9
JG
474}
475
851b70bd
PP
476enum bt_graph_status bt_graph_consume(struct bt_graph *graph)
477{
478 enum bt_graph_status status = BT_GRAPH_STATUS_OK;
479
480 if (!graph) {
481 BT_LOGW_STR("Invalid parameter: graph is NULL.");
482 status = BT_GRAPH_STATUS_INVALID;
483 goto end;
484 }
485
486 if (graph->canceled) {
487 BT_LOGW("Invalid parameter: graph is canceled: "
488 "graph-addr=%p", graph);
489 status = BT_GRAPH_STATUS_CANCELED;
490 goto end;
491 }
492
493 status = bt_graph_consume_no_check(graph);
494
495end:
496 return status;
497}
498
72b913fb 499enum bt_graph_status bt_graph_run(struct bt_graph *graph)
f60c8b34 500{
72b913fb 501 enum bt_graph_status status = BT_GRAPH_STATUS_OK;
f60c8b34
JG
502
503 if (!graph) {
262e5473 504 BT_LOGW_STR("Invalid parameter: graph is NULL.");
72b913fb 505 status = BT_GRAPH_STATUS_INVALID;
202a3a13 506 goto end;
f60c8b34
JG
507 }
508
851b70bd
PP
509 if (graph->canceled) {
510 BT_LOGW("Invalid parameter: graph is canceled: "
511 "graph-addr=%p", graph);
512 status = BT_GRAPH_STATUS_CANCELED;
513 goto end;
514 }
515
262e5473
PP
516 BT_LOGV("Running graph: addr=%p", graph);
517
f60c8b34 518 do {
851b70bd
PP
519 /*
520 * Check if the graph is canceled at each iteration. If
521 * the graph was canceled by another thread or by a
522 * signal, this is not a warning nor an error, it was
523 * intentional: log with a DEBUG level only.
524 */
525 if (graph->canceled) {
526 BT_LOGD("Stopping the graph: graph is canceled: "
527 "graph-addr=%p", graph);
528 status = BT_GRAPH_STATUS_CANCELED;
529 goto end;
530 }
531
72b913fb
PP
532 status = bt_graph_consume(graph);
533 if (status == BT_GRAPH_STATUS_AGAIN) {
f60c8b34 534 /*
202a3a13
PP
535 * If AGAIN is received and there are multiple
536 * sinks, go ahead and consume from the next
537 * sink.
f60c8b34 538 *
202a3a13
PP
539 * However, in the case where a single sink is
540 * left, the caller can decide to busy-wait and
541 * call bt_graph_run() continuously until the
542 * source is ready or it can decide to sleep for
543 * an arbitrary amount of time.
f60c8b34
JG
544 */
545 if (graph->sinks_to_consume->length > 1) {
72b913fb 546 status = BT_GRAPH_STATUS_OK;
f60c8b34 547 }
aebb2750
PP
548 } else if (status == BT_GRAPH_STATUS_NO_SINK) {
549 goto end;
f60c8b34 550 }
72b913fb 551 } while (status == BT_GRAPH_STATUS_OK);
f60c8b34
JG
552
553 if (g_queue_is_empty(graph->sinks_to_consume)) {
72b913fb 554 status = BT_GRAPH_STATUS_END;
f60c8b34 555 }
262e5473 556
202a3a13 557end:
262e5473 558 BT_LOGV("Graph ran: status=%s", bt_graph_status_string(status));
72b913fb 559 return status;
f60c8b34 560}
1bf957a0
PP
561
562static
eb87cce7 563int add_listener(GArray *listeners, void *func, void *removed, void *data)
1bf957a0
PP
564{
565 struct bt_graph_listener listener = {
566 .func = func,
eb87cce7 567 .removed = removed,
1bf957a0
PP
568 .data = data,
569 };
570
571 g_array_append_val(listeners, listener);
0d107cdd 572 return listeners->len - 1;
1bf957a0
PP
573}
574
0d107cdd 575int bt_graph_add_port_added_listener(
1bf957a0 576 struct bt_graph *graph,
eb87cce7
PP
577 bt_graph_port_added_listener listener,
578 bt_graph_listener_removed listener_removed, void *data)
1bf957a0 579{
0d107cdd 580 int ret;
1bf957a0 581
262e5473
PP
582 if (!graph) {
583 BT_LOGW_STR("Invalid parameter: graph is NULL.");
0d107cdd 584 ret = -1;
262e5473
PP
585 goto end;
586 }
587
eb87cce7
PP
588 if (graph->in_remove_listener) {
589 BT_LOGW("Cannot call this function during the execution of a remove listener: "
590 "addr=%p", graph);
591 ret = -1;
592 goto end;
593 }
594
262e5473
PP
595 if (!listener) {
596 BT_LOGW_STR("Invalid parameter: listener is NULL.");
0d107cdd 597 ret = -1;
1bf957a0
PP
598 goto end;
599 }
600
eb87cce7
PP
601 ret = add_listener(graph->listeners.port_added, listener,
602 listener_removed, data);
262e5473 603 BT_LOGV("Added \"port added\" listener to graph: "
0d107cdd
PP
604 "graph-addr=%p, listener-addr=%p, pos=%d",
605 graph, listener, ret);
1bf957a0
PP
606
607end:
0d107cdd 608 return ret;
1bf957a0
PP
609}
610
0d107cdd 611int bt_graph_add_port_removed_listener(
1bf957a0 612 struct bt_graph *graph,
eb87cce7
PP
613 bt_graph_port_removed_listener listener,
614 bt_graph_listener_removed listener_removed, void *data)
1bf957a0 615{
0d107cdd 616 int ret;
1bf957a0 617
262e5473
PP
618 if (!graph) {
619 BT_LOGW_STR("Invalid parameter: graph is NULL.");
0d107cdd 620 ret = -1;
262e5473
PP
621 goto end;
622 }
623
eb87cce7
PP
624 if (graph->in_remove_listener) {
625 BT_LOGW("Cannot call this function during the execution of a remove listener: "
626 "addr=%p", graph);
627 ret = -1;
628 goto end;
629 }
630
262e5473
PP
631 if (!listener) {
632 BT_LOGW_STR("Invalid parameter: listener is NULL.");
0d107cdd 633 ret = -1;
1bf957a0
PP
634 goto end;
635 }
636
eb87cce7
PP
637 ret = add_listener(graph->listeners.port_removed, listener,
638 listener_removed, data);
262e5473 639 BT_LOGV("Added \"port removed\" listener to graph: "
0d107cdd
PP
640 "graph-addr=%p, listener-addr=%p, pos=%d",
641 graph, listener, ret);
1bf957a0
PP
642
643end:
0d107cdd 644 return ret;
1bf957a0
PP
645}
646
0d107cdd 647int bt_graph_add_ports_connected_listener(
1bf957a0 648 struct bt_graph *graph,
eb87cce7
PP
649 bt_graph_ports_connected_listener listener,
650 bt_graph_listener_removed listener_removed, void *data)
1bf957a0 651{
0d107cdd 652 int ret;
1bf957a0 653
262e5473
PP
654 if (!graph) {
655 BT_LOGW_STR("Invalid parameter: graph is NULL.");
0d107cdd 656 ret = -1;
262e5473
PP
657 goto end;
658 }
659
eb87cce7
PP
660 if (graph->in_remove_listener) {
661 BT_LOGW("Cannot call this function during the execution of a remove listener: "
662 "addr=%p", graph);
663 ret = -1;
664 goto end;
665 }
666
262e5473
PP
667 if (!listener) {
668 BT_LOGW_STR("Invalid parameter: listener is NULL.");
0d107cdd 669 ret = -1;
1bf957a0
PP
670 goto end;
671 }
672
eb87cce7
PP
673 ret = add_listener(graph->listeners.ports_connected, listener,
674 listener_removed, data);
262e5473 675 BT_LOGV("Added \"port connected\" listener to graph: "
0d107cdd
PP
676 "graph-addr=%p, listener-addr=%p, pos=%d",
677 graph, listener, ret);
1bf957a0
PP
678
679end:
0d107cdd 680 return ret;
1bf957a0
PP
681}
682
0d107cdd 683int bt_graph_add_ports_disconnected_listener(
1bf957a0 684 struct bt_graph *graph,
eb87cce7
PP
685 bt_graph_ports_disconnected_listener listener,
686 bt_graph_listener_removed listener_removed, void *data)
1bf957a0 687{
0d107cdd 688 int ret;
1bf957a0 689
262e5473
PP
690 if (!graph) {
691 BT_LOGW_STR("Invalid parameter: graph is NULL.");
0d107cdd 692 ret = -1;
262e5473
PP
693 goto end;
694 }
695
eb87cce7
PP
696 if (graph->in_remove_listener) {
697 BT_LOGW("Cannot call this function during the execution of a remove listener: "
698 "addr=%p", graph);
699 ret = -1;
700 goto end;
701 }
702
262e5473
PP
703 if (!listener) {
704 BT_LOGW_STR("Invalid parameter: listener is NULL.");
0d107cdd 705 ret = -1;
1bf957a0
PP
706 goto end;
707 }
708
eb87cce7
PP
709 ret = add_listener(graph->listeners.ports_disconnected, listener,
710 listener_removed, data);
262e5473 711 BT_LOGV("Added \"port disconnected\" listener to graph: "
0d107cdd
PP
712 "graph-addr=%p, listener-addr=%p, pos=%d",
713 graph, listener, ret);
1bf957a0
PP
714
715end:
0d107cdd 716 return ret;
1bf957a0
PP
717}
718
719BT_HIDDEN
720void bt_graph_notify_port_added(struct bt_graph *graph, struct bt_port *port)
721{
722 size_t i;
723
262e5473
PP
724 BT_LOGV("Notifying graph listeners that a port was added: "
725 "graph-addr=%p, port-addr=%p, port-name=\"%s\"",
726 graph, port, bt_port_get_name(port));
727
1bf957a0
PP
728 for (i = 0; i < graph->listeners.port_added->len; i++) {
729 struct bt_graph_listener listener =
730 g_array_index(graph->listeners.port_added,
731 struct bt_graph_listener, i);
732 bt_graph_port_added_listener func = listener.func;
733
734 assert(func);
735 func(port, listener.data);
736 }
737}
738
739BT_HIDDEN
740void bt_graph_notify_port_removed(struct bt_graph *graph,
741 struct bt_component *comp, struct bt_port *port)
742{
743 size_t i;
744
262e5473
PP
745 BT_LOGV("Notifying graph listeners that a port was removed: "
746 "graph-addr=%p, port-addr=%p, port-name=\"%s\"",
747 graph, port, bt_port_get_name(port));
748
1bf957a0
PP
749 for (i = 0; i < graph->listeners.port_removed->len; i++) {
750 struct bt_graph_listener listener =
751 g_array_index(graph->listeners.port_removed,
752 struct bt_graph_listener, i);
753 bt_graph_port_removed_listener func = listener.func;
754
755 assert(func);
756 func(comp, port, listener.data);
757 }
758}
759
760BT_HIDDEN
f345f8bb
PP
761void bt_graph_notify_ports_connected(struct bt_graph *graph,
762 struct bt_port *upstream_port, struct bt_port *downstream_port)
1bf957a0
PP
763{
764 size_t i;
765
262e5473
PP
766 BT_LOGV("Notifying graph listeners that two ports were connected: "
767 "graph-addr=%p, "
768 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
769 "downstream-port-addr=%p, downstream-port-name=\"%s\"",
770 graph, upstream_port, bt_port_get_name(upstream_port),
771 downstream_port, bt_port_get_name(downstream_port));
772
f345f8bb 773 for (i = 0; i < graph->listeners.ports_connected->len; i++) {
1bf957a0 774 struct bt_graph_listener listener =
f345f8bb 775 g_array_index(graph->listeners.ports_connected,
1bf957a0 776 struct bt_graph_listener, i);
f345f8bb 777 bt_graph_ports_connected_listener func = listener.func;
1bf957a0
PP
778
779 assert(func);
f345f8bb 780 func(upstream_port, downstream_port, listener.data);
1bf957a0
PP
781 }
782}
783
784BT_HIDDEN
f345f8bb
PP
785void bt_graph_notify_ports_disconnected(struct bt_graph *graph,
786 struct bt_component *upstream_comp,
787 struct bt_component *downstream_comp,
788 struct bt_port *upstream_port, struct bt_port *downstream_port)
1bf957a0
PP
789{
790 size_t i;
791
262e5473
PP
792 BT_LOGV("Notifying graph listeners that two ports were disconnected: "
793 "graph-addr=%p, "
794 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
795 "downstream-port-addr=%p, downstream-port-name=\"%s\"",
796 graph, upstream_port, bt_port_get_name(upstream_port),
797 downstream_port, bt_port_get_name(downstream_port));
798
f345f8bb 799 for (i = 0; i < graph->listeners.ports_disconnected->len; i++) {
1bf957a0 800 struct bt_graph_listener listener =
f345f8bb 801 g_array_index(graph->listeners.ports_disconnected,
1bf957a0 802 struct bt_graph_listener, i);
f345f8bb 803 bt_graph_ports_disconnected_listener func = listener.func;
1bf957a0
PP
804
805 assert(func);
f345f8bb
PP
806 func(upstream_comp, downstream_comp, upstream_port,
807 downstream_port, listener.data);
1bf957a0
PP
808 }
809}
202a3a13 810
1286dcbb 811enum bt_graph_status bt_graph_cancel(struct bt_graph *graph)
202a3a13
PP
812{
813 enum bt_graph_status ret = BT_GRAPH_STATUS_OK;
814
815 if (!graph) {
262e5473 816 BT_LOGW_STR("Invalid parameter: graph is NULL.");
202a3a13
PP
817 ret = BT_GRAPH_STATUS_INVALID;
818 goto end;
819 }
820
821 graph->canceled = BT_TRUE;
262e5473 822 BT_LOGV("Canceled graph: addr=%p", graph);
202a3a13
PP
823
824end:
825 return ret;
826}
827
1286dcbb 828bt_bool bt_graph_is_canceled(struct bt_graph *graph)
202a3a13 829{
1286dcbb
PP
830 bt_bool canceled = BT_FALSE;
831
832 if (!graph) {
833 BT_LOGW_STR("Invalid parameter: graph is NULL.");
834 goto end;
835 }
836
837 canceled = graph->canceled;
838
839end:
840 return canceled;
202a3a13 841}
f167d3c0
PP
842
843BT_HIDDEN
844void bt_graph_remove_connection(struct bt_graph *graph,
845 struct bt_connection *connection)
846{
847 assert(graph);
848 assert(connection);
262e5473
PP
849 BT_LOGV("Removing graph's connection: graph-addr=%p, conn-addr=%p",
850 graph, connection);
f167d3c0
PP
851 g_ptr_array_remove(graph->connections, connection);
852}
36712f1d
PP
853
854enum bt_graph_status bt_graph_add_component_with_init_method_data(
855 struct bt_graph *graph,
856 struct bt_component_class *component_class,
857 const char *name, struct bt_value *params,
858 void *init_method_data,
859 struct bt_component **user_component)
860{
861 enum bt_graph_status graph_status = BT_GRAPH_STATUS_OK;
862 enum bt_component_status comp_status;
863 struct bt_component *component = NULL;
864 enum bt_component_class_type type;
865 size_t i;
866
867 bt_get(params);
868
869 if (!graph) {
870 BT_LOGW_STR("Invalid parameter: graph is NULL.");
871 graph_status = BT_GRAPH_STATUS_INVALID;
872 goto end;
873 }
874
875 if (!component_class) {
876 BT_LOGW_STR("Invalid parameter: component class is NULL.");
877 graph_status = BT_GRAPH_STATUS_INVALID;
878 goto end;
879 }
880
881 type = bt_component_class_get_type(component_class);
882 BT_LOGD("Adding component to graph: "
883 "graph-addr=%p, comp-cls-addr=%p, "
884 "comp-cls-type=%s, name=\"%s\", params-addr=%p, "
885 "init-method-data-addr=%p",
886 graph, component_class, bt_component_class_type_string(type),
887 name, params, init_method_data);
888
889 if (!name) {
890 BT_LOGW_STR("Invalid parameter: name is NULL.");
891 graph_status = BT_GRAPH_STATUS_INVALID;
892 goto end;
893 }
894
895 if (graph->canceled) {
896 BT_LOGW_STR("Invalid parameter: graph is canceled.");
897 graph_status = BT_GRAPH_STATUS_CANCELED;
898 goto end;
899 }
900
901 if (type != BT_COMPONENT_CLASS_TYPE_SOURCE &&
902 type != BT_COMPONENT_CLASS_TYPE_FILTER &&
903 type != BT_COMPONENT_CLASS_TYPE_SINK) {
904 BT_LOGW("Invalid parameter: unknown component class type: "
905 "type=%d", type);
906 graph_status = BT_GRAPH_STATUS_INVALID;
907 goto end;
908 }
909
910 for (i = 0; i < graph->components->len; i++) {
911 void *other_comp = graph->components->pdata[i];
912
913 if (strcmp(name, bt_component_get_name(other_comp)) == 0) {
914 BT_LOGW("Invalid parameter: another component with the same name already exists in the graph: "
915 "other-comp-addr=%p, name=\"%s\"",
916 other_comp, name);
917 graph_status = BT_GRAPH_STATUS_INVALID;
918 goto end;
919 }
920 }
921
922 /*
923 * Parameters must be a map value, but we create a convenient
924 * empty one if it's NULL.
925 */
926 if (params) {
927 if (!bt_value_is_map(params)) {
928 BT_LOGW("Invalid parameter: initialization parameters must be a map value: "
929 "type=%s",
930 bt_value_type_string(bt_value_get_type(params)));
931 graph_status = BT_GRAPH_STATUS_INVALID;
932 goto end;
933 }
934 } else {
935 params = bt_value_map_create();
936 if (!params) {
937 BT_LOGE_STR("Cannot create map value object.");
938 graph_status = BT_GRAPH_STATUS_NOMEM;
939 goto end;
940 }
941 }
942
943 comp_status = bt_component_create(component_class, name, &component);
944 if (comp_status != BT_COMPONENT_STATUS_OK) {
945 BT_LOGE("Cannot create empty component object: status=%s",
946 bt_component_status_string(comp_status));
947 graph_status = bt_graph_status_from_component_status(
948 comp_status);
949 goto end;
950 }
951
952 /*
953 * The user's initialization method needs to see that this
954 * component is part of the graph. If the user method fails, we
955 * immediately remove the component from the graph's components.
956 */
957 g_ptr_array_add(graph->components, component);
958 bt_component_set_graph(component, graph);
959
960 if (component_class->methods.init) {
961 BT_LOGD_STR("Calling user's initialization method.");
962 comp_status = component_class->methods.init(
963 bt_private_component_from_component(component), params,
964 init_method_data);
965 BT_LOGD("User method returned: status=%s",
966 bt_component_status_string(comp_status));
967 if (comp_status != BT_COMPONENT_STATUS_OK) {
968 BT_LOGW_STR("Initialization method failed.");
969 graph_status = bt_graph_status_from_component_status(
970 comp_status);
971 bt_component_set_graph(component, NULL);
972 g_ptr_array_remove_fast(graph->components, component);
973 goto end;
974 }
975 }
976
977 /*
978 * Mark the component as initialized so that its finalization
979 * method is called when it is destroyed.
980 */
981 component->initialized = true;
982
983 /*
984 * If it's a sink component, it needs to be part of the graph's
985 * sink queue to be consumed by bt_graph_consume().
986 */
987 if (bt_component_is_sink(component)) {
aebb2750 988 graph->has_sink = BT_TRUE;
36712f1d
PP
989 g_queue_push_tail(graph->sinks_to_consume, component);
990 }
991
992 /*
993 * Freeze the component class now that it's instantiated at
994 * least once.
995 */
996 BT_LOGD_STR("Freezing component class.");
997 bt_component_class_freeze(component->class);
998 BT_LOGD("Added component to graph: "
999 "graph-addr=%p, comp-cls-addr=%p, "
1000 "comp-cls-type=%s, name=\"%s\", params-addr=%p, "
1001 "init-method-data-addr=%p, comp-addr=%p",
1002 graph, component_class, bt_component_class_type_string(type),
1003 name, params, init_method_data, component);
1004
1005 if (user_component) {
1006 /* Move reference to user */
1007 *user_component = component;
1008 component = NULL;
1009 }
1010
1011end:
1012 bt_put(component);
1013 bt_put(params);
1014 return graph_status;
1015}
1016
1017enum bt_graph_status bt_graph_add_component(
1018 struct bt_graph *graph,
1019 struct bt_component_class *component_class,
1020 const char *name, struct bt_value *params,
1021 struct bt_component **component)
1022{
1023 return bt_graph_add_component_with_init_method_data(graph,
1024 component_class, name, params, NULL, component);
1025}
This page took 0.083616 seconds and 4 git commands to generate.