Add BTF_KIND_FLOAT support
Subsystems (6)
v3 cover Add BTF_KIND_FLOAT support
Some BPF programs compiled on s390 fail to load, because s390 arch-specific linux headers contain float and double types.
Introduce support for such types by representing them using the new BTF_KIND_FLOAT. This series deals with libbpf, bpftool, in-kernel BTF parser as well as selftests and documentation.
There are also pahole and LLVM parts:
* https://github.com/iii-i/dwarves/commit/btf-kind-float-v2
* https://reviews.llvm.org/D83289
but they should go in after the libbpf part is integrated.
---
v0: https://lore.kernel.org/bpf/[email protected]/
v0 -> v1: Per Andrii's suggestion, remove the unnecessary trailing u32.
v1: https://lore.kernel.org/bpf/[email protected]/
v1 -> v2: John noticed that sanitization corrupts BTF, because new and
old sizes don't match. Per Yonghong's suggestion, use a modifier type (which has the same size as the float type) as a replacement.
Per Yonghong's suggestion, add size and alignment checks to the kernel BTF parser.
v2: https://lore.kernel.org/bpf/[email protected]/
v2 -> v3: Based on Yonghong's suggestions: Use BTF_KIND_CONST instead of
BTF_KIND_TYPEDEF and make sure that the C code generated from the sanitized BTF is well-formed; fix size calculation in tests and use NAME_TBD everywhere; limit allowed sizes to 2, 4, 8, 12 and 16 (this should also fix m68k and nds32le builds).
Based on Alexei's feedback [1] I'm proceeding with the BTF_KIND_FLOAT approach.
[1] https://lore.kernel.org/bpf/CAADnVQKWPODWZ2RSJ5FJhfYpxkuV0cvSAL1O+FSr9oP1ercoBg@mail.gmail.com/
Ilya Leoshkevich (6):
bpf: Add BTF_KIND_FLOAT to uapi
libbpf: Add BTF_KIND_FLOAT support
tools/bpftool: Add BTF_KIND_FLOAT support
bpf: Add BTF_KIND_FLOAT support
selftest/bpf: Add BTF_KIND_FLOAT tests
bpf: Document BTF_KIND_FLOAT in btf.rst
Documentation/bpf/btf.rst | 17 ++- include/uapi/linux/btf.h | 5 +- kernel/bpf/btf.c | 77 ++++++++++- tools/bpf/bpftool/btf.c | 8 ++ tools/bpf/bpftool/btf_dumper.c | 1 + tools/include/uapi/linux/btf.h | 5 +- tools/lib/bpf/btf.c | 44 +++++++ tools/lib/bpf/btf.h | 8 ++ tools/lib/bpf/btf_dump.c | 4 + tools/lib/bpf/libbpf.c | 48 ++++++- tools/lib/bpf/libbpf.map | 5 + tools/lib/bpf/libbpf_internal.h | 2 + tools/testing/selftests/bpf/btf_helpers.c | 4 + tools/testing/selftests/bpf/prog_tests/btf.c | 129 +++++++++++++++++++ tools/testing/selftests/bpf/test_btf.h | 3 + 15 files changed, 351 insertions(+), 9 deletions(-)
Signature · 1 line
2.29.2
PATCH v3 1/6 bpf: Add BTF_KIND_FLOAT to uapi
Add a new kind value and expand the kind bitfield.
--- include/uapi/linux/btf.h | 5 +++-- tools/include/uapi/linux/btf.h | 5 +++-- 2 files changed, 6 insertions(+), 4 deletions(-)
include/uapi/linux/btf.h +3 -2
@@ -52,7 +52,7 @@ struct btf_type { }; }; -#define BTF_INFO_KIND (info) (((info) >> 24) & 0x0f) +#define BTF_INFO_KIND (info) (((info) >> 24) & 0x1f)#define BTF_INFO_VLEN (info) ((info) & 0xffff)#define BTF_INFO_KFLAG (info) ((info) >> 31)
@@ -72,7 +72,8 @@ struct btf_type {#define BTF_KIND_FUNC_PROTO 13/* Function Proto */ #define BTF_KIND_VAR 14/* Variable */ #define BTF_KIND_DATASEC 15/* Section */ -#define BTF_KIND_MAX BTF_KIND_DATASEC +#define BTF_KIND_FLOAT 16/* Floating point */ +#define BTF_KIND_MAX BTF_KIND_FLOAT#define NR_BTF_KINDS (BTF_KIND_MAX + 1)/* For some specific BTF_KIND, "struct btf_type" is immediately
tools/include/uapi/linux/btf.h +3 -2
@@ -52,7 +52,7 @@ struct btf_type { }; }; -#define BTF_INFO_KIND (info) (((info) >> 24) & 0x0f) +#define BTF_INFO_KIND (info) (((info) >> 24) & 0x1f)#define BTF_INFO_VLEN (info) ((info) & 0xffff)#define BTF_INFO_KFLAG (info) ((info) >> 31)
@@ -72,7 +72,8 @@ struct btf_type {#define BTF_KIND_FUNC_PROTO 13/* Function Proto */ #define BTF_KIND_VAR 14/* Variable */ #define BTF_KIND_DATASEC 15/* Section */ -#define BTF_KIND_MAX BTF_KIND_DATASEC +#define BTF_KIND_FLOAT 16/* Floating point */ +#define BTF_KIND_MAX BTF_KIND_FLOAT#define NR_BTF_KINDS (BTF_KIND_MAX + 1)/* For some specific BTF_KIND, "struct btf_type" is immediately
Signature · 1 line
2.29.2
Re: [PATCH v3 bpf-next 1/6] bpf: Add BTF_KIND_FLOAT to uapi
Quoted 3 lines · Ilya Leoshkevich
Add a new kind value and expand the kind bitfield.
Signed-off-by Ilya Leoshkevich <[email protected]>
PATCH v3 2/6 libbpf: Add BTF_KIND_FLOAT support
In reply to Ilya LeoshkevichThe logic follows that of BTF_KIND_INT most of the time. Sanitization replaces BTF_KIND_FLOATs with BTF_KIND_CONSTs pointing to equally-sized BTF_KIND_ARRAYs on older kernels.
--- tools/lib/bpf/btf.c | 44 ++++++++++++++++++++++++++++++ tools/lib/bpf/btf.h | 8 ++++++ tools/lib/bpf/btf_dump.c | 4 +++ tools/lib/bpf/libbpf.c | 48 ++++++++++++++++++++++++++++++++- tools/lib/bpf/libbpf.map | 5 ++++ tools/lib/bpf/libbpf_internal.h | 2 ++ 6 files changed, 110 insertions(+), 1 deletion(-)
tools/lib/bpf/btf.c +44 -0
@@ -292,6 +292,7 @@ static int btf_type_size(const struct btf_type *t)case BTF_KIND_PTR :case BTF_KIND_TYPEDEF :case BTF_KIND_FUNC : +case BTF_KIND_FLOAT :return base_size;case BTF_KIND_INT :return base_size +sizeof (__u32);
@@ -339,6 +340,7 @@ static int btf_bswap_type_rest(struct btf_type *t)case BTF_KIND_PTR :case BTF_KIND_TYPEDEF :case BTF_KIND_FUNC : +case BTF_KIND_FLOAT :return 0 ;case BTF_KIND_INT : *(__u32 *)(t +1 ) =bswap_32 (*(__u32 *)(t +1 ));
@@ -579,6 +581,7 @@ __s64 btf__resolve_size(const struct btf *btf, __u32 type_id)case BTF_KIND_UNION :case BTF_KIND_ENUM :case BTF_KIND_DATASEC : +case BTF_KIND_FLOAT : size = t->size; goto done;case BTF_KIND_PTR :
@@ -622,6 +625,7 @@ int btf__align_of(const struct btf *btf, __u32 id)switch (kind) {case BTF_KIND_INT :case BTF_KIND_ENUM : +case BTF_KIND_FLOAT :return min (btf_ptr_sz (btf), (size_t )t->size);case BTF_KIND_PTR :return btf_ptr_sz (btf);
@@ -2400,6 +2404,42 @@ int btf__add_datasec(struct btf *btf, const char *name, __u32 byte_sz)return btf_commit_type (btf, sz); } +/* +* Append new BTF_KIND_FLOAT type with: +* - *name* - non-empty, non-NULL type name; +* - *sz* - size of the type, in bytes; +* Returns: +* - >0, type ID of newly added BTF type; +* - <0, on error. +*/ +int btf__add_float (struct btf *btf,const char *name,size_t byte_sz) +{ +struct btf_type *t; +int sz, name_off; + +/* non-empty name */ +if (!name || !name[0 ]) +return -EINVAL ; + +if (btf_ensure_modifiable (btf)) +return -ENOMEM ; + + sz =sizeof (struct btf_type ); + t =btf_add_type_mem (btf, sz); +if (!t) +return -ENOMEM ; + + name_off =btf__add_str (btf, name); +if (name_off <0 ) +return name_off; + + t->name_off = name_off; + t->info =btf_type_info (BTF_KIND_FLOAT ,0 ,0 ); + t->size = byte_sz; + +return btf_commit_type (btf, sz); +} +/* * Append new data section variable information entry for current DATASEC type: * - *var_type_id* - type ID, describing type of the variable;
@@ -3653,6 +3693,7 @@ static int btf_dedup_prep(struct btf_dedup *d)case BTF_KIND_FWD :case BTF_KIND_TYPEDEF :case BTF_KIND_FUNC : +case BTF_KIND_FLOAT : h =btf_hash_common (t);break ;case BTF_KIND_INT :
@@ -3749,6 +3790,7 @@ static int btf_dedup_prim_type(struct btf_dedup *d, __u32 type_id)break ;case BTF_KIND_FWD : +case BTF_KIND_FLOAT : h =btf_hash_common (t);for_each_dedup_cand (d, hash_entry, h) { cand_id = (__u32 )(long )hash_entry->value;
@@ -4010,6 +4052,7 @@ static int btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id,return btf_compat_enum (cand_type, canon_type);case BTF_KIND_FWD : +case BTF_KIND_FLOAT :return btf_equal_common (cand_type, canon_type);case BTF_KIND_CONST :
@@ -4506,6 +4549,7 @@ static int btf_dedup_remap_type(struct btf_dedup *d, __u32 type_id)switch (btf_kind (t)) {case BTF_KIND_INT :case BTF_KIND_ENUM : +case BTF_KIND_FLOAT :break ;case BTF_KIND_FWD :
tools/lib/bpf/btf.h +8 -0
@@ -132,6 +132,9 @@ 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); +/* float construction APIs */ +LIBBPF_API int btf__add_float(struct btf *btf, const char *name, size_t byte_sz); +struct btf_dedup_opts {unsigned int dedup_table_size;bool dont_resolve_fwds;
@@ -294,6 +297,11 @@ static inline bool btf_is_datasec(const struct btf_type *t)return btf_kind (t) ==BTF_KIND_DATASEC ; } +static inline bool btf_is_float (const struct btf_type *t) +{ +return btf_kind (t) ==BTF_KIND_FLOAT ; +} +static inline __u8 btf_int_encoding (const struct btf_type *t) {return BTF_INT_ENCODING (*(__u32 *)(t +1 ));
tools/lib/bpf/btf_dump.c +4 -0
@@ -279,6 +279,7 @@ static int btf_dump_mark_referenced(struct btf_dump *d)case BTF_KIND_INT :case BTF_KIND_ENUM :case BTF_KIND_FWD : +case BTF_KIND_FLOAT :break ;case BTF_KIND_VOLATILE :
@@ -453,6 +454,7 @@ static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr)switch (btf_kind (t)) {case BTF_KIND_INT : +case BTF_KIND_FLOAT : tstate->order_state =ORDERED ;return 0 ;
@@ -1133,6 +1135,7 @@ static void btf_dump_emit_type_decl(struct btf_dump *d, __u32 id,case BTF_KIND_STRUCT :case BTF_KIND_UNION :case BTF_KIND_TYPEDEF : +case BTF_KIND_FLOAT : goto done;default : pr_warn("unexpected type in decl chain, kind:%u, id:[%u]\n",
@@ -1247,6 +1250,7 @@ static void btf_dump_emit_type_chain(struct btf_dump *d,switch (kind) {case BTF_KIND_INT : +case BTF_KIND_FLOAT :btf_dump_emit_mods (d, decls); name =btf_name_of (d, t->name_off);btf_dump_printf (d,"%s" , name);
tools/lib/bpf/libbpf.c +47 -1
107 lines not on this page · raw message
tools/lib/bpf/libbpf.map +5 -0
@@ -350,3 +350,8 @@ LIBBPF_0.3.0 { xsk_setup_xdp_prog; xsk_socket__update_xskmap; } LIBBPF_0.2.0; + +LIBBPF_0.4.0 { + global: + btf__add_float; +} LIBBPF_0.3.0;
tools/lib/bpf/libbpf_internal.h +2 -0
@@ -31,6 +31,8 @@#define BTF_MEMBER_ENC (name, type, bits_offset) (name), (type), (bits_offset)#define BTF_PARAM_ENC (name, type) (name), (type)#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)#ifndef likely#define likely (x) __builtin_expect(!!(x), 1)
Signature · 1 line
2.29.2
Re: [PATCH v3 bpf-next 2/6] libbpf: Add BTF_KIND_FLOAT support
Quoted 51 lines · Ilya Leoshkevich
The logic follows that of
BTF_KIND_INTmost of the time. Sanitization replacesBTF_KIND_FLOATswithBTF_KIND_CONSTspointing to equally-sizedBTF_KIND_ARRAYson older kernels.Signed-off-by Ilya Leoshkevich <[email protected]>--- tools/lib/bpf/btf.c | 44 ++++++++++++++++++++++++++++++ tools/lib/bpf/btf.h | 8 ++++++ tools/lib/bpf/btf_dump.c | 4 +++ tools/lib/bpf/libbpf.c | 48 ++++++++++++++++++++++++++++++++- tools/lib/bpf/libbpf.map | 5 ++++ tools/lib/bpf/libbpf_internal.h | 2 ++ 6 files changed, 110 insertions(+), 1 deletion(-)tools/lib/bpf/btf.c +4
-0@@ -292,6 +292,7 @@ static int btf_type_size(const struct btf_type *t)case BTF_KIND_PTR :case BTF_KIND_TYPEDEF :case BTF_KIND_FUNC : +case BTF_KIND_FLOAT :return base_size;case BTF_KIND_INT :return base_size +sizeof (__u32);@@ -339,6 +340,7 @@ static int btf_bswap_type_rest(struct btf_type *t)case BTF_KIND_PTR :case BTF_KIND_TYPEDEF :case BTF_KIND_FUNC : +case BTF_KIND_FLOAT :return 0 ;case BTF_KIND_INT : *(__u32 *)(t +1 ) =bswap_32 (*(__u32 *)(t +1 ));@@ -579,6 +581,7 @@ __s64 btf__resolve_size(const struct btf *btf, __u32 type_id)case BTF_KIND_UNION :case BTF_KIND_ENUM :case BTF_KIND_DATASEC : +case BTF_KIND_FLOAT : size = t->size; goto done;case BTF_KIND_PTR :@@ -622,6 +625,7 @@ int btf__align_of(const struct btf *btf, __u32 id)switch (kind) {case BTF_KIND_INT :case BTF_KIND_ENUM : +case BTF_KIND_FLOAT :return min (btf_ptr_sz (btf), (size_t )t->size);case BTF_KIND_PTR :return btf_ptr_sz (btf);
tools/lib/bpf/btf.c int btf__add_datasec(struct btf *btf, const char *name, __u32 byte_sz) · line 2405
Quoted 2 lines
tools/lib/bpf/btf.c +0
-0@@ -2400,6 +2404,42 @@ int btf__add_datasec(struct btf *btf, const char *name, __u32 byte_sz)return btf_commit_type (btf, sz); }
[...]
I skipped deduplication part, Andrii can take a look later.
Quoted 46 lines
tools/lib/bpf/libbpf.c +8
-1@@ -178,6 +178,8 @@ enum kern_feature_id {FEAT_PROG_BIND_MAP ,/* Kernel support for module BTFs */ FEAT_MODULE_BTF , +/* BTF_KIND_FLOAT support */ +FEAT_BTF_FLOAT , __FEAT_CNT, };@@ -1935,6 +1937,7 @@ static const char *btf_kind_str(const struct btf_type *t)case BTF_KIND_FUNC_PROTO :return "func_proto" ;case BTF_KIND_VAR :return "var" ;case BTF_KIND_DATASEC :return "datasec" ; +case BTF_KIND_FLOAT :return "float" ;default :return "unknown" ; } }@@ -2384,18 +2387,22 @@ static bool btf_needs_sanitization(struct bpf_object *obj) {bool has_func_global =kernel_supports (FEAT_BTF_GLOBAL_FUNC );bool has_datasec =kernel_supports (FEAT_BTF_DATASEC ); +bool has_float =kernel_supports (FEAT_BTF_FLOAT );bool has_func =kernel_supports (FEAT_BTF_FUNC ); -return !has_func || !has_datasec || !has_func_global; +return !has_func || !has_datasec || !has_func_global || !has_float; }static void bpf_object__sanitize_btf (struct bpf_object *obj,struct btf *btf) {bool has_func_global =kernel_supports (FEAT_BTF_GLOBAL_FUNC );bool has_datasec =kernel_supports (FEAT_BTF_DATASEC ); +bool has_float =kernel_supports (FEAT_BTF_FLOAT );bool has_func =kernel_supports (FEAT_BTF_FUNC );struct btf_type *t; +int t_uchar =0 ;int i, j, vlen; +int t_uint =0 ;for (i =1 ; i <=btf__get_nr_types (btf); i++) { t = (struct btf_type *)btf__type_by_id (btf, i);
tools/lib/bpf/libbpf.c static void bpf_object__sanitize_btf(struct bpf_object *obj, struct btf *btf) · line 2456
Quoted 5 lines
tools/lib/bpf/libbpf.c +2
-0@@ -2445,6 +2452,26 @@ static void bpf_object__sanitize_btf(struct bpf_object *obj, struct btf *btf) }else if (!has_func_global &&btf_is_func (t)) {/* replace BTF_FUNC_GLOBAL with BTF_FUNC_STATIC */ t->info =BTF_INFO_ENC (BTF_KIND_FUNC ,0 ,0 ); + }else if (!has_float &&btf_is_float (t)) { +/* replace FLOAT with TYPEDEF(u8[]) */
replace FLOAT with CONST(u8[]).
tools/lib/bpf/libbpf.c static void bpf_object__sanitize_btf(struct bpf_object *obj, struct btf *btf) · line 2467
Quoted 11 lines
tools/lib/bpf/libbpf.c +11
-0+int t_array; +__u32 size; + + size = t->size; +if (!t_uchar) + t_uchar =btf__add_int (btf,"unsigned char" ,1 , +0 ); +if (!t_uint) + t_uint =btf__add_int (btf,"unsigned int" ,4 , +0 ); + t_array =btf__add_array (btf, t_uint, t_uchar, size);
Checking whether t_array is valid here or not?
We do not need to check t_uchar/t_uint. If they are invalid btf__add_array() will return -EINVAL.
Quoted 84 lines
tools/lib/bpf/libbpf.c +26
-0+ +/* adding new types may have invalidated t */ + t = (struct btf_type *)btf__type_by_id (btf, i); + + t->name_off =0 ; + t->info =BTF_INFO_ENC (BTF_KIND_CONST ,0 ,0 ); + t->type = t_array; } } }@@ -3882,6 +3909,18 @@ static int probe_kern_btf_datasec(void) strs, sizeof(strs))); } +static int probe_kern_btf_float (void ) +{ +static const char strs[] ="\0float" ; +__u32 types[] = { +/* float */ +BTF_TYPE_FLOAT_ENC (1 ,4 ), + }; + +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 = {@@ -4061,6 +4100,9 @@ static struct kern_feature_desc { [FEAT_MODULE_BTF ] = {"module BTF support" , probe_module_btf, }, + [FEAT_BTF_FLOAT ] = { +"BTF_KIND_FLOAT support" , probe_kern_btf_float, + }, };static bool kernel_supports (enum kern_feature_id feat_id)@@ -4940,6 +4982,8 @@ static int bpf_core_fields_are_compat(const struct btf *local_btf, local_id =btf_array (local_type)->type; targ_id =btf_array (targ_type)->type; goto recur; +case BTF_KIND_FLOAT : +return local_type->size == targ_type->size;default :pr_warn ("unexpected kind %d relocated, local [%d], target [%d]\n" ,btf_kind (local_type), local_id, targ_id);@@ -5122,6 +5166,8 @@ static int bpf_core_types_are_compat(const struct btf *local_btf, __u32 local_idskip_mods_and_typedefs (targ_btf, targ_type->type, &targ_id); goto recur; } +case BTF_KIND_FLOAT : +return local_type->size == targ_type->size;default :pr_warn ("unexpected kind %s relocated, local [%d], target [%d]\n" ,btf_kind_str (local_type), local_id, targ_id);tools/lib/bpf/libbpf.map +5
-0@@ -350,3 +350,8 @@ LIBBPF_0.3.0 { xsk_setup_xdp_prog; xsk_socket__update_xskmap; } LIBBPF_0.2.0; + +LIBBPF_0.4.0 { + global: + btf__add_float; +} LIBBPF_0.3.0;tools/lib/bpf/libbpf_internal.h +2
-0@@ -31,6 +31,8 @@#define BTF_MEMBER_ENC (name, type, bits_offset) (name), (type), (bits_offset)#define BTF_PARAM_ENC (name, type) (name), (type)#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)#ifndef likely#define likely (x) __builtin_expect(!!(x), 1)
PATCH v3 3/6 tools/bpftool: Add BTF_KIND_FLOAT support
In reply to Ilya LeoshkevichOnly dumping support needs to be adjusted, the code structure follows that of BTF_KIND_INT.
--- tools/bpf/bpftool/btf.c | 8 ++++++++ tools/bpf/bpftool/btf_dumper.c | 1 + 2 files changed, 9 insertions(+)
tools/bpf/bpftool/btf.c +8 -0
@@ -36,6 +36,7 @@ static const char * const btf_kind_str[NR_BTF_KINDS] = { [BTF_KIND_FUNC_PROTO] = "FUNC_PROTO", [BTF_KIND_VAR] = "VAR", [BTF_KIND_DATASEC] = "DATASEC", + [BTF_KIND_FLOAT] = "FLOAT", };struct btf_attach_table {
@@ -327,6 +328,13 @@ static int dump_btf_type(const struct btf *btf, __u32 id,jsonw_end_array (w);break ; } +case BTF_KIND_FLOAT : { +if (json_output) +jsonw_uint_field (w,"size" , t->size); +else +printf (" size=%u" , t->size); +break ; + }default :break ; }
tools/bpf/bpftool/btf_dumper.c +1 -0
@@ -596,6 +596,7 @@ static int __btf_dumper_type_only(const struct btf *btf, __u32 type_id,switch (BTF_INFO_KIND (t->info)) {case BTF_KIND_INT :case BTF_KIND_TYPEDEF : +case BTF_KIND_FLOAT :BTF_PRINT_ARG ("%s " ,btf__name_by_offset (btf, t->name_off));break ;case BTF_KIND_STRUCT :
Signature · 1 line
2.29.2
Re: [PATCH v3 bpf-next 3/6] tools/bpftool: Add BTF_KIND_FLOAT support
Quoted 2 lines · Ilya Leoshkevich
Only dumping support needs to be adjusted, the code structure follows that of
BTF_KIND_INT.
Maybe give an example to show what exactly the output looks like?
Quoted 45 lines
Signed-off-by Ilya Leoshkevich <[email protected]> > ---tools/bpf/bpftool/btf.c | 8 ++++++++ tools/bpf/bpftool/btf_dumper.c | 1 + 2 files changed, 9 insertions(+)tools/bpf/bpftool/btf.c +8
-0@@ -36,6 +36,7 @@ static const char * const btf_kind_str[NR_BTF_KINDS] = { [BTF_KIND_FUNC_PROTO] = "FUNC_PROTO", [BTF_KIND_VAR] = "VAR", [BTF_KIND_DATASEC] = "DATASEC", + [BTF_KIND_FLOAT] = "FLOAT", };struct btf_attach_table {@@ -327,6 +328,13 @@ static int dump_btf_type(const struct btf *btf, __u32 id,jsonw_end_array (w);break ; } +case BTF_KIND_FLOAT : { +if (json_output) +jsonw_uint_field (w,"size" , t->size); +else +printf (" size=%u" , t->size); +break ; + }default :break ; }tools/bpf/bpftool/btf_dumper.c +1
-0@@ -596,6 +596,7 @@ static int __btf_dumper_type_only(const struct btf *btf, __u32 type_id,switch (BTF_INFO_KIND (t->info)) {case BTF_KIND_INT :case BTF_KIND_TYPEDEF : +case BTF_KIND_FLOAT :BTF_PRINT_ARG ("%s " ,btf__name_by_offset (btf, t->name_off));break ;case BTF_KIND_STRUCT :
PATCH v3 4/6 bpf: Add BTF_KIND_FLOAT support
In reply to Ilya LeoshkevichOn the kernel side, introduce a new btf_kind_operations. It is similar to that of BTF_KIND_INT, however, it does not need to handle encodings and bit offsets. Do not implement printing, since the kernel does not know how to format floating-point values.
--- kernel/bpf/btf.c | 77 ++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 75 insertions(+), 2 deletions(-)
kernel/bpf/btf.c +75 -2
@@ -173,7 +173,7 @@#define BITS_ROUNDUP_BYTES (bits) \ (BITS_ROUNDDOWN_BYTES(bits) + !!BITS_PER_BYTE_MASKED(bits)) -#define BTF_INFO_MASK 0x8f00ffff +#define BTF_INFO_MASK 0x9f00ffff#define BTF_INT_MASK 0x0fffffff#define BTF_TYPE_ID_VALID (type_id) ((type_id) <= BTF_MAX_TYPE)#define BTF_STR_OFFSET_VALID (name_off) ((name_off) <= BTF_MAX_NAME_OFFSET)
@@ -280,6 +280,7 @@ static const char * const btf_kind_str[NR_BTF_KINDS] = { [BTF_KIND_FUNC_PROTO] = "FUNC_PROTO", [BTF_KIND_VAR] = "VAR", [BTF_KIND_DATASEC] = "DATASEC", + [BTF_KIND_FLOAT] = "FLOAT", };static const char *btf_type_str (const struct btf_type *t)
@@ -574,6 +575,7 @@ static bool btf_type_has_size(const struct btf_type *t)case BTF_KIND_UNION :case BTF_KIND_ENUM :case BTF_KIND_DATASEC : +case BTF_KIND_FLOAT :return true; }
@@ -1704,6 +1706,7 @@ __btf_resolve_size(const struct btf *btf, const struct btf_type *type,case BTF_KIND_STRUCT :case BTF_KIND_UNION :case BTF_KIND_ENUM : +case BTF_KIND_FLOAT : size = type->size; goto resolved;
@@ -1849,7 +1852,7 @@ static int btf_df_check_kflag_member(struct btf_verifier_env *env,return -EINVAL ; } -/* Used for ptr, array and struct/union type members. +/* Used for ptr, array struct/union and float type members. * int, enum and modifier types have their specific callback functions. */ static int btf_generic_check_kflag_member(struct btf_verifier_env *env,
@@ -3675,6 +3678,75 @@ static const struct btf_kind_operations datasec_ops = { .show = btf_datasec_show, }; +static s32 btf_float_check_meta (struct btf_verifier_env *env, +const struct btf_type *t, +u32 meta_left) +{ +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 ; + } + +if (t->size !=2 && t->size !=4 && t->size !=8 && t->size !=12 && + t->size !=16 ) { +btf_verifier_log_type (env, t,"Invalid type_size" ); +return -EINVAL ; + } + +btf_verifier_log_type (env, t,NULL ); + +return 0 ; +} + +static int btf_float_check_member (struct btf_verifier_env *env, +const struct btf_type *struct_type, +const struct btf_member *member, +const struct btf_type *member_type) +{ +u64 start_offset_bytes; +u64 end_offset_bytes; +u64 align_bytes; +u64 align_bits; + + align_bytes =min_t (u64,sizeof (void *), member_type->size); + align_bits = align_bytes *BITS_PER_BYTE ; +if (member->offset % align_bits) { +btf_verifier_log_member (env, struct_type, member, +"Member is not properly aligned" ); +return -EINVAL ; + } + + start_offset_bytes = member->offset /BITS_PER_BYTE ; + end_offset_bytes = start_offset_bytes + member_type->size; +if (end_offset_bytes > struct_type->size) { +btf_verifier_log_member (env, struct_type, member, +"Member exceeds struct_size" ); +return -EINVAL ; + } + +return 0 ; +} + +static void btf_float_log (struct btf_verifier_env *env, +const struct btf_type *t) +{ +btf_verifier_log (env,"size=%u" , t->size); +} + +static const struct btf_kind_operations float_ops = { + .check_meta = btf_float_check_meta, + .resolve = btf_df_resolve, + .check_member = btf_float_check_member, + .check_kflag_member = btf_generic_check_kflag_member, + .log_details = btf_float_log, + .show = btf_df_show, +}; +static int btf_func_proto_check (struct btf_verifier_env *env,const struct btf_type *t) {
@@ -3808,6 +3880,7 @@ static const struct btf_kind_operations * const kind_ops[NR_BTF_KINDS] = { [BTF_KIND_FUNC_PROTO] = &func_proto_ops, [BTF_KIND_VAR] = &var_ops, [BTF_KIND_DATASEC] = &datasec_ops, + [BTF_KIND_FLOAT] = &float_ops, }; static s32 btf_check_meta(struct btf_verifier_env *env,
Signature · 1 line
2.29.2
kernel test robot
build botRe: [PATCH v3 bpf-next 4/6] bpf: Add BTF_KIND_FLOAT support
I love your patch! Yet something to improve:
Hi Ilya,
I love your patch! Yet something to improve:
[auto build test ERROR on bpf-next/master]
url: https://github.com/0day-ci/linux/commits/Ilya-Leoshkevich/Add-BTF_KIND_FLOAT-support/20210220-115658 base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master config: nds32-randconfig-r024-20210220 (attached as .config) compiler: nds32le-linux-gcc (GCC) 9.3.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/0day-ci/linux/commit/91b04e9599495806c46c36ba275df4e653a6f112
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Ilya-Leoshkevich/Add-BTF_KIND_FLOAT-support/20210220-115658 git checkout 91b04e9599495806c46c36ba275df4e653a6f112
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross ARCH=nds32
If you fix the issue, kindly add following tag as appropriate
All errors (new ones prefixed by >>):
nds32le-linux-ld: kernel/bpf/btf.o: in function `btf_float_check_member':
>> btf.c:(.text+0x1be6): undefined reference to `__umoddi3' >> nds32le-linux-ld: btf.c:(.text+0x1bea): undefined reference to `__umoddi3'
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
kernel test robot
build botRe: [PATCH v3 bpf-next 4/6] bpf: Add BTF_KIND_FLOAT support
In reply to Ilya LeoshkevichI love your patch! Yet something to improve:
Hi Ilya,
I love your patch! Yet something to improve:
[auto build test ERROR on bpf-next/master]
url: https://github.com/0day-ci/linux/commits/Ilya-Leoshkevich/Add-BTF_KIND_FLOAT-support/20210220-115658 base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master config: microblaze-randconfig-r016-20210219 (attached as .config) compiler: microblaze-linux-gcc (GCC) 9.3.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/0day-ci/linux/commit/91b04e9599495806c46c36ba275df4e653a6f112
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Ilya-Leoshkevich/Add-BTF_KIND_FLOAT-support/20210220-115658 git checkout 91b04e9599495806c46c36ba275df4e653a6f112
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross ARCH=microblaze
If you fix the issue, kindly add following tag as appropriate
All errors (new ones prefixed by >>):
microblaze-linux-ld: kernel/bpf/btf.o: in function `btf_float_check_member':
>> (.text+0x3bdc): undefined reference to `__umoddi3'
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
Re: [PATCH v3 bpf-next 4/6] bpf: Add BTF_KIND_FLOAT support
In reply to Ilya LeoshkevichQuoted 15 lines · Ilya Leoshkevich
On the kernel side, introduce a new
btf_kind_operations. It is similar to that ofBTF_KIND_INT, however, it does not need to handle encodings and bit offsets. Do not implement printing, since the kernel does not know how to format floating-point values.Signed-off-by Ilya Leoshkevich <[email protected]>---
kernel/bpf/btf.c | 77
++++++++++++++++++++++++++++++++++++++++++++++--1 file changed, 75 insertions(+), 2 deletions(-)kernel/bpf/btf.c +0
-0
[...]
kernel/bpf/btf.c static const struct btf_kind_operations datasec_ops = { · line 3718
Quoted 13 lines
kernel/bpf/btf.c +13
-0+static int btf_float_check_member (struct btf_verifier_env *env, + const struct btf_type *struct_type, + const struct btf_member *member, + const struct btf_type *member_type) +{ + u64 start_offset_bytes; + u64 end_offset_bytes; + u64 align_bytes; + u64 align_bits; + + align_bytes = min_t(u64, sizeof(void *), member_type->size); + align_bits = align_bytes * BITS_PER_BYTE; + if (member->offset % align_bits) {
The kernel test robot's link error is most likely due to this line. I should be using do_div here.
[...]
PATCH v3 5/6 selftest/bpf: Add BTF_KIND_FLOAT tests
In reply to Ilya LeoshkevichTest the good variants as well as the potential malformed ones.
--- tools/testing/selftests/bpf/btf_helpers.c | 4 + tools/testing/selftests/bpf/prog_tests/btf.c | 129 +++++++++++++++++++ tools/testing/selftests/bpf/test_btf.h | 3 + 3 files changed, 136 insertions(+)
tools/testing/selftests/bpf/btf_helpers.c +4 -0
@@ -23,6 +23,7 @@ static const char * const btf_kind_str_mapping[] = { [BTF_KIND_FUNC_PROTO] = "FUNC_PROTO", [BTF_KIND_VAR] = "VAR", [BTF_KIND_DATASEC] = "DATASEC", + [BTF_KIND_FLOAT] = "FLOAT", };static const char *btf_kind_str (__u16 kind)
@@ -173,6 +174,9 @@ int fprintf_btf_type_raw(FILE *out, const struct btf *btf, __u32 id) }break ; } +case BTF_KIND_FLOAT : +fprintf (out," size=%u" , t->size); +break ;default :break ; }
tools/testing/selftests/bpf/prog_tests/btf.c +129 -0
141 lines not on this page · raw message
tools/testing/selftests/bpf/test_btf.h +3 -0
@@ -66,4 +66,7 @@#define BTF_FUNC_ENC (name, func_proto) \ BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_FUNC, 0, 0), func_proto) +#define BTF_TYPE_FLOAT_ENC (name, sz) \ + BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_FLOAT, 0, 0), sz) +#endif /* _TEST_BTF_H */
Signature · 1 line
2.29.2
Re: [PATCH v3 bpf-next 5/6] selftest/bpf: Add BTF_KIND_FLOAT tests
Quoted 3 lines · Ilya Leoshkevich
Test the good variants as well as the potential malformed ones.
Signed-off-by Ilya Leoshkevich <[email protected]>
Thanks for the detailed tests!
PATCH v3 6/6 bpf: Document BTF_KIND_FLOAT in btf.rst
In reply to Ilya LeoshkevichAlso document the expansion of the kind bitfield.
--- Documentation/bpf/btf.rst | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-)
Documentation/bpf/btf.rst +15 -2
@@ -84,6 +84,7 @@ sequentially and type id is assigned to each recognized type starting from id #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 */ 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.
@@ -95,8 +96,8 @@ Each type contains the following common data:: /* "info" bits arrangement * bits 0-15: vlen (e.g. # of struct's members) * bits 16-23: unused - * bits 24-27: kind (e.g. int, ptr, array...etc) - * bits 28-30: unused + * bits 24-28: kind (e.g. int, ptr, array...etc) + * bits 29-30: unused * bit 31: kind_flag, currently used by * struct, union and fwd */
@@ -452,6 +453,18 @@ map definition. * ``offset``: the in-section offset of the variable * ``size``: the size of the variable in bytes +2.2.16 BTF_KIND_FLOAT +~~~~~~~~~~~~~~~~~~~~~ + +``struct btf_type`` encoding requirement: + * ``name_off``: any valid offset + * ``info.kind_flag``: 0 + * ``info.kind``: BTF_KIND_FLOAT + * ``info.vlen``: 0 + * ``size``: the size of the float type in bytes: 2, 4, 8, 12 or 16. + +No additional type data follow ``btf_type``. + 3. BTF Kernel API *****************
Signature · 1 line
2.29.2
Re: [PATCH v3 bpf-next 6/6] bpf: Document BTF_KIND_FLOAT in btf.rst
Quoted 3 lines · Ilya Leoshkevich
Also document the expansion of the kind bitfield.
Signed-off-by Ilya Leoshkevich <[email protected]>