Skip to contentSkip to conversation

selftests/bpf: check if distilled base inherits source endianness

PATCH Applied Eduard Zingerman 4 participants 7 messages Aug 30, 2024

Subsystems (3)
lore
Share & tools
lore

Eduard Zingerman

author maintainer
#0 lore raw

PATCH 1/1 selftests/bpf: check if distilled base inherits source endianness

Create a BTF with endianness different from host, make a distilled base/split BTF pair from it, dump as raw bytes, import again and verify that endianness is preserved.

---
 .../selftests/bpf/prog_tests/btf_distill.c    | 73 +++++++++++++++++++
 1 file changed, 73 insertions(+)
tools/testing/selftests/bpf/prog_tests/btf_distill.c +73 -0
index bfbe795823a2..810b2e434562 100644
@@ -535,6 +535,77 @@ static void test_distilled_base_vmlinux(void)
 	btf__free(vmlinux_btf);
 }
 
+static bool is_host_big_endian(void)
+{
+	return htons(0x1234) == 0x1234;
+}
+
+/* Split and new base BTFs should inherit endianness from source BTF. */
+static void test_distilled_endianness(void)
+{
+	struct btf *base = NULL, *split = NULL, *new_base = NULL, *new_split = NULL;
+	struct btf *new_base1 = NULL, *new_split1 = NULL;
+	enum btf_endianness inverse_endianness;
+	const void *raw_data;
+	__u32 size;
+
+	printf("is_host_big_endian? %d\n", is_host_big_endian());
+	inverse_endianness = is_host_big_endian() ? BTF_LITTLE_ENDIAN : BTF_BIG_ENDIAN;
+	base = btf__new_empty();
+	btf__set_endianness(base, inverse_endianness);
+	if (!ASSERT_OK_PTR(base, "empty_main_btf"))
+		return;
+	btf__add_int(base, "int", 4, BTF_INT_SIGNED);   /* [1] int */
+	VALIDATE_RAW_BTF(
+		base,
+		"[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED");
+	split = btf__new_empty_split(base);
+	if (!ASSERT_OK_PTR(split, "empty_split_btf"))
+		goto cleanup;
+	btf__add_ptr(split, 1);
+	VALIDATE_RAW_BTF(
+		split,
+		"[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED",
+		"[2] PTR '(anon)' type_id=1");
+	if (!ASSERT_EQ(0, btf__distill_base(split, &new_base, &new_split),
+		       "distilled_base") ||
+	    !ASSERT_OK_PTR(new_base, "distilled_base") ||
+	    !ASSERT_OK_PTR(new_split, "distilled_split") ||
+	    !ASSERT_EQ(2, btf__type_cnt(new_base), "distilled_base_type_cnt"))
+		goto cleanup;
+	VALIDATE_RAW_BTF(
+		new_split,
+		"[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED",
+		"[2] PTR '(anon)' type_id=1");
+
+	raw_data = btf__raw_data(new_base, &size);
+	if (!ASSERT_OK_PTR(raw_data, "btf__raw_data #1"))
+		goto cleanup;
+	new_base1 = btf__new(raw_data, size);
+	if (!ASSERT_OK_PTR(new_base1, "new_base1 = btf__new()"))
+		goto cleanup;
+	raw_data = btf__raw_data(new_split, &size);
+	if (!ASSERT_OK_PTR(raw_data, "btf__raw_data #2"))
+		goto cleanup;
+	new_split1 = btf__new_split(raw_data, size, new_base1);
+	if (!ASSERT_OK_PTR(new_split1, "new_split1 = btf__new()"))
+		goto cleanup;
+
+	ASSERT_EQ(btf__endianness(new_base1), inverse_endianness, "new_base1 endianness");
+	ASSERT_EQ(btf__endianness(new_split1), inverse_endianness, "new_split1 endianness");
+	VALIDATE_RAW_BTF(
+		new_split1,
+		"[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED",
+		"[2] PTR '(anon)' type_id=1");
+cleanup:
+	btf__free(new_split1);
+	btf__free(new_base1);
+	btf__free(new_split);
+	btf__free(new_base);
+	btf__free(split);
+	btf__free(base);
+}
+
 void test_btf_distill(void)
 {
 	if (test__start_subtest("distilled_base"))
@@ -549,4 +620,6 @@ void test_btf_distill(void)
 		test_distilled_base_multi_err2();
 	if (test__start_subtest("distilled_base_vmlinux"))
 		test_distilled_base_vmlinux();
+	if (test__start_subtest("distilled_endianness"))
+		test_distilled_endianness();
 }
Signature · 1 line
2.46.0
#2 lore raw
In reply to Eduard Zingerman
Quoted 23 lines · Eduard Zingerman

Create a BTF with endianness different from host, make a distilled base/split BTF pair from it, dump as raw bytes, import again and verify that endianness is preserved.

---
 .../selftests/bpf/prog_tests/btf_distill.c    | 73 +++++++++++++++++++
 1 file changed, 73 insertions(+)
tools/testing/selftests/bpf/prog_tests/btf_distill.c +5 -0
index bfbe795823a2..810b2e434562 100644
@@ -535,6 +535,77 @@ static void test_distilled_base_vmlinux(void)
        btf__free(vmlinux_btf);
 }
 
+static bool is_host_big_endian(void)
+{
+       return htons(0x1234) == 0x1234;
+}
+

tools/testing/selftests/bpf/prog_tests/btf_distill.c static void test_distilled_base_vmlinux(void) · line 552

Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/btf_distill.c +10 -0
+/* Split and new base BTFs should inherit endianness from source BTF. */
+static void test_distilled_endianness(void)
+{
+       struct btf *base = NULL, *split = NULL, *new_base = NULL, *new_split = NULL;
+       struct btf *new_base1 = NULL, *new_split1 = NULL;
+       enum btf_endianness inverse_endianness;
+       const void *raw_data;
+       __u32 size;
+
+       printf("is_host_big_endian? %d\n", is_host_big_endian());

removed printf

tools/testing/selftests/bpf/prog_tests/btf_distill.c static void test_distilled_base_vmlinux(void) · line 556

Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/btf_distill.c +4 -0
+       inverse_endianness = is_host_big_endian() ? BTF_LITTLE_ENDIAN : BTF_BIG_ENDIAN;
+       base = btf__new_empty();
+       btf__set_endianness(base, inverse_endianness);
+       if (!ASSERT_OK_PTR(base, "empty_main_btf"))

moved check before set_endianness

applied to bpf-next after Tony's endianness fix, thanks!

Quoted 9 lines
tools/testing/selftests/bpf/prog_tests/btf_distill.c +9 -0
+               return;
+       btf__add_int(base, "int", 4, BTF_INT_SIGNED);   /* [1] int */
+       VALIDATE_RAW_BTF(
+               base,
+               "[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED");
+       split = btf__new_empty_split(base);
+       if (!ASSERT_OK_PTR(split, "empty_split_btf"))
+               goto cleanup;
+       btf__add_ptr(split, 1);

[...]

author maintainer
#3 lore raw

On Fri, 2024-08-30 at 10:51 -0700, Andrii Nakryiko wrote:

[...]

Quoted 4 lines
Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/btf_distill.c +4 -0
+/* Split and new base BTFs should inherit endianness from source BTF. */
+static void test_distilled_endianness(void)
+{
+       struct btf *base = NULL, *split = NULL, *new_base = NULL, *new_split = NULL;
Quoted 8 lines

tools/testing/selftests/bpf/prog_tests/btf_distill.c static void test_distilled_base_vmlinux(void) · line 552

Quoted 6 lines
tools/testing/selftests/bpf/prog_tests/btf_distill.c +6 -0
+       struct btf *new_base1 = NULL, *new_split1 = NULL;
+       enum btf_endianness inverse_endianness;
+       const void *raw_data;
+       __u32 size;
+
+       printf("is_host_big_endian? %d\n", is_host_big_endian());

removed printf

:facepalm:, sorry, my bad.

[...]

Reviewed-by Tested-by on v1 1/1
#4 lore raw
In reply to Eduard Zingerman
Quoted 5 lines · Eduard Zingerman

Create a BTF with endianness different from host, make a distilled base/split BTF pair from it, dump as raw bytes, import again and verify that endianness is preserved.

One small thing below, but

Thanks!

Quoted 19 lines
---
 .../selftests/bpf/prog_tests/btf_distill.c    | 73 +++++++++++++++++++
 1 file changed, 73 insertions(+)
tools/testing/selftests/bpf/prog_tests/btf_distill.c +7 -0
index bfbe795823a2..810b2e434562 100644
@@ -535,6 +535,77 @@ static void test_distilled_base_vmlinux(void)
 	btf__free(vmlinux_btf);
 }
 
+static bool is_host_big_endian(void)
+{
+	return htons(0x1234) == 0x1234;
+}
+
+/* Split and new base BTFs should inherit endianness from source BTF. */
+static void test_distilled_endianness(void)

tools/testing/selftests/bpf/prog_tests/btf_distill.c static void test_distilled_base_vmlinux(void) · line 554

Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/btf_distill.c +10 -0
+{
+	struct btf *base = NULL, *split = NULL, *new_base = NULL, *new_split = NULL;
+	struct btf *new_base1 = NULL, *new_split1 = NULL;
+	enum btf_endianness inverse_endianness;
+	const void *raw_data;
+	__u32 size;
+
+	printf("is_host_big_endian? %d\n", is_host_big_endian());
+	inverse_endianness = is_host_big_endian() ? BTF_LITTLE_ENDIAN : BTF_BIG_ENDIAN;
+	base = btf__new_empty();

nit: I think you could avoid the need for is_host_big_endian() by doing this:

inverse_endianness = btf__endianness(base) == BTF_LITTLE_ENDIAN ?

		     BTF_BIG_ENDIAN : BTF_LITTLE_ENDIAN;
Quoted 64 lines
tools/testing/selftests/bpf/prog_tests/btf_distill.c +56 -0
+	btf__set_endianness(base, inverse_endianness);
+	if (!ASSERT_OK_PTR(base, "empty_main_btf"))
+		return;
+	btf__add_int(base, "int", 4, BTF_INT_SIGNED);   /* [1] int */
+	VALIDATE_RAW_BTF(
+		base,
+		"[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED");
+	split = btf__new_empty_split(base);
+	if (!ASSERT_OK_PTR(split, "empty_split_btf"))
+		goto cleanup;
+	btf__add_ptr(split, 1);
+	VALIDATE_RAW_BTF(
+		split,
+		"[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED",
+		"[2] PTR '(anon)' type_id=1");
+	if (!ASSERT_EQ(0, btf__distill_base(split, &new_base, &new_split),
+		       "distilled_base") ||
+	    !ASSERT_OK_PTR(new_base, "distilled_base") ||
+	    !ASSERT_OK_PTR(new_split, "distilled_split") ||
+	    !ASSERT_EQ(2, btf__type_cnt(new_base), "distilled_base_type_cnt"))
+		goto cleanup;
+	VALIDATE_RAW_BTF(
+		new_split,
+		"[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED",
+		"[2] PTR '(anon)' type_id=1");
+
+	raw_data = btf__raw_data(new_base, &size);
+	if (!ASSERT_OK_PTR(raw_data, "btf__raw_data #1"))
+		goto cleanup;
+	new_base1 = btf__new(raw_data, size);
+	if (!ASSERT_OK_PTR(new_base1, "new_base1 = btf__new()"))
+		goto cleanup;
+	raw_data = btf__raw_data(new_split, &size);
+	if (!ASSERT_OK_PTR(raw_data, "btf__raw_data #2"))
+		goto cleanup;
+	new_split1 = btf__new_split(raw_data, size, new_base1);
+	if (!ASSERT_OK_PTR(new_split1, "new_split1 = btf__new()"))
+		goto cleanup;
+
+	ASSERT_EQ(btf__endianness(new_base1), inverse_endianness, "new_base1 endianness");
+	ASSERT_EQ(btf__endianness(new_split1), inverse_endianness, "new_split1 endianness");
+	VALIDATE_RAW_BTF(
+		new_split1,
+		"[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED",
+		"[2] PTR '(anon)' type_id=1");
+cleanup:
+	btf__free(new_split1);
+	btf__free(new_base1);
+	btf__free(new_split);
+	btf__free(new_base);
+	btf__free(split);
+	btf__free(base);
+}
+
 void test_btf_distill(void)
 {
 	if (test__start_subtest("distilled_base"))
@@ -549,4 +620,6 @@ void test_btf_distill(void)
 		test_distilled_base_multi_err2();
 	if (test__start_subtest("distilled_base_vmlinux"))
 		test_distilled_base_vmlinux();
+	if (test__start_subtest("distilled_endianness"))
+		test_distilled_endianness();
 }
#5 lore raw
Quoted 6 lines · Alan Maguire
Quoted 4 lines · Eduard Zingerman

Create a BTF with endianness different from host, make a distilled base/split BTF pair from it, dump as raw bytes, import again and verify that endianness is preserved.

Quoted 6 lines
Quoted 1 line

One small thing below, but

will add and force-push, thanks

Quoted 37 lines

Thanks!

Quoted 19 lines
---
 .../selftests/bpf/prog_tests/btf_distill.c    | 73 +++++++++++++++++++
 1 file changed, 73 insertions(+)
tools/testing/selftests/bpf/prog_tests/btf_distill.c +7 -0
index bfbe795823a2..810b2e434562 100644
@@ -535,6 +535,77 @@ static void test_distilled_base_vmlinux(void)
      btf__free(vmlinux_btf);
 }
 
+static bool is_host_big_endian(void)
+{
+     return htons(0x1234) == 0x1234;
+}
+
+/* Split and new base BTFs should inherit endianness from source BTF. */
+static void test_distilled_endianness(void)

tools/testing/selftests/bpf/prog_tests/btf_distill.c static void test_distilled_base_vmlinux(void) · line 554

Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/btf_distill.c +10 -0
+{
+     struct btf *base = NULL, *split = NULL, *new_base = NULL, *new_split = NULL;
+     struct btf *new_base1 = NULL, *new_split1 = NULL;
+     enum btf_endianness inverse_endianness;
+     const void *raw_data;
+     __u32 size;
+
+     printf("is_host_big_endian? %d\n", is_host_big_endian());
+     inverse_endianness = is_host_big_endian() ? BTF_LITTLE_ENDIAN : BTF_BIG_ENDIAN;
+     base = btf__new_empty();

nit: I think you could avoid the need for is_host_big_endian() by doing this:

Quoted 2 lines

inverse_endianness = btf__endianness(base) == BTF_LITTLE_ENDIAN ?

                     BTF_BIG_ENDIAN : BTF_LITTLE_ENDIAN;

good point, I'll fix it up

Quoted 66 lines
Quoted 66 lines
tools/testing/selftests/bpf/prog_tests/btf_distill.c +56 -0
+     btf__set_endianness(base, inverse_endianness);
+     if (!ASSERT_OK_PTR(base, "empty_main_btf"))
+             return;
+     btf__add_int(base, "int", 4, BTF_INT_SIGNED);   /* [1] int */
+     VALIDATE_RAW_BTF(
+             base,
+             "[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED");
+     split = btf__new_empty_split(base);
+     if (!ASSERT_OK_PTR(split, "empty_split_btf"))
+             goto cleanup;
+     btf__add_ptr(split, 1);
+     VALIDATE_RAW_BTF(
+             split,
+             "[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED",
+             "[2] PTR '(anon)' type_id=1");
+     if (!ASSERT_EQ(0, btf__distill_base(split, &new_base, &new_split),
+                    "distilled_base") ||
+         !ASSERT_OK_PTR(new_base, "distilled_base") ||
+         !ASSERT_OK_PTR(new_split, "distilled_split") ||
+         !ASSERT_EQ(2, btf__type_cnt(new_base), "distilled_base_type_cnt"))
+             goto cleanup;
+     VALIDATE_RAW_BTF(
+             new_split,
+             "[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED",
+             "[2] PTR '(anon)' type_id=1");
+
+     raw_data = btf__raw_data(new_base, &size);
+     if (!ASSERT_OK_PTR(raw_data, "btf__raw_data #1"))
+             goto cleanup;
+     new_base1 = btf__new(raw_data, size);
+     if (!ASSERT_OK_PTR(new_base1, "new_base1 = btf__new()"))
+             goto cleanup;
+     raw_data = btf__raw_data(new_split, &size);
+     if (!ASSERT_OK_PTR(raw_data, "btf__raw_data #2"))
+             goto cleanup;
+     new_split1 = btf__new_split(raw_data, size, new_base1);
+     if (!ASSERT_OK_PTR(new_split1, "new_split1 = btf__new()"))
+             goto cleanup;
+
+     ASSERT_EQ(btf__endianness(new_base1), inverse_endianness, "new_base1 endianness");
+     ASSERT_EQ(btf__endianness(new_split1), inverse_endianness, "new_split1 endianness");
+     VALIDATE_RAW_BTF(
+             new_split1,
+             "[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED",
+             "[2] PTR '(anon)' type_id=1");
+cleanup:
+     btf__free(new_split1);
+     btf__free(new_base1);
+     btf__free(new_split);
+     btf__free(new_base);
+     btf__free(split);
+     btf__free(base);
+}
+
 void test_btf_distill(void)
 {
      if (test__start_subtest("distilled_base"))
@@ -549,4 +620,6 @@ void test_btf_distill(void)
              test_distilled_base_multi_err2();
      if (test__start_subtest("distilled_base_vmlinux"))
              test_distilled_base_vmlinux();
+     if (test__start_subtest("distilled_endianness"))
+             test_distilled_endianness();
 }
#6 lore raw
In reply to Eduard Zingerman
This patch was applied to bpf/bpf-next.git (master) by Andrii Nakryiko <[email protected]>:

Hello:

This patch was applied to bpf/bpf-next.git (master) by Andrii Nakryiko <[email protected]>:

Quoted 8 lines · On Fri, 30 Aug 2024 10:34:06 -0700 you wrote:

Create a BTF with endianness different from host, make a distilled base/split BTF pair from it, dump as raw bytes, import again and verify that endianness is preserved.

---
 .../selftests/bpf/prog_tests/btf_distill.c    | 73 +++++++++++++++++++
 1 file changed, 73 insertions(+)

Here is the summary with links:
- [bpf-next] selftests/bpf: check if distilled base inherits source endianness

    https://git.kernel.org/bpf/bpf-next/c/217c4dfec4a6

You are awesome, thank you!

Signature · 2 lines
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html