/* * resolve.c * * Babeltrace - CTF IR: Type resolving internal * * Copyright 2015 Jérémie Galarneau * Copyright 2016 Philippe Proulx * * Authors: Jérémie Galarneau * Philippe Proulx * * 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. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include #include #include #include #include #include #include #include #include #include #include #include #define _printf_error(fmt, args...) \ printf_verbose("[resolving] " fmt, ## args) typedef GPtrArray type_stack; /* * A stack frame. * * `type` contains a compound field type (structure, variant, array, * or sequence) and `index` indicates the index of the field type in * the upper frame (-1 for array and sequence field types). * * `type` is owned by the stack frame. */ struct type_stack_frame { struct bt_ctf_field_type *type; int index; }; /* * The current context of the resolving engine. * * `scopes` contain the 6 CTF scope field types (see CTF, sect. 7.3.2) * in the following order: * * * Packet header * * Packet context * * Event header * * Stream event context * * Event context * * Event payload */ struct resolve_context { struct bt_value *environment; struct bt_ctf_field_type *scopes[6]; /* Root scope being visited */ enum bt_ctf_ir_scope root_scope; type_stack *type_stack; struct bt_ctf_field_type *cur_field_type; }; /* TSDL dynamic scope prefixes as defined in CTF Section 7.3.2 */ static const char * const absolute_path_prefixes[] = { [BT_CTF_SCOPE_ENV] = "env.", [BT_CTF_SCOPE_TRACE_PACKET_HEADER] = "trace.packet.header.", [BT_CTF_SCOPE_STREAM_PACKET_CONTEXT] = "stream.packet.context.", [BT_CTF_SCOPE_STREAM_EVENT_HEADER] = "stream.event.header.", [BT_CTF_SCOPE_STREAM_EVENT_CONTEXT] = "stream.event.context.", [BT_CTF_SCOPE_EVENT_CONTEXT] = "event.context.", [BT_CTF_SCOPE_EVENT_FIELDS] = "event.fields.", }; /* Number of path tokens used for the absolute prefixes */ static const int absolute_path_prefix_ptoken_counts[] = { [BT_CTF_SCOPE_ENV] = 1, [BT_CTF_SCOPE_TRACE_PACKET_HEADER] = 3, [BT_CTF_SCOPE_STREAM_PACKET_CONTEXT] = 3, [BT_CTF_SCOPE_STREAM_EVENT_HEADER] = 3, [BT_CTF_SCOPE_STREAM_EVENT_CONTEXT] = 3, [BT_CTF_SCOPE_EVENT_CONTEXT] = 2, [BT_CTF_SCOPE_EVENT_FIELDS] = 2, }; /* * Destroys a type stack frame. */ static void type_stack_destroy_notify(gpointer data) { struct type_stack_frame *frame = data; BT_PUT(frame->type); g_free(frame); } /* * Creates a type stack. * * Return value is owned by the caller. */ static type_stack *type_stack_create(void) { return g_ptr_array_new_with_free_func(type_stack_destroy_notify); } /* * Destroys a type stack. */ static void type_stack_destroy(type_stack *stack) { g_ptr_array_free(stack, TRUE); } /* * Pushes a field type onto a type stack. * * `type` is owned by the caller (stack frame gets a new reference). */ static int type_stack_push(type_stack *stack, struct bt_ctf_field_type *type) { int ret = 0; struct type_stack_frame *frame = NULL; if (!stack || !type) { ret = -1; goto end; } frame = g_new0(struct type_stack_frame, 1); if (!frame) { ret = -1; goto end; } frame->type = bt_get(type); g_ptr_array_add(stack, frame); end: return ret; } /* * Checks whether or not `stack` is empty. */ static bool type_stack_empty(type_stack *stack) { return stack->len == 0; } /* * Returns the number of frames in `stack`. */ static size_t type_stack_size(type_stack *stack) { return stack->len; } /* * Returns the top frame of `stack`. * * Return value is owned by `stack`. */ static struct type_stack_frame *type_stack_peek(type_stack *stack) { struct type_stack_frame *entry = NULL; if (!stack || type_stack_empty(stack)) { goto end; } entry = g_ptr_array_index(stack, stack->len - 1); end: return entry; } /* * Returns the frame at index `index` in `stack`. * * Return value is owned by `stack`. */ static struct type_stack_frame *type_stack_at(type_stack *stack, size_t index) { struct type_stack_frame *entry = NULL; if (!stack || index >= stack->len) { goto end; } entry = g_ptr_array_index(stack, index); end: return entry; } /* * Removes the top frame of `stack`. */ static void type_stack_pop(type_stack *stack) { if (!type_stack_empty(stack)) { /* * This will call the frame's destructor and free it, as * well as put its contained field type. */ g_ptr_array_set_size(stack, stack->len - 1); } } /* * Returns the scope field type of `scope` in the context `ctx`. * * Return value is owned by `ctx` on success. */ static struct bt_ctf_field_type *get_type_from_ctx(struct resolve_context *ctx, enum bt_ctf_ir_scope scope) { assert(scope >= BT_CTF_SCOPE_TRACE_PACKET_HEADER && scope <= BT_CTF_SCOPE_EVENT_FIELDS); return ctx->scopes[scope - BT_CTF_SCOPE_TRACE_PACKET_HEADER]; } /* * Returns the CTF scope from a path string. May return * CTF_NODE_UNKNOWN if the path is found to be relative. */ static enum bt_ctf_ir_scope get_root_scope_from_absolute_pathstr(const char *pathstr) { enum bt_ctf_ir_scope scope; enum bt_ctf_ir_scope ret = BT_CTF_SCOPE_UNKNOWN; const size_t prefixes_count = sizeof(absolute_path_prefixes) / sizeof(*absolute_path_prefixes); for (scope = BT_CTF_SCOPE_ENV; scope < BT_CTF_SCOPE_ENV + prefixes_count; scope++) { /* * Chech 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 */ continue; } /* Found it! */ ret = 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. * * Return value is owned by the caller on success. */ static GList *pathstr_to_ptokens(const char *pathstr) { const char *at = pathstr; const char *last = at; GList *ptokens = NULL; for (;;) { if (*at == '.' || *at == '\0') { GString *tokenstr; if (at == last) { /* Error: empty token */ _printf_error("Empty token in path string at position %d\n", (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 `type`. The index of the source looking for * its target within `type` is indicated by `src_index`. This can be * `INT_MAX` if the source is contained in `type`. * * `ptokens` is owned by the caller. `field_path` is an output parameter * owned by the caller that must be filled here. `type` is owned by the * caller. */ static int ptokens_to_field_path(GList *ptokens, struct bt_ctf_field_path *field_path, struct bt_ctf_field_type *type, int src_index) { int ret = 0; GList *cur_ptoken = ptokens; bool first_level_done = false; /* Get our own reference */ bt_get(type); /* Locate target */ while (cur_ptoken) { int child_index; struct bt_ctf_field_type *child_type; const char *field_name = ptoken_get_string(cur_ptoken); enum ctf_type_id type_id = bt_ctf_field_type_get_type_id(type); /* Find to which index corresponds the current path token */ if (type_id == CTF_TYPE_ARRAY || type_id == CTF_TYPE_SEQUENCE) { child_index = -1; } else { child_index = bt_ctf_field_type_get_field_index(type, field_name); if (child_index < 0) { /* * Error: field name does not exist or * wrong current type. */ _printf_error("Cannot get index of field type named \"%s\"\n", field_name); ret = -1; goto end; } else if (child_index > src_index && !first_level_done) { _printf_error("Child type is located after source index (%d)\n", src_index); ret = -1; goto end; } /* Next path token */ cur_ptoken = g_list_next(cur_ptoken); first_level_done = true; } /* Create new field path entry */ g_array_append_val(field_path->indexes, child_index); /* Get child field type */ child_type = bt_ctf_field_type_get_field_at_index(type, child_index); if (!child_type) { _printf_error("Cannot get child type at index %d (field \"%s\")\n", child_index, field_name); ret = -1; goto end; } /* Move child type to current type */ BT_MOVE(type, child_type); } end: bt_put(type); return ret; } /* * Converts a known absolute path token list to a field path object * within the resolving context `ctx`. * * `ptokens` is owned by the caller. `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 bt_ctf_field_path *field_path, struct resolve_context *ctx) { int ret = 0; GList *cur_ptoken; struct bt_ctf_field_type *type; /* Skip absolute path tokens */ cur_ptoken = g_list_nth(ptokens, absolute_path_prefix_ptoken_counts[field_path->root]); /* Start with root type */ type = get_type_from_ctx(ctx, field_path->root); if (!type) { /* Error: root type is not available */ _printf_error("Root type with scope type %d is not available\n", field_path->root); ret = -1; goto end; } /* Locate target */ ret = ptokens_to_field_path(cur_ptoken, field_path, type, INT_MAX); end: return ret; } /* * Converts a known relative path token list to a field path object * within the resolving context `ctx`. * * `ptokens` is owned by the caller. `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 bt_ctf_field_path *field_path, struct resolve_context *ctx) { int ret = 0; int parent_pos_in_stack; struct bt_ctf_field_path *tail_field_path = bt_ctf_field_path_create(); if (!tail_field_path) { _printf_error("Cannot create field path\n"); ret = -1; goto end; } parent_pos_in_stack = type_stack_size(ctx->type_stack) - 1; while (parent_pos_in_stack >= 0) { struct bt_ctf_field_type *parent_type = type_stack_at(ctx->type_stack, parent_pos_in_stack)->type; int cur_index = type_stack_at(ctx->type_stack, parent_pos_in_stack)->index; /* Locate target from current parent type */ ret = ptokens_to_field_path(ptokens, tail_field_path, parent_type, cur_index); if (ret) { /* Not found... yet */ bt_ctf_field_path_clear(tail_field_path); } else { /* Found: stitch tail field path to head field path */ int i = 0; int tail_field_path_len = tail_field_path->indexes->len; while (true) { struct bt_ctf_field_type *cur_type = type_stack_at(ctx->type_stack, i)->type; int index = type_stack_at( ctx->type_stack, i)->index; if (cur_type == parent_type) { break; } g_array_append_val(field_path->indexes, index); i++; } for (i = 0; i < tail_field_path_len; i++) { int index = g_array_index( tail_field_path->indexes, int, i); g_array_append_val(field_path->indexes, index); } break; } parent_pos_in_stack--; } if (parent_pos_in_stack < 0) { /* Not found: look in previous scopes */ field_path->root--; while (field_path->root >= BT_CTF_SCOPE_TRACE_PACKET_HEADER) { struct bt_ctf_field_type *root_type; bt_ctf_field_path_clear(field_path); root_type = get_type_from_ctx(ctx, field_path->root); if (!root_type) { field_path->root--; continue; } /* Locate target in previous scope */ ret = ptokens_to_field_path(ptokens, field_path, root_type, INT_MAX); if (ret) { /* Not found yet */ field_path->root--; continue; } /* Found */ break; } } end: BT_PUT(tail_field_path); return ret; } /* * Converts a path string to a field path object within the resolving * context `ctx`. * * Return value is owned by the caller on success. */ static struct bt_ctf_field_path *pathstr_to_field_path(const char *pathstr, struct resolve_context *ctx) { int ret; enum bt_ctf_ir_scope root_scope; GList *ptokens = NULL; struct bt_ctf_field_path *field_path = NULL; /* Create field path */ field_path = bt_ctf_field_path_create(); if (!field_path) { _printf_error("Cannot create field path\n"); ret = -1; goto end; } /* Convert path string to path tokens */ ptokens = pathstr_to_ptokens(pathstr); if (!ptokens) { _printf_error("Cannot convert path string \"%s\" to path tokens\n", pathstr); ret = -1; goto end; } /* Absolute or relative path? */ root_scope = get_root_scope_from_absolute_pathstr(pathstr); if (root_scope == BT_CTF_SCOPE_UNKNOWN) { /* Relative path: start with current root scope */ field_path->root = ctx->root_scope; ret = relative_ptokens_to_field_path(ptokens, field_path, ctx); if (ret) { _printf_error("Cannot get relative field path of path string \"%s\"\n", pathstr); _printf_error(" Starting at root scope %d, finished at root scope %d\n", ctx->root_scope, field_path->root); goto end; } } else if (root_scope == BT_CTF_SCOPE_ENV) { _printf_error("Sequence field types referring the trace environment are not supported as of this version\n"); ret = -1; goto end; } else { /* Absolute path: use found root scope */ field_path->root = root_scope; ret = absolute_ptokens_to_field_path(ptokens, field_path, ctx); if (ret) { _printf_error("Cannot get absolute field path of path string \"%s\"\n", pathstr); _printf_error(" Looking in root scope %d\n", root_scope); goto end; } } end: if (ret) { BT_PUT(field_path); } ptokens_destroy(ptokens); return field_path; } /* * Retrieves a field type by following the field path `field_path` in * the resolving context `ctx`. * * Return value is owned by the caller on success. */ static struct bt_ctf_field_type *field_path_to_field_type( struct bt_ctf_field_path *field_path, struct resolve_context *ctx) { int i; struct bt_ctf_field_type *type; /* Start with root type */ type = get_type_from_ctx(ctx, field_path->root); bt_get(type); if (!type) { /* Error: root type is not available */ _printf_error("Root type with scope type %d is not available\n", field_path->root); goto error; } /* Locate target */ for (i = 0; i < field_path->indexes->len; i++) { struct bt_ctf_field_type *child_type; int child_index = g_array_index(field_path->indexes, int, i); /* Get child field type */ child_type = bt_ctf_field_type_get_field_at_index(type, child_index); if (!child_type) { _printf_error("Cannot get field type field at index %d\n", child_index); goto error; } /* Move child type to current type */ BT_MOVE(type, child_type); } return type; error: BT_PUT(type); return type; } /* * Returns the equivalent field path object of the context type stack. * * Return value is owned by the caller on success. */ static struct bt_ctf_field_path *get_ctx_stack_field_path(struct resolve_context *ctx) { int i; struct bt_ctf_field_path *field_path; /* Create field path */ field_path = bt_ctf_field_path_create(); if (!field_path) { _printf_error("Cannot create field path\n"); goto error; } field_path->root = ctx->root_scope; for (i = 0; i < type_stack_size(ctx->type_stack); i++) { struct type_stack_frame *frame; frame = type_stack_at(ctx->type_stack, i); g_array_append_val(field_path->indexes, frame->index); } return field_path; error: BT_PUT(field_path); return field_path; } /* * Returns the lowest common ancestor of two field path objects * having the same root scope. * * `field_path1` and `field_path2` are owned by the caller. */ static int get_field_paths_lca_index(struct bt_ctf_field_path *field_path1, struct bt_ctf_field_path *field_path2) { int lca_index = 0; int field_path1_len, field_path2_len; /* * Start from both roots and find the first mismatch. */ assert(field_path1->root == field_path2->root); field_path1_len = field_path1->indexes->len; field_path2_len = field_path2->indexes->len; while (true) { int target_index, ctx_index; if (lca_index == field_path2_len || lca_index == field_path1_len) { /* * This means that both field paths never split. * This is invalid because the target cannot be * an ancestor of the source. */ _printf_error("In source and target: one is an ancestor of the other\n"); lca_index = -1; break; } target_index = g_array_index(field_path1->indexes, int, lca_index); ctx_index = g_array_index(field_path2->indexes, int, lca_index); if (target_index != ctx_index) { /* LCA index is the previous */ break; } lca_index++; } return lca_index; } /* * Validates a target field path. * * `target_field_path` and `target_type` are owned by the caller. */ static int validate_target_field_path(struct bt_ctf_field_path *target_field_path, struct bt_ctf_field_type *target_type, struct resolve_context *ctx) { int ret = 0; struct bt_ctf_field_path *ctx_field_path; int target_field_path_len = target_field_path->indexes->len; int lca_index; int ctx_cur_field_type_id; int target_type_id; /* Get context field path */ ctx_field_path = get_ctx_stack_field_path(ctx); if (!ctx_field_path) { _printf_error("Cannot get source field path\n"); ret = -1; goto end; } /* * Make sure the target is not a root. */ if (target_field_path_len == 0) { _printf_error("Target field path's length is 0 (targeting the root)\n"); 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) { _printf_error("Target is located after source\n"); ret = -1; goto end; } if (target_field_path->root == ctx_field_path->root) { int 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); if (lca_index < 0) { _printf_error("Cannot get least common ancestor\n"); ret = -1; goto end; } /* * Make sure the target field path is located before the * context field path. */ target_index = g_array_index(target_field_path->indexes, int, lca_index); ctx_index = g_array_index(ctx_field_path->indexes, int, lca_index); if (target_index >= ctx_index) { _printf_error("Target index (%d) is greater or equal to source index (%d) in LCA\n", target_index, ctx_index); ret = -1; goto end; } } /* * Make sure the target type has the right type and properties. */ ctx_cur_field_type_id = bt_ctf_field_type_get_type_id( ctx->cur_field_type); target_type_id = bt_ctf_field_type_get_type_id(target_type); if (ctx_cur_field_type_id == CTF_TYPE_VARIANT) { if (target_type_id != CTF_TYPE_ENUM) { _printf_error("Variant type's tag field type is not an enumeration\n"); ret = -1; goto end; } } else if (ctx_cur_field_type_id == CTF_TYPE_SEQUENCE) { if (target_type_id != CTF_TYPE_INTEGER || bt_ctf_field_type_integer_get_signed( target_type)) { _printf_error("Sequence type's length field type is not an unsigned integer\n"); ret = -1; goto end; } } else { assert(false); } end: BT_PUT(ctx_field_path); return ret; } /* * Resolves a variant or sequence field type `type`. * * `type` is owned by the caller. */ static int resolve_sequence_or_variant_type(struct bt_ctf_field_type *type, struct resolve_context *ctx) { int ret = 0; const char *pathstr; int type_id = bt_ctf_field_type_get_type_id(type); struct bt_ctf_field_path *target_field_path = NULL; struct bt_ctf_field_type *target_type = NULL; /* Get path string */ switch (type_id) { case CTF_TYPE_SEQUENCE: pathstr = bt_ctf_field_type_sequence_get_length_field_name(type); break; case CTF_TYPE_VARIANT: pathstr = bt_ctf_field_type_variant_get_tag_name(type); break; default: assert(false); ret = -1; goto end; } /* Get target field path out of path string */ target_field_path = pathstr_to_field_path(pathstr, ctx); if (!target_field_path) { _printf_error("Cannot get target field path for path string \"%s\"\n", pathstr); ret = -1; goto end; } /* Get target field type */ target_type = field_path_to_field_type(target_field_path, ctx); if (!target_type) { _printf_error("Cannot get target field type for path string \"%s\"\n", pathstr); ret = -1; goto end; } ret = validate_target_field_path(target_field_path, target_type, ctx); if (ret) { _printf_error("Invalid target field path for path string \"%s\"\n", pathstr); goto end; } /* Set target field path and target field type */ if (type_id == CTF_TYPE_SEQUENCE) { ret = bt_ctf_field_type_sequence_set_length_field_path( type, target_field_path); if (ret) { _printf_error("Cannot set sequence field type's length field path\n"); goto end; } } else if (type_id == CTF_TYPE_VARIANT) { ret = bt_ctf_field_type_variant_set_tag_field_path( type, target_field_path); if (ret) { _printf_error("Cannot set variant field type's tag field path\n"); goto end; } ret = bt_ctf_field_type_variant_set_tag_field_type( type, target_type); if (ret) { _printf_error("Cannot set variant field type's tag field type\n"); goto end; } } else { assert(false); } end: BT_PUT(target_field_path); BT_PUT(target_type); return ret; } /* * Resolves a field type `type`. * * `type` is owned by the caller. */ static int resolve_type(struct bt_ctf_field_type *type, struct resolve_context *ctx) { int ret = 0; int type_id; if (!type) { /* Type is not available; still valid */ goto end; } type_id = bt_ctf_field_type_get_type_id(type); ctx->cur_field_type = type; /* Resolve sequence/variant field type */ switch (type_id) { case CTF_TYPE_SEQUENCE: case CTF_TYPE_VARIANT: ret = resolve_sequence_or_variant_type(type, ctx); if (ret) { _printf_error("Cannot resolve sequence or variant field type's length/tag\n"); goto end; } break; default: break; } /* Recurse into compound types */ switch (type_id) { case CTF_TYPE_STRUCT: case CTF_TYPE_VARIANT: case CTF_TYPE_SEQUENCE: case CTF_TYPE_ARRAY: { int field_count, f_index; ret = type_stack_push(ctx->type_stack, type); if (ret) { _printf_error("Cannot push field type on type stack\n"); _printf_error(" Stack size: %zu\n", type_stack_size(ctx->type_stack)); goto end; } field_count = bt_ctf_field_type_get_field_count(type); if (field_count < 0) { _printf_error("Cannot get field type field count\n"); ret = field_count; goto end; } for (f_index = 0; f_index < field_count; f_index++) { struct bt_ctf_field_type *child_type = bt_ctf_field_type_get_field_at_index(type, f_index); if (!child_type) { _printf_error("Cannot get field type field at index %d/%d\n", f_index, field_count); ret = -1; goto end; } if (type_id == CTF_TYPE_ARRAY || type_id == CTF_TYPE_SEQUENCE) { type_stack_peek(ctx->type_stack)->index = -1; } else { type_stack_peek(ctx->type_stack)->index = f_index; } ret = resolve_type(child_type, ctx); BT_PUT(child_type); if (ret) { goto end; } } type_stack_pop(ctx->type_stack); break; } default: break; } end: return ret; } /* * Resolves the root field type corresponding to the scope `root_scope`. */ static int resolve_root_type(enum bt_ctf_ir_scope root_scope, struct resolve_context *ctx) { int ret; assert(type_stack_size(ctx->type_stack) == 0); ctx->root_scope = root_scope; ret = resolve_type(get_type_from_ctx(ctx, root_scope), ctx); ctx->root_scope = BT_CTF_SCOPE_UNKNOWN; return ret; } BT_HIDDEN int bt_ctf_resolve_types( struct bt_value *environment, struct bt_ctf_field_type *packet_header_type, struct bt_ctf_field_type *packet_context_type, struct bt_ctf_field_type *event_header_type, struct bt_ctf_field_type *stream_event_ctx_type, struct bt_ctf_field_type *event_context_type, struct bt_ctf_field_type *event_payload_type, enum bt_ctf_resolve_flag flags) { int ret = 0; struct resolve_context ctx = { .environment = environment, .scopes = { packet_header_type, packet_context_type, event_header_type, stream_event_ctx_type, event_context_type, event_payload_type, }, .root_scope = BT_CTF_SCOPE_UNKNOWN, }; /* Initialize type stack */ ctx.type_stack = type_stack_create(); if (!ctx.type_stack) { printf_error("Cannot create type stack\n"); ret = -1; goto end; } /* Resolve packet header type */ if (flags & BT_CTF_RESOLVE_FLAG_PACKET_HEADER) { ret = resolve_root_type(BT_CTF_SCOPE_TRACE_PACKET_HEADER, &ctx); if (ret) { _printf_error("Cannot resolve trace packet header type\n"); goto end; } } /* Resolve packet context type */ if (flags & BT_CTF_RESOLVE_FLAG_PACKET_CONTEXT) { ret = resolve_root_type(BT_CTF_SCOPE_STREAM_PACKET_CONTEXT, &ctx); if (ret) { _printf_error("Cannot resolve stream packet context type\n"); goto end; } } /* Resolve event header type */ if (flags & BT_CTF_RESOLVE_FLAG_EVENT_HEADER) { ret = resolve_root_type(BT_CTF_SCOPE_STREAM_EVENT_HEADER, &ctx); if (ret) { _printf_error("Cannot resolve stream event header type\n"); goto end; } } /* Resolve stream event context type */ if (flags & BT_CTF_RESOLVE_FLAG_STREAM_EVENT_CTX) { ret = resolve_root_type(BT_CTF_SCOPE_STREAM_EVENT_CONTEXT, &ctx); if (ret) { _printf_error("Cannot resolve stream event context type\n"); goto end; } } /* Resolve event context type */ if (flags & BT_CTF_RESOLVE_FLAG_EVENT_CONTEXT) { ret = resolve_root_type(BT_CTF_SCOPE_EVENT_CONTEXT, &ctx); if (ret) { _printf_error("Cannot resolve event context type\n"); goto end; } } /* Resolve event payload type */ if (flags & BT_CTF_RESOLVE_FLAG_EVENT_PAYLOAD) { ret = resolve_root_type(BT_CTF_SCOPE_EVENT_FIELDS, &ctx); if (ret) { _printf_error("Cannot resolve event payload type\n"); goto end; } } end: type_stack_destroy(ctx.type_stack); return ret; }