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