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