src/plugins/ctf/common/metadata/ctf-meta-translate.c

   1 /*
   2  * Copyright 2018 - Philippe Proulx <pproulx@efficios.com>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  */
  14
  15 #include <babeltrace2/babeltrace.h>
  16 #include "common/macros.h"
  17 #include "common/assert.h"
  18 #include <glib.h>
  19 #include <stdbool.h>
  20 #include <stdint.h>
  21 #include <string.h>
  22 #include <inttypes.h>
  23
  24 #include "ctf-meta-visitors.h"
  25
  26 struct ctx {
  27         bt_self_component *self_comp;
  28         bt_trace_class *ir_tc;
  29         bt_stream_class *ir_sc;
  30         struct ctf_trace_class *tc;
  31         struct ctf_stream_class *sc;
  32         struct ctf_event_class *ec;
  33         enum ctf_scope scope;
  34 };
  35
  36 static inline
  37 bt_field_class *ctf_field_class_to_ir(struct ctx *ctx,
  38                 struct ctf_field_class *fc);
  39
  40 static inline
  41 void ctf_field_class_int_set_props(struct ctf_field_class_int *fc,
  42                 bt_field_class *ir_fc)
  43 {
  44         bt_field_class_integer_set_field_value_range(ir_fc,
  45                 fc->base.size);
  46         bt_field_class_integer_set_preferred_display_base(ir_fc,
  47                 fc->disp_base);
  48 }
  49
  50 static inline
  51 bt_field_class *ctf_field_class_int_to_ir(struct ctx *ctx,
  52                 struct ctf_field_class_int *fc)
  53 {
  54         bt_field_class *ir_fc;
  55
  56         if (fc->is_signed) {
  57                 ir_fc = bt_field_class_integer_signed_create(ctx->ir_tc);
  58         } else {
  59                 ir_fc = bt_field_class_integer_unsigned_create(ctx->ir_tc);
  60         }
  61
  62         BT_ASSERT(ir_fc);
  63         ctf_field_class_int_set_props(fc, ir_fc);
  64         return ir_fc;
  65 }
  66
  67 static inline
  68 bt_field_class *ctf_field_class_enum_to_ir(struct ctx *ctx,
  69                 struct ctf_field_class_enum *fc)
  70 {
  71         int ret;
  72         bt_field_class *ir_fc;
  73         uint64_t i;
  74
  75         if (fc->base.is_signed) {
  76                 ir_fc = bt_field_class_enumeration_signed_create(ctx->ir_tc);
  77         } else {
  78                 ir_fc = bt_field_class_enumeration_unsigned_create(ctx->ir_tc);
  79         }
  80
  81         BT_ASSERT(ir_fc);
  82         ctf_field_class_int_set_props((void *) fc, ir_fc);
  83
  84         for (i = 0; i < fc->mappings->len; i++) {
  85                 struct ctf_field_class_enum_mapping *mapping =
  86                         ctf_field_class_enum_borrow_mapping_by_index(fc, i);
  87                 void *range_set;
  88                 uint64_t range_i;
  89
  90                 if (fc->base.is_signed) {
  91                         range_set = bt_integer_range_set_signed_create();
  92                 } else {
  93                         range_set = bt_integer_range_set_unsigned_create();
  94                 }
  95
  96                 BT_ASSERT(range_set);
  97
  98                 for (range_i = 0; range_i < mapping->ranges->len; range_i++) {
  99                         struct ctf_range *range =
 100                                 ctf_field_class_enum_mapping_borrow_range_by_index(
 101                                         mapping, range_i);
 102
 103                         if (fc->base.is_signed) {
 104                                 ret = bt_integer_range_set_signed_add_range(
 105                                         range_set, range->lower.i,
 106                                         range->upper.i);
 107                         } else {
 108                                 ret = bt_integer_range_set_unsigned_add_range(
 109                                         range_set, range->lower.u,
 110                                         range->upper.u);
 111                         }
 112
 113                         BT_ASSERT(ret == 0);
 114                 }
 115
 116                 if (fc->base.is_signed) {
 117                         ret = bt_field_class_enumeration_signed_add_mapping(
 118                                 ir_fc, mapping->label->str, range_set);
 119                         BT_INTEGER_RANGE_SET_SIGNED_PUT_REF_AND_RESET(range_set);
 120                 } else {
 121                         ret = bt_field_class_enumeration_unsigned_add_mapping(
 122                                 ir_fc, mapping->label->str, range_set);
 123                         BT_INTEGER_RANGE_SET_UNSIGNED_PUT_REF_AND_RESET(range_set);
 124                 }
 125
 126                 BT_ASSERT(ret == 0);
 127         }
 128
 129         return ir_fc;
 130 }
 131
 132 static inline
 133 bt_field_class *ctf_field_class_float_to_ir(struct ctx *ctx,
 134                 struct ctf_field_class_float *fc)
 135 {
 136         bt_field_class *ir_fc;
 137
 138         if (fc->base.size == 32) {
 139                 ir_fc = bt_field_class_real_single_precision_create(ctx->ir_tc);
 140         } else {
 141                 ir_fc = bt_field_class_real_double_precision_create(ctx->ir_tc);
 142         }
 143         BT_ASSERT(ir_fc);
 144
 145         return ir_fc;
 146 }
 147
 148 static inline
 149 bt_field_class *ctf_field_class_string_to_ir(struct ctx *ctx,
 150                 struct ctf_field_class_string *fc)
 151 {
 152         bt_field_class *ir_fc = bt_field_class_string_create(ctx->ir_tc);
 153
 154         BT_ASSERT(ir_fc);
 155         return ir_fc;
 156 }
 157
 158 static inline
 159 void translate_struct_field_class_members(struct ctx *ctx,
 160                 struct ctf_field_class_struct *fc, bt_field_class *ir_fc,
 161                 bool with_header_prefix,
 162                 struct ctf_field_class_struct *context_fc)
 163 {
 164         uint64_t i;
 165         int ret;
 166
 167         for (i = 0; i < fc->members->len; i++) {
 168                 struct ctf_named_field_class *named_fc =
 169                         ctf_field_class_struct_borrow_member_by_index(fc, i);
 170                 bt_field_class *member_ir_fc;
 171                 const char *name = named_fc->name->str;
 172
 173                 if (!named_fc->fc->in_ir) {
 174                         continue;
 175                 }
 176
 177                 member_ir_fc = ctf_field_class_to_ir(ctx, named_fc->fc);
 178                 BT_ASSERT(member_ir_fc);
 179                 ret = bt_field_class_structure_append_member(ir_fc, name,
 180                         member_ir_fc);
 181                 BT_ASSERT(ret == 0);
 182                 bt_field_class_put_ref(member_ir_fc);
 183         }
 184 }
 185
 186 static inline
 187 bt_field_class *ctf_field_class_struct_to_ir(struct ctx *ctx,
 188                 struct ctf_field_class_struct *fc)
 189 {
 190         bt_field_class *ir_fc = bt_field_class_structure_create(ctx->ir_tc);
 191
 192         BT_ASSERT(ir_fc);
 193         translate_struct_field_class_members(ctx, fc, ir_fc, false, NULL);
 194         return ir_fc;
 195 }
 196
 197 static inline
 198 bt_field_class *borrow_ir_fc_from_field_path(struct ctx *ctx,
 199                 struct ctf_field_path *field_path)
 200 {
 201         bt_field_class *ir_fc = NULL;
 202         struct ctf_field_class *fc = ctf_field_path_borrow_field_class(
 203                 field_path, ctx->tc, ctx->sc, ctx->ec);
 204
 205         BT_ASSERT(fc);
 206
 207         if (fc->in_ir) {
 208                 ir_fc = fc->ir_fc;
 209         }
 210
 211         return ir_fc;
 212 }
 213
 214 static inline
 215 const void *find_ir_enum_field_class_mapping_by_label(const bt_field_class *fc,
 216                 const char *label, bool is_signed)
 217 {
 218         const void *mapping = NULL;
 219         uint64_t i;
 220
 221         for (i = 0; i < bt_field_class_enumeration_get_mapping_count(fc); i++) {
 222                 const bt_field_class_enumeration_mapping *this_mapping;
 223                 const void *spec_this_mapping;
 224
 225                 if (is_signed) {
 226                         spec_this_mapping =
 227                                 bt_field_class_enumeration_signed_borrow_mapping_by_index_const(
 228                                         fc, i);
 229                         this_mapping =
 230                                 bt_field_class_enumeration_signed_mapping_as_mapping_const(
 231                                         spec_this_mapping);
 232                 } else {
 233                         spec_this_mapping =
 234                                 bt_field_class_enumeration_unsigned_borrow_mapping_by_index_const(
 235                                         fc, i);
 236                         this_mapping =
 237                                 bt_field_class_enumeration_unsigned_mapping_as_mapping_const(
 238                                         spec_this_mapping);
 239                 }
 240
 241                 BT_ASSERT(this_mapping);
 242                 BT_ASSERT(spec_this_mapping);
 243
 244                 if (strcmp(bt_field_class_enumeration_mapping_get_label(
 245                                 this_mapping), label) == 0) {
 246                         mapping = spec_this_mapping;
 247                         goto end;
 248                 }
 249         }
 250
 251 end:
 252         return mapping;
 253 }
 254
 255 static inline
 256 bt_field_class *ctf_field_class_variant_to_ir(struct ctx *ctx,
 257                 struct ctf_field_class_variant *fc)
 258 {
 259         int ret;
 260         bt_field_class *ir_fc;
 261         uint64_t i;
 262         bt_field_class *ir_tag_fc = NULL;
 263
 264         if (fc->tag_path.root != CTF_SCOPE_PACKET_HEADER &&
 265                         fc->tag_path.root != CTF_SCOPE_EVENT_HEADER) {
 266                 ir_tag_fc = borrow_ir_fc_from_field_path(ctx, &fc->tag_path);
 267                 BT_ASSERT(ir_tag_fc);
 268         }
 269
 270         ir_fc = bt_field_class_variant_create(ctx->ir_tc, ir_tag_fc);
 271         BT_ASSERT(ir_fc);
 272
 273         for (i = 0; i < fc->options->len; i++) {
 274                 struct ctf_named_field_class *named_fc =
 275                         ctf_field_class_variant_borrow_option_by_index(fc, i);
 276                 bt_field_class *option_ir_fc;
 277
 278                 BT_ASSERT(named_fc->fc->in_ir);
 279                 option_ir_fc = ctf_field_class_to_ir(ctx, named_fc->fc);
 280                 BT_ASSERT(option_ir_fc);
 281
 282                 if (ir_tag_fc) {
 283                         /*
 284                          * At this point the trace IR selector
 285                          * (enumeration) field class already exists if
 286                          * the variant is tagged (`ir_tag_fc`). This one
 287                          * already contains range sets for its mappings,
 288                          * so we just reuse the same, finding them by
 289                          * matching a variant field class's option's
 290                          * _original_ name (with a leading underscore,
 291                          * possibly) with a selector field class's
 292                          * mapping name.
 293                          */
 294                         if (fc->tag_fc->base.is_signed) {
 295                                 const bt_field_class_enumeration_signed_mapping *mapping =
 296                                         find_ir_enum_field_class_mapping_by_label(
 297                                                 ir_tag_fc,
 298                                                 named_fc->orig_name->str, true);
 299                                 const bt_integer_range_set_signed *range_set;
 300
 301                                 BT_ASSERT(mapping);
 302                                 range_set =
 303                                         bt_field_class_enumeration_signed_mapping_borrow_ranges_const(
 304                                                 mapping);
 305                                 BT_ASSERT(range_set);
 306                                 ret = bt_field_class_variant_with_selector_field_integer_signed_append_option(
 307                                         ir_fc, named_fc->name->str,
 308                                         option_ir_fc, range_set);
 309                         } else {
 310                                 const bt_field_class_enumeration_unsigned_mapping *mapping =
 311                                         find_ir_enum_field_class_mapping_by_label(
 312                                                 ir_tag_fc,
 313                                                 named_fc->orig_name->str,
 314                                                 false);
 315                                 const bt_integer_range_set_unsigned *range_set;
 316
 317                                 BT_ASSERT(mapping);
 318                                 range_set =
 319                                         bt_field_class_enumeration_unsigned_mapping_borrow_ranges_const(
 320                                                 mapping);
 321                                 BT_ASSERT(range_set);
 322                                 ret = bt_field_class_variant_with_selector_field_integer_unsigned_append_option(
 323                                         ir_fc, named_fc->name->str,
 324                                         option_ir_fc, range_set);
 325                         }
 326                 } else {
 327                         ret = bt_field_class_variant_without_selector_append_option(
 328                                 ir_fc, named_fc->name->str, option_ir_fc);
 329                 }
 330
 331                 BT_ASSERT(ret == 0);
 332                 bt_field_class_put_ref(option_ir_fc);
 333         }
 334
 335         return ir_fc;
 336 }
 337
 338 static inline
 339 bt_field_class *ctf_field_class_array_to_ir(struct ctx *ctx,
 340                 struct ctf_field_class_array *fc)
 341 {
 342         bt_field_class *ir_fc;
 343         bt_field_class *elem_ir_fc;
 344
 345         if (fc->base.is_text) {
 346                 ir_fc = bt_field_class_string_create(ctx->ir_tc);
 347                 BT_ASSERT(ir_fc);
 348                 goto end;
 349         }
 350
 351         elem_ir_fc = ctf_field_class_to_ir(ctx, fc->base.elem_fc);
 352         BT_ASSERT(elem_ir_fc);
 353         ir_fc = bt_field_class_array_static_create(ctx->ir_tc, elem_ir_fc,
 354                 fc->length);
 355         BT_ASSERT(ir_fc);
 356         bt_field_class_put_ref(elem_ir_fc);
 357
 358 end:
 359         return ir_fc;
 360 }
 361
 362 static inline
 363 bt_field_class *ctf_field_class_sequence_to_ir(struct ctx *ctx,
 364                 struct ctf_field_class_sequence *fc)
 365 {
 366         bt_field_class *ir_fc;
 367         bt_field_class *elem_ir_fc;
 368         bt_field_class *length_fc = NULL;
 369
 370         if (fc->base.is_text) {
 371                 ir_fc = bt_field_class_string_create(ctx->ir_tc);
 372                 BT_ASSERT(ir_fc);
 373                 goto end;
 374         }
 375
 376         elem_ir_fc = ctf_field_class_to_ir(ctx, fc->base.elem_fc);
 377         BT_ASSERT(elem_ir_fc);
 378
 379         if (fc->length_path.root != CTF_SCOPE_PACKET_HEADER &&
 380                         fc->length_path.root != CTF_SCOPE_EVENT_HEADER) {
 381                 length_fc = borrow_ir_fc_from_field_path(ctx, &fc->length_path);
 382                 BT_ASSERT(length_fc);
 383         }
 384
 385         ir_fc = bt_field_class_array_dynamic_create(ctx->ir_tc, elem_ir_fc,
 386                 length_fc);
 387         BT_ASSERT(ir_fc);
 388         bt_field_class_put_ref(elem_ir_fc);
 389         BT_ASSERT(ir_fc);
 390
 391 end:
 392         return ir_fc;
 393 }
 394
 395 static inline
 396 bt_field_class *ctf_field_class_to_ir(struct ctx *ctx,
 397                 struct ctf_field_class *fc)
 398 {
 399         bt_field_class *ir_fc = NULL;
 400
 401         BT_ASSERT(fc);
 402         BT_ASSERT(fc->in_ir);
 403
 404         switch (fc->type) {
 405         case CTF_FIELD_CLASS_TYPE_INT:
 406                 ir_fc = ctf_field_class_int_to_ir(ctx, (void *) fc);
 407                 break;
 408         case CTF_FIELD_CLASS_TYPE_ENUM:
 409                 ir_fc = ctf_field_class_enum_to_ir(ctx, (void *) fc);
 410                 break;
 411         case CTF_FIELD_CLASS_TYPE_FLOAT:
 412                 ir_fc = ctf_field_class_float_to_ir(ctx, (void *) fc);
 413                 break;
 414         case CTF_FIELD_CLASS_TYPE_STRING:
 415                 ir_fc = ctf_field_class_string_to_ir(ctx, (void *) fc);
 416                 break;
 417         case CTF_FIELD_CLASS_TYPE_STRUCT:
 418                 ir_fc = ctf_field_class_struct_to_ir(ctx, (void *) fc);
 419                 break;
 420         case CTF_FIELD_CLASS_TYPE_ARRAY:
 421                 ir_fc = ctf_field_class_array_to_ir(ctx, (void *) fc);
 422                 break;
 423         case CTF_FIELD_CLASS_TYPE_SEQUENCE:
 424                 ir_fc = ctf_field_class_sequence_to_ir(ctx, (void *) fc);
 425                 break;
 426         case CTF_FIELD_CLASS_TYPE_VARIANT:
 427                 ir_fc = ctf_field_class_variant_to_ir(ctx, (void *) fc);
 428                 break;
 429         default:
 430                 bt_common_abort();
 431         }
 432
 433         fc->ir_fc = ir_fc;
 434         return ir_fc;
 435 }
 436
 437 static inline
 438 bool ctf_field_class_struct_has_immediate_member_in_ir(
 439                 struct ctf_field_class_struct *fc)
 440 {
 441         uint64_t i;
 442         bool has_immediate_member_in_ir = false;
 443
 444         /*
 445          * If the structure field class has no members at all, then it
 446          * was an empty structure in the beginning, so leave it existing
 447          * and empty.
 448          */
 449         if (fc->members->len == 0) {
 450                 has_immediate_member_in_ir = true;
 451                 goto end;
 452         }
 453
 454         for (i = 0; i < fc->members->len; i++) {
 455                 struct ctf_named_field_class *named_fc =
 456                         ctf_field_class_struct_borrow_member_by_index(fc, i);
 457
 458                 if (named_fc->fc->in_ir) {
 459                         has_immediate_member_in_ir = true;
 460                         goto end;
 461                 }
 462         }
 463
 464 end:
 465         return has_immediate_member_in_ir;
 466 }
 467
 468 static inline
 469 bt_field_class *scope_ctf_field_class_to_ir(struct ctx *ctx)
 470 {
 471         bt_field_class *ir_fc = NULL;
 472         struct ctf_field_class *fc = NULL;
 473
 474         switch (ctx->scope) {
 475         case CTF_SCOPE_PACKET_CONTEXT:
 476                 fc = ctx->sc->packet_context_fc;
 477                 break;
 478         case CTF_SCOPE_EVENT_COMMON_CONTEXT:
 479                 fc = ctx->sc->event_common_context_fc;
 480                 break;
 481         case CTF_SCOPE_EVENT_SPECIFIC_CONTEXT:
 482                 fc = ctx->ec->spec_context_fc;
 483                 break;
 484         case CTF_SCOPE_EVENT_PAYLOAD:
 485                 fc = ctx->ec->payload_fc;
 486                 break;
 487         default:
 488                 bt_common_abort();
 489         }
 490
 491         if (fc && ctf_field_class_struct_has_immediate_member_in_ir(
 492                         (void *) fc)) {
 493                 ir_fc = ctf_field_class_to_ir(ctx, fc);
 494         }
 495
 496         return ir_fc;
 497 }
 498
 499 static inline
 500 void ctf_event_class_to_ir(struct ctx *ctx)
 501 {
 502         int ret;
 503         bt_event_class *ir_ec = NULL;
 504         bt_field_class *ir_fc;
 505
 506         BT_ASSERT(ctx->ec);
 507
 508         if (ctx->ec->is_translated) {
 509                 ir_ec = bt_stream_class_borrow_event_class_by_id(
 510                         ctx->ir_sc, ctx->ec->id);
 511                 BT_ASSERT(ir_ec);
 512                 goto end;
 513         }
 514
 515         ir_ec = bt_event_class_create_with_id(ctx->ir_sc, ctx->ec->id);
 516         BT_ASSERT(ir_ec);
 517         bt_event_class_put_ref(ir_ec);
 518         ctx->scope = CTF_SCOPE_EVENT_SPECIFIC_CONTEXT;
 519         ir_fc = scope_ctf_field_class_to_ir(ctx);
 520         if (ir_fc) {
 521                 ret = bt_event_class_set_specific_context_field_class(
 522                         ir_ec, ir_fc);
 523                 BT_ASSERT(ret == 0);
 524                 bt_field_class_put_ref(ir_fc);
 525         }
 526
 527         ctx->scope = CTF_SCOPE_EVENT_PAYLOAD;
 528         ir_fc = scope_ctf_field_class_to_ir(ctx);
 529         if (ir_fc) {
 530                 ret = bt_event_class_set_payload_field_class(ir_ec,
 531                         ir_fc);
 532                 BT_ASSERT(ret == 0);
 533                 bt_field_class_put_ref(ir_fc);
 534         }
 535
 536         if (ctx->ec->name->len > 0) {
 537                 ret = bt_event_class_set_name(ir_ec, ctx->ec->name->str);
 538                 BT_ASSERT(ret == 0);
 539         }
 540
 541         if (ctx->ec->emf_uri->len > 0) {
 542                 ret = bt_event_class_set_emf_uri(ir_ec, ctx->ec->emf_uri->str);
 543                 BT_ASSERT(ret == 0);
 544         }
 545
 546         if (ctx->ec->is_log_level_set) {
 547                 bt_event_class_set_log_level(ir_ec, ctx->ec->log_level);
 548         }
 549
 550         ctx->ec->is_translated = true;
 551         ctx->ec->ir_ec = ir_ec;
 552
 553 end:
 554         return;
 555 }
 556
 557
 558 static inline
 559 void ctf_stream_class_to_ir(struct ctx *ctx)
 560 {
 561         int ret;
 562         bt_field_class *ir_fc;
 563
 564         BT_ASSERT(ctx->sc);
 565
 566         if (ctx->sc->is_translated) {
 567                 ctx->ir_sc = bt_trace_class_borrow_stream_class_by_id(
 568                         ctx->ir_tc, ctx->sc->id);
 569                 BT_ASSERT(ctx->ir_sc);
 570                 goto end;
 571         }
 572
 573         ctx->ir_sc = bt_stream_class_create_with_id(ctx->ir_tc, ctx->sc->id);
 574         BT_ASSERT(ctx->ir_sc);
 575         bt_stream_class_put_ref(ctx->ir_sc);
 576
 577         if (ctx->sc->default_clock_class) {
 578                 BT_ASSERT(ctx->sc->default_clock_class->ir_cc);
 579                 ret = bt_stream_class_set_default_clock_class(ctx->ir_sc,
 580                         ctx->sc->default_clock_class->ir_cc);
 581                 BT_ASSERT(ret == 0);
 582         }
 583
 584         bt_stream_class_set_supports_packets(ctx->ir_sc, BT_TRUE,
 585                 ctx->sc->packets_have_ts_begin, ctx->sc->packets_have_ts_end);
 586         bt_stream_class_set_supports_discarded_events(ctx->ir_sc,
 587                 ctx->sc->has_discarded_events,
 588                 ctx->sc->discarded_events_have_default_cs);
 589         bt_stream_class_set_supports_discarded_packets(ctx->ir_sc,
 590                 ctx->sc->has_discarded_packets,
 591                 ctx->sc->discarded_packets_have_default_cs);
 592         ctx->scope = CTF_SCOPE_PACKET_CONTEXT;
 593         ir_fc = scope_ctf_field_class_to_ir(ctx);
 594         if (ir_fc) {
 595                 ret = bt_stream_class_set_packet_context_field_class(
 596                         ctx->ir_sc, ir_fc);
 597                 BT_ASSERT(ret == 0);
 598                 bt_field_class_put_ref(ir_fc);
 599         }
 600
 601         ctx->scope = CTF_SCOPE_EVENT_COMMON_CONTEXT;
 602         ir_fc = scope_ctf_field_class_to_ir(ctx);
 603         if (ir_fc) {
 604                 ret = bt_stream_class_set_event_common_context_field_class(
 605                         ctx->ir_sc, ir_fc);
 606                 BT_ASSERT(ret == 0);
 607                 bt_field_class_put_ref(ir_fc);
 608         }
 609
 610         bt_stream_class_set_assigns_automatic_event_class_id(ctx->ir_sc,
 611                 BT_FALSE);
 612         bt_stream_class_set_assigns_automatic_stream_id(ctx->ir_sc, BT_FALSE);
 613
 614         ctx->sc->is_translated = true;
 615         ctx->sc->ir_sc = ctx->ir_sc;
 616
 617 end:
 618         return;
 619 }
 620
 621 static inline
 622 void ctf_clock_class_to_ir(bt_clock_class *ir_cc, struct ctf_clock_class *cc)
 623 {
 624         int ret;
 625
 626         if (strlen(cc->name->str) > 0) {
 627                 ret = bt_clock_class_set_name(ir_cc, cc->name->str);
 628                 BT_ASSERT(ret == 0);
 629         }
 630
 631         if (strlen(cc->description->str) > 0) {
 632                 ret = bt_clock_class_set_description(ir_cc, cc->description->str);
 633                 BT_ASSERT(ret == 0);
 634         }
 635
 636         bt_clock_class_set_frequency(ir_cc, cc->frequency);
 637         bt_clock_class_set_precision(ir_cc, cc->precision);
 638         bt_clock_class_set_offset(ir_cc, cc->offset_seconds, cc->offset_cycles);
 639
 640         if (cc->has_uuid) {
 641                 bt_clock_class_set_uuid(ir_cc, cc->uuid);
 642         }
 643
 644         bt_clock_class_set_origin_is_unix_epoch(ir_cc, cc->is_absolute);
 645 }
 646
 647 static inline
 648 int ctf_trace_class_to_ir(struct ctx *ctx)
 649 {
 650         int ret = 0;
 651         uint64_t i;
 652
 653         BT_ASSERT(ctx->tc);
 654         BT_ASSERT(ctx->ir_tc);
 655
 656         if (ctx->tc->is_translated) {
 657                 goto end;
 658         }
 659
 660         for (i = 0; i < ctx->tc->clock_classes->len; i++) {
 661                 struct ctf_clock_class *cc = ctx->tc->clock_classes->pdata[i];
 662
 663                 cc->ir_cc = bt_clock_class_create(ctx->self_comp);
 664                 ctf_clock_class_to_ir(cc->ir_cc, cc);
 665         }
 666
 667         bt_trace_class_set_assigns_automatic_stream_class_id(ctx->ir_tc,
 668                 BT_FALSE);
 669         ctx->tc->is_translated = true;
 670         ctx->tc->ir_tc = ctx->ir_tc;
 671
 672 end:
 673         return ret;
 674 }
 675
 676 BT_HIDDEN
 677 int ctf_trace_class_translate(bt_self_component *self_comp,
 678                 bt_trace_class *ir_tc, struct ctf_trace_class *tc)
 679 {
 680         int ret = 0;
 681         uint64_t i;
 682         struct ctx ctx = { 0 };
 683
 684         ctx.self_comp = self_comp;
 685         ctx.tc = tc;
 686         ctx.ir_tc = ir_tc;
 687         ret = ctf_trace_class_to_ir(&ctx);
 688         if (ret) {
 689                 goto end;
 690         }
 691
 692         for (i = 0; i < tc->stream_classes->len; i++) {
 693                 uint64_t j;
 694                 ctx.sc = tc->stream_classes->pdata[i];
 695
 696                 ctf_stream_class_to_ir(&ctx);
 697
 698                 for (j = 0; j < ctx.sc->event_classes->len; j++) {
 699                         ctx.ec = ctx.sc->event_classes->pdata[j];
 700
 701                         ctf_event_class_to_ir(&ctx);
 702                         ctx.ec = NULL;
 703                 }
 704
 705                 ctx.sc = NULL;
 706         }
 707
 708 end:
 709         return ret;
 710 }