lib: Rename to libbabeltrace2
[babeltrace.git] / lib / graph / component.c
1 /*
2 * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
3 * Copyright 2015 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a copy
6 * of this software and associated documentation files (the "Software"), to deal
7 * in the Software without restriction, including without limitation the rights
8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 * copies of the Software, and to permit persons to whom the Software is
10 * furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 * SOFTWARE.
22 */
23
24 #define BT_LOG_TAG "COMP"
25 #include <babeltrace/lib-logging-internal.h>
26
27 #include <babeltrace/assert-internal.h>
28 #include <babeltrace/assert-pre-internal.h>
29 #include <babeltrace/graph/self-component.h>
30 #include <babeltrace/graph/component-const.h>
31 #include <babeltrace/graph/component-source-const.h>
32 #include <babeltrace/graph/component-filter-const.h>
33 #include <babeltrace/graph/component-sink-const.h>
34 #include <babeltrace/graph/component-internal.h>
35 #include <babeltrace/graph/component-class-internal.h>
36 #include <babeltrace/graph/component-source-internal.h>
37 #include <babeltrace/graph/component-filter-internal.h>
38 #include <babeltrace/graph/component-sink-internal.h>
39 #include <babeltrace/graph/connection-internal.h>
40 #include <babeltrace/graph/graph-internal.h>
41 #include <babeltrace/graph/message-iterator-internal.h>
42 #include <babeltrace/graph/port-internal.h>
43 #include <babeltrace/babeltrace-internal.h>
44 #include <babeltrace/compiler-internal.h>
45 #include <babeltrace/types.h>
46 #include <babeltrace/value.h>
47 #include <babeltrace/value-internal.h>
48 #include <stdint.h>
49 #include <inttypes.h>
50
51 static
52 struct bt_component * (* const component_create_funcs[])(
53 const struct bt_component_class *) = {
54 [BT_COMPONENT_CLASS_TYPE_SOURCE] = bt_component_source_create,
55 [BT_COMPONENT_CLASS_TYPE_SINK] = bt_component_sink_create,
56 [BT_COMPONENT_CLASS_TYPE_FILTER] = bt_component_filter_create,
57 };
58
59 static
60 void (*component_destroy_funcs[])(struct bt_component *) = {
61 [BT_COMPONENT_CLASS_TYPE_SOURCE] = bt_component_source_destroy,
62 [BT_COMPONENT_CLASS_TYPE_SINK] = bt_component_sink_destroy,
63 [BT_COMPONENT_CLASS_TYPE_FILTER] = bt_component_filter_destroy,
64 };
65
66 static
67 void finalize_component(struct bt_component *comp)
68 {
69 typedef void (*method_t)(void *);
70
71 method_t method = NULL;
72
73 BT_ASSERT(comp);
74
75 switch (comp->class->type) {
76 case BT_COMPONENT_CLASS_TYPE_SOURCE:
77 {
78 struct bt_component_class_source *src_cc = (void *) comp->class;
79
80 method = (method_t) src_cc->methods.finalize;
81 break;
82 }
83 case BT_COMPONENT_CLASS_TYPE_FILTER:
84 {
85 struct bt_component_class_filter *flt_cc = (void *) comp->class;
86
87 method = (method_t) flt_cc->methods.finalize;
88 break;
89 }
90 case BT_COMPONENT_CLASS_TYPE_SINK:
91 {
92 struct bt_component_class_sink *sink_cc = (void *) comp->class;
93
94 method = (method_t) sink_cc->methods.finalize;
95 break;
96 }
97 default:
98 abort();
99 }
100
101 if (method) {
102 BT_LIB_LOGD("Calling user's finalization method: "
103 "%![comp-]+c", comp);
104 method(comp);
105 }
106 }
107
108 static
109 void destroy_component(struct bt_object *obj)
110 {
111 struct bt_component *component = NULL;
112 int i;
113
114 if (!obj) {
115 return;
116 }
117
118 /*
119 * The component's reference count is 0 if we're here. Increment
120 * it to avoid a double-destroy (possibly infinitely recursive).
121 * This could happen for example if the component's finalization
122 * function does bt_object_get_ref() (or anything that causes
123 * bt_object_get_ref() to be called) on itself (ref. count goes
124 * from 0 to 1), and then bt_object_put_ref(): the reference
125 * count would go from 1 to 0 again and this function would be
126 * called again.
127 */
128 obj->ref_count++;
129 component = container_of(obj, struct bt_component, base);
130 BT_LIB_LOGD("Destroying component: %![comp-]+c, %![graph-]+g",
131 component, bt_component_borrow_graph(component));
132
133 /* Call destroy listeners in reverse registration order */
134 BT_LOGD_STR("Calling destroy listeners.");
135
136 for (i = component->destroy_listeners->len - 1; i >= 0; i--) {
137 struct bt_component_destroy_listener *listener =
138 &g_array_index(component->destroy_listeners,
139 struct bt_component_destroy_listener, i);
140
141 listener->func(component, listener->data);
142 }
143
144 /*
145 * User data is destroyed first, followed by the concrete
146 * component instance. Do not finalize if the component's user
147 * initialization method failed in the first place.
148 */
149 if (component->initialized) {
150 finalize_component(component);
151 }
152
153 if (component->destroy) {
154 BT_LOGD_STR("Destroying type-specific data.");
155 component->destroy(component);
156 }
157
158 if (component->input_ports) {
159 BT_LOGD_STR("Destroying input ports.");
160 g_ptr_array_free(component->input_ports, TRUE);
161 component->input_ports = NULL;
162 }
163
164 if (component->output_ports) {
165 BT_LOGD_STR("Destroying output ports.");
166 g_ptr_array_free(component->output_ports, TRUE);
167 component->output_ports = NULL;
168 }
169
170 if (component->destroy_listeners) {
171 g_array_free(component->destroy_listeners, TRUE);
172 component->destroy_listeners = NULL;
173 }
174
175 if (component->name) {
176 g_string_free(component->name, TRUE);
177 component->name = NULL;
178 }
179
180 BT_LOGD_STR("Putting component class.");
181 BT_OBJECT_PUT_REF_AND_RESET(component->class);
182 g_free(component);
183 }
184
185 enum bt_component_class_type bt_component_get_class_type(
186 const struct bt_component *component)
187 {
188 BT_ASSERT_PRE_NON_NULL(component, "Component");
189 return component->class->type;
190 }
191
192 static
193 enum bt_self_component_status add_port(
194 struct bt_component *component, GPtrArray *ports,
195 enum bt_port_type port_type, const char *name, void *user_data,
196 struct bt_port **port)
197 {
198 struct bt_port *new_port = NULL;
199 struct bt_graph *graph = NULL;
200 enum bt_self_component_status status;
201
202 BT_ASSERT_PRE_NON_NULL(component, "Component");
203 BT_ASSERT_PRE_NON_NULL(name, "Name");
204 BT_ASSERT_PRE(strlen(name) > 0, "Name is empty");
205 graph = bt_component_borrow_graph(component);
206 BT_ASSERT_PRE(graph && !bt_graph_is_canceled(graph),
207 "Component's graph is canceled: %![comp-]+c, %![graph-]+g",
208 component, graph);
209 BT_ASSERT_PRE(
210 graph->config_state == BT_GRAPH_CONFIGURATION_STATE_CONFIGURING,
211 "Component's graph is already configured: "
212 "%![comp-]+c, %![graph-]+g", component, graph);
213
214 // TODO: Validate that the name is not already used.
215
216 BT_LIB_LOGD("Adding port to component: %![comp-]+c, "
217 "port-type=%s, port-name=\"%s\"", component,
218 bt_port_type_string(port_type), name);
219
220 new_port = bt_port_create(component, port_type, name, user_data);
221 if (!new_port) {
222 BT_LOGE_STR("Cannot create port object.");
223 status = BT_SELF_COMPONENT_STATUS_NOMEM;
224 goto error;
225 }
226
227 /*
228 * No name clash, add the port.
229 * The component is now the port's parent; it should _not_
230 * hold a reference to the port since the port's lifetime
231 * is now protected by the component's own lifetime.
232 */
233 g_ptr_array_add(ports, new_port);
234
235 /*
236 * Notify the graph's creator that a new port was added.
237 */
238 graph = bt_component_borrow_graph(component);
239 if (graph) {
240 enum bt_graph_listener_status listener_status;
241
242 listener_status = bt_graph_notify_port_added(graph, new_port);
243 if (listener_status != BT_GRAPH_LISTENER_STATUS_OK) {
244 bt_graph_make_faulty(graph);
245 status = listener_status;
246 goto error;
247 }
248 }
249
250 BT_LIB_LOGD("Created and added port to component: "
251 "%![comp-]+c, %![port-]+p", component, new_port);
252
253 *port = new_port;
254 status = BT_SELF_COMPONENT_STATUS_OK;
255
256 goto end;
257 error:
258 /*
259 * We need to release the reference that we would otherwise have
260 * returned to the caller.
261 */
262 BT_PORT_PUT_REF_AND_RESET(new_port);
263
264 end:
265 return status;
266 }
267
268 BT_HIDDEN
269 uint64_t bt_component_get_input_port_count(const struct bt_component *comp)
270 {
271 BT_ASSERT_PRE_NON_NULL(comp, "Component");
272 return (uint64_t) comp->input_ports->len;
273 }
274
275 BT_HIDDEN
276 uint64_t bt_component_get_output_port_count(const struct bt_component *comp)
277 {
278 BT_ASSERT_PRE_NON_NULL(comp, "Component");
279 return (uint64_t) comp->output_ports->len;
280 }
281
282 BT_HIDDEN
283 int bt_component_create(struct bt_component_class *component_class,
284 const char *name, struct bt_component **user_component)
285 {
286 int ret = 0;
287 struct bt_component *component = NULL;
288 enum bt_component_class_type type;
289
290 BT_ASSERT(user_component);
291 BT_ASSERT(component_class);
292 BT_ASSERT(name);
293 type = bt_component_class_get_type(component_class);
294 BT_LIB_LOGD("Creating empty component from component class: %![cc-]+C, "
295 "comp-name=\"%s\"", component_class, name);
296 component = component_create_funcs[type](component_class);
297 if (!component) {
298 BT_LOGE_STR("Cannot create specific component object.");
299 ret = -1;
300 goto end;
301 }
302
303 bt_object_init_shared_with_parent(&component->base, destroy_component);
304 component->class = component_class;
305 bt_object_get_no_null_check(component->class);
306 component->destroy = component_destroy_funcs[type];
307 component->name = g_string_new(name);
308 if (!component->name) {
309 BT_LOGE_STR("Failed to allocate one GString.");
310 ret = -1;
311 goto end;
312 }
313
314 component->input_ports = g_ptr_array_new_with_free_func(
315 (GDestroyNotify) bt_object_try_spec_release);
316 if (!component->input_ports) {
317 BT_LOGE_STR("Failed to allocate one GPtrArray.");
318 ret = -1;
319 goto end;
320 }
321
322 component->output_ports = g_ptr_array_new_with_free_func(
323 (GDestroyNotify) bt_object_try_spec_release);
324 if (!component->output_ports) {
325 BT_LOGE_STR("Failed to allocate one GPtrArray.");
326 ret = -1;
327 goto end;
328 }
329
330 component->destroy_listeners = g_array_new(FALSE, TRUE,
331 sizeof(struct bt_component_destroy_listener));
332 if (!component->destroy_listeners) {
333 BT_LOGE_STR("Failed to allocate one GArray.");
334 ret = -1;
335 goto end;
336 }
337
338 BT_LIB_LOGD("Created empty component from component class: "
339 "%![cc-]+C, %![comp-]+c", component_class, component);
340 BT_OBJECT_MOVE_REF(*user_component, component);
341
342 end:
343 bt_object_put_ref(component);
344 return ret;
345 }
346
347 const char *bt_component_get_name(const struct bt_component *component)
348 {
349 BT_ASSERT_PRE_NON_NULL(component, "Component");
350 return component->name->str;
351 }
352
353 const struct bt_component_class *bt_component_borrow_class_const(
354 const struct bt_component *component)
355 {
356 BT_ASSERT_PRE_NON_NULL(component, "Component");
357 return component->class;
358 }
359
360 void *bt_self_component_get_data(const struct bt_self_component *self_comp)
361 {
362 struct bt_component *component = (void *) self_comp;
363
364 BT_ASSERT_PRE_NON_NULL(component, "Component");
365 return component->user_data;
366 }
367
368 void bt_self_component_set_data(struct bt_self_component *self_comp,
369 void *data)
370 {
371 struct bt_component *component = (void *) self_comp;
372
373 BT_ASSERT_PRE_NON_NULL(component, "Component");
374 component->user_data = data;
375 BT_LIB_LOGV("Set component's user data: %!+c", component);
376 }
377
378 BT_HIDDEN
379 void bt_component_set_graph(struct bt_component *component,
380 struct bt_graph *graph)
381 {
382 bt_object_set_parent(&component->base,
383 graph ? &graph->base : NULL);
384 }
385
386 bt_bool bt_component_graph_is_canceled(const struct bt_component *component)
387 {
388 return bt_graph_is_canceled(
389 (void *) bt_object_borrow_parent(&component->base));
390 }
391
392 static
393 struct bt_port *borrow_port_by_name(GPtrArray *ports,
394 const char *name)
395 {
396 uint64_t i;
397 struct bt_port *ret_port = NULL;
398
399 BT_ASSERT(name);
400
401 for (i = 0; i < ports->len; i++) {
402 struct bt_port *port = g_ptr_array_index(ports, i);
403
404 if (!strcmp(name, port->name->str)) {
405 ret_port = port;
406 break;
407 }
408 }
409
410 return ret_port;
411 }
412
413 BT_HIDDEN
414 struct bt_port_input *bt_component_borrow_input_port_by_name(
415 struct bt_component *comp, const char *name)
416 {
417 BT_ASSERT(comp);
418 return (void *) borrow_port_by_name(comp->input_ports, name);
419 }
420
421 BT_HIDDEN
422 struct bt_port_output *bt_component_borrow_output_port_by_name(
423 struct bt_component *comp, const char *name)
424 {
425 BT_ASSERT_PRE_NON_NULL(comp, "Component");
426 return (void *)
427 borrow_port_by_name(comp->output_ports, name);
428 }
429
430 static
431 struct bt_port *borrow_port_by_index(GPtrArray *ports, uint64_t index)
432 {
433 BT_ASSERT(index < ports->len);
434 return g_ptr_array_index(ports, index);
435 }
436
437 BT_HIDDEN
438 struct bt_port_input *bt_component_borrow_input_port_by_index(
439 struct bt_component *comp, uint64_t index)
440 {
441 BT_ASSERT_PRE_NON_NULL(comp, "Component");
442 BT_ASSERT_PRE_VALID_INDEX(index, comp->input_ports->len);
443 return (void *)
444 borrow_port_by_index(comp->input_ports, index);
445 }
446
447 BT_HIDDEN
448 struct bt_port_output *bt_component_borrow_output_port_by_index(
449 struct bt_component *comp, uint64_t index)
450 {
451 BT_ASSERT_PRE_NON_NULL(comp, "Component");
452 BT_ASSERT_PRE_VALID_INDEX(index, comp->output_ports->len);
453 return (void *)
454 borrow_port_by_index(comp->output_ports, index);
455 }
456
457 BT_HIDDEN
458 enum bt_self_component_status bt_component_add_input_port(
459 struct bt_component *component, const char *name,
460 void *user_data, struct bt_port **port)
461 {
462 /* add_port() logs details */
463 return add_port(component, component->input_ports,
464 BT_PORT_TYPE_INPUT, name, user_data, port);
465 }
466
467 BT_HIDDEN
468 enum bt_self_component_status bt_component_add_output_port(
469 struct bt_component *component, const char *name,
470 void *user_data, struct bt_port **port)
471 {
472 /* add_port() logs details */
473 return add_port(component, component->output_ports,
474 BT_PORT_TYPE_OUTPUT, name, user_data, port);
475 }
476
477 BT_HIDDEN
478 enum bt_self_component_status bt_component_accept_port_connection(
479 struct bt_component *comp, struct bt_port *self_port,
480 struct bt_port *other_port)
481 {
482 typedef enum bt_self_component_status (*method_t)(
483 void *, void *, const void *);
484
485 enum bt_self_component_status status = BT_SELF_COMPONENT_STATUS_OK;
486 method_t method = NULL;
487
488 BT_ASSERT(comp);
489 BT_ASSERT(self_port);
490 BT_ASSERT(other_port);
491
492 switch (comp->class->type) {
493 case BT_COMPONENT_CLASS_TYPE_SOURCE:
494 {
495 struct bt_component_class_source *src_cc = (void *) comp->class;
496
497 switch (self_port->type) {
498 case BT_PORT_TYPE_OUTPUT:
499 method = (method_t) src_cc->methods.accept_output_port_connection;
500 break;
501 default:
502 abort();
503 }
504
505 break;
506 }
507 case BT_COMPONENT_CLASS_TYPE_FILTER:
508 {
509 struct bt_component_class_filter *flt_cc = (void *) comp->class;
510
511 switch (self_port->type) {
512 case BT_PORT_TYPE_INPUT:
513 method = (method_t) flt_cc->methods.accept_input_port_connection;
514 break;
515 case BT_PORT_TYPE_OUTPUT:
516 method = (method_t) flt_cc->methods.accept_output_port_connection;
517 break;
518 default:
519 abort();
520 }
521
522 break;
523 }
524 case BT_COMPONENT_CLASS_TYPE_SINK:
525 {
526 struct bt_component_class_sink *sink_cc = (void *) comp->class;
527
528 switch (self_port->type) {
529 case BT_PORT_TYPE_INPUT:
530 method = (method_t) sink_cc->methods.accept_input_port_connection;
531 break;
532 default:
533 abort();
534 }
535
536 break;
537 }
538 default:
539 abort();
540 }
541
542 if (method) {
543 BT_LIB_LOGD("Calling user's \"accept port connection\" method: "
544 "%![comp-]+c, %![self-port-]+p, %![other-port-]+p",
545 comp, self_port, other_port);
546 status = method(comp, self_port, (void *) other_port);
547 BT_LOGD("User method returned: status=%s",
548 bt_self_component_status_string(status));
549 }
550
551 return status;
552 }
553
554 BT_HIDDEN
555 enum bt_self_component_status bt_component_port_connected(
556 struct bt_component *comp, struct bt_port *self_port,
557 struct bt_port *other_port)
558 {
559 typedef enum bt_self_component_status (*method_t)(
560 void *, void *, const void *);
561
562 enum bt_self_component_status status = BT_SELF_COMPONENT_STATUS_OK;
563 method_t method = NULL;
564
565 BT_ASSERT(comp);
566 BT_ASSERT(self_port);
567 BT_ASSERT(other_port);
568
569 switch (comp->class->type) {
570 case BT_COMPONENT_CLASS_TYPE_SOURCE:
571 {
572 struct bt_component_class_source *src_cc = (void *) comp->class;
573
574 switch (self_port->type) {
575 case BT_PORT_TYPE_OUTPUT:
576 method = (method_t) src_cc->methods.output_port_connected;
577 break;
578 default:
579 abort();
580 }
581
582 break;
583 }
584 case BT_COMPONENT_CLASS_TYPE_FILTER:
585 {
586 struct bt_component_class_filter *flt_cc = (void *) comp->class;
587
588 switch (self_port->type) {
589 case BT_PORT_TYPE_INPUT:
590 method = (method_t) flt_cc->methods.input_port_connected;
591 break;
592 case BT_PORT_TYPE_OUTPUT:
593 method = (method_t) flt_cc->methods.output_port_connected;
594 break;
595 default:
596 abort();
597 }
598
599 break;
600 }
601 case BT_COMPONENT_CLASS_TYPE_SINK:
602 {
603 struct bt_component_class_sink *sink_cc = (void *) comp->class;
604
605 switch (self_port->type) {
606 case BT_PORT_TYPE_INPUT:
607 method = (method_t) sink_cc->methods.input_port_connected;
608 break;
609 default:
610 abort();
611 }
612
613 break;
614 }
615 default:
616 abort();
617 }
618
619 if (method) {
620 BT_LIB_LOGD("Calling user's \"port connected\" method: "
621 "%![comp-]+c, %![self-port-]+p, %![other-port-]+p",
622 comp, self_port, other_port);
623 status = method(comp, self_port, (void *) other_port);
624 BT_LOGD("User method returned: status=%s",
625 bt_self_component_status_string(status));
626 BT_ASSERT_PRE(status == BT_SELF_COMPONENT_STATUS_OK ||
627 status == BT_SELF_COMPONENT_STATUS_ERROR ||
628 status == BT_SELF_COMPONENT_STATUS_NOMEM,
629 "Unexpected returned component status: status=%s",
630 bt_self_component_status_string(status));
631 }
632
633 return status;
634 }
635
636 BT_HIDDEN
637 void bt_component_add_destroy_listener(struct bt_component *component,
638 bt_component_destroy_listener_func func, void *data)
639 {
640 struct bt_component_destroy_listener listener;
641
642 BT_ASSERT(component);
643 BT_ASSERT(func);
644 listener.func = func;
645 listener.data = data;
646 g_array_append_val(component->destroy_listeners, listener);
647 BT_LIB_LOGV("Added destroy listener: %![comp-]+c, "
648 "func-addr=%p, data-addr=%p",
649 component, func, data);
650 }
651
652 BT_HIDDEN
653 void bt_component_remove_destroy_listener(struct bt_component *component,
654 bt_component_destroy_listener_func func, void *data)
655 {
656 uint64_t i;
657
658 BT_ASSERT(component);
659 BT_ASSERT(func);
660
661 for (i = 0; i < component->destroy_listeners->len; i++) {
662 struct bt_component_destroy_listener *listener =
663 &g_array_index(component->destroy_listeners,
664 struct bt_component_destroy_listener, i);
665
666 if (listener->func == func && listener->data == data) {
667 g_array_remove_index(component->destroy_listeners, i);
668 i--;
669 BT_LIB_LOGV("Removed destroy listener: %![comp-]+c, "
670 "func-addr=%p, data-addr=%p",
671 component, func, data);
672 }
673 }
674 }
675
676 void bt_component_get_ref(const struct bt_component *component)
677 {
678 bt_object_get_ref(component);
679 }
680
681 void bt_component_put_ref(const struct bt_component *component)
682 {
683 bt_object_put_ref(component);
684 }
This page took 0.055341 seconds and 4 git commands to generate.