BPF Archive on lore.kernel.org
 help / color / Atom feed
* [PATCH v4 bpf-next 0/7] Add BTF_KIND_FLOAT support
@ 2021-02-22 21:49 Ilya Leoshkevich
  2021-02-22 21:49 ` [PATCH v4 bpf-next 1/7] bpf: Add BTF_KIND_FLOAT to uapi Ilya Leoshkevich
                   ` (6 more replies)
  0 siblings, 7 replies; 14+ messages in thread
From: Ilya Leoshkevich @ 2021-02-22 21:49 UTC (permalink / raw)
  To: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Yonghong Song, Arnaldo Carvalho de Melo, John Fastabend
  Cc: bpf, Heiko Carstens, Vasily Gorbik, Ilya Leoshkevich

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/20210210030317.78820-1-iii@linux.ibm.com/
v0 -> v1: Per Andrii's suggestion, remove the unnecessary trailing u32.

v1: https://lore.kernel.org/bpf/20210216011216.3168-1-iii@linux.ibm.com/
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/20210219022543.20893-1-iii@linux.ibm.com/
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).

v3: https://lore.kernel.org/bpf/20210220034959.27006-1-iii@linux.ibm.com/
v3 -> v4: More fixes for the Yonghong's findings: fix the outdated
          comment in bpf_object__sanitize_btf() and add the error
          handling there (I've decided to check uint_id and uchar_id
          too in order to simplify debugging); add bpftool output
          example; use div64_u64_rem() instead of % in order to fix the
          linker error.
          Also fix the "invalid BTF_INFO" test (new commit, #4).

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 (7):
  bpf: Add BTF_KIND_FLOAT to uapi
  libbpf: Add BTF_KIND_FLOAT support
  tools/bpftool: Add BTF_KIND_FLOAT support
  selftests/bpf: Use 25th bit in "invalid BTF_INFO" test
  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                             |  79 ++++++++++-
 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                       |  84 +++++++++++-
 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 | 131 ++++++++++++++++++-
 tools/testing/selftests/bpf/test_btf.h       |   3 +
 15 files changed, 386 insertions(+), 14 deletions(-)

-- 
2.29.2


^ permalink raw reply	[flat|nested] 14+ messages in thread

* [PATCH v4 bpf-next 1/7] bpf: Add BTF_KIND_FLOAT to uapi
  2021-02-22 21:49 [PATCH v4 bpf-next 0/7] Add BTF_KIND_FLOAT support Ilya Leoshkevich
@ 2021-02-22 21:49 ` Ilya Leoshkevich
  2021-02-22 21:49 ` [PATCH v4 bpf-next 2/7] libbpf: Add BTF_KIND_FLOAT support Ilya Leoshkevich
                   ` (5 subsequent siblings)
  6 siblings, 0 replies; 14+ messages in thread
From: Ilya Leoshkevich @ 2021-02-22 21:49 UTC (permalink / raw)
  To: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Yonghong Song, Arnaldo Carvalho de Melo, John Fastabend
  Cc: bpf, Heiko Carstens, Vasily Gorbik, Ilya Leoshkevich

Add a new kind value and expand the kind bitfield.

Signed-off-by: Ilya Leoshkevich <iii@linux.ibm.com>
Acked-by: Yonghong Song <yhs@fb.com>
---
 include/uapi/linux/btf.h       | 5 +++--
 tools/include/uapi/linux/btf.h | 5 +++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/include/uapi/linux/btf.h b/include/uapi/linux/btf.h
index 5a667107ad2c..d27b1708efe9 100644
--- a/include/uapi/linux/btf.h
+++ b/include/uapi/linux/btf.h
@@ -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
diff --git a/tools/include/uapi/linux/btf.h b/tools/include/uapi/linux/btf.h
index 5a667107ad2c..d27b1708efe9 100644
--- a/tools/include/uapi/linux/btf.h
+++ b/tools/include/uapi/linux/btf.h
@@ -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
-- 
2.29.2


^ permalink raw reply	[flat|nested] 14+ messages in thread

* [PATCH v4 bpf-next 2/7] libbpf: Add BTF_KIND_FLOAT support
  2021-02-22 21:49 [PATCH v4 bpf-next 0/7] Add BTF_KIND_FLOAT support Ilya Leoshkevich
  2021-02-22 21:49 ` [PATCH v4 bpf-next 1/7] bpf: Add BTF_KIND_FLOAT to uapi Ilya Leoshkevich
@ 2021-02-22 21:49 ` Ilya Leoshkevich
  2021-02-23  7:03   ` Andrii Nakryiko
  2021-02-22 21:49 ` [PATCH v4 bpf-next 3/7] tools/bpftool: " Ilya Leoshkevich
                   ` (4 subsequent siblings)
  6 siblings, 1 reply; 14+ messages in thread
From: Ilya Leoshkevich @ 2021-02-22 21:49 UTC (permalink / raw)
  To: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Yonghong Song, Arnaldo Carvalho de Melo, John Fastabend
  Cc: bpf, Heiko Carstens, Vasily Gorbik, 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, for example, the
following:

    [4] FLOAT 'float' size=4

becomes the following:

    [4] CONST '(anon)' type_id=10
    ...
    [8] INT 'unsigned int' size=4 bits_offset=0 nr_bits=32 encoding=(none)
    [9] INT 'unsigned char' size=1 bits_offset=0 nr_bits=8 encoding=(none)
    [10] ARRAY '(anon)' type_id=9 index_type_id=8 nr_elems=4

Signed-off-by: Ilya Leoshkevich <iii@linux.ibm.com>
---
 tools/lib/bpf/btf.c             | 44 +++++++++++++++++
 tools/lib/bpf/btf.h             |  8 ++++
 tools/lib/bpf/btf_dump.c        |  4 ++
 tools/lib/bpf/libbpf.c          | 84 +++++++++++++++++++++++++++++++--
 tools/lib/bpf/libbpf.map        |  5 ++
 tools/lib/bpf/libbpf_internal.h |  2 +
 6 files changed, 142 insertions(+), 5 deletions(-)

diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c
index fdfff544f59a..1ebfcc687dab 100644
--- a/tools/lib/bpf/btf.c
+++ b/tools/lib/bpf/btf.c
@@ -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:
diff --git a/tools/lib/bpf/btf.h b/tools/lib/bpf/btf.h
index 1237bcd1dd17..c3b11bcebeda 100644
--- a/tools/lib/bpf/btf.h
+++ b/tools/lib/bpf/btf.h
@@ -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));
diff --git a/tools/lib/bpf/btf_dump.c b/tools/lib/bpf/btf_dump.c
index 2f9d685bd522..5e957fcceee6 100644
--- a/tools/lib/bpf/btf_dump.c
+++ b/tools/lib/bpf/btf_dump.c
@@ -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);
diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index d43cc3f29dae..45682820a6e8 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -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,37 @@ 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)
+static int btf_ensure_int(struct btf *btf, int *id, const char *name,
+			  size_t byte_sz, int encoding)
+{
+	if (*id)
+		return 0;
+
+	*id = btf__add_int(btf, name, byte_sz, encoding);
+	if (*id < 0) {
+		pr_warn("Error adding %s BTF type: %d.\n", name, *id);
+		return *id;
+	}
+
+	return 0;
+}
+
+static int 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);
+	int err, i, j, vlen;
 	struct btf_type *t;
-	int i, j, vlen;
+	int uchar_id = 0;
+	int uint_id = 0;
 
 	for (i = 1; i <= btf__get_nr_types(btf); i++) {
 		t = (struct btf_type *)btf__type_by_id(btf, i);
@@ -2445,8 +2467,35 @@ 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 CONST(u8[]) */
+			int array_id;
+			__u32 size;
+
+			size = t->size;
+			err = btf_ensure_int(btf, &uint_id, "unsigned int", 4, 0);
+			if (err)
+				return err;
+			err = btf_ensure_int(btf, &uchar_id, "unsigned char", 1, 0);
+			if (err)
+				return err;
+			array_id = btf__add_array(btf, uint_id, uchar_id, size);
+			if (array_id < 0) {
+				pr_warn("Error adding unsigned char[%" PRIu32 "] BTF type: %d.\n",
+					t->size, array_id);
+				return array_id;
+			}
+
+			/* 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 = array_id;
 		}
 	}
+
+	return 0;
 }
 
 static bool libbpf_needs_btf(const struct bpf_object *obj)
@@ -2585,6 +2634,7 @@ static int bpf_object__load_vmlinux_btf(struct bpf_object *obj, bool force)
 
 static int bpf_object__sanitize_and_load_btf(struct bpf_object *obj)
 {
+	const char *action = "loading .BTF into kernel";
 	struct btf *kern_btf = obj->btf;
 	bool btf_mandatory, sanitize;
 	int err = 0;
@@ -2614,7 +2664,12 @@ static int bpf_object__sanitize_and_load_btf(struct bpf_object *obj)
 
 		/* enforce 8-byte pointers for BPF-targeted BTFs */
 		btf__set_pointer_size(obj->btf, 8);
-		bpf_object__sanitize_btf(obj, kern_btf);
+		err = bpf_object__sanitize_btf(obj, kern_btf);
+		if (err) {
+			btf__free(kern_btf);
+			action = "sanitizing .BTF";
+			goto report;
+		}
 	}
 
 	err = btf__load(kern_btf);
@@ -2629,7 +2684,7 @@ static int bpf_object__sanitize_and_load_btf(struct bpf_object *obj)
 report:
 	if (err) {
 		btf_mandatory = kernel_needs_btf(obj);
-		pr_warn("Error loading .BTF into kernel: %d. %s\n", err,
+		pr_warn("Error %s: %d. %s\n", action, err,
 			btf_mandatory ? "BTF is mandatory, can't proceed."
 				      : "BTF is optional, ignoring.");
 		if (!btf_mandatory)
@@ -3882,6 +3937,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 +4128,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 +5010,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 +5194,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);
diff --git a/tools/lib/bpf/libbpf.map b/tools/lib/bpf/libbpf.map
index 1c0fd2dd233a..ec898f464ab9 100644
--- a/tools/lib/bpf/libbpf.map
+++ b/tools/lib/bpf/libbpf.map
@@ -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;
diff --git a/tools/lib/bpf/libbpf_internal.h b/tools/lib/bpf/libbpf_internal.h
index 969d0ac592ba..343f6eb05637 100644
--- a/tools/lib/bpf/libbpf_internal.h
+++ b/tools/lib/bpf/libbpf_internal.h
@@ -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)
-- 
2.29.2


^ permalink raw reply	[flat|nested] 14+ messages in thread

* [PATCH v4 bpf-next 3/7] tools/bpftool: Add BTF_KIND_FLOAT support
  2021-02-22 21:49 [PATCH v4 bpf-next 0/7] Add BTF_KIND_FLOAT support Ilya Leoshkevich
  2021-02-22 21:49 ` [PATCH v4 bpf-next 1/7] bpf: Add BTF_KIND_FLOAT to uapi Ilya Leoshkevich
  2021-02-22 21:49 ` [PATCH v4 bpf-next 2/7] libbpf: Add BTF_KIND_FLOAT support Ilya Leoshkevich
@ 2021-02-22 21:49 ` Ilya Leoshkevich
  2021-02-22 21:49 ` [PATCH v4 bpf-next 4/7] selftests/bpf: Use 25th bit in "invalid BTF_INFO" test Ilya Leoshkevich
                   ` (3 subsequent siblings)
  6 siblings, 0 replies; 14+ messages in thread
From: Ilya Leoshkevich @ 2021-02-22 21:49 UTC (permalink / raw)
  To: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Yonghong Song, Arnaldo Carvalho de Melo, John Fastabend
  Cc: bpf, Heiko Carstens, Vasily Gorbik, Ilya Leoshkevich

Only dumping support needs to be adjusted, the code structure follows
that of BTF_KIND_INT. Example plain and JSON outputs:

    [4] FLOAT 'float' size=4
    {"id":4,"kind":"FLOAT","name":"float","size":4}

Signed-off-by: Ilya Leoshkevich <iii@linux.ibm.com>
---
 tools/bpf/bpftool/btf.c        | 8 ++++++++
 tools/bpf/bpftool/btf_dumper.c | 1 +
 2 files changed, 9 insertions(+)

diff --git a/tools/bpf/bpftool/btf.c b/tools/bpf/bpftool/btf.c
index fe9e7b3a4b50..985610c3f193 100644
--- a/tools/bpf/bpftool/btf.c
+++ b/tools/bpf/bpftool/btf.c
@@ -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;
 	}
diff --git a/tools/bpf/bpftool/btf_dumper.c b/tools/bpf/bpftool/btf_dumper.c
index 0e9310727281..7ca54d046362 100644
--- a/tools/bpf/bpftool/btf_dumper.c
+++ b/tools/bpf/bpftool/btf_dumper.c
@@ -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:
-- 
2.29.2


^ permalink raw reply	[flat|nested] 14+ messages in thread

* [PATCH v4 bpf-next 4/7] selftests/bpf: Use 25th bit in "invalid BTF_INFO" test
  2021-02-22 21:49 [PATCH v4 bpf-next 0/7] Add BTF_KIND_FLOAT support Ilya Leoshkevich
                   ` (2 preceding siblings ...)
  2021-02-22 21:49 ` [PATCH v4 bpf-next 3/7] tools/bpftool: " Ilya Leoshkevich
@ 2021-02-22 21:49 ` Ilya Leoshkevich
  2021-02-22 21:49 ` [PATCH v4 bpf-next 5/7] bpf: Add BTF_KIND_FLOAT support Ilya Leoshkevich
                   ` (2 subsequent siblings)
  6 siblings, 0 replies; 14+ messages in thread
From: Ilya Leoshkevich @ 2021-02-22 21:49 UTC (permalink / raw)
  To: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Yonghong Song, Arnaldo Carvalho de Melo, John Fastabend
  Cc: bpf, Heiko Carstens, Vasily Gorbik, Ilya Leoshkevich

The bit being checked by this test is no longer reserved after
introducing BTF_KIND_FLOAT, use the next one instead.

Signed-off-by: Ilya Leoshkevich <iii@linux.ibm.com>
---
 tools/testing/selftests/bpf/prog_tests/btf.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/testing/selftests/bpf/prog_tests/btf.c b/tools/testing/selftests/bpf/prog_tests/btf.c
index 6a7ee7420701..c29406736138 100644
--- a/tools/testing/selftests/bpf/prog_tests/btf.c
+++ b/tools/testing/selftests/bpf/prog_tests/btf.c
@@ -1903,7 +1903,7 @@ static struct btf_raw_test raw_tests[] = {
 	.raw_types = {
 		/* int */				/* [1] */
 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
-		BTF_TYPE_ENC(0, 0x10000000, 4),
+		BTF_TYPE_ENC(0, 0x20000000, 4),
 		BTF_END_RAW,
 	},
 	.str_sec = "",
-- 
2.29.2


^ permalink raw reply	[flat|nested] 14+ messages in thread

* [PATCH v4 bpf-next 5/7] bpf: Add BTF_KIND_FLOAT support
  2021-02-22 21:49 [PATCH v4 bpf-next 0/7] Add BTF_KIND_FLOAT support Ilya Leoshkevich
                   ` (3 preceding siblings ...)
  2021-02-22 21:49 ` [PATCH v4 bpf-next 4/7] selftests/bpf: Use 25th bit in "invalid BTF_INFO" test Ilya Leoshkevich
@ 2021-02-22 21:49 ` Ilya Leoshkevich
  2021-02-22 21:49 ` [PATCH v4 bpf-next 6/7] selftest/bpf: Add BTF_KIND_FLOAT tests Ilya Leoshkevich
  2021-02-22 21:49 ` [PATCH v4 bpf-next 7/7] bpf: Document BTF_KIND_FLOAT in btf.rst Ilya Leoshkevich
  6 siblings, 0 replies; 14+ messages in thread
From: Ilya Leoshkevich @ 2021-02-22 21:49 UTC (permalink / raw)
  To: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Yonghong Song, Arnaldo Carvalho de Melo, John Fastabend
  Cc: bpf, Heiko Carstens, Vasily Gorbik, 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.

Signed-off-by: Ilya Leoshkevich <iii@linux.ibm.com>
---
 kernel/bpf/btf.c | 79 ++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 77 insertions(+), 2 deletions(-)

diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c
index 2efeb5f4b343..c405edc8e615 100644
--- a/kernel/bpf/btf.c
+++ b/kernel/bpf/btf.c
@@ -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,77 @@ 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 misalign_bits;
+	u64 align_bytes;
+	u64 align_bits;
+
+	align_bytes = min_t(u64, sizeof(void *), member_type->size);
+	align_bits = align_bytes * BITS_PER_BYTE;
+	div64_u64_rem(member->offset, align_bits, &misalign_bits);
+	if (misalign_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 +3882,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,
-- 
2.29.2


^ permalink raw reply	[flat|nested] 14+ messages in thread

* [PATCH v4 bpf-next 6/7] selftest/bpf: Add BTF_KIND_FLOAT tests
  2021-02-22 21:49 [PATCH v4 bpf-next 0/7] Add BTF_KIND_FLOAT support Ilya Leoshkevich
                   ` (4 preceding siblings ...)
  2021-02-22 21:49 ` [PATCH v4 bpf-next 5/7] bpf: Add BTF_KIND_FLOAT support Ilya Leoshkevich
@ 2021-02-22 21:49 ` Ilya Leoshkevich
  2021-02-23  7:11   ` Andrii Nakryiko
  2021-02-22 21:49 ` [PATCH v4 bpf-next 7/7] bpf: Document BTF_KIND_FLOAT in btf.rst Ilya Leoshkevich
  6 siblings, 1 reply; 14+ messages in thread
From: Ilya Leoshkevich @ 2021-02-22 21:49 UTC (permalink / raw)
  To: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Yonghong Song, Arnaldo Carvalho de Melo, John Fastabend
  Cc: bpf, Heiko Carstens, Vasily Gorbik, Ilya Leoshkevich

Test the good variants as well as the potential malformed ones.

Signed-off-by: Ilya Leoshkevich <iii@linux.ibm.com>
Acked-by: Yonghong Song <yhs@fb.com>
---
 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(+)

diff --git a/tools/testing/selftests/bpf/btf_helpers.c b/tools/testing/selftests/bpf/btf_helpers.c
index 48f90490f922..b692e6ead9b5 100644
--- a/tools/testing/selftests/bpf/btf_helpers.c
+++ b/tools/testing/selftests/bpf/btf_helpers.c
@@ -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;
 	}
diff --git a/tools/testing/selftests/bpf/prog_tests/btf.c b/tools/testing/selftests/bpf/prog_tests/btf.c
index c29406736138..3a8ceb8db20f 100644
--- a/tools/testing/selftests/bpf/prog_tests/btf.c
+++ b/tools/testing/selftests/bpf/prog_tests/btf.c
@@ -3531,6 +3531,134 @@ static struct btf_raw_test raw_tests[] = {
 	.max_entries = 1,
 },
 
+{
+	.descr = "float test #1, well-formed",
+	.raw_types = {
+		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
+								/* [1] */
+		BTF_TYPE_FLOAT_ENC(NAME_TBD, 2),		/* [2] */
+		BTF_TYPE_FLOAT_ENC(NAME_TBD, 4),		/* [3] */
+		BTF_TYPE_FLOAT_ENC(NAME_TBD, 8),		/* [4] */
+		BTF_TYPE_FLOAT_ENC(NAME_TBD, 16),		/* [5] */
+		BTF_STRUCT_ENC(NAME_TBD, 4, 32),		/* [6] */
+		BTF_MEMBER_ENC(NAME_TBD, 2, 0),
+		BTF_MEMBER_ENC(NAME_TBD, 3, 32),
+		BTF_MEMBER_ENC(NAME_TBD, 4, 64),
+		BTF_MEMBER_ENC(NAME_TBD, 5, 128),
+		BTF_END_RAW,
+	},
+	BTF_STR_SEC("\0int\0_Float16\0float\0double\0long_double\0floats"
+		    "\0x\0y\0z\0_"),
+	.map_type = BPF_MAP_TYPE_ARRAY,
+	.map_name = "float_type_check_btf",
+	.key_size = sizeof(int),
+	.value_size = 32,
+	.key_type_id = 1,
+	.value_type_id = 6,
+	.max_entries = 1,
+},
+{
+	.descr = "float test #2, invalid vlen",
+	.raw_types = {
+		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
+								/* [1] */
+		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_FLOAT, 0, 1), 4),
+								/* [2] */
+		BTF_END_RAW,
+	},
+	BTF_STR_SEC("\0int\0float"),
+	.map_type = BPF_MAP_TYPE_ARRAY,
+	.map_name = "float_type_check_btf",
+	.key_size = sizeof(int),
+	.value_size = 4,
+	.key_type_id = 1,
+	.value_type_id = 2,
+	.max_entries = 1,
+	.btf_load_err = true,
+	.err_str = "vlen != 0",
+},
+{
+	.descr = "float test #3, invalid kind_flag",
+	.raw_types = {
+		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
+								/* [1] */
+		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_FLOAT, 1, 0), 4),
+								/* [2] */
+		BTF_END_RAW,
+	},
+	BTF_STR_SEC("\0int\0float"),
+	.map_type = BPF_MAP_TYPE_ARRAY,
+	.map_name = "float_type_check_btf",
+	.key_size = sizeof(int),
+	.value_size = 4,
+	.key_type_id = 1,
+	.value_type_id = 2,
+	.max_entries = 1,
+	.btf_load_err = true,
+	.err_str = "Invalid btf_info kind_flag",
+},
+{
+	.descr = "float test #4, member does not fit",
+	.raw_types = {
+		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
+								/* [1] */
+		BTF_TYPE_FLOAT_ENC(NAME_TBD, 4),		/* [2] */
+		BTF_STRUCT_ENC(NAME_TBD, 1, 2),			/* [3] */
+		BTF_MEMBER_ENC(NAME_TBD, 2, 0),
+		BTF_END_RAW,
+	},
+	BTF_STR_SEC("\0int\0float\0floats\0x"),
+	.map_type = BPF_MAP_TYPE_ARRAY,
+	.map_name = "float_type_check_btf",
+	.key_size = sizeof(int),
+	.value_size = 4,
+	.key_type_id = 1,
+	.value_type_id = 3,
+	.max_entries = 1,
+	.btf_load_err = true,
+	.err_str = "Member exceeds struct_size",
+},
+{
+	.descr = "float test #5, member is not properly aligned",
+	.raw_types = {
+		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
+								/* [1] */
+		BTF_TYPE_FLOAT_ENC(NAME_TBD, 4),		/* [2] */
+		BTF_STRUCT_ENC(NAME_TBD, 1, 8),			/* [3] */
+		BTF_MEMBER_ENC(NAME_TBD, 2, 8),
+		BTF_END_RAW,
+	},
+	BTF_STR_SEC("\0int\0float\0floats\0x"),
+	.map_type = BPF_MAP_TYPE_ARRAY,
+	.map_name = "float_type_check_btf",
+	.key_size = sizeof(int),
+	.value_size = 4,
+	.key_type_id = 1,
+	.value_type_id = 3,
+	.max_entries = 1,
+	.btf_load_err = true,
+	.err_str = "Member is not properly aligned",
+},
+{
+	.descr = "float test #6, invalid size",
+	.raw_types = {
+		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
+								/* [1] */
+		BTF_TYPE_FLOAT_ENC(NAME_TBD, 6),		/* [2] */
+		BTF_END_RAW,
+	},
+	BTF_STR_SEC("\0int\0float"),
+	.map_type = BPF_MAP_TYPE_ARRAY,
+	.map_name = "float_type_check_btf",
+	.key_size = sizeof(int),
+	.value_size = 6,
+	.key_type_id = 1,
+	.value_type_id = 2,
+	.max_entries = 1,
+	.btf_load_err = true,
+	.err_str = "Invalid type_size",
+},
+
 }; /* struct btf_raw_test raw_tests[] */
 
 static const char *get_next_str(const char *start, const char *end)
@@ -6630,6 +6758,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);
diff --git a/tools/testing/selftests/bpf/test_btf.h b/tools/testing/selftests/bpf/test_btf.h
index 2023725f1962..e2394eea4b7f 100644
--- a/tools/testing/selftests/bpf/test_btf.h
+++ b/tools/testing/selftests/bpf/test_btf.h
@@ -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 */
-- 
2.29.2


^ permalink raw reply	[flat|nested] 14+ messages in thread

* [PATCH v4 bpf-next 7/7] bpf: Document BTF_KIND_FLOAT in btf.rst
  2021-02-22 21:49 [PATCH v4 bpf-next 0/7] Add BTF_KIND_FLOAT support Ilya Leoshkevich
                   ` (5 preceding siblings ...)
  2021-02-22 21:49 ` [PATCH v4 bpf-next 6/7] selftest/bpf: Add BTF_KIND_FLOAT tests Ilya Leoshkevich
@ 2021-02-22 21:49 ` Ilya Leoshkevich
  6 siblings, 0 replies; 14+ messages in thread
From: Ilya Leoshkevich @ 2021-02-22 21:49 UTC (permalink / raw)
  To: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Yonghong Song, Arnaldo Carvalho de Melo, John Fastabend
  Cc: bpf, Heiko Carstens, Vasily Gorbik, Ilya Leoshkevich

Also document the expansion of the kind bitfield.

Signed-off-by: Ilya Leoshkevich <iii@linux.ibm.com>
Acked-by: Yonghong Song <yhs@fb.com>
---
 Documentation/bpf/btf.rst | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/Documentation/bpf/btf.rst b/Documentation/bpf/btf.rst
index 44dc789de2b4..846354cd2d69 100644
--- a/Documentation/bpf/btf.rst
+++ b/Documentation/bpf/btf.rst
@@ -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
 *****************
 
-- 
2.29.2


^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH v4 bpf-next 2/7] libbpf: Add BTF_KIND_FLOAT support
  2021-02-22 21:49 ` [PATCH v4 bpf-next 2/7] libbpf: Add BTF_KIND_FLOAT support Ilya Leoshkevich
@ 2021-02-23  7:03   ` Andrii Nakryiko
  2021-02-23  7:08     ` Andrii Nakryiko
  2021-02-23 20:14     ` Ilya Leoshkevich
  0 siblings, 2 replies; 14+ messages in thread
From: Andrii Nakryiko @ 2021-02-23  7:03 UTC (permalink / raw)
  To: Ilya Leoshkevich
  Cc: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Yonghong Song, Arnaldo Carvalho de Melo, John Fastabend, bpf,
	Heiko Carstens, Vasily Gorbik

On Mon, Feb 22, 2021 at 1:50 PM Ilya Leoshkevich <iii@linux.ibm.com> wrote:
>
> 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, for example, the
> following:
>
>     [4] FLOAT 'float' size=4
>
> becomes the following:
>
>     [4] CONST '(anon)' type_id=10
>     ...
>     [8] INT 'unsigned int' size=4 bits_offset=0 nr_bits=32 encoding=(none)
>     [9] INT 'unsigned char' size=1 bits_offset=0 nr_bits=8 encoding=(none)
>     [10] ARRAY '(anon)' type_id=9 index_type_id=8 nr_elems=4
>

I liked Yonghong's initial suggestion to replace it with PTR to VOID.
The only concern was that if this type was used from VAR, then
sizeof(void *) != sizeof(float) on 64-bit architectures, which might
theoretically mess up DATASEC layout. But is this a real concern? BPF
programs don't really support floats, so there is no point in
declaring float variables. I'd rather stick to a simple FLOAT -> PTR
substitution than extend generated BTF.

Alternatively, was FLOAT -> anonymous empty STRUCT with desired size
considered? Any problems with that?

> Signed-off-by: Ilya Leoshkevich <iii@linux.ibm.com>
> ---
>  tools/lib/bpf/btf.c             | 44 +++++++++++++++++
>  tools/lib/bpf/btf.h             |  8 ++++
>  tools/lib/bpf/btf_dump.c        |  4 ++
>  tools/lib/bpf/libbpf.c          | 84 +++++++++++++++++++++++++++++++--
>  tools/lib/bpf/libbpf.map        |  5 ++
>  tools/lib/bpf/libbpf_internal.h |  2 +
>  6 files changed, 142 insertions(+), 5 deletions(-)
>
> diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c
> index fdfff544f59a..1ebfcc687dab 100644
> --- a/tools/lib/bpf/btf.c
> +++ b/tools/lib/bpf/btf.c
> @@ -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);

well this won't work for 12-byte floats, would it?

>         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;
> +

check byte_sz here?


> +       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:
> diff --git a/tools/lib/bpf/btf.h b/tools/lib/bpf/btf.h
> index 1237bcd1dd17..c3b11bcebeda 100644
> --- a/tools/lib/bpf/btf.h
> +++ b/tools/lib/bpf/btf.h
> @@ -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);

nit: can you please put it right after btf__add_int() and drop the comment?

> +
>  struct btf_dedup_opts {
>         unsigned int dedup_table_size;
>         bool dont_resolve_fwds;

[...]

>  static bool kernel_supports(enum kern_feature_id feat_id)
> @@ -4940,6 +5010,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;

we don't enforce this for INTs, so maybe let's not do this for FLOATs as well?

But really, FLOAT is not supported by BPF programs, so we should
probably just error out on FLOAT relo.

>         default:
>                 pr_warn("unexpected kind %d relocated, local [%d], target [%d]\n",
>                         btf_kind(local_type), local_id, targ_id);
> @@ -5122,6 +5194,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;

ditto


>         default:
>                 pr_warn("unexpected kind %s relocated, local [%d], target [%d]\n",
>                         btf_kind_str(local_type), local_id, targ_id);

[...]

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH v4 bpf-next 2/7] libbpf: Add BTF_KIND_FLOAT support
  2021-02-23  7:03   ` Andrii Nakryiko
@ 2021-02-23  7:08     ` Andrii Nakryiko
  2021-02-23 20:14     ` Ilya Leoshkevich
  1 sibling, 0 replies; 14+ messages in thread
From: Andrii Nakryiko @ 2021-02-23  7:08 UTC (permalink / raw)
  To: Ilya Leoshkevich
  Cc: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Yonghong Song, Arnaldo Carvalho de Melo, John Fastabend, bpf,
	Heiko Carstens, Vasily Gorbik

On Mon, Feb 22, 2021 at 11:03 PM Andrii Nakryiko
<andrii.nakryiko@gmail.com> wrote:
>
> On Mon, Feb 22, 2021 at 1:50 PM Ilya Leoshkevich <iii@linux.ibm.com> wrote:
> >
> > 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, for example, the
> > following:
> >
> >     [4] FLOAT 'float' size=4
> >
> > becomes the following:
> >
> >     [4] CONST '(anon)' type_id=10
> >     ...
> >     [8] INT 'unsigned int' size=4 bits_offset=0 nr_bits=32 encoding=(none)
> >     [9] INT 'unsigned char' size=1 bits_offset=0 nr_bits=8 encoding=(none)
> >     [10] ARRAY '(anon)' type_id=9 index_type_id=8 nr_elems=4
> >
>
> I liked Yonghong's initial suggestion to replace it with PTR to VOID.
> The only concern was that if this type was used from VAR, then
> sizeof(void *) != sizeof(float) on 64-bit architectures, which might
> theoretically mess up DATASEC layout. But is this a real concern? BPF
> programs don't really support floats, so there is no point in
> declaring float variables. I'd rather stick to a simple FLOAT -> PTR
> substitution than extend generated BTF.
>
> Alternatively, was FLOAT -> anonymous empty STRUCT with desired size
> considered? Any problems with that?
>
> > Signed-off-by: Ilya Leoshkevich <iii@linux.ibm.com>
> > ---
> >  tools/lib/bpf/btf.c             | 44 +++++++++++++++++
> >  tools/lib/bpf/btf.h             |  8 ++++
> >  tools/lib/bpf/btf_dump.c        |  4 ++
> >  tools/lib/bpf/libbpf.c          | 84 +++++++++++++++++++++++++++++++--
> >  tools/lib/bpf/libbpf.map        |  5 ++
> >  tools/lib/bpf/libbpf_internal.h |  2 +
> >  6 files changed, 142 insertions(+), 5 deletions(-)
> >
> > diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c
> > index fdfff544f59a..1ebfcc687dab 100644
> > --- a/tools/lib/bpf/btf.c
> > +++ b/tools/lib/bpf/btf.c
> > @@ -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);
>
> well this won't work for 12-byte floats, would it?

never mind, btf_ptr_sz() takes care of it

>
> >         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;
> > +
>
> check byte_sz here?
>
>
> > +       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:
> > diff --git a/tools/lib/bpf/btf.h b/tools/lib/bpf/btf.h
> > index 1237bcd1dd17..c3b11bcebeda 100644
> > --- a/tools/lib/bpf/btf.h
> > +++ b/tools/lib/bpf/btf.h
> > @@ -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);
>
> nit: can you please put it right after btf__add_int() and drop the comment?
>
> > +
> >  struct btf_dedup_opts {
> >         unsigned int dedup_table_size;
> >         bool dont_resolve_fwds;
>
> [...]
>
> >  static bool kernel_supports(enum kern_feature_id feat_id)
> > @@ -4940,6 +5010,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;
>
> we don't enforce this for INTs, so maybe let's not do this for FLOATs as well?
>
> But really, FLOAT is not supported by BPF programs, so we should
> probably just error out on FLOAT relo.
>
> >         default:
> >                 pr_warn("unexpected kind %d relocated, local [%d], target [%d]\n",
> >                         btf_kind(local_type), local_id, targ_id);
> > @@ -5122,6 +5194,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;
>
> ditto
>
>
> >         default:
> >                 pr_warn("unexpected kind %s relocated, local [%d], target [%d]\n",
> >                         btf_kind_str(local_type), local_id, targ_id);
>
> [...]

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH v4 bpf-next 6/7] selftest/bpf: Add BTF_KIND_FLOAT tests
  2021-02-22 21:49 ` [PATCH v4 bpf-next 6/7] selftest/bpf: Add BTF_KIND_FLOAT tests Ilya Leoshkevich
@ 2021-02-23  7:11   ` Andrii Nakryiko
  2021-02-23 20:16     ` Ilya Leoshkevich
  0 siblings, 1 reply; 14+ messages in thread
From: Andrii Nakryiko @ 2021-02-23  7:11 UTC (permalink / raw)
  To: Ilya Leoshkevich
  Cc: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Yonghong Song, Arnaldo Carvalho de Melo, John Fastabend, bpf,
	Heiko Carstens, Vasily Gorbik

On Mon, Feb 22, 2021 at 1:52 PM Ilya Leoshkevich <iii@linux.ibm.com> wrote:
>
> Test the good variants as well as the potential malformed ones.
>
> Signed-off-by: Ilya Leoshkevich <iii@linux.ibm.com>
> Acked-by: Yonghong Song <yhs@fb.com>
> ---

Would be nice to have BTF dumping and dedup tests added/adjusted as well.

>  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(+)
>

[...]

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH v4 bpf-next 2/7] libbpf: Add BTF_KIND_FLOAT support
  2021-02-23  7:03   ` Andrii Nakryiko
  2021-02-23  7:08     ` Andrii Nakryiko
@ 2021-02-23 20:14     ` Ilya Leoshkevich
  1 sibling, 0 replies; 14+ messages in thread
From: Ilya Leoshkevich @ 2021-02-23 20:14 UTC (permalink / raw)
  To: Andrii Nakryiko
  Cc: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Yonghong Song, Arnaldo Carvalho de Melo, John Fastabend, bpf,
	Heiko Carstens, Vasily Gorbik

On Mon, 2021-02-22 at 23:03 -0800, Andrii Nakryiko wrote:
> On Mon, Feb 22, 2021 at 1:50 PM Ilya Leoshkevich <iii@linux.ibm.com>
> wrote:
> > 
> > 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, for example, the
> > following:
> > 
> >     [4] FLOAT 'float' size=4
> > 
> > becomes the following:
> > 
> >     [4] CONST '(anon)' type_id=10
> >     ...
> >     [8] INT 'unsigned int' size=4 bits_offset=0 nr_bits=32
> > encoding=(none)
> >     [9] INT 'unsigned char' size=1 bits_offset=0 nr_bits=8
> > encoding=(none)
> >     [10] ARRAY '(anon)' type_id=9 index_type_id=8 nr_elems=4
> > 
> 
> I liked Yonghong's initial suggestion to replace it with PTR to VOID.
> The only concern was that if this type was used from VAR, then
> sizeof(void *) != sizeof(float) on 64-bit architectures, which might
> theoretically mess up DATASEC layout. But is this a real concern? BPF
> programs don't really support floats, so there is no point in
> declaring float variables. I'd rather stick to a simple FLOAT -> PTR
> substitution than extend generated BTF.
> 
> Alternatively, was FLOAT -> anonymous empty STRUCT with desired size
> considered? Any problems with that?

An empty STRUCT is a really nice idea - it's future-proof and has much
smaller implementation than char[]. I'll go for it.

[...]


^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH v4 bpf-next 6/7] selftest/bpf: Add BTF_KIND_FLOAT tests
  2021-02-23  7:11   ` Andrii Nakryiko
@ 2021-02-23 20:16     ` Ilya Leoshkevich
  2021-02-23 21:35       ` Andrii Nakryiko
  0 siblings, 1 reply; 14+ messages in thread
From: Ilya Leoshkevich @ 2021-02-23 20:16 UTC (permalink / raw)
  To: Andrii Nakryiko
  Cc: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Yonghong Song, Arnaldo Carvalho de Melo, John Fastabend, bpf,
	Heiko Carstens, Vasily Gorbik

On Mon, 2021-02-22 at 23:11 -0800, Andrii Nakryiko wrote:
> On Mon, Feb 22, 2021 at 1:52 PM Ilya Leoshkevich <iii@linux.ibm.com>
> wrote:
> > 
> > Test the good variants as well as the potential malformed ones.
> > 
> > Signed-off-by: Ilya Leoshkevich <iii@linux.ibm.com>
> > Acked-by: Yonghong Song <yhs@fb.com>
> > ---
> 
> Would be nice to have BTF dumping and dedup tests added/adjusted as
> well.
> 
> >  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(+)
> > 
> 
> [...]

I will add a dedup in the next series, but dumping test requires LLVM
support, so it will have to come later separately. Still, in my local
setup the following works:

--- a/tools/testing/selftests/bpf/progs/btf_dump_test_case_syntax.c
+++ b/tools/testing/selftests/bpf/progs/btf_dump_test_case_syntax.c
@@ -205,6 +205,12 @@ struct struct_with_embedded_stuff {
        int t[11];
 };
 
+struct float_struct {
+       float *f;
+       const double *d;
+       volatile long double *ld;
+};
+
 struct root_struct {
        enum e1 _1;
        enum e2 _2;
@@ -219,6 +225,7 @@ struct root_struct {
        union_fwd_t *_12;
        union_fwd_ptr_t _13;
        struct struct_with_embedded_stuff _14;
+       struct float_struct _15;
 };
 
 /* ------ END-EXPECTED-OUTPUT ------ */



^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH v4 bpf-next 6/7] selftest/bpf: Add BTF_KIND_FLOAT tests
  2021-02-23 20:16     ` Ilya Leoshkevich
@ 2021-02-23 21:35       ` Andrii Nakryiko
  0 siblings, 0 replies; 14+ messages in thread
From: Andrii Nakryiko @ 2021-02-23 21:35 UTC (permalink / raw)
  To: Ilya Leoshkevich
  Cc: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Yonghong Song, Arnaldo Carvalho de Melo, John Fastabend, bpf,
	Heiko Carstens, Vasily Gorbik

On Tue, Feb 23, 2021 at 12:16 PM Ilya Leoshkevich <iii@linux.ibm.com> wrote:
>
> On Mon, 2021-02-22 at 23:11 -0800, Andrii Nakryiko wrote:
> > On Mon, Feb 22, 2021 at 1:52 PM Ilya Leoshkevich <iii@linux.ibm.com>
> > wrote:
> > >
> > > Test the good variants as well as the potential malformed ones.
> > >
> > > Signed-off-by: Ilya Leoshkevich <iii@linux.ibm.com>
> > > Acked-by: Yonghong Song <yhs@fb.com>
> > > ---
> >
> > Would be nice to have BTF dumping and dedup tests added/adjusted as
> > well.
> >
> > >  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(+)
> > >
> >
> > [...]
>
> I will add a dedup in the next series, but dumping test requires LLVM
> support, so it will have to come later separately. Still, in my local
> setup the following works:

Awesome, thanks for checking!

>
> --- a/tools/testing/selftests/bpf/progs/btf_dump_test_case_syntax.c
> +++ b/tools/testing/selftests/bpf/progs/btf_dump_test_case_syntax.c
> @@ -205,6 +205,12 @@ struct struct_with_embedded_stuff {
>         int t[11];
>  };
>
> +struct float_struct {
> +       float *f;
> +       const double *d;
> +       volatile long double *ld;
> +};
> +
>  struct root_struct {
>         enum e1 _1;
>         enum e2 _2;
> @@ -219,6 +225,7 @@ struct root_struct {
>         union_fwd_t *_12;
>         union_fwd_ptr_t _13;
>         struct struct_with_embedded_stuff _14;
> +       struct float_struct _15;
>  };
>
>  /* ------ END-EXPECTED-OUTPUT ------ */
>
>

^ permalink raw reply	[flat|nested] 14+ messages in thread

end of thread, back to index

Thread overview: 14+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-02-22 21:49 [PATCH v4 bpf-next 0/7] Add BTF_KIND_FLOAT support Ilya Leoshkevich
2021-02-22 21:49 ` [PATCH v4 bpf-next 1/7] bpf: Add BTF_KIND_FLOAT to uapi Ilya Leoshkevich
2021-02-22 21:49 ` [PATCH v4 bpf-next 2/7] libbpf: Add BTF_KIND_FLOAT support Ilya Leoshkevich
2021-02-23  7:03   ` Andrii Nakryiko
2021-02-23  7:08     ` Andrii Nakryiko
2021-02-23 20:14     ` Ilya Leoshkevich
2021-02-22 21:49 ` [PATCH v4 bpf-next 3/7] tools/bpftool: " Ilya Leoshkevich
2021-02-22 21:49 ` [PATCH v4 bpf-next 4/7] selftests/bpf: Use 25th bit in "invalid BTF_INFO" test Ilya Leoshkevich
2021-02-22 21:49 ` [PATCH v4 bpf-next 5/7] bpf: Add BTF_KIND_FLOAT support Ilya Leoshkevich
2021-02-22 21:49 ` [PATCH v4 bpf-next 6/7] selftest/bpf: Add BTF_KIND_FLOAT tests Ilya Leoshkevich
2021-02-23  7:11   ` Andrii Nakryiko
2021-02-23 20:16     ` Ilya Leoshkevich
2021-02-23 21:35       ` Andrii Nakryiko
2021-02-22 21:49 ` [PATCH v4 bpf-next 7/7] bpf: Document BTF_KIND_FLOAT in btf.rst Ilya Leoshkevich

BPF Archive on lore.kernel.org

Archives are clonable:
	git clone --mirror https://lore.kernel.org/bpf/0 bpf/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 bpf bpf/ https://lore.kernel.org/bpf \
		bpf@vger.kernel.org
	public-inbox-index bpf

Example config snippet for mirrors

Newsgroup available over NNTP:
	nntp://nntp.lore.kernel.org/org.kernel.vger.bpf


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git