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 <babeltrace/babeltrace.h>
  19 #include <babeltrace/babeltrace-internal.h>
  20 #include <babeltrace/assert-internal.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         for (i = 0; i < fc->members->len; i++) {
 330                 struct ctf_named_field_class *named_fc =
 331                         ctf_field_class_struct_borrow_member_by_index(fc, i);
 332
 333                 if (named_fc->fc->in_ir) {
 334                         has_immediate_member_in_ir = true;
 335                         goto end;
 336                 }
 337         }
 338
 339 end:
 340         return has_immediate_member_in_ir;
 341 }
 342
 343 static inline
 344 bt_field_class *scope_ctf_field_class_to_ir(struct ctx *ctx)
 345 {
 346         bt_field_class *ir_fc = NULL;
 347         struct ctf_field_class *fc = NULL;
 348
 349         switch (ctx->scope) {
 350         case CTF_SCOPE_PACKET_CONTEXT:
 351                 fc = ctx->sc->packet_context_fc;
 352                 break;
 353         case CTF_SCOPE_EVENT_COMMON_CONTEXT:
 354                 fc = ctx->sc->event_common_context_fc;
 355                 break;
 356         case CTF_SCOPE_EVENT_SPECIFIC_CONTEXT:
 357                 fc = ctx->ec->spec_context_fc;
 358                 break;
 359         case CTF_SCOPE_EVENT_PAYLOAD:
 360                 fc = ctx->ec->payload_fc;
 361                 break;
 362         default:
 363                 abort();
 364         }
 365
 366         if (fc && ctf_field_class_struct_has_immediate_member_in_ir(
 367                         (void *) fc)) {
 368                 ir_fc = ctf_field_class_to_ir(ctx, fc);
 369         }
 370
 371         return ir_fc;
 372 }
 373
 374 static inline
 375 struct ctf_field_class_int *borrow_named_int_field_class(
 376                 struct ctf_field_class_struct *struct_fc, const char *name)
 377 {
 378         struct ctf_named_field_class *named_fc = NULL;
 379         struct ctf_field_class_int *int_fc = NULL;
 380
 381         if (!struct_fc) {
 382                 goto end;
 383         }
 384
 385         named_fc = ctf_field_class_struct_borrow_member_by_name(struct_fc, name);
 386         if (!named_fc) {
 387                 goto end;
 388         }
 389
 390         if (named_fc->fc->type != CTF_FIELD_CLASS_TYPE_INT &&
 391                         named_fc->fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
 392                 goto end;
 393         }
 394
 395         int_fc = (void *) named_fc->fc;
 396
 397 end:
 398         return int_fc;
 399 }
 400
 401 static inline
 402 void ctf_event_class_to_ir(struct ctx *ctx)
 403 {
 404         int ret;
 405         bt_event_class *ir_ec = NULL;
 406         bt_field_class *ir_fc;
 407
 408         BT_ASSERT(ctx->ec);
 409
 410         if (ctx->ec->is_translated) {
 411                 ir_ec = bt_stream_class_borrow_event_class_by_id(
 412                         ctx->ir_sc, ctx->ec->id);
 413                 BT_ASSERT(ir_ec);
 414                 goto end;
 415         }
 416
 417         ir_ec = bt_event_class_create_with_id(ctx->ir_sc, ctx->ec->id);
 418         BT_ASSERT(ir_ec);
 419         bt_event_class_put_ref(ir_ec);
 420         ctx->scope = CTF_SCOPE_EVENT_SPECIFIC_CONTEXT;
 421         ir_fc = scope_ctf_field_class_to_ir(ctx);
 422         if (ir_fc) {
 423                 ret = bt_event_class_set_specific_context_field_class(
 424                         ir_ec, ir_fc);
 425                 BT_ASSERT(ret == 0);
 426                 bt_field_class_put_ref(ir_fc);
 427         }
 428
 429         ctx->scope = CTF_SCOPE_EVENT_PAYLOAD;
 430         ir_fc = scope_ctf_field_class_to_ir(ctx);
 431         if (ir_fc) {
 432                 ret = bt_event_class_set_payload_field_class(ir_ec,
 433                         ir_fc);
 434                 BT_ASSERT(ret == 0);
 435                 bt_field_class_put_ref(ir_fc);
 436         }
 437
 438         if (ctx->ec->name->len > 0) {
 439                 ret = bt_event_class_set_name(ir_ec, ctx->ec->name->str);
 440                 BT_ASSERT(ret == 0);
 441         }
 442
 443         if (ctx->ec->emf_uri->len > 0) {
 444                 ret = bt_event_class_set_emf_uri(ir_ec, ctx->ec->emf_uri->str);
 445                 BT_ASSERT(ret == 0);
 446         }
 447
 448         if (ctx->ec->log_level != -1) {
 449                 bt_event_class_set_log_level(ir_ec, ctx->ec->log_level);
 450         }
 451
 452         ctx->ec->is_translated = true;
 453         ctx->ec->ir_ec = ir_ec;
 454
 455 end:
 456         return;
 457 }
 458
 459
 460 static inline
 461 void ctf_stream_class_to_ir(struct ctx *ctx)
 462 {
 463         int ret;
 464         bt_field_class *ir_fc;
 465
 466         BT_ASSERT(ctx->sc);
 467
 468         if (ctx->sc->is_translated) {
 469                 ctx->ir_sc = bt_trace_class_borrow_stream_class_by_id(
 470                         ctx->ir_tc, ctx->sc->id);
 471                 BT_ASSERT(ctx->ir_sc);
 472                 goto end;
 473         }
 474
 475         ctx->ir_sc = bt_stream_class_create_with_id(ctx->ir_tc, ctx->sc->id);
 476         BT_ASSERT(ctx->ir_sc);
 477         bt_stream_class_put_ref(ctx->ir_sc);
 478         ctx->scope = CTF_SCOPE_PACKET_CONTEXT;
 479         ir_fc = scope_ctf_field_class_to_ir(ctx);
 480         if (ir_fc) {
 481                 ret = bt_stream_class_set_packet_context_field_class(
 482                         ctx->ir_sc, ir_fc);
 483                 BT_ASSERT(ret == 0);
 484                 bt_field_class_put_ref(ir_fc);
 485         }
 486
 487         ctx->scope = CTF_SCOPE_EVENT_COMMON_CONTEXT;
 488         ir_fc = scope_ctf_field_class_to_ir(ctx);
 489         if (ir_fc) {
 490                 ret = bt_stream_class_set_event_common_context_field_class(
 491                         ctx->ir_sc, ir_fc);
 492                 BT_ASSERT(ret == 0);
 493                 bt_field_class_put_ref(ir_fc);
 494         }
 495
 496         bt_stream_class_set_assigns_automatic_event_class_id(ctx->ir_sc,
 497                 BT_FALSE);
 498         bt_stream_class_set_assigns_automatic_stream_id(ctx->ir_sc, BT_FALSE);
 499
 500         if (ctx->sc->default_clock_class) {
 501                 BT_ASSERT(ctx->sc->default_clock_class->ir_cc);
 502                 ret = bt_stream_class_set_default_clock_class(ctx->ir_sc,
 503                         ctx->sc->default_clock_class->ir_cc);
 504                 BT_ASSERT(ret == 0);
 505         }
 506
 507         ctx->sc->is_translated = true;
 508         ctx->sc->ir_sc = ctx->ir_sc;
 509
 510 end:
 511         return;
 512 }
 513
 514 static inline
 515 void ctf_clock_class_to_ir(bt_clock_class *ir_cc, struct ctf_clock_class *cc)
 516 {
 517         int ret;
 518
 519         if (strlen(cc->name->str) > 0) {
 520                 ret = bt_clock_class_set_name(ir_cc, cc->name->str);
 521                 BT_ASSERT(ret == 0);
 522         }
 523
 524         if (strlen(cc->description->str) > 0) {
 525                 ret = bt_clock_class_set_description(ir_cc, cc->description->str);
 526                 BT_ASSERT(ret == 0);
 527         }
 528
 529         bt_clock_class_set_frequency(ir_cc, cc->frequency);
 530         bt_clock_class_set_precision(ir_cc, cc->precision);
 531         bt_clock_class_set_offset(ir_cc, cc->offset_seconds, cc->offset_cycles);
 532
 533         if (cc->has_uuid) {
 534                 bt_clock_class_set_uuid(ir_cc, cc->uuid);
 535         }
 536
 537         bt_clock_class_set_origin_is_unix_epoch(ir_cc, cc->is_absolute);
 538 }
 539
 540 static inline
 541 int ctf_trace_class_to_ir(struct ctx *ctx)
 542 {
 543         int ret = 0;
 544         uint64_t i;
 545
 546         BT_ASSERT(ctx->tc);
 547         BT_ASSERT(ctx->ir_tc);
 548
 549         if (ctx->tc->is_translated) {
 550                 goto end;
 551         }
 552
 553         if (ctx->tc->is_uuid_set) {
 554                 bt_trace_class_set_uuid(ctx->ir_tc, ctx->tc->uuid);
 555         }
 556
 557         for (i = 0; i < ctx->tc->env_entries->len; i++) {
 558                 struct ctf_trace_class_env_entry *env_entry =
 559                         ctf_trace_class_borrow_env_entry_by_index(ctx->tc, i);
 560
 561                 switch (env_entry->type) {
 562                 case CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT:
 563                         ret = bt_trace_class_set_environment_entry_integer(
 564                                 ctx->ir_tc, env_entry->name->str,
 565                                 env_entry->value.i);
 566                         break;
 567                 case CTF_TRACE_CLASS_ENV_ENTRY_TYPE_STR:
 568                         ret = bt_trace_class_set_environment_entry_string(
 569                                 ctx->ir_tc, env_entry->name->str,
 570                                 env_entry->value.str->str);
 571                         break;
 572                 default:
 573                         abort();
 574                 }
 575
 576                 if (ret) {
 577                         goto end;
 578                 }
 579         }
 580
 581         for (i = 0; i < ctx->tc->clock_classes->len; i++) {
 582                 struct ctf_clock_class *cc = ctx->tc->clock_classes->pdata[i];
 583
 584                 cc->ir_cc = bt_clock_class_create(
 585                                 bt_self_component_source_as_self_component(
 586                                         ctx->self_comp));
 587                 ctf_clock_class_to_ir(cc->ir_cc, cc);
 588         }
 589
 590         bt_trace_class_set_assigns_automatic_stream_class_id(ctx->ir_tc,
 591                 BT_FALSE);
 592         ctx->tc->is_translated = true;
 593         ctx->tc->ir_tc = ctx->ir_tc;
 594
 595 end:
 596         return ret;
 597 }
 598
 599 BT_HIDDEN
 600 int ctf_trace_class_translate(bt_self_component_source *self_comp,
 601                 bt_trace_class *ir_tc, struct ctf_trace_class *tc)
 602 {
 603         int ret = 0;
 604         uint64_t i;
 605         struct ctx ctx = { 0 };
 606
 607         ctx.self_comp = self_comp;
 608         ctx.tc = tc;
 609         ctx.ir_tc = ir_tc;
 610         ret = ctf_trace_class_to_ir(&ctx);
 611         if (ret) {
 612                 goto end;
 613         }
 614
 615         for (i = 0; i < tc->stream_classes->len; i++) {
 616                 uint64_t j;
 617                 ctx.sc = tc->stream_classes->pdata[i];
 618
 619                 ctf_stream_class_to_ir(&ctx);
 620
 621                 for (j = 0; j < ctx.sc->event_classes->len; j++) {
 622                         ctx.ec = ctx.sc->event_classes->pdata[j];
 623
 624                         ctf_event_class_to_ir(&ctx);
 625                         ctx.ec = NULL;
 626                 }
 627
 628                 ctx.sc = NULL;
 629         }
 630
 631 end:
 632         return ret;
 633 }