src/lib/error.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright (c) 2019 Philippe Proulx <pproulx@efficios.com>
   5  */
   6
   7 #define BT_LOG_TAG "LIB/ERROR"
   8 #include "lib/logging.h"
   9
  10 #include <stdlib.h>
  11 #include <stdint.h>
  12 #include <babeltrace2/babeltrace.h>
  13
  14 #include "error.h"
  15 #include "graph/message/iterator.h"
  16 #include "graph/component.h"
  17 #include "graph/component-class.h"
  18 #include "common/assert.h"
  19 #include "lib/assert-cond.h"
  20 #include "lib/func-status.h"
  21
  22 #define BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(_cause, _exp_type_name, _exp_type) \
  23         BT_ASSERT_PRE("error-cause-has-" _exp_type_name "-actor",       \
  24                 ((const struct bt_error_cause *) (_cause))->actor_type == _exp_type, \
  25                 "Unexpected error cause's actor type: type=%s, exp-type=%s", \
  26                 bt_error_cause_actor_type_string(((const struct bt_error_cause *) (_cause))->actor_type), \
  27                 bt_error_cause_actor_type_string(_exp_type))
  28
  29 static
  30 void fini_component_class_id(
  31                 struct bt_error_cause_component_class_id *comp_class_id)
  32 {
  33         BT_ASSERT(comp_class_id);
  34
  35         if (comp_class_id->name) {
  36                 g_string_free(comp_class_id->name, TRUE);
  37                 comp_class_id->name = NULL;
  38         }
  39
  40         if (comp_class_id->plugin_name) {
  41                 g_string_free(comp_class_id->plugin_name, TRUE);
  42                 comp_class_id->plugin_name = NULL;
  43         }
  44 }
  45
  46 static
  47 void fini_error_cause(struct bt_error_cause *cause)
  48 {
  49         BT_ASSERT(cause);
  50         BT_LIB_LOGD("Finalizing error cause: %!+r", cause);
  51
  52         if (cause->module_name) {
  53                 g_string_free(cause->module_name, TRUE);
  54                 cause->module_name = NULL;
  55         }
  56
  57         if (cause->file_name) {
  58                 g_string_free(cause->file_name, TRUE);
  59                 cause->file_name = NULL;
  60         }
  61
  62         if (cause->message) {
  63                 g_string_free(cause->message, TRUE);
  64                 cause->message = NULL;
  65         }
  66 }
  67
  68 static
  69 void destroy_error_cause(struct bt_error_cause *cause)
  70 {
  71         if (!cause) {
  72                 goto end;
  73         }
  74
  75         BT_LIB_LOGD("Destroying error cause: %!+r", cause);
  76
  77         switch (cause->actor_type) {
  78         case BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT:
  79         {
  80                 struct bt_error_cause_component_actor *spec_cause =
  81                         (void *) cause;
  82
  83                 if (spec_cause->comp_name) {
  84                         g_string_free(spec_cause->comp_name, TRUE);
  85                         spec_cause->comp_name = NULL;
  86                 }
  87
  88                 fini_component_class_id(&spec_cause->comp_class_id);
  89                 break;
  90         }
  91         case BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS:
  92         {
  93                 struct bt_error_cause_component_class_actor *spec_cause =
  94                         (void *) cause;
  95
  96                 fini_component_class_id(&spec_cause->comp_class_id);
  97                 break;
  98         }
  99         case BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR:
 100         {
 101                 struct bt_error_cause_message_iterator_actor *spec_cause =
 102                         (void *) cause;
 103
 104                 if (spec_cause->comp_name) {
 105                         g_string_free(spec_cause->comp_name, TRUE);
 106                         spec_cause->comp_name = NULL;
 107                 }
 108
 109                 if (spec_cause->output_port_name) {
 110                         g_string_free(spec_cause->output_port_name, TRUE);
 111                         spec_cause->output_port_name = NULL;
 112                 }
 113
 114                 fini_component_class_id(&spec_cause->comp_class_id);
 115                 break;
 116         }
 117         default:
 118                 break;
 119         }
 120
 121         fini_error_cause(cause);
 122         g_free(cause);
 123
 124 end:
 125         return;
 126 }
 127
 128 static
 129 int init_error_cause(struct bt_error_cause *cause,
 130                 enum bt_error_cause_actor_type actor_type)
 131 {
 132         int ret = 0;
 133
 134         BT_ASSERT(cause);
 135         BT_LIB_LOGD("Initializing error cause: %!+r", cause);
 136         cause->actor_type = actor_type;
 137         cause->module_name = g_string_new(NULL);
 138         if (!cause->module_name) {
 139                 BT_LOGE_STR("Failed to allocate one GString.");
 140                 ret = -1;
 141                 goto end;
 142         }
 143
 144         cause->message = g_string_new(NULL);
 145         if (!cause->message) {
 146                 BT_LOGE_STR("Failed to allocate one GString.");
 147                 ret = -1;
 148                 goto end;
 149         }
 150
 151         cause->file_name = g_string_new(NULL);
 152         if (!cause->file_name) {
 153                 BT_LOGE_STR("Failed to allocate one GString.");
 154                 ret = -1;
 155                 goto end;
 156         }
 157
 158 end:
 159         return ret;
 160 }
 161
 162 static
 163 int init_component_class_id(
 164                 struct bt_error_cause_component_class_id *comp_class_id,
 165                 struct bt_component_class *comp_cls)
 166 {
 167         int ret = 0;
 168
 169         BT_ASSERT(comp_class_id);
 170         comp_class_id->type = comp_cls->type;
 171         comp_class_id->name = g_string_new(comp_cls->name->str);
 172         if (!comp_class_id->name) {
 173                 BT_LOGE_STR("Failed to allocate one GString.");
 174                 ret = -1;
 175                 goto end;
 176         }
 177
 178         comp_class_id->plugin_name = g_string_new(comp_cls->plugin_name->str);
 179         if (!comp_class_id->plugin_name) {
 180                 BT_LOGE_STR("Failed to allocate one GString.");
 181                 ret = -1;
 182                 goto end;
 183         }
 184
 185 end:
 186         return ret;
 187 }
 188
 189 static
 190 void set_error_cause_props(struct bt_error_cause *cause,
 191                 const char *file_name, uint64_t line_no)
 192 {
 193         BT_ASSERT(cause);
 194         g_string_assign(cause->file_name, file_name);
 195         cause->line_no = line_no;
 196 }
 197
 198 static
 199 struct bt_error_cause *create_error_cause(const char *module_name,
 200                 const char *file_name, uint64_t line_no)
 201 {
 202         struct bt_error_cause *cause = g_new0(struct bt_error_cause, 1);
 203         int ret;
 204
 205         BT_LOGD_STR("Creating error cause (unknown actor).");
 206
 207         if (!cause) {
 208                 BT_LOGE_STR("Failed to allocate one error cause.");
 209                 goto error;
 210         }
 211
 212         ret = init_error_cause(cause, BT_ERROR_CAUSE_ACTOR_TYPE_UNKNOWN);
 213         if (ret) {
 214                 goto error;
 215         }
 216
 217         g_string_assign(cause->module_name, module_name);
 218         set_error_cause_props(cause, file_name, line_no);
 219         BT_LIB_LOGD("Created error cause: %!+r", cause);
 220         goto end;
 221
 222 error:
 223         destroy_error_cause(cause);
 224         cause = NULL;
 225
 226 end:
 227         return cause;
 228 }
 229
 230 static
 231 void append_component_class_id_str(GString *str,
 232                 struct bt_error_cause_component_class_id *comp_class_id)
 233 {
 234         const char *type_str = NULL;
 235
 236         switch (comp_class_id->type) {
 237         case BT_COMPONENT_CLASS_TYPE_SOURCE:
 238                 type_str = "src";
 239                 break;
 240         case BT_COMPONENT_CLASS_TYPE_FILTER:
 241                 type_str = "flt";
 242                 break;
 243         case BT_COMPONENT_CLASS_TYPE_SINK:
 244                 type_str = "sink";
 245                 break;
 246         default:
 247                 bt_common_abort();
 248         }
 249
 250         if (comp_class_id->plugin_name->len > 0) {
 251                 g_string_append_printf(str, "%s.%s.%s",
 252                         type_str, comp_class_id->plugin_name->str,
 253                         comp_class_id->name->str);
 254         } else {
 255                 g_string_append_printf(str, "%s.%s",
 256                         type_str, comp_class_id->name->str);
 257         }
 258 }
 259
 260 static
 261 struct bt_error_cause_component_actor *create_error_cause_component_actor(
 262                 struct bt_component *comp, const char *file_name,
 263                 uint64_t line_no)
 264 {
 265         struct bt_error_cause_component_actor *cause =
 266                 g_new0(struct bt_error_cause_component_actor, 1);
 267         int ret;
 268
 269         BT_LOGD_STR("Creating error cause object (component actor).");
 270
 271         if (!cause) {
 272                 goto error;
 273         }
 274
 275         ret = init_error_cause(&cause->base,
 276                 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT);
 277         if (ret) {
 278                 goto error;
 279         }
 280
 281         set_error_cause_props(&cause->base, file_name, line_no);
 282         cause->comp_name = g_string_new(comp->name->str);
 283         if (!cause->comp_name) {
 284                 BT_LOGE_STR("Failed to allocate one GString.");
 285                 goto error;
 286         }
 287
 288         ret = init_component_class_id(&cause->comp_class_id, comp->class);
 289         if (ret) {
 290                 goto error;
 291         }
 292
 293         g_string_append_printf(cause->base.module_name, "%s: ",
 294                 comp->name->str);
 295         append_component_class_id_str(cause->base.module_name,
 296                 &cause->comp_class_id);
 297         BT_LIB_LOGD("Created error cause object: %!+r", cause);
 298         goto end;
 299
 300 error:
 301         if (cause) {
 302                 destroy_error_cause(&cause->base);
 303                 cause = NULL;
 304         }
 305
 306 end:
 307         return cause;
 308 }
 309
 310 static
 311 struct bt_error_cause_component_class_actor *
 312 create_error_cause_component_class_actor(struct bt_component_class *comp_cls,
 313                 const char *file_name, uint64_t line_no)
 314 {
 315         struct bt_error_cause_component_class_actor *cause =
 316                 g_new0(struct bt_error_cause_component_class_actor, 1);
 317         int ret;
 318
 319         BT_LOGD_STR("Creating error cause object (component class actor).");
 320
 321         if (!cause) {
 322                 BT_LOGE_STR("Failed to allocate one error cause object.");
 323                 goto error;
 324         }
 325
 326         ret = init_error_cause(&cause->base,
 327                 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS);
 328         if (ret) {
 329                 goto error;
 330         }
 331
 332         set_error_cause_props(&cause->base, file_name, line_no);
 333         ret = init_component_class_id(&cause->comp_class_id, comp_cls);
 334         if (ret) {
 335                 goto error;
 336         }
 337
 338         append_component_class_id_str(cause->base.module_name,
 339                 &cause->comp_class_id);
 340         BT_LIB_LOGD("Created error cause object: %!+r", cause);
 341         goto end;
 342
 343 error:
 344         if (cause) {
 345                 destroy_error_cause(&cause->base);
 346                 cause = NULL;
 347         }
 348
 349 end:
 350         return cause;
 351 }
 352
 353 static
 354 struct bt_error_cause_message_iterator_actor *
 355 create_error_cause_message_iterator_actor(struct bt_message_iterator *iter,
 356                 const char *file_name, uint64_t line_no)
 357 {
 358         struct bt_error_cause_message_iterator_actor *cause;
 359         struct bt_message_iterator *input_port_iter;
 360         int ret;
 361
 362         BT_LOGD_STR("Creating error cause object (message iterator actor).");
 363
 364         /*
 365          * This can only be created from within a graph, from a user
 366          * message iterator, which is a self component port input
 367          * message iterator.
 368          */
 369         input_port_iter = (void *) iter;
 370         cause = g_new0(struct bt_error_cause_message_iterator_actor, 1);
 371         if (!cause) {
 372                 BT_LOGE_STR("Failed to allocate one error cause object.");
 373                 goto error;
 374         }
 375
 376         ret = init_error_cause(&cause->base,
 377                 BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR);
 378         if (ret) {
 379                 goto error;
 380         }
 381
 382         set_error_cause_props(&cause->base, file_name, line_no);
 383         cause->comp_name = g_string_new(
 384                 input_port_iter->upstream_component->name->str);
 385         if (!cause->comp_name) {
 386                 BT_LOGE_STR("Failed to allocate one GString.");
 387                 goto error;
 388         }
 389
 390         cause->output_port_name = g_string_new(
 391                 input_port_iter->upstream_port->name->str);
 392         if (!cause->output_port_name) {
 393                 BT_LOGE_STR("Failed to allocate one GString.");
 394                 goto error;
 395         }
 396
 397         ret = init_component_class_id(&cause->comp_class_id,
 398                 input_port_iter->upstream_component->class);
 399         if (ret) {
 400                 goto error;
 401         }
 402
 403         g_string_append_printf(cause->base.module_name, "%s (%s): ",
 404                 input_port_iter->upstream_component->name->str,
 405                 input_port_iter->upstream_port->name->str);
 406         append_component_class_id_str(cause->base.module_name,
 407                 &cause->comp_class_id);
 408         BT_LIB_LOGD("Created error cause object: %!+r", cause);
 409         goto end;
 410
 411 error:
 412         if (cause) {
 413                 destroy_error_cause(&cause->base);
 414                 cause = NULL;
 415         }
 416
 417 end:
 418         return cause;
 419 }
 420
 421 BT_HIDDEN
 422 struct bt_error *bt_error_create(void)
 423 {
 424         struct bt_error *error;
 425
 426         BT_LOGD_STR("Creating error object.");
 427         error = g_new0(struct bt_error, 1);
 428         if (!error) {
 429                 BT_LOGE_STR("Failed to allocate one error object.");
 430                 goto error;
 431         }
 432
 433         error->causes = g_ptr_array_new_with_free_func(
 434                 (GDestroyNotify) destroy_error_cause);
 435         if (!error->causes) {
 436                 BT_LOGE_STR("Failed to allocate one GPtrArray.");
 437                 goto error;
 438         }
 439
 440         BT_LOGD("Created error object: addr=%p", error);
 441         goto end;
 442
 443 error:
 444         bt_error_destroy(error);
 445         error = NULL;
 446
 447 end:
 448         return error;
 449 }
 450
 451 BT_HIDDEN
 452 void bt_error_destroy(struct bt_error *error)
 453 {
 454         if (!error) {
 455                 goto end;
 456         }
 457
 458         if (error->causes) {
 459                 g_ptr_array_free(error->causes, TRUE);
 460                 error->causes = NULL;
 461         }
 462
 463         g_free(error);
 464
 465 end:
 466         return;
 467 }
 468
 469 BT_HIDDEN
 470 int bt_error_append_cause_from_unknown(struct bt_error *error,
 471                 const char *module_name, const char *file_name,
 472                 uint64_t line_no, const char *msg_fmt, va_list args)
 473 {
 474         struct bt_error_cause *cause = NULL;
 475         int status = BT_FUNC_STATUS_OK;
 476
 477         BT_ASSERT(error);
 478         BT_ASSERT(module_name);
 479         BT_ASSERT(file_name);
 480         BT_ASSERT(msg_fmt);
 481         BT_LOGD("Appending error cause from unknown actor: "
 482                 "module-name=\"%s\", func-name=\"%s\", line-no=%" PRIu64,
 483                 module_name, file_name, line_no);
 484         cause = create_error_cause(module_name, file_name, line_no);
 485         if (!cause) {
 486                 /* create_error_cause() logs errors */
 487                 status = BT_FUNC_STATUS_MEMORY_ERROR;
 488                 goto end;
 489         }
 490
 491         g_string_append_vprintf(cause->message, msg_fmt, args);
 492         g_ptr_array_add(error->causes, cause);
 493         BT_LIB_LOGD("Appended error cause: %!+r", cause);
 494         cause = NULL;
 495
 496 end:
 497         return status;
 498 }
 499
 500 BT_HIDDEN
 501 int bt_error_append_cause_from_component(
 502                 struct bt_error *error, bt_self_component *self_comp,
 503                 const char *file_name, uint64_t line_no,
 504                 const char *msg_fmt, va_list args)
 505 {
 506         struct bt_error_cause_component_actor *cause = NULL;
 507         int status = BT_FUNC_STATUS_OK;
 508
 509         BT_ASSERT(error);
 510         BT_ASSERT(self_comp);
 511         BT_ASSERT(file_name);
 512         BT_ASSERT(msg_fmt);
 513         BT_LIB_LOGD("Appending error cause from component actor: %![comp-]+c",
 514                 self_comp);
 515         cause = create_error_cause_component_actor((void *) self_comp,
 516                 file_name, line_no);
 517         if (!cause) {
 518                 /* create_error_cause_component_actor() logs errors */
 519                 status = BT_FUNC_STATUS_MEMORY_ERROR;
 520                 goto end;
 521         }
 522
 523         g_string_append_vprintf(cause->base.message, msg_fmt, args);
 524         g_ptr_array_add(error->causes, cause);
 525         BT_LIB_LOGD("Appended error cause: %!+r", cause);
 526         cause = NULL;
 527
 528 end:
 529         return status;
 530 }
 531
 532 BT_HIDDEN
 533 int bt_error_append_cause_from_component_class(
 534                 struct bt_error *error,
 535                 bt_self_component_class *self_comp_class,
 536                 const char *file_name, uint64_t line_no,
 537                 const char *msg_fmt, va_list args)
 538 {
 539         struct bt_error_cause_component_class_actor *cause = NULL;
 540         int status = BT_FUNC_STATUS_OK;
 541
 542         BT_ASSERT(error);
 543         BT_ASSERT(self_comp_class);
 544         BT_ASSERT(file_name);
 545         BT_ASSERT(msg_fmt);
 546         BT_LIB_LOGD("Appending error cause from component class actor: "
 547                 "%![comp-cls-]+C", self_comp_class);
 548         cause = create_error_cause_component_class_actor(
 549                 (void *) self_comp_class, file_name, line_no);
 550         if (!cause) {
 551                 /* create_error_cause_component_class_actor() logs errors */
 552                 status = BT_FUNC_STATUS_MEMORY_ERROR;
 553                 goto end;
 554         }
 555
 556         g_string_append_vprintf(cause->base.message, msg_fmt, args);
 557         g_ptr_array_add(error->causes, cause);
 558         BT_LIB_LOGD("Appended error cause: %!+r", cause);
 559         cause = NULL;
 560
 561 end:
 562         return status;
 563 }
 564
 565 BT_HIDDEN
 566 int bt_error_append_cause_from_message_iterator(
 567                 struct bt_error *error, bt_self_message_iterator *self_iter,
 568                 const char *file_name, uint64_t line_no,
 569                 const char *msg_fmt, va_list args)
 570 {
 571         struct bt_error_cause_message_iterator_actor *cause = NULL;
 572         int status = BT_FUNC_STATUS_OK;
 573
 574         BT_ASSERT(error);
 575         BT_ASSERT(self_iter);
 576         BT_ASSERT(file_name);
 577         BT_ASSERT(msg_fmt);
 578         BT_LIB_LOGD("Appending error cause from message iterator actor: "
 579                 "%![comp-]+i", self_iter);
 580         cause = create_error_cause_message_iterator_actor(
 581                 (void *) self_iter, file_name, line_no);
 582         if (!cause) {
 583                 /* create_error_cause_message_iterator_actor() logs errors */
 584                 status = BT_FUNC_STATUS_MEMORY_ERROR;
 585                 goto end;
 586         }
 587
 588         g_string_append_vprintf(cause->base.message, msg_fmt, args);
 589         g_ptr_array_add(error->causes, cause);
 590         BT_LIB_LOGD("Appended error cause: %!+r", cause);
 591         cause = NULL;
 592
 593 end:
 594         return status;
 595 }
 596
 597 static
 598 uint64_t error_cause_count(const bt_error *error)
 599 {
 600         return error->causes ? error->causes->len : 0;
 601 }
 602
 603 uint64_t bt_error_get_cause_count(const bt_error *error)
 604 {
 605         BT_ASSERT_PRE_ERROR_NON_NULL(error);
 606         return error_cause_count(error);
 607 }
 608
 609 void bt_error_release(const struct bt_error *error)
 610 {
 611         BT_ASSERT_PRE_ERROR_NON_NULL(error);
 612         bt_error_destroy((void *) error);
 613 }
 614
 615 const struct bt_error_cause *bt_error_borrow_cause_by_index(
 616                 const bt_error *error, uint64_t index)
 617 {
 618         BT_ASSERT_PRE_ERROR_NON_NULL(error);
 619         BT_ASSERT_PRE_VALID_INDEX(index, error_cause_count(error));
 620         return error->causes->pdata[index];
 621 }
 622
 623 enum bt_error_cause_actor_type bt_error_cause_get_actor_type(
 624                 const struct bt_error_cause *cause)
 625 {
 626         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 627         return cause->actor_type;
 628 }
 629
 630 const char *bt_error_cause_get_message(const struct bt_error_cause *cause)
 631 {
 632         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 633         return cause->message->str;
 634 }
 635
 636 const char *bt_error_cause_get_module_name(const struct bt_error_cause *cause)
 637 {
 638         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 639         return cause->module_name->str;
 640 }
 641
 642 const char *bt_error_cause_get_file_name(const struct bt_error_cause *cause)
 643 {
 644         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 645         return cause->file_name->str;
 646 }
 647
 648 uint64_t bt_error_cause_get_line_number(const bt_error_cause *cause)
 649 {
 650         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 651         return cause->line_no;
 652 }
 653
 654 const char *bt_error_cause_component_actor_get_component_name(
 655                 const struct bt_error_cause *cause)
 656 {
 657         const struct bt_error_cause_component_actor *spec_cause =
 658                 (const void *) cause;
 659
 660         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 661         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "component",
 662                 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT);
 663         return spec_cause->comp_name->str;
 664 }
 665
 666 bt_component_class_type bt_error_cause_component_actor_get_component_class_type(
 667                 const struct bt_error_cause *cause)
 668 {
 669         const struct bt_error_cause_component_actor *spec_cause =
 670                 (const void *) cause;
 671
 672         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 673         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "component",
 674                 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT);
 675         return spec_cause->comp_class_id.type;
 676 }
 677
 678 const char *bt_error_cause_component_actor_get_component_class_name(
 679                 const struct bt_error_cause *cause)
 680 {
 681         const struct bt_error_cause_component_actor *spec_cause =
 682                 (const void *) cause;
 683
 684         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 685         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "component",
 686                 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT);
 687         return spec_cause->comp_class_id.name->str;
 688 }
 689
 690 const char *bt_error_cause_component_actor_get_plugin_name(
 691                 const struct bt_error_cause *cause)
 692 {
 693         const struct bt_error_cause_component_actor *spec_cause =
 694                 (const void *) cause;
 695
 696         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 697         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "component",
 698                 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT);
 699         return spec_cause->comp_class_id.plugin_name->len > 0 ?
 700                 spec_cause->comp_class_id.plugin_name->str : NULL;
 701 }
 702
 703 bt_component_class_type
 704 bt_error_cause_component_class_actor_get_component_class_type(
 705                 const struct bt_error_cause *cause)
 706 {
 707         const struct bt_error_cause_component_class_actor *spec_cause =
 708                 (const void *) cause;
 709
 710         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 711         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "component-class",
 712                 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS);
 713         return spec_cause->comp_class_id.type;
 714 }
 715
 716 const char *bt_error_cause_component_class_actor_get_component_class_name(
 717                 const struct bt_error_cause *cause)
 718 {
 719         const struct bt_error_cause_component_class_actor *spec_cause =
 720                 (const void *) cause;
 721
 722         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 723         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "component-class",
 724                 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS);
 725         return spec_cause->comp_class_id.name->str;
 726 }
 727
 728 const char *bt_error_cause_component_class_actor_get_plugin_name(
 729                 const struct bt_error_cause *cause)
 730 {
 731         const struct bt_error_cause_component_class_actor *spec_cause =
 732                 (const void *) cause;
 733
 734         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 735         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "component-class",
 736                 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS);
 737         return spec_cause->comp_class_id.plugin_name->len > 0 ?
 738                 spec_cause->comp_class_id.plugin_name->str : NULL;
 739 }
 740
 741 const char *bt_error_cause_message_iterator_actor_get_component_name(
 742                 const struct bt_error_cause *cause)
 743 {
 744         const struct bt_error_cause_message_iterator_actor *spec_cause =
 745                 (const void *) cause;
 746
 747         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 748         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "message-iterator",
 749                 BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR);
 750         return spec_cause->comp_name->str;
 751 }
 752
 753 const char *
 754 bt_error_cause_message_iterator_actor_get_component_output_port_name(
 755                 const struct bt_error_cause *cause)
 756 {
 757         const struct bt_error_cause_message_iterator_actor *spec_cause =
 758                 (const void *) cause;
 759
 760         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 761         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "message-iterator",
 762                 BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR);
 763         return spec_cause->output_port_name->str;
 764 }
 765
 766 bt_component_class_type
 767 bt_error_cause_message_iterator_actor_get_component_class_type(
 768                 const struct bt_error_cause *cause)
 769 {
 770         const struct bt_error_cause_message_iterator_actor *spec_cause =
 771                 (const void *) cause;
 772
 773         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 774         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "message-iterator",
 775                 BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR);
 776         return spec_cause->comp_class_id.type;
 777 }
 778
 779 const char *bt_error_cause_message_iterator_actor_get_component_class_name(
 780                 const struct bt_error_cause *cause)
 781 {
 782         const struct bt_error_cause_message_iterator_actor *spec_cause =
 783                 (const void *) cause;
 784
 785         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 786         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "message-iterator",
 787                 BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR);
 788         return spec_cause->comp_class_id.name->str;
 789 }
 790
 791 const char *bt_error_cause_message_iterator_actor_get_plugin_name(
 792                 const struct bt_error_cause *cause)
 793 {
 794         const struct bt_error_cause_message_iterator_actor *spec_cause =
 795                 (const void *) cause;
 796
 797         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 798         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "message-iterator",
 799                 BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR);
 800         return spec_cause->comp_class_id.plugin_name->len > 0 ?
 801                 spec_cause->comp_class_id.plugin_name->str : NULL;
 802 }