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 #define BT_LOG_TAG "PLUGIN-CTF-METADATA-META-TRANSLATE"
  16 #include "logging.h"
  17
  18 #include <babeltrace2/babeltrace.h>
  19 #include "common/macros.h"
  20 #include "common/assert.h"
  21 #include <glib.h>
  22 #include <stdint.h>
  23 #include <string.h>
  24 #include <inttypes.h>
  25
  26 #include "ctf-meta-visitors.h"
  27
  28 struct ctx {
  29         bt_self_component_source *self_comp;
  30         bt_trace_class *ir_tc;
  31         bt_stream_class *ir_sc;
  32         struct ctf_trace_class *tc;
  33         struct ctf_stream_class *sc;
  34         struct ctf_event_class *ec;
  35         enum ctf_scope scope;
  36 };
  37
  38 static inline
  39 bt_field_class *ctf_field_class_to_ir(struct ctx *ctx,
  40                 struct ctf_field_class *fc);
  41
  42 static inline
  43 void ctf_field_class_int_set_props(struct ctf_field_class_int *fc,
  44                 bt_field_class *ir_fc)
  45 {
  46         bt_field_class_integer_set_field_value_range(ir_fc,
  47                 fc->base.size);
  48         bt_field_class_integer_set_preferred_display_base(ir_fc,
  49                 fc->disp_base);
  50 }
  51
  52 static inline
  53 bt_field_class *ctf_field_class_int_to_ir(struct ctx *ctx,
  54                 struct ctf_field_class_int *fc)
  55 {
  56         bt_field_class *ir_fc;
  57
  58         if (fc->is_signed) {
  59                 ir_fc = bt_field_class_signed_integer_create(ctx->ir_tc);
  60         } else {
  61                 ir_fc = bt_field_class_unsigned_integer_create(ctx->ir_tc);
  62         }
  63
  64         BT_ASSERT(ir_fc);
  65         ctf_field_class_int_set_props(fc, ir_fc);
  66         return ir_fc;
  67 }
  68
  69 static inline
  70 bt_field_class *ctf_field_class_enum_to_ir(struct ctx *ctx,
  71                 struct ctf_field_class_enum *fc)
  72 {
  73         int ret;
  74         bt_field_class *ir_fc;
  75         uint64_t i;
  76
  77         if (fc->base.is_signed) {
  78                 ir_fc = bt_field_class_signed_enumeration_create(ctx->ir_tc);
  79         } else {
  80                 ir_fc = bt_field_class_unsigned_enumeration_create(ctx->ir_tc);
  81         }
  82
  83         BT_ASSERT(ir_fc);
  84         ctf_field_class_int_set_props((void *) fc, ir_fc);
  85
  86         for (i = 0; i < fc->mappings->len; i++) {
  87                 struct ctf_field_class_enum_mapping *mapping =
  88                         ctf_field_class_enum_borrow_mapping_by_index(fc, i);
  89
  90                 if (fc->base.is_signed) {
  91                         ret = bt_field_class_signed_enumeration_map_range(
  92                                 ir_fc, mapping->label->str,
  93                                 mapping->range.lower.i, mapping->range.upper.i);
  94                 } else {
  95                         ret = bt_field_class_unsigned_enumeration_map_range(
  96                                 ir_fc, mapping->label->str,
  97                                 mapping->range.lower.u, mapping->range.upper.u);
  98                 }
  99
 100                 BT_ASSERT(ret == 0);
 101         }
 102
 103         return ir_fc;
 104 }
 105
 106 static inline
 107 bt_field_class *ctf_field_class_float_to_ir(struct ctx *ctx,
 108                 struct ctf_field_class_float *fc)
 109 {
 110         bt_field_class *ir_fc;
 111
 112         ir_fc = bt_field_class_real_create(ctx->ir_tc);
 113         BT_ASSERT(ir_fc);
 114
 115         if (fc->base.size == 32) {
 116                 bt_field_class_real_set_is_single_precision(ir_fc,
 117                         BT_TRUE);
 118         }
 119
 120         return ir_fc;
 121 }
 122
 123 static inline
 124 bt_field_class *ctf_field_class_string_to_ir(struct ctx *ctx,
 125                 struct ctf_field_class_string *fc)
 126 {
 127         bt_field_class *ir_fc = bt_field_class_string_create(ctx->ir_tc);
 128
 129         BT_ASSERT(ir_fc);
 130         return ir_fc;
 131 }
 132
 133 static inline
 134 void translate_struct_field_class_members(struct ctx *ctx,
 135                 struct ctf_field_class_struct *fc, bt_field_class *ir_fc,
 136                 bool with_header_prefix,
 137                 struct ctf_field_class_struct *context_fc)
 138 {
 139         uint64_t i;
 140         int ret;
 141
 142         for (i = 0; i < fc->members->len; i++) {
 143                 struct ctf_named_field_class *named_fc =
 144                         ctf_field_class_struct_borrow_member_by_index(fc, i);
 145                 bt_field_class *member_ir_fc;
 146                 const char *name = named_fc->name->str;
 147
 148                 if (!named_fc->fc->in_ir) {
 149                         continue;
 150                 }
 151
 152                 member_ir_fc = ctf_field_class_to_ir(ctx, named_fc->fc);
 153                 BT_ASSERT(member_ir_fc);
 154                 ret = bt_field_class_structure_append_member(ir_fc, name,
 155                         member_ir_fc);
 156                 BT_ASSERT(ret == 0);
 157                 bt_field_class_put_ref(member_ir_fc);
 158         }
 159 }
 160
 161 static inline
 162 bt_field_class *ctf_field_class_struct_to_ir(struct ctx *ctx,
 163                 struct ctf_field_class_struct *fc)
 164 {
 165         bt_field_class *ir_fc = bt_field_class_structure_create(ctx->ir_tc);
 166
 167         BT_ASSERT(ir_fc);
 168         translate_struct_field_class_members(ctx, fc, ir_fc, false, NULL);
 169         return ir_fc;
 170 }
 171
 172 static inline
 173 bt_field_class *borrow_ir_fc_from_field_path(struct ctx *ctx,
 174                 struct ctf_field_path *field_path)
 175 {
 176         bt_field_class *ir_fc = NULL;
 177         struct ctf_field_class *fc = ctf_field_path_borrow_field_class(
 178                 field_path, ctx->tc, ctx->sc, ctx->ec);
 179
 180         BT_ASSERT(fc);
 181
 182         if (fc->in_ir) {
 183                 ir_fc = fc->ir_fc;
 184         }
 185
 186         return ir_fc;
 187 }
 188
 189 static inline
 190 bt_field_class *ctf_field_class_variant_to_ir(struct ctx *ctx,
 191                 struct ctf_field_class_variant *fc)
 192 {
 193         int ret;
 194         bt_field_class *ir_fc = bt_field_class_variant_create(ctx->ir_tc);
 195         uint64_t i;
 196
 197         BT_ASSERT(ir_fc);
 198
 199         if (fc->tag_path.root != CTF_SCOPE_PACKET_HEADER &&
 200                         fc->tag_path.root != CTF_SCOPE_EVENT_HEADER) {
 201                 ret = bt_field_class_variant_set_selector_field_class(
 202                         ir_fc, borrow_ir_fc_from_field_path(ctx,
 203                                 &fc->tag_path));
 204                 BT_ASSERT(ret == 0);
 205         }
 206
 207         for (i = 0; i < fc->options->len; i++) {
 208                 struct ctf_named_field_class *named_fc =
 209                         ctf_field_class_variant_borrow_option_by_index(fc, i);
 210                 bt_field_class *option_ir_fc;
 211
 212                 BT_ASSERT(named_fc->fc->in_ir);
 213                 option_ir_fc = ctf_field_class_to_ir(ctx, named_fc->fc);
 214                 BT_ASSERT(option_ir_fc);
 215                 ret = bt_field_class_variant_append_option(
 216                         ir_fc, named_fc->name->str, option_ir_fc);
 217                 BT_ASSERT(ret == 0);
 218                 bt_field_class_put_ref(option_ir_fc);
 219         }
 220
 221         return ir_fc;
 222 }
 223
 224 static inline
 225 bt_field_class *ctf_field_class_array_to_ir(struct ctx *ctx,
 226                 struct ctf_field_class_array *fc)
 227 {
 228         bt_field_class *ir_fc;
 229         bt_field_class *elem_ir_fc;
 230
 231         if (fc->base.is_text) {
 232                 ir_fc = bt_field_class_string_create(ctx->ir_tc);
 233                 BT_ASSERT(ir_fc);
 234                 goto end;
 235         }
 236
 237         elem_ir_fc = ctf_field_class_to_ir(ctx, fc->base.elem_fc);
 238         BT_ASSERT(elem_ir_fc);
 239         ir_fc = bt_field_class_static_array_create(ctx->ir_tc, elem_ir_fc,
 240                 fc->length);
 241         BT_ASSERT(ir_fc);
 242         bt_field_class_put_ref(elem_ir_fc);
 243
 244 end:
 245         return ir_fc;
 246 }
 247
 248 static inline
 249 bt_field_class *ctf_field_class_sequence_to_ir(struct ctx *ctx,
 250                 struct ctf_field_class_sequence *fc)
 251 {
 252         int ret;
 253         bt_field_class *ir_fc;
 254         bt_field_class *elem_ir_fc;
 255
 256         if (fc->base.is_text) {
 257                 ir_fc = bt_field_class_string_create(ctx->ir_tc);
 258                 BT_ASSERT(ir_fc);
 259                 goto end;
 260         }
 261
 262         elem_ir_fc = ctf_field_class_to_ir(ctx, fc->base.elem_fc);
 263         BT_ASSERT(elem_ir_fc);
 264         ir_fc = bt_field_class_dynamic_array_create(ctx->ir_tc, elem_ir_fc);
 265         BT_ASSERT(ir_fc);
 266         bt_field_class_put_ref(elem_ir_fc);
 267         BT_ASSERT(ir_fc);
 268
 269         if (fc->length_path.root != CTF_SCOPE_PACKET_HEADER &&
 270                         fc->length_path.root != CTF_SCOPE_EVENT_HEADER) {
 271                 ret = bt_field_class_dynamic_array_set_length_field_class(
 272                         ir_fc, borrow_ir_fc_from_field_path(ctx, &fc->length_path));
 273                 BT_ASSERT(ret == 0);
 274         }
 275
 276 end:
 277         return ir_fc;
 278 }
 279
 280 static inline
 281 bt_field_class *ctf_field_class_to_ir(struct ctx *ctx,
 282                 struct ctf_field_class *fc)
 283 {
 284         bt_field_class *ir_fc = NULL;
 285
 286         BT_ASSERT(fc);
 287         BT_ASSERT(fc->in_ir);
 288
 289         switch (fc->type) {
 290         case CTF_FIELD_CLASS_TYPE_INT:
 291                 ir_fc = ctf_field_class_int_to_ir(ctx, (void *) fc);
 292                 break;
 293         case CTF_FIELD_CLASS_TYPE_ENUM:
 294                 ir_fc = ctf_field_class_enum_to_ir(ctx, (void *) fc);
 295                 break;
 296         case CTF_FIELD_CLASS_TYPE_FLOAT:
 297                 ir_fc = ctf_field_class_float_to_ir(ctx, (void *) fc);
 298                 break;
 299         case CTF_FIELD_CLASS_TYPE_STRING:
 300                 ir_fc = ctf_field_class_string_to_ir(ctx, (void *) fc);
 301                 break;
 302         case CTF_FIELD_CLASS_TYPE_STRUCT:
 303                 ir_fc = ctf_field_class_struct_to_ir(ctx, (void *) fc);
 304                 break;
 305         case CTF_FIELD_CLASS_TYPE_ARRAY:
 306                 ir_fc = ctf_field_class_array_to_ir(ctx, (void *) fc);
 307                 break;
 308         case CTF_FIELD_CLASS_TYPE_SEQUENCE:
 309                 ir_fc = ctf_field_class_sequence_to_ir(ctx, (void *) fc);
 310                 break;
 311         case CTF_FIELD_CLASS_TYPE_VARIANT:
 312                 ir_fc = ctf_field_class_variant_to_ir(ctx, (void *) fc);
 313                 break;
 314         default:
 315                 abort();
 316         }
 317
 318         fc->ir_fc = ir_fc;
 319         return ir_fc;
 320 }
 321
 322 static inline
 323 bool ctf_field_class_struct_has_immediate_member_in_ir(
 324                 struct ctf_field_class_struct *fc)
 325 {
 326         uint64_t i;
 327         bool has_immediate_member_in_ir = false;
 328
 329         /*
 330          * If the structure field class has no members at all, then it
 331          * was an empty structure in the beginning, so leave it existing
 332          * and empty.
 333          */
 334         if (fc->members->len == 0) {
 335                 has_immediate_member_in_ir = true;
 336                 goto end;
 337         }
 338
 339         for (i = 0; i < fc->members->len; i++) {
 340                 struct ctf_named_field_class *named_fc =
 341                         ctf_field_class_struct_borrow_member_by_index(fc, i);
 342
 343                 if (named_fc->fc->in_ir) {
 344                         has_immediate_member_in_ir = true;
 345                         goto end;
 346                 }
 347         }
 348
 349 end:
 350         return has_immediate_member_in_ir;
 351 }
 352
 353 static inline
 354 bt_field_class *scope_ctf_field_class_to_ir(struct ctx *ctx)
 355 {
 356         bt_field_class *ir_fc = NULL;
 357         struct ctf_field_class *fc = NULL;
 358
 359         switch (ctx->scope) {
 360         case CTF_SCOPE_PACKET_CONTEXT:
 361                 fc = ctx->sc->packet_context_fc;
 362                 break;
 363         case CTF_SCOPE_EVENT_COMMON_CONTEXT:
 364                 fc = ctx->sc->event_common_context_fc;
 365                 break;
 366         case CTF_SCOPE_EVENT_SPECIFIC_CONTEXT:
 367                 fc = ctx->ec->spec_context_fc;
 368                 break;
 369         case CTF_SCOPE_EVENT_PAYLOAD:
 370                 fc = ctx->ec->payload_fc;
 371                 break;
 372         default:
 373                 abort();
 374         }
 375
 376         if (fc && ctf_field_class_struct_has_immediate_member_in_ir(
 377                         (void *) fc)) {
 378                 ir_fc = ctf_field_class_to_ir(ctx, fc);
 379         }
 380
 381         return ir_fc;
 382 }
 383
 384 static inline
 385 void ctf_event_class_to_ir(struct ctx *ctx)
 386 {
 387         int ret;
 388         bt_event_class *ir_ec = NULL;
 389         bt_field_class *ir_fc;
 390
 391         BT_ASSERT(ctx->ec);
 392
 393         if (ctx->ec->is_translated) {
 394                 ir_ec = bt_stream_class_borrow_event_class_by_id(
 395                         ctx->ir_sc, ctx->ec->id);
 396                 BT_ASSERT(ir_ec);
 397                 goto end;
 398         }
 399
 400         ir_ec = bt_event_class_create_with_id(ctx->ir_sc, ctx->ec->id);
 401         BT_ASSERT(ir_ec);
 402         bt_event_class_put_ref(ir_ec);
 403         ctx->scope = CTF_SCOPE_EVENT_SPECIFIC_CONTEXT;
 404         ir_fc = scope_ctf_field_class_to_ir(ctx);
 405         if (ir_fc) {
 406                 ret = bt_event_class_set_specific_context_field_class(
 407                         ir_ec, ir_fc);
 408                 BT_ASSERT(ret == 0);
 409                 bt_field_class_put_ref(ir_fc);
 410         }
 411
 412         ctx->scope = CTF_SCOPE_EVENT_PAYLOAD;
 413         ir_fc = scope_ctf_field_class_to_ir(ctx);
 414         if (ir_fc) {
 415                 ret = bt_event_class_set_payload_field_class(ir_ec,
 416                         ir_fc);
 417                 BT_ASSERT(ret == 0);
 418                 bt_field_class_put_ref(ir_fc);
 419         }
 420
 421         if (ctx->ec->name->len > 0) {
 422                 ret = bt_event_class_set_name(ir_ec, ctx->ec->name->str);
 423                 BT_ASSERT(ret == 0);
 424         }
 425
 426         if (ctx->ec->emf_uri->len > 0) {
 427                 ret = bt_event_class_set_emf_uri(ir_ec, ctx->ec->emf_uri->str);
 428                 BT_ASSERT(ret == 0);
 429         }
 430
 431         if (ctx->ec->log_level != -1) {
 432                 bt_event_class_set_log_level(ir_ec, ctx->ec->log_level);
 433         }
 434
 435         ctx->ec->is_translated = true;
 436         ctx->ec->ir_ec = ir_ec;
 437
 438 end:
 439         return;
 440 }
 441
 442
 443 static inline
 444 void ctf_stream_class_to_ir(struct ctx *ctx)
 445 {
 446         int ret;
 447         bt_field_class *ir_fc;
 448
 449         BT_ASSERT(ctx->sc);
 450
 451         if (ctx->sc->is_translated) {
 452                 ctx->ir_sc = bt_trace_class_borrow_stream_class_by_id(
 453                         ctx->ir_tc, ctx->sc->id);
 454                 BT_ASSERT(ctx->ir_sc);
 455                 goto end;
 456         }
 457
 458         ctx->ir_sc = bt_stream_class_create_with_id(ctx->ir_tc, ctx->sc->id);
 459         BT_ASSERT(ctx->ir_sc);
 460         bt_stream_class_put_ref(ctx->ir_sc);
 461         ctx->scope = CTF_SCOPE_PACKET_CONTEXT;
 462         ir_fc = scope_ctf_field_class_to_ir(ctx);
 463         if (ir_fc) {
 464                 ret = bt_stream_class_set_packet_context_field_class(
 465                         ctx->ir_sc, ir_fc);
 466                 BT_ASSERT(ret == 0);
 467                 bt_field_class_put_ref(ir_fc);
 468         }
 469
 470         ctx->scope = CTF_SCOPE_EVENT_COMMON_CONTEXT;
 471         ir_fc = scope_ctf_field_class_to_ir(ctx);
 472         if (ir_fc) {
 473                 ret = bt_stream_class_set_event_common_context_field_class(
 474                         ctx->ir_sc, ir_fc);
 475                 BT_ASSERT(ret == 0);
 476                 bt_field_class_put_ref(ir_fc);
 477         }
 478
 479         bt_stream_class_set_assigns_automatic_event_class_id(ctx->ir_sc,
 480                 BT_FALSE);
 481         bt_stream_class_set_assigns_automatic_stream_id(ctx->ir_sc, BT_FALSE);
 482
 483         if (ctx->sc->default_clock_class) {
 484                 BT_ASSERT(ctx->sc->default_clock_class->ir_cc);
 485                 ret = bt_stream_class_set_default_clock_class(ctx->ir_sc,
 486                         ctx->sc->default_clock_class->ir_cc);
 487                 BT_ASSERT(ret == 0);
 488         }
 489
 490         bt_stream_class_set_packets_have_beginning_default_clock_snapshot(
 491                 ctx->ir_sc, ctx->sc->packets_have_ts_begin);
 492         bt_stream_class_set_packets_have_end_default_clock_snapshot(
 493                 ctx->ir_sc, ctx->sc->packets_have_ts_end);
 494         bt_stream_class_set_supports_discarded_events(ctx->ir_sc,
 495                 ctx->sc->has_discarded_events,
 496                 ctx->sc->discarded_events_have_default_cs);
 497         bt_stream_class_set_supports_discarded_packets(ctx->ir_sc,
 498                 ctx->sc->has_discarded_packets,
 499                 ctx->sc->discarded_packets_have_default_cs);
 500         ctx->sc->is_translated = true;
 501         ctx->sc->ir_sc = ctx->ir_sc;
 502
 503 end:
 504         return;
 505 }
 506
 507 static inline
 508 void ctf_clock_class_to_ir(bt_clock_class *ir_cc, struct ctf_clock_class *cc)
 509 {
 510         int ret;
 511
 512         if (strlen(cc->name->str) > 0) {
 513                 ret = bt_clock_class_set_name(ir_cc, cc->name->str);
 514                 BT_ASSERT(ret == 0);
 515         }
 516
 517         if (strlen(cc->description->str) > 0) {
 518                 ret = bt_clock_class_set_description(ir_cc, cc->description->str);
 519                 BT_ASSERT(ret == 0);
 520         }
 521
 522         bt_clock_class_set_frequency(ir_cc, cc->frequency);
 523         bt_clock_class_set_precision(ir_cc, cc->precision);
 524         bt_clock_class_set_offset(ir_cc, cc->offset_seconds, cc->offset_cycles);
 525
 526         if (cc->has_uuid) {
 527                 bt_clock_class_set_uuid(ir_cc, cc->uuid);
 528         }
 529
 530         bt_clock_class_set_origin_is_unix_epoch(ir_cc, cc->is_absolute);
 531 }
 532
 533 static inline
 534 int ctf_trace_class_to_ir(struct ctx *ctx)
 535 {
 536         int ret = 0;
 537         uint64_t i;
 538
 539         BT_ASSERT(ctx->tc);
 540         BT_ASSERT(ctx->ir_tc);
 541
 542         if (ctx->tc->is_translated) {
 543                 goto end;
 544         }
 545
 546         if (ctx->tc->is_uuid_set) {
 547                 bt_trace_class_set_uuid(ctx->ir_tc, ctx->tc->uuid);
 548         }
 549
 550         for (i = 0; i < ctx->tc->env_entries->len; i++) {
 551                 struct ctf_trace_class_env_entry *env_entry =
 552                         ctf_trace_class_borrow_env_entry_by_index(ctx->tc, i);
 553
 554                 switch (env_entry->type) {
 555                 case CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT:
 556                         ret = bt_trace_class_set_environment_entry_integer(
 557                                 ctx->ir_tc, env_entry->name->str,
 558                                 env_entry->value.i);
 559                         break;
 560                 case CTF_TRACE_CLASS_ENV_ENTRY_TYPE_STR:
 561                         ret = bt_trace_class_set_environment_entry_string(
 562                                 ctx->ir_tc, env_entry->name->str,
 563                                 env_entry->value.str->str);
 564                         break;
 565                 default:
 566                         abort();
 567                 }
 568
 569                 if (ret) {
 570                         goto end;
 571                 }
 572         }
 573
 574         for (i = 0; i < ctx->tc->clock_classes->len; i++) {
 575                 struct ctf_clock_class *cc = ctx->tc->clock_classes->pdata[i];
 576
 577                 cc->ir_cc = bt_clock_class_create(
 578                                 bt_self_component_source_as_self_component(
 579                                         ctx->self_comp));
 580                 ctf_clock_class_to_ir(cc->ir_cc, cc);
 581         }
 582
 583         bt_trace_class_set_assigns_automatic_stream_class_id(ctx->ir_tc,
 584                 BT_FALSE);
 585         ctx->tc->is_translated = true;
 586         ctx->tc->ir_tc = ctx->ir_tc;
 587
 588 end:
 589         return ret;
 590 }
 591
 592 BT_HIDDEN
 593 int ctf_trace_class_translate(bt_self_component_source *self_comp,
 594                 bt_trace_class *ir_tc, struct ctf_trace_class *tc)
 595 {
 596         int ret = 0;
 597         uint64_t i;
 598         struct ctx ctx = { 0 };
 599
 600         ctx.self_comp = self_comp;
 601         ctx.tc = tc;
 602         ctx.ir_tc = ir_tc;
 603         ret = ctf_trace_class_to_ir(&ctx);
 604         if (ret) {
 605                 goto end;
 606         }
 607
 608         for (i = 0; i < tc->stream_classes->len; i++) {
 609                 uint64_t j;
 610                 ctx.sc = tc->stream_classes->pdata[i];
 611
 612                 ctf_stream_class_to_ir(&ctx);
 613
 614                 for (j = 0; j < ctx.sc->event_classes->len; j++) {
 615                         ctx.ec = ctx.sc->event_classes->pdata[j];
 616
 617                         ctf_event_class_to_ir(&ctx);
 618                         ctx.ec = NULL;
 619                 }
 620
 621                 ctx.sc = NULL;
 622         }
 623
 624 end:
 625         return ret;
 626 }