Skip to contentSkip to conversation

Add BTF_KIND_FLOAT support

PATCH Superseded Ilya Leoshkevich 3 participants 15 messages Feb 20, 2021 – Feb 22, 2021

Subsystems (6)

v3 of 7 Superseded Latest is v7 →

lore
Share & tools
lore
#0 lore raw

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
#1 lore raw

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
index 5a667107ad2c..d27b1708efe9 100644
@@ -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
index 5a667107ad2c..d27b1708efe9 100644
@@ -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
#3 lore raw

PATCH v3 2/6 libbpf: Add BTF_KIND_FLOAT support

In reply to Ilya Leoshkevich

The 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
index fdfff544f59a..1ebfcc687dab 100644
@@ -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
index 1237bcd1dd17..c3b11bcebeda 100644
@@ -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
index 2f9d685bd522..5e957fcceee6 100644
@@ -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
index 1c0fd2dd233a..ec898f464ab9 100644
@@ -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
index 969d0ac592ba..343f6eb05637 100644
@@ -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
#4 lore raw

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_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 +4 -0
index fdfff544f59a..1ebfcc687dab 100644
@@ -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
index d43cc3f29dae..b79a6a2e6faa 100644
@@ -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_id
  		skip_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
index 1c0fd2dd233a..ec898f464ab9 100644
@@ -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
index 969d0ac592ba..343f6eb05637 100644
@@ -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)
#5 lore raw

PATCH v3 3/6 tools/bpftool: Add BTF_KIND_FLOAT support

In reply to Ilya Leoshkevich

Only 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
index fe9e7b3a4b50..985610c3f193 100644
@@ -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
index 0e9310727281..7ca54d046362 100644
@@ -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
#6 lore raw

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
  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
index fe9e7b3a4b50..985610c3f193 100644
@@ -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
index 0e9310727281..7ca54d046362 100644
@@ -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:
#7 lore raw

PATCH v3 4/6 bpf: Add BTF_KIND_FLOAT support

In reply to Ilya Leoshkevich

On 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
index 2efeb5f4b343..813c2bfe284f 100644
@@ -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
#8 lore raw

Re: [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

#9 lore raw

Re: [PATCH v3 bpf-next 4/6] bpf: Add BTF_KIND_FLOAT support

In reply to Ilya Leoshkevich
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: 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

#10 lore raw

Re: [PATCH v3 bpf-next 4/6] bpf: Add BTF_KIND_FLOAT support

In reply to Ilya Leoshkevich
Quoted 15 lines · Ilya Leoshkevich

On 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 +0 -0
index 2efeb5f4b343..813c2bfe284f 100644

[...]

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.

[...]

#11 lore raw

PATCH v3 5/6 selftest/bpf: Add BTF_KIND_FLOAT tests

In reply to Ilya Leoshkevich

Test 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
index 48f90490f922..b692e6ead9b5 100644
@@ -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
index 2023725f1962..e2394eea4b7f 100644
@@ -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
#13 lore raw

PATCH v3 6/6 bpf: Document BTF_KIND_FLOAT in btf.rst

In reply to Ilya Leoshkevich

Also 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
index 44dc789de2b4..846354cd2d69 100644
@@ -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