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