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 #define BT_LOG_TAG "COMP"
  30 #include <babeltrace/lib-logging-internal.h>
  31
  32 #include <babeltrace/graph/private-component.h>
  33 #include <babeltrace/graph/component.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/private-connection.h>
  40 #include <babeltrace/graph/connection-internal.h>
  41 #include <babeltrace/graph/graph-internal.h>
  42 #include <babeltrace/graph/notification-iterator-internal.h>
  43 #include <babeltrace/graph/private-connection-private-notification-iterator.h>
  44 #include <babeltrace/babeltrace-internal.h>
  45 #include <babeltrace/compiler-internal.h>
  46 #include <babeltrace/ref.h>
  47 #include <babeltrace/types.h>
  48 #include <babeltrace/values.h>
  49 #include <babeltrace/values-internal.h>
  50 #include <babeltrace/assert-internal.h>
  51 #include <stdint.h>
  52 #include <inttypes.h>
  53
  54 static
  55 struct bt_component * (* const component_create_funcs[])(
  56                 struct bt_component_class *) = {
  57         [BT_COMPONENT_CLASS_TYPE_SOURCE] = bt_component_source_create,
  58         [BT_COMPONENT_CLASS_TYPE_SINK] = bt_component_sink_create,
  59         [BT_COMPONENT_CLASS_TYPE_FILTER] = bt_component_filter_create,
  60 };
  61
  62 static
  63 void (*component_destroy_funcs[])(struct bt_component *) = {
  64         [BT_COMPONENT_CLASS_TYPE_SOURCE] = bt_component_source_destroy,
  65         [BT_COMPONENT_CLASS_TYPE_SINK] = bt_component_sink_destroy,
  66         [BT_COMPONENT_CLASS_TYPE_FILTER] = bt_component_filter_destroy,
  67 };
  68
  69 static
  70 void bt_component_destroy(struct bt_object *obj)
  71 {
  72         struct bt_component *component = NULL;
  73         struct bt_component_class *component_class = NULL;
  74         int i;
  75
  76         if (!obj) {
  77                 return;
  78         }
  79
  80         /*
  81          * The component's reference count is 0 if we're here. Increment
  82          * it to avoid a double-destroy (possibly infinitely recursive).
  83          * This could happen for example if the component's finalization
  84          * function does bt_get() (or anything that causes bt_get() to
  85          * be called) on itself (ref. count goes from 0 to 1), and then
  86          * bt_put(): the reference count would go from 1 to 0 again and
  87          * this function would be called again.
  88          */
  89         obj->ref_count++;
  90         component = container_of(obj, struct bt_component, base);
  91         BT_LOGD("Destroying component: addr=%p, name=\"%s\", graph-addr=%p",
  92                 component, bt_component_get_name(component),
  93                 obj->parent);
  94
  95         /* Call destroy listeners in reverse registration order */
  96         BT_LOGD_STR("Calling destroy listeners.");
  97
  98         for (i = component->destroy_listeners->len - 1; i >= 0; i--) {
  99                 struct bt_component_destroy_listener *listener =
 100                         &g_array_index(component->destroy_listeners,
 101                                 struct bt_component_destroy_listener, i);
 102
 103                 listener->func(component, listener->data);
 104         }
 105
 106         component_class = component->class;
 107
 108         /*
 109          * User data is destroyed first, followed by the concrete
 110          * component instance. Do not finalize if the component's user
 111          * initialization method failed in the first place.
 112          */
 113         if (component->initialized && component->class->methods.finalize) {
 114                 BT_LOGD_STR("Calling user's finalization method.");
 115                 component->class->methods.finalize(
 116                         bt_private_component_from_component(component));
 117         }
 118
 119         if (component->destroy) {
 120                 BT_LOGD_STR("Destroying type-specific data.");
 121                 component->destroy(component);
 122         }
 123
 124         if (component->input_ports) {
 125                 BT_LOGD_STR("Destroying input ports.");
 126                 g_ptr_array_free(component->input_ports, TRUE);
 127         }
 128
 129         if (component->output_ports) {
 130                 BT_LOGD_STR("Destroying output ports.");
 131                 g_ptr_array_free(component->output_ports, TRUE);
 132         }
 133
 134         if (component->destroy_listeners) {
 135                 g_array_free(component->destroy_listeners, TRUE);
 136         }
 137
 138         if (component->name) {
 139                 g_string_free(component->name, TRUE);
 140         }
 141
 142         BT_LOGD("Putting component class.");
 143         bt_put(component_class);
 144         g_free(component);
 145 }
 146
 147 struct bt_component *bt_component_borrow_from_private(
 148                 struct bt_private_component *private_component)
 149 {
 150         return (void *) private_component;
 151 }
 152
 153 enum bt_component_class_type bt_component_get_class_type(
 154                 struct bt_component *component)
 155 {
 156         return component ? component->class->type : BT_COMPONENT_CLASS_TYPE_UNKNOWN;
 157 }
 158
 159 static
 160 struct bt_port *bt_component_add_port(
 161                 struct bt_component *component, GPtrArray *ports,
 162                 enum bt_port_type port_type, const char *name, void *user_data)
 163 {
 164         size_t i;
 165         struct bt_port *new_port = NULL;
 166         struct bt_graph *graph = NULL;
 167
 168         if (!name) {
 169                 BT_LOGW_STR("Invalid parameter: name is NULL.");
 170                 goto end;
 171         }
 172
 173         if (strlen(name) == 0) {
 174                 BT_LOGW_STR("Invalid parameter: name is an empty string.");
 175                 goto end;
 176         }
 177
 178         BT_LOGD("Adding port to component: comp-addr=%p, comp-name=\"%s\", "
 179                 "port-type=%s, port-name=\"%s\"", component,
 180                 bt_component_get_name(component),
 181                 bt_port_type_string(port_type), name);
 182
 183         /* Look for a port having the same name. */
 184         for (i = 0; i < ports->len; i++) {
 185                 const char *port_name;
 186                 struct bt_port *port = g_ptr_array_index(ports, i);
 187
 188                 port_name = bt_port_get_name(port);
 189                 BT_ASSERT(port_name);
 190
 191                 if (!strcmp(name, port_name)) {
 192                         /* Port name clash, abort. */
 193                         BT_LOGW("Invalid parameter: another port with the same name already exists in the component: "
 194                                 "other-port-addr=%p", port);
 195                         goto end;
 196                 }
 197         }
 198
 199         new_port = bt_port_create(component, port_type, name, user_data);
 200         if (!new_port) {
 201                 BT_LOGE("Cannot create port object.");
 202                 goto end;
 203         }
 204
 205         /*
 206          * No name clash, add the port.
 207          * The component is now the port's parent; it should _not_
 208          * hold a reference to the port since the port's lifetime
 209          * is now protected by the component's own lifetime.
 210          */
 211         g_ptr_array_add(ports, new_port);
 212
 213         /*
 214          * Notify the graph's creator that a new port was added.
 215          */
 216         graph = bt_component_get_graph(component);
 217         if (graph) {
 218                 bt_graph_notify_port_added(graph, new_port);
 219                 BT_PUT(graph);
 220         }
 221
 222         BT_LOGD("Created and added port to component: comp-addr=%p, comp-name=\"%s\", "
 223                 "port-type=%s, port-name=\"%s\", port-addr=%p", component,
 224                 bt_component_get_name(component),
 225                 bt_port_type_string(port_type), name, new_port);
 226
 227 end:
 228         return new_port;
 229 }
 230
 231 BT_HIDDEN
 232 int64_t bt_component_get_input_port_count(struct bt_component *comp)
 233 {
 234         BT_ASSERT(comp);
 235         return (int64_t) comp->input_ports->len;
 236 }
 237
 238 BT_HIDDEN
 239 int64_t bt_component_get_output_port_count(struct bt_component *comp)
 240 {
 241         BT_ASSERT(comp);
 242         return (int64_t) comp->output_ports->len;
 243 }
 244
 245 BT_HIDDEN
 246 enum bt_component_status bt_component_create(
 247                 struct bt_component_class *component_class,
 248                 const char *name, struct bt_component **user_component)
 249 {
 250         enum bt_component_status status = BT_COMPONENT_STATUS_OK;
 251         struct bt_component *component = NULL;
 252         enum bt_component_class_type type;
 253
 254         BT_ASSERT(user_component);
 255         BT_ASSERT(component_class);
 256         BT_ASSERT(name);
 257
 258         type = bt_component_class_get_type(component_class);
 259         BT_LOGD("Creating empty component from component class: "
 260                 "comp-cls-addr=%p, comp-cls-type=%s, name=\"%s\"",
 261                 component_class, bt_component_class_type_string(type), name);
 262         component = component_create_funcs[type](component_class);
 263         if (!component) {
 264                 BT_LOGE_STR("Cannot create specific component object.");
 265                 status = BT_COMPONENT_STATUS_NOMEM;
 266                 goto end;
 267         }
 268
 269         bt_object_init_shared_with_parent(&component->base,
 270                 bt_component_destroy);
 271         component->class = bt_get(component_class);
 272         component->destroy = component_destroy_funcs[type];
 273         component->name = g_string_new(name);
 274         if (!component->name) {
 275                 BT_LOGE_STR("Failed to allocate one GString.");
 276                 status = BT_COMPONENT_STATUS_NOMEM;
 277                 goto end;
 278         }
 279
 280         component->input_ports = g_ptr_array_new_with_free_func(
 281                 (GDestroyNotify) bt_object_try_spec_release);
 282         if (!component->input_ports) {
 283                 BT_LOGE_STR("Failed to allocate one GPtrArray.");
 284                 status = BT_COMPONENT_STATUS_NOMEM;
 285                 goto end;
 286         }
 287
 288         component->output_ports = g_ptr_array_new_with_free_func(
 289                 (GDestroyNotify) bt_object_try_spec_release);
 290         if (!component->output_ports) {
 291                 BT_LOGE_STR("Failed to allocate one GPtrArray.");
 292                 status = BT_COMPONENT_STATUS_NOMEM;
 293                 goto end;
 294         }
 295
 296         component->destroy_listeners = g_array_new(FALSE, TRUE,
 297                 sizeof(struct bt_component_destroy_listener));
 298         if (!component->destroy_listeners) {
 299                 BT_LOGE_STR("Failed to allocate one GArray.");
 300                 status = BT_COMPONENT_STATUS_NOMEM;
 301                 goto end;
 302         }
 303
 304         BT_LOGD("Created empty component from component class: "
 305                 "comp-cls-addr=%p, comp-cls-type=%s, name=\"%s\", comp-addr=%p",
 306                 component_class, bt_component_class_type_string(type), name,
 307                 component);
 308         BT_MOVE(*user_component, component);
 309
 310 end:
 311         bt_put(component);
 312         return status;
 313 }
 314
 315 const char *bt_component_get_name(struct bt_component *component)
 316 {
 317         const char *ret = NULL;
 318
 319         if (!component) {
 320                 BT_LOGW_STR("Invalid parameter: component is NULL.");
 321                 goto end;
 322         }
 323
 324         ret = component->name->len == 0 ? NULL : component->name->str;
 325
 326 end:
 327         return ret;
 328 }
 329
 330 struct bt_component_class *bt_component_get_class(
 331                 struct bt_component *component)
 332 {
 333         return component ? bt_get(component->class) : NULL;
 334 }
 335
 336 void *bt_private_component_get_user_data(
 337                 struct bt_private_component *private_component)
 338 {
 339         struct bt_component *component =
 340                 bt_component_borrow_from_private(private_component);
 341
 342         return component ? component->user_data : NULL;
 343 }
 344
 345 enum bt_component_status bt_private_component_set_user_data(
 346                 struct bt_private_component *private_component,
 347                 void *data)
 348 {
 349         struct bt_component *component =
 350                 bt_component_borrow_from_private(private_component);
 351         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 352
 353         if (!component) {
 354                 BT_LOGW_STR("Invalid parameter: component is NULL.");
 355                 ret = BT_COMPONENT_STATUS_INVALID;
 356                 goto end;
 357         }
 358
 359         component->user_data = data;
 360         BT_LOGV("Set component's user data: "
 361                 "comp-addr=%p, comp-name=\"%s\", user-data-addr=%p",
 362                 component, bt_component_get_name(component), data);
 363
 364 end:
 365         return ret;
 366 }
 367
 368 BT_HIDDEN
 369 void bt_component_set_graph(struct bt_component *component,
 370                 struct bt_graph *graph)
 371 {
 372         bt_object_set_parent(&component->base,
 373                 graph ? &graph->base : NULL);
 374 }
 375
 376 struct bt_graph *bt_component_borrow_graph(struct bt_component *component)
 377 {
 378         return (struct bt_graph *) bt_object_borrow_parent(&component->base);
 379 }
 380
 381 static
 382 struct bt_port *bt_component_get_port_by_name(GPtrArray *ports,
 383                 const char *name)
 384 {
 385         size_t i;
 386         struct bt_port *ret_port = NULL;
 387
 388         BT_ASSERT(name);
 389
 390         for (i = 0; i < ports->len; i++) {
 391                 struct bt_port *port = g_ptr_array_index(ports, i);
 392                 const char *port_name = bt_port_get_name(port);
 393
 394                 if (!port_name) {
 395                         continue;
 396                 }
 397
 398                 if (!strcmp(name, port_name)) {
 399                         ret_port = bt_get(port);
 400                         break;
 401                 }
 402         }
 403
 404         return ret_port;
 405 }
 406
 407 BT_HIDDEN
 408 struct bt_port *bt_component_get_input_port_by_name(struct bt_component *comp,
 409                 const char *name)
 410 {
 411         BT_ASSERT(comp);
 412
 413         return bt_component_get_port_by_name(comp->input_ports, name);
 414 }
 415
 416 BT_HIDDEN
 417 struct bt_port *bt_component_get_output_port_by_name(struct bt_component *comp,
 418                 const char *name)
 419 {
 420         BT_ASSERT(comp);
 421
 422         return bt_component_get_port_by_name(comp->output_ports, name);
 423 }
 424
 425 static
 426 struct bt_port *bt_component_get_port_by_index(GPtrArray *ports, uint64_t index)
 427 {
 428         struct bt_port *port = NULL;
 429
 430         if (index >= ports->len) {
 431                 BT_LOGW("Invalid parameter: index is out of bounds: "
 432                         "index=%" PRIu64 ", count=%u",
 433                         index, ports->len);
 434                 goto end;
 435         }
 436
 437         port = bt_get(g_ptr_array_index(ports, index));
 438 end:
 439         return port;
 440 }
 441
 442 BT_HIDDEN
 443 struct bt_port *bt_component_get_input_port_by_index(struct bt_component *comp,
 444                 uint64_t index)
 445 {
 446         BT_ASSERT(comp);
 447
 448         return bt_component_get_port_by_index(comp->input_ports, index);
 449 }
 450
 451 BT_HIDDEN
 452 struct bt_port *bt_component_get_output_port_by_index(struct bt_component *comp,
 453                 uint64_t index)
 454 {
 455         BT_ASSERT(comp);
 456
 457         return bt_component_get_port_by_index(comp->output_ports, index);
 458 }
 459
 460 BT_HIDDEN
 461 struct bt_port *bt_component_add_input_port(
 462                 struct bt_component *component, const char *name,
 463                 void *user_data)
 464 {
 465         /* bt_component_add_port() logs details */
 466         return bt_component_add_port(component, component->input_ports,
 467                 BT_PORT_TYPE_INPUT, name, user_data);
 468 }
 469
 470 BT_HIDDEN
 471 struct bt_port *bt_component_add_output_port(
 472                 struct bt_component *component, const char *name,
 473                 void *user_data)
 474 {
 475         /* bt_component_add_port() logs details */
 476         return bt_component_add_port(component, component->output_ports,
 477                 BT_PORT_TYPE_OUTPUT, name, user_data);
 478 }
 479
 480 static
 481 void bt_component_remove_port_by_index(struct bt_component *component,
 482                 GPtrArray *ports, size_t index)
 483 {
 484         struct bt_port *port;
 485         struct bt_graph *graph;
 486
 487         BT_ASSERT(ports);
 488         BT_ASSERT(index < ports->len);
 489         port = g_ptr_array_index(ports, index);
 490
 491         BT_LOGD("Removing port from component: "
 492                 "comp-addr=%p, comp-name=\"%s\", "
 493                 "port-addr=%p, port-name=\"%s\"",
 494                 component, bt_component_get_name(component),
 495                 port, bt_port_get_name(port));
 496
 497         /* Disconnect both ports of this port's connection, if any */
 498         if (port->connection) {
 499                 bt_connection_end(port->connection, true);
 500         }
 501
 502         /* Remove from parent's array of ports (weak refs) */
 503         g_ptr_array_remove_index(ports, index);
 504
 505         /* Detach port from its component parent */
 506         BT_PUT(port->base.parent);
 507
 508         /*
 509          * Notify the graph's creator that a port is removed.
 510          */
 511         graph = bt_component_get_graph(component);
 512         if (graph) {
 513                 bt_graph_notify_port_removed(graph, component, port);
 514                 BT_PUT(graph);
 515         }
 516
 517         BT_LOGD("Removed port from component: "
 518                 "comp-addr=%p, comp-name=\"%s\", "
 519                 "port-addr=%p, port-name=\"%s\"",
 520                 component, bt_component_get_name(component),
 521                 port, bt_port_get_name(port));
 522 }
 523
 524 BT_HIDDEN
 525 enum bt_component_status bt_component_remove_port(
 526                 struct bt_component *component, struct bt_port *port)
 527 {
 528         size_t i;
 529         enum bt_component_status status = BT_COMPONENT_STATUS_OK;
 530         GPtrArray *ports = NULL;
 531
 532         if (!component) {
 533                 BT_LOGW_STR("Invalid parameter: component is NULL.");
 534                 status = BT_COMPONENT_STATUS_INVALID;
 535                 goto end;
 536         }
 537
 538         if (!port) {
 539                 BT_LOGW_STR("Invalid parameter: port is NULL.");
 540                 status = BT_COMPONENT_STATUS_INVALID;
 541                 goto end;
 542         }
 543
 544         if (bt_port_get_type(port) == BT_PORT_TYPE_INPUT) {
 545                 ports = component->input_ports;
 546         } else if (bt_port_get_type(port) == BT_PORT_TYPE_OUTPUT) {
 547                 ports = component->output_ports;
 548         }
 549
 550         BT_ASSERT(ports);
 551
 552         for (i = 0; i < ports->len; i++) {
 553                 struct bt_port *cur_port = g_ptr_array_index(ports, i);
 554
 555                 if (cur_port == port) {
 556                         bt_component_remove_port_by_index(component,
 557                                 ports, i);
 558                         goto end;
 559                 }
 560         }
 561
 562         status = BT_COMPONENT_STATUS_NOT_FOUND;
 563         BT_LOGW("Port to remove from component was not found: "
 564                 "comp-addr=%p, comp-name=\"%s\", "
 565                 "port-addr=%p, port-name=\"%s\"",
 566                 component, bt_component_get_name(component),
 567                 port, bt_port_get_name(port));
 568
 569 end:
 570         return status;
 571 }
 572
 573 BT_HIDDEN
 574 enum bt_component_status bt_component_accept_port_connection(
 575                 struct bt_component *comp, struct bt_port *self_port,
 576                 struct bt_port *other_port)
 577 {
 578         enum bt_component_status status = BT_COMPONENT_STATUS_OK;
 579
 580         BT_ASSERT(comp);
 581         BT_ASSERT(self_port);
 582         BT_ASSERT(other_port);
 583
 584         if (comp->class->methods.accept_port_connection) {
 585                 BT_LOGD("Calling user's \"accept port connection\" method: "
 586                         "comp-addr=%p, comp-name=\"%s\", "
 587                         "self-port-addr=%p, self-port-name=\"%s\", "
 588                         "other-port-addr=%p, other-port-name=\"%s\"",
 589                         comp, bt_component_get_name(comp),
 590                         self_port, bt_port_get_name(self_port),
 591                         other_port, bt_port_get_name(other_port));
 592                 status = comp->class->methods.accept_port_connection(
 593                         bt_private_component_from_component(comp),
 594                         bt_private_port_from_port(self_port),
 595                         other_port);
 596                 BT_LOGD("User method returned: status=%s",
 597                         bt_component_status_string(status));
 598         }
 599
 600         return status;
 601 }
 602
 603 BT_HIDDEN
 604 enum bt_component_status bt_component_port_connected(struct bt_component *comp,
 605                 struct bt_port *self_port, struct bt_port *other_port)
 606 {
 607         enum bt_component_status status = BT_COMPONENT_STATUS_OK;
 608
 609         BT_ASSERT(comp);
 610         BT_ASSERT(self_port);
 611         BT_ASSERT(other_port);
 612
 613         if (comp->class->methods.port_connected) {
 614                 BT_LOGD("Calling user's \"port connected\" method: "
 615                         "comp-addr=%p, comp-name=\"%s\", "
 616                         "self-port-addr=%p, self-port-name=\"%s\", "
 617                         "other-port-addr=%p, other-port-name=\"%s\"",
 618                         comp, bt_component_get_name(comp),
 619                         self_port, bt_port_get_name(self_port),
 620                         other_port, bt_port_get_name(other_port));
 621                 status = comp->class->methods.port_connected(
 622                         bt_private_component_from_component(comp),
 623                         bt_private_port_from_port(self_port), other_port);
 624         }
 625
 626         return status;
 627 }
 628
 629 BT_HIDDEN
 630 void bt_component_port_disconnected(struct bt_component *comp,
 631                 struct bt_port *port)
 632 {
 633         BT_ASSERT(comp);
 634         BT_ASSERT(port);
 635
 636         if (comp->class->methods.port_disconnected) {
 637                 BT_LOGD("Calling user's \"port disconnected\" method: "
 638                         "comp-addr=%p, comp-name=\"%s\", "
 639                         "port-addr=%p, port-name=\"%s\"",
 640                         comp, bt_component_get_name(comp),
 641                         port, bt_port_get_name(port));
 642                 comp->class->methods.port_disconnected(
 643                         bt_private_component_from_component(comp),
 644                         bt_private_port_from_port(port));
 645         }
 646 }
 647
 648 BT_HIDDEN
 649 void bt_component_add_destroy_listener(struct bt_component *component,
 650                 bt_component_destroy_listener_func func, void *data)
 651 {
 652         struct bt_component_destroy_listener listener;
 653
 654         BT_ASSERT(component);
 655         BT_ASSERT(func);
 656         listener.func = func;
 657         listener.data = data;
 658         g_array_append_val(component->destroy_listeners, listener);
 659         BT_LOGV("Added destroy listener: "
 660                 "comp-addr=%p, comp-name=\"%s\", "
 661                 "func-addr=%p, data-addr=%p",
 662                 component, bt_component_get_name(component),
 663                 func, data);
 664 }
 665
 666 BT_HIDDEN
 667 void bt_component_remove_destroy_listener(struct bt_component *component,
 668                 bt_component_destroy_listener_func func, void *data)
 669 {
 670         size_t i;
 671
 672         BT_ASSERT(component);
 673         BT_ASSERT(func);
 674
 675         for (i = 0; i < component->destroy_listeners->len; i++) {
 676                 struct bt_component_destroy_listener *listener =
 677                         &g_array_index(component->destroy_listeners,
 678                                 struct bt_component_destroy_listener, i);
 679
 680                 if (listener->func == func && listener->data == data) {
 681                         g_array_remove_index(component->destroy_listeners, i);
 682                         i--;
 683                         BT_LOGV("Removed destroy listener: "
 684                                 "comp-addr=%p, comp-name=\"%s\", "
 685                                 "func-addr=%p, data-addr=%p",
 686                                 component, bt_component_get_name(component),
 687                                 func, data);
 688                 }
 689         }
 690 }