src/plugins/lttng-utils/debug-info/debug-info.c

   1 /*
   2  * Babeltrace - Debug Information State Tracker
   3  *
   4  * Copyright (c) 2015 EfficiOS Inc. and Linux Foundation
   5  * Copyright (c) 2015 Philippe Proulx <pproulx@efficios.com>
   6  * Copyright (c) 2015 Antoine Busque <abusque@efficios.com>
   7  * Copyright (c) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   8  * Copyright (c) 2019 Francis Deslauriers <francis.deslauriers@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_COMP_LOG_SELF_COMP self_comp
  30 #define BT_LOG_OUTPUT_LEVEL log_level
  31 #define BT_LOG_TAG "PLUGIN/FLT.LTTNG-UTILS.DEBUG-INFO"
  32 #include "logging/comp-logging.h"
  33
  34 #include <stdbool.h>
  35
  36 #include <glib.h>
  37
  38 #include "common/assert.h"
  39 #include "common/common.h"
  40 #include "fd-cache/fd-cache.h"
  41
  42 #include "bin-info.h"
  43 #include "debug-info.h"
  44 #include "trace-ir-data-copy.h"
  45 #include "trace-ir-mapping.h"
  46 #include "trace-ir-metadata-copy.h"
  47 #include "utils.h"
  48 #include "plugins/common/param-validation/param-validation.h"
  49
  50 #define DEFAULT_DEBUG_INFO_FIELD_NAME   "debug_info"
  51 #define LTTNG_UST_STATEDUMP_PREFIX      "lttng_ust"
  52 #define VPID_FIELD_NAME                 "vpid"
  53 #define IP_FIELD_NAME                   "ip"
  54 #define BADDR_FIELD_NAME                "baddr"
  55 #define CRC32_FIELD_NAME                "crc"
  56 #define BUILD_ID_FIELD_NAME             "build_id"
  57 #define FILENAME_FIELD_NAME             "filename"
  58 #define IS_PIC_FIELD_NAME               "is_pic"
  59 #define MEMSZ_FIELD_NAME                "memsz"
  60 #define PATH_FIELD_NAME                 "path"
  61
  62 struct debug_info_component {
  63         bt_logging_level log_level;
  64         bt_self_component *self_comp;
  65         bt_self_component_filter *self_comp_filter;
  66         gchar *arg_debug_dir;
  67         gchar *arg_debug_info_field_name;
  68         gchar *arg_target_prefix;
  69         bt_bool arg_full_path;
  70 };
  71
  72 struct debug_info_msg_iter {
  73         bt_logging_level log_level;
  74         struct debug_info_component *debug_info_component;
  75         bt_self_message_iterator *input_iterator;
  76         bt_self_component *self_comp;
  77         bt_self_component_port_input_message_iterator *msg_iter;
  78
  79         struct trace_ir_maps *ir_maps;
  80         /* in_trace -> debug_info_mapping. */
  81         GHashTable *debug_info_map;
  82
  83         struct bt_fd_cache fd_cache;
  84 };
  85
  86 struct debug_info_source {
  87         /* Strings are owned by debug_info_source. */
  88         gchar *func;
  89         /*
  90          * Store the line number as a string so that the allocation and
  91          * conversion to string is only done once.
  92          */
  93         gchar *line_no;
  94         gchar *src_path;
  95         /* short_src_path points inside src_path, no need to free. */
  96         const gchar *short_src_path;
  97         gchar *bin_path;
  98         /* short_bin_path points inside bin_path, no need to free. */
  99         const gchar *short_bin_path;
 100         /*
 101          * Location within the binary. Either absolute (@0x1234) or
 102          * relative (+0x4321).
 103          */
 104         gchar *bin_loc;
 105 };
 106
 107 struct proc_debug_info_sources {
 108         /*
 109          * Hash table: base address (pointer to uint64_t) to bin info; owned by
 110          * proc_debug_info_sources.
 111          */
 112         GHashTable *baddr_to_bin_info;
 113
 114         /*
 115          * Hash table: IP (pointer to uint64_t) to (struct debug_info_source *);
 116          * owned by proc_debug_info_sources.
 117          */
 118         GHashTable *ip_to_debug_info_src;
 119 };
 120
 121 struct debug_info {
 122         bt_logging_level log_level;
 123         bt_self_component *self_comp;
 124         struct debug_info_component *comp;
 125         const bt_trace *input_trace;
 126         bt_listener_id destruction_listener_id;
 127
 128         /*
 129          * Hash table of VPIDs (pointer to int64_t) to
 130          * (struct proc_debug_info_sources*); owned by debug_info.
 131          */
 132         GHashTable *vpid_to_proc_dbg_info_src;
 133         GQuark q_statedump_bin_info;
 134         GQuark q_statedump_debug_link;
 135         GQuark q_statedump_build_id;
 136         GQuark q_statedump_start;
 137         GQuark q_dl_open;
 138         GQuark q_lib_load;
 139         GQuark q_lib_unload;
 140         struct bt_fd_cache *fd_cache; /* Weak ref. Owned by the iterator. */
 141 };
 142
 143 static
 144 int debug_info_init(struct debug_info *info)
 145 {
 146         info->q_statedump_bin_info = g_quark_from_string(
 147                         "lttng_ust_statedump:bin_info");
 148         info->q_statedump_debug_link = g_quark_from_string(
 149                         "lttng_ust_statedump:debug_link");
 150         info->q_statedump_build_id = g_quark_from_string(
 151                         "lttng_ust_statedump:build_id");
 152         info->q_statedump_start = g_quark_from_string(
 153                         "lttng_ust_statedump:start");
 154         info->q_dl_open = g_quark_from_string("lttng_ust_dl:dlopen");
 155         info->q_lib_load = g_quark_from_string("lttng_ust_lib:load");
 156         info->q_lib_unload = g_quark_from_string("lttng_ust_lib:unload");
 157
 158         return bin_info_init(info->log_level, info->self_comp);
 159 }
 160
 161 static
 162 void debug_info_source_destroy(struct debug_info_source *debug_info_src)
 163 {
 164         if (!debug_info_src) {
 165                 return;
 166         }
 167
 168         g_free(debug_info_src->func);
 169         g_free(debug_info_src->line_no);
 170         g_free(debug_info_src->src_path);
 171         g_free(debug_info_src->bin_path);
 172         g_free(debug_info_src->bin_loc);
 173         g_free(debug_info_src);
 174 }
 175
 176 static
 177 struct debug_info_source *debug_info_source_create_from_bin(
 178                 struct bin_info *bin, uint64_t ip,
 179                 bt_self_component *self_comp)
 180 {
 181         int ret;
 182         struct debug_info_source *debug_info_src = NULL;
 183         struct source_location *src_loc = NULL;
 184         bt_logging_level log_level;
 185
 186         BT_ASSERT(bin);
 187
 188         log_level = bin->log_level;
 189
 190         debug_info_src = g_new0(struct debug_info_source, 1);
 191
 192         if (!debug_info_src) {
 193                 goto end;
 194         }
 195
 196         /* Lookup function name */
 197         ret = bin_info_lookup_function_name(bin, ip, &debug_info_src->func);
 198         if (ret) {
 199                 goto error;
 200         }
 201
 202         /* Can't retrieve src_loc from ELF, or could not find binary, skip. */
 203         if (!bin->is_elf_only || !debug_info_src->func) {
 204                 /* Lookup source location */
 205                 ret = bin_info_lookup_source_location(bin, ip, &src_loc);
 206                 if (ret) {
 207                         BT_COMP_LOGI("Failed to lookup source location: ret=%d", ret);
 208                 }
 209         }
 210
 211         if (src_loc) {
 212                 debug_info_src->line_no =
 213                         g_strdup_printf("%"PRId64, src_loc->line_no);
 214                 if (!debug_info_src->line_no) {
 215                         BT_COMP_LOGE_APPEND_CAUSE(self_comp,
 216                                 "Error occured when setting `line_no` field.");
 217                         goto error;
 218                 }
 219
 220                 if (src_loc->filename) {
 221                         debug_info_src->src_path = g_strdup(src_loc->filename);
 222                         if (!debug_info_src->src_path) {
 223                                 goto error;
 224                         }
 225
 226                         debug_info_src->short_src_path = get_filename_from_path(
 227                                 debug_info_src->src_path);
 228                 }
 229                 source_location_destroy(src_loc);
 230         }
 231
 232         if (bin->elf_path) {
 233                 debug_info_src->bin_path = g_strdup(bin->elf_path);
 234                 if (!debug_info_src->bin_path) {
 235                         goto error;
 236                 }
 237
 238                 debug_info_src->short_bin_path = get_filename_from_path(
 239                         debug_info_src->bin_path);
 240
 241                 ret = bin_info_get_bin_loc(bin, ip, &(debug_info_src->bin_loc));
 242                 if (ret) {
 243                         goto error;
 244                 }
 245         }
 246
 247 end:
 248         return debug_info_src;
 249
 250 error:
 251         debug_info_source_destroy(debug_info_src);
 252         return NULL;
 253 }
 254
 255 static
 256 void proc_debug_info_sources_destroy(
 257                 struct proc_debug_info_sources *proc_dbg_info_src)
 258 {
 259         if (!proc_dbg_info_src) {
 260                 return;
 261         }
 262
 263         if (proc_dbg_info_src->baddr_to_bin_info) {
 264                 g_hash_table_destroy(proc_dbg_info_src->baddr_to_bin_info);
 265         }
 266
 267         if (proc_dbg_info_src->ip_to_debug_info_src) {
 268                 g_hash_table_destroy(proc_dbg_info_src->ip_to_debug_info_src);
 269         }
 270
 271         g_free(proc_dbg_info_src);
 272 }
 273
 274 static
 275 struct proc_debug_info_sources *proc_debug_info_sources_create(void)
 276 {
 277         struct proc_debug_info_sources *proc_dbg_info_src = NULL;
 278
 279         proc_dbg_info_src = g_new0(struct proc_debug_info_sources, 1);
 280         if (!proc_dbg_info_src) {
 281                 goto end;
 282         }
 283
 284         proc_dbg_info_src->baddr_to_bin_info = g_hash_table_new_full(
 285                 g_int64_hash, g_int64_equal, (GDestroyNotify) g_free,
 286                 (GDestroyNotify) bin_info_destroy);
 287         if (!proc_dbg_info_src->baddr_to_bin_info) {
 288                 goto error;
 289         }
 290
 291         proc_dbg_info_src->ip_to_debug_info_src = g_hash_table_new_full(
 292                 g_int64_hash, g_int64_equal, (GDestroyNotify) g_free,
 293                 (GDestroyNotify) debug_info_source_destroy);
 294         if (!proc_dbg_info_src->ip_to_debug_info_src) {
 295                 goto error;
 296         }
 297
 298 end:
 299         return proc_dbg_info_src;
 300
 301 error:
 302         proc_debug_info_sources_destroy(proc_dbg_info_src);
 303         return NULL;
 304 }
 305
 306 static
 307 struct proc_debug_info_sources *proc_debug_info_sources_ht_get_entry(
 308                 GHashTable *ht, int64_t vpid)
 309 {
 310         gpointer key = g_new0(int64_t, 1);
 311         struct proc_debug_info_sources *proc_dbg_info_src = NULL;
 312
 313         if (!key) {
 314                 goto end;
 315         }
 316
 317         *((int64_t *) key) = vpid;
 318
 319         /* Exists? Return it */
 320         proc_dbg_info_src = g_hash_table_lookup(ht, key);
 321         if (proc_dbg_info_src) {
 322                 goto end;
 323         }
 324
 325         /* Otherwise, create and return it */
 326         proc_dbg_info_src = proc_debug_info_sources_create();
 327         if (!proc_dbg_info_src) {
 328                 goto end;
 329         }
 330
 331         g_hash_table_insert(ht, key, proc_dbg_info_src);
 332         /* Ownership passed to ht */
 333         key = NULL;
 334 end:
 335         g_free(key);
 336         return proc_dbg_info_src;
 337 }
 338
 339 static inline
 340 const bt_field *event_borrow_payload_field(const bt_event *event,
 341                 const char *field_name)
 342 {
 343         const bt_field *event_payload, *field;
 344
 345         event_payload =  bt_event_borrow_payload_field_const(event);
 346         BT_ASSERT_DBG(event_payload);
 347
 348         field = bt_field_structure_borrow_member_field_by_name_const(
 349                 event_payload, field_name);
 350         return field;
 351 }
 352
 353 static inline
 354 const bt_field *event_borrow_common_context_field(const bt_event *event,
 355                 const char *field_name)
 356 {
 357         const bt_field *event_common_ctx, *field = NULL;
 358
 359         event_common_ctx =  bt_event_borrow_common_context_field_const(event);
 360         if (!event_common_ctx) {
 361                 goto end;
 362         }
 363
 364         field = bt_field_structure_borrow_member_field_by_name_const(
 365                 event_common_ctx, field_name);
 366
 367 end:
 368         return field;
 369 }
 370
 371 static inline
 372 void event_get_common_context_signed_integer_field_value(
 373                 const bt_event *event, const char *field_name, int64_t *value)
 374 {
 375         *value = bt_field_integer_signed_get_value(
 376                 event_borrow_common_context_field(event, field_name));
 377 }
 378
 379 static inline
 380 void event_get_payload_build_id_length(const bt_event *event,
 381                 const char *field_name, uint64_t *build_id_len)
 382 {
 383         const bt_field *build_id_field;
 384         const bt_field_class *build_id_field_class;
 385
 386         build_id_field = event_borrow_payload_field(event, field_name);
 387         build_id_field_class = bt_field_borrow_class_const(build_id_field);
 388
 389         BT_ASSERT(bt_field_class_get_type(build_id_field_class) ==
 390                 BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD ||
 391                 bt_field_class_get_type(build_id_field_class) ==
 392                 BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD);
 393         BT_ASSERT(bt_field_class_get_type(
 394                 bt_field_class_array_borrow_element_field_class_const(
 395                         build_id_field_class)) ==
 396                 BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER);
 397
 398         *build_id_len = bt_field_array_get_length(build_id_field);
 399 }
 400
 401 static inline
 402 void event_get_payload_build_id_value(const bt_event *event,
 403                 const char *field_name, uint8_t *build_id)
 404 {
 405         const bt_field *curr_field, *build_id_field;
 406         const bt_field_class *build_id_field_class;
 407         uint64_t i, build_id_len;
 408
 409         build_id_field = event_borrow_payload_field(event, field_name);
 410         build_id_field_class = bt_field_borrow_class_const(build_id_field);
 411
 412         BT_ASSERT(bt_field_class_get_type(build_id_field_class) ==
 413                 BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD ||
 414                 bt_field_class_get_type(build_id_field_class) ==
 415                 BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD);
 416         BT_ASSERT(bt_field_class_get_type(
 417                 bt_field_class_array_borrow_element_field_class_const(
 418                         build_id_field_class)) ==
 419                 BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER);
 420
 421         build_id_len = bt_field_array_get_length(build_id_field);
 422
 423         for (i = 0; i < build_id_len; i++) {
 424                 curr_field = bt_field_array_borrow_element_field_by_index_const(
 425                         build_id_field, i);
 426
 427                 build_id[i] = bt_field_integer_unsigned_get_value(curr_field);
 428         }
 429 }
 430
 431 static
 432 void event_get_payload_unsigned_integer_field_value(const bt_event *event,
 433                 const char *field_name, uint64_t *value)
 434 {
 435         *value = bt_field_integer_unsigned_get_value(
 436                 event_borrow_payload_field(event, field_name));
 437 }
 438
 439 static
 440 void event_get_payload_string_field_value(const bt_event *event,
 441                 const char *field_name, const char **value)
 442 {
 443         *value = bt_field_string_get_value(
 444                 event_borrow_payload_field(event, field_name));
 445 }
 446
 447 static inline
 448 bool event_has_payload_field(const bt_event *event,
 449                 const char *field_name)
 450 {
 451         return event_borrow_payload_field(event, field_name);
 452 }
 453
 454 static
 455 struct debug_info_source *proc_debug_info_sources_get_entry(
 456                 struct debug_info *debug_info,
 457                 struct proc_debug_info_sources *proc_dbg_info_src, uint64_t ip)
 458 {
 459         struct debug_info_source *debug_info_src = NULL;
 460         gpointer key = g_new0(uint64_t, 1);
 461         GHashTableIter iter;
 462         gpointer baddr, value;
 463
 464         if (!key) {
 465                 goto end;
 466         }
 467
 468         *((uint64_t *) key) = ip;
 469
 470         /* Look in IP to debug infos hash table first. */
 471         debug_info_src = g_hash_table_lookup(
 472                 proc_dbg_info_src->ip_to_debug_info_src, key);
 473         if (debug_info_src) {
 474                 goto end;
 475         }
 476
 477         /* Check in all bin_infos. */
 478         g_hash_table_iter_init(&iter, proc_dbg_info_src->baddr_to_bin_info);
 479
 480         while (g_hash_table_iter_next(&iter, &baddr, &value))
 481         {
 482                 struct bin_info *bin = value;
 483
 484                 if (!bin_info_has_address(value, ip)) {
 485                         continue;
 486                 }
 487
 488                 /*
 489                  * Found; add it to cache.
 490                  *
 491                  * FIXME: this should be bounded in size (and implement
 492                  * a caching policy), and entries should be prunned when
 493                  * libraries are unmapped.
 494                  */
 495                 debug_info_src = debug_info_source_create_from_bin(bin, ip,
 496                         debug_info->self_comp);
 497                 if (debug_info_src) {
 498                         g_hash_table_insert(
 499                                 proc_dbg_info_src->ip_to_debug_info_src, key,
 500                                 debug_info_src);
 501                         /* Ownership passed to ht. */
 502                         key = NULL;
 503                 }
 504                 break;
 505         }
 506
 507 end:
 508         free(key);
 509         return debug_info_src;
 510 }
 511
 512 static
 513 struct debug_info_source *debug_info_query(struct debug_info *debug_info,
 514                 int64_t vpid, uint64_t ip)
 515 {
 516         struct debug_info_source *dbg_info_src = NULL;
 517         struct proc_debug_info_sources *proc_dbg_info_src;
 518
 519         proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
 520                 debug_info->vpid_to_proc_dbg_info_src, vpid);
 521         if (!proc_dbg_info_src) {
 522                 goto end;
 523         }
 524
 525         dbg_info_src = proc_debug_info_sources_get_entry(debug_info,
 526                 proc_dbg_info_src, ip);
 527
 528 end:
 529         return dbg_info_src;
 530 }
 531
 532 static
 533 struct debug_info *debug_info_create(struct debug_info_component *comp,
 534                 const bt_trace *trace, struct bt_fd_cache *fdc)
 535 {
 536         int ret;
 537         struct debug_info *debug_info;
 538
 539         BT_ASSERT(comp);
 540         BT_ASSERT(trace);
 541         BT_ASSERT(fdc);
 542
 543         debug_info = g_new0(struct debug_info, 1);
 544         if (!debug_info) {
 545                 goto end;
 546         }
 547
 548         debug_info->log_level = comp->log_level;
 549         debug_info->self_comp = comp->self_comp;
 550         debug_info->vpid_to_proc_dbg_info_src = g_hash_table_new_full(
 551                 g_int64_hash, g_int64_equal, (GDestroyNotify) g_free,
 552                 (GDestroyNotify) proc_debug_info_sources_destroy);
 553         if (!debug_info->vpid_to_proc_dbg_info_src) {
 554                 goto error;
 555         }
 556
 557         debug_info->comp = comp;
 558         ret = debug_info_init(debug_info);
 559         if (ret) {
 560                 goto error;
 561         }
 562
 563         debug_info->input_trace = trace;
 564         debug_info->fd_cache = fdc;
 565
 566 end:
 567         return debug_info;
 568 error:
 569         g_free(debug_info);
 570         return NULL;
 571 }
 572
 573 static
 574 void debug_info_destroy(struct debug_info *debug_info)
 575 {
 576         bt_logging_level log_level;
 577         bt_self_component *self_comp;
 578         bt_trace_remove_listener_status remove_listener_status;
 579         if (!debug_info) {
 580                 goto end;
 581         }
 582
 583         log_level = debug_info->log_level;
 584         self_comp = debug_info->self_comp;
 585
 586         if (debug_info->vpid_to_proc_dbg_info_src) {
 587                 g_hash_table_destroy(debug_info->vpid_to_proc_dbg_info_src);
 588         }
 589
 590         remove_listener_status = bt_trace_remove_destruction_listener(
 591                 debug_info->input_trace,
 592                 debug_info->destruction_listener_id);
 593         if (remove_listener_status != BT_TRACE_REMOVE_LISTENER_STATUS_OK) {
 594                 BT_COMP_LOGE("Trace destruction listener removal failed.");
 595                 bt_current_thread_clear_error();
 596         }
 597
 598         g_free(debug_info);
 599 end:
 600         return;
 601 }
 602
 603 static
 604 void handle_event_statedump_build_id(struct debug_info *debug_info,
 605                 const bt_event *event)
 606 {
 607         struct proc_debug_info_sources *proc_dbg_info_src;
 608         uint64_t build_id_len, baddr;
 609         uint8_t *build_id = NULL;
 610         struct bin_info *bin;
 611         int64_t vpid;
 612         int ret = 0;
 613
 614         event_get_common_context_signed_integer_field_value(event,
 615                 VPID_FIELD_NAME, &vpid);
 616         event_get_payload_unsigned_integer_field_value(event,
 617                 BADDR_FIELD_NAME, &baddr);
 618
 619         proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
 620                 debug_info->vpid_to_proc_dbg_info_src, vpid);
 621         if (!proc_dbg_info_src) {
 622                 goto end;
 623         }
 624
 625         bin = g_hash_table_lookup(proc_dbg_info_src->baddr_to_bin_info,
 626                 (gpointer) &baddr);
 627         if (!bin) {
 628                 /*
 629                  * The build_id event comes after the bin has been
 630                  * created. If it isn't found, just ignore this event.
 631                  */
 632                 goto end;
 633         }
 634
 635         event_get_payload_build_id_length(event, BUILD_ID_FIELD_NAME,
 636                 &build_id_len);
 637
 638         build_id = g_new0(uint8_t, build_id_len);
 639         if (!build_id) {
 640                 goto end;
 641         }
 642
 643         event_get_payload_build_id_value(event, BUILD_ID_FIELD_NAME, build_id);
 644
 645         ret = bin_info_set_build_id(bin, build_id, build_id_len);
 646         if (ret) {
 647                 goto end;
 648         }
 649
 650         /*
 651          * Reset the is_elf_only flag in case it had been set
 652          * previously, because we might find separate debug info using
 653          * the new build id information.
 654          */
 655         bin->is_elf_only = false;
 656
 657 end:
 658         g_free(build_id);
 659         return;
 660 }
 661
 662 static
 663 void handle_event_statedump_debug_link(struct debug_info *debug_info,
 664                 const bt_event *event)
 665 {
 666         struct proc_debug_info_sources *proc_dbg_info_src;
 667         struct bin_info *bin = NULL;
 668         int64_t vpid;
 669         uint64_t baddr;
 670         const char *filename = NULL;
 671         uint32_t crc32;
 672         uint64_t crc_field_value;
 673
 674         event_get_common_context_signed_integer_field_value(event,
 675                 VPID_FIELD_NAME, &vpid);
 676
 677         event_get_payload_unsigned_integer_field_value(event,
 678                 BADDR_FIELD_NAME, &baddr);
 679
 680         event_get_payload_unsigned_integer_field_value(event,
 681                 CRC32_FIELD_NAME, &crc_field_value);
 682
 683         crc32 = (uint32_t) crc_field_value;
 684
 685         event_get_payload_string_field_value(event,
 686                 FILENAME_FIELD_NAME, &filename);
 687
 688         proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
 689                 debug_info->vpid_to_proc_dbg_info_src, vpid);
 690         if (!proc_dbg_info_src) {
 691                 goto end;
 692         }
 693
 694         bin = g_hash_table_lookup(proc_dbg_info_src->baddr_to_bin_info,
 695                 (gpointer) &baddr);
 696         if (!bin) {
 697                 /*
 698                  * The debug_link event comes after the bin has been
 699                  * created. If it isn't found, just ignore this event.
 700                  */
 701                 goto end;
 702         }
 703
 704         bin_info_set_debug_link(bin, filename, crc32);
 705
 706 end:
 707         return;
 708 }
 709
 710 static
 711 void handle_bin_info_event(struct debug_info *debug_info,
 712                 const bt_event *event, bool has_pic_field)
 713 {
 714         struct proc_debug_info_sources *proc_dbg_info_src;
 715         struct bin_info *bin;
 716         uint64_t baddr, memsz;
 717         int64_t vpid;
 718         const char *path;
 719         gpointer key = NULL;
 720         bool is_pic;
 721
 722         event_get_payload_unsigned_integer_field_value(event,
 723                 MEMSZ_FIELD_NAME, &memsz);
 724         if (memsz == 0) {
 725                 /* Ignore VDSO. */
 726                 goto end;
 727         }
 728
 729         event_get_payload_unsigned_integer_field_value(event,
 730                 BADDR_FIELD_NAME, &baddr);
 731
 732         /*
 733          * This field is not produced by the dlopen event emitted before
 734          * lttng-ust 2.9.
 735          */
 736         if (!event_has_payload_field(event, PATH_FIELD_NAME)) {
 737                 goto end;
 738         }
 739         event_get_payload_string_field_value(event, PATH_FIELD_NAME, &path);
 740
 741         if (has_pic_field) {
 742                 uint64_t is_pic_field_value;
 743
 744                 event_get_payload_unsigned_integer_field_value(event,
 745                         IS_PIC_FIELD_NAME, &is_pic_field_value);
 746                 is_pic = is_pic_field_value == 1;
 747         } else {
 748                 /*
 749                  * dlopen has no is_pic field, because the shared
 750                  * object is always PIC.
 751                  */
 752                 is_pic = true;
 753         }
 754
 755         event_get_common_context_signed_integer_field_value(event,
 756                 VPID_FIELD_NAME, &vpid);
 757
 758         proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
 759                 debug_info->vpid_to_proc_dbg_info_src, vpid);
 760         if (!proc_dbg_info_src) {
 761                 goto end;
 762         }
 763
 764         key = g_new0(uint64_t, 1);
 765         if (!key) {
 766                 goto end;
 767         }
 768
 769         *((uint64_t *) key) = baddr;
 770
 771         bin = g_hash_table_lookup(proc_dbg_info_src->baddr_to_bin_info, key);
 772         if (bin) {
 773                 goto end;
 774         }
 775
 776         bin = bin_info_create(debug_info->fd_cache, path, baddr, memsz, is_pic,
 777                 debug_info->comp->arg_debug_dir,
 778                 debug_info->comp->arg_target_prefix,
 779                 debug_info->log_level, debug_info->self_comp);
 780         if (!bin) {
 781                 goto end;
 782         }
 783
 784         g_hash_table_insert(proc_dbg_info_src->baddr_to_bin_info, key, bin);
 785         /* Ownership passed to ht. */
 786         key = NULL;
 787
 788 end:
 789         g_free(key);
 790         return;
 791 }
 792
 793 static inline
 794 void handle_event_statedump_bin_info(struct debug_info *debug_info,
 795                 const bt_event *event)
 796 {
 797         handle_bin_info_event(debug_info, event, true);
 798 }
 799
 800 static inline
 801 void handle_event_lib_load(struct debug_info *debug_info,
 802                 const bt_event *event)
 803 {
 804         handle_bin_info_event(debug_info, event, false);
 805 }
 806
 807 static
 808 void handle_event_lib_unload(struct debug_info *debug_info,
 809                 const bt_event *event)
 810 {
 811         gboolean ret;
 812         struct proc_debug_info_sources *proc_dbg_info_src;
 813         uint64_t baddr;
 814         int64_t vpid;
 815
 816         event_get_payload_unsigned_integer_field_value(event, BADDR_FIELD_NAME,
 817                 &baddr);
 818
 819         event_get_common_context_signed_integer_field_value(event,
 820                 VPID_FIELD_NAME, &vpid);
 821
 822         proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
 823                 debug_info->vpid_to_proc_dbg_info_src, vpid);
 824         if (!proc_dbg_info_src) {
 825                 /*
 826                  * It's an unload event for a library for which no load event
 827                  * was previously received.
 828                  */
 829                 goto end;
 830         }
 831
 832         ret = g_hash_table_remove(proc_dbg_info_src->baddr_to_bin_info,
 833                 (gpointer) &baddr);
 834         BT_ASSERT(ret);
 835 end:
 836         return;
 837 }
 838
 839 static
 840 void handle_event_statedump_start(struct debug_info *debug_info,
 841                 const bt_event *event)
 842 {
 843         struct proc_debug_info_sources *proc_dbg_info_src;
 844         int64_t vpid;
 845
 846         event_get_common_context_signed_integer_field_value(
 847                 event, VPID_FIELD_NAME, &vpid);
 848
 849         proc_dbg_info_src = proc_debug_info_sources_ht_get_entry(
 850                 debug_info->vpid_to_proc_dbg_info_src, vpid);
 851         if (!proc_dbg_info_src) {
 852                 goto end;
 853         }
 854
 855         g_hash_table_remove_all(proc_dbg_info_src->baddr_to_bin_info);
 856         g_hash_table_remove_all(proc_dbg_info_src->ip_to_debug_info_src);
 857
 858 end:
 859         return;
 860 }
 861
 862 static
 863 void trace_debug_info_remove_func(const bt_trace *in_trace, void *data)
 864 {
 865         struct debug_info_msg_iter *debug_it = data;
 866         if (debug_it->debug_info_map) {
 867                 gboolean ret;
 868                 ret = g_hash_table_remove(debug_it->debug_info_map,
 869                         (gpointer) in_trace);
 870                 BT_ASSERT(ret);
 871         }
 872 }
 873
 874 static
 875 void handle_event_statedump(struct debug_info_msg_iter *debug_it,
 876                 const bt_event *event)
 877 {
 878         const bt_event_class *event_class;
 879         const char *event_name;
 880         GQuark q_event_name;
 881         const bt_trace *trace;
 882         struct debug_info *debug_info;
 883
 884         BT_ASSERT(debug_it);
 885         BT_ASSERT(event);
 886
 887         event_class = bt_event_borrow_class_const(event);
 888
 889         event_name = bt_event_class_get_name(event_class);
 890
 891         trace = bt_stream_borrow_trace_const(
 892                 bt_event_borrow_stream_const(event));
 893
 894         debug_info = g_hash_table_lookup(debug_it->debug_info_map, trace);
 895         if (!debug_info) {
 896                 bt_trace_add_listener_status add_listener_status;
 897
 898                 debug_info = debug_info_create(debug_it->debug_info_component,
 899                         trace, &debug_it->fd_cache);
 900                 g_hash_table_insert(debug_it->debug_info_map, (gpointer) trace,
 901                         debug_info);
 902                 add_listener_status = bt_trace_add_destruction_listener(
 903                         trace, trace_debug_info_remove_func, debug_it,
 904                         &debug_info->destruction_listener_id);
 905                 BT_ASSERT(add_listener_status == BT_TRACE_ADD_LISTENER_STATUS_OK);
 906         }
 907
 908         q_event_name = g_quark_try_string(event_name);
 909
 910         if (q_event_name == debug_info->q_statedump_bin_info) {
 911                 /* State dump */
 912                 handle_event_statedump_bin_info(debug_info, event);
 913         } else if (q_event_name == debug_info->q_dl_open ||
 914                         q_event_name == debug_info->q_lib_load) {
 915                 /*
 916                  * dl_open and lib_load events are both checked for since
 917                  * only dl_open was produced as of lttng-ust 2.8.
 918                  *
 919                  * lib_load, which is produced from lttng-ust 2.9+, is a lot
 920                  * more reliable since it will be emitted when other functions
 921                  * of the dlopen family are called (e.g. dlmopen) and when
 922                  * library are transitively loaded.
 923                  */
 924                 handle_event_lib_load(debug_info, event);
 925         } else if (q_event_name == debug_info->q_statedump_start) {
 926                 /* Start state dump */
 927                 handle_event_statedump_start(debug_info, event);
 928         } else if (q_event_name == debug_info->q_statedump_debug_link) {
 929                 /* Debug link info */
 930                 handle_event_statedump_debug_link(debug_info, event);
 931         } else if (q_event_name == debug_info->q_statedump_build_id) {
 932                 /* Build ID info */
 933                 handle_event_statedump_build_id(debug_info, event);
 934         } else if (q_event_name == debug_info-> q_lib_unload) {
 935                 handle_event_lib_unload(debug_info, event);
 936         }
 937
 938         return;
 939 }
 940
 941 static
 942 void destroy_debug_info_comp(struct debug_info_component *debug_info)
 943 {
 944         if (!debug_info) {
 945                 return;
 946         }
 947
 948         g_free(debug_info->arg_debug_dir);
 949         g_free(debug_info->arg_debug_info_field_name);
 950         g_free(debug_info->arg_target_prefix);
 951         g_free(debug_info);
 952 }
 953
 954 static
 955 void fill_debug_info_bin_field(struct debug_info_source *dbg_info_src,
 956                 bool full_path, bt_field *curr_field,
 957                 bt_logging_level log_level, bt_self_component *self_comp)
 958 {
 959         bt_field_string_set_value_status set_status;
 960         bt_field_string_append_status append_status;
 961
 962         BT_ASSERT_DBG(bt_field_get_class_type(curr_field) ==
 963                 BT_FIELD_CLASS_TYPE_STRING);
 964
 965         if (dbg_info_src) {
 966                 if (full_path) {
 967                         set_status = bt_field_string_set_value(curr_field,
 968                                 dbg_info_src->bin_path);
 969                 } else {
 970                         set_status = bt_field_string_set_value(curr_field,
 971                                 dbg_info_src->short_bin_path);
 972                 }
 973                 if (set_status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
 974                         BT_COMP_LOGE("Cannot set path component of `bin` "
 975                                 "curr_field field's value: str-fc-addr=%p",
 976                                 curr_field);
 977                         bt_current_thread_clear_error();
 978                 }
 979
 980                 append_status = bt_field_string_append(curr_field,
 981                         dbg_info_src->bin_loc);
 982                 if (append_status != BT_FIELD_STRING_APPEND_STATUS_OK) {
 983                         BT_COMP_LOGE("Cannot set bin location component of `bin` "
 984                                 "curr_field field's value: str-fc-addr=%p",
 985                                 curr_field);
 986                         bt_current_thread_clear_error();
 987                 }
 988         } else {
 989                 set_status = bt_field_string_set_value(curr_field, "");
 990                 if (set_status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
 991                         BT_COMP_LOGE("Cannot set `bin` curr_field field's value: "
 992                                 "str-fc-addr=%p", curr_field);
 993                         bt_current_thread_clear_error();
 994                 }
 995         }
 996 }
 997
 998 static
 999 void fill_debug_info_func_field(struct debug_info_source *dbg_info_src,
1000                 bt_field *curr_field, bt_logging_level log_level,
1001                 bt_self_component *self_comp)
1002 {
1003         bt_field_string_set_value_status status;
1004
1005         BT_ASSERT_DBG(bt_field_get_class_type(curr_field) ==
1006                         BT_FIELD_CLASS_TYPE_STRING);
1007         if (dbg_info_src && dbg_info_src->func) {
1008                 status = bt_field_string_set_value(curr_field,
1009                         dbg_info_src->func);
1010         } else {
1011                 status = bt_field_string_set_value(curr_field, "");
1012         }
1013         if (status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
1014                 BT_COMP_LOGE("Cannot set `func` curr_field field's value: "
1015                         "str-fc-addr=%p", curr_field);
1016                 bt_current_thread_clear_error();
1017         }
1018 }
1019
1020 static
1021 void fill_debug_info_src_field(struct debug_info_source *dbg_info_src,
1022                 bool full_path, bt_field *curr_field,
1023                 bt_logging_level log_level,
1024                 bt_self_component *self_comp)
1025 {
1026         bt_field_string_set_value_status set_status;
1027         bt_field_string_append_status append_status;
1028
1029         BT_ASSERT_DBG(bt_field_get_class_type(curr_field) ==
1030                 BT_FIELD_CLASS_TYPE_STRING);
1031
1032         if (dbg_info_src && dbg_info_src->src_path) {
1033                 if (full_path) {
1034                         set_status = bt_field_string_set_value(curr_field,
1035                                 dbg_info_src->src_path);
1036                 } else {
1037                         set_status = bt_field_string_set_value(curr_field,
1038                                 dbg_info_src->short_src_path);
1039                 }
1040                 if (set_status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
1041                         BT_COMP_LOGE("Cannot set path component of `src` "
1042                                 "curr_field field's value: str-fc-addr=%p",
1043                                 curr_field);
1044                         bt_current_thread_clear_error();
1045                 }
1046
1047                 append_status = bt_field_string_append(curr_field, ":");
1048                 if (append_status != BT_FIELD_STRING_APPEND_STATUS_OK) {
1049                         BT_COMP_LOGE("Cannot set colon component of `src` "
1050                                 "curr_field field's value: str-fc-addr=%p",
1051                                 curr_field);
1052                         bt_current_thread_clear_error();
1053                 }
1054
1055                 append_status = bt_field_string_append(curr_field,
1056                         dbg_info_src->line_no);
1057                 if (append_status != BT_FIELD_STRING_APPEND_STATUS_OK) {
1058                         BT_COMP_LOGE("Cannot set line number component of `src` "
1059                                 "curr_field field's value: str-fc-addr=%p",
1060                                 curr_field);
1061                         bt_current_thread_clear_error();
1062                 }
1063         } else {
1064                 set_status = bt_field_string_set_value(curr_field, "");
1065                 if (set_status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
1066                         BT_COMP_LOGE("Cannot set `src` curr_field field's value: "
1067                                 "str-fc-addr=%p", curr_field);
1068                         bt_current_thread_clear_error();
1069                 }
1070         }
1071 }
1072
1073 static
1074 void fill_debug_info_field_empty(bt_field *debug_info_field,
1075         bt_logging_level log_level, bt_self_component *self_comp)
1076 {
1077         bt_field_string_set_value_status status;
1078         bt_field *bin_field, *func_field, *src_field;
1079
1080         BT_ASSERT_DBG(bt_field_get_class_type(debug_info_field) ==
1081                 BT_FIELD_CLASS_TYPE_STRUCTURE);
1082
1083         bin_field = bt_field_structure_borrow_member_field_by_name(
1084                 debug_info_field, "bin");
1085         func_field = bt_field_structure_borrow_member_field_by_name(
1086                 debug_info_field, "func");
1087         src_field = bt_field_structure_borrow_member_field_by_name(
1088                 debug_info_field, "src");
1089
1090         BT_ASSERT_DBG(bt_field_get_class_type(bin_field) ==
1091                 BT_FIELD_CLASS_TYPE_STRING);
1092         BT_ASSERT_DBG(bt_field_get_class_type(func_field) ==
1093                 BT_FIELD_CLASS_TYPE_STRING);
1094         BT_ASSERT_DBG(bt_field_get_class_type(src_field) ==
1095                 BT_FIELD_CLASS_TYPE_STRING);
1096
1097         status = bt_field_string_set_value(bin_field, "");
1098         if (status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
1099                 BT_COMP_LOGE("Cannot set `bin` field's value: "
1100                         "str-fc-addr=%p", bin_field);
1101                 bt_current_thread_clear_error();
1102         }
1103
1104         status = bt_field_string_set_value(func_field, "");
1105         if (status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
1106                 BT_COMP_LOGE("Cannot set `func` field's value: "
1107                         "str-fc-addr=%p", func_field);
1108                 bt_current_thread_clear_error();
1109         }
1110
1111         status = bt_field_string_set_value(src_field, "");
1112         if (status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
1113                 BT_COMP_LOGE("Cannot set `src` field's value: "
1114                         "str-fc-addr=%p", src_field);
1115                 bt_current_thread_clear_error();
1116         }
1117 }
1118 static
1119 void fill_debug_info_field(struct debug_info *debug_info, int64_t vpid,
1120                 uint64_t ip, bt_field *debug_info_field)
1121 {
1122         struct debug_info_source *dbg_info_src;
1123         const bt_field_class *debug_info_fc;
1124
1125         BT_ASSERT_DBG(bt_field_get_class_type(debug_info_field) ==
1126                 BT_FIELD_CLASS_TYPE_STRUCTURE);
1127
1128         debug_info_fc = bt_field_borrow_class_const(debug_info_field);
1129
1130         BT_ASSERT_DBG(bt_field_class_structure_get_member_count(
1131                 debug_info_fc) == 3);
1132
1133         dbg_info_src = debug_info_query(debug_info, vpid, ip);
1134
1135         fill_debug_info_bin_field(dbg_info_src,
1136                 debug_info->comp->arg_full_path,
1137                 bt_field_structure_borrow_member_field_by_name(
1138                         debug_info_field, "bin"),
1139                 debug_info->log_level, debug_info->self_comp);
1140         fill_debug_info_func_field(dbg_info_src,
1141                 bt_field_structure_borrow_member_field_by_name(
1142                         debug_info_field, "func"),
1143                 debug_info->log_level, debug_info->self_comp);
1144         fill_debug_info_src_field(dbg_info_src,
1145                 debug_info->comp->arg_full_path,
1146                 bt_field_structure_borrow_member_field_by_name(
1147                         debug_info_field, "src"),
1148                 debug_info->log_level, debug_info->self_comp);
1149 }
1150
1151 static
1152 void fill_debug_info_event_if_needed(struct debug_info_msg_iter *debug_it,
1153                 const bt_event *in_event, bt_event *out_event)
1154 {
1155         bt_field *out_common_ctx_field, *out_debug_info_field;
1156         const bt_field *vpid_field, *ip_field, *in_common_ctx_field;
1157         const bt_field_class *in_common_ctx_fc;
1158         struct debug_info *debug_info;
1159         uint64_t vpid;
1160         int64_t ip;
1161         gchar *debug_info_field_name =
1162                 debug_it->debug_info_component->arg_debug_info_field_name;
1163         bt_logging_level log_level = debug_it->log_level;
1164         bt_self_component *self_comp = debug_it->self_comp;
1165
1166         in_common_ctx_field = bt_event_borrow_common_context_field_const(
1167                 in_event);
1168         if (!in_common_ctx_field) {
1169                 /*
1170                  * There is no event common context so no need to add debug
1171                  * info field.
1172                  */
1173                 goto end;
1174         }
1175
1176         in_common_ctx_fc = bt_field_borrow_class_const(in_common_ctx_field);
1177         if (!is_event_common_ctx_dbg_info_compatible(in_common_ctx_fc,
1178                         debug_it->ir_maps->debug_info_field_class_name)) {
1179                 /*
1180                  * The input event common context does not have the necessary
1181                  * fields to resolve debug information.
1182                  */
1183                 goto end;
1184         }
1185
1186         /* Borrow the debug-info field. */
1187         out_common_ctx_field = bt_event_borrow_common_context_field(out_event);
1188         if (!out_common_ctx_field) {
1189                 goto end;
1190         }
1191
1192         out_debug_info_field = bt_field_structure_borrow_member_field_by_name(
1193                 out_common_ctx_field, debug_info_field_name);
1194
1195         vpid_field = bt_field_structure_borrow_member_field_by_name_const(
1196                 out_common_ctx_field, VPID_FIELD_NAME);
1197         ip_field = bt_field_structure_borrow_member_field_by_name_const(
1198                 out_common_ctx_field, IP_FIELD_NAME);
1199
1200         vpid = bt_field_integer_signed_get_value(vpid_field);
1201         ip = bt_field_integer_unsigned_get_value(ip_field);
1202
1203         /*
1204          * Borrow the debug_info structure needed for the source
1205          * resolving.
1206          */
1207         debug_info = g_hash_table_lookup(debug_it->debug_info_map,
1208                 bt_stream_borrow_trace_const(
1209                         bt_event_borrow_stream_const(in_event)));
1210
1211         if (debug_info) {
1212                 /*
1213                  * Perform the debug-info resolving and set the event fields
1214                  * accordingly.
1215                  */
1216                 fill_debug_info_field(debug_info, vpid, ip, out_debug_info_field);
1217         } else {
1218                 BT_COMP_LOGD("No debug information for this trace. Setting debug "
1219                         "info fields to empty strings.");
1220                 fill_debug_info_field_empty(out_debug_info_field,
1221                         log_level, self_comp);
1222         }
1223 end:
1224         return;
1225 }
1226
1227 static
1228 void update_event_statedump_if_needed(struct debug_info_msg_iter *debug_it,
1229                 const bt_event *in_event)
1230 {
1231         const bt_field *event_common_ctx;
1232         const bt_field_class *event_common_ctx_fc;
1233         const bt_event_class *in_event_class = bt_event_borrow_class_const(in_event);
1234
1235         /*
1236          * If the event is an lttng_ust_statedump event AND has the right event
1237          * common context fields update the debug-info view for this process.
1238          */
1239         event_common_ctx = bt_event_borrow_common_context_field_const(in_event);
1240         if (!event_common_ctx) {
1241                 goto end;
1242         }
1243
1244         event_common_ctx_fc = bt_field_borrow_class_const(event_common_ctx);
1245         if (is_event_common_ctx_dbg_info_compatible(event_common_ctx_fc,
1246                         debug_it->ir_maps->debug_info_field_class_name)) {
1247                 /* Checkout if it might be a one of lttng ust statedump events. */
1248                 const char *in_event_name = bt_event_class_get_name(in_event_class);
1249                 if (strncmp(in_event_name, LTTNG_UST_STATEDUMP_PREFIX,
1250                                 strlen(LTTNG_UST_STATEDUMP_PREFIX)) == 0) {
1251                         /* Handle statedump events. */
1252                         handle_event_statedump(debug_it, in_event);
1253                 }
1254         }
1255 end:
1256         return;
1257 }
1258
1259 static
1260 bt_message *handle_event_message(struct debug_info_msg_iter *debug_it,
1261                 const bt_message *in_message)
1262 {
1263         const bt_clock_snapshot *cs;
1264         const bt_clock_class *default_cc;
1265         const bt_packet *in_packet;
1266         const bt_stream *in_stream;
1267         const bt_stream *out_stream;
1268         bt_event_class *out_event_class;
1269         bt_packet *out_packet = NULL;
1270         bt_event *out_event;
1271         bt_logging_level log_level = debug_it->log_level;
1272         bt_self_component *self_comp = debug_it->self_comp;
1273
1274         bt_message *out_message = NULL;
1275
1276         /* Borrow the input event and its event class. */
1277         const bt_event *in_event =
1278                 bt_message_event_borrow_event_const(in_message);
1279         const bt_event_class *in_event_class =
1280                 bt_event_borrow_class_const(in_event);
1281
1282         update_event_statedump_if_needed(debug_it, in_event);
1283
1284         out_event_class = trace_ir_mapping_borrow_mapped_event_class(
1285                         debug_it->ir_maps, in_event_class);
1286         if (!out_event_class) {
1287                 out_event_class = trace_ir_mapping_create_new_mapped_event_class(
1288                         debug_it->ir_maps, in_event_class);
1289         }
1290         BT_ASSERT_DBG(out_event_class);
1291
1292         /* Borrow the input stream. */
1293         in_stream = bt_event_borrow_stream_const(in_event);
1294         BT_ASSERT_DBG(in_stream);
1295         out_stream = trace_ir_mapping_borrow_mapped_stream(debug_it->ir_maps,
1296                 in_stream);
1297         BT_ASSERT_DBG(in_stream);
1298
1299         /* Borrow the input and output packets. */
1300         in_packet = bt_event_borrow_packet_const(in_event);
1301         if (in_packet) {
1302                 out_packet = trace_ir_mapping_borrow_mapped_packet(
1303                         debug_it->ir_maps, in_packet);
1304         }
1305
1306         default_cc = bt_stream_class_borrow_default_clock_class_const(
1307                 bt_event_class_borrow_stream_class_const(in_event_class));
1308         if (default_cc) {
1309                 /* Borrow event clock snapshot. */
1310                 cs = bt_message_event_borrow_default_clock_snapshot_const(
1311                         in_message);
1312
1313                 /* Create an output event message. */
1314                 if (out_packet) {
1315                         out_message =
1316                                 bt_message_event_create_with_packet_and_default_clock_snapshot(
1317                                         debug_it->input_iterator,
1318                                         out_event_class, out_packet,
1319                                         bt_clock_snapshot_get_value(cs));
1320                 } else {
1321                         out_message =
1322                                 bt_message_event_create_with_default_clock_snapshot(
1323                                         debug_it->input_iterator,
1324                                         out_event_class, out_stream,
1325                                         bt_clock_snapshot_get_value(cs));
1326                 }
1327         } else {
1328                 if (out_packet) {
1329                         out_message = bt_message_event_create_with_packet(
1330                                 debug_it->input_iterator, out_event_class,
1331                                 out_packet);
1332                 } else {
1333                         out_message = bt_message_event_create(
1334                                 debug_it->input_iterator, out_event_class,
1335                                 out_stream);
1336                 }
1337         }
1338
1339         if (!out_message) {
1340                 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1341                         "Error creating output event message.");
1342                 goto error;
1343         }
1344
1345         out_event = bt_message_event_borrow_event(out_message);
1346
1347         /* Copy the original fields to the output event. */
1348         if (copy_event_content(in_event, out_event, log_level, self_comp) !=
1349                         DEBUG_INFO_TRACE_IR_MAPPING_STATUS_OK) {
1350                 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1351                         "Error copying event message content output event message: "
1352                         "in-ev-addr=%p, out-ev-addr=%p", in_event, out_event);
1353                 goto error;
1354         }
1355
1356         /*
1357          * Try to set the debug-info fields based on debug information that is
1358          * gathered so far.
1359          */
1360         fill_debug_info_event_if_needed(debug_it, in_event, out_event);
1361
1362         goto end;
1363
1364 error:
1365         BT_MESSAGE_PUT_REF_AND_RESET(out_message);
1366 end:
1367         return out_message;
1368 }
1369
1370 static
1371 bt_message *handle_stream_begin_message(struct debug_info_msg_iter *debug_it,
1372                 const bt_message *in_message)
1373 {
1374         const bt_stream *in_stream;
1375         bt_message *out_message;
1376         bt_stream *out_stream;
1377         bt_logging_level log_level = debug_it->log_level;
1378         bt_self_component *self_comp = debug_it->self_comp;
1379
1380         in_stream = bt_message_stream_beginning_borrow_stream_const(in_message);
1381         BT_ASSERT(in_stream);
1382
1383         /* Create a duplicated output stream. */
1384         out_stream = trace_ir_mapping_create_new_mapped_stream(
1385                 debug_it->ir_maps, in_stream);
1386         if (!out_stream) {
1387                 out_message = NULL;
1388                 goto error;
1389         }
1390
1391         /* Create an output stream beginning message. */
1392         out_message = bt_message_stream_beginning_create(
1393                 debug_it->input_iterator, out_stream);
1394         if (!out_message) {
1395                 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1396                         "Error creating output stream beginning message: "
1397                         "out-s-addr=%p", out_stream);
1398         }
1399 error:
1400         return out_message;
1401 }
1402
1403 static
1404 bt_message *handle_stream_end_message(struct debug_info_msg_iter *debug_it,
1405                 const bt_message *in_message)
1406 {
1407         const bt_stream *in_stream;
1408         bt_message *out_message = NULL;
1409         bt_stream *out_stream;
1410         bt_logging_level log_level = debug_it->log_level;
1411         bt_self_component *self_comp = debug_it->self_comp;
1412
1413         in_stream = bt_message_stream_end_borrow_stream_const(in_message);
1414         BT_ASSERT(in_stream);
1415
1416         out_stream = trace_ir_mapping_borrow_mapped_stream(
1417                 debug_it->ir_maps, in_stream);
1418         BT_ASSERT(out_stream);
1419
1420         /* Create an output stream end message. */
1421         out_message = bt_message_stream_end_create(debug_it->input_iterator,
1422                 out_stream);
1423         if (!out_message) {
1424                 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1425                         "Error creating output stream end message: "
1426                         "out-s-addr=%p", out_stream);
1427                 goto end;
1428         }
1429
1430         /* Remove stream from trace mapping hashtable. */
1431         trace_ir_mapping_remove_mapped_stream(debug_it->ir_maps, in_stream);
1432
1433 end:
1434         return out_message;
1435 }
1436
1437 static
1438 bt_message *handle_packet_begin_message(struct debug_info_msg_iter *debug_it,
1439                 const bt_message *in_message)
1440 {
1441         bool has_default_clock_snapshot;
1442         const bt_clock_snapshot *cs;
1443         bt_message *out_message = NULL;
1444         bt_packet *out_packet;
1445         bt_logging_level log_level = debug_it->log_level;
1446         bt_self_component *self_comp = debug_it->self_comp;
1447
1448         const bt_packet *in_packet =
1449                 bt_message_packet_beginning_borrow_packet_const(in_message);
1450         BT_ASSERT(in_packet);
1451
1452         /* This packet should not be already mapped. */
1453         BT_ASSERT(!trace_ir_mapping_borrow_mapped_packet(
1454                                 debug_it->ir_maps, in_packet));
1455
1456         out_packet = trace_ir_mapping_create_new_mapped_packet(debug_it->ir_maps,
1457                 in_packet);
1458
1459         BT_ASSERT(out_packet);
1460
1461         has_default_clock_snapshot =
1462                 bt_stream_class_packets_have_beginning_default_clock_snapshot(
1463                         bt_stream_borrow_class_const(
1464                                 bt_packet_borrow_stream_const(in_packet)));
1465         if (has_default_clock_snapshot) {
1466                 /* Borrow clock snapshot. */
1467                 cs = bt_message_packet_beginning_borrow_default_clock_snapshot_const(
1468                         in_message);
1469
1470                 /* Create an output packet beginning message. */
1471                 out_message = bt_message_packet_beginning_create_with_default_clock_snapshot(
1472                         debug_it->input_iterator, out_packet,
1473                         bt_clock_snapshot_get_value(cs));
1474         } else {
1475                 out_message = bt_message_packet_beginning_create(
1476                         debug_it->input_iterator, out_packet);
1477         }
1478         if (!out_message) {
1479                 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1480                         "Error creating output packet beginning message: "
1481                         "out-p-addr=%p", out_packet);
1482         }
1483
1484         return out_message;
1485 }
1486
1487 static
1488 bt_message *handle_packet_end_message(struct debug_info_msg_iter *debug_it,
1489                 const bt_message *in_message)
1490 {
1491         bool has_default_clock_snapshot;
1492         const bt_clock_snapshot *cs;
1493         const bt_packet *in_packet;
1494         bt_message *out_message = NULL;
1495         bt_packet *out_packet;
1496         bt_logging_level log_level = debug_it->log_level;
1497         bt_self_component *self_comp = debug_it->self_comp;
1498
1499         in_packet = bt_message_packet_end_borrow_packet_const(in_message);
1500         BT_ASSERT(in_packet);
1501
1502         out_packet = trace_ir_mapping_borrow_mapped_packet(debug_it->ir_maps, in_packet);
1503         BT_ASSERT(out_packet);
1504
1505         has_default_clock_snapshot =
1506                 bt_stream_class_packets_have_end_default_clock_snapshot(
1507                         bt_stream_borrow_class_const(
1508                                 bt_packet_borrow_stream_const(in_packet)));
1509         if (has_default_clock_snapshot) {
1510                 /* Borrow clock snapshot. */
1511                 cs = bt_message_packet_end_borrow_default_clock_snapshot_const(
1512                         in_message);
1513
1514                 /* Create an outpute packet end message. */
1515                 out_message = bt_message_packet_end_create_with_default_clock_snapshot(
1516                         debug_it->input_iterator, out_packet,
1517                         bt_clock_snapshot_get_value(cs));
1518         } else {
1519                 out_message = bt_message_packet_end_create(
1520                         debug_it->input_iterator, out_packet);
1521         }
1522
1523         if (!out_message) {
1524                 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1525                         "Error creating output packet end message: "
1526                         "out-p-addr=%p", out_packet);
1527                 goto end;
1528         }
1529
1530         /* Remove packet from data mapping hashtable. */
1531         trace_ir_mapping_remove_mapped_packet(debug_it->ir_maps, in_packet);
1532
1533 end:
1534         return out_message;
1535 }
1536
1537 static
1538 bt_message *handle_msg_iterator_inactivity(struct debug_info_msg_iter *debug_it,
1539                 const bt_message *in_message)
1540 {
1541         /*
1542          * This message type can be forwarded directly because it does
1543          * not refer to any objects in the trace class.
1544          */
1545         bt_message_get_ref(in_message);
1546         return (bt_message*) in_message;
1547 }
1548
1549 static
1550 bt_message *handle_discarded_events_message(struct debug_info_msg_iter *debug_it,
1551                 const bt_message *in_message)
1552 {
1553         const bt_clock_snapshot *begin_cs, *end_cs;
1554         const bt_stream *in_stream;
1555         bool has_default_clock_snapshots;
1556         uint64_t discarded_events, begin_cs_value, end_cs_value;
1557         bt_property_availability prop_avail;
1558         bt_message *out_message = NULL;
1559         bt_stream *out_stream;
1560         bt_logging_level log_level = debug_it->log_level;
1561         bt_self_component *self_comp = debug_it->self_comp;
1562
1563         in_stream = bt_message_discarded_events_borrow_stream_const(
1564                         in_message);
1565         BT_ASSERT(in_stream);
1566
1567         out_stream = trace_ir_mapping_borrow_mapped_stream( debug_it->ir_maps,
1568                 in_stream);
1569         BT_ASSERT(out_stream);
1570
1571         has_default_clock_snapshots =
1572                 bt_stream_class_discarded_events_have_default_clock_snapshots(
1573                         bt_stream_borrow_class_const(in_stream));
1574         if (has_default_clock_snapshots) {
1575                 begin_cs = bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(
1576                         in_message);
1577                 end_cs = bt_message_discarded_events_borrow_end_default_clock_snapshot_const(
1578                         in_message);
1579
1580                 begin_cs_value = bt_clock_snapshot_get_value(begin_cs);
1581                 end_cs_value = bt_clock_snapshot_get_value(end_cs);
1582
1583                 out_message = bt_message_discarded_events_create_with_default_clock_snapshots(
1584                         debug_it->input_iterator, out_stream,
1585                         begin_cs_value, end_cs_value);
1586         } else {
1587                 out_message = bt_message_discarded_events_create(
1588                         debug_it->input_iterator, out_stream);
1589         }
1590         if (!out_message) {
1591                 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1592                         "Error creating output discarded events message: "
1593                         "out-s-addr=%p", out_stream);
1594                 goto error;
1595         }
1596
1597         prop_avail = bt_message_discarded_events_get_count(in_message,
1598                 &discarded_events);
1599
1600         if (prop_avail == BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE) {
1601                 bt_message_discarded_events_set_count(out_message,
1602                         discarded_events);
1603         }
1604
1605 error:
1606         return out_message;
1607 }
1608
1609 static
1610 bt_message *handle_discarded_packets_message(struct debug_info_msg_iter *debug_it,
1611                 const bt_message *in_message)
1612 {
1613         const bt_clock_snapshot *begin_cs, *end_cs;
1614         bool has_default_clock_snapshots;
1615         const bt_stream *in_stream;
1616         uint64_t discarded_packets, begin_cs_value, end_cs_value;
1617         bt_property_availability prop_avail;
1618         bt_message *out_message = NULL;
1619         bt_stream *out_stream;
1620         bt_logging_level log_level = debug_it->log_level;
1621         bt_self_component *self_comp = debug_it->self_comp;
1622
1623         in_stream = bt_message_discarded_packets_borrow_stream_const(
1624                 in_message);
1625         BT_ASSERT(in_stream);
1626
1627         out_stream = trace_ir_mapping_borrow_mapped_stream( debug_it->ir_maps,
1628                 in_stream);
1629         BT_ASSERT(out_stream);
1630
1631         has_default_clock_snapshots =
1632                 bt_stream_class_discarded_packets_have_default_clock_snapshots(
1633                         bt_stream_borrow_class_const(in_stream));
1634         if (has_default_clock_snapshots) {
1635                 begin_cs = bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(
1636                         in_message);
1637
1638                 end_cs = bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(
1639                         in_message);
1640
1641                 begin_cs_value = bt_clock_snapshot_get_value(begin_cs);
1642                 end_cs_value = bt_clock_snapshot_get_value(end_cs);
1643
1644                 out_message = bt_message_discarded_packets_create_with_default_clock_snapshots(
1645                         debug_it->input_iterator, out_stream,
1646                         begin_cs_value, end_cs_value);
1647         } else {
1648                 out_message = bt_message_discarded_packets_create(
1649                         debug_it->input_iterator, out_stream);
1650         }
1651         if (!out_message) {
1652                 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1653                         "Error creating output discarded packet message: "
1654                         "out-s-addr=%p", out_stream);
1655                 goto error;
1656         }
1657
1658         prop_avail = bt_message_discarded_packets_get_count(in_message,
1659                 &discarded_packets);
1660         if (prop_avail == BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE) {
1661                 bt_message_discarded_packets_set_count(out_message,
1662                         discarded_packets);
1663         }
1664
1665 error:
1666         return out_message;
1667 }
1668
1669 static
1670 const bt_message *handle_message(struct debug_info_msg_iter *debug_it,
1671                 const bt_message *in_message)
1672 {
1673         bt_message *out_message = NULL;
1674
1675         switch (bt_message_get_type(in_message)) {
1676         case BT_MESSAGE_TYPE_EVENT:
1677                 out_message = handle_event_message(debug_it, in_message);
1678                 break;
1679         case BT_MESSAGE_TYPE_PACKET_BEGINNING:
1680                 out_message = handle_packet_begin_message(debug_it, in_message);
1681                 break;
1682         case BT_MESSAGE_TYPE_PACKET_END:
1683                 out_message = handle_packet_end_message(debug_it, in_message);
1684                 break;
1685         case BT_MESSAGE_TYPE_STREAM_BEGINNING:
1686                 out_message = handle_stream_begin_message(debug_it, in_message);
1687                 break;
1688         case BT_MESSAGE_TYPE_STREAM_END:
1689                 out_message = handle_stream_end_message(debug_it, in_message);
1690                 break;
1691         case BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY:
1692                 out_message = handle_msg_iterator_inactivity(debug_it, in_message);
1693                 break;
1694         case BT_MESSAGE_TYPE_DISCARDED_EVENTS:
1695                 out_message = handle_discarded_events_message(debug_it, in_message);
1696                 break;
1697         case BT_MESSAGE_TYPE_DISCARDED_PACKETS:
1698                 out_message = handle_discarded_packets_message(debug_it, in_message);
1699                 break;
1700         default:
1701                 bt_common_abort();
1702                 break;
1703         }
1704
1705         return out_message;
1706 }
1707
1708 static
1709 struct bt_param_validation_map_value_entry_descr debug_info_params[] = {
1710         { "debug-info-field-name", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_STRING } },
1711         { "debug-info-dir", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_STRING } },
1712         { "target-prefix", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_STRING } },
1713         { "full-path", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
1714         BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_END
1715 };
1716
1717 static
1718 bt_component_class_initialize_method_status init_from_params(
1719                 struct debug_info_component *debug_info_component,
1720                 const bt_value *params)
1721 {
1722         const bt_value *value;
1723         bt_component_class_initialize_method_status status;
1724         bt_logging_level log_level = debug_info_component->log_level;
1725         enum bt_param_validation_status validation_status;
1726         gchar *validate_error = NULL;
1727
1728         validation_status = bt_param_validation_validate(params,
1729                 debug_info_params, &validate_error);
1730         if (validation_status == BT_PARAM_VALIDATION_STATUS_MEMORY_ERROR) {
1731                 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
1732                 goto end;
1733         } else if (validation_status == BT_PARAM_VALIDATION_STATUS_VALIDATION_ERROR) {
1734                 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
1735                 BT_COMP_LOGE_APPEND_CAUSE(debug_info_component->self_comp,
1736                         "%s", validate_error);
1737                 goto end;
1738         }
1739
1740         BT_ASSERT(params);
1741
1742         value = bt_value_map_borrow_entry_value_const(params,
1743                         "debug-info-field-name");
1744         if (value) {
1745                 debug_info_component->arg_debug_info_field_name =
1746                         g_strdup(bt_value_string_get(value));
1747         } else {
1748                 debug_info_component->arg_debug_info_field_name =
1749                         g_strdup(DEFAULT_DEBUG_INFO_FIELD_NAME);
1750         }
1751
1752         value = bt_value_map_borrow_entry_value_const(params, "debug-info-dir");
1753         if (value) {
1754                 debug_info_component->arg_debug_dir =
1755                         g_strdup(bt_value_string_get(value));
1756         } else {
1757                 debug_info_component->arg_debug_dir = NULL;
1758         }
1759
1760
1761         value = bt_value_map_borrow_entry_value_const(params, "target-prefix");
1762         if (value) {
1763                 debug_info_component->arg_target_prefix =
1764                         g_strdup(bt_value_string_get(value));
1765         } else {
1766                 debug_info_component->arg_target_prefix = NULL;
1767         }
1768
1769         value = bt_value_map_borrow_entry_value_const(params, "full-path");
1770         if (value) {
1771                 debug_info_component->arg_full_path = bt_value_bool_get(value);
1772         } else {
1773                 debug_info_component->arg_full_path = BT_FALSE;
1774         }
1775
1776         status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
1777
1778 end:
1779         g_free(validate_error);
1780
1781         return status;
1782 }
1783
1784 BT_HIDDEN
1785 bt_component_class_initialize_method_status debug_info_comp_init(
1786                 bt_self_component_filter *self_comp_flt,
1787                 bt_self_component_filter_configuration *config,
1788                 const bt_value *params, __attribute__((unused)) void *init_method_data)
1789 {
1790         struct debug_info_component *debug_info_comp;
1791         bt_component_class_initialize_method_status status =
1792                 BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
1793         bt_self_component_add_port_status add_port_status;
1794         bt_self_component *self_comp =
1795                 bt_self_component_filter_as_self_component(self_comp_flt);
1796         bt_logging_level log_level = bt_component_get_logging_level(
1797                 bt_self_component_as_component(self_comp));
1798
1799         BT_COMP_LOGI("Initializing debug_info component: "
1800                 "comp-addr=%p, params-addr=%p", self_comp, params);
1801
1802         debug_info_comp = g_new0(struct debug_info_component, 1);
1803         if (!debug_info_comp) {
1804                 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1805                         "Failed to allocate one debug_info component.");
1806                 goto error;
1807         }
1808
1809         debug_info_comp->log_level = log_level;
1810         debug_info_comp->self_comp = self_comp;
1811         debug_info_comp->self_comp_filter = self_comp_flt;
1812         bt_self_component_set_data(self_comp, debug_info_comp);
1813
1814         add_port_status = bt_self_component_filter_add_input_port(
1815                 self_comp_flt, "in", NULL, NULL);
1816         if (add_port_status != BT_SELF_COMPONENT_ADD_PORT_STATUS_OK) {
1817                 status = (int) add_port_status;
1818                 goto error;
1819         }
1820
1821         add_port_status = bt_self_component_filter_add_output_port(
1822                         self_comp_flt, "out", NULL, NULL);
1823         if (add_port_status != BT_SELF_COMPONENT_ADD_PORT_STATUS_OK) {
1824                 status = (int) add_port_status;
1825                 goto error;
1826         }
1827
1828         status = init_from_params(debug_info_comp, params);
1829         if (status != BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK) {
1830                 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1831                         "Cannot configure debug_info component: "
1832                         "debug_info-comp-addr=%p, params-addr=%p",
1833                         debug_info_comp, params);
1834                 goto error;
1835         }
1836
1837         goto end;
1838
1839 error:
1840         destroy_debug_info_comp(debug_info_comp);
1841         bt_self_component_set_data(self_comp, NULL);
1842
1843         if (status == BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK) {
1844                 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
1845         }
1846 end:
1847         return status;
1848 }
1849
1850 BT_HIDDEN
1851 void debug_info_comp_finalize(bt_self_component_filter *self_comp_flt)
1852 {
1853         struct debug_info_component *debug_info =
1854                 bt_self_component_get_data(
1855                         bt_self_component_filter_as_self_component(
1856                                 self_comp_flt));
1857         bt_logging_level log_level = debug_info->log_level;
1858         bt_self_component *self_comp = debug_info->self_comp;
1859
1860         BT_COMP_LOGI("Finalizing debug_info self_component: comp-addr=%p",
1861                 self_comp);
1862
1863         destroy_debug_info_comp(debug_info);
1864 }
1865
1866 BT_HIDDEN
1867 bt_message_iterator_class_next_method_status debug_info_msg_iter_next(
1868                 bt_self_message_iterator *self_msg_iter,
1869                 const bt_message_array_const msgs, uint64_t capacity,
1870                 uint64_t *count)
1871 {
1872         bt_self_component_port_input_message_iterator *upstream_iterator = NULL;
1873         bt_message_iterator_next_status upstream_iterator_ret_status;
1874         struct debug_info_msg_iter *debug_info_msg_iter;
1875         struct debug_info_component *debug_info = NULL;
1876         bt_message_iterator_class_next_method_status status;
1877         bt_self_component *self_comp = NULL;
1878         bt_message_array_const input_msgs;
1879         const bt_message *out_message;
1880         uint64_t curr_msg_idx, i;
1881
1882         status = BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK;
1883
1884         self_comp = bt_self_message_iterator_borrow_component(self_msg_iter);
1885         BT_ASSERT_DBG(self_comp);
1886
1887         debug_info = bt_self_component_get_data(self_comp);
1888         BT_ASSERT_DBG(debug_info);
1889
1890         debug_info_msg_iter = bt_self_message_iterator_get_data(self_msg_iter);
1891         BT_ASSERT_DBG(debug_info_msg_iter);
1892
1893         upstream_iterator = debug_info_msg_iter->msg_iter;
1894         BT_ASSERT_DBG(upstream_iterator);
1895
1896         upstream_iterator_ret_status =
1897                 bt_self_component_port_input_message_iterator_next(
1898                         upstream_iterator, &input_msgs, count);
1899         if (upstream_iterator_ret_status !=
1900                         BT_MESSAGE_ITERATOR_NEXT_STATUS_OK) {
1901                 /*
1902                  * No messages were returned. Not necessarily an error.
1903                  * Convert the upstream message iterator status to a
1904                  * self status.
1905                  */
1906                 status = (int) upstream_iterator_ret_status;
1907                 goto end;
1908         }
1909
1910         /*
1911          * There should never be more received messages than the capacity we
1912          * provided.
1913          */
1914         BT_ASSERT_DBG(*count <= capacity);
1915
1916         for (curr_msg_idx = 0; curr_msg_idx < *count; curr_msg_idx++) {
1917                 out_message = handle_message(debug_info_msg_iter,
1918                         input_msgs[curr_msg_idx]);
1919                 if (!out_message) {
1920                         goto handle_msg_error;
1921                 }
1922
1923                 msgs[curr_msg_idx] = out_message;
1924                 /*
1925                  * Drop our reference of the input message as we are done with
1926                  * it and created a output copy.
1927                  */
1928                 bt_message_put_ref(input_msgs[curr_msg_idx]);
1929         }
1930
1931         goto end;
1932
1933 handle_msg_error:
1934         /*
1935          * Drop references of all the output messages created before the
1936          * failure.
1937          */
1938         for (i = 0; i < curr_msg_idx; i++) {
1939                 bt_message_put_ref(msgs[i]);
1940         }
1941
1942         /*
1943          * Drop references of all the input messages not dropped before the
1944          * failure.
1945          */
1946         for (i = curr_msg_idx; i < *count; i++) {
1947                 bt_message_put_ref(input_msgs[i]);
1948         }
1949
1950         status = BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_MEMORY_ERROR;
1951
1952 end:
1953         return status;
1954 }
1955
1956 static
1957 void debug_info_msg_iter_destroy(struct debug_info_msg_iter *debug_info_msg_iter)
1958 {
1959         if (!debug_info_msg_iter) {
1960                 goto end;
1961         }
1962
1963         if (debug_info_msg_iter->msg_iter) {
1964                 bt_self_component_port_input_message_iterator_put_ref(
1965                         debug_info_msg_iter->msg_iter);
1966         }
1967
1968         if (debug_info_msg_iter->ir_maps) {
1969                 trace_ir_maps_destroy(debug_info_msg_iter->ir_maps);
1970         }
1971
1972         if (debug_info_msg_iter->debug_info_map) {
1973                 g_hash_table_destroy(debug_info_msg_iter->debug_info_map);
1974         }
1975
1976         bt_fd_cache_fini(&debug_info_msg_iter->fd_cache);
1977         g_free(debug_info_msg_iter);
1978
1979 end:
1980         return;
1981 }
1982
1983 BT_HIDDEN
1984 bt_message_iterator_class_initialize_method_status debug_info_msg_iter_init(
1985                 bt_self_message_iterator *self_msg_iter,
1986                 bt_self_message_iterator_configuration *config,
1987                 bt_self_component *self_comp,
1988                 bt_self_component_port_output *self_port)
1989 {
1990         bt_message_iterator_class_initialize_method_status status;
1991         bt_self_component_port_input_message_iterator_create_from_message_iterator_status
1992                 msg_iter_status;
1993         struct bt_self_component_port_input *input_port = NULL;
1994         bt_self_component_port_input_message_iterator *upstream_iterator = NULL;
1995         struct debug_info_msg_iter *debug_info_msg_iter = NULL;
1996         gchar *debug_info_field_name;
1997         int ret;
1998         bt_logging_level log_level = bt_component_get_logging_level(
1999                 bt_self_component_as_component(self_comp));
2000
2001         debug_info_msg_iter = g_new0(struct debug_info_msg_iter, 1);
2002         if (!debug_info_msg_iter) {
2003                 status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
2004                 goto error;
2005         }
2006
2007         debug_info_msg_iter->log_level = log_level;
2008         debug_info_msg_iter->self_comp = self_comp;
2009
2010         debug_info_msg_iter->debug_info_component =
2011                 bt_self_component_get_data(self_comp);
2012
2013         /* Borrow the upstream input port. */
2014         input_port = bt_self_component_filter_borrow_input_port_by_name(
2015                         debug_info_msg_iter->debug_info_component->self_comp_filter,
2016                         "in");
2017         if (!input_port) {
2018                 status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
2019                 goto error;
2020         }
2021
2022         /* Create an iterator on the upstream component. */
2023         msg_iter_status = bt_self_component_port_input_message_iterator_create_from_message_iterator(
2024                 self_msg_iter, input_port, &upstream_iterator);
2025         if (msg_iter_status != BT_SELF_COMPONENT_PORT_INPUT_MESSAGE_ITERATOR_CREATE_FROM_MESSAGE_ITERATOR_STATUS_OK) {
2026                 status = (int) msg_iter_status;
2027                 goto error;
2028         }
2029
2030         BT_SELF_COMPONENT_PORT_INPUT_MESSAGE_ITERATOR_MOVE_REF(
2031                 debug_info_msg_iter->msg_iter, upstream_iterator);
2032
2033         /* Create hashtable that will contain debug info mapping. */
2034         debug_info_msg_iter->debug_info_map = g_hash_table_new_full(
2035                 g_direct_hash, g_direct_equal, (GDestroyNotify) NULL,
2036                 (GDestroyNotify) debug_info_destroy);
2037         if (!debug_info_msg_iter->debug_info_map) {
2038                 status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
2039                 goto error;
2040         }
2041
2042         debug_info_field_name =
2043                 debug_info_msg_iter->debug_info_component->arg_debug_info_field_name;
2044
2045         debug_info_msg_iter->ir_maps = trace_ir_maps_create(self_comp,
2046                 debug_info_field_name, log_level);
2047         if (!debug_info_msg_iter->ir_maps) {
2048                 status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
2049                 goto error;
2050         }
2051
2052         ret = bt_fd_cache_init(&debug_info_msg_iter->fd_cache, log_level);
2053         if (ret) {
2054                 status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
2055                 goto error;
2056         }
2057
2058         bt_self_message_iterator_configuration_set_can_seek_forward(config,
2059                 bt_self_component_port_input_message_iterator_can_seek_forward(
2060                         debug_info_msg_iter->msg_iter));
2061
2062         bt_self_message_iterator_set_data(self_msg_iter, debug_info_msg_iter);
2063         debug_info_msg_iter->input_iterator = self_msg_iter;
2064
2065         status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_OK;
2066         goto end;
2067
2068 error:
2069         debug_info_msg_iter_destroy(debug_info_msg_iter);
2070
2071 end:
2072         return status;
2073 }
2074
2075 BT_HIDDEN
2076 bt_message_iterator_class_can_seek_beginning_method_status
2077 debug_info_msg_iter_can_seek_beginning(bt_self_message_iterator *self_msg_iter,
2078                 bt_bool *can_seek)
2079 {
2080         struct debug_info_msg_iter *debug_info_msg_iter =
2081                 bt_self_message_iterator_get_data(self_msg_iter);
2082         BT_ASSERT(debug_info_msg_iter);
2083
2084         return (int) bt_self_component_port_input_message_iterator_can_seek_beginning(
2085                 debug_info_msg_iter->msg_iter, can_seek);
2086 }
2087
2088 BT_HIDDEN
2089 bt_message_iterator_class_seek_beginning_method_status
2090 debug_info_msg_iter_seek_beginning(bt_self_message_iterator *self_msg_iter)
2091 {
2092         struct debug_info_msg_iter *debug_info_msg_iter =
2093                 bt_self_message_iterator_get_data(self_msg_iter);
2094         bt_message_iterator_class_seek_beginning_method_status status =
2095                 BT_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHOD_STATUS_OK;
2096         bt_message_iterator_seek_beginning_status seek_beg_status;
2097
2098         BT_ASSERT(debug_info_msg_iter);
2099
2100         /* Ask the upstream component to seek to the beginning. */
2101         seek_beg_status = bt_self_component_port_input_message_iterator_seek_beginning(
2102                 debug_info_msg_iter->msg_iter);
2103         if (seek_beg_status != BT_MESSAGE_ITERATOR_SEEK_BEGINNING_STATUS_OK) {
2104                 status = (int) seek_beg_status;
2105                 goto end;
2106         }
2107
2108         /* Clear this iterator data. */
2109         trace_ir_maps_clear(debug_info_msg_iter->ir_maps);
2110         g_hash_table_remove_all(debug_info_msg_iter->debug_info_map);
2111
2112 end:
2113         return status;
2114 }
2115
2116 BT_HIDDEN
2117 void debug_info_msg_iter_finalize(bt_self_message_iterator *it)
2118 {
2119         struct debug_info_msg_iter *debug_info_msg_iter;
2120
2121         debug_info_msg_iter = bt_self_message_iterator_get_data(it);
2122         BT_ASSERT(debug_info_msg_iter);
2123
2124         debug_info_msg_iter_destroy(debug_info_msg_iter);
2125 }