lib/ctf-ir/resolve.c

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