4 * Babeltrace - CTF IR: Type resolving internal
6 * Copyright 2015 Jérémie Galarneau <jeremie.galarneau@efficios.com>
7 * Copyright 2016 Philippe Proulx <pproulx@efficios.com>
9 * Authors: Jérémie Galarneau <jeremie.galarneau@efficios.com>
10 * Philippe Proulx <pproulx@efficios.com>
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:
19 * The above copyright notice and this permission notice shall be included in
20 * all copies or substantial portions of the Software.
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
31 #define BT_LOG_TAG "RESOLVE"
32 #include <babeltrace/lib-logging-internal.h>
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>
50 typedef GPtrArray type_stack
;
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).
59 * `type` is owned by the stack frame.
61 struct type_stack_frame
{
62 struct bt_ctf_field_type
*type
;
67 * The current context of the resolving engine.
69 * `scopes` contain the 6 CTF scope field types (see CTF, sect. 7.3.2)
70 * in the following order:
75 * * Stream event context
79 struct resolve_context
{
80 struct bt_value
*environment
;
81 struct bt_ctf_field_type
*scopes
[6];
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
;
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.",
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,
112 * Destroys a type stack frame.
115 void type_stack_destroy_notify(gpointer data
)
117 struct type_stack_frame
*frame
= data
;
124 * Creates a type stack.
126 * Return value is owned by the caller.
129 type_stack
*type_stack_create(void)
131 return g_ptr_array_new_with_free_func(type_stack_destroy_notify
);
135 * Destroys a type stack.
138 void type_stack_destroy(type_stack
*stack
)
140 g_ptr_array_free(stack
, TRUE
);
144 * Pushes a field type onto a type stack.
146 * `type` is owned by the caller (stack frame gets a new reference).
149 int type_stack_push(type_stack
*stack
, struct bt_ctf_field_type
*type
)
152 struct type_stack_frame
*frame
= NULL
;
154 if (!stack
|| !type
) {
155 BT_LOGW("Invalid parameter: stack or type is NULL.");
160 frame
= g_new0(struct type_stack_frame
, 1);
162 BT_LOGE_STR("Failed to allocate one field type stack frame.");
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
);
177 * Checks whether or not `stack` is empty.
180 bt_bool
type_stack_empty(type_stack
*stack
)
182 return stack
->len
== 0;
186 * Returns the number of frames in `stack`.
189 size_t type_stack_size(type_stack
*stack
)
195 * Returns the top frame of `stack`.
197 * Return value is owned by `stack`.
200 struct type_stack_frame
*type_stack_peek(type_stack
*stack
)
202 struct type_stack_frame
*entry
= NULL
;
204 if (!stack
|| type_stack_empty(stack
)) {
208 entry
= g_ptr_array_index(stack
, stack
->len
- 1);
214 * Returns the frame at index `index` in `stack`.
216 * Return value is owned by `stack`.
219 struct type_stack_frame
*type_stack_at(type_stack
*stack
,
222 struct type_stack_frame
*entry
= NULL
;
224 if (!stack
|| index
>= stack
->len
) {
228 entry
= g_ptr_array_index(stack
, index
);
235 * Removes the top frame of `stack`.
238 void type_stack_pop(type_stack
*stack
)
240 if (!type_stack_empty(stack
)) {
242 * This will call the frame's destructor and free it, as
243 * well as put its contained field type.
245 BT_LOGV("Popping context's stack: stack-size-before=%u",
247 g_ptr_array_set_size(stack
, stack
->len
- 1);
252 * Returns the scope field type of `scope` in the context `ctx`.
254 * Return value is owned by `ctx` on success.
257 struct bt_ctf_field_type
*get_type_from_ctx(struct resolve_context
*ctx
,
258 enum bt_ctf_scope scope
)
260 assert(scope
>= BT_CTF_SCOPE_TRACE_PACKET_HEADER
&&
261 scope
<= BT_CTF_SCOPE_EVENT_FIELDS
);
263 return ctx
->scopes
[scope
- BT_CTF_SCOPE_TRACE_PACKET_HEADER
];
267 * Returns the CTF scope from a path string. May return
268 * CTF_NODE_UNKNOWN if the path is found to be relative.
271 enum bt_ctf_scope
get_root_scope_from_absolute_pathstr(const char *pathstr
)
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
);
278 for (scope
= BT_CTF_SCOPE_ENV
; scope
< BT_CTF_SCOPE_ENV
+
279 prefixes_count
; scope
++) {
281 * Chech if path string starts with a known absolute
284 * Refer to CTF 7.3.2 STATIC AND DYNAMIC SCOPES.
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
));
298 BT_LOGV("Found root scope from absolute path: "
299 "path=\"%s\", scope=%s", pathstr
,
300 bt_ctf_scope_string(scope
));
309 * Destroys a path token.
312 void ptokens_destroy_func(gpointer ptoken
, gpointer data
)
314 g_string_free(ptoken
, TRUE
);
318 * Destroys a path token list.
321 void ptokens_destroy(GList
*ptokens
)
327 g_list_foreach(ptokens
, ptokens_destroy_func
, NULL
);
328 g_list_free(ptokens
);
332 * Returns the string contained in a path token.
335 const char *ptoken_get_string(GList
*ptoken
)
337 GString
*tokenstr
= (GString
*) ptoken
->data
;
339 return tokenstr
->str
;
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
347 * Return value is owned by the caller on success.
350 GList
*pathstr_to_ptokens(const char *pathstr
)
352 const char *at
= pathstr
;
353 const char *last
= at
;
354 GList
*ptokens
= NULL
;
357 if (*at
== '.' || *at
== '\0') {
361 /* Error: empty token */
362 BT_LOGW("Empty path token: path=\"%s\", pos=%u",
363 pathstr
, (int) (at
- pathstr
));
367 tokenstr
= g_string_new(NULL
);
368 g_string_append_len(tokenstr
, last
, at
- last
);
369 ptokens
= g_list_append(ptokens
, tokenstr
);
383 ptokens_destroy(ptokens
);
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`.
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
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
)
402 GList
*cur_ptoken
= ptokens
;
403 bt_bool first_level_done
= BT_FALSE
;
405 /* Get our own reference */
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
);
416 BT_LOGV("Current path token: token=\"%s\"", field_name
);
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
) {
423 child_index
= bt_ctf_field_type_get_field_index(type
,
425 if (child_index
< 0) {
427 * Error: field name does not exist or
428 * wrong current type.
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
);
435 } else if (child_index
> src_index
&&
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
);
444 /* Next path token */
445 cur_ptoken
= g_list_next(cur_ptoken
);
446 first_level_done
= BT_TRUE
;
449 /* Create new field path entry */
450 g_array_append_val(field_path
->indexes
, child_index
);
452 /* Get child field type */
453 child_type
= bt_ctf_field_type_get_field_at_index(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
);
463 /* Move child type to current type */
464 BT_MOVE(type
, child_type
);
473 * Converts a known absolute path token list to a field path object
474 * within the resolving context `ctx`.
476 * `ptokens` is owned by the caller. `field_path` is an output parameter
477 * owned by the caller that must be filled here.
480 int absolute_ptokens_to_field_path(GList
*ptokens
,
481 struct bt_ctf_field_path
*field_path
,
482 struct resolve_context
*ctx
)
486 struct bt_ctf_field_type
*type
;
488 /* Skip absolute path tokens */
489 cur_ptoken
= g_list_nth(ptokens
,
490 absolute_path_prefix_ptoken_counts
[field_path
->root
]);
492 /* Start with root type */
493 type
= get_type_from_ctx(ctx
, field_path
->root
);
495 /* Error: root type is not available */
496 BT_LOGW("Root field type is not available: "
498 bt_ctf_scope_string(field_path
->root
));
504 ret
= ptokens_to_field_path(cur_ptoken
, field_path
, type
, INT_MAX
);
511 * Converts a known relative path token list to a field path object
512 * within the resolving context `ctx`.
514 * `ptokens` is owned by the caller. `field_path` is an output parameter
515 * owned by the caller that must be filled here.
518 int relative_ptokens_to_field_path(GList
*ptokens
,
519 struct bt_ctf_field_path
*field_path
,
520 struct resolve_context
*ctx
)
523 int parent_pos_in_stack
;
524 struct bt_ctf_field_path
*tail_field_path
= bt_ctf_field_path_create();
526 if (!tail_field_path
) {
527 BT_LOGE_STR("Cannot create empty field path.");
532 parent_pos_in_stack
= type_stack_size(ctx
->type_stack
) - 1;
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
;
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
);
545 /* Locate target from current parent type */
546 ret
= ptokens_to_field_path(ptokens
, tail_field_path
,
547 parent_type
, cur_index
);
549 /* Not found... yet */
550 BT_LOGV_STR("Not found at this point.");
551 bt_ctf_field_path_clear(tail_field_path
);
553 /* Found: stitch tail field path to head field path */
555 int tail_field_path_len
=
556 tail_field_path
->indexes
->len
;
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
;
564 if (cur_type
== parent_type
) {
568 g_array_append_val(field_path
->indexes
,
573 for (i
= 0; i
< tail_field_path_len
; i
++) {
574 int index
= g_array_index(
575 tail_field_path
->indexes
,
578 g_array_append_val(field_path
->indexes
,
584 parent_pos_in_stack
--;
587 if (parent_pos_in_stack
< 0) {
588 /* Not found: look in previous scopes */
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
);
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
);
603 /* Locate target in previous scope */
604 ret
= ptokens_to_field_path(ptokens
, field_path
,
608 BT_LOGV_STR("Not found in this scope.");
614 BT_LOGV_STR("Found in this scope.");
620 BT_PUT(tail_field_path
);
625 * Converts a path string to a field path object within the resolving
628 * Return value is owned by the caller on success.
631 struct bt_ctf_field_path
*pathstr_to_field_path(const char *pathstr
,
632 struct resolve_context
*ctx
)
635 enum bt_ctf_scope root_scope
;
636 GList
*ptokens
= NULL
;
637 struct bt_ctf_field_path
*field_path
= NULL
;
639 /* Create field path */
640 field_path
= bt_ctf_field_path_create();
642 BT_LOGE_STR("Cannot create empty field path.");
647 /* Convert path string to path tokens */
648 ptokens
= pathstr_to_ptokens(pathstr
);
650 BT_LOGW("Cannot convert path string to path tokens: "
651 "path=\"%s\"", pathstr
);
656 /* Absolute or relative path? */
657 root_scope
= get_root_scope_from_absolute_pathstr(pathstr
);
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
);
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
));
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
);
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
);
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
));
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
;
697 BT_LOGV("Found field path: path=\"%s\", field-path=\"%s\"",
698 pathstr
, field_path_pretty_str
);
700 if (field_path_pretty
) {
701 g_string_free(field_path_pretty
, TRUE
);
710 ptokens_destroy(ptokens
);
715 * Retrieves a field type by following the field path `field_path` in
716 * the resolving context `ctx`.
718 * Return value is owned by the caller on success.
721 struct bt_ctf_field_type
*field_path_to_field_type(
722 struct bt_ctf_field_path
*field_path
,
723 struct resolve_context
*ctx
)
726 struct bt_ctf_field_type
*type
;
728 /* Start with root type */
729 type
= get_type_from_ctx(ctx
, field_path
->root
);
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
));
739 for (i
= 0; i
< field_path
->indexes
->len
; i
++) {
740 struct bt_ctf_field_type
*child_type
;
742 g_array_index(field_path
->indexes
, int, i
);
744 /* Get child field type */
745 child_type
= bt_ctf_field_type_get_field_at_index(type
,
748 BT_LOGW("Cannot get field type: "
749 "parent-ft-addr=%p, index=%d", type
, i
);
753 /* Move child type to current type */
754 BT_MOVE(type
, child_type
);
765 * Returns the equivalent field path object of the context type stack.
767 * Return value is owned by the caller on success.
770 struct bt_ctf_field_path
*get_ctx_stack_field_path(struct resolve_context
*ctx
)
773 struct bt_ctf_field_path
*field_path
;
775 /* Create field path */
776 field_path
= bt_ctf_field_path_create();
778 BT_LOGE_STR("Cannot create empty field path.");
782 field_path
->root
= ctx
->root_scope
;
784 for (i
= 0; i
< type_stack_size(ctx
->type_stack
); i
++) {
785 struct type_stack_frame
*frame
;
787 frame
= type_stack_at(ctx
->type_stack
, i
);
788 g_array_append_val(field_path
->indexes
, frame
->index
);
799 * Returns the lowest common ancestor of two field path objects
800 * having the same root scope.
802 * `field_path1` and `field_path2` are owned by the caller.
804 int get_field_paths_lca_index(struct bt_ctf_field_path
*field_path1
,
805 struct bt_ctf_field_path
*field_path2
)
808 int field_path1_len
, field_path2_len
;
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
;
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
);
824 if (field_path1_pretty
) {
825 g_string_free(field_path1_pretty
, TRUE
);
828 if (field_path2_pretty
) {
829 g_string_free(field_path2_pretty
, TRUE
);
834 * Start from both roots and find the first mismatch.
836 assert(field_path1
->root
== field_path2
->root
);
837 field_path1_len
= field_path1
->indexes
->len
;
838 field_path2_len
= field_path2
->indexes
->len
;
841 int target_index
, ctx_index
;
843 if (lca_index
== field_path2_len
||
844 lca_index
== field_path1_len
) {
846 * This means that both field paths never split.
847 * This is invalid because the target cannot be
848 * an ancestor of the source.
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
);
858 target_index
= g_array_index(field_path1
->indexes
, int,
860 ctx_index
= g_array_index(field_path2
->indexes
, int,
863 if (target_index
!= ctx_index
) {
864 /* LCA index is the previous */
871 BT_LOGV("Found LCA: lca-index=%d", lca_index
);
876 * Validates a target field path.
878 * `target_field_path` and `target_type` are owned by the caller.
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
)
886 struct bt_ctf_field_path
*ctx_field_path
;
887 int target_field_path_len
= target_field_path
->indexes
->len
;
889 enum bt_ctf_field_type_id ctx_cur_field_type_id
;
890 enum bt_ctf_field_type_id target_type_id
;
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.");
901 * Make sure the target is not a root.
903 if (target_field_path_len
== 0) {
904 BT_LOGW_STR("Target field path's length is 0 (targeting the root).");
910 * Make sure the root of the target field path is not located
911 * after the context field path's root.
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
));
922 if (target_field_path
->root
== ctx_field_path
->root
) {
923 int target_index
, ctx_index
;
926 * Find the index of the lowest common ancestor of both field
929 lca_index
= get_field_paths_lca_index(target_field_path
,
932 BT_LOGW_STR("Cannot get least common ancestor.");
938 * Make sure the target field path is located before the
939 * context field path.
941 target_index
= g_array_index(target_field_path
->indexes
,
943 ctx_index
= g_array_index(ctx_field_path
->indexes
,
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
);
956 * Make sure the target type has the right type and properties.
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
);
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",
968 bt_ctf_field_type_id_string(target_type_id
));
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(
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",
980 bt_ctf_field_type_id_string(target_type_id
));
990 BT_PUT(ctx_field_path
);
995 * Resolves a variant or sequence field type `type`.
997 * `type` is owned by the caller.
1000 int resolve_sequence_or_variant_type(struct bt_ctf_field_type
*type
,
1001 struct resolve_context
*ctx
)
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
;
1012 /* Get path string */
1014 case BT_CTF_FIELD_TYPE_ID_SEQUENCE
:
1016 bt_ctf_field_type_sequence_get_length_field_name(type
);
1018 case BT_CTF_FIELD_TYPE_ID_VARIANT
:
1020 bt_ctf_field_type_variant_get_tag_name(type
);
1027 BT_LOGW_STR("Cannot get path string.");
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
);
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
;
1045 /* Get target field type */
1046 target_type
= field_path_to_field_type(target_field_path
, ctx
);
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
);
1055 ret
= validate_target_field_path(target_field_path
, target_type
, ctx
);
1057 BT_LOGW("Invalid target field path for path string: "
1058 "path=\"%s\", target-field-path=\"%s\"",
1059 pathstr
, target_field_path_pretty_str
);
1063 /* Set target field path and target field type */
1065 case BT_CTF_FIELD_TYPE_ID_SEQUENCE
:
1066 ret
= bt_ctf_field_type_sequence_set_length_field_path(
1067 type
, target_field_path
);
1069 BT_LOGW("Cannot set sequence field type's length field path: "
1070 "ret=%d, ft-addr=%p, path=\"%s\", target-field-path=\"%s\"",
1072 target_field_path_pretty_str
);
1076 case BT_CTF_FIELD_TYPE_ID_VARIANT
:
1077 ret
= bt_ctf_field_type_variant_set_tag_field_path(
1078 type
, target_field_path
);
1080 BT_LOGW("Cannot set varaint field type's tag field path: "
1081 "ret=%d, ft-addr=%p, path=\"%s\", target-field-path=\"%s\"",
1083 target_field_path_pretty_str
);
1087 ret
= bt_ctf_field_type_variant_set_tag_field_type(
1090 BT_LOGW("Cannot set varaint field type's tag field type: "
1091 "ret=%d, ft-addr=%p, path=\"%s\", target-field-path=\"%s\"",
1093 target_field_path_pretty_str
);
1102 if (target_field_path_pretty
) {
1103 g_string_free(target_field_path_pretty
, TRUE
);
1106 BT_PUT(target_field_path
);
1107 BT_PUT(target_type
);
1112 * Resolves a field type `type`.
1114 * `type` is owned by the caller.
1117 int resolve_type(struct bt_ctf_field_type
*type
, struct resolve_context
*ctx
)
1120 enum bt_ctf_field_type_id type_id
;
1123 /* Type is not available; still valid */
1127 type_id
= bt_ctf_field_type_get_type_id(type
);
1128 ctx
->cur_field_type
= type
;
1130 /* Resolve sequence/variant field type */
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
);
1136 BT_LOGW("Cannot resolve sequence field type's length or variant field type's tag: "
1137 "ret=%d, ft-addr=%p", ret
, type
);
1145 /* Recurse into compound types */
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
:
1152 int64_t field_count
, f_index
;
1154 ret
= type_stack_push(ctx
->type_stack
, type
);
1156 BT_LOGW("Cannot push field type on context's stack: "
1157 "ft-addr=%p", type
);
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",
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
,
1176 BT_LOGW("Cannot get field type's child field: "
1177 "ft-addr=%p, index=%" PRId64
", "
1178 "count=%" PRId64
, type
, f_index
,
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;
1188 type_stack_peek(ctx
->type_stack
)->index
=
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
);
1203 type_stack_pop(ctx
->type_stack
);
1215 * Resolves the root field type corresponding to the scope `root_scope`.
1218 int resolve_root_type(enum bt_ctf_scope root_scope
, struct resolve_context
*ctx
)
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
;
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
)
1242 struct resolve_context ctx
= {
1243 .environment
= environment
,
1246 packet_context_type
,
1248 stream_event_ctx_type
,
1252 .root_scope
= BT_CTF_SCOPE_UNKNOWN
,
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
);
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.");
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
);
1277 BT_LOGW("Cannot resolve trace packet header field type: "
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
);
1287 BT_LOGW("Cannot resolve stream packet context field type: "
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
);
1297 BT_LOGW("Cannot resolve stream event header field type: "
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
);
1307 BT_LOGW("Cannot resolve stream event context field type: "
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
);
1317 BT_LOGW("Cannot resolve event context field type: "
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
);
1327 BT_LOGW("Cannot resolve event payload field type: "
1333 BT_LOGV_STR("Resolved field types.");
1336 type_stack_destroy(ctx
.type_stack
);