Adapt `flt.utils.trimmer` to current API
[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 struct bt_port *add_port(
194 struct bt_component *component, GPtrArray *ports,
195 enum bt_port_type port_type, const char *name, void *user_data)
196 {
197 struct bt_port *new_port = NULL;
198 struct bt_graph *graph = NULL;
199
200 BT_ASSERT_PRE_NON_NULL(component, "Component");
201 BT_ASSERT_PRE_NON_NULL(name, "Name");
202 BT_ASSERT_PRE(strlen(name) > 0, "Name is empty");
203 graph = bt_component_borrow_graph(component);
204 BT_ASSERT_PRE(graph && !bt_graph_is_canceled(graph),
205 "Component's graph is canceled: %![comp-]+c, %![graph-]+g",
206 component, graph);
207 BT_ASSERT_PRE(
208 graph->config_state == BT_GRAPH_CONFIGURATION_STATE_CONFIGURING,
209 "Component's graph is already configured: "
210 "%![comp-]+c, %![graph-]+g", component, graph);
211
212 // TODO: Validate that the name is not already used.
213
214 BT_LIB_LOGD("Adding port to component: %![comp-]+c, "
215 "port-type=%s, port-name=\"%s\"", component,
216 bt_port_type_string(port_type), name);
217
218 new_port = bt_port_create(component, port_type, name, user_data);
219 if (!new_port) {
220 BT_LOGE_STR("Cannot create port object.");
221 goto end;
222 }
223
224 /*
225 * No name clash, add the port.
226 * The component is now the port's parent; it should _not_
227 * hold a reference to the port since the port's lifetime
228 * is now protected by the component's own lifetime.
229 */
230 g_ptr_array_add(ports, new_port);
231
232 /*
233 * Notify the graph's creator that a new port was added.
234 */
235 bt_object_get_ref(bt_component_borrow_graph(component));
236 graph = bt_component_borrow_graph(component);
237 if (graph) {
238 bt_graph_notify_port_added(graph, new_port);
239 BT_OBJECT_PUT_REF_AND_RESET(graph);
240 }
241
242 BT_LIB_LOGD("Created and added port to component: "
243 "%![comp-]+c, %![port-]+p", component, new_port);
244
245 end:
246 return new_port;
247 }
248
249 BT_HIDDEN
250 uint64_t bt_component_get_input_port_count(const struct bt_component *comp)
251 {
252 BT_ASSERT_PRE_NON_NULL(comp, "Component");
253 return (uint64_t) comp->input_ports->len;
254 }
255
256 BT_HIDDEN
257 uint64_t bt_component_get_output_port_count(const struct bt_component *comp)
258 {
259 BT_ASSERT_PRE_NON_NULL(comp, "Component");
260 return (uint64_t) comp->output_ports->len;
261 }
262
263 BT_HIDDEN
264 int bt_component_create(struct bt_component_class *component_class,
265 const char *name, struct bt_component **user_component)
266 {
267 int ret = 0;
268 struct bt_component *component = NULL;
269 enum bt_component_class_type type;
270
271 BT_ASSERT(user_component);
272 BT_ASSERT(component_class);
273 BT_ASSERT(name);
274 type = bt_component_class_get_type(component_class);
275 BT_LIB_LOGD("Creating empty component from component class: %![cc-]+C, "
276 "comp-name=\"%s\"", component_class, name);
277 component = component_create_funcs[type](component_class);
278 if (!component) {
279 BT_LOGE_STR("Cannot create specific component object.");
280 ret = -1;
281 goto end;
282 }
283
284 bt_object_init_shared_with_parent(&component->base, destroy_component);
285 component->class = component_class;
286 bt_object_get_no_null_check(component->class);
287 component->destroy = component_destroy_funcs[type];
288 component->name = g_string_new(name);
289 if (!component->name) {
290 BT_LOGE_STR("Failed to allocate one GString.");
291 ret = -1;
292 goto end;
293 }
294
295 component->input_ports = g_ptr_array_new_with_free_func(
296 (GDestroyNotify) bt_object_try_spec_release);
297 if (!component->input_ports) {
298 BT_LOGE_STR("Failed to allocate one GPtrArray.");
299 ret = -1;
300 goto end;
301 }
302
303 component->output_ports = g_ptr_array_new_with_free_func(
304 (GDestroyNotify) bt_object_try_spec_release);
305 if (!component->output_ports) {
306 BT_LOGE_STR("Failed to allocate one GPtrArray.");
307 ret = -1;
308 goto end;
309 }
310
311 component->destroy_listeners = g_array_new(FALSE, TRUE,
312 sizeof(struct bt_component_destroy_listener));
313 if (!component->destroy_listeners) {
314 BT_LOGE_STR("Failed to allocate one GArray.");
315 ret = -1;
316 goto end;
317 }
318
319 BT_LIB_LOGD("Created empty component from component class: "
320 "%![cc-]+C, %![comp-]+c", component_class, component);
321 BT_OBJECT_MOVE_REF(*user_component, component);
322
323 end:
324 bt_object_put_ref(component);
325 return ret;
326 }
327
328 const char *bt_component_get_name(const struct bt_component *component)
329 {
330 BT_ASSERT_PRE_NON_NULL(component, "Component");
331 return component->name->str;
332 }
333
334 struct bt_component_class *bt_component_borrow_class(
335 const struct bt_component *component)
336 {
337 BT_ASSERT_PRE_NON_NULL(component, "Component");
338 return component->class;
339 }
340
341 void *bt_self_component_get_data(const struct bt_self_component *self_comp)
342 {
343 struct bt_component *component = (void *) self_comp;
344
345 BT_ASSERT_PRE_NON_NULL(component, "Component");
346 return component->user_data;
347 }
348
349 void bt_self_component_set_data(struct bt_self_component *self_comp,
350 void *data)
351 {
352 struct bt_component *component = (void *) self_comp;
353
354 BT_ASSERT_PRE_NON_NULL(component, "Component");
355 component->user_data = data;
356 BT_LIB_LOGV("Set component's user data: %!+c", component);
357 }
358
359 BT_HIDDEN
360 void bt_component_set_graph(struct bt_component *component,
361 struct bt_graph *graph)
362 {
363 bt_object_set_parent(&component->base,
364 graph ? &graph->base : NULL);
365 }
366
367 bt_bool bt_component_graph_is_canceled(const struct bt_component *component)
368 {
369 return bt_graph_is_canceled(
370 (void *) bt_object_borrow_parent(&component->base));
371 }
372
373 static
374 struct bt_port *borrow_port_by_name(GPtrArray *ports,
375 const char *name)
376 {
377 uint64_t i;
378 struct bt_port *ret_port = NULL;
379
380 BT_ASSERT(name);
381
382 for (i = 0; i < ports->len; i++) {
383 struct bt_port *port = g_ptr_array_index(ports, i);
384
385 if (!strcmp(name, port->name->str)) {
386 ret_port = port;
387 break;
388 }
389 }
390
391 return ret_port;
392 }
393
394 BT_HIDDEN
395 struct bt_port_input *bt_component_borrow_input_port_by_name(
396 struct bt_component *comp, const char *name)
397 {
398 BT_ASSERT(comp);
399 return (void *) borrow_port_by_name(comp->input_ports, name);
400 }
401
402 BT_HIDDEN
403 struct bt_port_output *bt_component_borrow_output_port_by_name(
404 struct bt_component *comp, const char *name)
405 {
406 BT_ASSERT_PRE_NON_NULL(comp, "Component");
407 return (void *)
408 borrow_port_by_name(comp->output_ports, name);
409 }
410
411 static
412 struct bt_port *borrow_port_by_index(GPtrArray *ports, uint64_t index)
413 {
414 BT_ASSERT(index < ports->len);
415 return g_ptr_array_index(ports, index);
416 }
417
418 BT_HIDDEN
419 struct bt_port_input *bt_component_borrow_input_port_by_index(
420 struct bt_component *comp, uint64_t index)
421 {
422 BT_ASSERT_PRE_NON_NULL(comp, "Component");
423 BT_ASSERT_PRE_VALID_INDEX(index, comp->input_ports->len);
424 return (void *)
425 borrow_port_by_index(comp->input_ports, index);
426 }
427
428 BT_HIDDEN
429 struct bt_port_output *bt_component_borrow_output_port_by_index(
430 struct bt_component *comp, uint64_t index)
431 {
432 BT_ASSERT_PRE_NON_NULL(comp, "Component");
433 BT_ASSERT_PRE_VALID_INDEX(index, comp->output_ports->len);
434 return (void *)
435 borrow_port_by_index(comp->output_ports, index);
436 }
437
438 BT_HIDDEN
439 struct bt_port_input *bt_component_add_input_port(
440 struct bt_component *component, const char *name,
441 void *user_data)
442 {
443 /* add_port() logs details */
444 return (void *)
445 add_port(component, component->input_ports,
446 BT_PORT_TYPE_INPUT, name, user_data);
447 }
448
449 BT_HIDDEN
450 struct bt_port_output *bt_component_add_output_port(
451 struct bt_component *component, const char *name,
452 void *user_data)
453 {
454 /* add_port() logs details */
455 return (void *)
456 add_port(component, component->output_ports,
457 BT_PORT_TYPE_OUTPUT, name, user_data);
458 }
459
460 BT_HIDDEN
461 enum bt_self_component_status bt_component_accept_port_connection(
462 struct bt_component *comp, struct bt_port *self_port,
463 struct bt_port *other_port)
464 {
465 typedef enum bt_self_component_status (*method_t)(
466 void *, void *, const void *);
467
468 enum bt_self_component_status status = BT_SELF_COMPONENT_STATUS_OK;
469 method_t method = NULL;
470
471 BT_ASSERT(comp);
472 BT_ASSERT(self_port);
473 BT_ASSERT(other_port);
474
475 switch (comp->class->type) {
476 case BT_COMPONENT_CLASS_TYPE_SOURCE:
477 {
478 struct bt_component_class_source *src_cc = (void *) comp->class;
479
480 switch (self_port->type) {
481 case BT_PORT_TYPE_OUTPUT:
482 method = (method_t) src_cc->methods.accept_output_port_connection;
483 break;
484 default:
485 abort();
486 }
487
488 break;
489 }
490 case BT_COMPONENT_CLASS_TYPE_FILTER:
491 {
492 struct bt_component_class_filter *flt_cc = (void *) comp->class;
493
494 switch (self_port->type) {
495 case BT_PORT_TYPE_INPUT:
496 method = (method_t) flt_cc->methods.accept_input_port_connection;
497 break;
498 case BT_PORT_TYPE_OUTPUT:
499 method = (method_t) flt_cc->methods.accept_output_port_connection;
500 break;
501 default:
502 abort();
503 }
504
505 break;
506 }
507 case BT_COMPONENT_CLASS_TYPE_SINK:
508 {
509 struct bt_component_class_sink *sink_cc = (void *) comp->class;
510
511 switch (self_port->type) {
512 case BT_PORT_TYPE_INPUT:
513 method = (method_t) sink_cc->methods.accept_input_port_connection;
514 break;
515 default:
516 abort();
517 }
518
519 break;
520 }
521 default:
522 abort();
523 }
524
525 if (method) {
526 BT_LIB_LOGD("Calling user's \"accept port connection\" method: "
527 "%![comp-]+c, %![self-port-]+p, %![other-port-]+p",
528 comp, self_port, other_port);
529 status = method(comp, self_port, (void *) other_port);
530 BT_LOGD("User method returned: status=%s",
531 bt_self_component_status_string(status));
532 }
533
534 return status;
535 }
536
537 BT_HIDDEN
538 enum bt_self_component_status bt_component_port_connected(
539 struct bt_component *comp, struct bt_port *self_port,
540 struct bt_port *other_port)
541 {
542 typedef enum bt_self_component_status (*method_t)(
543 void *, void *, const void *);
544
545 enum bt_self_component_status status = BT_SELF_COMPONENT_STATUS_OK;
546 method_t method = NULL;
547
548 BT_ASSERT(comp);
549 BT_ASSERT(self_port);
550 BT_ASSERT(other_port);
551
552 switch (comp->class->type) {
553 case BT_COMPONENT_CLASS_TYPE_SOURCE:
554 {
555 struct bt_component_class_source *src_cc = (void *) comp->class;
556
557 switch (self_port->type) {
558 case BT_PORT_TYPE_OUTPUT:
559 method = (method_t) src_cc->methods.output_port_connected;
560 break;
561 default:
562 abort();
563 }
564
565 break;
566 }
567 case BT_COMPONENT_CLASS_TYPE_FILTER:
568 {
569 struct bt_component_class_filter *flt_cc = (void *) comp->class;
570
571 switch (self_port->type) {
572 case BT_PORT_TYPE_INPUT:
573 method = (method_t) flt_cc->methods.input_port_connected;
574 break;
575 case BT_PORT_TYPE_OUTPUT:
576 method = (method_t) flt_cc->methods.output_port_connected;
577 break;
578 default:
579 abort();
580 }
581
582 break;
583 }
584 case BT_COMPONENT_CLASS_TYPE_SINK:
585 {
586 struct bt_component_class_sink *sink_cc = (void *) comp->class;
587
588 switch (self_port->type) {
589 case BT_PORT_TYPE_INPUT:
590 method = (method_t) sink_cc->methods.input_port_connected;
591 break;
592 default:
593 abort();
594 }
595
596 break;
597 }
598 default:
599 abort();
600 }
601
602 if (method) {
603 BT_LIB_LOGD("Calling user's \"port connected\" method: "
604 "%![comp-]+c, %![self-port-]+p, %![other-port-]+p",
605 comp, self_port, other_port);
606 status = method(comp, self_port, (void *) other_port);
607 BT_LOGD("User method returned: status=%s",
608 bt_self_component_status_string(status));
609 BT_ASSERT_PRE(status == BT_SELF_COMPONENT_STATUS_OK ||
610 status == BT_SELF_COMPONENT_STATUS_ERROR ||
611 status == BT_SELF_COMPONENT_STATUS_NOMEM,
612 "Unexpected returned component status: status=%s",
613 bt_self_component_status_string(status));
614 }
615
616 return status;
617 }
618
619 BT_HIDDEN
620 void bt_component_add_destroy_listener(struct bt_component *component,
621 bt_component_destroy_listener_func func, void *data)
622 {
623 struct bt_component_destroy_listener listener;
624
625 BT_ASSERT(component);
626 BT_ASSERT(func);
627 listener.func = func;
628 listener.data = data;
629 g_array_append_val(component->destroy_listeners, listener);
630 BT_LIB_LOGV("Added destroy listener: %![comp-]+c, "
631 "func-addr=%p, data-addr=%p",
632 component, func, data);
633 }
634
635 BT_HIDDEN
636 void bt_component_remove_destroy_listener(struct bt_component *component,
637 bt_component_destroy_listener_func func, void *data)
638 {
639 uint64_t i;
640
641 BT_ASSERT(component);
642 BT_ASSERT(func);
643
644 for (i = 0; i < component->destroy_listeners->len; i++) {
645 struct bt_component_destroy_listener *listener =
646 &g_array_index(component->destroy_listeners,
647 struct bt_component_destroy_listener, i);
648
649 if (listener->func == func && listener->data == data) {
650 g_array_remove_index(component->destroy_listeners, i);
651 i--;
652 BT_LIB_LOGV("Removed destroy listener: %![comp-]+c, "
653 "func-addr=%p, data-addr=%p",
654 component, func, data);
655 }
656 }
657 }
658
659 void bt_component_get_ref(const struct bt_component *component)
660 {
661 bt_object_get_ref(component);
662 }
663
664 void bt_component_put_ref(const struct bt_component *component)
665 {
666 bt_object_put_ref(component);
667 }
This page took 0.043692 seconds and 4 git commands to generate.