Merge branch 'bpf: add support for new btf kind BTF_KIND_TAG'
Yonghong Song says:
====================
LLVM14 added support for a new C attribute ([1])
__attribute__((btf_tag("arbitrary_str")))
This attribute will be emitted to dwarf ([2]) and pahole
will convert it to BTF. Or for bpf target, this
attribute will be emitted to BTF directly ([3], [4]).
The attribute is intended to provide additional
information for
- struct/union type or struct/union member
- static/global variables
- static/global function or function parameter.
This new attribute can be used to add attributes
to kernel codes, e.g., pre- or post- conditions,
allow/deny info, or any other info in which only
the kernel is interested. Such attributes will
be processed by clang frontend and emitted to
dwarf, converting to BTF by pahole. Ultimiately
the verifier can use these information for
verification purpose.
The new attribute can also be used for bpf
programs, e.g., tagging with __user attributes
for function parameters, specifying global
function preconditions, etc. Such information
may help verifier to detect user program
bugs.
After this series, pahole dwarf->btf converter
will be enhanced to support new llvm tag
for btf_tag attribute. With pahole support,
we will then try to add a few real use case,
e.g., __user/__rcu tagging, allow/deny list,
some kernel function precondition, etc,
in the kernel.
In the rest of the series, Patches 1-2 had
kernel support. Patches 3-4 added
libbpf support. Patch 5 added bpftool
support. Patches 6-10 added various selftests.
Patch 11 added documentation for the new kind.
[1] https://reviews.llvm.org/D106614
[2] https://reviews.llvm.org/D106621
[3] https://reviews.llvm.org/D106622
[4] https://reviews.llvm.org/D109560
Changelog:
v2 -> v3:
- put NR_BTF_KINDS and BTF_KIND_MAX into enum as well
- check component_idx earlier (check_meta stage) in kernel
- add more tests
- fix misc nits
v1 -> v2:
- BTF ELF format changed in llvm ([4] above),
so cross-board change to use the new format.
- Clarified in commit message that BTF_KIND_TAG
is not emitted by bpftool btf dump format c.
- Fix various comments from Andrii.
====================
Acked-by: Andrii Nakryiko <andrii@kernel.org>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
This commit is contained in:
Alexei Starovoitov
Коммит
4c24483e24
|
|
@ -85,6 +85,7 @@ sequentially and type id is assigned to each recognized type starting from id
|
|||
#define BTF_KIND_VAR 14 /* Variable */
|
||||
#define BTF_KIND_DATASEC 15 /* Section */
|
||||
#define BTF_KIND_FLOAT 16 /* Floating point */
|
||||
#define BTF_KIND_TAG 17 /* Tag */
|
||||
|
||||
Note that the type section encodes debug info, not just pure types.
|
||||
``BTF_KIND_FUNC`` is not a type, and it represents a defined subprogram.
|
||||
|
|
@ -106,7 +107,7 @@ Each type contains the following common data::
|
|||
* "size" tells the size of the type it is describing.
|
||||
*
|
||||
* "type" is used by PTR, TYPEDEF, VOLATILE, CONST, RESTRICT,
|
||||
* FUNC and FUNC_PROTO.
|
||||
* FUNC, FUNC_PROTO and TAG.
|
||||
* "type" is a type_id referring to another type.
|
||||
*/
|
||||
union {
|
||||
|
|
@ -465,6 +466,32 @@ map definition.
|
|||
|
||||
No additional type data follow ``btf_type``.
|
||||
|
||||
2.2.17 BTF_KIND_TAG
|
||||
~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
``struct btf_type`` encoding requirement:
|
||||
* ``name_off``: offset to a non-empty string
|
||||
* ``info.kind_flag``: 0
|
||||
* ``info.kind``: BTF_KIND_TAG
|
||||
* ``info.vlen``: 0
|
||||
* ``type``: ``struct``, ``union``, ``func`` or ``var``
|
||||
|
||||
``btf_type`` is followed by ``struct btf_tag``.::
|
||||
|
||||
struct btf_tag {
|
||||
__u32 component_idx;
|
||||
};
|
||||
|
||||
The ``name_off`` encodes btf_tag attribute string.
|
||||
The ``type`` should be ``struct``, ``union``, ``func`` or ``var``.
|
||||
For ``var`` type, ``btf_tag.component_idx`` must be ``-1``.
|
||||
For the other three types, if the btf_tag attribute is
|
||||
applied to the ``struct``, ``union`` or ``func`` itself,
|
||||
``btf_tag.component_idx`` must be ``-1``. Otherwise,
|
||||
the attribute is applied to a ``struct``/``union`` member or
|
||||
a ``func`` argument, and ``btf_tag.component_idx`` should be a
|
||||
valid index (starting from 0) pointing to a member or an argument.
|
||||
|
||||
3. BTF Kernel API
|
||||
*****************
|
||||
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ struct btf_type {
|
|||
* "size" tells the size of the type it is describing.
|
||||
*
|
||||
* "type" is used by PTR, TYPEDEF, VOLATILE, CONST, RESTRICT,
|
||||
* FUNC, FUNC_PROTO and VAR.
|
||||
* FUNC, FUNC_PROTO, VAR and TAG.
|
||||
* "type" is a type_id referring to another type.
|
||||
*/
|
||||
union {
|
||||
|
|
@ -56,25 +56,29 @@ struct btf_type {
|
|||
#define BTF_INFO_VLEN(info) ((info) & 0xffff)
|
||||
#define BTF_INFO_KFLAG(info) ((info) >> 31)
|
||||
|
||||
#define BTF_KIND_UNKN 0 /* Unknown */
|
||||
#define BTF_KIND_INT 1 /* Integer */
|
||||
#define BTF_KIND_PTR 2 /* Pointer */
|
||||
#define BTF_KIND_ARRAY 3 /* Array */
|
||||
#define BTF_KIND_STRUCT 4 /* Struct */
|
||||
#define BTF_KIND_UNION 5 /* Union */
|
||||
#define BTF_KIND_ENUM 6 /* Enumeration */
|
||||
#define BTF_KIND_FWD 7 /* Forward */
|
||||
#define BTF_KIND_TYPEDEF 8 /* Typedef */
|
||||
#define BTF_KIND_VOLATILE 9 /* Volatile */
|
||||
#define BTF_KIND_CONST 10 /* Const */
|
||||
#define BTF_KIND_RESTRICT 11 /* Restrict */
|
||||
#define BTF_KIND_FUNC 12 /* Function */
|
||||
#define BTF_KIND_FUNC_PROTO 13 /* Function Proto */
|
||||
#define BTF_KIND_VAR 14 /* Variable */
|
||||
#define BTF_KIND_DATASEC 15 /* Section */
|
||||
#define BTF_KIND_FLOAT 16 /* Floating point */
|
||||
#define BTF_KIND_MAX BTF_KIND_FLOAT
|
||||
#define NR_BTF_KINDS (BTF_KIND_MAX + 1)
|
||||
enum {
|
||||
BTF_KIND_UNKN = 0, /* Unknown */
|
||||
BTF_KIND_INT = 1, /* Integer */
|
||||
BTF_KIND_PTR = 2, /* Pointer */
|
||||
BTF_KIND_ARRAY = 3, /* Array */
|
||||
BTF_KIND_STRUCT = 4, /* Struct */
|
||||
BTF_KIND_UNION = 5, /* Union */
|
||||
BTF_KIND_ENUM = 6, /* Enumeration */
|
||||
BTF_KIND_FWD = 7, /* Forward */
|
||||
BTF_KIND_TYPEDEF = 8, /* Typedef */
|
||||
BTF_KIND_VOLATILE = 9, /* Volatile */
|
||||
BTF_KIND_CONST = 10, /* Const */
|
||||
BTF_KIND_RESTRICT = 11, /* Restrict */
|
||||
BTF_KIND_FUNC = 12, /* Function */
|
||||
BTF_KIND_FUNC_PROTO = 13, /* Function Proto */
|
||||
BTF_KIND_VAR = 14, /* Variable */
|
||||
BTF_KIND_DATASEC = 15, /* Section */
|
||||
BTF_KIND_FLOAT = 16, /* Floating point */
|
||||
BTF_KIND_TAG = 17, /* Tag */
|
||||
|
||||
NR_BTF_KINDS,
|
||||
BTF_KIND_MAX = NR_BTF_KINDS - 1,
|
||||
};
|
||||
|
||||
/* For some specific BTF_KIND, "struct btf_type" is immediately
|
||||
* followed by extra data.
|
||||
|
|
@ -170,4 +174,15 @@ struct btf_var_secinfo {
|
|||
__u32 size;
|
||||
};
|
||||
|
||||
/* BTF_KIND_TAG is followed by a single "struct btf_tag" to describe
|
||||
* additional information related to the tag applied location.
|
||||
* If component_idx == -1, the tag is applied to a struct, union,
|
||||
* variable or function. Otherwise, it is applied to a struct/union
|
||||
* member or a func argument, and component_idx indicates which member
|
||||
* or argument (0 ... vlen-1).
|
||||
*/
|
||||
struct btf_tag {
|
||||
__s32 component_idx;
|
||||
};
|
||||
|
||||
#endif /* _UAPI__LINUX_BTF_H__ */
|
||||
|
|
|
|||
128
kernel/bpf/btf.c
128
kernel/bpf/btf.c
|
|
@ -281,6 +281,7 @@ static const char * const btf_kind_str[NR_BTF_KINDS] = {
|
|||
[BTF_KIND_VAR] = "VAR",
|
||||
[BTF_KIND_DATASEC] = "DATASEC",
|
||||
[BTF_KIND_FLOAT] = "FLOAT",
|
||||
[BTF_KIND_TAG] = "TAG",
|
||||
};
|
||||
|
||||
const char *btf_type_str(const struct btf_type *t)
|
||||
|
|
@ -459,6 +460,17 @@ static bool btf_type_is_datasec(const struct btf_type *t)
|
|||
return BTF_INFO_KIND(t->info) == BTF_KIND_DATASEC;
|
||||
}
|
||||
|
||||
static bool btf_type_is_tag(const struct btf_type *t)
|
||||
{
|
||||
return BTF_INFO_KIND(t->info) == BTF_KIND_TAG;
|
||||
}
|
||||
|
||||
static bool btf_type_is_tag_target(const struct btf_type *t)
|
||||
{
|
||||
return btf_type_is_func(t) || btf_type_is_struct(t) ||
|
||||
btf_type_is_var(t);
|
||||
}
|
||||
|
||||
u32 btf_nr_types(const struct btf *btf)
|
||||
{
|
||||
u32 total = 0;
|
||||
|
|
@ -537,6 +549,7 @@ const struct btf_type *btf_type_resolve_func_ptr(const struct btf *btf,
|
|||
static bool btf_type_is_resolve_source_only(const struct btf_type *t)
|
||||
{
|
||||
return btf_type_is_var(t) ||
|
||||
btf_type_is_tag(t) ||
|
||||
btf_type_is_datasec(t);
|
||||
}
|
||||
|
||||
|
|
@ -563,6 +576,7 @@ static bool btf_type_needs_resolve(const struct btf_type *t)
|
|||
btf_type_is_struct(t) ||
|
||||
btf_type_is_array(t) ||
|
||||
btf_type_is_var(t) ||
|
||||
btf_type_is_tag(t) ||
|
||||
btf_type_is_datasec(t);
|
||||
}
|
||||
|
||||
|
|
@ -616,6 +630,11 @@ static const struct btf_var *btf_type_var(const struct btf_type *t)
|
|||
return (const struct btf_var *)(t + 1);
|
||||
}
|
||||
|
||||
static const struct btf_tag *btf_type_tag(const struct btf_type *t)
|
||||
{
|
||||
return (const struct btf_tag *)(t + 1);
|
||||
}
|
||||
|
||||
static const struct btf_kind_operations *btf_type_ops(const struct btf_type *t)
|
||||
{
|
||||
return kind_ops[BTF_INFO_KIND(t->info)];
|
||||
|
|
@ -3801,6 +3820,110 @@ static const struct btf_kind_operations float_ops = {
|
|||
.show = btf_df_show,
|
||||
};
|
||||
|
||||
static s32 btf_tag_check_meta(struct btf_verifier_env *env,
|
||||
const struct btf_type *t,
|
||||
u32 meta_left)
|
||||
{
|
||||
const struct btf_tag *tag;
|
||||
u32 meta_needed = sizeof(*tag);
|
||||
s32 component_idx;
|
||||
const char *value;
|
||||
|
||||
if (meta_left < meta_needed) {
|
||||
btf_verifier_log_basic(env, t,
|
||||
"meta_left:%u meta_needed:%u",
|
||||
meta_left, meta_needed);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
value = btf_name_by_offset(env->btf, t->name_off);
|
||||
if (!value || !value[0]) {
|
||||
btf_verifier_log_type(env, t, "Invalid value");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (btf_type_vlen(t)) {
|
||||
btf_verifier_log_type(env, t, "vlen != 0");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (btf_type_kflag(t)) {
|
||||
btf_verifier_log_type(env, t, "Invalid btf_info kind_flag");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
component_idx = btf_type_tag(t)->component_idx;
|
||||
if (component_idx < -1) {
|
||||
btf_verifier_log_type(env, t, "Invalid component_idx");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
btf_verifier_log_type(env, t, NULL);
|
||||
|
||||
return meta_needed;
|
||||
}
|
||||
|
||||
static int btf_tag_resolve(struct btf_verifier_env *env,
|
||||
const struct resolve_vertex *v)
|
||||
{
|
||||
const struct btf_type *next_type;
|
||||
const struct btf_type *t = v->t;
|
||||
u32 next_type_id = t->type;
|
||||
struct btf *btf = env->btf;
|
||||
s32 component_idx;
|
||||
u32 vlen;
|
||||
|
||||
next_type = btf_type_by_id(btf, next_type_id);
|
||||
if (!next_type || !btf_type_is_tag_target(next_type)) {
|
||||
btf_verifier_log_type(env, v->t, "Invalid type_id");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (!env_type_is_resolve_sink(env, next_type) &&
|
||||
!env_type_is_resolved(env, next_type_id))
|
||||
return env_stack_push(env, next_type, next_type_id);
|
||||
|
||||
component_idx = btf_type_tag(t)->component_idx;
|
||||
if (component_idx != -1) {
|
||||
if (btf_type_is_var(next_type)) {
|
||||
btf_verifier_log_type(env, v->t, "Invalid component_idx");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (btf_type_is_struct(next_type)) {
|
||||
vlen = btf_type_vlen(next_type);
|
||||
} else {
|
||||
/* next_type should be a function */
|
||||
next_type = btf_type_by_id(btf, next_type->type);
|
||||
vlen = btf_type_vlen(next_type);
|
||||
}
|
||||
|
||||
if ((u32)component_idx >= vlen) {
|
||||
btf_verifier_log_type(env, v->t, "Invalid component_idx");
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
env_stack_pop_resolved(env, next_type_id, 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void btf_tag_log(struct btf_verifier_env *env, const struct btf_type *t)
|
||||
{
|
||||
btf_verifier_log(env, "type=%u component_idx=%d", t->type,
|
||||
btf_type_tag(t)->component_idx);
|
||||
}
|
||||
|
||||
static const struct btf_kind_operations tag_ops = {
|
||||
.check_meta = btf_tag_check_meta,
|
||||
.resolve = btf_tag_resolve,
|
||||
.check_member = btf_df_check_member,
|
||||
.check_kflag_member = btf_df_check_kflag_member,
|
||||
.log_details = btf_tag_log,
|
||||
.show = btf_df_show,
|
||||
};
|
||||
|
||||
static int btf_func_proto_check(struct btf_verifier_env *env,
|
||||
const struct btf_type *t)
|
||||
{
|
||||
|
|
@ -3935,6 +4058,7 @@ static const struct btf_kind_operations * const kind_ops[NR_BTF_KINDS] = {
|
|||
[BTF_KIND_VAR] = &var_ops,
|
||||
[BTF_KIND_DATASEC] = &datasec_ops,
|
||||
[BTF_KIND_FLOAT] = &float_ops,
|
||||
[BTF_KIND_TAG] = &tag_ops,
|
||||
};
|
||||
|
||||
static s32 btf_check_meta(struct btf_verifier_env *env,
|
||||
|
|
@ -4019,6 +4143,10 @@ static bool btf_resolve_valid(struct btf_verifier_env *env,
|
|||
return !btf_resolved_type_id(btf, type_id) &&
|
||||
!btf_resolved_type_size(btf, type_id);
|
||||
|
||||
if (btf_type_is_tag(t))
|
||||
return btf_resolved_type_id(btf, type_id) &&
|
||||
!btf_resolved_type_size(btf, type_id);
|
||||
|
||||
if (btf_type_is_modifier(t) || btf_type_is_ptr(t) ||
|
||||
btf_type_is_var(t)) {
|
||||
t = btf_type_id_resolve(btf, &type_id);
|
||||
|
|
|
|||
|
|
@ -37,6 +37,7 @@ static const char * const btf_kind_str[NR_BTF_KINDS] = {
|
|||
[BTF_KIND_VAR] = "VAR",
|
||||
[BTF_KIND_DATASEC] = "DATASEC",
|
||||
[BTF_KIND_FLOAT] = "FLOAT",
|
||||
[BTF_KIND_TAG] = "TAG",
|
||||
};
|
||||
|
||||
struct btf_attach_table {
|
||||
|
|
@ -347,6 +348,17 @@ static int dump_btf_type(const struct btf *btf, __u32 id,
|
|||
printf(" size=%u", t->size);
|
||||
break;
|
||||
}
|
||||
case BTF_KIND_TAG: {
|
||||
const struct btf_tag *tag = (const void *)(t + 1);
|
||||
|
||||
if (json_output) {
|
||||
jsonw_uint_field(w, "type_id", t->type);
|
||||
jsonw_int_field(w, "component_idx", tag->component_idx);
|
||||
} else {
|
||||
printf(" type_id=%u component_idx=%d", t->type, tag->component_idx);
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ struct btf_type {
|
|||
* "size" tells the size of the type it is describing.
|
||||
*
|
||||
* "type" is used by PTR, TYPEDEF, VOLATILE, CONST, RESTRICT,
|
||||
* FUNC, FUNC_PROTO and VAR.
|
||||
* FUNC, FUNC_PROTO, VAR and TAG.
|
||||
* "type" is a type_id referring to another type.
|
||||
*/
|
||||
union {
|
||||
|
|
@ -56,25 +56,29 @@ struct btf_type {
|
|||
#define BTF_INFO_VLEN(info) ((info) & 0xffff)
|
||||
#define BTF_INFO_KFLAG(info) ((info) >> 31)
|
||||
|
||||
#define BTF_KIND_UNKN 0 /* Unknown */
|
||||
#define BTF_KIND_INT 1 /* Integer */
|
||||
#define BTF_KIND_PTR 2 /* Pointer */
|
||||
#define BTF_KIND_ARRAY 3 /* Array */
|
||||
#define BTF_KIND_STRUCT 4 /* Struct */
|
||||
#define BTF_KIND_UNION 5 /* Union */
|
||||
#define BTF_KIND_ENUM 6 /* Enumeration */
|
||||
#define BTF_KIND_FWD 7 /* Forward */
|
||||
#define BTF_KIND_TYPEDEF 8 /* Typedef */
|
||||
#define BTF_KIND_VOLATILE 9 /* Volatile */
|
||||
#define BTF_KIND_CONST 10 /* Const */
|
||||
#define BTF_KIND_RESTRICT 11 /* Restrict */
|
||||
#define BTF_KIND_FUNC 12 /* Function */
|
||||
#define BTF_KIND_FUNC_PROTO 13 /* Function Proto */
|
||||
#define BTF_KIND_VAR 14 /* Variable */
|
||||
#define BTF_KIND_DATASEC 15 /* Section */
|
||||
#define BTF_KIND_FLOAT 16 /* Floating point */
|
||||
#define BTF_KIND_MAX BTF_KIND_FLOAT
|
||||
#define NR_BTF_KINDS (BTF_KIND_MAX + 1)
|
||||
enum {
|
||||
BTF_KIND_UNKN = 0, /* Unknown */
|
||||
BTF_KIND_INT = 1, /* Integer */
|
||||
BTF_KIND_PTR = 2, /* Pointer */
|
||||
BTF_KIND_ARRAY = 3, /* Array */
|
||||
BTF_KIND_STRUCT = 4, /* Struct */
|
||||
BTF_KIND_UNION = 5, /* Union */
|
||||
BTF_KIND_ENUM = 6, /* Enumeration */
|
||||
BTF_KIND_FWD = 7, /* Forward */
|
||||
BTF_KIND_TYPEDEF = 8, /* Typedef */
|
||||
BTF_KIND_VOLATILE = 9, /* Volatile */
|
||||
BTF_KIND_CONST = 10, /* Const */
|
||||
BTF_KIND_RESTRICT = 11, /* Restrict */
|
||||
BTF_KIND_FUNC = 12, /* Function */
|
||||
BTF_KIND_FUNC_PROTO = 13, /* Function Proto */
|
||||
BTF_KIND_VAR = 14, /* Variable */
|
||||
BTF_KIND_DATASEC = 15, /* Section */
|
||||
BTF_KIND_FLOAT = 16, /* Floating point */
|
||||
BTF_KIND_TAG = 17, /* Tag */
|
||||
|
||||
NR_BTF_KINDS,
|
||||
BTF_KIND_MAX = NR_BTF_KINDS - 1,
|
||||
};
|
||||
|
||||
/* For some specific BTF_KIND, "struct btf_type" is immediately
|
||||
* followed by extra data.
|
||||
|
|
@ -170,4 +174,15 @@ struct btf_var_secinfo {
|
|||
__u32 size;
|
||||
};
|
||||
|
||||
/* BTF_KIND_TAG is followed by a single "struct btf_tag" to describe
|
||||
* additional information related to the tag applied location.
|
||||
* If component_idx == -1, the tag is applied to a struct, union,
|
||||
* variable or function. Otherwise, it is applied to a struct/union
|
||||
* member or a func argument, and component_idx indicates which member
|
||||
* or argument (0 ... vlen-1).
|
||||
*/
|
||||
struct btf_tag {
|
||||
__s32 component_idx;
|
||||
};
|
||||
|
||||
#endif /* _UAPI__LINUX_BTF_H__ */
|
||||
|
|
|
|||
|
|
@ -304,6 +304,8 @@ static int btf_type_size(const struct btf_type *t)
|
|||
return base_size + sizeof(struct btf_var);
|
||||
case BTF_KIND_DATASEC:
|
||||
return base_size + vlen * sizeof(struct btf_var_secinfo);
|
||||
case BTF_KIND_TAG:
|
||||
return base_size + sizeof(struct btf_tag);
|
||||
default:
|
||||
pr_debug("Unsupported BTF_KIND:%u\n", btf_kind(t));
|
||||
return -EINVAL;
|
||||
|
|
@ -376,6 +378,9 @@ static int btf_bswap_type_rest(struct btf_type *t)
|
|||
v->size = bswap_32(v->size);
|
||||
}
|
||||
return 0;
|
||||
case BTF_KIND_TAG:
|
||||
btf_tag(t)->component_idx = bswap_32(btf_tag(t)->component_idx);
|
||||
return 0;
|
||||
default:
|
||||
pr_debug("Unsupported BTF_KIND:%u\n", btf_kind(t));
|
||||
return -EINVAL;
|
||||
|
|
@ -586,6 +591,7 @@ __s64 btf__resolve_size(const struct btf *btf, __u32 type_id)
|
|||
case BTF_KIND_CONST:
|
||||
case BTF_KIND_RESTRICT:
|
||||
case BTF_KIND_VAR:
|
||||
case BTF_KIND_TAG:
|
||||
type_id = t->type;
|
||||
break;
|
||||
case BTF_KIND_ARRAY:
|
||||
|
|
@ -2440,6 +2446,48 @@ int btf__add_datasec_var_info(struct btf *btf, int var_type_id, __u32 offset, __
|
|||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Append new BTF_KIND_TAG type with:
|
||||
* - *value* - non-empty/non-NULL string;
|
||||
* - *ref_type_id* - referenced type ID, it might not exist yet;
|
||||
* - *component_idx* - -1 for tagging reference type, otherwise struct/union
|
||||
* member or function argument index;
|
||||
* Returns:
|
||||
* - >0, type ID of newly added BTF type;
|
||||
* - <0, on error.
|
||||
*/
|
||||
int btf__add_tag(struct btf *btf, const char *value, int ref_type_id,
|
||||
int component_idx)
|
||||
{
|
||||
struct btf_type *t;
|
||||
int sz, value_off;
|
||||
|
||||
if (!value || !value[0] || component_idx < -1)
|
||||
return libbpf_err(-EINVAL);
|
||||
|
||||
if (validate_type_id(ref_type_id))
|
||||
return libbpf_err(-EINVAL);
|
||||
|
||||
if (btf_ensure_modifiable(btf))
|
||||
return libbpf_err(-ENOMEM);
|
||||
|
||||
sz = sizeof(struct btf_type) + sizeof(struct btf_tag);
|
||||
t = btf_add_type_mem(btf, sz);
|
||||
if (!t)
|
||||
return libbpf_err(-ENOMEM);
|
||||
|
||||
value_off = btf__add_str(btf, value);
|
||||
if (value_off < 0)
|
||||
return value_off;
|
||||
|
||||
t->name_off = value_off;
|
||||
t->info = btf_type_info(BTF_KIND_TAG, 0, false);
|
||||
t->type = ref_type_id;
|
||||
btf_tag(t)->component_idx = component_idx;
|
||||
|
||||
return btf_commit_type(btf, sz);
|
||||
}
|
||||
|
||||
struct btf_ext_sec_setup_param {
|
||||
__u32 off;
|
||||
__u32 len;
|
||||
|
|
@ -3256,8 +3304,8 @@ static bool btf_equal_common(struct btf_type *t1, struct btf_type *t2)
|
|||
t1->size == t2->size;
|
||||
}
|
||||
|
||||
/* Calculate type signature hash of INT. */
|
||||
static long btf_hash_int(struct btf_type *t)
|
||||
/* Calculate type signature hash of INT or TAG. */
|
||||
static long btf_hash_int_tag(struct btf_type *t)
|
||||
{
|
||||
__u32 info = *(__u32 *)(t + 1);
|
||||
long h;
|
||||
|
|
@ -3267,8 +3315,8 @@ static long btf_hash_int(struct btf_type *t)
|
|||
return h;
|
||||
}
|
||||
|
||||
/* Check structural equality of two INTs. */
|
||||
static bool btf_equal_int(struct btf_type *t1, struct btf_type *t2)
|
||||
/* Check structural equality of two INTs or TAGs. */
|
||||
static bool btf_equal_int_tag(struct btf_type *t1, struct btf_type *t2)
|
||||
{
|
||||
__u32 info1, info2;
|
||||
|
||||
|
|
@ -3535,7 +3583,8 @@ static int btf_dedup_prep(struct btf_dedup *d)
|
|||
h = btf_hash_common(t);
|
||||
break;
|
||||
case BTF_KIND_INT:
|
||||
h = btf_hash_int(t);
|
||||
case BTF_KIND_TAG:
|
||||
h = btf_hash_int_tag(t);
|
||||
break;
|
||||
case BTF_KIND_ENUM:
|
||||
h = btf_hash_enum(t);
|
||||
|
|
@ -3590,14 +3639,15 @@ static int btf_dedup_prim_type(struct btf_dedup *d, __u32 type_id)
|
|||
case BTF_KIND_FUNC_PROTO:
|
||||
case BTF_KIND_VAR:
|
||||
case BTF_KIND_DATASEC:
|
||||
case BTF_KIND_TAG:
|
||||
return 0;
|
||||
|
||||
case BTF_KIND_INT:
|
||||
h = btf_hash_int(t);
|
||||
h = btf_hash_int_tag(t);
|
||||
for_each_dedup_cand(d, hash_entry, h) {
|
||||
cand_id = (__u32)(long)hash_entry->value;
|
||||
cand = btf_type_by_id(d->btf, cand_id);
|
||||
if (btf_equal_int(t, cand)) {
|
||||
if (btf_equal_int_tag(t, cand)) {
|
||||
new_id = cand_id;
|
||||
break;
|
||||
}
|
||||
|
|
@ -3881,7 +3931,7 @@ static int btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id,
|
|||
|
||||
switch (cand_kind) {
|
||||
case BTF_KIND_INT:
|
||||
return btf_equal_int(cand_type, canon_type);
|
||||
return btf_equal_int_tag(cand_type, canon_type);
|
||||
|
||||
case BTF_KIND_ENUM:
|
||||
if (d->opts.dont_resolve_fwds)
|
||||
|
|
@ -4210,6 +4260,23 @@ static int btf_dedup_ref_type(struct btf_dedup *d, __u32 type_id)
|
|||
}
|
||||
break;
|
||||
|
||||
case BTF_KIND_TAG:
|
||||
ref_type_id = btf_dedup_ref_type(d, t->type);
|
||||
if (ref_type_id < 0)
|
||||
return ref_type_id;
|
||||
t->type = ref_type_id;
|
||||
|
||||
h = btf_hash_int_tag(t);
|
||||
for_each_dedup_cand(d, hash_entry, h) {
|
||||
cand_id = (__u32)(long)hash_entry->value;
|
||||
cand = btf_type_by_id(d->btf, cand_id);
|
||||
if (btf_equal_int_tag(t, cand)) {
|
||||
new_id = cand_id;
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case BTF_KIND_ARRAY: {
|
||||
struct btf_array *info = btf_array(t);
|
||||
|
||||
|
|
@ -4482,6 +4549,7 @@ int btf_type_visit_type_ids(struct btf_type *t, type_id_visit_fn visit, void *ct
|
|||
case BTF_KIND_TYPEDEF:
|
||||
case BTF_KIND_FUNC:
|
||||
case BTF_KIND_VAR:
|
||||
case BTF_KIND_TAG:
|
||||
return visit(&t->type, ctx);
|
||||
|
||||
case BTF_KIND_ARRAY: {
|
||||
|
|
|
|||
|
|
@ -143,6 +143,10 @@ LIBBPF_API int btf__add_datasec(struct btf *btf, const char *name, __u32 byte_sz
|
|||
LIBBPF_API int btf__add_datasec_var_info(struct btf *btf, int var_type_id,
|
||||
__u32 offset, __u32 byte_sz);
|
||||
|
||||
/* tag construction API */
|
||||
LIBBPF_API int btf__add_tag(struct btf *btf, const char *value, int ref_type_id,
|
||||
int component_idx);
|
||||
|
||||
struct btf_dedup_opts {
|
||||
unsigned int dedup_table_size;
|
||||
bool dont_resolve_fwds;
|
||||
|
|
@ -330,6 +334,11 @@ static inline bool btf_is_float(const struct btf_type *t)
|
|||
return btf_kind(t) == BTF_KIND_FLOAT;
|
||||
}
|
||||
|
||||
static inline bool btf_is_tag(const struct btf_type *t)
|
||||
{
|
||||
return btf_kind(t) == BTF_KIND_TAG;
|
||||
}
|
||||
|
||||
static inline __u8 btf_int_encoding(const struct btf_type *t)
|
||||
{
|
||||
return BTF_INT_ENCODING(*(__u32 *)(t + 1));
|
||||
|
|
@ -398,6 +407,12 @@ btf_var_secinfos(const struct btf_type *t)
|
|||
return (struct btf_var_secinfo *)(t + 1);
|
||||
}
|
||||
|
||||
struct btf_tag;
|
||||
static inline struct btf_tag *btf_tag(const struct btf_type *t)
|
||||
{
|
||||
return (struct btf_tag *)(t + 1);
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -316,6 +316,7 @@ static int btf_dump_mark_referenced(struct btf_dump *d)
|
|||
case BTF_KIND_TYPEDEF:
|
||||
case BTF_KIND_FUNC:
|
||||
case BTF_KIND_VAR:
|
||||
case BTF_KIND_TAG:
|
||||
d->type_states[t->type].referenced = 1;
|
||||
break;
|
||||
|
||||
|
|
@ -583,6 +584,7 @@ static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr)
|
|||
case BTF_KIND_FUNC:
|
||||
case BTF_KIND_VAR:
|
||||
case BTF_KIND_DATASEC:
|
||||
case BTF_KIND_TAG:
|
||||
d->type_states[id].order_state = ORDERED;
|
||||
return 0;
|
||||
|
||||
|
|
@ -2215,6 +2217,7 @@ static int btf_dump_dump_type_data(struct btf_dump *d,
|
|||
case BTF_KIND_FWD:
|
||||
case BTF_KIND_FUNC:
|
||||
case BTF_KIND_FUNC_PROTO:
|
||||
case BTF_KIND_TAG:
|
||||
err = btf_dump_unsupported_data(d, t, id);
|
||||
break;
|
||||
case BTF_KIND_INT:
|
||||
|
|
|
|||
|
|
@ -195,6 +195,8 @@ enum kern_feature_id {
|
|||
FEAT_BTF_FLOAT,
|
||||
/* BPF perf link support */
|
||||
FEAT_PERF_LINK,
|
||||
/* BTF_KIND_TAG support */
|
||||
FEAT_BTF_TAG,
|
||||
__FEAT_CNT,
|
||||
};
|
||||
|
||||
|
|
@ -1986,6 +1988,7 @@ static const char *__btf_kind_str(__u16 kind)
|
|||
case BTF_KIND_VAR: return "var";
|
||||
case BTF_KIND_DATASEC: return "datasec";
|
||||
case BTF_KIND_FLOAT: return "float";
|
||||
case BTF_KIND_TAG: return "tag";
|
||||
default: return "unknown";
|
||||
}
|
||||
}
|
||||
|
|
@ -2485,8 +2488,9 @@ static bool btf_needs_sanitization(struct bpf_object *obj)
|
|||
bool has_datasec = kernel_supports(obj, FEAT_BTF_DATASEC);
|
||||
bool has_float = kernel_supports(obj, FEAT_BTF_FLOAT);
|
||||
bool has_func = kernel_supports(obj, FEAT_BTF_FUNC);
|
||||
bool has_tag = kernel_supports(obj, FEAT_BTF_TAG);
|
||||
|
||||
return !has_func || !has_datasec || !has_func_global || !has_float;
|
||||
return !has_func || !has_datasec || !has_func_global || !has_float || !has_tag;
|
||||
}
|
||||
|
||||
static void bpf_object__sanitize_btf(struct bpf_object *obj, struct btf *btf)
|
||||
|
|
@ -2495,14 +2499,15 @@ static void bpf_object__sanitize_btf(struct bpf_object *obj, struct btf *btf)
|
|||
bool has_datasec = kernel_supports(obj, FEAT_BTF_DATASEC);
|
||||
bool has_float = kernel_supports(obj, FEAT_BTF_FLOAT);
|
||||
bool has_func = kernel_supports(obj, FEAT_BTF_FUNC);
|
||||
bool has_tag = kernel_supports(obj, FEAT_BTF_TAG);
|
||||
struct btf_type *t;
|
||||
int i, j, vlen;
|
||||
|
||||
for (i = 1; i <= btf__get_nr_types(btf); i++) {
|
||||
t = (struct btf_type *)btf__type_by_id(btf, i);
|
||||
|
||||
if (!has_datasec && btf_is_var(t)) {
|
||||
/* replace VAR with INT */
|
||||
if ((!has_datasec && btf_is_var(t)) || (!has_tag && btf_is_tag(t))) {
|
||||
/* replace VAR/TAG with INT */
|
||||
t->info = BTF_INFO_ENC(BTF_KIND_INT, 0, 0);
|
||||
/*
|
||||
* using size = 1 is the safest choice, 4 will be too
|
||||
|
|
@ -4212,6 +4217,23 @@ static int probe_kern_btf_float(void)
|
|||
strs, sizeof(strs)));
|
||||
}
|
||||
|
||||
static int probe_kern_btf_tag(void)
|
||||
{
|
||||
static const char strs[] = "\0tag";
|
||||
__u32 types[] = {
|
||||
/* int */
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
/* VAR x */ /* [2] */
|
||||
BTF_TYPE_ENC(1, BTF_INFO_ENC(BTF_KIND_VAR, 0, 0), 1),
|
||||
BTF_VAR_STATIC,
|
||||
/* attr */
|
||||
BTF_TYPE_TAG_ENC(1, 2, -1),
|
||||
};
|
||||
|
||||
return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
|
||||
strs, sizeof(strs)));
|
||||
}
|
||||
|
||||
static int probe_kern_array_mmap(void)
|
||||
{
|
||||
struct bpf_create_map_attr attr = {
|
||||
|
|
@ -4428,6 +4450,9 @@ static struct kern_feature_desc {
|
|||
[FEAT_PERF_LINK] = {
|
||||
"BPF perf link support", probe_perf_link,
|
||||
},
|
||||
[FEAT_BTF_TAG] = {
|
||||
"BTF_KIND_TAG support", probe_kern_btf_tag,
|
||||
},
|
||||
};
|
||||
|
||||
static bool kernel_supports(const struct bpf_object *obj, enum kern_feature_id feat_id)
|
||||
|
|
|
|||
|
|
@ -388,4 +388,6 @@ LIBBPF_0.5.0 {
|
|||
} LIBBPF_0.4.0;
|
||||
|
||||
LIBBPF_0.6.0 {
|
||||
global:
|
||||
btf__add_tag;
|
||||
} LIBBPF_0.5.0;
|
||||
|
|
|
|||
|
|
@ -69,6 +69,8 @@
|
|||
#define BTF_VAR_SECINFO_ENC(type, offset, size) (type), (offset), (size)
|
||||
#define BTF_TYPE_FLOAT_ENC(name, sz) \
|
||||
BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_FLOAT, 0, 0), sz)
|
||||
#define BTF_TYPE_TAG_ENC(value, type, component_idx) \
|
||||
BTF_TYPE_ENC(value, BTF_INFO_ENC(BTF_KIND_TAG, 0, 0), type), (component_idx)
|
||||
|
||||
#ifndef likely
|
||||
#define likely(x) __builtin_expect(!!(x), 1)
|
||||
|
|
|
|||
|
|
@ -24,11 +24,12 @@ static const char * const btf_kind_str_mapping[] = {
|
|||
[BTF_KIND_VAR] = "VAR",
|
||||
[BTF_KIND_DATASEC] = "DATASEC",
|
||||
[BTF_KIND_FLOAT] = "FLOAT",
|
||||
[BTF_KIND_TAG] = "TAG",
|
||||
};
|
||||
|
||||
static const char *btf_kind_str(__u16 kind)
|
||||
{
|
||||
if (kind > BTF_KIND_DATASEC)
|
||||
if (kind > BTF_KIND_TAG)
|
||||
return "UNKNOWN";
|
||||
return btf_kind_str_mapping[kind];
|
||||
}
|
||||
|
|
@ -177,6 +178,10 @@ int fprintf_btf_type_raw(FILE *out, const struct btf *btf, __u32 id)
|
|||
case BTF_KIND_FLOAT:
|
||||
fprintf(out, " size=%u", t->size);
|
||||
break;
|
||||
case BTF_KIND_TAG:
|
||||
fprintf(out, " type_id=%u component_idx=%d",
|
||||
t->type, btf_tag(t)->component_idx);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -39,8 +39,8 @@ static bool always_log;
|
|||
#define BTF_END_RAW 0xdeadbeef
|
||||
#define NAME_TBD 0xdeadb33f
|
||||
|
||||
#define NAME_NTH(N) (0xffff0000 | N)
|
||||
#define IS_NAME_NTH(X) ((X & 0xffff0000) == 0xffff0000)
|
||||
#define NAME_NTH(N) (0xfffe0000 | N)
|
||||
#define IS_NAME_NTH(X) ((X & 0xffff0000) == 0xfffe0000)
|
||||
#define GET_NAME_NTH_IDX(X) (X & 0x0000ffff)
|
||||
|
||||
#define MAX_NR_RAW_U32 1024
|
||||
|
|
@ -3661,6 +3661,249 @@ static struct btf_raw_test raw_tests[] = {
|
|||
.err_str = "Invalid type_size",
|
||||
},
|
||||
|
||||
{
|
||||
.descr = "tag test #1, struct/member, well-formed",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_STRUCT_ENC(0, 2, 8), /* [2] */
|
||||
BTF_MEMBER_ENC(NAME_TBD, 1, 0),
|
||||
BTF_MEMBER_ENC(NAME_TBD, 1, 32),
|
||||
BTF_TAG_ENC(NAME_TBD, 2, -1),
|
||||
BTF_TAG_ENC(NAME_TBD, 2, 0),
|
||||
BTF_TAG_ENC(NAME_TBD, 2, 1),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0m1\0m2\0tag1\0tag2\0tag3"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 8,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 2,
|
||||
.max_entries = 1,
|
||||
},
|
||||
{
|
||||
.descr = "tag test #2, union/member, well-formed",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_UNION_ENC(NAME_TBD, 2, 4), /* [2] */
|
||||
BTF_MEMBER_ENC(NAME_TBD, 1, 0),
|
||||
BTF_MEMBER_ENC(NAME_TBD, 1, 0),
|
||||
BTF_TAG_ENC(NAME_TBD, 2, -1),
|
||||
BTF_TAG_ENC(NAME_TBD, 2, 0),
|
||||
BTF_TAG_ENC(NAME_TBD, 2, 1),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0t\0m1\0m2\0tag1\0tag2\0tag3"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 2,
|
||||
.max_entries = 1,
|
||||
},
|
||||
{
|
||||
.descr = "tag test #3, variable, well-formed",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
|
||||
BTF_VAR_ENC(NAME_TBD, 1, 1), /* [3] */
|
||||
BTF_TAG_ENC(NAME_TBD, 2, -1),
|
||||
BTF_TAG_ENC(NAME_TBD, 3, -1),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0local\0global\0tag1\0tag2"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
},
|
||||
{
|
||||
.descr = "tag test #4, func/parameter, well-formed",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_FUNC_PROTO_ENC(0, 2), /* [2] */
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
|
||||
BTF_FUNC_ENC(NAME_TBD, 2), /* [3] */
|
||||
BTF_TAG_ENC(NAME_TBD, 3, -1),
|
||||
BTF_TAG_ENC(NAME_TBD, 3, 0),
|
||||
BTF_TAG_ENC(NAME_TBD, 3, 1),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0arg1\0arg2\0f\0tag1\0tag2\0tag3"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
},
|
||||
{
|
||||
.descr = "tag test #5, invalid value",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
|
||||
BTF_TAG_ENC(0, 2, -1),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0local\0tag"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "Invalid value",
|
||||
},
|
||||
{
|
||||
.descr = "tag test #6, invalid target type",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_TAG_ENC(NAME_TBD, 1, -1),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0tag1"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "Invalid type",
|
||||
},
|
||||
{
|
||||
.descr = "tag test #7, invalid vlen",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
|
||||
BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_TAG, 0, 1), 2), (0),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0local\0tag1"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "vlen != 0",
|
||||
},
|
||||
{
|
||||
.descr = "tag test #8, invalid kflag",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
|
||||
BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_TAG, 1, 0), 2), (-1),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0local\0tag1"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "Invalid btf_info kind_flag",
|
||||
},
|
||||
{
|
||||
.descr = "tag test #9, var, invalid component_idx",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
|
||||
BTF_TAG_ENC(NAME_TBD, 2, 0),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0local\0tag"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "Invalid component_idx",
|
||||
},
|
||||
{
|
||||
.descr = "tag test #10, struct member, invalid component_idx",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_STRUCT_ENC(0, 2, 8), /* [2] */
|
||||
BTF_MEMBER_ENC(NAME_TBD, 1, 0),
|
||||
BTF_MEMBER_ENC(NAME_TBD, 1, 32),
|
||||
BTF_TAG_ENC(NAME_TBD, 2, 2),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0m1\0m2\0tag"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 8,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 2,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "Invalid component_idx",
|
||||
},
|
||||
{
|
||||
.descr = "tag test #11, func parameter, invalid component_idx",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_FUNC_PROTO_ENC(0, 2), /* [2] */
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
|
||||
BTF_FUNC_ENC(NAME_TBD, 2), /* [3] */
|
||||
BTF_TAG_ENC(NAME_TBD, 3, 2),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0arg1\0arg2\0f\0tag"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "Invalid component_idx",
|
||||
},
|
||||
{
|
||||
.descr = "tag test #12, < -1 component_idx",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_FUNC_PROTO_ENC(0, 2), /* [2] */
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
|
||||
BTF_FUNC_ENC(NAME_TBD, 2), /* [3] */
|
||||
BTF_TAG_ENC(NAME_TBD, 3, -2),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0arg1\0arg2\0f\0tag"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "Invalid component_idx",
|
||||
},
|
||||
|
||||
}; /* struct btf_raw_test raw_tests[] */
|
||||
|
||||
static const char *get_next_str(const char *start, const char *end)
|
||||
|
|
@ -6421,27 +6664,33 @@ const struct btf_dedup_test dedup_tests[] = {
|
|||
BTF_MEMBER_ENC(NAME_NTH(4), 5, 64), /* const int *a; */
|
||||
BTF_MEMBER_ENC(NAME_NTH(5), 2, 128), /* int b[16]; */
|
||||
BTF_MEMBER_ENC(NAME_NTH(6), 1, 640), /* int c; */
|
||||
BTF_MEMBER_ENC(NAME_NTH(8), 13, 672), /* float d; */
|
||||
BTF_MEMBER_ENC(NAME_NTH(8), 15, 672), /* float d; */
|
||||
/* ptr -> [3] struct s */
|
||||
BTF_PTR_ENC(3), /* [4] */
|
||||
/* ptr -> [6] const int */
|
||||
BTF_PTR_ENC(6), /* [5] */
|
||||
/* const -> [1] int */
|
||||
BTF_CONST_ENC(1), /* [6] */
|
||||
/* tag -> [3] struct s */
|
||||
BTF_TAG_ENC(NAME_NTH(2), 3, -1), /* [7] */
|
||||
/* tag -> [3] struct s, member 1 */
|
||||
BTF_TAG_ENC(NAME_NTH(2), 3, 1), /* [8] */
|
||||
|
||||
/* full copy of the above */
|
||||
BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4), /* [7] */
|
||||
BTF_TYPE_ARRAY_ENC(7, 7, 16), /* [8] */
|
||||
BTF_STRUCT_ENC(NAME_NTH(2), 5, 88), /* [9] */
|
||||
BTF_MEMBER_ENC(NAME_NTH(3), 10, 0),
|
||||
BTF_MEMBER_ENC(NAME_NTH(4), 11, 64),
|
||||
BTF_MEMBER_ENC(NAME_NTH(5), 8, 128),
|
||||
BTF_MEMBER_ENC(NAME_NTH(6), 7, 640),
|
||||
BTF_MEMBER_ENC(NAME_NTH(8), 13, 672),
|
||||
BTF_PTR_ENC(9), /* [10] */
|
||||
BTF_PTR_ENC(12), /* [11] */
|
||||
BTF_CONST_ENC(7), /* [12] */
|
||||
BTF_TYPE_FLOAT_ENC(NAME_NTH(7), 4), /* [13] */
|
||||
BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4), /* [9] */
|
||||
BTF_TYPE_ARRAY_ENC(9, 9, 16), /* [10] */
|
||||
BTF_STRUCT_ENC(NAME_NTH(2), 5, 88), /* [11] */
|
||||
BTF_MEMBER_ENC(NAME_NTH(3), 12, 0),
|
||||
BTF_MEMBER_ENC(NAME_NTH(4), 13, 64),
|
||||
BTF_MEMBER_ENC(NAME_NTH(5), 10, 128),
|
||||
BTF_MEMBER_ENC(NAME_NTH(6), 9, 640),
|
||||
BTF_MEMBER_ENC(NAME_NTH(8), 15, 672),
|
||||
BTF_PTR_ENC(11), /* [12] */
|
||||
BTF_PTR_ENC(14), /* [13] */
|
||||
BTF_CONST_ENC(9), /* [14] */
|
||||
BTF_TYPE_FLOAT_ENC(NAME_NTH(7), 4), /* [15] */
|
||||
BTF_TAG_ENC(NAME_NTH(2), 11, -1), /* [16] */
|
||||
BTF_TAG_ENC(NAME_NTH(2), 11, 1), /* [17] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0int\0s\0next\0a\0b\0c\0float\0d"),
|
||||
|
|
@ -6458,14 +6707,16 @@ const struct btf_dedup_test dedup_tests[] = {
|
|||
BTF_MEMBER_ENC(NAME_NTH(1), 5, 64), /* const int *a; */
|
||||
BTF_MEMBER_ENC(NAME_NTH(2), 2, 128), /* int b[16]; */
|
||||
BTF_MEMBER_ENC(NAME_NTH(3), 1, 640), /* int c; */
|
||||
BTF_MEMBER_ENC(NAME_NTH(4), 7, 672), /* float d; */
|
||||
BTF_MEMBER_ENC(NAME_NTH(4), 9, 672), /* float d; */
|
||||
/* ptr -> [3] struct s */
|
||||
BTF_PTR_ENC(3), /* [4] */
|
||||
/* ptr -> [6] const int */
|
||||
BTF_PTR_ENC(6), /* [5] */
|
||||
/* const -> [1] int */
|
||||
BTF_CONST_ENC(1), /* [6] */
|
||||
BTF_TYPE_FLOAT_ENC(NAME_NTH(7), 4), /* [7] */
|
||||
BTF_TAG_ENC(NAME_NTH(2), 3, -1), /* [7] */
|
||||
BTF_TAG_ENC(NAME_NTH(2), 3, 1), /* [8] */
|
||||
BTF_TYPE_FLOAT_ENC(NAME_NTH(7), 4), /* [9] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0a\0b\0c\0d\0int\0float\0next\0s"),
|
||||
|
|
@ -6590,9 +6841,11 @@ const struct btf_dedup_test dedup_tests[] = {
|
|||
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 8),
|
||||
BTF_FUNC_ENC(NAME_TBD, 12), /* [13] func */
|
||||
BTF_TYPE_FLOAT_ENC(NAME_TBD, 2), /* [14] float */
|
||||
BTF_TAG_ENC(NAME_TBD, 13, -1), /* [15] tag */
|
||||
BTF_TAG_ENC(NAME_TBD, 13, 1), /* [16] tag */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N"),
|
||||
BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P"),
|
||||
},
|
||||
.expect = {
|
||||
.raw_types = {
|
||||
|
|
@ -6616,9 +6869,11 @@ const struct btf_dedup_test dedup_tests[] = {
|
|||
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 8),
|
||||
BTF_FUNC_ENC(NAME_TBD, 12), /* [13] func */
|
||||
BTF_TYPE_FLOAT_ENC(NAME_TBD, 2), /* [14] float */
|
||||
BTF_TAG_ENC(NAME_TBD, 13, -1), /* [15] tag */
|
||||
BTF_TAG_ENC(NAME_TBD, 13, 1), /* [16] tag */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N"),
|
||||
BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P"),
|
||||
},
|
||||
.opts = {
|
||||
.dont_resolve_fwds = false,
|
||||
|
|
@ -6767,6 +7022,152 @@ const struct btf_dedup_test dedup_tests[] = {
|
|||
.dedup_table_size = 1
|
||||
},
|
||||
},
|
||||
{
|
||||
.descr = "dedup: func/func_arg/var tags",
|
||||
.input = {
|
||||
.raw_types = {
|
||||
/* int */
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
/* static int t */
|
||||
BTF_VAR_ENC(NAME_NTH(1), 1, 0), /* [2] */
|
||||
/* void f(int a1, int a2) */
|
||||
BTF_FUNC_PROTO_ENC(0, 2), /* [3] */
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(3), 1),
|
||||
BTF_FUNC_ENC(NAME_NTH(4), 2), /* [4] */
|
||||
/* tag -> t */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 2, -1), /* [5] */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 2, -1), /* [6] */
|
||||
/* tag -> func */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 4, -1), /* [7] */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 4, -1), /* [8] */
|
||||
/* tag -> func arg a1 */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 4, 1), /* [9] */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 4, 1), /* [10] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0t\0a1\0a2\0f\0tag"),
|
||||
},
|
||||
.expect = {
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_VAR_ENC(NAME_NTH(1), 1, 0), /* [2] */
|
||||
BTF_FUNC_PROTO_ENC(0, 2), /* [3] */
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(3), 1),
|
||||
BTF_FUNC_ENC(NAME_NTH(4), 2), /* [4] */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 2, -1), /* [5] */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 4, -1), /* [6] */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 4, 1), /* [7] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0t\0a1\0a2\0f\0tag"),
|
||||
},
|
||||
.opts = {
|
||||
.dont_resolve_fwds = false,
|
||||
},
|
||||
},
|
||||
{
|
||||
.descr = "dedup: func/func_param tags",
|
||||
.input = {
|
||||
.raw_types = {
|
||||
/* int */
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
/* void f(int a1, int a2) */
|
||||
BTF_FUNC_PROTO_ENC(0, 2), /* [2] */
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(1), 1),
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
|
||||
BTF_FUNC_ENC(NAME_NTH(3), 2), /* [3] */
|
||||
/* void f(int a1, int a2) */
|
||||
BTF_FUNC_PROTO_ENC(0, 2), /* [4] */
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(1), 1),
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
|
||||
BTF_FUNC_ENC(NAME_NTH(3), 4), /* [5] */
|
||||
/* tag -> f: tag1, tag2 */
|
||||
BTF_TAG_ENC(NAME_NTH(4), 3, -1), /* [6] */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 3, -1), /* [7] */
|
||||
/* tag -> f/a2: tag1, tag2 */
|
||||
BTF_TAG_ENC(NAME_NTH(4), 3, 1), /* [8] */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 3, 1), /* [9] */
|
||||
/* tag -> f: tag1, tag3 */
|
||||
BTF_TAG_ENC(NAME_NTH(4), 5, -1), /* [10] */
|
||||
BTF_TAG_ENC(NAME_NTH(6), 5, -1), /* [11] */
|
||||
/* tag -> f/a2: tag1, tag3 */
|
||||
BTF_TAG_ENC(NAME_NTH(4), 5, 1), /* [12] */
|
||||
BTF_TAG_ENC(NAME_NTH(6), 5, 1), /* [13] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0a1\0a2\0f\0tag1\0tag2\0tag3"),
|
||||
},
|
||||
.expect = {
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_FUNC_PROTO_ENC(0, 2), /* [2] */
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(1), 1),
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
|
||||
BTF_FUNC_ENC(NAME_NTH(3), 2), /* [3] */
|
||||
BTF_TAG_ENC(NAME_NTH(4), 3, -1), /* [4] */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 3, -1), /* [5] */
|
||||
BTF_TAG_ENC(NAME_NTH(6), 3, -1), /* [6] */
|
||||
BTF_TAG_ENC(NAME_NTH(4), 3, 1), /* [7] */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 3, 1), /* [8] */
|
||||
BTF_TAG_ENC(NAME_NTH(6), 3, 1), /* [9] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0a1\0a2\0f\0tag1\0tag2\0tag3"),
|
||||
},
|
||||
.opts = {
|
||||
.dont_resolve_fwds = false,
|
||||
},
|
||||
},
|
||||
{
|
||||
.descr = "dedup: struct/struct_member tags",
|
||||
.input = {
|
||||
.raw_types = {
|
||||
/* int */
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_STRUCT_ENC(NAME_NTH(1), 2, 8), /* [2] */
|
||||
BTF_MEMBER_ENC(NAME_NTH(2), 1, 0),
|
||||
BTF_MEMBER_ENC(NAME_NTH(3), 1, 32),
|
||||
BTF_STRUCT_ENC(NAME_NTH(1), 2, 8), /* [3] */
|
||||
BTF_MEMBER_ENC(NAME_NTH(2), 1, 0),
|
||||
BTF_MEMBER_ENC(NAME_NTH(3), 1, 32),
|
||||
/* tag -> t: tag1, tag2 */
|
||||
BTF_TAG_ENC(NAME_NTH(4), 2, -1), /* [4] */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 2, -1), /* [5] */
|
||||
/* tag -> t/m2: tag1, tag2 */
|
||||
BTF_TAG_ENC(NAME_NTH(4), 2, 1), /* [6] */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 2, 1), /* [7] */
|
||||
/* tag -> t: tag1, tag3 */
|
||||
BTF_TAG_ENC(NAME_NTH(4), 3, -1), /* [8] */
|
||||
BTF_TAG_ENC(NAME_NTH(6), 3, -1), /* [9] */
|
||||
/* tag -> t/m2: tag1, tag3 */
|
||||
BTF_TAG_ENC(NAME_NTH(4), 3, 1), /* [10] */
|
||||
BTF_TAG_ENC(NAME_NTH(6), 3, 1), /* [11] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0t\0m1\0m2\0tag1\0tag2\0tag3"),
|
||||
},
|
||||
.expect = {
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_STRUCT_ENC(NAME_NTH(1), 2, 8), /* [2] */
|
||||
BTF_MEMBER_ENC(NAME_NTH(2), 1, 0),
|
||||
BTF_MEMBER_ENC(NAME_NTH(3), 1, 32),
|
||||
BTF_TAG_ENC(NAME_NTH(4), 2, -1), /* [3] */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 2, -1), /* [4] */
|
||||
BTF_TAG_ENC(NAME_NTH(6), 2, -1), /* [5] */
|
||||
BTF_TAG_ENC(NAME_NTH(4), 2, 1), /* [6] */
|
||||
BTF_TAG_ENC(NAME_NTH(5), 2, 1), /* [7] */
|
||||
BTF_TAG_ENC(NAME_NTH(6), 2, 1), /* [8] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0t\0m1\0m2\0tag1\0tag2\0tag3"),
|
||||
},
|
||||
.opts = {
|
||||
.dont_resolve_fwds = false,
|
||||
},
|
||||
},
|
||||
|
||||
};
|
||||
|
||||
|
|
@ -6801,6 +7202,8 @@ static int btf_type_size(const struct btf_type *t)
|
|||
return base_size + sizeof(struct btf_var);
|
||||
case BTF_KIND_DATASEC:
|
||||
return base_size + vlen * sizeof(struct btf_var_secinfo);
|
||||
case BTF_KIND_TAG:
|
||||
return base_size + sizeof(struct btf_tag);
|
||||
default:
|
||||
fprintf(stderr, "Unsupported BTF_KIND:%u\n", kind);
|
||||
return -EINVAL;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,14 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (c) 2021 Facebook */
|
||||
#include <test_progs.h>
|
||||
#include "tag.skel.h"
|
||||
|
||||
void test_btf_tag(void)
|
||||
{
|
||||
struct tag *skel;
|
||||
|
||||
skel = tag__open_and_load();
|
||||
if (!ASSERT_OK_PTR(skel, "btf_tag"))
|
||||
return;
|
||||
tag__destroy(skel);
|
||||
}
|
||||
|
|
@ -281,5 +281,26 @@ void test_btf_write() {
|
|||
"[17] DATASEC 'datasec1' size=12 vlen=1\n"
|
||||
"\ttype_id=1 offset=4 size=8", "raw_dump");
|
||||
|
||||
/* TAG */
|
||||
id = btf__add_tag(btf, "tag1", 16, -1);
|
||||
ASSERT_EQ(id, 18, "tag_id");
|
||||
t = btf__type_by_id(btf, 18);
|
||||
ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "tag1", "tag_value");
|
||||
ASSERT_EQ(btf_kind(t), BTF_KIND_TAG, "tag_kind");
|
||||
ASSERT_EQ(t->type, 16, "tag_type");
|
||||
ASSERT_EQ(btf_tag(t)->component_idx, -1, "tag_component_idx");
|
||||
ASSERT_STREQ(btf_type_raw_dump(btf, 18),
|
||||
"[18] TAG 'tag1' type_id=16 component_idx=-1", "raw_dump");
|
||||
|
||||
id = btf__add_tag(btf, "tag2", 14, 1);
|
||||
ASSERT_EQ(id, 19, "tag_id");
|
||||
t = btf__type_by_id(btf, 19);
|
||||
ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "tag2", "tag_value");
|
||||
ASSERT_EQ(btf_kind(t), BTF_KIND_TAG, "tag_kind");
|
||||
ASSERT_EQ(t->type, 14, "tag_type");
|
||||
ASSERT_EQ(btf_tag(t)->component_idx, 1, "tag_component_idx");
|
||||
ASSERT_STREQ(btf_type_raw_dump(btf, 19),
|
||||
"[19] TAG 'tag2' type_id=14 component_idx=1", "raw_dump");
|
||||
|
||||
btf__free(btf);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,39 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (c) 2021 Facebook */
|
||||
#include "vmlinux.h"
|
||||
#include <bpf/bpf_helpers.h>
|
||||
#include <bpf/bpf_tracing.h>
|
||||
|
||||
#define __tag1 __attribute__((btf_tag("tag1")))
|
||||
#define __tag2 __attribute__((btf_tag("tag2")))
|
||||
|
||||
struct key_t {
|
||||
int a;
|
||||
int b __tag1 __tag2;
|
||||
int c;
|
||||
} __tag1 __tag2;
|
||||
|
||||
struct {
|
||||
__uint(type, BPF_MAP_TYPE_HASH);
|
||||
__uint(max_entries, 3);
|
||||
__type(key, struct key_t);
|
||||
__type(value, __u64);
|
||||
} hashmap1 SEC(".maps");
|
||||
|
||||
__u32 total __tag1 __tag2 = 0;
|
||||
|
||||
static __noinline int foo(int x __tag1 __tag2) __tag1 __tag2
|
||||
{
|
||||
struct key_t key;
|
||||
__u64 val = 1;
|
||||
|
||||
key.a = key.b = key.c = x;
|
||||
bpf_map_update_elem(&hashmap1, &key, &val, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
SEC("fentry/bpf_fentry_test1")
|
||||
int BPF_PROG(sub, int x)
|
||||
{
|
||||
return foo(x);
|
||||
}
|
||||
|
|
@ -69,4 +69,7 @@
|
|||
#define BTF_TYPE_FLOAT_ENC(name, sz) \
|
||||
BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_FLOAT, 0, 0), sz)
|
||||
|
||||
#define BTF_TAG_ENC(value, type, component_idx) \
|
||||
BTF_TYPE_ENC(value, BTF_INFO_ENC(BTF_KIND_TAG, 0, 0), type), (component_idx)
|
||||
|
||||
#endif /* _TEST_BTF_H */
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче