plugins/lttng-utils/copy.c

   1 /*
   2  * copy.c
   3  *
   4  * Babeltrace Copy Trace Structure
   5  *
   6  * Copyright 2017 Julien Desfossez <jdesfossez@efficios.com>
   7  *
   8  * Author: Julien Desfossez <jdesfossez@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 #include <inttypes.h>
  30 #include <babeltrace/ctf-ir/event.h>
  31 #include <babeltrace/ctf-ir/packet.h>
  32 #include <babeltrace/ctf-ir/event-class.h>
  33 #include <babeltrace/ctf-ir/stream.h>
  34 #include <babeltrace/ctf-ir/stream-class.h>
  35 #include <babeltrace/ctf-ir/clock-class.h>
  36 #include <babeltrace/ctf-ir/fields.h>
  37 #include <babeltrace/ctf-writer/stream-class.h>
  38 #include <babeltrace/ctf-writer/stream.h>
  39
  40 #include <ctfcopytrace.h>
  41 #include "debug-info.h"
  42
  43 static
  44 struct bt_ctf_stream *insert_new_stream(
  45                 struct debug_info_iterator *debug_it,
  46                 struct bt_ctf_stream *stream,
  47                 struct debug_info_trace *di_trace);
  48
  49 static
  50 void unref_stream(struct bt_ctf_stream *stream)
  51 {
  52         bt_put(stream);
  53 }
  54
  55 static
  56 void unref_packet(struct bt_ctf_packet *packet)
  57 {
  58         bt_put(packet);
  59 }
  60
  61 static
  62 void unref_stream_class(struct bt_ctf_stream_class *stream_class)
  63 {
  64         bt_put(stream_class);
  65 }
  66
  67 static
  68 void unref_debug_info(struct debug_info *debug_info)
  69 {
  70         debug_info_destroy(debug_info);
  71 }
  72
  73 static
  74 void destroy_stream_state_key(gpointer key)
  75 {
  76         g_free((enum fs_writer_stream_state *) key);
  77 }
  78
  79 static
  80 struct bt_ctf_field *get_payload_field(FILE *err,
  81                 struct bt_ctf_event *event, const char *field_name)
  82 {
  83         struct bt_ctf_field *field = NULL, *sec = NULL;
  84         struct bt_ctf_field_type *sec_type = NULL;
  85
  86         sec = bt_ctf_event_get_payload(event, NULL);
  87         if (!sec) {
  88                 fprintf(err, "[error] %s in %s:%d\n", __func__,
  89                                 __FILE__, __LINE__);
  90                 goto end;
  91         }
  92
  93         sec_type = bt_ctf_field_get_type(sec);
  94         if (!sec_type) {
  95                 fprintf(err, "[error] %s in %s:%d\n", __func__,
  96                                 __FILE__, __LINE__);
  97                 goto end;
  98         }
  99
 100         if (bt_ctf_field_type_get_type_id(sec_type) != BT_CTF_FIELD_TYPE_ID_STRUCT) {
 101                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 102                                 __FILE__, __LINE__);
 103                 goto end;
 104         }
 105
 106         field = bt_ctf_field_structure_get_field(sec, field_name);
 107
 108 end:
 109         bt_put(sec_type);
 110         bt_put(sec);
 111         return field;
 112 }
 113
 114 static
 115 struct bt_ctf_field *get_stream_event_context_field(FILE *err,
 116                 struct bt_ctf_event *event, const char *field_name)
 117 {
 118         struct bt_ctf_field *field = NULL, *sec = NULL;
 119         struct bt_ctf_field_type *sec_type = NULL;
 120
 121         sec = bt_ctf_event_get_stream_event_context(event);
 122         if (!sec) {
 123                 goto end;
 124         }
 125
 126         sec_type = bt_ctf_field_get_type(sec);
 127         if (!sec_type) {
 128                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 129                                 __FILE__, __LINE__);
 130                 goto end;
 131         }
 132
 133         if (bt_ctf_field_type_get_type_id(sec_type) != BT_CTF_FIELD_TYPE_ID_STRUCT) {
 134                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 135                                 __FILE__, __LINE__);
 136                 goto end;
 137         }
 138
 139         field = bt_ctf_field_structure_get_field(sec, field_name);
 140
 141 end:
 142         bt_put(sec_type);
 143         bt_put(sec);
 144         return field;
 145 }
 146
 147 BT_HIDDEN
 148 int get_stream_event_context_unsigned_int_field_value(FILE *err,
 149                 struct bt_ctf_event *event, const char *field_name,
 150                 uint64_t *value)
 151 {
 152         int ret;
 153         struct bt_ctf_field *field = NULL;
 154         struct bt_ctf_field_type *field_type = NULL;
 155
 156         field = get_stream_event_context_field(err, event, field_name);
 157         if (!field) {
 158                 goto error;
 159         }
 160
 161         field_type = bt_ctf_field_get_type(field);
 162         if (!field_type) {
 163                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 164                                 __FILE__, __LINE__);
 165                 goto error;
 166         }
 167
 168         if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_INTEGER) {
 169                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 170                                 __FILE__, __LINE__);
 171                 goto error;
 172         }
 173
 174         if (bt_ctf_field_type_integer_get_signed(field_type) != 0) {
 175                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 176                                 __FILE__, __LINE__);
 177                 goto error;
 178         }
 179
 180         ret = bt_ctf_field_unsigned_integer_get_value(field, value);
 181         goto end;
 182
 183 error:
 184         ret = -1;
 185 end:
 186         bt_put(field_type);
 187         bt_put(field);
 188         return ret;
 189 }
 190
 191 BT_HIDDEN
 192 int get_stream_event_context_int_field_value(FILE *err, struct bt_ctf_event *event,
 193                 const char *field_name, int64_t *value)
 194 {
 195         struct bt_ctf_field *field = NULL;
 196         struct bt_ctf_field_type *field_type = NULL;
 197         int ret;
 198
 199         field = get_stream_event_context_field(err, event, field_name);
 200         if (!field) {
 201                 goto error;
 202         }
 203
 204         field_type = bt_ctf_field_get_type(field);
 205         if (!field_type) {
 206                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 207                                 __FILE__, __LINE__);
 208                 goto error;
 209         }
 210
 211         if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_INTEGER) {
 212                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 213                                 __FILE__, __LINE__);
 214                 goto error;
 215         }
 216
 217         if (bt_ctf_field_type_integer_get_signed(field_type) != 1) {
 218                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 219                                 __FILE__, __LINE__);
 220                 goto error;
 221         }
 222
 223         ret = bt_ctf_field_signed_integer_get_value(field, value);
 224         goto end;
 225
 226 error:
 227         ret = -1;
 228 end:
 229         bt_put(field_type);
 230         bt_put(field);
 231         return ret;
 232 }
 233
 234 BT_HIDDEN
 235 int get_payload_unsigned_int_field_value(FILE *err,
 236                 struct bt_ctf_event *event, const char *field_name,
 237                 uint64_t *value)
 238 {
 239         struct bt_ctf_field *field = NULL;
 240         struct bt_ctf_field_type *field_type = NULL;
 241         int ret;
 242
 243         field = get_payload_field(err, event, field_name);
 244         if (!field) {
 245                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 246                                 __FILE__, __LINE__);
 247                 goto error;
 248         }
 249
 250         field_type = bt_ctf_field_get_type(field);
 251         if (!field_type) {
 252                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 253                                 __FILE__, __LINE__);
 254                 goto error;
 255         }
 256
 257         if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_INTEGER) {
 258                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 259                                 __FILE__, __LINE__);
 260                 goto error;
 261         }
 262
 263         if (bt_ctf_field_type_integer_get_signed(field_type) != 0) {
 264                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 265                                 __FILE__, __LINE__);
 266                 goto error;
 267         }
 268
 269         ret = bt_ctf_field_unsigned_integer_get_value(field, value);
 270         goto end;
 271
 272 error:
 273         ret = -1;
 274 end:
 275         bt_put(field_type);
 276         bt_put(field);
 277         return ret;
 278 }
 279
 280 BT_HIDDEN
 281 int get_payload_int_field_value(FILE *err, struct bt_ctf_event *event,
 282                 const char *field_name, int64_t *value)
 283 {
 284         struct bt_ctf_field *field = NULL;
 285         struct bt_ctf_field_type *field_type = NULL;
 286         int ret;
 287
 288         field = get_payload_field(err, event, field_name);
 289         if (!field) {
 290                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 291                                 __FILE__, __LINE__);
 292                 goto error;
 293         }
 294
 295         field_type = bt_ctf_field_get_type(field);
 296         if (!field_type) {
 297                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 298                                 __FILE__, __LINE__);
 299                 goto error;
 300         }
 301
 302         if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_INTEGER) {
 303                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 304                                 __FILE__, __LINE__);
 305                 goto error;
 306         }
 307
 308         if (bt_ctf_field_type_integer_get_signed(field_type) != 1) {
 309                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 310                                 __FILE__, __LINE__);
 311                 goto error;
 312         }
 313
 314         ret = bt_ctf_field_signed_integer_get_value(field, value);
 315         goto end;
 316
 317 error:
 318         ret = -1;
 319 end:
 320         bt_put(field_type);
 321         bt_put(field);
 322         return ret;
 323 }
 324
 325 BT_HIDDEN
 326 int get_payload_string_field_value(FILE *err,
 327                 struct bt_ctf_event *event, const char *field_name,
 328                 const char **value)
 329 {
 330         struct bt_ctf_field *field = NULL;
 331         struct bt_ctf_field_type *field_type = NULL;
 332         int ret;
 333
 334         /*
 335          * The field might not exist, no error here.
 336          */
 337         field = get_payload_field(err, event, field_name);
 338         if (!field) {
 339                 goto error;
 340         }
 341
 342         field_type = bt_ctf_field_get_type(field);
 343         if (!field_type) {
 344                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 345                                 __FILE__, __LINE__);
 346                 goto error;
 347         }
 348
 349         if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_STRING) {
 350                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 351                                 __FILE__, __LINE__);
 352                 goto error;
 353         }
 354
 355         *value = bt_ctf_field_string_get_value(field);
 356         if (!*value) {
 357                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 358                                 __FILE__, __LINE__);
 359                 goto error;
 360         }
 361
 362         ret = 0;
 363         goto end;
 364
 365 error:
 366         ret = -1;
 367 end:
 368         bt_put(field_type);
 369         bt_put(field);
 370         return ret;
 371 }
 372
 373 BT_HIDDEN
 374 int get_payload_build_id_field_value(FILE *err,
 375                 struct bt_ctf_event *event, const char *field_name,
 376                 uint8_t **build_id, uint64_t *build_id_len)
 377 {
 378         struct bt_ctf_field *field = NULL, *seq_len = NULL;
 379         struct bt_ctf_field_type *field_type = NULL;
 380         struct bt_ctf_field *seq_field = NULL;
 381         uint64_t i;
 382         int ret;
 383
 384         *build_id = NULL;
 385
 386         field = get_payload_field(err, event, field_name);
 387         if (!field) {
 388                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 389                                 __FILE__, __LINE__);
 390                 goto error;
 391         }
 392
 393         field_type = bt_ctf_field_get_type(field);
 394         if (!field_type) {
 395                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 396                                 __FILE__, __LINE__);
 397                 goto error;
 398         }
 399
 400         if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_SEQUENCE) {
 401                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 402                                 __FILE__, __LINE__);
 403                 goto error;
 404         }
 405         BT_PUT(field_type);
 406
 407         seq_len = bt_ctf_field_sequence_get_length(field);
 408         if (!seq_len) {
 409                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 410                                 __FILE__, __LINE__);
 411                 goto error;
 412         }
 413
 414         ret = bt_ctf_field_unsigned_integer_get_value(seq_len, build_id_len);
 415         if (ret) {
 416                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 417                                 __FILE__, __LINE__);
 418                 goto error;
 419         }
 420         BT_PUT(seq_len);
 421
 422         *build_id = g_new0(uint8_t, *build_id_len);
 423         if (!*build_id) {
 424                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 425                                 __FILE__, __LINE__);
 426                 goto error;
 427         }
 428
 429         for (i = 0; i < *build_id_len; i++) {
 430                 uint64_t tmp;
 431
 432                 seq_field = bt_ctf_field_sequence_get_field(field, i);
 433                 if (!seq_field) {
 434                         fprintf(err, "[error] %s in %s:%d\n", __func__,
 435                                         __FILE__, __LINE__);
 436                         goto error;
 437                 }
 438
 439                 ret = bt_ctf_field_unsigned_integer_get_value(seq_field, &tmp);
 440                 if (ret) {
 441                         fprintf(err, "[error] %s in %s:%d\n", __func__,
 442                                         __FILE__, __LINE__);
 443                         goto error;
 444                 }
 445                 BT_PUT(seq_field);
 446                 (*build_id)[i] = (uint8_t) tmp;
 447         }
 448         ret = 0;
 449         goto end;
 450
 451 error:
 452         g_free(*build_id);
 453         ret = -1;
 454 end:
 455         bt_put(field_type);
 456         bt_put(field);
 457         return ret;
 458 }
 459
 460 static
 461 struct debug_info *lookup_trace_debug_info(struct debug_info_iterator *debug_it,
 462                 struct bt_ctf_trace *writer_trace,
 463                 struct debug_info_trace *di_trace)
 464 {
 465         return (struct debug_info *) g_hash_table_lookup(
 466                         di_trace->trace_debug_map,
 467                         (gpointer) writer_trace);
 468 }
 469
 470 static
 471 struct debug_info *insert_new_debug_info(struct debug_info_iterator *debug_it,
 472                 struct bt_ctf_trace *writer_trace,
 473                 struct debug_info_trace *di_trace)
 474 {
 475         struct debug_info *debug_info = NULL;
 476         struct bt_value *field = NULL;
 477         const char *str_value;
 478         enum bt_value_status ret;
 479
 480         field = bt_ctf_trace_get_environment_field_value_by_name(writer_trace,
 481                         "domain");
 482         /* No domain field, no debug info */
 483         if (!field) {
 484                 goto end;
 485         }
 486         ret = bt_value_string_get(field, &str_value);
 487         if (ret != BT_VALUE_STATUS_OK) {
 488                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
 489                                 __FILE__, __LINE__);
 490                 goto end;
 491         }
 492         /* Domain not ust, no debug info */
 493         if (strcmp(str_value, "ust") != 0) {
 494                 goto end;
 495         }
 496         BT_PUT(field);
 497
 498         /* No tracer_name, no debug info */
 499         field = bt_ctf_trace_get_environment_field_value_by_name(writer_trace,
 500                         "tracer_name");
 501         /* No tracer_name, no debug info */
 502         if (!field) {
 503                 goto end;
 504         }
 505         ret = bt_value_string_get(field, &str_value);
 506         if (ret != BT_VALUE_STATUS_OK) {
 507                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
 508                                 __FILE__, __LINE__);
 509                 goto end;
 510         }
 511         /* Tracer_name not lttng-ust, no debug info */
 512         if (strcmp(str_value, "lttng-ust") != 0) {
 513                 goto end;
 514         }
 515         BT_PUT(field);
 516
 517         debug_info = debug_info_create(debug_it->debug_info_component);
 518         if (!debug_info) {
 519                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
 520                                 __FILE__, __LINE__);
 521                 goto end;
 522         }
 523
 524         g_hash_table_insert(di_trace->trace_debug_map, (gpointer) writer_trace,
 525                         debug_info);
 526
 527 end:
 528         bt_put(field);
 529         return debug_info;
 530 }
 531
 532 static
 533 struct debug_info *get_trace_debug_info(struct debug_info_iterator *debug_it,
 534                 struct bt_ctf_trace *writer_trace,
 535                 struct debug_info_trace *di_trace)
 536 {
 537         struct debug_info *debug_info;
 538
 539         debug_info = lookup_trace_debug_info(debug_it, writer_trace, di_trace);
 540         if (debug_info) {
 541                 goto end;
 542         }
 543
 544         debug_info = insert_new_debug_info(debug_it, writer_trace, di_trace);
 545
 546 end:
 547         return debug_info;
 548 }
 549
 550 static
 551 struct debug_info_trace *lookup_trace(struct debug_info_iterator *debug_it,
 552                 struct bt_ctf_trace *trace)
 553 {
 554         return (struct debug_info_trace *) g_hash_table_lookup(
 555                         debug_it->trace_map,
 556                         (gpointer) trace);
 557 }
 558
 559 static
 560 enum debug_info_stream_state *insert_new_stream_state(
 561                 struct debug_info_iterator *debug_it,
 562                 struct debug_info_trace *di_trace, struct bt_ctf_stream *stream)
 563 {
 564         enum debug_info_stream_state *v = NULL;
 565
 566         v = g_new0(enum debug_info_stream_state, 1);
 567         if (!v) {
 568                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
 569                                 __FILE__, __LINE__);
 570                 goto end;
 571         }
 572         *v = DEBUG_INFO_UNKNOWN_STREAM;
 573
 574         g_hash_table_insert(di_trace->stream_states, stream, v);
 575
 576 end:
 577         return v;
 578 }
 579
 580 static
 581 void check_completed_trace(gpointer key, gpointer value, gpointer user_data)
 582 {
 583         enum debug_info_stream_state *state = value;
 584         int *trace_completed = user_data;
 585
 586         if (*state != DEBUG_INFO_COMPLETED_STREAM) {
 587                 *trace_completed = 0;
 588         }
 589 }
 590
 591 static
 592 gboolean empty_ht(gpointer key, gpointer value, gpointer user_data)
 593 {
 594         return TRUE;
 595 }
 596
 597 BT_HIDDEN
 598 void debug_info_close_trace(struct debug_info_iterator *debug_it,
 599                 struct debug_info_trace *di_trace)
 600 {
 601         if (di_trace->static_listener_id >= 0) {
 602                 bt_ctf_trace_remove_is_static_listener(di_trace->trace,
 603                                 di_trace->static_listener_id);
 604         }
 605
 606         /* Empty the stream class HT. */
 607         g_hash_table_foreach_remove(di_trace->stream_class_map,
 608                         empty_ht, NULL);
 609         g_hash_table_destroy(di_trace->stream_class_map);
 610
 611         /* Empty the stream HT. */
 612         g_hash_table_foreach_remove(di_trace->stream_map,
 613                         empty_ht, NULL);
 614         g_hash_table_destroy(di_trace->stream_map);
 615
 616         /* Empty the stream state HT. */
 617         g_hash_table_foreach_remove(di_trace->stream_states,
 618                         empty_ht, NULL);
 619         g_hash_table_destroy(di_trace->stream_states);
 620
 621         /* Empty the packet HT. */
 622         g_hash_table_foreach_remove(di_trace->packet_map,
 623                         empty_ht, NULL);
 624         g_hash_table_destroy(di_trace->packet_map);
 625
 626         /* Empty the trace_debug HT. */
 627         g_hash_table_foreach_remove(di_trace->trace_debug_map,
 628                         empty_ht, NULL);
 629         g_hash_table_destroy(di_trace->trace_debug_map);
 630 }
 631
 632 static
 633 int sync_event_classes(struct debug_info_iterator *debug_it,
 634                 struct bt_ctf_stream *stream,
 635                 struct bt_ctf_stream *writer_stream)
 636 {
 637         int int_ret;
 638         struct bt_ctf_stream_class *stream_class = NULL,
 639                                    *writer_stream_class = NULL;
 640         enum bt_component_status ret;
 641
 642         stream_class = bt_ctf_stream_get_class(stream);
 643         if (!stream_class) {
 644                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
 645                                 __FILE__, __LINE__);
 646                 goto error;
 647         }
 648
 649         writer_stream_class = bt_ctf_stream_get_class(writer_stream);
 650         if (!writer_stream_class) {
 651                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
 652                                 __FILE__, __LINE__);
 653                 goto error;
 654         }
 655
 656         ret = ctf_copy_event_classes(debug_it->err, stream_class,
 657                         writer_stream_class);
 658         if (ret != BT_COMPONENT_STATUS_OK) {
 659                 goto error;
 660         }
 661
 662         int_ret = 0;
 663         goto end;
 664
 665 error:
 666         int_ret = -1;
 667 end:
 668         bt_put(stream_class);
 669         bt_put(writer_stream_class);
 670         return int_ret;
 671 }
 672
 673 static
 674 void trace_is_static_listener(struct bt_ctf_trace *trace, void *data)
 675 {
 676         struct debug_info_trace *di_trace = data;
 677         struct debug_info_iterator *debug_it = di_trace->debug_it;
 678         int trace_completed = 1, ret, nr_stream, i;
 679         struct bt_ctf_stream *stream = NULL, *writer_stream = NULL;
 680         struct bt_ctf_trace *writer_trace = di_trace->writer_trace;
 681
 682         /*
 683          * When the trace becomes static, make sure that we have all
 684          * the event classes in our stream_class copies before setting it
 685          * static as well.
 686          */
 687         nr_stream = bt_ctf_trace_get_stream_count(trace);
 688         for (i = 0; i < nr_stream; i++) {
 689                 stream = bt_ctf_trace_get_stream_by_index(trace, i);
 690                 if (!stream) {
 691                         fprintf(debug_it->err,
 692                                         "[error] %s in %s:%d\n", __func__,
 693                                         __FILE__, __LINE__);
 694                         goto error;
 695                 }
 696                 writer_stream = bt_ctf_trace_get_stream_by_index(writer_trace, i);
 697                 if (!writer_stream) {
 698                         fprintf(debug_it->err,
 699                                         "[error] %s in %s:%d\n", __func__,
 700                                         __FILE__, __LINE__);
 701                         goto error;
 702                 }
 703                 ret = sync_event_classes(di_trace->debug_it, stream, writer_stream);
 704                 if (ret) {
 705                         fprintf(debug_it->err,
 706                                         "[error] %s in %s:%d\n", __func__,
 707                                         __FILE__, __LINE__);
 708                         goto error;
 709                 }
 710                 BT_PUT(stream);
 711                 BT_PUT(writer_stream);
 712         }
 713
 714         bt_ctf_trace_set_is_static(di_trace->writer_trace);
 715         di_trace->trace_static = 1;
 716
 717         g_hash_table_foreach(di_trace->stream_states,
 718                         check_completed_trace, &trace_completed);
 719         if (trace_completed) {
 720                 debug_info_close_trace(di_trace->debug_it, di_trace);
 721                 g_hash_table_remove(di_trace->debug_it->trace_map,
 722                                 di_trace->trace);
 723         }
 724
 725 error:
 726         bt_put(writer_stream);
 727         bt_put(stream);
 728 }
 729
 730 static
 731 struct debug_info_trace *insert_new_trace(struct debug_info_iterator *debug_it,
 732                 struct bt_ctf_stream *stream) {
 733         struct bt_ctf_trace *writer_trace = NULL;
 734         struct debug_info_trace *di_trace = NULL;
 735         struct bt_ctf_trace *trace = NULL;
 736         struct bt_ctf_stream_class *stream_class = NULL;
 737         struct bt_ctf_stream *writer_stream = NULL;
 738         int ret, nr_stream, i;
 739
 740         writer_trace = bt_ctf_trace_create();
 741         if (!writer_trace) {
 742                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
 743                                 __FILE__, __LINE__);
 744                 goto error;
 745         }
 746
 747         stream_class = bt_ctf_stream_get_class(stream);
 748         if (!stream_class) {
 749                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
 750                                 __FILE__, __LINE__);
 751                 goto error;
 752         }
 753
 754         trace = bt_ctf_stream_class_get_trace(stream_class);
 755         if (!trace) {
 756                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
 757                                 __FILE__, __LINE__);
 758                 goto error;
 759         }
 760
 761         ret = ctf_copy_trace(debug_it->err, trace, writer_trace);
 762         if (ret != BT_COMPONENT_STATUS_OK) {
 763                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
 764                                 __FILE__, __LINE__);
 765                 goto error;
 766         }
 767
 768         di_trace = g_new0(struct debug_info_trace, 1);
 769         if (!di_trace) {
 770                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
 771                                 __FILE__, __LINE__);
 772                 goto error;
 773         }
 774
 775         di_trace->trace = trace;
 776         di_trace->writer_trace = writer_trace;
 777         di_trace->debug_info_component = debug_it->debug_info_component;
 778         di_trace->debug_it = debug_it;
 779         di_trace->stream_map = g_hash_table_new_full(g_direct_hash,
 780                         g_direct_equal, NULL, (GDestroyNotify) unref_stream);
 781         di_trace->stream_class_map = g_hash_table_new_full(g_direct_hash,
 782                         g_direct_equal, NULL, (GDestroyNotify) unref_stream_class);
 783         di_trace->packet_map = g_hash_table_new_full(g_direct_hash,
 784                         g_direct_equal, NULL, (GDestroyNotify) unref_packet);
 785         di_trace->trace_debug_map = g_hash_table_new_full(g_direct_hash,
 786                         g_direct_equal, NULL, (GDestroyNotify) unref_debug_info);
 787         di_trace->stream_states = g_hash_table_new_full(g_direct_hash,
 788                         g_direct_equal, NULL, destroy_stream_state_key);
 789         g_hash_table_insert(debug_it->trace_map, (gpointer) trace, di_trace);
 790
 791         /* Set all the existing streams in the unknown state. */
 792         nr_stream = bt_ctf_trace_get_stream_count(trace);
 793         for (i = 0; i < nr_stream; i++) {
 794                 stream = bt_ctf_trace_get_stream_by_index(trace, i);
 795                 if (!stream) {
 796                         fprintf(debug_it->err,
 797                                         "[error] %s in %s:%d\n", __func__,
 798                                         __FILE__, __LINE__);
 799                         goto error;
 800                 }
 801                 insert_new_stream_state(debug_it, di_trace, stream);
 802                 writer_stream = insert_new_stream(debug_it, stream, di_trace);
 803                 if (!writer_stream) {
 804                         fprintf(debug_it->err,
 805                                         "[error] %s in %s:%d\n", __func__,
 806                                         __FILE__, __LINE__);
 807                         goto error;
 808                 }
 809                 bt_get(writer_stream);
 810                 ret = sync_event_classes(debug_it, stream, writer_stream);
 811                 if (ret) {
 812                         fprintf(debug_it->err,
 813                                         "[error] %s in %s:%d\n", __func__,
 814                                         __FILE__, __LINE__);
 815                         goto error;
 816                 }
 817                 BT_PUT(writer_stream);
 818                 BT_PUT(stream);
 819         }
 820
 821         /* Check if the trace is already static or register a listener. */
 822         if (bt_ctf_trace_is_static(trace)) {
 823                 di_trace->trace_static = 1;
 824                 di_trace->static_listener_id = -1;
 825                 bt_ctf_trace_set_is_static(writer_trace);
 826         } else {
 827                 ret = bt_ctf_trace_add_is_static_listener(trace,
 828                                 trace_is_static_listener, di_trace);
 829                 if (ret < 0) {
 830                         fprintf(debug_it->err,
 831                                         "[error] %s in %s:%d\n", __func__, __FILE__,
 832                                         __LINE__);
 833                         goto error;
 834                 }
 835                 di_trace->static_listener_id = ret;
 836         }
 837
 838
 839         goto end;
 840
 841 error:
 842         BT_PUT(writer_trace);
 843         g_free(di_trace);
 844         di_trace = NULL;
 845 end:
 846         bt_put(stream);
 847         bt_put(writer_stream);
 848         bt_put(stream_class);
 849         bt_put(trace);
 850         return di_trace;
 851 }
 852
 853 static
 854 struct bt_ctf_packet *lookup_packet(struct debug_info_iterator *debug_it,
 855                 struct bt_ctf_packet *packet,
 856                 struct debug_info_trace *di_trace)
 857 {
 858         return (struct bt_ctf_packet *) g_hash_table_lookup(
 859                         di_trace->packet_map,
 860                         (gpointer) packet);
 861 }
 862
 863 static
 864 struct bt_ctf_packet *insert_new_packet(struct debug_info_iterator *debug_it,
 865                 struct bt_ctf_packet *packet,
 866                 struct bt_ctf_stream *writer_stream,
 867                 struct debug_info_trace *di_trace)
 868 {
 869         struct bt_ctf_packet *writer_packet;
 870
 871         writer_packet = bt_ctf_packet_create(writer_stream);
 872         if (!writer_packet) {
 873                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
 874                                 __FILE__, __LINE__);
 875                 goto end;
 876         }
 877         g_hash_table_insert(di_trace->packet_map, (gpointer) packet, writer_packet);
 878
 879 end:
 880         return writer_packet;
 881 }
 882
 883 static
 884 int add_debug_info_fields(FILE *err,
 885                 struct bt_ctf_field_type *writer_event_context_type,
 886                 struct debug_info_component *component)
 887 {
 888         struct bt_ctf_field_type *ip_field = NULL, *debug_field_type = NULL,
 889                                  *bin_field_type = NULL, *func_field_type = NULL,
 890                                  *src_field_type = NULL;
 891         int ret = 0;
 892
 893         ip_field = bt_ctf_field_type_structure_get_field_type_by_name(
 894                         writer_event_context_type, "_ip");
 895         /* No ip field, so no debug info. */
 896         if (!ip_field) {
 897                 goto end;
 898         }
 899         BT_PUT(ip_field);
 900
 901         debug_field_type = bt_ctf_field_type_structure_get_field_type_by_name(
 902                         writer_event_context_type,
 903                         component->arg_debug_info_field_name);
 904         /* Already existing debug_info field, no need to add it. */
 905         if (debug_field_type) {
 906                 goto end;
 907         }
 908
 909         debug_field_type = bt_ctf_field_type_structure_create();
 910         if (!debug_field_type) {
 911                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 912                                 __FILE__, __LINE__);
 913                 goto error;
 914         }
 915
 916         bin_field_type = bt_ctf_field_type_string_create();
 917         if (!bin_field_type) {
 918                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 919                                 __LINE__);
 920                 goto error;
 921         }
 922
 923         func_field_type = bt_ctf_field_type_string_create();
 924         if (!func_field_type) {
 925                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 926                                 __LINE__);
 927                 goto error;
 928         }
 929
 930         src_field_type = bt_ctf_field_type_string_create();
 931         if (!src_field_type) {
 932                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 933                                 __LINE__);
 934                 goto error;
 935         }
 936
 937         ret = bt_ctf_field_type_structure_add_field(debug_field_type,
 938                         bin_field_type, "bin");
 939         if (ret) {
 940                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 941                                 __LINE__);
 942                 goto error;
 943         }
 944
 945         ret = bt_ctf_field_type_structure_add_field(debug_field_type,
 946                         func_field_type, "func");
 947         if (ret) {
 948                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 949                                 __LINE__);
 950                 goto error;
 951         }
 952
 953         ret = bt_ctf_field_type_structure_add_field(debug_field_type,
 954                         src_field_type, "src");
 955         if (ret) {
 956                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 957                                 __LINE__);
 958                 goto error;
 959         }
 960
 961         ret = bt_ctf_field_type_structure_add_field(writer_event_context_type,
 962                         debug_field_type, component->arg_debug_info_field_name);
 963         if (ret) {
 964                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 965                                 __LINE__);
 966                 goto error;
 967         }
 968
 969         ret = 0;
 970         goto end;
 971
 972 error:
 973         BT_PUT(debug_field_type);
 974         ret = -1;
 975 end:
 976         bt_put(src_field_type);
 977         bt_put(func_field_type);
 978         bt_put(bin_field_type);
 979         bt_put(debug_field_type);
 980         return ret;
 981 }
 982
 983 static
 984 int create_debug_info_event_context_type(FILE *err,
 985                 struct bt_ctf_field_type *event_context_type,
 986                 struct bt_ctf_field_type *writer_event_context_type,
 987                 struct debug_info_component *component)
 988 {
 989         int ret, nr_fields, i;
 990
 991         nr_fields = bt_ctf_field_type_structure_get_field_count(event_context_type);
 992         for (i = 0; i < nr_fields; i++) {
 993                 struct bt_ctf_field_type *field_type = NULL;
 994                 const char *field_name;
 995
 996                 if (bt_ctf_field_type_structure_get_field(event_context_type,
 997                                         &field_name, &field_type, i) < 0) {
 998                         fprintf(err, "[error] %s in %s:%d\n", __func__,
 999                                         __FILE__, __LINE__);
1000                         goto error;
1001                 }
1002
1003                 ret = bt_ctf_field_type_structure_add_field(writer_event_context_type,
1004                                 field_type, field_name);
1005                 BT_PUT(field_type);
1006                 if (ret) {
1007                         fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1008                                         __LINE__);
1009                         goto error;
1010                 }
1011         }
1012
1013         ret = add_debug_info_fields(err, writer_event_context_type,
1014                         component);
1015         goto end;
1016
1017 error:
1018         ret = -1;
1019 end:
1020         return ret;
1021 }
1022
1023 static
1024 struct bt_ctf_stream_class *copy_stream_class_debug_info(FILE *err,
1025                 struct bt_ctf_stream_class *stream_class,
1026                 struct bt_ctf_trace *writer_trace,
1027                 struct debug_info_component *component)
1028 {
1029         struct bt_ctf_field_type *type = NULL;
1030         struct bt_ctf_stream_class *writer_stream_class = NULL;
1031         struct bt_ctf_field_type *writer_event_context_type = NULL;
1032         int ret_int;
1033         const char *name = bt_ctf_stream_class_get_name(stream_class);
1034
1035         if (strlen(name) == 0) {
1036                 name = NULL;
1037         }
1038
1039         writer_stream_class = bt_ctf_stream_class_create_empty(name);
1040         if (!writer_stream_class) {
1041                 fprintf(err, "[error] %s in %s:%d\n",
1042                                 __func__, __FILE__, __LINE__);
1043                 goto error;
1044         }
1045
1046         type = bt_ctf_stream_class_get_packet_context_type(stream_class);
1047         if (type) {
1048                 ret_int = bt_ctf_stream_class_set_packet_context_type(
1049                                 writer_stream_class, type);
1050                 if (ret_int < 0) {
1051                         fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1052                                         __LINE__);
1053                         goto error;
1054                 }
1055                 BT_PUT(type);
1056         }
1057
1058         type = bt_ctf_stream_class_get_event_header_type(stream_class);
1059         if (type) {
1060                 ret_int = bt_ctf_stream_class_set_event_header_type(
1061                                 writer_stream_class, type);
1062                 if (ret_int < 0) {
1063                         fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1064                                         __LINE__);
1065                         goto error;
1066                 }
1067                 BT_PUT(type);
1068         }
1069
1070         type = bt_ctf_stream_class_get_event_context_type(stream_class);
1071         if (type) {
1072                 writer_event_context_type = bt_ctf_field_type_structure_create();
1073                 if (!writer_event_context_type) {
1074                         fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1075                                         __LINE__);
1076                         goto error;
1077                 }
1078                 ret_int = create_debug_info_event_context_type(err, type,
1079                                 writer_event_context_type, component);
1080                 if (ret_int) {
1081                         fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1082                                         __LINE__);
1083                         goto error;
1084                 }
1085                 BT_PUT(type);
1086
1087                 ret_int = bt_ctf_stream_class_set_event_context_type(
1088                                 writer_stream_class, writer_event_context_type);
1089                 if (ret_int < 0) {
1090                         fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1091                                         __LINE__);
1092                         goto error;
1093                 }
1094                 BT_PUT(writer_event_context_type);
1095         }
1096
1097         goto end;
1098
1099 error:
1100         BT_PUT(writer_stream_class);
1101 end:
1102         bt_put(writer_event_context_type);
1103         bt_put(type);
1104         return writer_stream_class;
1105 }
1106
1107 /*
1108  * Add the original clock classes to the new trace, we do not need to copy
1109  * them, and if we did, we would have to manually inspect the stream class
1110  * to update the integers mapping to a clock.
1111  */
1112 static
1113 int add_clock_classes(FILE *err, struct bt_ctf_trace *writer_trace,
1114                 struct bt_ctf_stream_class *writer_stream_class,
1115                 struct bt_ctf_trace *trace)
1116 {
1117         int ret, clock_class_count, i;
1118
1119         clock_class_count = bt_ctf_trace_get_clock_class_count(trace);
1120
1121         for (i = 0; i < clock_class_count; i++) {
1122                 struct bt_ctf_clock_class *clock_class =
1123                         bt_ctf_trace_get_clock_class_by_index(trace, i);
1124
1125                 if (!clock_class) {
1126                         fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1127                                         __LINE__);
1128                         goto error;
1129                 }
1130
1131                 ret = bt_ctf_trace_add_clock_class(writer_trace, clock_class);
1132                 BT_PUT(clock_class);
1133                 if (ret != 0) {
1134                         fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1135                                         __LINE__);
1136                         goto error;
1137                 }
1138         }
1139
1140         ret = 0;
1141         goto end;
1142
1143 error:
1144         ret = -1;
1145 end:
1146         return ret;
1147
1148 }
1149
1150 static
1151 struct bt_ctf_stream_class *insert_new_stream_class(
1152                 struct debug_info_iterator *debug_it,
1153                 struct bt_ctf_stream_class *stream_class)
1154 {
1155         struct bt_ctf_stream_class *writer_stream_class = NULL;
1156         struct bt_ctf_trace *trace, *writer_trace = NULL;
1157         struct debug_info_trace *di_trace;
1158         enum bt_component_status ret;
1159         int int_ret;
1160
1161         trace = bt_ctf_stream_class_get_trace(stream_class);
1162         if (!trace) {
1163                 fprintf(debug_it->err,
1164                                 "[error] %s in %s:%d\n", __func__, __FILE__,
1165                                 __LINE__);
1166                 goto error;
1167         }
1168
1169         di_trace = lookup_trace(debug_it, trace);
1170         if (!di_trace) {
1171                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
1172                                 __FILE__, __LINE__);
1173                 ret = BT_COMPONENT_STATUS_ERROR;
1174                 goto error;
1175         }
1176         writer_trace = di_trace->writer_trace;
1177         bt_get(writer_trace);
1178
1179         writer_stream_class = copy_stream_class_debug_info(debug_it->err, stream_class,
1180                         writer_trace, debug_it->debug_info_component);
1181         if (!writer_stream_class) {
1182                 fprintf(debug_it->err, "[error] Failed to copy stream class\n");
1183                 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1184                                 __func__, __FILE__, __LINE__);
1185                 goto error;
1186         }
1187
1188         int_ret = bt_ctf_trace_add_stream_class(writer_trace, writer_stream_class);
1189         if (int_ret) {
1190                 fprintf(debug_it->err,
1191                                 "[error] %s in %s:%d\n", __func__, __FILE__,
1192                                 __LINE__);
1193                 goto error;
1194         }
1195
1196         ret = add_clock_classes(debug_it->err, writer_trace,
1197                         writer_stream_class, trace);
1198         if (ret != BT_COMPONENT_STATUS_OK) {
1199                 fprintf(debug_it->err,
1200                                 "[error] %s in %s:%d\n", __func__, __FILE__,
1201                                 __LINE__);
1202                 goto error;
1203         }
1204
1205         g_hash_table_insert(di_trace->stream_class_map,
1206                         (gpointer) stream_class, writer_stream_class);
1207
1208         goto end;
1209
1210 error:
1211         BT_PUT(writer_stream_class);
1212 end:
1213         bt_put(trace);
1214         bt_put(writer_trace);
1215         return writer_stream_class;
1216 }
1217
1218 static
1219 struct bt_ctf_stream *insert_new_stream(
1220                 struct debug_info_iterator *debug_it,
1221                 struct bt_ctf_stream *stream,
1222                 struct debug_info_trace *di_trace)
1223 {
1224         struct bt_ctf_stream *writer_stream = NULL;
1225         struct bt_ctf_stream_class *stream_class = NULL;
1226         struct bt_ctf_stream_class *writer_stream_class = NULL;
1227
1228         stream_class = bt_ctf_stream_get_class(stream);
1229         if (!stream_class) {
1230                 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1231                                 __func__, __FILE__, __LINE__);
1232                 goto error;
1233         }
1234
1235         writer_stream_class = g_hash_table_lookup(
1236                         di_trace->stream_class_map,
1237                         (gpointer) stream_class);
1238
1239         if (!writer_stream_class) {
1240                 writer_stream_class = insert_new_stream_class(debug_it,
1241                                 stream_class);
1242                 if (!writer_stream_class) {
1243                         fprintf(debug_it->err, "[error] %s in %s:%d\n",
1244                                         __func__, __FILE__, __LINE__);
1245                         goto error;
1246                 }
1247         }
1248         bt_get(writer_stream_class);
1249
1250         writer_stream = bt_ctf_stream_create(writer_stream_class,
1251                         bt_ctf_stream_get_name(stream));
1252         if (!writer_stream) {
1253                 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1254                                 __func__, __FILE__, __LINE__);
1255                 goto error;
1256         }
1257
1258         g_hash_table_insert(di_trace->stream_map, (gpointer) stream,
1259                         writer_stream);
1260
1261         goto end;
1262
1263 error:
1264         BT_PUT(writer_stream);
1265 end:
1266         bt_put(stream_class);
1267         bt_put(writer_stream_class);
1268         return writer_stream;
1269 }
1270
1271 static
1272 struct bt_ctf_stream *lookup_stream(struct debug_info_iterator *debug_it,
1273                 struct bt_ctf_stream *stream,
1274                 struct debug_info_trace *di_trace)
1275 {
1276         return (struct bt_ctf_stream *) g_hash_table_lookup(
1277                         di_trace->stream_map, (gpointer) stream);
1278 }
1279
1280 static
1281 struct bt_ctf_event_class *get_event_class(struct debug_info_iterator *debug_it,
1282                 struct bt_ctf_stream_class *writer_stream_class,
1283                 struct bt_ctf_event_class *event_class)
1284 {
1285         return bt_ctf_stream_class_get_event_class_by_id(writer_stream_class,
1286                         bt_ctf_event_class_get_id(event_class));
1287 }
1288
1289 static
1290 struct debug_info_trace *lookup_di_trace_from_stream(
1291                 struct debug_info_iterator *debug_it,
1292                 struct bt_ctf_stream *stream)
1293 {
1294         struct bt_ctf_stream_class *stream_class = NULL;
1295         struct bt_ctf_trace *trace = NULL;
1296         struct debug_info_trace *di_trace = NULL;
1297
1298         stream_class = bt_ctf_stream_get_class(stream);
1299         if (!stream_class) {
1300                 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1301                                 __func__, __FILE__, __LINE__);
1302                 goto end;
1303         }
1304
1305         trace = bt_ctf_stream_class_get_trace(stream_class);
1306         if (!trace) {
1307                 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1308                                 __func__, __FILE__, __LINE__);
1309                 goto end;
1310         }
1311
1312         di_trace = (struct debug_info_trace *) g_hash_table_lookup(
1313                         debug_it->trace_map, (gpointer) trace);
1314
1315 end:
1316         BT_PUT(stream_class);
1317         BT_PUT(trace);
1318         return di_trace;
1319 }
1320
1321 static
1322 struct bt_ctf_stream *get_writer_stream(
1323                 struct debug_info_iterator *debug_it,
1324                 struct bt_ctf_packet *packet, struct bt_ctf_stream *stream)
1325 {
1326         struct bt_ctf_stream_class *stream_class = NULL;
1327         struct bt_ctf_stream *writer_stream = NULL;
1328         struct debug_info_trace *di_trace = NULL;
1329
1330         stream_class = bt_ctf_stream_get_class(stream);
1331         if (!stream_class) {
1332                 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1333                                 __func__, __FILE__, __LINE__);
1334                 goto error;
1335         }
1336
1337         di_trace = lookup_di_trace_from_stream(debug_it, stream);
1338         if (!di_trace) {
1339                 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1340                                 __func__, __FILE__, __LINE__);
1341                 goto error;
1342         }
1343
1344         writer_stream = lookup_stream(debug_it, stream, di_trace);
1345         if (!writer_stream) {
1346                 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1347                                 __func__, __FILE__, __LINE__);
1348                 goto error;
1349         }
1350         bt_get(writer_stream);
1351
1352         goto end;
1353
1354 error:
1355         BT_PUT(writer_stream);
1356 end:
1357         bt_put(stream_class);
1358         return writer_stream;
1359 }
1360
1361 BT_HIDDEN
1362 struct bt_ctf_packet *debug_info_new_packet(
1363                 struct debug_info_iterator *debug_it,
1364                 struct bt_ctf_packet *packet)
1365 {
1366         struct bt_ctf_stream *stream = NULL, *writer_stream = NULL;
1367         struct bt_ctf_packet *writer_packet = NULL;
1368         struct bt_ctf_field *packet_context = NULL;
1369         struct debug_info_trace *di_trace;
1370         int int_ret;
1371
1372         stream = bt_ctf_packet_get_stream(packet);
1373         if (!stream) {
1374                 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1375                                 __func__, __FILE__, __LINE__);
1376                 goto error;
1377         }
1378
1379         writer_stream = get_writer_stream(debug_it, packet, stream);
1380         if (!writer_stream) {
1381                 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1382                                 __func__, __FILE__, __LINE__);
1383                 goto error;
1384         }
1385
1386         di_trace = lookup_di_trace_from_stream(debug_it, stream);
1387         if (!di_trace) {
1388                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
1389                                 __FILE__, __LINE__);
1390                 goto error;
1391         }
1392
1393         /*
1394          * If a packet was already opened, close it and remove it from
1395          * the HT.
1396          */
1397         writer_packet = lookup_packet(debug_it, packet, di_trace);
1398         if (writer_packet) {
1399                 g_hash_table_remove(di_trace->packet_map, packet);
1400                 BT_PUT(writer_packet);
1401         }
1402
1403         writer_packet = insert_new_packet(debug_it, packet, writer_stream,
1404                         di_trace);
1405         if (!writer_packet) {
1406                 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1407                                 __func__, __FILE__, __LINE__);
1408                 goto error;
1409         }
1410
1411         packet_context = bt_ctf_packet_get_context(packet);
1412         if (packet_context) {
1413                 int_ret = ctf_packet_copy_context(debug_it->err,
1414                                 packet, writer_stream, writer_packet);
1415                 if (int_ret < 0) {
1416                         fprintf(debug_it->err, "[error] %s in %s:%d\n",
1417                                         __func__, __FILE__, __LINE__);
1418                         goto error;
1419                 }
1420                 BT_PUT(packet_context);
1421         }
1422
1423         bt_get(writer_packet);
1424         goto end;
1425
1426 error:
1427
1428 end:
1429         bt_put(packet_context);
1430         bt_put(writer_stream);
1431         bt_put(stream);
1432         return writer_packet;
1433 }
1434
1435 BT_HIDDEN
1436 struct bt_ctf_packet *debug_info_close_packet(
1437                 struct debug_info_iterator *debug_it,
1438                 struct bt_ctf_packet *packet)
1439 {
1440         struct bt_ctf_packet *writer_packet = NULL;
1441         struct bt_ctf_stream *stream = NULL;
1442         struct debug_info_trace *di_trace;
1443
1444         stream = bt_ctf_packet_get_stream(packet);
1445         if (!stream) {
1446                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
1447                                 __FILE__, __LINE__);
1448                 goto end;
1449         }
1450
1451         di_trace = lookup_di_trace_from_stream(debug_it, stream);
1452         if (!di_trace) {
1453                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
1454                                 __FILE__, __LINE__);
1455                 goto end;
1456         }
1457
1458         writer_packet = lookup_packet(debug_it, packet, di_trace);
1459         if (!writer_packet) {
1460                 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1461                                 __func__, __FILE__, __LINE__);
1462                 goto end;
1463         }
1464         bt_get(writer_packet);
1465         g_hash_table_remove(di_trace->packet_map, packet);
1466
1467 end:
1468         bt_put(stream);
1469         return writer_packet;
1470 }
1471
1472 BT_HIDDEN
1473 struct bt_ctf_stream *debug_info_stream_begin(
1474                 struct debug_info_iterator *debug_it,
1475                 struct bt_ctf_stream *stream)
1476 {
1477         struct bt_ctf_stream *writer_stream = NULL;
1478         enum debug_info_stream_state *state;
1479         struct debug_info_trace *di_trace = NULL;
1480
1481         di_trace = lookup_di_trace_from_stream(debug_it, stream);
1482         if (!di_trace) {
1483                 di_trace = insert_new_trace(debug_it, stream);
1484                 if (!di_trace) {
1485                         fprintf(debug_it->err, "[error] %s in %s:%d\n",
1486                                         __func__, __FILE__, __LINE__);
1487                         goto error;
1488                 }
1489         }
1490
1491         /* Set the stream as active */
1492         state = g_hash_table_lookup(di_trace->stream_states, stream);
1493         if (!state) {
1494                 if (di_trace->trace_static) {
1495                         fprintf(debug_it->err, "[error] Adding a new stream "
1496                                         "on a static trace\n");
1497                         goto error;
1498                 }
1499                 state = insert_new_stream_state(debug_it, di_trace,
1500                                 stream);
1501                 if (!state) {
1502                         fprintf(debug_it->err, "[error] Adding a new stream "
1503                                         "on a static trace\n");
1504                         goto error;
1505                 }
1506         }
1507         if (*state != DEBUG_INFO_UNKNOWN_STREAM) {
1508                 fprintf(debug_it->err, "[error] Unexpected stream state %d\n",
1509                                 *state);
1510                 goto error;
1511         }
1512         *state = DEBUG_INFO_ACTIVE_STREAM;
1513
1514         writer_stream = lookup_stream(debug_it, stream, di_trace);
1515         if (!writer_stream) {
1516                 writer_stream = insert_new_stream(debug_it, stream, di_trace);
1517         }
1518         bt_get(writer_stream);
1519
1520         goto end;
1521
1522 error:
1523         BT_PUT(writer_stream);
1524 end:
1525         return writer_stream;
1526 }
1527
1528 BT_HIDDEN
1529 struct bt_ctf_stream *debug_info_stream_end(struct debug_info_iterator *debug_it,
1530                 struct bt_ctf_stream *stream)
1531 {
1532         struct bt_ctf_stream *writer_stream = NULL;
1533         struct debug_info_trace *di_trace = NULL;
1534         enum debug_info_stream_state *state;
1535
1536         di_trace = lookup_di_trace_from_stream(debug_it, stream);
1537         if (!di_trace) {
1538                 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1539                                 __func__, __FILE__, __LINE__);
1540                 goto error;
1541         }
1542
1543         writer_stream = lookup_stream(debug_it, stream, di_trace);
1544         if (!writer_stream) {
1545                 fprintf(debug_it->err, "[error] %s in %s:%d\n",
1546                                 __func__, __FILE__, __LINE__);
1547                 goto error;
1548         }
1549         /*
1550          * Take the ref on the stream and keep it until the notification
1551          * is created.
1552          */
1553         bt_get(writer_stream);
1554
1555         state = g_hash_table_lookup(di_trace->stream_states, stream);
1556         if (*state != DEBUG_INFO_ACTIVE_STREAM) {
1557                 fprintf(debug_it->err, "[error] Unexpected stream "
1558                                 "state %d\n", *state);
1559                 goto error;
1560         }
1561         *state = DEBUG_INFO_COMPLETED_STREAM;
1562
1563         g_hash_table_remove(di_trace->stream_map, stream);
1564
1565         if (di_trace->trace_static) {
1566                 int trace_completed = 1;
1567
1568                 g_hash_table_foreach(di_trace->stream_states,
1569                                 check_completed_trace, &trace_completed);
1570                 if (trace_completed) {
1571                         debug_info_close_trace(debug_it, di_trace);
1572                         g_hash_table_remove(debug_it->trace_map,
1573                                         di_trace->trace);
1574                 }
1575         }
1576
1577         goto end;
1578
1579 error:
1580         BT_PUT(writer_stream);
1581
1582 end:
1583         return writer_stream;
1584 }
1585
1586 static
1587 struct debug_info_source *lookup_debug_info(FILE *err,
1588                 struct bt_ctf_event *event,
1589                 struct debug_info *debug_info)
1590 {
1591         int64_t vpid;
1592         uint64_t ip;
1593         struct debug_info_source *dbg_info_src = NULL;
1594         int ret;
1595
1596         ret = get_stream_event_context_int_field_value(err, event,
1597                         "_vpid", &vpid);
1598         if (ret) {
1599                 goto end;
1600         }
1601
1602         ret = get_stream_event_context_unsigned_int_field_value(err, event,
1603                         "_ip", &ip);
1604         if (ret) {
1605                 goto end;
1606         }
1607
1608         /* Get debug info for this context. */
1609         dbg_info_src = debug_info_query(debug_info, vpid, ip);
1610
1611 end:
1612         return dbg_info_src;
1613 }
1614
1615 static
1616 int set_debug_info_field(FILE *err, struct bt_ctf_field *debug_field,
1617                 struct debug_info_source *dbg_info_src,
1618                 struct debug_info_component *component)
1619 {
1620         int i, nr_fields, ret = 0;
1621         struct bt_ctf_field_type *debug_field_type = NULL;
1622         struct bt_ctf_field *field = NULL;
1623         struct bt_ctf_field_type *field_type = NULL;
1624
1625         debug_field_type = bt_ctf_field_get_type(debug_field);
1626         if (!debug_field_type) {
1627                 fprintf(err, "[error] %s in %s:%d\n", __func__,
1628                                 __FILE__, __LINE__);
1629                 goto error;
1630         }
1631
1632         nr_fields = bt_ctf_field_type_structure_get_field_count(debug_field_type);
1633         for (i = 0; i < nr_fields; i++) {
1634                 const char *field_name;
1635
1636                 if (bt_ctf_field_type_structure_get_field(debug_field_type,
1637                                         &field_name, &field_type, i) < 0) {
1638                         fprintf(err, "[error] %s in %s:%d\n", __func__,
1639                                         __FILE__, __LINE__);
1640                         goto error;
1641                 }
1642                 BT_PUT(field_type);
1643
1644                 field = bt_ctf_field_structure_get_field_by_index(debug_field, i);
1645                 if (!strcmp(field_name, "bin")) {
1646                         if (dbg_info_src && dbg_info_src->bin_path) {
1647                                 GString *tmp = g_string_new(NULL);
1648
1649                                 if (component->arg_full_path) {
1650                                         g_string_printf(tmp, "%s%s",
1651                                                         dbg_info_src->bin_path,
1652                                                         dbg_info_src->bin_loc);
1653                                 } else {
1654                                         g_string_printf(tmp, "%s%s",
1655                                                         dbg_info_src->short_bin_path,
1656                                                         dbg_info_src->bin_loc);
1657                                 }
1658                                 ret = bt_ctf_field_string_set_value(field, tmp->str);
1659                                 g_string_free(tmp, true);
1660                         } else {
1661                                 ret = bt_ctf_field_string_set_value(field, "");
1662                         }
1663                 } else if (!strcmp(field_name, "func")) {
1664                         if (dbg_info_src && dbg_info_src->func) {
1665                                 ret = bt_ctf_field_string_set_value(field,
1666                                                 dbg_info_src->func);
1667                         } else {
1668                                 ret = bt_ctf_field_string_set_value(field, "");
1669                         }
1670                 } else if (!strcmp(field_name, "src")) {
1671                         if (dbg_info_src && dbg_info_src->src_path) {
1672                                 GString *tmp = g_string_new(NULL);
1673
1674                                 if (component->arg_full_path) {
1675                                         g_string_printf(tmp, "%s:%" PRId64,
1676                                                         dbg_info_src->src_path,
1677                                                         dbg_info_src->line_no);
1678                                 } else {
1679                                         g_string_printf(tmp, "%s:%" PRId64,
1680                                                         dbg_info_src->short_src_path,
1681                                                         dbg_info_src->line_no);
1682                                 }
1683                                 ret = bt_ctf_field_string_set_value(field, tmp->str);
1684                                 g_string_free(tmp, true);
1685                         } else {
1686                                 ret = bt_ctf_field_string_set_value(field, "");
1687                         }
1688                 }
1689                 BT_PUT(field);
1690                 if (ret) {
1691                         fprintf(err, "[error] %s in %s:%d\n", __func__,
1692                                         __FILE__, __LINE__);
1693                         goto error;
1694                 }
1695         }
1696         ret = 0;
1697         goto end;
1698
1699 error:
1700         ret = -1;
1701 end:
1702         bt_put(field_type);
1703         bt_put(field);
1704         bt_put(debug_field_type);
1705         return ret;
1706 }
1707
1708 static
1709 int copy_set_debug_info_stream_event_context(FILE *err,
1710                 struct bt_ctf_field *event_context,
1711                 struct bt_ctf_event *event,
1712                 struct bt_ctf_event *writer_event,
1713                 struct debug_info *debug_info,
1714                 struct debug_info_component *component)
1715 {
1716         struct bt_ctf_field_type *writer_event_context_type = NULL,
1717                                  *event_context_type = NULL;
1718         struct bt_ctf_field *writer_event_context = NULL;
1719         struct bt_ctf_field *field = NULL, *copy_field = NULL, *debug_field = NULL;
1720         struct bt_ctf_field_type *field_type = NULL;
1721         struct debug_info_source *dbg_info_src;
1722         int ret, nr_fields, i;
1723
1724         writer_event_context = bt_ctf_event_get_stream_event_context(writer_event);
1725         if (!writer_event_context) {
1726                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
1727                 goto error;
1728         }
1729
1730         writer_event_context_type = bt_ctf_field_get_type(writer_event_context);
1731         if (!writer_event_context_type) {
1732                 fprintf(err, "[error] %s in %s:%d\n", __func__,
1733                                 __FILE__, __LINE__);
1734                 goto error;
1735         }
1736
1737         event_context_type = bt_ctf_field_get_type(event_context);
1738         if (!event_context_type) {
1739                 fprintf(err, "[error] %s in %s:%d\n", __func__,
1740                                 __FILE__, __LINE__);
1741                 goto error;
1742         }
1743
1744         /*
1745          * If it is not a structure, we did not modify it to add the debug info
1746          * fields, so just assign it as is.
1747          */
1748         if (bt_ctf_field_type_get_type_id(writer_event_context_type) != BT_CTF_FIELD_TYPE_ID_STRUCT) {
1749                 ret = bt_ctf_event_set_event_context(writer_event, event_context);
1750                 goto end;
1751         }
1752
1753         dbg_info_src = lookup_debug_info(err, event, debug_info);
1754
1755         nr_fields = bt_ctf_field_type_structure_get_field_count(writer_event_context_type);
1756         for (i = 0; i < nr_fields; i++) {
1757                 const char *field_name;
1758
1759                 if (bt_ctf_field_type_structure_get_field(writer_event_context_type,
1760                                         &field_name, &field_type, i) < 0) {
1761                         fprintf(err, "[error] %s in %s:%d\n", __func__,
1762                                         __FILE__, __LINE__);
1763                         goto error;
1764                 }
1765
1766                 /*
1767                  * Prevent illegal access in the event_context.
1768                  */
1769                 if (i < bt_ctf_field_type_structure_get_field_count(event_context_type)) {
1770                         field = bt_ctf_field_structure_get_field_by_index(event_context, i);
1771                 }
1772                 /*
1773                  * The debug_info field, only exists in the writer event or
1774                  * if it was set by a earlier pass of the debug_info plugin.
1775                  */
1776                 if (!strcmp(field_name, component->arg_debug_info_field_name) &&
1777                                 !field) {
1778                         debug_field = bt_ctf_field_structure_get_field_by_index(
1779                                         writer_event_context, i);
1780                         if (!debug_field) {
1781                                 fprintf(err, "[error] %s in %s:%d\n", __func__,
1782                                                 __FILE__, __LINE__);
1783                                 goto error;
1784                         }
1785                         ret = set_debug_info_field(err, debug_field,
1786                                         dbg_info_src, component);
1787                         if (ret) {
1788                                 fprintf(err, "[error] %s in %s:%d\n", __func__,
1789                                                 __FILE__, __LINE__);
1790                                 goto error;
1791                         }
1792                         BT_PUT(debug_field);
1793                 } else {
1794                         copy_field = bt_ctf_field_copy(field);
1795                         if (!copy_field) {
1796                                 fprintf(err, "[error] %s in %s:%d\n", __func__,
1797                                                 __FILE__, __LINE__);
1798                                 goto error;
1799                         }
1800
1801                         ret = bt_ctf_field_structure_set_field_by_name(
1802                                         writer_event_context,
1803                                         field_name, copy_field);
1804                         if (ret) {
1805                                 fprintf(err, "[error] %s in %s:%d\n", __func__,
1806                                                 __FILE__, __LINE__);
1807                                 goto error;
1808                         }
1809                         BT_PUT(copy_field);
1810                 }
1811                 BT_PUT(field_type);
1812                 BT_PUT(field);
1813         }
1814
1815         ret = 0;
1816         goto end;
1817
1818 error:
1819         ret = -1;
1820 end:
1821         bt_put(event_context_type);
1822         bt_put(writer_event_context_type);
1823         bt_put(writer_event_context);
1824         bt_put(field);
1825         bt_put(copy_field);
1826         bt_put(debug_field);
1827         bt_put(field_type);
1828         return ret;
1829 }
1830
1831 static
1832 struct bt_ctf_clock_class *stream_class_get_clock_class(FILE *err,
1833                 struct bt_ctf_stream_class *stream_class)
1834 {
1835         struct bt_ctf_trace *trace = NULL;
1836         struct bt_ctf_clock_class *clock_class = NULL;
1837
1838         trace = bt_ctf_stream_class_get_trace(stream_class);
1839         if (!trace) {
1840                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1841                                 __LINE__);
1842                 goto end;
1843         }
1844
1845         if (!bt_ctf_trace_get_clock_class_count(trace)) {
1846                 /* No clock. */
1847                 goto end;
1848         }
1849
1850         /* FIXME multi-clock? */
1851         clock_class = bt_ctf_trace_get_clock_class_by_index(trace, 0);
1852
1853         bt_put(trace);
1854
1855 end:
1856         return clock_class;
1857 }
1858
1859 static
1860 struct bt_ctf_clock_class *event_get_clock_class(FILE *err, struct bt_ctf_event *event)
1861 {
1862         struct bt_ctf_event_class *event_class = NULL;
1863         struct bt_ctf_stream_class *stream_class = NULL;
1864         struct bt_ctf_clock_class *clock_class = NULL;
1865
1866         event_class = bt_ctf_event_get_class(event);
1867         if (!event_class) {
1868                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1869                                 __LINE__);
1870                 goto error;
1871         }
1872
1873         stream_class = bt_ctf_event_class_get_stream_class(event_class);
1874         if (!stream_class) {
1875                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1876                                 __LINE__);
1877                 goto error;
1878         }
1879
1880         clock_class = stream_class_get_clock_class(err, stream_class);
1881         goto end;
1882
1883 error:
1884         BT_PUT(clock_class);
1885 end:
1886         bt_put(stream_class);
1887         bt_put(event_class);
1888         return clock_class;
1889 }
1890
1891 static
1892 int set_event_clock_value(FILE *err, struct bt_ctf_event *event,
1893                 struct bt_ctf_event *writer_event)
1894 {
1895         struct bt_ctf_clock_class *clock_class = NULL;
1896         struct bt_ctf_clock_value *clock_value = NULL;
1897         int ret = 0;
1898
1899         clock_class = event_get_clock_class(err, event);
1900         if (!clock_class) {
1901                 /* No clock on input trace. */
1902                 goto end;
1903         }
1904
1905         clock_value = bt_ctf_event_get_clock_value(event, clock_class);
1906         if (!clock_value) {
1907                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1908                                 __LINE__);
1909                 goto error;
1910         }
1911
1912         /*
1913          * We share the same clocks, so we can assign the clock value to the
1914          * writer event.
1915          */
1916         ret = bt_ctf_event_set_clock_value(writer_event, clock_value);
1917         if (ret) {
1918                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1919                                 __LINE__);
1920                 goto error;
1921         }
1922
1923         ret = 0;
1924         goto end;
1925
1926 error:
1927         ret = -1;
1928 end:
1929         bt_put(clock_class);
1930         bt_put(clock_value);
1931         return ret;
1932 }
1933
1934 static
1935 struct bt_ctf_event *debug_info_copy_event(FILE *err, struct bt_ctf_event *event,
1936                 struct bt_ctf_event_class *writer_event_class,
1937                 struct debug_info *debug_info,
1938                 struct debug_info_component *component)
1939 {
1940         struct bt_ctf_event *writer_event = NULL;
1941         struct bt_ctf_field *field = NULL, *copy_field = NULL;
1942         int ret;
1943
1944         writer_event = bt_ctf_event_create(writer_event_class);
1945         if (!writer_event) {
1946                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1947                                 __LINE__);
1948                 goto error;
1949         }
1950
1951         ret = set_event_clock_value(err, event, writer_event);
1952         if (ret) {
1953                 fprintf(err, "[error] %s in %s:%d\n", __func__,
1954                                 __FILE__, __LINE__);
1955                 goto error;
1956         }
1957
1958         /* Optional field, so it can fail silently. */
1959         field = bt_ctf_event_get_header(event);
1960         if (field) {
1961                 ret = ctf_copy_event_header(err, event, writer_event_class,
1962                                 writer_event, field);
1963                 if (ret) {
1964                         fprintf(err, "[error] %s in %s:%d\n", __func__,
1965                                         __FILE__, __LINE__);
1966                         goto error;
1967                 }
1968                 BT_PUT(field);
1969         }
1970
1971         /* Optional field, so it can fail silently. */
1972         field = bt_ctf_event_get_stream_event_context(event);
1973         if (field) {
1974                 ret = copy_set_debug_info_stream_event_context(err,
1975                                 field, event, writer_event, debug_info,
1976                                 component);
1977                 if (ret < 0) {
1978                         fprintf(err, "[error] %s in %s:%d\n", __func__,
1979                                         __FILE__, __LINE__);
1980                         goto error;
1981                 }
1982                 BT_PUT(field);
1983         }
1984
1985         /* Optional field, so it can fail silently. */
1986         field = bt_ctf_event_get_event_context(event);
1987         if (field) {
1988                 copy_field = bt_ctf_field_copy(field);
1989                 if (!copy_field) {
1990                         fprintf(err, "[error] %s in %s:%d\n", __func__,
1991                                         __FILE__, __LINE__);
1992                         goto error;
1993                 }
1994                 ret = bt_ctf_event_set_event_context(writer_event, copy_field);
1995                 if (ret < 0) {
1996                         fprintf(err, "[error] %s in %s:%d\n", __func__,
1997                                         __FILE__, __LINE__);
1998                         goto error;
1999                 }
2000                 BT_PUT(copy_field);
2001                 BT_PUT(field);
2002         }
2003
2004         field = bt_ctf_event_get_event_payload(event);
2005         if (!field) {
2006                 fprintf(err, "[error] %s in %s:%d\n", __func__,
2007                                 __FILE__, __LINE__);
2008                 goto error;
2009         }
2010         copy_field = bt_ctf_field_copy(field);
2011         if (copy_field) {
2012                 ret = bt_ctf_event_set_event_payload(writer_event, copy_field);
2013                 if (ret < 0) {
2014                         fprintf(err, "[error] %s in %s:%d\n", __func__,
2015                                         __FILE__, __LINE__);
2016                         goto error;
2017                 }
2018                 BT_PUT(copy_field);
2019         }
2020         BT_PUT(field);
2021
2022         goto end;
2023
2024 error:
2025         BT_PUT(writer_event);
2026 end:
2027         bt_put(copy_field);
2028         bt_put(field);
2029         return writer_event;
2030 }
2031
2032 BT_HIDDEN
2033 struct bt_ctf_event *debug_info_output_event(
2034                 struct debug_info_iterator *debug_it,
2035                 struct bt_ctf_event *event)
2036 {
2037         struct bt_ctf_event_class *event_class = NULL, *writer_event_class = NULL;
2038         struct bt_ctf_stream_class *stream_class = NULL, *writer_stream_class = NULL;
2039         struct bt_ctf_event *writer_event = NULL;
2040         struct bt_ctf_packet *packet = NULL, *writer_packet = NULL;
2041         struct bt_ctf_trace *writer_trace = NULL;
2042         struct bt_ctf_stream *stream = NULL;
2043         struct debug_info_trace *di_trace;
2044         struct debug_info *debug_info;
2045         const char *event_name;
2046         int int_ret;
2047
2048         event_class = bt_ctf_event_get_class(event);
2049         if (!event_class) {
2050                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2051                                 __FILE__, __LINE__);
2052                 goto error;
2053         }
2054
2055         event_name = bt_ctf_event_class_get_name(event_class);
2056         if (!event_name) {
2057                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2058                                 __FILE__, __LINE__);
2059                 goto error;
2060         }
2061
2062         stream_class = bt_ctf_event_class_get_stream_class(event_class);
2063         if (!stream_class) {
2064                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2065                                 __FILE__, __LINE__);
2066                 goto error;
2067         }
2068         stream = bt_ctf_event_get_stream(event);
2069         if (!stream) {
2070                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2071                                 __FILE__, __LINE__);
2072                 goto error;
2073         }
2074         di_trace = lookup_di_trace_from_stream(debug_it, stream);
2075         if (!di_trace) {
2076                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2077                                 __FILE__, __LINE__);
2078                 goto error;
2079         }
2080
2081         writer_stream_class = g_hash_table_lookup(
2082                         di_trace->stream_class_map,
2083                         (gpointer) stream_class);
2084         if (!writer_stream_class) {
2085                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2086                                 __FILE__, __LINE__);
2087                 goto error;
2088         }
2089         bt_get(writer_stream_class);
2090
2091         writer_event_class = get_event_class(debug_it,
2092                         writer_stream_class, event_class);
2093         if (!writer_event_class) {
2094                 writer_event_class = ctf_copy_event_class(debug_it->err,
2095                                 event_class);
2096                 if (!writer_event_class) {
2097                         fprintf(debug_it->err, "[error] %s in %s:%d\n",
2098                                         __func__, __FILE__, __LINE__);
2099                         goto error;
2100                 }
2101                 int_ret = bt_ctf_stream_class_add_event_class(
2102                                 writer_stream_class, writer_event_class);
2103                 if (int_ret) {
2104                         fprintf(debug_it->err, "[error] %s in %s:%d\n",
2105                                         __func__, __FILE__, __LINE__);
2106                         goto error;
2107                 }
2108         }
2109
2110         writer_trace = bt_ctf_stream_class_get_trace(writer_stream_class);
2111         if (!writer_trace) {
2112                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2113                                 __FILE__, __LINE__);
2114                 goto error;
2115         }
2116
2117         debug_info = get_trace_debug_info(debug_it, writer_trace, di_trace);
2118         if (debug_info) {
2119                 debug_info_handle_event(debug_it->err, event, debug_info);
2120         }
2121
2122         writer_event = debug_info_copy_event(debug_it->err, event,
2123                         writer_event_class, debug_info,
2124                         debug_it->debug_info_component);
2125         if (!writer_event) {
2126                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2127                                 __FILE__, __LINE__);
2128                 fprintf(debug_it->err, "[error] Failed to copy event %s\n",
2129                                 bt_ctf_event_class_get_name(writer_event_class));
2130                 goto error;
2131         }
2132
2133         packet = bt_ctf_event_get_packet(event);
2134         if (!packet) {
2135                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2136                                 __FILE__, __LINE__);
2137                 goto error;
2138         }
2139
2140         writer_packet = lookup_packet(debug_it, packet, di_trace);
2141         if (!writer_packet) {
2142                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2143                                 __FILE__, __LINE__);
2144                 goto error;
2145         }
2146         bt_get(writer_packet);
2147
2148         int_ret = bt_ctf_event_set_packet(writer_event, writer_packet);
2149         if (int_ret < 0) {
2150                 fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__,
2151                                 __FILE__, __LINE__);
2152                 fprintf(debug_it->err, "[error] Failed to append event %s\n",
2153                                 bt_ctf_event_class_get_name(writer_event_class));
2154                 goto error;
2155         }
2156
2157         /* Keep the reference on the writer event */
2158         goto end;
2159
2160 error:
2161         BT_PUT(writer_event);
2162
2163 end:
2164         bt_put(stream);
2165         bt_put(writer_trace);
2166         bt_put(writer_packet);
2167         bt_put(packet);
2168         bt_put(writer_event_class);
2169         bt_put(writer_stream_class);
2170         bt_put(stream_class);
2171         bt_put(event_class);
2172         return writer_event;
2173 }