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

   1 /*
   2  * Copyright 2016-2018 - Philippe Proulx <pproulx@efficios.com>
   3  * Copyright 2015 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy
   6  * of this software and associated documentation files (the "Software"), to deal
   7  * in the Software without restriction, including without limitation the rights
   8  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9  * copies of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  */
  15
  16 #define BT_COMP_LOG_SELF_COMP (ctx->self_comp)
  17 #define BT_LOG_OUTPUT_LEVEL (ctx->log_level)
  18 #define BT_LOG_TAG "PLUGIN/CTF/META/RESOLVE"
  19 #include "logging/comp-logging.h"
  20
  21 #include <babeltrace2/babeltrace.h>
  22 #include "common/macros.h"
  23 #include "common/assert.h"
  24 #include "common/common.h"
  25 #include <glib.h>
  26 #include <stdint.h>
  27 #include <string.h>
  28 #include <inttypes.h>
  29 #include <limits.h>
  30 #include <stdlib.h>
  31 #include <glib.h>
  32
  33 #include "ctf-meta-visitors.h"
  34 #include "logging.h"
  35
  36 typedef GPtrArray field_class_stack;
  37
  38 /*
  39  * A stack frame.
  40  *
  41  * `fc` contains a compound field class (structure, variant, array,
  42  * or sequence) and `index` indicates the index of the field class in
  43  * the upper frame (-1 for array and sequence field classes). `name`
  44  * indicates the name of the field class in the upper frame (empty
  45  * string for array and sequence field classes).
  46  */
  47 struct field_class_stack_frame {
  48         struct ctf_field_class *fc;
  49         int64_t index;
  50 };
  51
  52 /*
  53  * The current context of the resolving engine.
  54  */
  55 struct resolve_context {
  56         bt_logging_level log_level;
  57         bt_self_component *self_comp;
  58         struct ctf_trace_class *tc;
  59         struct ctf_stream_class *sc;
  60         struct ctf_event_class *ec;
  61
  62         struct {
  63                 struct ctf_field_class *packet_header;
  64                 struct ctf_field_class *packet_context;
  65                 struct ctf_field_class *event_header;
  66                 struct ctf_field_class *event_common_context;
  67                 struct ctf_field_class *event_spec_context;
  68                 struct ctf_field_class *event_payload;
  69         } scopes;
  70
  71         /* Root scope being visited */
  72         enum ctf_scope root_scope;
  73         field_class_stack *field_class_stack;
  74         struct ctf_field_class *cur_fc;
  75 };
  76
  77 /* TSDL dynamic scope prefixes as defined in CTF Section 7.3.2 */
  78 static const char * const absolute_path_prefixes[] = {
  79         [CTF_SCOPE_PACKET_HEADER]               = "trace.packet.header.",
  80         [CTF_SCOPE_PACKET_CONTEXT]              = "stream.packet.context.",
  81         [CTF_SCOPE_EVENT_HEADER]                = "stream.event.header.",
  82         [CTF_SCOPE_EVENT_COMMON_CONTEXT]        = "stream.event.context.",
  83         [CTF_SCOPE_EVENT_SPECIFIC_CONTEXT]      = "event.context.",
  84         [CTF_SCOPE_EVENT_PAYLOAD]               = "event.fields.",
  85 };
  86
  87 /* Number of path tokens used for the absolute prefixes */
  88 static const uint64_t absolute_path_prefix_ptoken_counts[] = {
  89         [CTF_SCOPE_PACKET_HEADER]               = 3,
  90         [CTF_SCOPE_PACKET_CONTEXT]              = 3,
  91         [CTF_SCOPE_EVENT_HEADER]                = 3,
  92         [CTF_SCOPE_EVENT_COMMON_CONTEXT]        = 3,
  93         [CTF_SCOPE_EVENT_SPECIFIC_CONTEXT]      = 2,
  94         [CTF_SCOPE_EVENT_PAYLOAD]               = 2,
  95 };
  96
  97 static
  98 void destroy_field_class_stack_frame(struct field_class_stack_frame *frame)
  99 {
 100         if (!frame) {
 101                 return;
 102         }
 103
 104         g_free(frame);
 105 }
 106
 107 /*
 108  * Creates a class stack.
 109  */
 110 static
 111 field_class_stack *field_class_stack_create(void)
 112 {
 113         return g_ptr_array_new_with_free_func(
 114                 (GDestroyNotify) destroy_field_class_stack_frame);
 115 }
 116
 117 /*
 118  * Destroys a class stack.
 119  */
 120 static
 121 void field_class_stack_destroy(field_class_stack *stack)
 122 {
 123         if (stack) {
 124                 g_ptr_array_free(stack, TRUE);
 125         }
 126 }
 127
 128 /*
 129  * Pushes a field class onto a class stack.
 130  */
 131 static
 132 int field_class_stack_push(field_class_stack *stack, struct ctf_field_class *fc,
 133                 struct resolve_context *ctx)
 134 {
 135         int ret = 0;
 136         struct field_class_stack_frame *frame = NULL;
 137
 138         if (!stack || !fc) {
 139                 BT_COMP_LOGE("Invalid parameter: stack or field class is NULL.");
 140                 ret = -1;
 141                 goto end;
 142         }
 143
 144         frame = g_new0(struct field_class_stack_frame, 1);
 145         if (!frame) {
 146                 BT_COMP_LOGE_STR("Failed to allocate one field class stack frame.");
 147                 ret = -1;
 148                 goto end;
 149         }
 150
 151         BT_COMP_LOGD("Pushing field class on context's stack: "
 152                 "fc-addr=%p, stack-size-before=%u", fc, stack->len);
 153         frame->fc = fc;
 154         g_ptr_array_add(stack, frame);
 155
 156 end:
 157         return ret;
 158 }
 159
 160 /*
 161  * Checks whether or not `stack` is empty.
 162  */
 163 static
 164 bool field_class_stack_empty(field_class_stack *stack)
 165 {
 166         return stack->len == 0;
 167 }
 168
 169 /*
 170  * Returns the number of frames in `stack`.
 171  */
 172 static
 173 size_t field_class_stack_size(field_class_stack *stack)
 174 {
 175         return stack->len;
 176 }
 177
 178 /*
 179  * Returns the top frame of `stack`.
 180  */
 181 static
 182 struct field_class_stack_frame *field_class_stack_peek(field_class_stack *stack)
 183 {
 184         BT_ASSERT(stack);
 185         BT_ASSERT(!field_class_stack_empty(stack));
 186
 187         return g_ptr_array_index(stack, stack->len - 1);
 188 }
 189
 190 /*
 191  * Returns the frame at index `index` in `stack`.
 192  */
 193 static
 194 struct field_class_stack_frame *field_class_stack_at(field_class_stack *stack,
 195                 size_t index)
 196 {
 197         BT_ASSERT(stack);
 198         BT_ASSERT(index < stack->len);
 199
 200         return g_ptr_array_index(stack, index);
 201 }
 202
 203 /*
 204  * Removes the top frame of `stack`.
 205  */
 206 static
 207 void field_class_stack_pop(field_class_stack *stack,
 208                 struct resolve_context *ctx)
 209 {
 210         if (!field_class_stack_empty(stack)) {
 211                 /*
 212                  * This will call the frame's destructor and free it, as
 213                  * well as put its contained field class.
 214                  */
 215                 BT_COMP_LOGD("Popping context's stack: stack-size-before=%u",
 216                         stack->len);
 217                 g_ptr_array_set_size(stack, stack->len - 1);
 218         }
 219 }
 220
 221 /*
 222  * Returns the scope field class of `scope` in the context `ctx`.
 223  */
 224 static
 225 struct ctf_field_class *borrow_class_from_ctx(struct resolve_context *ctx,
 226                 enum ctf_scope scope)
 227 {
 228         switch (scope) {
 229         case CTF_SCOPE_PACKET_HEADER:
 230                 return ctx->scopes.packet_header;
 231         case CTF_SCOPE_PACKET_CONTEXT:
 232                 return ctx->scopes.packet_context;
 233         case CTF_SCOPE_EVENT_HEADER:
 234                 return ctx->scopes.event_header;
 235         case CTF_SCOPE_EVENT_COMMON_CONTEXT:
 236                 return ctx->scopes.event_common_context;
 237         case CTF_SCOPE_EVENT_SPECIFIC_CONTEXT:
 238                 return ctx->scopes.event_spec_context;
 239         case CTF_SCOPE_EVENT_PAYLOAD:
 240                 return ctx->scopes.event_payload;
 241         default:
 242                 abort();
 243         }
 244
 245         return NULL;
 246 }
 247
 248 /*
 249  * Returns the CTF scope from a path string. May return -1 if the path
 250  * is found to be relative.
 251  */
 252 static
 253 enum ctf_scope get_root_scope_from_absolute_pathstr(const char *pathstr,
 254                 struct resolve_context *ctx)
 255 {
 256         enum ctf_scope scope;
 257         enum ctf_scope ret = CTF_SCOPE_PACKET_UNKNOWN;
 258         const size_t prefixes_count = sizeof(absolute_path_prefixes) /
 259                 sizeof(*absolute_path_prefixes);
 260
 261         for (scope = CTF_SCOPE_PACKET_HEADER; scope < CTF_SCOPE_PACKET_HEADER +
 262                         prefixes_count; scope++) {
 263                 /*
 264                  * Check if path string starts with a known absolute
 265                  * path prefix.
 266                  *
 267                  * Refer to CTF 7.3.2 STATIC AND DYNAMIC SCOPES.
 268                  */
 269                 if (strncmp(pathstr, absolute_path_prefixes[scope],
 270                                 strlen(absolute_path_prefixes[scope]))) {
 271                         /* Prefix does not match: try the next one */
 272                         BT_COMP_LOGD("Prefix does not match: trying the next one: "
 273                                 "path=\"%s\", path-prefix=\"%s\", scope=%s",
 274                                 pathstr, absolute_path_prefixes[scope],
 275                                 ctf_scope_string(scope));
 276                         continue;
 277                 }
 278
 279                 /* Found it! */
 280                 ret = scope;
 281                 BT_COMP_LOGD("Found root scope from absolute path: "
 282                         "path=\"%s\", scope=%s", pathstr,
 283                         ctf_scope_string(scope));
 284                 goto end;
 285         }
 286
 287 end:
 288         return ret;
 289 }
 290
 291 /*
 292  * Destroys a path token.
 293  */
 294 static
 295 void ptokens_destroy_func(gpointer ptoken, gpointer data)
 296 {
 297         g_string_free(ptoken, TRUE);
 298 }
 299
 300 /*
 301  * Destroys a path token list.
 302  */
 303 static
 304 void ptokens_destroy(GList *ptokens)
 305 {
 306         if (!ptokens) {
 307                 return;
 308         }
 309
 310         g_list_foreach(ptokens, ptokens_destroy_func, NULL);
 311         g_list_free(ptokens);
 312 }
 313
 314 /*
 315  * Returns the string contained in a path token.
 316  */
 317 static
 318 const char *ptoken_get_string(GList *ptoken)
 319 {
 320         GString *tokenstr = (GString *) ptoken->data;
 321
 322         return tokenstr->str;
 323 }
 324
 325 /*
 326  * Converts a path string to a path token list, that is, splits the
 327  * individual words of a path string into a list of individual
 328  * strings.
 329  */
 330 static
 331 GList *pathstr_to_ptokens(const char *pathstr, struct resolve_context *ctx)
 332 {
 333         const char *at = pathstr;
 334         const char *last = at;
 335         GList *ptokens = NULL;
 336
 337         for (;;) {
 338                 if (*at == '.' || *at == '\0') {
 339                         GString *tokenstr;
 340
 341                         if (at == last) {
 342                                 /* Error: empty token */
 343                                 BT_COMP_LOGE("Empty path token: path=\"%s\", pos=%u",
 344                                         pathstr, (unsigned int) (at - pathstr));
 345                                 goto error;
 346                         }
 347
 348                         tokenstr = g_string_new(NULL);
 349                         g_string_append_len(tokenstr, last, at - last);
 350                         ptokens = g_list_append(ptokens, tokenstr);
 351                         last = at + 1;
 352                 }
 353
 354                 if (*at == '\0') {
 355                         break;
 356                 }
 357
 358                 at++;
 359         }
 360
 361         return ptokens;
 362
 363 error:
 364         ptokens_destroy(ptokens);
 365         return NULL;
 366 }
 367
 368 /*
 369  * Converts a path token list to a field path object. The path token
 370  * list is relative from `fc`. The index of the source looking for its
 371  * target within `fc` is indicated by `src_index`. This can be
 372  * `INT64_MAX` if the source is contained in `fc`.
 373  *
 374  * `field_path` is an output parameter owned by the caller that must be
 375  * filled here.
 376  */
 377 static
 378 int ptokens_to_field_path(GList *ptokens, struct ctf_field_path *field_path,
 379                 struct ctf_field_class *fc, int64_t src_index,
 380                 struct resolve_context *ctx)
 381 {
 382         int ret = 0;
 383         GList *cur_ptoken = ptokens;
 384         bool first_level_done = false;
 385
 386         /* Locate target */
 387         while (cur_ptoken) {
 388                 int64_t child_index;
 389                 struct ctf_field_class *child_fc;
 390                 const char *ft_name = ptoken_get_string(cur_ptoken);
 391
 392                 BT_COMP_LOGD("Current path token: token=\"%s\"", ft_name);
 393
 394                 /* Find to which index corresponds the current path token */
 395                 if (fc->type == CTF_FIELD_CLASS_TYPE_ARRAY ||
 396                                 fc->type == CTF_FIELD_CLASS_TYPE_SEQUENCE) {
 397                         child_index = -1;
 398                 } else {
 399                         child_index =
 400                                 ctf_field_class_compound_get_field_class_index_from_orig_name(
 401                                         fc, ft_name);
 402                         if (child_index < 0) {
 403                                 /*
 404                                  * Error: field name does not exist or
 405                                  * wrong current class.
 406                                  */
 407                                 BT_COMP_LOGD("Cannot get index of field class: "
 408                                         "field-name=\"%s\", "
 409                                         "src-index=%" PRId64 ", "
 410                                         "child-index=%" PRId64 ", "
 411                                         "first-level-done=%d",
 412                                         ft_name, src_index, child_index,
 413                                         first_level_done);
 414                                 ret = -1;
 415                                 goto end;
 416                         } else if (child_index > src_index &&
 417                                         !first_level_done) {
 418                                 BT_COMP_LOGD("Child field class is located after source field class: "
 419                                         "field-name=\"%s\", "
 420                                         "src-index=%" PRId64 ", "
 421                                         "child-index=%" PRId64 ", "
 422                                         "first-level-done=%d",
 423                                         ft_name, src_index, child_index,
 424                                         first_level_done);
 425                                 ret = -1;
 426                                 goto end;
 427                         }
 428
 429                         /* Next path token */
 430                         cur_ptoken = g_list_next(cur_ptoken);
 431                         first_level_done = true;
 432                 }
 433
 434                 /* Create new field path entry */
 435                 ctf_field_path_append_index(field_path, child_index);
 436
 437                 /* Get child field class */
 438                 child_fc = ctf_field_class_compound_borrow_field_class_by_index(
 439                         fc, child_index);
 440                 BT_ASSERT(child_fc);
 441
 442                 /* Move child class to current class */
 443                 fc = child_fc;
 444         }
 445
 446 end:
 447         return ret;
 448 }
 449
 450 /*
 451  * Converts a known absolute path token list to a field path object
 452  * within the resolving context `ctx`.
 453  *
 454  * `field_path` is an output parameter owned by the caller that must be
 455  * filled here.
 456  */
 457 static
 458 int absolute_ptokens_to_field_path(GList *ptokens,
 459                 struct ctf_field_path *field_path,
 460                 struct resolve_context *ctx)
 461 {
 462         int ret = 0;
 463         GList *cur_ptoken;
 464         struct ctf_field_class *fc;
 465
 466         /*
 467          * Make sure we're not referring to a scope within a translated
 468          * object.
 469          */
 470         switch (field_path->root) {
 471         case CTF_SCOPE_PACKET_HEADER:
 472                 if (ctx->tc->is_translated) {
 473                         BT_COMP_LOGE("Trace class is already translated: "
 474                                 "root-scope=%s",
 475                                 ctf_scope_string(field_path->root));
 476                         ret = -1;
 477                         goto end;
 478                 }
 479
 480                 break;
 481         case CTF_SCOPE_PACKET_CONTEXT:
 482         case CTF_SCOPE_EVENT_HEADER:
 483         case CTF_SCOPE_EVENT_COMMON_CONTEXT:
 484                 if (!ctx->sc) {
 485                         BT_COMP_LOGE("No current stream class: "
 486                                 "root-scope=%s",
 487                                 ctf_scope_string(field_path->root));
 488                         ret = -1;
 489                         goto end;
 490                 }
 491
 492                 if (ctx->sc->is_translated) {
 493                         BT_COMP_LOGE("Stream class is already translated: "
 494                                 "root-scope=%s",
 495                                 ctf_scope_string(field_path->root));
 496                         ret = -1;
 497                         goto end;
 498                 }
 499
 500                 break;
 501         case CTF_SCOPE_EVENT_SPECIFIC_CONTEXT:
 502         case CTF_SCOPE_EVENT_PAYLOAD:
 503                 if (!ctx->ec) {
 504                         BT_COMP_LOGE("No current event class: "
 505                                 "root-scope=%s",
 506                                 ctf_scope_string(field_path->root));
 507                         ret = -1;
 508                         goto end;
 509                 }
 510
 511                 if (ctx->ec->is_translated) {
 512                         BT_COMP_LOGE("Event class is already translated: "
 513                                 "root-scope=%s",
 514                                 ctf_scope_string(field_path->root));
 515                         ret = -1;
 516                         goto end;
 517                 }
 518
 519                 break;
 520
 521         default:
 522                 abort();
 523         }
 524
 525         /* Skip absolute path tokens */
 526         cur_ptoken = g_list_nth(ptokens,
 527                 absolute_path_prefix_ptoken_counts[field_path->root]);
 528
 529         /* Start with root class */
 530         fc = borrow_class_from_ctx(ctx, field_path->root);
 531         if (!fc) {
 532                 /* Error: root class is not available */
 533                 BT_COMP_LOGE("Root field class is not available: "
 534                         "root-scope=%s",
 535                         ctf_scope_string(field_path->root));
 536                 ret = -1;
 537                 goto end;
 538         }
 539
 540         /* Locate target */
 541         ret = ptokens_to_field_path(cur_ptoken, field_path, fc, INT64_MAX, ctx);
 542
 543 end:
 544         return ret;
 545 }
 546
 547 /*
 548  * Converts a known relative path token list to a field path object
 549  * within the resolving context `ctx`.
 550  *
 551  * `field_path` is an output parameter owned by the caller that must be
 552  * filled here.
 553  */
 554 static
 555 int relative_ptokens_to_field_path(GList *ptokens,
 556                 struct ctf_field_path *field_path, struct resolve_context *ctx)
 557 {
 558         int ret = 0;
 559         int64_t parent_pos_in_stack;
 560         struct ctf_field_path tail_field_path;
 561
 562         ctf_field_path_init(&tail_field_path);
 563         parent_pos_in_stack = field_class_stack_size(ctx->field_class_stack) - 1;
 564
 565         while (parent_pos_in_stack >= 0) {
 566                 struct ctf_field_class *parent_class =
 567                         field_class_stack_at(ctx->field_class_stack,
 568                                 parent_pos_in_stack)->fc;
 569                 int64_t cur_index = field_class_stack_at(ctx->field_class_stack,
 570                         parent_pos_in_stack)->index;
 571
 572                 BT_COMP_LOGD("Locating target field class from current parent field class: "
 573                         "parent-pos=%" PRId64 ", parent-fc-addr=%p, "
 574                         "cur-index=%" PRId64,
 575                         parent_pos_in_stack, parent_class, cur_index);
 576
 577                 /* Locate target from current parent class */
 578                 ret = ptokens_to_field_path(ptokens, &tail_field_path,
 579                         parent_class, cur_index, ctx);
 580                 if (ret) {
 581                         /* Not found... yet */
 582                         BT_COMP_LOGD_STR("Not found at this point.");
 583                         ctf_field_path_clear(&tail_field_path);
 584                 } else {
 585                         /* Found: stitch tail field path to head field path */
 586                         uint64_t i = 0;
 587                         size_t tail_field_path_len =
 588                                 tail_field_path.path->len;
 589
 590                         while (BT_TRUE) {
 591                                 struct ctf_field_class *cur_class =
 592                                         field_class_stack_at(
 593                                                 ctx->field_class_stack, i)->fc;
 594                                 int64_t index = field_class_stack_at(
 595                                         ctx->field_class_stack, i)->index;
 596
 597                                 if (cur_class == parent_class) {
 598                                         break;
 599                                 }
 600
 601                                 ctf_field_path_append_index(field_path,
 602                                         index);
 603                                 i++;
 604                         }
 605
 606                         for (i = 0; i < tail_field_path_len; i++) {
 607                                 int64_t index =
 608                                         ctf_field_path_borrow_index_by_index(
 609                                                 &tail_field_path, i);
 610
 611                                 ctf_field_path_append_index(field_path,
 612                                         (int64_t) index);
 613                         }
 614                         break;
 615                 }
 616
 617                 parent_pos_in_stack--;
 618         }
 619
 620         if (parent_pos_in_stack < 0) {
 621                 /* Not found */
 622                 ret = -1;
 623         }
 624
 625         ctf_field_path_fini(&tail_field_path);
 626         return ret;
 627 }
 628
 629 /*
 630  * Converts a path string to a field path object within the resolving
 631  * context `ctx`.
 632  */
 633 static
 634 int pathstr_to_field_path(const char *pathstr,
 635                 struct ctf_field_path *field_path, struct resolve_context *ctx)
 636 {
 637         int ret = 0;
 638         enum ctf_scope root_scope;
 639         GList *ptokens = NULL;
 640
 641         /* Convert path string to path tokens */
 642         ptokens = pathstr_to_ptokens(pathstr, ctx);
 643         if (!ptokens) {
 644                 BT_COMP_LOGE("Cannot convert path string to path tokens: "
 645                         "path=\"%s\"", pathstr);
 646                 ret = -1;
 647                 goto end;
 648         }
 649
 650         /* Absolute or relative path? */
 651         root_scope = get_root_scope_from_absolute_pathstr(pathstr, ctx);
 652
 653         if (root_scope == CTF_SCOPE_PACKET_UNKNOWN) {
 654                 /* Relative path: start with current root scope */
 655                 field_path->root = ctx->root_scope;
 656                 BT_COMP_LOGD("Detected relative path: starting with current root scope: "
 657                         "scope=%s", ctf_scope_string(field_path->root));
 658                 ret = relative_ptokens_to_field_path(ptokens, field_path, ctx);
 659                 if (ret) {
 660                         BT_COMP_LOGE("Cannot get relative field path of path string: "
 661                                 "path=\"%s\", start-scope=%s, end-scope=%s",
 662                                 pathstr, ctf_scope_string(ctx->root_scope),
 663                                 ctf_scope_string(field_path->root));
 664                         goto end;
 665                 }
 666         } else {
 667                 /* Absolute path: use found root scope */
 668                 field_path->root = root_scope;
 669                 BT_COMP_LOGD("Detected absolute path: using root scope: "
 670                         "scope=%s", ctf_scope_string(field_path->root));
 671                 ret = absolute_ptokens_to_field_path(ptokens, field_path, ctx);
 672                 if (ret) {
 673                         BT_COMP_LOGE("Cannot get absolute field path of path string: "
 674                                 "path=\"%s\", root-scope=%s",
 675                                 pathstr, ctf_scope_string(root_scope));
 676                         goto end;
 677                 }
 678         }
 679
 680         if (BT_LOG_ON_TRACE && ret == 0) {
 681                 GString *field_path_pretty = ctf_field_path_string(field_path);
 682                 const char *field_path_pretty_str =
 683                         field_path_pretty ? field_path_pretty->str : NULL;
 684
 685                 BT_COMP_LOGD("Found field path: path=\"%s\", field-path=\"%s\"",
 686                         pathstr, field_path_pretty_str);
 687
 688                 if (field_path_pretty) {
 689                         g_string_free(field_path_pretty, TRUE);
 690                 }
 691         }
 692
 693 end:
 694         ptokens_destroy(ptokens);
 695         return ret;
 696 }
 697
 698 /*
 699  * Retrieves a field class by following the field path `field_path` in
 700  * the resolving context `ctx`.
 701  */
 702 static
 703 struct ctf_field_class *field_path_to_field_class(
 704                 struct ctf_field_path *field_path, struct resolve_context *ctx)
 705 {
 706         uint64_t i;
 707         struct ctf_field_class *fc;
 708
 709         /* Start with root class */
 710         fc = borrow_class_from_ctx(ctx, field_path->root);
 711         if (!fc) {
 712                 /* Error: root class is not available */
 713                 BT_COMP_LOGE("Root field class is not available: root-scope=%s",
 714                         ctf_scope_string(field_path->root));
 715                 goto end;
 716         }
 717
 718         /* Locate target */
 719         for (i = 0; i < field_path->path->len; i++) {
 720                 struct ctf_field_class *child_fc;
 721                 int64_t child_index =
 722                         ctf_field_path_borrow_index_by_index(field_path, i);
 723
 724                 /* Get child field class */
 725                 child_fc = ctf_field_class_compound_borrow_field_class_by_index(
 726                         fc, child_index);
 727                 BT_ASSERT(child_fc);
 728
 729                 /* Move child class to current class */
 730                 fc = child_fc;
 731         }
 732
 733 end:
 734         return fc;
 735 }
 736
 737 /*
 738  * Fills the equivalent field path object of the context class stack.
 739  */
 740 static
 741 void get_ctx_stack_field_path(struct resolve_context *ctx,
 742                 struct ctf_field_path *field_path)
 743 {
 744         uint64_t i;
 745
 746         BT_ASSERT(field_path);
 747         field_path->root = ctx->root_scope;
 748         ctf_field_path_clear(field_path);
 749
 750         for (i = 0; i < field_class_stack_size(ctx->field_class_stack); i++) {
 751                 struct field_class_stack_frame *frame =
 752                         field_class_stack_at(ctx->field_class_stack, i);
 753
 754                 ctf_field_path_append_index(field_path, frame->index);
 755         }
 756 }
 757
 758 /*
 759  * Returns the index of the lowest common ancestor of two field path
 760  * objects having the same root scope.
 761  */
 762 int64_t get_field_paths_lca_index(struct ctf_field_path *field_path1,
 763                 struct ctf_field_path *field_path2,
 764                 struct resolve_context *ctx)
 765 {
 766         int64_t lca_index = 0;
 767         uint64_t field_path1_len, field_path2_len;
 768
 769         if (BT_LOG_ON_TRACE) {
 770                 GString *field_path1_pretty =
 771                         ctf_field_path_string(field_path1);
 772                 GString *field_path2_pretty =
 773                         ctf_field_path_string(field_path2);
 774                 const char *field_path1_pretty_str =
 775                         field_path1_pretty ? field_path1_pretty->str : NULL;
 776                 const char *field_path2_pretty_str =
 777                         field_path2_pretty ? field_path2_pretty->str : NULL;
 778
 779                 BT_COMP_LOGD("Finding lowest common ancestor (LCA) between two field paths: "
 780                         "field-path-1=\"%s\", field-path-2=\"%s\"",
 781                         field_path1_pretty_str, field_path2_pretty_str);
 782
 783                 if (field_path1_pretty) {
 784                         g_string_free(field_path1_pretty, TRUE);
 785                 }
 786
 787                 if (field_path2_pretty) {
 788                         g_string_free(field_path2_pretty, TRUE);
 789                 }
 790         }
 791
 792         /*
 793          * Start from both roots and find the first mismatch.
 794          */
 795         BT_ASSERT(field_path1->root == field_path2->root);
 796         field_path1_len = field_path1->path->len;
 797         field_path2_len = field_path2->path->len;
 798
 799         while (true) {
 800                 int64_t target_index, ctx_index;
 801
 802                 if (lca_index == (int64_t) field_path2_len ||
 803                                 lca_index == (int64_t) field_path1_len) {
 804                         /*
 805                          * This means that both field paths never split.
 806                          * This is invalid because the target cannot be
 807                          * an ancestor of the source.
 808                          */
 809                         BT_COMP_LOGE("Source field class is an ancestor of target field class or vice versa: "
 810                                 "lca-index=%" PRId64 ", "
 811                                 "field-path-1-len=%" PRIu64 ", "
 812                                 "field-path-2-len=%" PRIu64,
 813                                 lca_index, field_path1_len, field_path2_len);
 814                         lca_index = -1;
 815                         break;
 816                 }
 817
 818                 target_index = ctf_field_path_borrow_index_by_index(field_path1,
 819                         lca_index);
 820                 ctx_index = ctf_field_path_borrow_index_by_index(field_path2,
 821                         lca_index);
 822
 823                 if (target_index != ctx_index) {
 824                         /* LCA index is the previous */
 825                         break;
 826                 }
 827
 828                 lca_index++;
 829         }
 830
 831         BT_COMP_LOGD("Found LCA: lca-index=%" PRId64, lca_index);
 832         return lca_index;
 833 }
 834
 835 /*
 836  * Validates a target field path.
 837  */
 838 static
 839 int validate_target_field_path(struct ctf_field_path *target_field_path,
 840                 struct ctf_field_class *target_fc,
 841                 struct resolve_context *ctx)
 842 {
 843         int ret = 0;
 844         struct ctf_field_path ctx_field_path;
 845         uint64_t target_field_path_len = target_field_path->path->len;
 846         int64_t lca_index;
 847
 848         /* Get context field path */
 849         ctf_field_path_init(&ctx_field_path);
 850         get_ctx_stack_field_path(ctx, &ctx_field_path);
 851
 852         /*
 853          * Make sure the target is not a root.
 854          */
 855         if (target_field_path_len == 0) {
 856                 BT_COMP_LOGE_STR("Target field path's length is 0 (targeting the root).");
 857                 ret = -1;
 858                 goto end;
 859         }
 860
 861         /*
 862          * Make sure the root of the target field path is not located
 863          * after the context field path's root.
 864          */
 865         if (target_field_path->root > ctx_field_path.root) {
 866                 BT_COMP_LOGE("Target field class is located after source field class: "
 867                         "target-root=%s, source-root=%s",
 868                         ctf_scope_string(target_field_path->root),
 869                         ctf_scope_string(ctx_field_path.root));
 870                 ret = -1;
 871                 goto end;
 872         }
 873
 874         if (target_field_path->root == ctx_field_path.root) {
 875                 int64_t target_index, ctx_index;
 876
 877                 /*
 878                  * Find the index of the lowest common ancestor of both field
 879                  * paths.
 880                  */
 881                 lca_index = get_field_paths_lca_index(target_field_path,
 882                         &ctx_field_path, ctx);
 883                 if (lca_index < 0) {
 884                         BT_COMP_LOGE_STR("Cannot get least common ancestor.");
 885                         ret = -1;
 886                         goto end;
 887                 }
 888
 889                 /*
 890                  * Make sure the target field path is located before the
 891                  * context field path.
 892                  */
 893                 target_index = ctf_field_path_borrow_index_by_index(
 894                         target_field_path, (uint64_t) lca_index);
 895                 ctx_index = ctf_field_path_borrow_index_by_index(
 896                         &ctx_field_path, (uint64_t) lca_index);
 897
 898                 if (target_index >= ctx_index) {
 899                         BT_COMP_LOGE("Target field class's index is greater than or equal to source field class's index in LCA: "
 900                                 "lca-index=%" PRId64 ", "
 901                                 "target-index=%" PRId64 ", "
 902                                 "source-index=%" PRId64,
 903                                 lca_index, target_index, ctx_index);
 904                         ret = -1;
 905                         goto end;
 906                 }
 907         }
 908
 909         /*
 910          * Make sure the target class has the right class and properties.
 911          */
 912         switch (ctx->cur_fc->type) {
 913         case CTF_FIELD_CLASS_TYPE_VARIANT:
 914                 if (target_fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
 915                         BT_COMP_LOGE("Variant field class's tag field class is not an enumeration field class: "
 916                                 "tag-fc-addr=%p, tag-fc-id=%d",
 917                                 target_fc, target_fc->type);
 918                         ret = -1;
 919                         goto end;
 920                 }
 921                 break;
 922         case CTF_FIELD_CLASS_TYPE_SEQUENCE:
 923         {
 924                 struct ctf_field_class_int *int_fc = (void *) target_fc;
 925
 926                 if (target_fc->type != CTF_FIELD_CLASS_TYPE_INT &&
 927                                 target_fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
 928                         BT_COMP_LOGE("Sequence field class's length field class is not an unsigned integer field class: "
 929                                 "length-fc-addr=%p, length-fc-id=%d",
 930                                 target_fc, target_fc->type);
 931                         ret = -1;
 932                         goto end;
 933                 }
 934
 935                 if (int_fc->is_signed) {
 936                         BT_COMP_LOGE("Sequence field class's length field class is not an unsigned integer field class: "
 937                                 "length-fc-addr=%p, length-fc-id=%d",
 938                                 target_fc, target_fc->type);
 939                         ret = -1;
 940                         goto end;
 941                 }
 942                 break;
 943         }
 944         default:
 945                 abort();
 946         }
 947
 948 end:
 949         ctf_field_path_fini(&ctx_field_path);
 950         return ret;
 951 }
 952
 953 /*
 954  * Resolves a variant or sequence field class `fc`.
 955  */
 956 static
 957 int resolve_sequence_or_variant_field_class(struct ctf_field_class *fc,
 958                 struct resolve_context *ctx)
 959 {
 960         int ret = 0;
 961         const char *pathstr;
 962         struct ctf_field_path target_field_path;
 963         struct ctf_field_class *target_fc = NULL;
 964         GString *target_field_path_pretty = NULL;
 965         const char *target_field_path_pretty_str;
 966
 967         ctf_field_path_init(&target_field_path);
 968
 969         /* Get path string */
 970         switch (fc->type) {
 971         case CTF_FIELD_CLASS_TYPE_SEQUENCE:
 972         {
 973                 struct ctf_field_class_sequence *seq_fc = (void *) fc;
 974                 pathstr = seq_fc->length_ref->str;
 975                 break;
 976         }
 977         case CTF_FIELD_CLASS_TYPE_VARIANT:
 978         {
 979                 struct ctf_field_class_variant *var_fc = (void *) fc;
 980                 pathstr = var_fc->tag_ref->str;
 981                 break;
 982         }
 983         default:
 984                 abort();
 985         }
 986
 987         if (!pathstr) {
 988                 BT_COMP_LOGE_STR("Cannot get path string.");
 989                 ret = -1;
 990                 goto end;
 991         }
 992
 993         /* Get target field path out of path string */
 994         ret = pathstr_to_field_path(pathstr, &target_field_path, ctx);
 995         if (ret) {
 996                 BT_COMP_LOGE("Cannot get target field path for path string: "
 997                         "path=\"%s\"", pathstr);
 998                 goto end;
 999         }
1000
1001         target_field_path_pretty = ctf_field_path_string(
1002                 &target_field_path);
1003         target_field_path_pretty_str =
1004                 target_field_path_pretty ? target_field_path_pretty->str : NULL;
1005
1006         /* Get target field class */
1007         target_fc = field_path_to_field_class(&target_field_path, ctx);
1008         if (!target_fc) {
1009                 BT_COMP_LOGE("Cannot get target field class for path string: "
1010                         "path=\"%s\", target-field-path=\"%s\"",
1011                         pathstr, target_field_path_pretty_str);
1012                 ret = -1;
1013                 goto end;
1014         }
1015
1016         ret = validate_target_field_path(&target_field_path,
1017                 target_fc, ctx);
1018         if (ret) {
1019                 BT_COMP_LOGE("Invalid target field path for path string: "
1020                         "path=\"%s\", target-field-path=\"%s\"",
1021                         pathstr, target_field_path_pretty_str);
1022                 goto end;
1023         }
1024
1025         /* Set target field path and target field class */
1026         switch (fc->type) {
1027         case CTF_FIELD_CLASS_TYPE_SEQUENCE:
1028         {
1029                 struct ctf_field_class_sequence *seq_fc = (void *) fc;
1030
1031                 ctf_field_path_copy_content(&seq_fc->length_path,
1032                         &target_field_path);
1033                 seq_fc->length_fc = (void *) target_fc;
1034                 break;
1035         }
1036         case CTF_FIELD_CLASS_TYPE_VARIANT:
1037         {
1038                 struct ctf_field_class_variant *var_fc = (void *) fc;
1039
1040                 ctf_field_path_copy_content(&var_fc->tag_path,
1041                         &target_field_path);
1042                 ctf_field_class_variant_set_tag_field_class(var_fc,
1043                         (void *) target_fc);
1044                 break;
1045         }
1046         default:
1047                 abort();
1048         }
1049
1050 end:
1051         if (target_field_path_pretty) {
1052                 g_string_free(target_field_path_pretty, TRUE);
1053         }
1054
1055         ctf_field_path_fini(&target_field_path);
1056         return ret;
1057 }
1058
1059 /*
1060  * Resolves a field class `fc`.
1061  */
1062 static
1063 int resolve_field_class(struct ctf_field_class *fc, struct resolve_context *ctx)
1064 {
1065         int ret = 0;
1066
1067         if (!fc) {
1068                 /* Field class is not available; still valid */
1069                 goto end;
1070         }
1071
1072         ctx->cur_fc = fc;
1073
1074         /* Resolve sequence/variant field class */
1075         switch (fc->type) {
1076         case CTF_FIELD_CLASS_TYPE_SEQUENCE:
1077         case CTF_FIELD_CLASS_TYPE_VARIANT:
1078                 ret = resolve_sequence_or_variant_field_class(fc, ctx);
1079                 if (ret) {
1080                         BT_COMP_LOGE("Cannot resolve sequence field class's length or variant field class's tag: "
1081                                 "ret=%d, fc-addr=%p", ret, fc);
1082                         goto end;
1083                 }
1084
1085                 break;
1086         default:
1087                 break;
1088         }
1089
1090         /* Recurse into compound classes */
1091         switch (fc->type) {
1092         case CTF_FIELD_CLASS_TYPE_STRUCT:
1093         case CTF_FIELD_CLASS_TYPE_VARIANT:
1094         case CTF_FIELD_CLASS_TYPE_SEQUENCE:
1095         case CTF_FIELD_CLASS_TYPE_ARRAY:
1096         {
1097                 uint64_t i;
1098                 uint64_t field_count =
1099                         ctf_field_class_compound_get_field_class_count(fc);
1100
1101                 ret = field_class_stack_push(ctx->field_class_stack, fc, ctx);
1102                 if (ret) {
1103                         BT_COMP_LOGE("Cannot push field class on context's stack: "
1104                                 "fc-addr=%p", fc);
1105                         goto end;
1106                 }
1107
1108                 for (i = 0; i < field_count; i++) {
1109                         struct ctf_field_class *child_fc =
1110                                 ctf_field_class_compound_borrow_field_class_by_index(
1111                                         fc, i);
1112
1113                         BT_ASSERT(child_fc);
1114
1115                         if (fc->type == CTF_FIELD_CLASS_TYPE_ARRAY||
1116                                         fc->type == CTF_FIELD_CLASS_TYPE_SEQUENCE) {
1117                                 field_class_stack_peek(
1118                                         ctx->field_class_stack)->index = -1;
1119                         } else {
1120                                 field_class_stack_peek(
1121                                         ctx->field_class_stack)->index =
1122                                                 (int64_t) i;
1123                         }
1124
1125                         BT_COMP_LOGD("Resolving field class's child field class: "
1126                                 "parent-fc-addr=%p, child-fc-addr=%p, "
1127                                 "index=%" PRIu64 ", count=%" PRIu64,
1128                                 fc, child_fc, i, field_count);
1129                         ret = resolve_field_class(child_fc, ctx);
1130                         if (ret) {
1131                                 goto end;
1132                         }
1133                 }
1134
1135                 field_class_stack_pop(ctx->field_class_stack, ctx);
1136                 break;
1137         }
1138         default:
1139                 break;
1140         }
1141
1142 end:
1143         return ret;
1144 }
1145
1146 /*
1147  * Resolves the root field class corresponding to the scope `root_scope`.
1148  */
1149 static
1150 int resolve_root_class(enum ctf_scope root_scope, struct resolve_context *ctx)
1151 {
1152         int ret;
1153
1154         BT_ASSERT(field_class_stack_size(ctx->field_class_stack) == 0);
1155         ctx->root_scope = root_scope;
1156         ret = resolve_field_class(borrow_class_from_ctx(ctx, root_scope), ctx);
1157         ctx->root_scope = -1;
1158         return ret;
1159 }
1160
1161 static
1162 int resolve_event_class_field_classes(struct resolve_context *ctx,
1163                 struct ctf_event_class *ec)
1164 {
1165         int ret = 0;
1166
1167         BT_ASSERT(!ctx->scopes.event_spec_context);
1168         BT_ASSERT(!ctx->scopes.event_payload);
1169
1170         if (ec->is_translated) {
1171                 goto end;
1172         }
1173
1174         ctx->ec = ec;
1175         ctx->scopes.event_spec_context = ec->spec_context_fc;
1176         ret = resolve_root_class(CTF_SCOPE_EVENT_COMMON_CONTEXT, ctx);
1177         if (ret) {
1178                 BT_COMP_LOGE("Cannot resolve event specific context field class: "
1179                         "ret=%d", ret);
1180                 goto end;
1181         }
1182
1183         ctx->scopes.event_payload = ec->payload_fc;
1184         ret = resolve_root_class(CTF_SCOPE_EVENT_PAYLOAD, ctx);
1185         if (ret) {
1186                 BT_COMP_LOGE("Cannot resolve event payload field class: "
1187                         "ret=%d", ret);
1188                 goto end;
1189         }
1190
1191 end:
1192         ctx->scopes.event_spec_context = NULL;
1193         ctx->scopes.event_payload = NULL;
1194         ctx->ec = NULL;
1195         return ret;
1196 }
1197
1198 static
1199 int resolve_stream_class_field_classes(struct resolve_context *ctx,
1200                 struct ctf_stream_class *sc)
1201 {
1202         int ret = 0;
1203         uint64_t i;
1204
1205         BT_ASSERT(!ctx->scopes.packet_context);
1206         BT_ASSERT(!ctx->scopes.event_header);
1207         BT_ASSERT(!ctx->scopes.event_common_context);
1208         ctx->sc = sc;
1209
1210         if (!sc->is_translated) {
1211                 ctx->scopes.packet_context = sc->packet_context_fc;
1212                 ret = resolve_root_class(CTF_SCOPE_PACKET_CONTEXT, ctx);
1213                 if (ret) {
1214                         BT_COMP_LOGE("Cannot resolve packet context field class: "
1215                                 "ret=%d", ret);
1216                         goto end;
1217                 }
1218
1219                 ctx->scopes.event_header = sc->event_header_fc;
1220                 ret = resolve_root_class(CTF_SCOPE_EVENT_HEADER, ctx);
1221                 if (ret) {
1222                         BT_COMP_LOGE("Cannot resolve event header field class: "
1223                                 "ret=%d", ret);
1224                         goto end;
1225                 }
1226
1227                 ctx->scopes.event_common_context = sc->event_common_context_fc;
1228                 ret = resolve_root_class(CTF_SCOPE_EVENT_SPECIFIC_CONTEXT, ctx);
1229                 if (ret) {
1230                         BT_COMP_LOGE("Cannot resolve event common context field class: "
1231                                 "ret=%d", ret);
1232                         goto end;
1233                 }
1234         }
1235
1236         ctx->scopes.packet_context = sc->packet_context_fc;
1237         ctx->scopes.event_header = sc->event_header_fc;
1238         ctx->scopes.event_common_context = sc->event_common_context_fc;
1239
1240         for (i = 0; i < sc->event_classes->len; i++) {
1241                 struct ctf_event_class *ec = sc->event_classes->pdata[i];
1242
1243                 ret = resolve_event_class_field_classes(ctx, ec);
1244                 if (ret) {
1245                         BT_COMP_LOGE("Cannot resolve event class's field classes: "
1246                                 "ec-id=%" PRIu64 ", ec-name=\"%s\"",
1247                                 ec->id, ec->name->str);
1248                         goto end;
1249                 }
1250         }
1251
1252 end:
1253         ctx->scopes.packet_context = NULL;
1254         ctx->scopes.event_header = NULL;
1255         ctx->scopes.event_common_context = NULL;
1256         ctx->sc = NULL;
1257         return ret;
1258 }
1259
1260 BT_HIDDEN
1261 int ctf_trace_class_resolve_field_classes(struct ctf_trace_class *tc,
1262                 struct meta_log_config *log_cfg)
1263 {
1264         int ret = 0;
1265         uint64_t i;
1266         struct resolve_context local_ctx = {
1267                 .log_level = log_cfg->log_level,
1268                 .self_comp = log_cfg->self_comp,
1269                 .tc = tc,
1270                 .sc = NULL,
1271                 .ec = NULL,
1272                 .scopes = {
1273                         .packet_header = tc->packet_header_fc,
1274                         .packet_context = NULL,
1275                         .event_header = NULL,
1276                         .event_common_context = NULL,
1277                         .event_spec_context = NULL,
1278                         .event_payload = NULL,
1279                 },
1280                 .root_scope = CTF_SCOPE_PACKET_HEADER,
1281                 .cur_fc = NULL,
1282         };
1283         struct resolve_context *ctx = &local_ctx;
1284
1285         /* Initialize class stack */
1286         ctx->field_class_stack = field_class_stack_create();
1287         if (!ctx->field_class_stack) {
1288                 BT_COMP_LOGE_STR("Cannot create field class stack.");
1289                 ret = -1;
1290                 goto end;
1291         }
1292
1293         if (!tc->is_translated) {
1294                 ctx->scopes.packet_header = tc->packet_header_fc;
1295                 ret = resolve_root_class(CTF_SCOPE_PACKET_HEADER, ctx);
1296                 if (ret) {
1297                         BT_COMP_LOGE("Cannot resolve packet header field class: "
1298                                 "ret=%d", ret);
1299                         goto end;
1300                 }
1301         }
1302
1303         ctx->scopes.packet_header = tc->packet_header_fc;
1304
1305         for (i = 0; i < tc->stream_classes->len; i++) {
1306                 struct ctf_stream_class *sc = tc->stream_classes->pdata[i];
1307
1308                 ret = resolve_stream_class_field_classes(ctx, sc);
1309                 if (ret) {
1310                         BT_COMP_LOGE("Cannot resolve stream class's field classes: "
1311                                 "sc-id=%" PRIu64, sc->id);
1312                         goto end;
1313                 }
1314         }
1315
1316 end:
1317         field_class_stack_destroy(ctx->field_class_stack);
1318         return ret;
1319 }