diff mbox series

[bpf-next,v3,09/15] selftests/bpf: verify struct_ops autoload/autocreate sync

Message ID 20240304225156.24765-10-eddyz87@gmail.com (mailing list archive)
State Superseded
Delegated to: BPF
Headers show
Series libbpf: type suffixes and autocreate flag for struct_ops maps | expand

Checks

Context Check Description
netdev/tree_selection success Clearly marked for bpf-next, async
netdev/apply fail Patch does not apply to bpf-next-0
bpf/vmtest-bpf-next-VM_Test-2 success Logs for Unittests
bpf/vmtest-bpf-next-VM_Test-5 success Logs for aarch64-gcc / build-release
bpf/vmtest-bpf-next-VM_Test-1 success Logs for ShellCheck
bpf/vmtest-bpf-next-VM_Test-3 success Logs for Validate matrix.py
bpf/vmtest-bpf-next-VM_Test-0 success Logs for Lint
bpf/vmtest-bpf-next-VM_Test-4 success Logs for aarch64-gcc / build / build for aarch64 with gcc
bpf/vmtest-bpf-next-VM_Test-9 success Logs for aarch64-gcc / test (test_verifier, false, 360) / test_verifier on aarch64 with gcc
bpf/vmtest-bpf-next-VM_Test-10 success Logs for aarch64-gcc / veristat
bpf/vmtest-bpf-next-VM_Test-11 success Logs for s390x-gcc / build / build for s390x with gcc
bpf/vmtest-bpf-next-VM_Test-12 success Logs for s390x-gcc / build-release
bpf/vmtest-bpf-next-VM_Test-17 success Logs for s390x-gcc / veristat
bpf/vmtest-bpf-next-VM_Test-18 success Logs for set-matrix
bpf/vmtest-bpf-next-VM_Test-19 success Logs for x86_64-gcc / build / build for x86_64 with gcc
bpf/vmtest-bpf-next-VM_Test-20 success Logs for x86_64-gcc / build-release
bpf/vmtest-bpf-next-VM_Test-21 success Logs for x86_64-gcc / test (test_maps, false, 360) / test_maps on x86_64 with gcc
bpf/vmtest-bpf-next-VM_Test-22 fail Logs for x86_64-gcc / test (test_progs, false, 360) / test_progs on x86_64 with gcc
bpf/vmtest-bpf-next-VM_Test-23 fail Logs for x86_64-gcc / test (test_progs_no_alu32, false, 360) / test_progs_no_alu32 on x86_64 with gcc
bpf/vmtest-bpf-next-VM_Test-24 success Logs for x86_64-gcc / test (test_progs_no_alu32_parallel, true, 30) / test_progs_no_alu32_parallel on x86_64 with gcc
bpf/vmtest-bpf-next-VM_Test-25 success Logs for x86_64-gcc / test (test_progs_parallel, true, 30) / test_progs_parallel on x86_64 with gcc
bpf/vmtest-bpf-next-VM_Test-26 success Logs for x86_64-gcc / test (test_verifier, false, 360) / test_verifier on x86_64 with gcc
bpf/vmtest-bpf-next-VM_Test-27 success Logs for x86_64-gcc / veristat / veristat on x86_64 with gcc
bpf/vmtest-bpf-next-VM_Test-28 fail Logs for x86_64-llvm-17 / build / build for x86_64 with llvm-17
bpf/vmtest-bpf-next-VM_Test-30 success Logs for x86_64-llvm-17 / test
bpf/vmtest-bpf-next-VM_Test-31 success Logs for x86_64-llvm-17 / veristat
bpf/vmtest-bpf-next-VM_Test-32 fail Logs for x86_64-llvm-18 / build / build for x86_64 with llvm-18
bpf/vmtest-bpf-next-VM_Test-34 success Logs for x86_64-llvm-18 / test
bpf/vmtest-bpf-next-VM_Test-35 success Logs for x86_64-llvm-18 / veristat
bpf/vmtest-bpf-next-VM_Test-6 success Logs for aarch64-gcc / test (test_maps, false, 360) / test_maps on aarch64 with gcc
bpf/vmtest-bpf-next-VM_Test-7 fail Logs for aarch64-gcc / test (test_progs, false, 360) / test_progs on aarch64 with gcc
bpf/vmtest-bpf-next-VM_Test-8 fail Logs for aarch64-gcc / test (test_progs_no_alu32, false, 360) / test_progs_no_alu32 on aarch64 with gcc
bpf/vmtest-bpf-next-VM_Test-33 fail Logs for x86_64-llvm-18 / build-release / build for x86_64 with llvm-18 and -O2 optimization
bpf/vmtest-bpf-next-VM_Test-15 fail Logs for s390x-gcc / test (test_progs_no_alu32, false, 360) / test_progs_no_alu32 on s390x with gcc
bpf/vmtest-bpf-next-VM_Test-29 fail Logs for x86_64-llvm-17 / build-release / build for x86_64 with llvm-17 and -O2 optimization
bpf/vmtest-bpf-next-PR fail PR summary
bpf/vmtest-bpf-next-VM_Test-13 fail Logs for s390x-gcc / test (test_maps, false, 360) / test_maps on s390x with gcc
bpf/vmtest-bpf-next-VM_Test-14 fail Logs for s390x-gcc / test (test_progs, false, 360) / test_progs on s390x with gcc
bpf/vmtest-bpf-next-VM_Test-16 fail Logs for s390x-gcc / test (test_verifier, false, 360) / test_verifier on s390x with gcc

Commit Message

Eduard Zingerman March 4, 2024, 10:51 p.m. UTC 
Check that autocreate flags of struct_ops map cause autoload of
struct_ops corresponding programs:
- when struct_ops program is referenced only from a map for which
  autocreate is set to false, that program should not be loaded;
- when struct_ops program with autoload == false is set to be used
  from a map with autocreate == true using shadow var,
  that program should be loaded;
- when struct_ops program is not referenced from any map object load
  should fail.

Signed-off-by: Eduard Zingerman <eddyz87@gmail.com>
---
 .../selftests/bpf/prog_tests/bad_struct_ops.c | 32 ++++++++++++++
 .../bpf/prog_tests/struct_ops_autocreate.c    | 43 +++++++++++++++++--
 .../selftests/bpf/progs/bad_struct_ops2.c     | 14 ++++++
 .../bpf/progs/struct_ops_autocreate2.c        | 32 ++++++++++++++
 4 files changed, 117 insertions(+), 4 deletions(-)
 create mode 100644 tools/testing/selftests/bpf/progs/bad_struct_ops2.c
 create mode 100644 tools/testing/selftests/bpf/progs/struct_ops_autocreate2.c

Comments

Andrii Nakryiko March 5, 2024, 7:48 p.m. UTC | #1 
On Mon, Mar 4, 2024 at 2:52 PM Eduard Zingerman <eddyz87@gmail.com> wrote:
>
> Check that autocreate flags of struct_ops map cause autoload of
> struct_ops corresponding programs:
> - when struct_ops program is referenced only from a map for which
>   autocreate is set to false, that program should not be loaded;
> - when struct_ops program with autoload == false is set to be used
>   from a map with autocreate == true using shadow var,
>   that program should be loaded;
> - when struct_ops program is not referenced from any map object load
>   should fail.
>
> Signed-off-by: Eduard Zingerman <eddyz87@gmail.com>
> ---
>  .../selftests/bpf/prog_tests/bad_struct_ops.c | 32 ++++++++++++++
>  .../bpf/prog_tests/struct_ops_autocreate.c    | 43 +++++++++++++++++--
>  .../selftests/bpf/progs/bad_struct_ops2.c     | 14 ++++++
>  .../bpf/progs/struct_ops_autocreate2.c        | 32 ++++++++++++++
>  4 files changed, 117 insertions(+), 4 deletions(-)
>  create mode 100644 tools/testing/selftests/bpf/progs/bad_struct_ops2.c
>  create mode 100644 tools/testing/selftests/bpf/progs/struct_ops_autocreate2.c
>
> diff --git a/tools/testing/selftests/bpf/prog_tests/bad_struct_ops.c b/tools/testing/selftests/bpf/prog_tests/bad_struct_ops.c
> index 9f5dbefa0dd9..6a707213e46b 100644
> --- a/tools/testing/selftests/bpf/prog_tests/bad_struct_ops.c
> +++ b/tools/testing/selftests/bpf/prog_tests/bad_struct_ops.c
> @@ -2,6 +2,7 @@
>
>  #include <test_progs.h>
>  #include "bad_struct_ops.skel.h"
> +#include "bad_struct_ops2.skel.h"
>
>  static void invalid_prog_reuse(void)
>  {
> @@ -28,8 +29,39 @@ static void invalid_prog_reuse(void)
>         bad_struct_ops__destroy(skel);
>  }
>
> +static void unused_program(void)
> +{
> +       struct bad_struct_ops2 *skel;
> +       char *log = NULL;
> +       int err;
> +
> +       skel = bad_struct_ops2__open();
> +       if (!ASSERT_OK_PTR(skel, "bad_struct_ops2__open"))
> +               return;
> +
> +       /* struct_ops programs not referenced from any maps are open
> +        * with autoload set to true.
> +        */
> +       ASSERT_TRUE(bpf_program__autoload(skel->progs.foo), "foo autoload == true");
> +
> +       if (start_libbpf_log_capture())
> +               goto cleanup;
> +
> +       err = bad_struct_ops2__load(skel);
> +       ASSERT_ERR(err, "bad_struct_ops2__load should fail");
> +       log = stop_libbpf_log_capture();
> +       ASSERT_HAS_SUBSTR(log, "prog 'foo': failed to load",
> +                         "message about 'foo' failing to load");
> +
> +cleanup:
> +       free(log);
> +       bad_struct_ops2__destroy(skel);
> +}
> +
>  void test_bad_struct_ops(void)
>  {
>         if (test__start_subtest("invalid_prog_reuse"))
>                 invalid_prog_reuse();
> +       if (test__start_subtest("unused_program"))
> +               unused_program();
>  }
> diff --git a/tools/testing/selftests/bpf/prog_tests/struct_ops_autocreate.c b/tools/testing/selftests/bpf/prog_tests/struct_ops_autocreate.c
> index 883f938d518c..35910cbb9ca4 100644
> --- a/tools/testing/selftests/bpf/prog_tests/struct_ops_autocreate.c
> +++ b/tools/testing/selftests/bpf/prog_tests/struct_ops_autocreate.c
> @@ -2,6 +2,7 @@
>
>  #include <test_progs.h>
>  #include "struct_ops_autocreate.skel.h"
> +#include "struct_ops_autocreate2.skel.h"
>
>  static void cant_load_full_object(void)
>  {
> @@ -43,10 +44,6 @@ static void can_load_partial_object(void)
>         if (!ASSERT_OK_PTR(skel, "struct_ops_autocreate__open_opts"))
>                 return;
>
> -       err = bpf_program__set_autoload(skel->progs.test_2, false);
> -       if (!ASSERT_OK(err, "bpf_program__set_autoload"))
> -               goto cleanup;
> -
>         err = bpf_map__set_autocreate(skel->maps.testmod_2, false);
>         if (!ASSERT_OK(err, "bpf_map__set_autocreate"))
>                 goto cleanup;
> @@ -67,10 +64,48 @@ static void can_load_partial_object(void)
>         struct_ops_autocreate__destroy(skel);
>  }
>
> +/* Swap test_mod1->test_1 program from 'bar' to 'foo' using shadow vars.
> + * test_mod1 load should enable autoload for 'foo'.
> + */
> +static void autoload_and_shadow_vars(void)
> +{
> +       struct struct_ops_autocreate2 *skel = NULL;
> +       struct bpf_link *link = NULL;
> +       int err;
> +
> +       skel = struct_ops_autocreate2__open();
> +       if (!ASSERT_OK_PTR(skel, "struct_ops_autocreate__open_opts"))
> +               return;
> +
> +       ASSERT_FALSE(bpf_program__autoload(skel->progs.foo), "foo default autoload");
> +       ASSERT_FALSE(bpf_program__autoload(skel->progs.bar), "bar default autoload");
> +
> +       /* loading map testmod_1 would switch foo's autoload to true */
> +       skel->struct_ops.testmod_1->test_1 = skel->progs.foo;
> +
> +       err = struct_ops_autocreate2__load(skel);
> +       if (ASSERT_OK(err, "struct_ops_autocreate__load"))
> +               goto cleanup;
> +
> +

let's assert autoload state here as well?

> +       link = bpf_map__attach_struct_ops(skel->maps.testmod_1);
> +       if (!ASSERT_OK_PTR(link, "bpf_map__attach_struct_ops"))
> +               goto cleanup;
> +
> +       /* test_1() would be called from bpf_dummy_reg2() in bpf_testmod.c */
> +       err = ASSERT_EQ(skel->bss->test_1_result, 42, "test_1_result");
> +
> +cleanup:
> +       bpf_link__destroy(link);
> +       struct_ops_autocreate2__destroy(skel);
> +}
> +
>  void test_struct_ops_autocreate(void)
>  {
>         if (test__start_subtest("cant_load_full_object"))
>                 cant_load_full_object();
>         if (test__start_subtest("can_load_partial_object"))
>                 can_load_partial_object();
> +       if (test__start_subtest("autoload_and_shadow_vars"))
> +               autoload_and_shadow_vars();
>  }
> diff --git a/tools/testing/selftests/bpf/progs/bad_struct_ops2.c b/tools/testing/selftests/bpf/progs/bad_struct_ops2.c
> new file mode 100644
> index 000000000000..64a95f6be86d
> --- /dev/null
> +++ b/tools/testing/selftests/bpf/progs/bad_struct_ops2.c
> @@ -0,0 +1,14 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <linux/bpf.h>
> +#include <bpf/bpf_helpers.h>
> +
> +char _license[] SEC("license") = "GPL";
> +
> +/* This is an unused struct_ops program, it lacks corresponding
> + * struct_ops map, which provides attachment information.
> + * W/o additional configuration attempt to load such
> + * BPF object file would fail.
> + */
> +SEC("struct_ops/foo")
> +void foo(void) {}
> diff --git a/tools/testing/selftests/bpf/progs/struct_ops_autocreate2.c b/tools/testing/selftests/bpf/progs/struct_ops_autocreate2.c
> new file mode 100644
> index 000000000000..6049d9c902d3
> --- /dev/null
> +++ b/tools/testing/selftests/bpf/progs/struct_ops_autocreate2.c
> @@ -0,0 +1,32 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <linux/bpf.h>
> +#include <bpf/bpf_helpers.h>
> +#include <bpf/bpf_tracing.h>
> +
> +char _license[] SEC("license") = "GPL";
> +
> +int test_1_result = 0;
> +
> +SEC("?struct_ops/test_1")
> +int BPF_PROG(foo)
> +{
> +       test_1_result = 42;
> +       return 0;
> +}
> +
> +SEC("?struct_ops/test_1")
> +int BPF_PROG(bar)
> +{
> +       test_1_result = 24;
> +       return 0;
> +}
> +
> +struct bpf_testmod_ops {
> +       int (*test_1)(void);
> +};
> +
> +SEC(".struct_ops.link")
> +struct bpf_testmod_ops testmod_1 = {
> +       .test_1 = (void *)bar
> +};
> --
> 2.43.0
>
Eduard Zingerman March 6, 2024, 12:40 a.m. UTC | #2 
On Tue, 2024-03-05 at 11:48 -0800, Andrii Nakryiko wrote:
[...]

> > +/* Swap test_mod1->test_1 program from 'bar' to 'foo' using shadow vars.
> > + * test_mod1 load should enable autoload for 'foo'.
> > + */
> > +static void autoload_and_shadow_vars(void)
> > +{
> > +       struct struct_ops_autocreate2 *skel = NULL;
> > +       struct bpf_link *link = NULL;
> > +       int err;
> > +
> > +       skel = struct_ops_autocreate2__open();
> > +       if (!ASSERT_OK_PTR(skel, "struct_ops_autocreate__open_opts"))
> > +               return;
> > +
> > +       ASSERT_FALSE(bpf_program__autoload(skel->progs.foo), "foo default autoload");
> > +       ASSERT_FALSE(bpf_program__autoload(skel->progs.bar), "bar default autoload");
> > +
> > +       /* loading map testmod_1 would switch foo's autoload to true */
> > +       skel->struct_ops.testmod_1->test_1 = skel->progs.foo;
> > +
> > +       err = struct_ops_autocreate2__load(skel);
> > +       if (ASSERT_OK(err, "struct_ops_autocreate__load"))
> > +               goto cleanup;
> > +
> > +
> 
> let's assert autoload state here as well?

Good idea!
Did not occur to me to check this after load for some reason.

[...]
diff mbox series

Patch

diff --git a/tools/testing/selftests/bpf/prog_tests/bad_struct_ops.c b/tools/testing/selftests/bpf/prog_tests/bad_struct_ops.c
index 9f5dbefa0dd9..6a707213e46b 100644
--- a/tools/testing/selftests/bpf/prog_tests/bad_struct_ops.c
+++ b/tools/testing/selftests/bpf/prog_tests/bad_struct_ops.c
@@ -2,6 +2,7 @@ 
 
 #include <test_progs.h>
 #include "bad_struct_ops.skel.h"
+#include "bad_struct_ops2.skel.h"
 
 static void invalid_prog_reuse(void)
 {
@@ -28,8 +29,39 @@  static void invalid_prog_reuse(void)
 	bad_struct_ops__destroy(skel);
 }
 
+static void unused_program(void)
+{
+	struct bad_struct_ops2 *skel;
+	char *log = NULL;
+	int err;
+
+	skel = bad_struct_ops2__open();
+	if (!ASSERT_OK_PTR(skel, "bad_struct_ops2__open"))
+		return;
+
+	/* struct_ops programs not referenced from any maps are open
+	 * with autoload set to true.
+	 */
+	ASSERT_TRUE(bpf_program__autoload(skel->progs.foo), "foo autoload == true");
+
+	if (start_libbpf_log_capture())
+		goto cleanup;
+
+	err = bad_struct_ops2__load(skel);
+	ASSERT_ERR(err, "bad_struct_ops2__load should fail");
+	log = stop_libbpf_log_capture();
+	ASSERT_HAS_SUBSTR(log, "prog 'foo': failed to load",
+			  "message about 'foo' failing to load");
+
+cleanup:
+	free(log);
+	bad_struct_ops2__destroy(skel);
+}
+
 void test_bad_struct_ops(void)
 {
 	if (test__start_subtest("invalid_prog_reuse"))
 		invalid_prog_reuse();
+	if (test__start_subtest("unused_program"))
+		unused_program();
 }
diff --git a/tools/testing/selftests/bpf/prog_tests/struct_ops_autocreate.c b/tools/testing/selftests/bpf/prog_tests/struct_ops_autocreate.c
index 883f938d518c..35910cbb9ca4 100644
--- a/tools/testing/selftests/bpf/prog_tests/struct_ops_autocreate.c
+++ b/tools/testing/selftests/bpf/prog_tests/struct_ops_autocreate.c
@@ -2,6 +2,7 @@ 
 
 #include <test_progs.h>
 #include "struct_ops_autocreate.skel.h"
+#include "struct_ops_autocreate2.skel.h"
 
 static void cant_load_full_object(void)
 {
@@ -43,10 +44,6 @@  static void can_load_partial_object(void)
 	if (!ASSERT_OK_PTR(skel, "struct_ops_autocreate__open_opts"))
 		return;
 
-	err = bpf_program__set_autoload(skel->progs.test_2, false);
-	if (!ASSERT_OK(err, "bpf_program__set_autoload"))
-		goto cleanup;
-
 	err = bpf_map__set_autocreate(skel->maps.testmod_2, false);
 	if (!ASSERT_OK(err, "bpf_map__set_autocreate"))
 		goto cleanup;
@@ -67,10 +64,48 @@  static void can_load_partial_object(void)
 	struct_ops_autocreate__destroy(skel);
 }
 
+/* Swap test_mod1->test_1 program from 'bar' to 'foo' using shadow vars.
+ * test_mod1 load should enable autoload for 'foo'.
+ */
+static void autoload_and_shadow_vars(void)
+{
+	struct struct_ops_autocreate2 *skel = NULL;
+	struct bpf_link *link = NULL;
+	int err;
+
+	skel = struct_ops_autocreate2__open();
+	if (!ASSERT_OK_PTR(skel, "struct_ops_autocreate__open_opts"))
+		return;
+
+	ASSERT_FALSE(bpf_program__autoload(skel->progs.foo), "foo default autoload");
+	ASSERT_FALSE(bpf_program__autoload(skel->progs.bar), "bar default autoload");
+
+	/* loading map testmod_1 would switch foo's autoload to true */
+	skel->struct_ops.testmod_1->test_1 = skel->progs.foo;
+
+	err = struct_ops_autocreate2__load(skel);
+	if (ASSERT_OK(err, "struct_ops_autocreate__load"))
+		goto cleanup;
+
+
+	link = bpf_map__attach_struct_ops(skel->maps.testmod_1);
+	if (!ASSERT_OK_PTR(link, "bpf_map__attach_struct_ops"))
+		goto cleanup;
+
+	/* test_1() would be called from bpf_dummy_reg2() in bpf_testmod.c */
+	err = ASSERT_EQ(skel->bss->test_1_result, 42, "test_1_result");
+
+cleanup:
+	bpf_link__destroy(link);
+	struct_ops_autocreate2__destroy(skel);
+}
+
 void test_struct_ops_autocreate(void)
 {
 	if (test__start_subtest("cant_load_full_object"))
 		cant_load_full_object();
 	if (test__start_subtest("can_load_partial_object"))
 		can_load_partial_object();
+	if (test__start_subtest("autoload_and_shadow_vars"))
+		autoload_and_shadow_vars();
 }
diff --git a/tools/testing/selftests/bpf/progs/bad_struct_ops2.c b/tools/testing/selftests/bpf/progs/bad_struct_ops2.c
new file mode 100644
index 000000000000..64a95f6be86d
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/bad_struct_ops2.c
@@ -0,0 +1,14 @@ 
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/bpf.h>
+#include <bpf/bpf_helpers.h>
+
+char _license[] SEC("license") = "GPL";
+
+/* This is an unused struct_ops program, it lacks corresponding
+ * struct_ops map, which provides attachment information.
+ * W/o additional configuration attempt to load such
+ * BPF object file would fail.
+ */
+SEC("struct_ops/foo")
+void foo(void) {}
diff --git a/tools/testing/selftests/bpf/progs/struct_ops_autocreate2.c b/tools/testing/selftests/bpf/progs/struct_ops_autocreate2.c
new file mode 100644
index 000000000000..6049d9c902d3
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/struct_ops_autocreate2.c
@@ -0,0 +1,32 @@ 
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/bpf.h>
+#include <bpf/bpf_helpers.h>
+#include <bpf/bpf_tracing.h>
+
+char _license[] SEC("license") = "GPL";
+
+int test_1_result = 0;
+
+SEC("?struct_ops/test_1")
+int BPF_PROG(foo)
+{
+	test_1_result = 42;
+	return 0;
+}
+
+SEC("?struct_ops/test_1")
+int BPF_PROG(bar)
+{
+	test_1_result = 24;
+	return 0;
+}
+
+struct bpf_testmod_ops {
+	int (*test_1)(void);
+};
+
+SEC(".struct_ops.link")
+struct bpf_testmod_ops testmod_1 = {
+	.test_1 = (void *)bar
+};