2 * Copyright 2018 Philippe Proulx <pproulx@efficios.com>
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 #define BT_LOG_TAG "LIB/RESOLVE-FIELD-PATH"
24 #include "lib/logging.h"
26 #include "lib/assert-pre.h"
27 #include "common/assert.h"
28 #include <babeltrace2/trace-ir/field-path-const.h>
34 #include "field-class.h"
35 #include "field-path.h"
36 #include "resolve-field-path.h"
39 bool find_field_class_recursive(struct bt_field_class
*fc
,
40 struct bt_field_class
*tgt_fc
, struct bt_field_path
*field_path
)
49 if (bt_field_class_type_is(fc
->type
, BT_FIELD_CLASS_TYPE_OPTION
)) {
50 struct bt_field_class_option
*opt_fc
= (void *) fc
;
51 struct bt_field_path_item item
= {
52 .type
= BT_FIELD_PATH_ITEM_TYPE_CURRENT_OPTION_CONTENT
,
53 .index
= UINT64_C(-1),
56 bt_field_path_append_item(field_path
, &item
);
57 found
= find_field_class_recursive(opt_fc
->content_fc
,
63 bt_field_path_remove_last_item(field_path
);
64 } else if (fc
->type
== BT_FIELD_CLASS_TYPE_STRUCTURE
||
65 bt_field_class_type_is(fc
->type
,
66 BT_FIELD_CLASS_TYPE_VARIANT
)) {
67 struct bt_field_class_named_field_class_container
*container_fc
=
71 for (i
= 0; i
< container_fc
->named_fcs
->len
; i
++) {
72 struct bt_named_field_class
*named_fc
=
73 container_fc
->named_fcs
->pdata
[i
];
74 struct bt_field_path_item item
= {
75 .type
= BT_FIELD_PATH_ITEM_TYPE_INDEX
,
79 bt_field_path_append_item(field_path
, &item
);
80 found
= find_field_class_recursive(named_fc
->fc
,
86 bt_field_path_remove_last_item(field_path
);
88 } else if (bt_field_class_type_is(fc
->type
, BT_FIELD_CLASS_TYPE_ARRAY
)) {
89 struct bt_field_class_array
*array_fc
= (void *) fc
;
90 struct bt_field_path_item item
= {
91 .type
= BT_FIELD_PATH_ITEM_TYPE_CURRENT_ARRAY_ELEMENT
,
92 .index
= UINT64_C(-1),
95 bt_field_path_append_item(field_path
, &item
);
96 found
= find_field_class_recursive(array_fc
->element_fc
,
102 bt_field_path_remove_last_item(field_path
);
110 int find_field_class(struct bt_field_class
*root_fc
,
111 enum bt_field_path_scope root_scope
, struct bt_field_class
*tgt_fc
,
112 struct bt_field_path
**ret_field_path
)
115 struct bt_field_path
*field_path
= NULL
;
121 field_path
= bt_field_path_create();
127 field_path
->root
= root_scope
;
128 if (!find_field_class_recursive(root_fc
, tgt_fc
, field_path
)) {
130 BT_OBJECT_PUT_REF_AND_RESET(field_path
);
134 *ret_field_path
= field_path
;
139 struct bt_field_path
*find_field_class_in_ctx(struct bt_field_class
*fc
,
140 struct bt_resolve_field_path_context
*ctx
)
142 struct bt_field_path
*field_path
= NULL
;
145 ret
= find_field_class(ctx
->packet_context
, BT_FIELD_PATH_SCOPE_PACKET_CONTEXT
,
147 if (ret
|| field_path
) {
151 ret
= find_field_class(ctx
->event_common_context
,
152 BT_FIELD_PATH_SCOPE_EVENT_COMMON_CONTEXT
, fc
, &field_path
);
153 if (ret
|| field_path
) {
157 ret
= find_field_class(ctx
->event_specific_context
,
158 BT_FIELD_PATH_SCOPE_EVENT_SPECIFIC_CONTEXT
, fc
, &field_path
);
159 if (ret
|| field_path
) {
163 ret
= find_field_class(ctx
->event_payload
, BT_FIELD_PATH_SCOPE_EVENT_PAYLOAD
,
165 if (ret
|| field_path
) {
173 BT_ASSERT_PRE_DEV_FUNC
175 bool target_is_before_source(struct bt_field_path
*src_field_path
,
176 struct bt_field_path
*tgt_field_path
)
178 bool is_valid
= true;
179 uint64_t src_i
= 0, tgt_i
= 0;
181 if (tgt_field_path
->root
< src_field_path
->root
) {
185 if (tgt_field_path
->root
> src_field_path
->root
) {
190 BT_ASSERT(tgt_field_path
->root
== src_field_path
->root
);
192 for (src_i
= 0, tgt_i
= 0; src_i
< src_field_path
->items
->len
&&
193 tgt_i
< tgt_field_path
->items
->len
; src_i
++, tgt_i
++) {
194 struct bt_field_path_item
*src_fp_item
=
195 bt_field_path_borrow_item_by_index_inline(
196 src_field_path
, src_i
);
197 struct bt_field_path_item
*tgt_fp_item
=
198 bt_field_path_borrow_item_by_index_inline(
199 tgt_field_path
, tgt_i
);
201 if (src_fp_item
->type
== BT_FIELD_PATH_ITEM_TYPE_INDEX
&&
202 tgt_fp_item
->type
== BT_FIELD_PATH_ITEM_TYPE_INDEX
) {
203 if (tgt_fp_item
->index
> src_fp_item
->index
) {
217 BT_ASSERT_PRE_DEV_FUNC
219 struct bt_field_class
*borrow_root_field_class(
220 struct bt_resolve_field_path_context
*ctx
, enum bt_field_path_scope scope
)
223 case BT_FIELD_PATH_SCOPE_PACKET_CONTEXT
:
224 return ctx
->packet_context
;
225 case BT_FIELD_PATH_SCOPE_EVENT_COMMON_CONTEXT
:
226 return ctx
->event_common_context
;
227 case BT_FIELD_PATH_SCOPE_EVENT_SPECIFIC_CONTEXT
:
228 return ctx
->event_specific_context
;
229 case BT_FIELD_PATH_SCOPE_EVENT_PAYLOAD
:
230 return ctx
->event_payload
;
238 BT_ASSERT_PRE_DEV_FUNC
240 struct bt_field_class
*borrow_child_field_class(
241 struct bt_field_class
*parent_fc
,
242 struct bt_field_path_item
*fp_item
)
244 struct bt_field_class
*child_fc
= NULL
;
246 if (bt_field_class_type_is(parent_fc
->type
,
247 BT_FIELD_CLASS_TYPE_OPTION
)) {
248 struct bt_field_class_option
*opt_fc
= (void *) parent_fc
;
250 BT_ASSERT(fp_item
->type
==
251 BT_FIELD_PATH_ITEM_TYPE_CURRENT_OPTION_CONTENT
);
252 child_fc
= opt_fc
->content_fc
;
253 } else if (parent_fc
->type
== BT_FIELD_CLASS_TYPE_STRUCTURE
||
254 bt_field_class_type_is(parent_fc
->type
,
255 BT_FIELD_CLASS_TYPE_VARIANT
)) {
256 struct bt_field_class_named_field_class_container
*container_fc
=
258 struct bt_named_field_class
*named_fc
;
260 BT_ASSERT(fp_item
->type
== BT_FIELD_PATH_ITEM_TYPE_INDEX
);
261 named_fc
= container_fc
->named_fcs
->pdata
[fp_item
->index
];
262 child_fc
= named_fc
->fc
;
263 } else if (bt_field_class_type_is(parent_fc
->type
,
264 BT_FIELD_CLASS_TYPE_ARRAY
)) {
265 struct bt_field_class_array
*array_fc
= (void *) parent_fc
;
267 BT_ASSERT(fp_item
->type
==
268 BT_FIELD_PATH_ITEM_TYPE_CURRENT_ARRAY_ELEMENT
);
269 child_fc
= array_fc
->element_fc
;
275 BT_ASSERT_PRE_DEV_FUNC
277 bool target_field_path_in_different_scope_has_struct_fc_only(
278 struct bt_field_path
*src_field_path
,
279 struct bt_field_path
*tgt_field_path
,
280 struct bt_resolve_field_path_context
*ctx
)
282 bool is_valid
= true;
284 struct bt_field_class
*fc
;
286 if (src_field_path
->root
== tgt_field_path
->root
) {
290 fc
= borrow_root_field_class(ctx
, tgt_field_path
->root
);
292 for (i
= 0; i
< tgt_field_path
->items
->len
; i
++) {
293 struct bt_field_path_item
*fp_item
=
294 bt_field_path_borrow_item_by_index_inline(
297 if (bt_field_class_type_is(fc
->type
,
298 BT_FIELD_CLASS_TYPE_ARRAY
) ||
299 bt_field_class_type_is(fc
->type
,
300 BT_FIELD_CLASS_TYPE_OPTION
) ||
301 bt_field_class_type_is(fc
->type
,
302 BT_FIELD_CLASS_TYPE_VARIANT
)) {
307 BT_ASSERT(fp_item
->type
== BT_FIELD_PATH_ITEM_TYPE_INDEX
);
308 fc
= borrow_child_field_class(fc
, fp_item
);
315 BT_ASSERT_PRE_DEV_FUNC
317 bool lca_is_structure_field_class(struct bt_field_path
*src_field_path
,
318 struct bt_field_path
*tgt_field_path
,
319 struct bt_resolve_field_path_context
*ctx
)
321 bool is_valid
= true;
322 struct bt_field_class
*src_fc
;
323 struct bt_field_class
*tgt_fc
;
324 struct bt_field_class
*prev_fc
= NULL
;
325 uint64_t src_i
= 0, tgt_i
= 0;
327 if (src_field_path
->root
!= tgt_field_path
->root
) {
331 src_fc
= borrow_root_field_class(ctx
, src_field_path
->root
);
332 tgt_fc
= borrow_root_field_class(ctx
, tgt_field_path
->root
);
336 for (src_i
= 0, tgt_i
= 0; src_i
< src_field_path
->items
->len
&&
337 tgt_i
< tgt_field_path
->items
->len
; src_i
++, tgt_i
++) {
338 struct bt_field_path_item
*src_fp_item
=
339 bt_field_path_borrow_item_by_index_inline(
340 src_field_path
, src_i
);
341 struct bt_field_path_item
*tgt_fp_item
=
342 bt_field_path_borrow_item_by_index_inline(
343 tgt_field_path
, tgt_i
);
345 if (src_fc
!= tgt_fc
) {
348 * This is correct: the LCA is the root
349 * scope field class, which must be a
350 * structure field class.
355 if (prev_fc
->type
!= BT_FIELD_CLASS_TYPE_STRUCTURE
) {
363 src_fc
= borrow_child_field_class(src_fc
, src_fp_item
);
364 tgt_fc
= borrow_child_field_class(tgt_fc
, tgt_fp_item
);
371 BT_ASSERT_PRE_DEV_FUNC
373 bool lca_to_target_has_struct_fc_only(struct bt_field_path
*src_field_path
,
374 struct bt_field_path
*tgt_field_path
,
375 struct bt_resolve_field_path_context
*ctx
)
377 bool is_valid
= true;
378 struct bt_field_class
*src_fc
;
379 struct bt_field_class
*tgt_fc
;
380 uint64_t src_i
= 0, tgt_i
= 0;
382 if (src_field_path
->root
!= tgt_field_path
->root
) {
386 src_fc
= borrow_root_field_class(ctx
, src_field_path
->root
);
387 tgt_fc
= borrow_root_field_class(ctx
, tgt_field_path
->root
);
390 BT_ASSERT(src_fc
== tgt_fc
);
393 for (src_i
= 0, tgt_i
= 0; src_i
< src_field_path
->items
->len
&&
394 tgt_i
< tgt_field_path
->items
->len
; src_i
++, tgt_i
++) {
395 struct bt_field_path_item
*src_fp_item
=
396 bt_field_path_borrow_item_by_index_inline(
397 src_field_path
, src_i
);
398 struct bt_field_path_item
*tgt_fp_item
=
399 bt_field_path_borrow_item_by_index_inline(
400 tgt_field_path
, tgt_i
);
402 if (src_i
!= tgt_i
) {
403 /* Next field class is different: LCA is `tgt_fc` */
407 src_fc
= borrow_child_field_class(src_fc
, src_fp_item
);
408 tgt_fc
= borrow_child_field_class(tgt_fc
, tgt_fp_item
);
411 /* Only structure field classes to the target */
412 for (; tgt_i
< tgt_field_path
->items
->len
; tgt_i
++) {
413 struct bt_field_path_item
*tgt_fp_item
=
414 bt_field_path_borrow_item_by_index_inline(
415 tgt_field_path
, tgt_i
);
417 if (bt_field_class_type_is(tgt_fc
->type
,
418 BT_FIELD_CLASS_TYPE_ARRAY
) ||
419 bt_field_class_type_is(tgt_fc
->type
,
420 BT_FIELD_CLASS_TYPE_OPTION
) ||
421 bt_field_class_type_is(tgt_fc
->type
,
422 BT_FIELD_CLASS_TYPE_VARIANT
)) {
427 tgt_fc
= borrow_child_field_class(tgt_fc
, tgt_fp_item
);
434 BT_ASSERT_PRE_DEV_FUNC
436 bool field_path_is_valid(struct bt_field_class
*src_fc
,
437 struct bt_field_class
*tgt_fc
,
438 struct bt_resolve_field_path_context
*ctx
)
440 bool is_valid
= true;
441 struct bt_field_path
*src_field_path
= find_field_class_in_ctx(
443 struct bt_field_path
*tgt_field_path
= find_field_class_in_ctx(
446 if (!src_field_path
) {
447 BT_ASSERT_PRE_DEV_MSG("Cannot find requesting field class in "
448 "resolving context: %!+F", src_fc
);
453 if (!tgt_field_path
) {
454 BT_ASSERT_PRE_DEV_MSG("Cannot find target field class in "
455 "resolving context: %!+F", tgt_fc
);
460 /* Target must be before source */
461 if (!target_is_before_source(src_field_path
, tgt_field_path
)) {
462 BT_ASSERT_PRE_DEV_MSG("Target field class is located after "
463 "requesting field class: %![req-fc-]+F, %![tgt-fc-]+F",
470 * If target is in a different scope than source, there are no
471 * array or variant field classes on the way to the target.
473 if (!target_field_path_in_different_scope_has_struct_fc_only(
474 src_field_path
, tgt_field_path
, ctx
)) {
475 BT_ASSERT_PRE_DEV_MSG("Target field class is located in a "
476 "different scope than requesting field class, "
477 "but within an array or a variant field class: "
478 "%![req-fc-]+F, %![tgt-fc-]+F",
484 /* Same scope: LCA must be a structure field class */
485 if (!lca_is_structure_field_class(src_field_path
, tgt_field_path
, ctx
)) {
486 BT_ASSERT_PRE_DEV_MSG("Lowest common ancestor of target and "
487 "requesting field classes is not a structure field class: "
488 "%![req-fc-]+F, %![tgt-fc-]+F",
494 /* Same scope: path from LCA to target has no array/variant FTs */
495 if (!lca_to_target_has_struct_fc_only(src_field_path
, tgt_field_path
,
497 BT_ASSERT_PRE_DEV_MSG("Path from lowest common ancestor of target "
498 "and requesting field classes to target field class "
499 "contains an array or a variant field class: "
500 "%![req-fc-]+F, %![tgt-fc-]+F", src_fc
, tgt_fc
);
506 bt_object_put_ref(src_field_path
);
507 bt_object_put_ref(tgt_field_path
);
512 struct bt_field_path
*resolve_field_path(struct bt_field_class
*src_fc
,
513 struct bt_field_class
*tgt_fc
,
514 struct bt_resolve_field_path_context
*ctx
)
516 BT_ASSERT_PRE_DEV(field_path_is_valid(src_fc
, tgt_fc
, ctx
),
517 "Invalid target field class: %![req-fc-]+F, %![tgt-fc-]+F",
519 return find_field_class_in_ctx(tgt_fc
, ctx
);
523 int bt_resolve_field_paths(struct bt_field_class
*fc
,
524 struct bt_resolve_field_path_context
*ctx
)
530 /* Resolving part for dynamic array and variant field classes */
531 if (bt_field_class_type_is(fc
->type
,
532 BT_FIELD_CLASS_TYPE_OPTION_WITH_SELECTOR_FIELD
)) {
533 struct bt_field_class_option_with_selector_field
*opt_fc
= (void *) fc
;
535 BT_ASSERT(opt_fc
->selector_fc
);
536 BT_ASSERT(!opt_fc
->selector_field_path
);
537 opt_fc
->selector_field_path
= resolve_field_path(
538 fc
, opt_fc
->selector_fc
, ctx
);
539 if (!opt_fc
->selector_field_path
) {
543 } else if (fc
->type
== BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD
) {
544 struct bt_field_class_array_dynamic
*dyn_array_fc
= (void *) fc
;
546 BT_ASSERT(dyn_array_fc
->length_fc
);
547 BT_ASSERT(!dyn_array_fc
->length_field_path
);
548 dyn_array_fc
->length_field_path
= resolve_field_path(
549 fc
, dyn_array_fc
->length_fc
, ctx
);
550 if (!dyn_array_fc
->length_field_path
) {
554 } else if (bt_field_class_type_is(fc
->type
,
555 BT_FIELD_CLASS_TYPE_VARIANT_WITH_SELECTOR_FIELD
)) {
556 struct bt_field_class_variant_with_selector_field
*var_fc
=
559 if (var_fc
->selector_fc
) {
560 BT_ASSERT(!var_fc
->selector_field_path
);
561 var_fc
->selector_field_path
=
562 resolve_field_path(fc
,
563 (void *) var_fc
->selector_fc
, ctx
);
564 if (!var_fc
->selector_field_path
) {
572 if (bt_field_class_type_is(fc
->type
, BT_FIELD_CLASS_TYPE_OPTION
)) {
573 struct bt_field_class_option
*opt_fc
= (void *) fc
;
575 ret
= bt_resolve_field_paths(opt_fc
->content_fc
, ctx
);
576 } else if (fc
->type
== BT_FIELD_CLASS_TYPE_STRUCTURE
||
577 bt_field_class_type_is(fc
->type
,
578 BT_FIELD_CLASS_TYPE_VARIANT
)) {
579 struct bt_field_class_named_field_class_container
*container_fc
=
583 for (i
= 0; i
< container_fc
->named_fcs
->len
; i
++) {
584 struct bt_named_field_class
*named_fc
=
585 container_fc
->named_fcs
->pdata
[i
];
587 ret
= bt_resolve_field_paths(named_fc
->fc
, ctx
);
592 } else if (bt_field_class_type_is(fc
->type
,
593 BT_FIELD_CLASS_TYPE_ARRAY
)) {
594 struct bt_field_class_array
*array_fc
= (void *) fc
;
596 ret
= bt_resolve_field_paths(array_fc
->element_fc
, ctx
);