9ed599448880b647d4d122fd9c50c2d8bb297cde
[babeltrace.git] / lib / graph / component.c
1 /*
2 * component.c
3 *
4 * Babeltrace Plugin Component
5 *
6 * Copyright 2015 Jérémie Galarneau <jeremie.galarneau@efficios.com>
7 *
8 * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
9 *
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
16 *
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
23 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26 * SOFTWARE.
27 */
28
29 #include <babeltrace/graph/private-component.h>
30 #include <babeltrace/graph/component.h>
31 #include <babeltrace/graph/component-internal.h>
32 #include <babeltrace/graph/component-class-internal.h>
33 #include <babeltrace/graph/component-source-internal.h>
34 #include <babeltrace/graph/component-filter-internal.h>
35 #include <babeltrace/graph/component-sink-internal.h>
36 #include <babeltrace/graph/private-connection.h>
37 #include <babeltrace/graph/connection-internal.h>
38 #include <babeltrace/graph/graph-internal.h>
39 #include <babeltrace/graph/notification-iterator-internal.h>
40 #include <babeltrace/graph/private-notification-iterator.h>
41 #include <babeltrace/babeltrace-internal.h>
42 #include <babeltrace/compiler-internal.h>
43 #include <babeltrace/ref.h>
44 #include <babeltrace/types.h>
45 #include <stdint.h>
46
47 static
48 struct bt_component * (* const component_create_funcs[])(
49 struct bt_component_class *, struct bt_value *) = {
50 [BT_COMPONENT_CLASS_TYPE_SOURCE] = bt_component_source_create,
51 [BT_COMPONENT_CLASS_TYPE_SINK] = bt_component_sink_create,
52 [BT_COMPONENT_CLASS_TYPE_FILTER] = bt_component_filter_create,
53 };
54
55 static
56 void (*component_destroy_funcs[])(struct bt_component *) = {
57 [BT_COMPONENT_CLASS_TYPE_SOURCE] = bt_component_source_destroy,
58 [BT_COMPONENT_CLASS_TYPE_SINK] = bt_component_sink_destroy,
59 [BT_COMPONENT_CLASS_TYPE_FILTER] = bt_component_filter_destroy,
60 };
61
62 static
63 enum bt_component_status (* const component_validation_funcs[])(
64 struct bt_component *) = {
65 [BT_COMPONENT_CLASS_TYPE_SOURCE] = bt_component_source_validate,
66 [BT_COMPONENT_CLASS_TYPE_SINK] = bt_component_sink_validate,
67 [BT_COMPONENT_CLASS_TYPE_FILTER] = bt_component_filter_validate,
68 };
69
70 static
71 void bt_component_destroy(struct bt_object *obj)
72 {
73 struct bt_component *component = NULL;
74 struct bt_component_class *component_class = NULL;
75 int i;
76
77 if (!obj) {
78 return;
79 }
80
81 /*
82 * The component's reference count is 0 if we're here. Increment
83 * it to avoid a double-destroy (possibly infinitely recursive).
84 * This could happen for example if the component's finalization
85 * function does bt_get() (or anything that causes bt_get() to
86 * be called) on itself (ref. count goes from 0 to 1), and then
87 * bt_put(): the reference count would go from 1 to 0 again and
88 * this function would be called again.
89 */
90 obj->ref_count.count++;
91 component = container_of(obj, struct bt_component, base);
92
93 /* Call destroy listeners in reverse registration order */
94 for (i = component->destroy_listeners->len - 1; i >= 0; i--) {
95 struct bt_component_destroy_listener *listener =
96 &g_array_index(component->destroy_listeners,
97 struct bt_component_destroy_listener, i);
98
99 listener->func(component, listener->data);
100 }
101
102 component_class = component->class;
103
104 /*
105 * User data is destroyed first, followed by the concrete component
106 * instance.
107 */
108 if (component->class->methods.finalize) {
109 component->class->methods.finalize(
110 bt_private_component_from_component(component));
111 }
112
113 if (component->destroy) {
114 component->destroy(component);
115 }
116
117 if (component->input_ports) {
118 g_ptr_array_free(component->input_ports, TRUE);
119 }
120
121 if (component->output_ports) {
122 g_ptr_array_free(component->output_ports, TRUE);
123 }
124
125 if (component->destroy_listeners) {
126 g_array_free(component->destroy_listeners, TRUE);
127 }
128
129 g_string_free(component->name, TRUE);
130 bt_put(component_class);
131 g_free(component);
132 }
133
134 struct bt_component *bt_component_from_private_component(
135 struct bt_private_component *private_component)
136 {
137 return bt_get(bt_component_from_private(private_component));
138 }
139
140 enum bt_component_class_type bt_component_get_class_type(
141 struct bt_component *component)
142 {
143 return component ? component->class->type : BT_COMPONENT_CLASS_TYPE_UNKNOWN;
144 }
145
146 static
147 struct bt_port *bt_component_add_port(
148 struct bt_component *component, GPtrArray *ports,
149 enum bt_port_type port_type, const char *name, void *user_data)
150 {
151 size_t i;
152 struct bt_port *new_port = NULL;
153 struct bt_graph *graph = NULL;
154
155 if (!name || strlen(name) == 0) {
156 goto end;
157 }
158
159 /* Look for a port having the same name. */
160 for (i = 0; i < ports->len; i++) {
161 const char *port_name;
162 struct bt_port *port = g_ptr_array_index(
163 ports, i);
164
165 port_name = bt_port_get_name(port);
166 if (!port_name) {
167 continue;
168 }
169
170 if (!strcmp(name, port_name)) {
171 /* Port name clash, abort. */
172 goto end;
173 }
174 }
175
176 new_port = bt_port_create(component, port_type, name, user_data);
177 if (!new_port) {
178 goto end;
179 }
180
181 /*
182 * No name clash, add the port.
183 * The component is now the port's parent; it should _not_
184 * hold a reference to the port since the port's lifetime
185 * is now protected by the component's own lifetime.
186 */
187 g_ptr_array_add(ports, new_port);
188
189 /*
190 * Notify the graph's creator that a new port was added.
191 */
192 graph = bt_component_get_graph(component);
193 if (graph) {
194 bt_graph_notify_port_added(graph, new_port);
195 BT_PUT(graph);
196 }
197
198 end:
199 return new_port;
200 }
201
202 BT_HIDDEN
203 int64_t bt_component_get_input_port_count(struct bt_component *comp)
204 {
205 assert(comp);
206 return (int64_t) comp->input_ports->len;
207 }
208
209 BT_HIDDEN
210 int64_t bt_component_get_output_port_count(struct bt_component *comp)
211 {
212 assert(comp);
213 return (int64_t) comp->output_ports->len;
214 }
215
216 struct bt_component *bt_component_create_with_init_method_data(
217 struct bt_component_class *component_class, const char *name,
218 struct bt_value *params, void *init_method_data)
219 {
220 int ret;
221 struct bt_component *component = NULL;
222 enum bt_component_class_type type;
223
224 bt_get(params);
225
226 if (!component_class) {
227 goto end;
228 }
229
230 type = bt_component_class_get_type(component_class);
231 if (type <= BT_COMPONENT_CLASS_TYPE_UNKNOWN ||
232 type > BT_COMPONENT_CLASS_TYPE_FILTER) {
233 goto end;
234 }
235
236 /*
237 * Parameters must be a map value, but we create a convenient
238 * empty one if it's NULL.
239 */
240 if (params) {
241 if (!bt_value_is_map(params)) {
242 goto end;
243 }
244 } else {
245 params = bt_value_map_create();
246 if (!params) {
247 goto end;
248 }
249 }
250
251 component = component_create_funcs[type](component_class, params);
252 if (!component) {
253 goto end;
254 }
255
256 bt_object_init(component, bt_component_destroy);
257 component->class = bt_get(component_class);
258 component->destroy = component_destroy_funcs[type];
259 component->name = g_string_new(name);
260 if (!component->name) {
261 BT_PUT(component);
262 goto end;
263 }
264
265 component->input_ports = g_ptr_array_new_with_free_func(
266 bt_object_release);
267 if (!component->input_ports) {
268 BT_PUT(component);
269 goto end;
270 }
271
272 component->output_ports = g_ptr_array_new_with_free_func(
273 bt_object_release);
274 if (!component->output_ports) {
275 BT_PUT(component);
276 goto end;
277 }
278
279 component->destroy_listeners = g_array_new(FALSE, TRUE,
280 sizeof(struct bt_component_destroy_listener));
281 if (!component->destroy_listeners) {
282 BT_PUT(component);
283 goto end;
284 }
285
286 component->initializing = BT_TRUE;
287
288 if (component_class->methods.init) {
289 ret = component_class->methods.init(
290 bt_private_component_from_component(component), params,
291 init_method_data);
292 component->initializing = BT_FALSE;
293 if (ret != BT_COMPONENT_STATUS_OK) {
294 BT_PUT(component);
295 goto end;
296 }
297 }
298
299 component->initializing = BT_FALSE;
300 ret = component_validation_funcs[type](component);
301 if (ret != BT_COMPONENT_STATUS_OK) {
302 BT_PUT(component);
303 goto end;
304 }
305
306 bt_component_class_freeze(component->class);
307 end:
308 bt_put(params);
309 return component;
310 }
311
312 struct bt_component *bt_component_create(
313 struct bt_component_class *component_class, const char *name,
314 struct bt_value *params)
315 {
316 return bt_component_create_with_init_method_data(component_class, name,
317 params, NULL);
318 }
319
320 const char *bt_component_get_name(struct bt_component *component)
321 {
322 const char *ret = NULL;
323
324 if (!component) {
325 goto end;
326 }
327
328 ret = component->name->len == 0 ? NULL : component->name->str;
329 end:
330 return ret;
331 }
332
333 enum bt_component_status bt_component_set_name(struct bt_component *component,
334 const char *name)
335 {
336 enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
337
338 if (!component || !name || name[0] == '\0') {
339 ret = BT_COMPONENT_STATUS_INVALID;
340 goto end;
341 }
342
343 g_string_assign(component->name, name);
344 end:
345 return ret;
346 }
347
348 struct bt_component_class *bt_component_get_class(
349 struct bt_component *component)
350 {
351 return component ? bt_get(component->class) : NULL;
352 }
353
354 void *bt_private_component_get_user_data(
355 struct bt_private_component *private_component)
356 {
357 struct bt_component *component =
358 bt_component_from_private(private_component);
359
360 return component ? component->user_data : NULL;
361 }
362
363 enum bt_component_status bt_private_component_set_user_data(
364 struct bt_private_component *private_component,
365 void *data)
366 {
367 struct bt_component *component =
368 bt_component_from_private(private_component);
369 enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
370
371 if (!component || !component->initializing) {
372 ret = BT_COMPONENT_STATUS_INVALID;
373 goto end;
374 }
375
376 component->user_data = data;
377 end:
378 return ret;
379 }
380
381 BT_HIDDEN
382 void bt_component_set_graph(struct bt_component *component,
383 struct bt_graph *graph)
384 {
385 struct bt_object *parent = bt_object_get_parent(&component->base);
386
387 assert(!parent || parent == &graph->base);
388 if (!parent) {
389 bt_object_set_parent(component, &graph->base);
390 }
391 bt_put(parent);
392 }
393
394 struct bt_graph *bt_component_get_graph(
395 struct bt_component *component)
396 {
397 return (struct bt_graph *) bt_object_get_parent(&component->base);
398 }
399
400 static
401 struct bt_port *bt_component_get_port_by_name(GPtrArray *ports,
402 const char *name)
403 {
404 size_t i;
405 struct bt_port *ret_port = NULL;
406
407 assert(name);
408
409 for (i = 0; i < ports->len; i++) {
410 struct bt_port *port = g_ptr_array_index(ports, i);
411 const char *port_name = bt_port_get_name(port);
412
413 if (!port_name) {
414 continue;
415 }
416
417 if (!strcmp(name, port_name)) {
418 ret_port = bt_get(port);
419 break;
420 }
421 }
422
423 return ret_port;
424 }
425
426 BT_HIDDEN
427 struct bt_port *bt_component_get_input_port_by_name(struct bt_component *comp,
428 const char *name)
429 {
430 assert(comp);
431
432 return bt_component_get_port_by_name(comp->input_ports, name);
433 }
434
435 BT_HIDDEN
436 struct bt_port *bt_component_get_output_port_by_name(struct bt_component *comp,
437 const char *name)
438 {
439 assert(comp);
440
441 return bt_component_get_port_by_name(comp->output_ports, name);
442 }
443
444 static
445 struct bt_port *bt_component_get_port_by_index(GPtrArray *ports, uint64_t index)
446 {
447 struct bt_port *port = NULL;
448
449 if (index >= ports->len) {
450 goto end;
451 }
452
453 port = bt_get(g_ptr_array_index(ports, index));
454 end:
455 return port;
456 }
457
458 BT_HIDDEN
459 struct bt_port *bt_component_get_input_port_by_index(struct bt_component *comp,
460 uint64_t index)
461 {
462 assert(comp);
463
464 return bt_component_get_port_by_index(comp->input_ports, index);
465 }
466
467 BT_HIDDEN
468 struct bt_port *bt_component_get_output_port_by_index(struct bt_component *comp,
469 uint64_t index)
470 {
471 assert(comp);
472
473 return bt_component_get_port_by_index(comp->output_ports, index);
474 }
475
476 BT_HIDDEN
477 struct bt_port *bt_component_add_input_port(
478 struct bt_component *component, const char *name,
479 void *user_data)
480 {
481 return bt_component_add_port(component, component->input_ports,
482 BT_PORT_TYPE_INPUT, name, user_data);
483 }
484
485 BT_HIDDEN
486 struct bt_port *bt_component_add_output_port(
487 struct bt_component *component, const char *name,
488 void *user_data)
489 {
490 return bt_component_add_port(component, component->output_ports,
491 BT_PORT_TYPE_OUTPUT, name, user_data);
492 }
493
494 static
495 void bt_component_remove_port_by_index(struct bt_component *component,
496 GPtrArray *ports, size_t index)
497 {
498 struct bt_port *port;
499 struct bt_graph *graph;
500
501 assert(ports);
502 assert(index < ports->len);
503 port = g_ptr_array_index(ports, index);
504
505 /* Disconnect both ports of this port's connection, if any */
506 if (port->connection) {
507 bt_connection_disconnect_ports(port->connection);
508 }
509
510 /* Remove from parent's array of ports (weak refs) */
511 g_ptr_array_remove_index(ports, index);
512
513 /* Detach port from its component parent */
514 BT_PUT(port->base.parent);
515
516 /*
517 * Notify the graph's creator that a port is removed.
518 */
519 graph = bt_component_get_graph(component);
520 if (graph) {
521 bt_graph_notify_port_removed(graph, component, port);
522 BT_PUT(graph);
523 }
524 }
525
526 BT_HIDDEN
527 enum bt_component_status bt_component_remove_port(
528 struct bt_component *component, struct bt_port *port)
529 {
530 size_t i;
531 enum bt_component_status status = BT_COMPONENT_STATUS_OK;
532 GPtrArray *ports = NULL;
533
534 if (!component || !port) {
535 status = BT_COMPONENT_STATUS_INVALID;
536 goto end;
537 }
538
539 if (bt_port_get_type(port) == BT_PORT_TYPE_INPUT) {
540 ports = component->input_ports;
541 } else if (bt_port_get_type(port) == BT_PORT_TYPE_OUTPUT) {
542 ports = component->output_ports;
543 }
544
545 assert(ports);
546
547 for (i = 0; i < ports->len; i++) {
548 struct bt_port *cur_port = g_ptr_array_index(ports, i);
549
550 if (cur_port == port) {
551 bt_component_remove_port_by_index(component,
552 ports, i);
553 goto end;
554 }
555 }
556
557 status = BT_COMPONENT_STATUS_NOT_FOUND;
558 end:
559 return status;
560 }
561
562 BT_HIDDEN
563 enum bt_component_status bt_component_accept_port_connection(
564 struct bt_component *comp, struct bt_port *self_port,
565 struct bt_port *other_port)
566 {
567 enum bt_component_status status = BT_COMPONENT_STATUS_OK;
568
569 assert(comp);
570 assert(self_port);
571 assert(other_port);
572
573 if (comp->class->methods.accept_port_connection) {
574 status = comp->class->methods.accept_port_connection(
575 bt_private_component_from_component(comp),
576 bt_private_port_from_port(self_port),
577 other_port);
578 }
579
580 return status;
581 }
582
583 BT_HIDDEN
584 void bt_component_port_connected(struct bt_component *comp,
585 struct bt_port *self_port, struct bt_port *other_port)
586 {
587 assert(comp);
588 assert(self_port);
589 assert(other_port);
590
591 if (comp->class->methods.port_connected) {
592 comp->class->methods.port_connected(
593 bt_private_component_from_component(comp),
594 bt_private_port_from_port(self_port), other_port);
595 }
596 }
597
598 BT_HIDDEN
599 void bt_component_port_disconnected(struct bt_component *comp,
600 struct bt_port *port)
601 {
602 assert(comp);
603 assert(port);
604
605 if (comp->class->methods.port_disconnected) {
606 comp->class->methods.port_disconnected(
607 bt_private_component_from_component(comp),
608 bt_private_port_from_port(port));
609 }
610 }
611
612 BT_HIDDEN
613 void bt_component_add_destroy_listener(struct bt_component *component,
614 bt_component_destroy_listener_func func, void *data)
615 {
616 struct bt_component_destroy_listener listener;
617
618 assert(component);
619 assert(func);
620 listener.func = func;
621 listener.data = data;
622 g_array_append_val(component->destroy_listeners, listener);
623 }
624
625 BT_HIDDEN
626 void bt_component_remove_destroy_listener(struct bt_component *component,
627 bt_component_destroy_listener_func func, void *data)
628 {
629 size_t i;
630
631 assert(component);
632 assert(func);
633
634 for (i = 0; i < component->destroy_listeners->len; i++) {
635 struct bt_component_destroy_listener *listener =
636 &g_array_index(component->destroy_listeners,
637 struct bt_component_destroy_listener, i);
638
639 if (listener->func == func && listener->data == data) {
640 g_array_remove_index(component->destroy_listeners, i);
641 i--;
642 }
643 }
644 }
This page took 0.040645 seconds and 3 git commands to generate.