src/plugins/lttng-utils/debug-info/trace-ir-mapping.c

   1 /*
   2  * Babeltrace - Mapping of IR metadata and data object between input and output
   3  *              trace
   4  *
   5  * Copyright (c) 2015 EfficiOS Inc. and Linux Foundation
   6  * Copyright (c) 2018 Philippe Proulx <pproulx@efficios.com>
   7  * Copyright (c) 2019 Francis Deslauriers <francis.deslauriers@efficios.com>
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a copy
  10  * of this software and associated documentation files (the "Software"), to deal
  11  * in the Software without restriction, including without limitation the rights
  12  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  13  * copies of the Software, and to permit persons to whom the Software is
  14  * furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included in
  17  * all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  22  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  24  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  25  * SOFTWARE.
  26  */
  27
  28 #define BT_COMP_LOG_SELF_COMP (ir_maps->self_comp)
  29 #define BT_LOG_OUTPUT_LEVEL (ir_maps->log_level)
  30 #define BT_LOG_TAG "PLUGIN/FLT.LTTNG-UTILS.DEBUG-INFO/TRACE-IR-MAPPING"
  31 #include "logging/comp-logging.h"
  32
  33 #include <stdbool.h>
  34
  35 #include "common/assert.h"
  36 #include <babeltrace2/babeltrace.h>
  37 /* For bt_property_availability */
  38 #include <babeltrace2/property.h>
  39
  40 #include "debug-info.h"
  41 #include "trace-ir-data-copy.h"
  42 #include "trace-ir-mapping.h"
  43 #include "trace-ir-metadata-copy.h"
  44
  45 static
  46 bt_trace_class *create_new_mapped_trace_class(struct trace_ir_maps *ir_maps,
  47                 const bt_trace_class *in_trace_class)
  48 {
  49         int ret;
  50         bt_trace_class *out_trace_class;
  51
  52         BT_COMP_LOGD("Creating new mapped trace class: in-tc-addr=%p", in_trace_class);
  53
  54         BT_ASSERT(ir_maps);
  55         BT_ASSERT(in_trace_class);
  56
  57         /* Create the ouput trace class. */
  58         out_trace_class = bt_trace_class_create(ir_maps->self_comp);
  59         if (!out_trace_class) {
  60                 BT_COMP_LOGE_STR("Error create output trace class");
  61                 goto end;
  62         }
  63
  64         /* If not, create a new one and add it to the mapping. */
  65         ret = copy_trace_class_content(in_trace_class, out_trace_class,
  66                 ir_maps->log_level, ir_maps->self_comp);
  67         if (ret) {
  68                 BT_COMP_LOGE_STR("Error copy content to output trace class");
  69                 out_trace_class = NULL;
  70                 goto end;
  71         }
  72
  73         BT_COMP_LOGD("Created new mapped trace class: in-tc-addr=%p, out-tc-addr=%p",
  74                         in_trace_class, out_trace_class);
  75
  76 end:
  77         return out_trace_class;
  78 }
  79
  80 static
  81 bt_trace *create_new_mapped_trace(struct trace_ir_maps *ir_maps,
  82                 const bt_trace *in_trace)
  83 {
  84         bt_trace *out_trace;
  85         const bt_trace_class *in_trace_class;
  86         struct trace_ir_metadata_maps *metadata_maps;
  87
  88         BT_COMP_LOGD("Creating new mapped trace: in-t-addr=%p", in_trace);
  89         BT_ASSERT(ir_maps);
  90         BT_ASSERT(in_trace);
  91
  92         in_trace_class = bt_trace_borrow_class_const(in_trace);
  93         metadata_maps = borrow_metadata_maps_from_input_trace_class(ir_maps,
  94                         in_trace_class);
  95
  96         if (!metadata_maps->output_trace_class) {
  97                 metadata_maps->output_trace_class =
  98                         create_new_mapped_trace_class(ir_maps, in_trace_class);
  99                 if (!metadata_maps->output_trace_class) {
 100                         out_trace = NULL;
 101                         goto end;
 102                 }
 103         }
 104
 105         out_trace = bt_trace_create(metadata_maps->output_trace_class);
 106         if (!out_trace) {
 107                 BT_COMP_LOGE_STR("Error create output trace");
 108                 goto end;
 109         }
 110
 111         /* If not, create a new one and add it to the mapping. */
 112         copy_trace_content(in_trace, out_trace, ir_maps->log_level,
 113                 ir_maps->self_comp);
 114
 115         BT_COMP_LOGD("Created new mapped trace: in-t-addr=%p, out-t-addr=%p",
 116                         in_trace, out_trace);
 117 end:
 118         return out_trace;
 119 }
 120
 121 static
 122 bt_stream_class *borrow_mapped_stream_class(struct trace_ir_metadata_maps *md_maps,
 123                 const bt_stream_class *in_stream_class)
 124 {
 125         BT_ASSERT(md_maps);
 126         BT_ASSERT(in_stream_class);
 127
 128         return g_hash_table_lookup(md_maps->stream_class_map,
 129                         (gpointer) in_stream_class);
 130 }
 131
 132 static
 133 bt_stream_class *create_new_mapped_stream_class(struct trace_ir_maps *ir_maps,
 134                 const bt_stream_class *in_stream_class)
 135 {
 136         int ret;
 137         bt_stream_class *out_stream_class;
 138         struct trace_ir_metadata_maps *md_maps;
 139
 140         BT_COMP_LOGD("Creating new mapped stream class: in-sc-addr=%p",
 141                         in_stream_class);
 142
 143         md_maps = borrow_metadata_maps_from_input_stream_class(ir_maps,
 144                         in_stream_class);
 145
 146         BT_ASSERT(md_maps);
 147         BT_ASSERT(in_stream_class);
 148         BT_ASSERT(!borrow_mapped_stream_class(md_maps, in_stream_class));
 149
 150         /* Create an out_stream_class. */
 151         out_stream_class = bt_stream_class_create_with_id(
 152                         md_maps->output_trace_class,
 153                         bt_stream_class_get_id(in_stream_class));
 154         if (!out_stream_class) {
 155                 BT_COMP_LOGE_STR("Error create output stream class");
 156                 goto end;
 157         }
 158
 159         /* If not, create a new one and add it to the mapping. */
 160         ret = copy_stream_class_content(ir_maps, in_stream_class,
 161                         out_stream_class);
 162         if (ret) {
 163                 BT_COMP_LOGE_STR("Error copy content to output stream class");
 164                 out_stream_class = NULL;
 165                 goto end;
 166         }
 167
 168         g_hash_table_insert(md_maps->stream_class_map,
 169                         (gpointer) in_stream_class, out_stream_class);
 170
 171         BT_COMP_LOGD("Created new mapped stream class: in-sc-addr=%p, out-sc-addr=%p",
 172                         in_stream_class, out_stream_class);
 173
 174 end:
 175         return out_stream_class;
 176 }
 177
 178 static
 179 bt_stream *borrow_mapped_stream(struct trace_ir_data_maps *d_maps,
 180                 const bt_stream *in_stream)
 181 {
 182         BT_ASSERT(d_maps);
 183         BT_ASSERT(in_stream);
 184
 185         return g_hash_table_lookup(d_maps->stream_map, (gpointer) in_stream);
 186 }
 187
 188 BT_HIDDEN
 189 bt_stream *trace_ir_mapping_create_new_mapped_stream(
 190                 struct trace_ir_maps *ir_maps,
 191                 const bt_stream *in_stream)
 192 {
 193         struct trace_ir_data_maps *d_maps;
 194         struct trace_ir_metadata_maps *md_maps;
 195         const bt_stream_class *in_stream_class;
 196         const bt_trace *in_trace;
 197         bt_stream_class *out_stream_class;
 198         bt_stream *out_stream = NULL;
 199
 200         BT_ASSERT(ir_maps);
 201         BT_ASSERT(in_stream);
 202         BT_COMP_LOGD("Creating new mapped stream: in-s-addr=%p", in_stream);
 203
 204         in_trace = bt_stream_borrow_trace_const(in_stream);
 205
 206         d_maps = borrow_data_maps_from_input_trace(ir_maps, in_trace);
 207         if (!d_maps->output_trace) {
 208                 d_maps->output_trace = create_new_mapped_trace(ir_maps, in_trace);
 209                 if (!d_maps->output_trace) {
 210                         goto end;
 211                 }
 212         }
 213
 214         BT_ASSERT(d_maps->output_trace);
 215         BT_ASSERT(!borrow_mapped_stream(d_maps, in_stream));
 216
 217         in_stream_class = bt_stream_borrow_class_const(in_stream);
 218         md_maps = borrow_metadata_maps_from_input_stream_class(ir_maps, in_stream_class);
 219         out_stream_class = borrow_mapped_stream_class(md_maps, in_stream_class);
 220         if (!out_stream_class) {
 221                 out_stream_class = create_new_mapped_stream_class(ir_maps,
 222                                 in_stream_class);
 223                 if (!out_stream_class) {
 224                         goto end;
 225                 }
 226         }
 227         BT_ASSERT(out_stream_class);
 228
 229         out_stream = bt_stream_create_with_id(out_stream_class,
 230                         d_maps->output_trace, bt_stream_get_id(in_stream));
 231         if (!out_stream) {
 232                 BT_COMP_LOGE_STR("Error creating output stream");
 233                 goto end;
 234         }
 235
 236         copy_stream_content(in_stream, out_stream, ir_maps->log_level,
 237                 ir_maps->self_comp);
 238
 239         g_hash_table_insert(d_maps->stream_map, (gpointer) in_stream,
 240                         out_stream);
 241
 242         BT_COMP_LOGD("Created new mapped stream: in-s-addr=%p, out-s-addr=%p",
 243                         in_stream, out_stream);
 244
 245 end:
 246         return out_stream;
 247 }
 248
 249 BT_HIDDEN
 250 bt_stream *trace_ir_mapping_borrow_mapped_stream(struct trace_ir_maps *ir_maps,
 251                 const bt_stream *in_stream)
 252 {
 253         BT_ASSERT(ir_maps);
 254         BT_ASSERT(in_stream);
 255         struct trace_ir_data_maps *d_maps;
 256
 257         d_maps = borrow_data_maps_from_input_stream(ir_maps, in_stream);
 258         /* Return the mapped stream. */
 259         return borrow_mapped_stream(d_maps, in_stream);
 260 }
 261
 262 static inline
 263 bt_event_class *borrow_mapped_event_class(struct trace_ir_metadata_maps *md_maps,
 264                 const bt_event_class *in_event_class)
 265 {
 266         return g_hash_table_lookup(md_maps->event_class_map,
 267                         (gpointer) in_event_class);
 268 }
 269
 270 BT_HIDDEN
 271 bt_event_class *trace_ir_mapping_create_new_mapped_event_class(
 272                 struct trace_ir_maps *ir_maps,
 273                 const bt_event_class *in_event_class)
 274 {
 275         bt_event_class *out_event_class;
 276         const bt_trace_class *in_trace_class;
 277         const bt_stream_class *in_stream_class;
 278         bt_stream_class *out_stream_class;
 279         struct trace_ir_metadata_maps *md_maps;
 280         int ret;
 281
 282         BT_ASSERT(ir_maps);
 283         BT_ASSERT(in_event_class);
 284         BT_COMP_LOGD("Creating new mapped event class: in-ec-addr=%p",
 285                         in_event_class);
 286
 287         in_trace_class = bt_stream_class_borrow_trace_class_const(
 288                                 bt_event_class_borrow_stream_class_const(
 289                                         in_event_class));
 290
 291         md_maps = borrow_metadata_maps_from_input_trace_class(ir_maps, in_trace_class);
 292
 293         BT_ASSERT(!borrow_mapped_event_class(md_maps, in_event_class));
 294
 295         in_stream_class =
 296                 bt_event_class_borrow_stream_class_const(in_event_class);
 297         BT_ASSERT(in_stream_class);
 298
 299         /* Get the right output stream class to add the new event class to. */
 300         out_stream_class = borrow_mapped_stream_class(md_maps, in_stream_class);
 301         BT_ASSERT(out_stream_class);
 302
 303         /* Create an output event class. */
 304         out_event_class = bt_event_class_create_with_id(out_stream_class,
 305                         bt_event_class_get_id(in_event_class));
 306         if (!out_event_class) {
 307                 BT_COMP_LOGE_STR("Error creating output event class");
 308                 goto end;
 309         }
 310
 311         /* If not, create a new one and add it to the mapping. */
 312         ret = copy_event_class_content(ir_maps, in_event_class,
 313                         out_event_class);
 314         if (ret) {
 315                 BT_COMP_LOGE_STR("Error copy content to output event class");
 316                 out_event_class = NULL;
 317                 goto end;
 318         }
 319
 320         g_hash_table_insert(md_maps->event_class_map,
 321                         (gpointer) in_event_class, out_event_class);
 322
 323         BT_COMP_LOGD("Created new mapped event class: in-ec-addr=%p, out-ec-addr=%p",
 324                         in_event_class, out_event_class);
 325
 326 end:
 327         return out_event_class;
 328 }
 329
 330 BT_HIDDEN
 331 bt_event_class *trace_ir_mapping_borrow_mapped_event_class(
 332                 struct trace_ir_maps *ir_maps,
 333                 const bt_event_class *in_event_class)
 334 {
 335         struct trace_ir_metadata_maps *md_maps;
 336
 337         BT_ASSERT(ir_maps);
 338         BT_ASSERT(in_event_class);
 339
 340         md_maps = borrow_metadata_maps_from_input_event_class(ir_maps, in_event_class);
 341
 342         /* Return the mapped event_class. */
 343         return borrow_mapped_event_class(md_maps, in_event_class);
 344 }
 345
 346 static inline
 347 bt_packet *borrow_mapped_packet(struct trace_ir_data_maps *d_maps,
 348                 const bt_packet *in_packet)
 349 {
 350         BT_ASSERT(d_maps);
 351         BT_ASSERT(in_packet);
 352
 353         return g_hash_table_lookup(d_maps->packet_map,
 354                         (gpointer) in_packet);
 355 }
 356
 357 BT_HIDDEN
 358 bt_packet *trace_ir_mapping_create_new_mapped_packet(
 359                 struct trace_ir_maps *ir_maps,
 360                 const bt_packet *in_packet)
 361 {
 362         struct trace_ir_data_maps *d_maps;
 363         const bt_trace *in_trace;
 364         const bt_stream *in_stream;
 365         bt_packet *out_packet;
 366         bt_stream *out_stream;
 367
 368         BT_COMP_LOGD("Creating new mapped packet: in-p-addr=%p", in_packet);
 369
 370         in_stream = bt_packet_borrow_stream_const(in_packet);
 371         in_trace = bt_stream_borrow_trace_const(in_stream);
 372         d_maps = borrow_data_maps_from_input_trace(ir_maps, in_trace);
 373
 374         /* There should never be a mapped packet. */
 375         BT_ASSERT(!borrow_mapped_packet(d_maps, in_packet));
 376
 377         BT_ASSERT(in_stream);
 378
 379         /* Get output stream corresponding to this input stream. */
 380         out_stream = borrow_mapped_stream(d_maps, in_stream);
 381         BT_ASSERT(out_stream);
 382
 383         /* Create the output packet. */
 384         out_packet = bt_packet_create(out_stream);
 385         if (!out_packet) {
 386                 BT_COMP_LOGE_STR("Error create output packet");
 387                 goto end;
 388         }
 389
 390         copy_packet_content(in_packet, out_packet, ir_maps->log_level,
 391                 ir_maps->self_comp);
 392
 393         g_hash_table_insert(d_maps->packet_map,
 394                         (gpointer) in_packet, out_packet);
 395
 396         BT_COMP_LOGD("Created new mapped packet: in-p-addr=%p, out-p-addr=%p",
 397                         in_packet, out_packet);
 398
 399 end:
 400         return out_packet;
 401 }
 402
 403 BT_HIDDEN
 404 bt_packet *trace_ir_mapping_borrow_mapped_packet(struct trace_ir_maps *ir_maps,
 405                 const bt_packet *in_packet)
 406 {
 407         struct trace_ir_data_maps *d_maps;
 408         BT_ASSERT(ir_maps);
 409         BT_ASSERT(in_packet);
 410
 411         d_maps = borrow_data_maps_from_input_packet(ir_maps, in_packet);
 412
 413         return borrow_mapped_packet(d_maps, in_packet);
 414 }
 415
 416 BT_HIDDEN
 417 void trace_ir_mapping_remove_mapped_packet(struct trace_ir_maps *ir_maps,
 418                 const bt_packet *in_packet)
 419 {
 420         gboolean ret;
 421
 422         struct trace_ir_data_maps *d_maps;
 423         BT_ASSERT(ir_maps);
 424         BT_ASSERT(in_packet);
 425
 426         d_maps = borrow_data_maps_from_input_packet(ir_maps, in_packet);
 427
 428         ret = g_hash_table_remove(d_maps->packet_map, in_packet);
 429
 430         BT_ASSERT(ret);
 431 }
 432
 433 BT_HIDDEN
 434 void trace_ir_mapping_remove_mapped_stream(struct trace_ir_maps *ir_maps,
 435                 const bt_stream *in_stream)
 436 {
 437         gboolean ret;
 438         struct trace_ir_data_maps *d_maps;
 439
 440         BT_ASSERT(ir_maps);
 441         BT_ASSERT(in_stream);
 442
 443         d_maps = borrow_data_maps_from_input_stream(ir_maps, in_stream);
 444
 445         ret = g_hash_table_remove(d_maps->stream_map, in_stream);
 446
 447         BT_ASSERT(ret);
 448 }
 449
 450 static
 451 void trace_ir_metadata_maps_remove_func(const bt_trace_class *in_trace_class,
 452                 void *data)
 453 {
 454         struct trace_ir_maps *maps = (struct trace_ir_maps *) data;
 455         if (maps->metadata_maps) {
 456                 gboolean ret;
 457                 ret = g_hash_table_remove(maps->metadata_maps,
 458                                 (gpointer) in_trace_class);
 459                 BT_ASSERT(ret);
 460         }
 461 }
 462
 463 static
 464 void trace_ir_data_maps_remove_func(const bt_trace *in_trace, void *data)
 465 {
 466         struct trace_ir_maps *maps = (struct trace_ir_maps *) data;
 467         if (maps->data_maps) {
 468                 gboolean ret;
 469                 ret = g_hash_table_remove(maps->data_maps, (gpointer) in_trace);
 470                 BT_ASSERT(ret);
 471         }
 472 }
 473
 474 struct trace_ir_data_maps *trace_ir_data_maps_create(struct trace_ir_maps *ir_maps,
 475                 const bt_trace *in_trace)
 476 {
 477         struct trace_ir_data_maps *d_maps =
 478                 g_new0(struct trace_ir_data_maps, 1);
 479         bt_trace_add_listener_status add_listener_status;
 480
 481         if (!d_maps) {
 482                 BT_COMP_LOGE_STR("Error allocating trace_ir_maps");
 483                 goto error;
 484         }
 485
 486         d_maps->log_level = ir_maps->log_level;
 487         d_maps->self_comp = ir_maps->self_comp;
 488         d_maps->input_trace = in_trace;
 489
 490         /* Create the hashtables used to map data objects. */
 491         d_maps->stream_map = g_hash_table_new_full(g_direct_hash,
 492                         g_direct_equal, NULL,(GDestroyNotify) bt_stream_put_ref);
 493         d_maps->packet_map = g_hash_table_new_full(g_direct_hash,
 494                         g_direct_equal, NULL,(GDestroyNotify) bt_packet_put_ref);
 495
 496         add_listener_status = bt_trace_add_destruction_listener(
 497                 in_trace, trace_ir_data_maps_remove_func,
 498                 ir_maps, &d_maps->destruction_listener_id);
 499         BT_ASSERT(add_listener_status == BT_TRACE_ADD_LISTENER_STATUS_OK);
 500
 501 error:
 502         return d_maps;
 503 }
 504
 505 struct trace_ir_metadata_maps *trace_ir_metadata_maps_create(
 506                 struct trace_ir_maps *ir_maps,
 507                 const bt_trace_class *in_trace_class)
 508 {
 509         struct trace_ir_metadata_maps *md_maps =
 510                 g_new0(struct trace_ir_metadata_maps, 1);
 511         bt_trace_class_add_listener_status add_listener_status;
 512
 513         if (!md_maps) {
 514                 BT_COMP_LOGE_STR("Error allocating trace_ir_maps");
 515                 goto error;
 516         }
 517
 518         md_maps->log_level = ir_maps->log_level;
 519         md_maps->self_comp = ir_maps->self_comp;
 520         md_maps->input_trace_class = in_trace_class;
 521         /*
 522          * Create the field class resolving context. This is needed to keep
 523          * track of the field class already copied in order to do the field
 524          * path resolution correctly.
 525          */
 526         md_maps->fc_resolving_ctx =
 527                 g_new0(struct field_class_resolving_context, 1);
 528         if (!md_maps->fc_resolving_ctx) {
 529                 BT_COMP_LOGE_STR("Error allocating field_class_resolving_context");
 530                 goto error;
 531         }
 532
 533         /* Create the hashtables used to map metadata objects. */
 534         md_maps->stream_class_map = g_hash_table_new_full(g_direct_hash,
 535                         g_direct_equal, NULL, (GDestroyNotify) bt_stream_class_put_ref);
 536         md_maps->event_class_map = g_hash_table_new_full(g_direct_hash,
 537                         g_direct_equal, NULL, (GDestroyNotify) bt_event_class_put_ref);
 538         md_maps->field_class_map = g_hash_table_new_full(g_direct_hash,
 539                         g_direct_equal, NULL, (GDestroyNotify) bt_field_class_put_ref);
 540         md_maps->clock_class_map = g_hash_table_new_full(g_direct_hash,
 541                         g_direct_equal, NULL, (GDestroyNotify) bt_clock_class_put_ref);
 542
 543         add_listener_status = bt_trace_class_add_destruction_listener(
 544                         in_trace_class,
 545                         trace_ir_metadata_maps_remove_func,
 546                         ir_maps, &md_maps->destruction_listener_id);
 547         BT_ASSERT(add_listener_status ==
 548                 BT_TRACE_CLASS_ADD_LISTENER_STATUS_OK);
 549
 550 error:
 551         return md_maps;
 552 }
 553
 554 BT_HIDDEN
 555 void trace_ir_data_maps_destroy(struct trace_ir_data_maps *maps)
 556 {
 557         bt_trace_remove_listener_status status;
 558
 559         if (!maps) {
 560                 return;
 561         }
 562
 563         if (maps->packet_map) {
 564                 g_hash_table_destroy(maps->packet_map);
 565         }
 566
 567         if (maps->stream_map) {
 568                 g_hash_table_destroy(maps->stream_map);
 569         }
 570
 571         if (maps->output_trace) {
 572                 bt_trace_put_ref(maps->output_trace);
 573         }
 574
 575         status = bt_trace_remove_destruction_listener(maps->input_trace,
 576                 maps->destruction_listener_id);
 577         if (status != BT_TRACE_REMOVE_LISTENER_STATUS_OK) {
 578                 BT_COMP_LOG_CUR_LVL(BT_LOG_DEBUG, maps->log_level,
 579                         maps->self_comp,
 580                         "Trace destruction listener removal failed.");
 581                 bt_current_thread_clear_error();
 582         }
 583
 584         g_free(maps);
 585 }
 586
 587 BT_HIDDEN
 588 void trace_ir_metadata_maps_destroy(struct trace_ir_metadata_maps *maps)
 589 {
 590         bt_trace_class_remove_listener_status status;
 591
 592         if (!maps) {
 593                 return;
 594         }
 595
 596         if (maps->stream_class_map) {
 597                 g_hash_table_destroy(maps->stream_class_map);
 598         }
 599
 600         if (maps->event_class_map) {
 601                 g_hash_table_destroy(maps->event_class_map);
 602         }
 603
 604         if (maps->field_class_map) {
 605                 g_hash_table_destroy(maps->field_class_map);
 606         }
 607
 608         if (maps->clock_class_map) {
 609                 g_hash_table_destroy(maps->clock_class_map);
 610         }
 611
 612         g_free(maps->fc_resolving_ctx);
 613
 614         if (maps->output_trace_class) {
 615                 bt_trace_class_put_ref(maps->output_trace_class);
 616         }
 617
 618         status = bt_trace_class_remove_destruction_listener(
 619                 maps->input_trace_class,
 620                 maps->destruction_listener_id);
 621         if (status != BT_TRACE_CLASS_REMOVE_LISTENER_STATUS_OK) {
 622                 BT_COMP_LOG_CUR_LVL(BT_LOG_DEBUG, maps->log_level,
 623                         maps->self_comp,
 624                         "Trace destruction listener removal failed.");
 625                 bt_current_thread_clear_error();
 626         }
 627
 628         g_free(maps);
 629 }
 630
 631 void trace_ir_maps_clear(struct trace_ir_maps *maps)
 632 {
 633         if (maps->data_maps) {
 634                 g_hash_table_remove_all(maps->data_maps);
 635         }
 636
 637         if (maps->metadata_maps) {
 638                 g_hash_table_remove_all(maps->metadata_maps);
 639         }
 640 }
 641
 642 BT_HIDDEN
 643 void trace_ir_maps_destroy(struct trace_ir_maps *maps)
 644 {
 645         if (!maps) {
 646                 return;
 647         }
 648
 649         g_free(maps->debug_info_field_class_name);
 650
 651         if (maps->data_maps) {
 652                 g_hash_table_destroy(maps->data_maps);
 653                 maps->data_maps = NULL;
 654         }
 655
 656         if (maps->metadata_maps) {
 657                 g_hash_table_destroy(maps->metadata_maps);
 658                 maps->metadata_maps = NULL;
 659         }
 660
 661         g_free(maps);
 662 }
 663
 664 BT_HIDDEN
 665 struct trace_ir_maps *trace_ir_maps_create(bt_self_component *self_comp,
 666                 const char *debug_info_field_name, bt_logging_level log_level)
 667 {
 668         struct trace_ir_maps *ir_maps =
 669                 g_new0(struct trace_ir_maps, 1);
 670         if (!ir_maps) {
 671                 BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
 672                         "Error allocating trace_ir_maps");
 673                 goto error;
 674         }
 675
 676         ir_maps->log_level = log_level;
 677         ir_maps->self_comp = self_comp;
 678
 679         /* Copy debug info field name received from the user. */
 680         ir_maps->debug_info_field_class_name =
 681                 g_strdup(debug_info_field_name);
 682         if (!ir_maps->debug_info_field_class_name) {
 683                 BT_COMP_LOGE_STR("Cannot copy debug info field name");
 684                 goto error;
 685         }
 686
 687         ir_maps->self_comp = self_comp;
 688
 689         ir_maps->data_maps = g_hash_table_new_full(g_direct_hash,
 690                         g_direct_equal, (GDestroyNotify) NULL,
 691                         (GDestroyNotify) trace_ir_data_maps_destroy);
 692
 693         ir_maps->metadata_maps = g_hash_table_new_full(g_direct_hash,
 694                         g_direct_equal, (GDestroyNotify) NULL,
 695                         (GDestroyNotify) trace_ir_metadata_maps_destroy);
 696
 697         goto end;
 698 error:
 699         trace_ir_maps_destroy(ir_maps);
 700         ir_maps = NULL;
 701 end:
 702         return ir_maps;
 703 }