src/lib/graph/component.c

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