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