[babeltrace.git] / src / plugins / ctf / common / metadata / ctf-meta-resolve.c

/*
 * Copyright 2016-2018 - Philippe Proulx <pproulx@efficios.com>
 * Copyright 2015 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 */

#define BT_COMP_LOG_SELF_COMP (ctx->self_comp)
#define BT_LOG_OUTPUT_LEVEL (ctx->log_level)
#define BT_LOG_TAG "PLUGIN/CTF/META/RESOLVE"
#include "logging/comp-logging.h"

#include <babeltrace2/babeltrace.h>
#include "common/macros.h"
#include "common/assert.h"
#include "common/common.h"
#include <glib.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <inttypes.h>
#include <limits.h>
#include <stdlib.h>
#include <glib.h>

#include "ctf-meta-visitors.h"
#include "logging.h"

typedef GPtrArray field_class_stack;

/*
 * A stack frame.
 *
 * `fc` contains a compound field class (structure, variant, array,
 * or sequence) and `index` indicates the index of the field class in
 * the upper frame (-1 for array and sequence field classes). `name`
 * indicates the name of the field class in the upper frame (empty
 * string for array and sequence field classes).
 */
struct field_class_stack_frame {
        struct ctf_field_class *fc;
        int64_t index;
};

/*
 * The current context of the resolving engine.
 */
struct resolve_context {
        bt_logging_level log_level;
        bt_self_component *self_comp;
        struct ctf_trace_class *tc;
        struct ctf_stream_class *sc;
        struct ctf_event_class *ec;

        struct {
                struct ctf_field_class *packet_header;
                struct ctf_field_class *packet_context;
                struct ctf_field_class *event_header;
                struct ctf_field_class *event_common_context;
                struct ctf_field_class *event_spec_context;
                struct ctf_field_class *event_payload;
        } scopes;

        /* Root scope being visited */
        enum ctf_scope root_scope;
        field_class_stack *field_class_stack;
        struct ctf_field_class *cur_fc;
};

/* TSDL dynamic scope prefixes as defined in CTF Section 7.3.2 */
static const char * const absolute_path_prefixes[] = {
        [CTF_SCOPE_PACKET_HEADER]               = "trace.packet.header.",
        [CTF_SCOPE_PACKET_CONTEXT]              = "stream.packet.context.",
        [CTF_SCOPE_EVENT_HEADER]                = "stream.event.header.",
        [CTF_SCOPE_EVENT_COMMON_CONTEXT]        = "stream.event.context.",
        [CTF_SCOPE_EVENT_SPECIFIC_CONTEXT]      = "event.context.",
        [CTF_SCOPE_EVENT_PAYLOAD]               = "event.fields.",
};

/* Number of path tokens used for the absolute prefixes */
static const uint64_t absolute_path_prefix_ptoken_counts[] = {
        [CTF_SCOPE_PACKET_HEADER]               = 3,
        [CTF_SCOPE_PACKET_CONTEXT]              = 3,
        [CTF_SCOPE_EVENT_HEADER]                = 3,
        [CTF_SCOPE_EVENT_COMMON_CONTEXT]        = 3,
        [CTF_SCOPE_EVENT_SPECIFIC_CONTEXT]      = 2,
        [CTF_SCOPE_EVENT_PAYLOAD]               = 2,
};

static
void destroy_field_class_stack_frame(struct field_class_stack_frame *frame)
{
        if (!frame) {
                return;
        }

        g_free(frame);
}

/*
 * Creates a class stack.
 */
static
field_class_stack *field_class_stack_create(void)
{
        return g_ptr_array_new_with_free_func(
                (GDestroyNotify) destroy_field_class_stack_frame);
}

/*
 * Destroys a class stack.
 */
static
void field_class_stack_destroy(field_class_stack *stack)
{
        if (stack) {
                g_ptr_array_free(stack, TRUE);
        }
}

/*
 * Pushes a field class onto a class stack.
 */
static
int field_class_stack_push(field_class_stack *stack, struct ctf_field_class *fc,
                struct resolve_context *ctx)
{
        int ret = 0;
        struct field_class_stack_frame *frame = NULL;

        if (!stack || !fc) {
                BT_COMP_LOGE("Invalid parameter: stack or field class is NULL.");
                ret = -1;
                goto end;
        }

        frame = g_new0(struct field_class_stack_frame, 1);
        if (!frame) {
                BT_COMP_LOGE_STR("Failed to allocate one field class stack frame.");
                ret = -1;
                goto end;
        }

        BT_COMP_LOGD("Pushing field class on context's stack: "
                "fc-addr=%p, stack-size-before=%u", fc, stack->len);
        frame->fc = fc;
        g_ptr_array_add(stack, frame);

end:
        return ret;
}

/*
 * Checks whether or not `stack` is empty.
 */
static
bool field_class_stack_empty(field_class_stack *stack)
{
        return stack->len == 0;
}

/*
 * Returns the number of frames in `stack`.
 */
static
size_t field_class_stack_size(field_class_stack *stack)
{
        return stack->len;
}

/*
 * Returns the top frame of `stack`.
 */
static
struct field_class_stack_frame *field_class_stack_peek(field_class_stack *stack)
{
        BT_ASSERT(stack);
        BT_ASSERT(!field_class_stack_empty(stack));

        return g_ptr_array_index(stack, stack->len - 1);
}

/*
 * Returns the frame at index `index` in `stack`.
 */
static
struct field_class_stack_frame *field_class_stack_at(field_class_stack *stack,
                size_t index)
{
        BT_ASSERT(stack);
        BT_ASSERT(index < stack->len);

        return g_ptr_array_index(stack, index);
}

/*
 * Removes the top frame of `stack`.
 */
static
void field_class_stack_pop(field_class_stack *stack,
                struct resolve_context *ctx)
{
        if (!field_class_stack_empty(stack)) {
                /*
                 * This will call the frame's destructor and free it, as
                 * well as put its contained field class.
                 */
                BT_COMP_LOGD("Popping context's stack: stack-size-before=%u",
                        stack->len);
                g_ptr_array_set_size(stack, stack->len - 1);
        }
}

/*
 * Returns the scope field class of `scope` in the context `ctx`.
 */
static
struct ctf_field_class *borrow_class_from_ctx(struct resolve_context *ctx,
                enum ctf_scope scope)
{
        switch (scope) {
        case CTF_SCOPE_PACKET_HEADER:
                return ctx->scopes.packet_header;
        case CTF_SCOPE_PACKET_CONTEXT:
                return ctx->scopes.packet_context;
        case CTF_SCOPE_EVENT_HEADER:
                return ctx->scopes.event_header;
        case CTF_SCOPE_EVENT_COMMON_CONTEXT:
                return ctx->scopes.event_common_context;
        case CTF_SCOPE_EVENT_SPECIFIC_CONTEXT:
                return ctx->scopes.event_spec_context;
        case CTF_SCOPE_EVENT_PAYLOAD:
                return ctx->scopes.event_payload;
        default:
                bt_common_abort();
        }

        return NULL;
}

/*
 * Returns the CTF scope from a path string. May return -1 if the path
 * is found to be relative.
 */
static
enum ctf_scope get_root_scope_from_absolute_pathstr(const char *pathstr,
                struct resolve_context *ctx)
{
        enum ctf_scope scope;
        enum ctf_scope ret = CTF_SCOPE_PACKET_UNKNOWN;
        const size_t prefixes_count = sizeof(absolute_path_prefixes) /
                sizeof(*absolute_path_prefixes);

        for (scope = CTF_SCOPE_PACKET_HEADER; scope < CTF_SCOPE_PACKET_HEADER +
                        prefixes_count; scope++) {
                /*
                 * Check if path string starts with a known absolute
                 * path prefix.
                 *
                 * Refer to CTF 7.3.2 STATIC AND DYNAMIC SCOPES.
                 */
                if (strncmp(pathstr, absolute_path_prefixes[scope],
                                strlen(absolute_path_prefixes[scope]))) {
                        /* Prefix does not match: try the next one */
                        BT_COMP_LOGD("Prefix does not match: trying the next one: "
                                "path=\"%s\", path-prefix=\"%s\", scope=%s",
                                pathstr, absolute_path_prefixes[scope],
                                ctf_scope_string(scope));
                        continue;
                }

                /* Found it! */
                ret = scope;
                BT_COMP_LOGD("Found root scope from absolute path: "
                        "path=\"%s\", scope=%s", pathstr,
                        ctf_scope_string(scope));
                goto end;
        }

end:
        return ret;
}

/*
 * Destroys a path token.
 */
static
void ptokens_destroy_func(gpointer ptoken, gpointer data)
{
        g_string_free(ptoken, TRUE);
}

/*
 * Destroys a path token list.
 */
static
void ptokens_destroy(GList *ptokens)
{
        if (!ptokens) {
                return;
        }

        g_list_foreach(ptokens, ptokens_destroy_func, NULL);
        g_list_free(ptokens);
}

/*
 * Returns the string contained in a path token.
 */
static
const char *ptoken_get_string(GList *ptoken)
{
        GString *tokenstr = (GString *) ptoken->data;

        return tokenstr->str;
}

/*
 * Converts a path string to a path token list, that is, splits the
 * individual words of a path string into a list of individual
 * strings.
 */
static
GList *pathstr_to_ptokens(const char *pathstr, struct resolve_context *ctx)
{
        const char *at = pathstr;
        const char *last = at;
        GList *ptokens = NULL;

        for (;;) {
                if (*at == '.' || *at == '\0') {
                        GString *tokenstr;

                        if (at == last) {
                                /* Error: empty token */
                                BT_COMP_LOGE("Empty path token: path=\"%s\", pos=%u",
                                        pathstr, (unsigned int) (at - pathstr));
                                goto error;
                        }

                        tokenstr = g_string_new(NULL);
                        g_string_append_len(tokenstr, last, at - last);
                        ptokens = g_list_append(ptokens, tokenstr);
                        last = at + 1;
                }

                if (*at == '\0') {
                        break;
                }

                at++;
        }

        return ptokens;

error:
        ptokens_destroy(ptokens);
        return NULL;
}

/*
 * Converts a path token list to a field path object. The path token
 * list is relative from `fc`. The index of the source looking for its
 * target within `fc` is indicated by `src_index`. This can be
 * `INT64_MAX` if the source is contained in `fc`.
 *
 * `field_path` is an output parameter owned by the caller that must be
 * filled here.
 */
static
int ptokens_to_field_path(GList *ptokens, struct ctf_field_path *field_path,
                struct ctf_field_class *fc, int64_t src_index,
                struct resolve_context *ctx)
{
        int ret = 0;
        GList *cur_ptoken = ptokens;
        bool first_level_done = false;

        /* Locate target */
        while (cur_ptoken) {
                int64_t child_index;
                struct ctf_field_class *child_fc;
                const char *ft_name = ptoken_get_string(cur_ptoken);

                BT_COMP_LOGD("Current path token: token=\"%s\"", ft_name);

                /* Find to which index corresponds the current path token */
                if (fc->type == CTF_FIELD_CLASS_TYPE_ARRAY ||
                                fc->type == CTF_FIELD_CLASS_TYPE_SEQUENCE) {
                        child_index = -1;
                } else {
                        child_index =
                                ctf_field_class_compound_get_field_class_index_from_orig_name(
                                        fc, ft_name);
                        if (child_index < 0) {
                                /*
                                 * Error: field name does not exist or
                                 * wrong current class.
                                 */
                                BT_COMP_LOGD("Cannot get index of field class: "
                                        "field-name=\"%s\", "
                                        "src-index=%" PRId64 ", "
                                        "child-index=%" PRId64 ", "
                                        "first-level-done=%d",
                                        ft_name, src_index, child_index,
                                        first_level_done);
                                ret = -1;
                                goto end;
                        } else if (child_index > src_index &&
                                        !first_level_done) {
                                BT_COMP_LOGD("Child field class is located after source field class: "
                                        "field-name=\"%s\", "
                                        "src-index=%" PRId64 ", "
                                        "child-index=%" PRId64 ", "
                                        "first-level-done=%d",
                                        ft_name, src_index, child_index,
                                        first_level_done);
                                ret = -1;
                                goto end;
                        }

                        /* Next path token */
                        cur_ptoken = g_list_next(cur_ptoken);
                        first_level_done = true;
                }

                /* Create new field path entry */
                ctf_field_path_append_index(field_path, child_index);

                /* Get child field class */
                child_fc = ctf_field_class_compound_borrow_field_class_by_index(
                        fc, child_index);
                BT_ASSERT(child_fc);

                /* Move child class to current class */
                fc = child_fc;
        }

end:
        return ret;
}

/*
 * Converts a known absolute path token list to a field path object
 * within the resolving context `ctx`.
 *
 * `field_path` is an output parameter owned by the caller that must be
 * filled here.
 */
static
int absolute_ptokens_to_field_path(GList *ptokens,
                struct ctf_field_path *field_path,
                struct resolve_context *ctx)
{
        int ret = 0;
        GList *cur_ptoken;
        struct ctf_field_class *fc;

        /*
         * Make sure we're not referring to a scope within a translated
         * object.
         */
        switch (field_path->root) {
        case CTF_SCOPE_PACKET_HEADER:
                if (ctx->tc->is_translated) {
                        BT_COMP_LOGE("Trace class is already translated: "
                                "root-scope=%s",
                                ctf_scope_string(field_path->root));
                        ret = -1;
                        goto end;
                }

                break;
        case CTF_SCOPE_PACKET_CONTEXT:
        case CTF_SCOPE_EVENT_HEADER:
        case CTF_SCOPE_EVENT_COMMON_CONTEXT:
                if (!ctx->sc) {
                        BT_COMP_LOGE("No current stream class: "
                                "root-scope=%s",
                                ctf_scope_string(field_path->root));
                        ret = -1;
                        goto end;
                }

                if (ctx->sc->is_translated) {
                        BT_COMP_LOGE("Stream class is already translated: "
                                "root-scope=%s",
                                ctf_scope_string(field_path->root));
                        ret = -1;
                        goto end;
                }

                break;
        case CTF_SCOPE_EVENT_SPECIFIC_CONTEXT:
        case CTF_SCOPE_EVENT_PAYLOAD:
                if (!ctx->ec) {
                        BT_COMP_LOGE("No current event class: "
                                "root-scope=%s",
                                ctf_scope_string(field_path->root));
                        ret = -1;
                        goto end;
                }

                if (ctx->ec->is_translated) {
                        BT_COMP_LOGE("Event class is already translated: "
                                "root-scope=%s",
                                ctf_scope_string(field_path->root));
                        ret = -1;
                        goto end;
                }

                break;

        default:
                bt_common_abort();
        }

        /* Skip absolute path tokens */
        cur_ptoken = g_list_nth(ptokens,
                absolute_path_prefix_ptoken_counts[field_path->root]);

        /* Start with root class */
        fc = borrow_class_from_ctx(ctx, field_path->root);
        if (!fc) {
                /* Error: root class is not available */
                BT_COMP_LOGE("Root field class is not available: "
                        "root-scope=%s",
                        ctf_scope_string(field_path->root));
                ret = -1;
                goto end;
        }

        /* Locate target */
        ret = ptokens_to_field_path(cur_ptoken, field_path, fc, INT64_MAX, ctx);

end:
        return ret;
}

/*
 * Converts a known relative path token list to a field path object
 * within the resolving context `ctx`.
 *
 * `field_path` is an output parameter owned by the caller that must be
 * filled here.
 */
static
int relative_ptokens_to_field_path(GList *ptokens,
                struct ctf_field_path *field_path, struct resolve_context *ctx)
{
        int ret = 0;
        int64_t parent_pos_in_stack;
        struct ctf_field_path tail_field_path;

        ctf_field_path_init(&tail_field_path);
        parent_pos_in_stack = field_class_stack_size(ctx->field_class_stack) - 1;

        while (parent_pos_in_stack >= 0) {
                struct ctf_field_class *parent_class =
                        field_class_stack_at(ctx->field_class_stack,
                                parent_pos_in_stack)->fc;
                int64_t cur_index = field_class_stack_at(ctx->field_class_stack,
                        parent_pos_in_stack)->index;

                BT_COMP_LOGD("Locating target field class from current parent field class: "
                        "parent-pos=%" PRId64 ", parent-fc-addr=%p, "
                        "cur-index=%" PRId64,
                        parent_pos_in_stack, parent_class, cur_index);

                /* Locate target from current parent class */
                ret = ptokens_to_field_path(ptokens, &tail_field_path,
                        parent_class, cur_index, ctx);
                if (ret) {
                        /* Not found... yet */
                        BT_COMP_LOGD_STR("Not found at this point.");
                        ctf_field_path_clear(&tail_field_path);
                } else {
                        /* Found: stitch tail field path to head field path */
                        uint64_t i = 0;
                        size_t tail_field_path_len =
                                tail_field_path.path->len;

                        while (BT_TRUE) {
                                struct ctf_field_class *cur_class =
                                        field_class_stack_at(
                                                ctx->field_class_stack, i)->fc;
                                int64_t index = field_class_stack_at(
                                        ctx->field_class_stack, i)->index;

                                if (cur_class == parent_class) {
                                        break;
                                }

                                ctf_field_path_append_index(field_path,
                                        index);
                                i++;
                        }

                        for (i = 0; i < tail_field_path_len; i++) {
                                int64_t index =
                                        ctf_field_path_borrow_index_by_index(
                                                &tail_field_path, i);

                                ctf_field_path_append_index(field_path,
                                        (int64_t) index);
                        }
                        break;
                }

                parent_pos_in_stack--;
        }

        if (parent_pos_in_stack < 0) {
                /* Not found */
                ret = -1;
        }

        ctf_field_path_fini(&tail_field_path);
        return ret;
}

/*
 * Converts a path string to a field path object within the resolving
 * context `ctx`.
 */
static
int pathstr_to_field_path(const char *pathstr,
                struct ctf_field_path *field_path, struct resolve_context *ctx)
{
        int ret = 0;
        enum ctf_scope root_scope;
        GList *ptokens = NULL;

        /* Convert path string to path tokens */
        ptokens = pathstr_to_ptokens(pathstr, ctx);
        if (!ptokens) {
                BT_COMP_LOGE("Cannot convert path string to path tokens: "
                        "path=\"%s\"", pathstr);
                ret = -1;
                goto end;
        }

        /* Absolute or relative path? */
        root_scope = get_root_scope_from_absolute_pathstr(pathstr, ctx);

        if (root_scope == CTF_SCOPE_PACKET_UNKNOWN) {
                /* Relative path: start with current root scope */
                field_path->root = ctx->root_scope;
                BT_COMP_LOGD("Detected relative path: starting with current root scope: "
                        "scope=%s", ctf_scope_string(field_path->root));
                ret = relative_ptokens_to_field_path(ptokens, field_path, ctx);
                if (ret) {
                        BT_COMP_LOGE("Cannot get relative field path of path string: "
                                "path=\"%s\", start-scope=%s, end-scope=%s",
                                pathstr, ctf_scope_string(ctx->root_scope),
                                ctf_scope_string(field_path->root));
                        goto end;
                }
        } else {
                /* Absolute path: use found root scope */
                field_path->root = root_scope;
                BT_COMP_LOGD("Detected absolute path: using root scope: "
                        "scope=%s", ctf_scope_string(field_path->root));
                ret = absolute_ptokens_to_field_path(ptokens, field_path, ctx);
                if (ret) {
                        BT_COMP_LOGE("Cannot get absolute field path of path string: "
                                "path=\"%s\", root-scope=%s",
                                pathstr, ctf_scope_string(root_scope));
                        goto end;
                }
        }

        if (BT_LOG_ON_TRACE && ret == 0) {
                GString *field_path_pretty = ctf_field_path_string(field_path);
                const char *field_path_pretty_str =
                        field_path_pretty ? field_path_pretty->str : NULL;

                BT_COMP_LOGD("Found field path: path=\"%s\", field-path=\"%s\"",
                        pathstr, field_path_pretty_str);

                if (field_path_pretty) {
                        g_string_free(field_path_pretty, TRUE);
                }
        }

end:
        ptokens_destroy(ptokens);
        return ret;
}

/*
 * Retrieves a field class by following the field path `field_path` in
 * the resolving context `ctx`.
 */
static
struct ctf_field_class *field_path_to_field_class(
                struct ctf_field_path *field_path, struct resolve_context *ctx)
{
        uint64_t i;
        struct ctf_field_class *fc;

        /* Start with root class */
        fc = borrow_class_from_ctx(ctx, field_path->root);
        if (!fc) {
                /* Error: root class is not available */
                BT_COMP_LOGE("Root field class is not available: root-scope=%s",
                        ctf_scope_string(field_path->root));
                goto end;
        }

        /* Locate target */
        for (i = 0; i < field_path->path->len; i++) {
                struct ctf_field_class *child_fc;
                int64_t child_index =
                        ctf_field_path_borrow_index_by_index(field_path, i);

                /* Get child field class */
                child_fc = ctf_field_class_compound_borrow_field_class_by_index(
                        fc, child_index);
                BT_ASSERT(child_fc);

                /* Move child class to current class */
                fc = child_fc;
        }

end:
        return fc;
}

/*
 * Fills the equivalent field path object of the context class stack.
 */
static
void get_ctx_stack_field_path(struct resolve_context *ctx,
                struct ctf_field_path *field_path)
{
        uint64_t i;

        BT_ASSERT(field_path);
        field_path->root = ctx->root_scope;
        ctf_field_path_clear(field_path);

        for (i = 0; i < field_class_stack_size(ctx->field_class_stack); i++) {
                struct field_class_stack_frame *frame =
                        field_class_stack_at(ctx->field_class_stack, i);

                ctf_field_path_append_index(field_path, frame->index);
        }
}

/*
 * Returns the index of the lowest common ancestor of two field path
 * objects having the same root scope.
 */
static
int64_t get_field_paths_lca_index(struct ctf_field_path *field_path1,
                struct ctf_field_path *field_path2,
                struct resolve_context *ctx)
{
        int64_t lca_index = 0;
        uint64_t field_path1_len, field_path2_len;

        if (BT_LOG_ON_TRACE) {
                GString *field_path1_pretty =
                        ctf_field_path_string(field_path1);
                GString *field_path2_pretty =
                        ctf_field_path_string(field_path2);
                const char *field_path1_pretty_str =
                        field_path1_pretty ? field_path1_pretty->str : NULL;
                const char *field_path2_pretty_str =
                        field_path2_pretty ? field_path2_pretty->str : NULL;

                BT_COMP_LOGD("Finding lowest common ancestor (LCA) between two field paths: "
                        "field-path-1=\"%s\", field-path-2=\"%s\"",
                        field_path1_pretty_str, field_path2_pretty_str);

                if (field_path1_pretty) {
                        g_string_free(field_path1_pretty, TRUE);
                }

                if (field_path2_pretty) {
                        g_string_free(field_path2_pretty, TRUE);
                }
        }

        /*
         * Start from both roots and find the first mismatch.
         */
        BT_ASSERT(field_path1->root == field_path2->root);
        field_path1_len = field_path1->path->len;
        field_path2_len = field_path2->path->len;

        while (true) {
                int64_t target_index, ctx_index;

                if (lca_index == (int64_t) field_path2_len ||
                                lca_index == (int64_t) field_path1_len) {
                        /*
                         * This means that both field paths never split.
                         * This is invalid because the target cannot be
                         * an ancestor of the source.
                         */
                        BT_COMP_LOGE("Source field class is an ancestor of target field class or vice versa: "
                                "lca-index=%" PRId64 ", "
                                "field-path-1-len=%" PRIu64 ", "
                                "field-path-2-len=%" PRIu64,
                                lca_index, field_path1_len, field_path2_len);
                        lca_index = -1;
                        break;
                }

                target_index = ctf_field_path_borrow_index_by_index(field_path1,
                        lca_index);
                ctx_index = ctf_field_path_borrow_index_by_index(field_path2,
                        lca_index);

                if (target_index != ctx_index) {
                        /* LCA index is the previous */
                        break;
                }

                lca_index++;
        }

        BT_COMP_LOGD("Found LCA: lca-index=%" PRId64, lca_index);
        return lca_index;
}

/*
 * Validates a target field path.
 */
static
int validate_target_field_path(struct ctf_field_path *target_field_path,
                struct ctf_field_class *target_fc,
                struct resolve_context *ctx)
{
        int ret = 0;
        struct ctf_field_path ctx_field_path;
        uint64_t target_field_path_len = target_field_path->path->len;
        int64_t lca_index;

        /* Get context field path */
        ctf_field_path_init(&ctx_field_path);
        get_ctx_stack_field_path(ctx, &ctx_field_path);

        /*
         * Make sure the target is not a root.
         */
        if (target_field_path_len == 0) {
                BT_COMP_LOGE_STR("Target field path's length is 0 (targeting the root).");
                ret = -1;
                goto end;
        }

        /*
         * Make sure the root of the target field path is not located
         * after the context field path's root.
         */
        if (target_field_path->root > ctx_field_path.root) {
                BT_COMP_LOGE("Target field class is located after source field class: "
                        "target-root=%s, source-root=%s",
                        ctf_scope_string(target_field_path->root),
                        ctf_scope_string(ctx_field_path.root));
                ret = -1;
                goto end;
        }

        if (target_field_path->root == ctx_field_path.root) {
                int64_t target_index, ctx_index;

                /*
                 * Find the index of the lowest common ancestor of both field
                 * paths.
                 */
                lca_index = get_field_paths_lca_index(target_field_path,
                        &ctx_field_path, ctx);
                if (lca_index < 0) {
                        BT_COMP_LOGE_STR("Cannot get least common ancestor.");
                        ret = -1;
                        goto end;
                }

                /*
                 * Make sure the target field path is located before the
                 * context field path.
                 */
                target_index = ctf_field_path_borrow_index_by_index(
                        target_field_path, (uint64_t) lca_index);
                ctx_index = ctf_field_path_borrow_index_by_index(
                        &ctx_field_path, (uint64_t) lca_index);

                if (target_index >= ctx_index) {
                        BT_COMP_LOGE("Target field class's index is greater than or equal to source field class's index in LCA: "
                                "lca-index=%" PRId64 ", "
                                "target-index=%" PRId64 ", "
                                "source-index=%" PRId64,
                                lca_index, target_index, ctx_index);
                        ret = -1;
                        goto end;
                }
        }

        /*
         * Make sure the target class has the right class and properties.
         */
        switch (ctx->cur_fc->type) {
        case CTF_FIELD_CLASS_TYPE_VARIANT:
                if (target_fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
                        BT_COMP_LOGE("Variant field class's tag field class is not an enumeration field class: "
                                "tag-fc-addr=%p, tag-fc-id=%d",
                                target_fc, target_fc->type);
                        ret = -1;
                        goto end;
                }
                break;
        case CTF_FIELD_CLASS_TYPE_SEQUENCE:
        {
                struct ctf_field_class_int *int_fc = (void *) target_fc;

                if (target_fc->type != CTF_FIELD_CLASS_TYPE_INT &&
                                target_fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
                        BT_COMP_LOGE("Sequence field class's length field class is not an unsigned integer field class: "
                                "length-fc-addr=%p, length-fc-id=%d",
                                target_fc, target_fc->type);
                        ret = -1;
                        goto end;
                }

                if (int_fc->is_signed) {
                        BT_COMP_LOGE("Sequence field class's length field class is not an unsigned integer field class: "
                                "length-fc-addr=%p, length-fc-id=%d",
                                target_fc, target_fc->type);
                        ret = -1;
                        goto end;
                }
                break;
        }
        default:
                bt_common_abort();
        }

end:
        ctf_field_path_fini(&ctx_field_path);
        return ret;
}

/*
 * Resolves a variant or sequence field class `fc`.
 */
static
int resolve_sequence_or_variant_field_class(struct ctf_field_class *fc,
                struct resolve_context *ctx)
{
        int ret = 0;
        const char *pathstr;
        struct ctf_field_path target_field_path;
        struct ctf_field_class *target_fc = NULL;
        GString *target_field_path_pretty = NULL;
        const char *target_field_path_pretty_str;

        ctf_field_path_init(&target_field_path);

        /* Get path string */
        switch (fc->type) {
        case CTF_FIELD_CLASS_TYPE_SEQUENCE:
        {
                struct ctf_field_class_sequence *seq_fc = (void *) fc;
                pathstr = seq_fc->length_ref->str;
                break;
        }
        case CTF_FIELD_CLASS_TYPE_VARIANT:
        {
                struct ctf_field_class_variant *var_fc = (void *) fc;
                pathstr = var_fc->tag_ref->str;
                break;
        }
        default:
                bt_common_abort();
        }

        if (!pathstr) {
                BT_COMP_LOGE_STR("Cannot get path string.");
                ret = -1;
                goto end;
        }

        /* Get target field path out of path string */
        ret = pathstr_to_field_path(pathstr, &target_field_path, ctx);
        if (ret) {
                BT_COMP_LOGE("Cannot get target field path for path string: "
                        "path=\"%s\"", pathstr);
                goto end;
        }

        target_field_path_pretty = ctf_field_path_string(
                &target_field_path);
        target_field_path_pretty_str =
                target_field_path_pretty ? target_field_path_pretty->str : NULL;

        /* Get target field class */
        target_fc = field_path_to_field_class(&target_field_path, ctx);
        if (!target_fc) {
                BT_COMP_LOGE("Cannot get target field class for path string: "
                        "path=\"%s\", target-field-path=\"%s\"",
                        pathstr, target_field_path_pretty_str);
                ret = -1;
                goto end;
        }

        ret = validate_target_field_path(&target_field_path,
                target_fc, ctx);
        if (ret) {
                BT_COMP_LOGE("Invalid target field path for path string: "
                        "path=\"%s\", target-field-path=\"%s\"",
                        pathstr, target_field_path_pretty_str);
                goto end;
        }

        /* Set target field path and target field class */
        switch (fc->type) {
        case CTF_FIELD_CLASS_TYPE_SEQUENCE:
        {
                struct ctf_field_class_sequence *seq_fc = (void *) fc;

                ctf_field_path_copy_content(&seq_fc->length_path,
                        &target_field_path);
                seq_fc->length_fc = (void *) target_fc;
                break;
        }
        case CTF_FIELD_CLASS_TYPE_VARIANT:
        {
                struct ctf_field_class_variant *var_fc = (void *) fc;

                ctf_field_path_copy_content(&var_fc->tag_path,
                        &target_field_path);
                ctf_field_class_variant_set_tag_field_class(var_fc,
                        (void *) target_fc);
                break;
        }
        default:
                bt_common_abort();
        }

end:
        if (target_field_path_pretty) {
                g_string_free(target_field_path_pretty, TRUE);
        }

        ctf_field_path_fini(&target_field_path);
        return ret;
}

/*
 * Resolves a field class `fc`.
 */
static
int resolve_field_class(struct ctf_field_class *fc, struct resolve_context *ctx)
{
        int ret = 0;

        if (!fc) {
                /* Field class is not available; still valid */
                goto end;
        }

        ctx->cur_fc = fc;

        /* Resolve sequence/variant field class */
        switch (fc->type) {
        case CTF_FIELD_CLASS_TYPE_SEQUENCE:
        case CTF_FIELD_CLASS_TYPE_VARIANT:
                ret = resolve_sequence_or_variant_field_class(fc, ctx);
                if (ret) {
                        BT_COMP_LOGE("Cannot resolve sequence field class's length or variant field class's tag: "
                                "ret=%d, fc-addr=%p", ret, fc);
                        goto end;
                }

                break;
        default:
                break;
        }

        /* Recurse into compound classes */
        switch (fc->type) {
        case CTF_FIELD_CLASS_TYPE_STRUCT:
        case CTF_FIELD_CLASS_TYPE_VARIANT:
        case CTF_FIELD_CLASS_TYPE_SEQUENCE:
        case CTF_FIELD_CLASS_TYPE_ARRAY:
        {
                uint64_t i;
                uint64_t field_count =
                        ctf_field_class_compound_get_field_class_count(fc);

                ret = field_class_stack_push(ctx->field_class_stack, fc, ctx);
                if (ret) {
                        BT_COMP_LOGE("Cannot push field class on context's stack: "
                                "fc-addr=%p", fc);
                        goto end;
                }

                for (i = 0; i < field_count; i++) {
                        struct ctf_field_class *child_fc =
                                ctf_field_class_compound_borrow_field_class_by_index(
                                        fc, i);

                        BT_ASSERT(child_fc);

                        if (fc->type == CTF_FIELD_CLASS_TYPE_ARRAY||
                                        fc->type == CTF_FIELD_CLASS_TYPE_SEQUENCE) {
                                field_class_stack_peek(
                                        ctx->field_class_stack)->index = -1;
                        } else {
                                field_class_stack_peek(
                                        ctx->field_class_stack)->index =
                                                (int64_t) i;
                        }

                        BT_COMP_LOGD("Resolving field class's child field class: "
                                "parent-fc-addr=%p, child-fc-addr=%p, "
                                "index=%" PRIu64 ", count=%" PRIu64,
                                fc, child_fc, i, field_count);
                        ret = resolve_field_class(child_fc, ctx);
                        if (ret) {
                                goto end;
                        }
                }

                field_class_stack_pop(ctx->field_class_stack, ctx);
                break;
        }
        default:
                break;
        }

end:
        return ret;
}

/*
 * Resolves the root field class corresponding to the scope `root_scope`.
 */
static
int resolve_root_class(enum ctf_scope root_scope, struct resolve_context *ctx)
{
        int ret;

        BT_ASSERT(field_class_stack_size(ctx->field_class_stack) == 0);
        ctx->root_scope = root_scope;
        ret = resolve_field_class(borrow_class_from_ctx(ctx, root_scope), ctx);
        ctx->root_scope = -1;
        return ret;
}

static
int resolve_event_class_field_classes(struct resolve_context *ctx,
                struct ctf_event_class *ec)
{
        int ret = 0;

        BT_ASSERT(!ctx->scopes.event_spec_context);
        BT_ASSERT(!ctx->scopes.event_payload);

        if (ec->is_translated) {
                goto end;
        }

        ctx->ec = ec;
        ctx->scopes.event_spec_context = ec->spec_context_fc;
        ret = resolve_root_class(CTF_SCOPE_EVENT_COMMON_CONTEXT, ctx);
        if (ret) {
                BT_COMP_LOGE("Cannot resolve event specific context field class: "
                        "ret=%d", ret);
                goto end;
        }

        ctx->scopes.event_payload = ec->payload_fc;
        ret = resolve_root_class(CTF_SCOPE_EVENT_PAYLOAD, ctx);
        if (ret) {
                BT_COMP_LOGE("Cannot resolve event payload field class: "
                        "ret=%d", ret);
                goto end;
        }

end:
        ctx->scopes.event_spec_context = NULL;
        ctx->scopes.event_payload = NULL;
        ctx->ec = NULL;
        return ret;
}

static
int resolve_stream_class_field_classes(struct resolve_context *ctx,
                struct ctf_stream_class *sc)
{
        int ret = 0;
        uint64_t i;

        BT_ASSERT(!ctx->scopes.packet_context);
        BT_ASSERT(!ctx->scopes.event_header);
        BT_ASSERT(!ctx->scopes.event_common_context);
        ctx->sc = sc;

        if (!sc->is_translated) {
                ctx->scopes.packet_context = sc->packet_context_fc;
                ret = resolve_root_class(CTF_SCOPE_PACKET_CONTEXT, ctx);
                if (ret) {
                        BT_COMP_LOGE("Cannot resolve packet context field class: "
                                "ret=%d", ret);
                        goto end;
                }

                ctx->scopes.event_header = sc->event_header_fc;
                ret = resolve_root_class(CTF_SCOPE_EVENT_HEADER, ctx);
                if (ret) {
                        BT_COMP_LOGE("Cannot resolve event header field class: "
                                "ret=%d", ret);
                        goto end;
                }

                ctx->scopes.event_common_context = sc->event_common_context_fc;
                ret = resolve_root_class(CTF_SCOPE_EVENT_SPECIFIC_CONTEXT, ctx);
                if (ret) {
                        BT_COMP_LOGE("Cannot resolve event common context field class: "
                                "ret=%d", ret);
                        goto end;
                }
        }

        ctx->scopes.packet_context = sc->packet_context_fc;
        ctx->scopes.event_header = sc->event_header_fc;
        ctx->scopes.event_common_context = sc->event_common_context_fc;

        for (i = 0; i < sc->event_classes->len; i++) {
                struct ctf_event_class *ec = sc->event_classes->pdata[i];

                ret = resolve_event_class_field_classes(ctx, ec);
                if (ret) {
                        BT_COMP_LOGE("Cannot resolve event class's field classes: "
                                "ec-id=%" PRIu64 ", ec-name=\"%s\"",
                                ec->id, ec->name->str);
                        goto end;
                }
        }

end:
        ctx->scopes.packet_context = NULL;
        ctx->scopes.event_header = NULL;
        ctx->scopes.event_common_context = NULL;
        ctx->sc = NULL;
        return ret;
}

BT_HIDDEN
int ctf_trace_class_resolve_field_classes(struct ctf_trace_class *tc,
                struct meta_log_config *log_cfg)
{
        int ret = 0;
        uint64_t i;
        struct resolve_context local_ctx = {
                .log_level = log_cfg->log_level,
                .self_comp = log_cfg->self_comp,
                .tc = tc,
                .sc = NULL,
                .ec = NULL,
                .scopes = {
                        .packet_header = tc->packet_header_fc,
                        .packet_context = NULL,
                        .event_header = NULL,
                        .event_common_context = NULL,
                        .event_spec_context = NULL,
                        .event_payload = NULL,
                },
                .root_scope = CTF_SCOPE_PACKET_HEADER,
                .cur_fc = NULL,
        };
        struct resolve_context *ctx = &local_ctx;

        /* Initialize class stack */
        ctx->field_class_stack = field_class_stack_create();
        if (!ctx->field_class_stack) {
                BT_COMP_LOGE_STR("Cannot create field class stack.");
                ret = -1;
                goto end;
        }

        if (!tc->is_translated) {
                ctx->scopes.packet_header = tc->packet_header_fc;
                ret = resolve_root_class(CTF_SCOPE_PACKET_HEADER, ctx);
                if (ret) {
                        BT_COMP_LOGE("Cannot resolve packet header field class: "
                                "ret=%d", ret);
                        goto end;
                }
        }

        ctx->scopes.packet_header = tc->packet_header_fc;

        for (i = 0; i < tc->stream_classes->len; i++) {
                struct ctf_stream_class *sc = tc->stream_classes->pdata[i];

                ret = resolve_stream_class_field_classes(ctx, sc);
                if (ret) {
                        BT_COMP_LOGE("Cannot resolve stream class's field classes: "
                                "sc-id=%" PRIu64, sc->id);
                        goto end;
                }
        }

end:
        field_class_stack_destroy(ctx->field_class_stack);
        return ret;
}