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         destroy_error_cause(cause);
 498         return status;
 499 }
 500
 501 BT_HIDDEN
 502 int bt_error_append_cause_from_component(
 503                 struct bt_error *error, bt_self_component *self_comp,
 504                 const char *file_name, uint64_t line_no,
 505                 const char *msg_fmt, va_list args)
 506 {
 507         struct bt_error_cause_component_actor *cause = NULL;
 508         int status = BT_FUNC_STATUS_OK;
 509
 510         BT_ASSERT(error);
 511         BT_ASSERT(self_comp);
 512         BT_ASSERT(file_name);
 513         BT_ASSERT(msg_fmt);
 514         BT_LIB_LOGD("Appending error cause from component actor: %![comp-]+c",
 515                 self_comp);
 516         cause = create_error_cause_component_actor((void *) self_comp,
 517                 file_name, line_no);
 518         if (!cause) {
 519                 /* create_error_cause_component_actor() logs errors */
 520                 status = BT_FUNC_STATUS_MEMORY_ERROR;
 521                 goto end;
 522         }
 523
 524         g_string_append_vprintf(cause->base.message, msg_fmt, args);
 525         g_ptr_array_add(error->causes, cause);
 526         BT_LIB_LOGD("Appended error cause: %!+r", cause);
 527         cause = NULL;
 528
 529 end:
 530         if (cause) {
 531                 destroy_error_cause(&cause->base);
 532         }
 533
 534         return status;
 535 }
 536
 537 BT_HIDDEN
 538 int bt_error_append_cause_from_component_class(
 539                 struct bt_error *error,
 540                 bt_self_component_class *self_comp_class,
 541                 const char *file_name, uint64_t line_no,
 542                 const char *msg_fmt, va_list args)
 543 {
 544         struct bt_error_cause_component_class_actor *cause = NULL;
 545         int status = BT_FUNC_STATUS_OK;
 546
 547         BT_ASSERT(error);
 548         BT_ASSERT(self_comp_class);
 549         BT_ASSERT(file_name);
 550         BT_ASSERT(msg_fmt);
 551         BT_LIB_LOGD("Appending error cause from component class actor: "
 552                 "%![comp-cls-]+C", self_comp_class);
 553         cause = create_error_cause_component_class_actor(
 554                 (void *) self_comp_class, file_name, line_no);
 555         if (!cause) {
 556                 /* create_error_cause_component_class_actor() logs errors */
 557                 status = BT_FUNC_STATUS_MEMORY_ERROR;
 558                 goto end;
 559         }
 560
 561         g_string_append_vprintf(cause->base.message, msg_fmt, args);
 562         g_ptr_array_add(error->causes, cause);
 563         BT_LIB_LOGD("Appended error cause: %!+r", cause);
 564         cause = NULL;
 565
 566 end:
 567         if (cause) {
 568                 destroy_error_cause(&cause->base);
 569         }
 570
 571         return status;
 572 }
 573
 574 BT_HIDDEN
 575 int bt_error_append_cause_from_message_iterator(
 576                 struct bt_error *error, bt_self_message_iterator *self_iter,
 577                 const char *file_name, uint64_t line_no,
 578                 const char *msg_fmt, va_list args)
 579 {
 580         struct bt_error_cause_message_iterator_actor *cause = NULL;
 581         int status = BT_FUNC_STATUS_OK;
 582
 583         BT_ASSERT(error);
 584         BT_ASSERT(self_iter);
 585         BT_ASSERT(file_name);
 586         BT_ASSERT(msg_fmt);
 587         BT_LIB_LOGD("Appending error cause from message iterator actor: "
 588                 "%![comp-]+i", self_iter);
 589         cause = create_error_cause_message_iterator_actor(
 590                 (void *) self_iter, file_name, line_no);
 591         if (!cause) {
 592                 /* create_error_cause_message_iterator_actor() logs errors */
 593                 status = BT_FUNC_STATUS_MEMORY_ERROR;
 594                 goto end;
 595         }
 596
 597         g_string_append_vprintf(cause->base.message, msg_fmt, args);
 598         g_ptr_array_add(error->causes, cause);
 599         BT_LIB_LOGD("Appended error cause: %!+r", cause);
 600         cause = NULL;
 601
 602 end:
 603         if (cause) {
 604                 destroy_error_cause(&cause->base);
 605         }
 606
 607         return status;
 608 }
 609
 610 static
 611 uint64_t error_cause_count(const bt_error *error)
 612 {
 613         return error->causes ? error->causes->len : 0;
 614 }
 615
 616 uint64_t bt_error_get_cause_count(const bt_error *error)
 617 {
 618         BT_ASSERT_PRE_ERROR_NON_NULL(error);
 619         return error_cause_count(error);
 620 }
 621
 622 void bt_error_release(const struct bt_error *error)
 623 {
 624         BT_ASSERT_PRE_ERROR_NON_NULL(error);
 625         bt_error_destroy((void *) error);
 626 }
 627
 628 const struct bt_error_cause *bt_error_borrow_cause_by_index(
 629                 const bt_error *error, uint64_t index)
 630 {
 631         BT_ASSERT_PRE_ERROR_NON_NULL(error);
 632         BT_ASSERT_PRE_VALID_INDEX(index, error_cause_count(error));
 633         return error->causes->pdata[index];
 634 }
 635
 636 enum bt_error_cause_actor_type bt_error_cause_get_actor_type(
 637                 const struct bt_error_cause *cause)
 638 {
 639         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 640         return cause->actor_type;
 641 }
 642
 643 const char *bt_error_cause_get_message(const struct bt_error_cause *cause)
 644 {
 645         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 646         return cause->message->str;
 647 }
 648
 649 const char *bt_error_cause_get_module_name(const struct bt_error_cause *cause)
 650 {
 651         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 652         return cause->module_name->str;
 653 }
 654
 655 const char *bt_error_cause_get_file_name(const struct bt_error_cause *cause)
 656 {
 657         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 658         return cause->file_name->str;
 659 }
 660
 661 uint64_t bt_error_cause_get_line_number(const bt_error_cause *cause)
 662 {
 663         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 664         return cause->line_no;
 665 }
 666
 667 const char *bt_error_cause_component_actor_get_component_name(
 668                 const struct bt_error_cause *cause)
 669 {
 670         const struct bt_error_cause_component_actor *spec_cause =
 671                 (const void *) cause;
 672
 673         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 674         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "component",
 675                 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT);
 676         return spec_cause->comp_name->str;
 677 }
 678
 679 bt_component_class_type bt_error_cause_component_actor_get_component_class_type(
 680                 const struct bt_error_cause *cause)
 681 {
 682         const struct bt_error_cause_component_actor *spec_cause =
 683                 (const void *) cause;
 684
 685         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 686         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "component",
 687                 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT);
 688         return spec_cause->comp_class_id.type;
 689 }
 690
 691 const char *bt_error_cause_component_actor_get_component_class_name(
 692                 const struct bt_error_cause *cause)
 693 {
 694         const struct bt_error_cause_component_actor *spec_cause =
 695                 (const void *) cause;
 696
 697         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 698         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "component",
 699                 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT);
 700         return spec_cause->comp_class_id.name->str;
 701 }
 702
 703 const char *bt_error_cause_component_actor_get_plugin_name(
 704                 const struct bt_error_cause *cause)
 705 {
 706         const struct bt_error_cause_component_actor *spec_cause =
 707                 (const void *) cause;
 708
 709         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 710         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "component",
 711                 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT);
 712         return spec_cause->comp_class_id.plugin_name->len > 0 ?
 713                 spec_cause->comp_class_id.plugin_name->str : NULL;
 714 }
 715
 716 bt_component_class_type
 717 bt_error_cause_component_class_actor_get_component_class_type(
 718                 const struct bt_error_cause *cause)
 719 {
 720         const struct bt_error_cause_component_class_actor *spec_cause =
 721                 (const void *) cause;
 722
 723         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 724         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "component-class",
 725                 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS);
 726         return spec_cause->comp_class_id.type;
 727 }
 728
 729 const char *bt_error_cause_component_class_actor_get_component_class_name(
 730                 const struct bt_error_cause *cause)
 731 {
 732         const struct bt_error_cause_component_class_actor *spec_cause =
 733                 (const void *) cause;
 734
 735         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 736         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "component-class",
 737                 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS);
 738         return spec_cause->comp_class_id.name->str;
 739 }
 740
 741 const char *bt_error_cause_component_class_actor_get_plugin_name(
 742                 const struct bt_error_cause *cause)
 743 {
 744         const struct bt_error_cause_component_class_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, "component-class",
 749                 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS);
 750         return spec_cause->comp_class_id.plugin_name->len > 0 ?
 751                 spec_cause->comp_class_id.plugin_name->str : NULL;
 752 }
 753
 754 const char *bt_error_cause_message_iterator_actor_get_component_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->comp_name->str;
 764 }
 765
 766 const char *
 767 bt_error_cause_message_iterator_actor_get_component_output_port_name(
 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->output_port_name->str;
 777 }
 778
 779 bt_component_class_type
 780 bt_error_cause_message_iterator_actor_get_component_class_type(
 781                 const struct bt_error_cause *cause)
 782 {
 783         const struct bt_error_cause_message_iterator_actor *spec_cause =
 784                 (const void *) cause;
 785
 786         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 787         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "message-iterator",
 788                 BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR);
 789         return spec_cause->comp_class_id.type;
 790 }
 791
 792 const char *bt_error_cause_message_iterator_actor_get_component_class_name(
 793                 const struct bt_error_cause *cause)
 794 {
 795         const struct bt_error_cause_message_iterator_actor *spec_cause =
 796                 (const void *) cause;
 797
 798         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 799         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "message-iterator",
 800                 BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR);
 801         return spec_cause->comp_class_id.name->str;
 802 }
 803
 804 const char *bt_error_cause_message_iterator_actor_get_plugin_name(
 805                 const struct bt_error_cause *cause)
 806 {
 807         const struct bt_error_cause_message_iterator_actor *spec_cause =
 808                 (const void *) cause;
 809
 810         BT_ASSERT_PRE_ERROR_CAUSE_NON_NULL(cause);
 811         BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause, "message-iterator",
 812                 BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR);
 813         return spec_cause->comp_class_id.plugin_name->len > 0 ?
 814                 spec_cause->comp_class_id.plugin_name->str : NULL;
 815 }