src/lib/error.c

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