Commit 72ed076a authored by Kumar Kartikeya Dwivedi's avatar Kumar Kartikeya Dwivedi Committed by Alexei Starovoitov
Browse files

selftests/bpf: Add tests for extending sleepable global subprogs 



Add tests for freplace behavior with the combination of sleepable
and non-sleepable global subprogs. The changes_pkt_data selftest
did all the hardwork, so simply rename it and include new support
for more summarization tests for might_sleep bit.

Signed-off-by: default avatarKumar Kartikeya Dwivedi <memxor@gmail.com>
Link: https://lore.kernel.org/r/20250301151846.1552362-4-memxor@gmail.com


Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parent b2bb7034

tools/testing/selftests/bpf/prog_tests/changes_pkt_data.c→tools/testing/selftests/bpf/prog_tests/summarization.c

+144 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

#include "bpf/libbpf.h"

#include "changes_pkt_data_freplace.skel.h"

#include "changes_pkt_data.skel.h"

#include "summarization_freplace.skel.h"

#include "summarization.skel.h"

#include <test_progs.h>



static void print_verifier_log(const char *log)
@@ -13,13 +13,14 @@ static void print_verifier_log(const char *log) 
static void test_aux(const char *main_prog_name,

		     const char *to_be_replaced,

		     const char *replacement,

		     bool expect_load)

		     bool expect_load,

		     const char *err_msg)

{

	struct changes_pkt_data_freplace *freplace = NULL;

	struct summarization_freplace *freplace = NULL;

	struct bpf_program *freplace_prog = NULL;

	struct bpf_program *main_prog = NULL;

	LIBBPF_OPTS(bpf_object_open_opts, opts);

	struct changes_pkt_data *main = NULL;

	struct summarization *main = NULL;

	char log[16*1024];

	int err;
@@ -27,19 +28,19 @@ static void test_aux(const char *main_prog_name, 
	opts.kernel_log_size = sizeof(log);

	if (env.verbosity >= VERBOSE_SUPER)

		opts.kernel_log_level = 1 | 2 | 4;

	main = changes_pkt_data__open_opts(&opts);

	if (!ASSERT_OK_PTR(main, "changes_pkt_data__open"))

	main = summarization__open_opts(&opts);

	if (!ASSERT_OK_PTR(main, "summarization__open"))

		goto out;

	main_prog = bpf_object__find_program_by_name(main->obj, main_prog_name);

	if (!ASSERT_OK_PTR(main_prog, "main_prog"))

		goto out;

	bpf_program__set_autoload(main_prog, true);

	err = changes_pkt_data__load(main);

	err = summarization__load(main);

	print_verifier_log(log);

	if (!ASSERT_OK(err, "changes_pkt_data__load"))

	if (!ASSERT_OK(err, "summarization__load"))

		goto out;

	freplace = changes_pkt_data_freplace__open_opts(&opts);

	if (!ASSERT_OK_PTR(freplace, "changes_pkt_data_freplace__open"))

	freplace = summarization_freplace__open_opts(&opts);

	if (!ASSERT_OK_PTR(freplace, "summarization_freplace__open"))

		goto out;

	freplace_prog = bpf_object__find_program_by_name(freplace->obj, replacement);

	if (!ASSERT_OK_PTR(freplace_prog, "freplace_prog"))
@@ -49,21 +50,33 @@ static void test_aux(const char *main_prog_name, 
	bpf_program__set_attach_target(freplace_prog,

				       bpf_program__fd(main_prog),

				       to_be_replaced);

	err = changes_pkt_data_freplace__load(freplace);

	err = summarization_freplace__load(freplace);

	print_verifier_log(log);



	/* The might_sleep extension doesn't work yet as sleepable calls are not

	 * allowed, but preserve the check in case it's supported later and then

	 * this particular combination can be enabled.

	 */

	if (!strcmp("might_sleep", replacement) && err) {

		ASSERT_HAS_SUBSTR(log, "helper call might sleep in a non-sleepable prog", "error log");

		ASSERT_EQ(err, -EINVAL, "err");

		test__skip();

		goto out;

	}



	if (expect_load) {

		ASSERT_OK(err, "changes_pkt_data_freplace__load");

		ASSERT_OK(err, "summarization_freplace__load");

	} else {

		ASSERT_ERR(err, "changes_pkt_data_freplace__load");

		ASSERT_HAS_SUBSTR(log, "Extension program changes packet data", "error log");

		ASSERT_ERR(err, "summarization_freplace__load");

		ASSERT_HAS_SUBSTR(log, err_msg, "error log");

	}



out:

	changes_pkt_data_freplace__destroy(freplace);

	changes_pkt_data__destroy(main);

	summarization_freplace__destroy(freplace);

	summarization__destroy(main);

}



/* There are two global subprograms in both changes_pkt_data.skel.h:

/* There are two global subprograms in both summarization.skel.h:

 * - one changes packet data;

 * - another does not.

 * It is ok to freplace subprograms that change packet data with those
@@ -72,36 +85,60 @@ static void test_aux(const char *main_prog_name, 
 * The below tests check outcomes for each combination of such freplace.

 * Also test a case when main subprogram itself is replaced and is a single

 * subprogram in a program.

 *

 * This holds for might_sleep programs. It is ok to replace might_sleep with

 * might_sleep and with does_not_sleep, but does_not_sleep cannot be replaced

 * with might_sleep.

 */

void test_changes_pkt_data_freplace(void)

void test_summarization_freplace(void)

{

	struct {

		const char *main;

		const char *to_be_replaced;

		bool changes;

	} mains[] = {

		{ "main_with_subprogs",   "changes_pkt_data",         true },

		{ "main_with_subprogs",   "does_not_change_pkt_data", false },

		bool has_side_effect;

	} mains[2][4] = {

		{

			{ "main_changes_with_subprogs",		"changes_pkt_data",	    true },

			{ "main_changes_with_subprogs",		"does_not_change_pkt_data", false },

			{ "main_changes",			"main_changes",             true },

			{ "main_does_not_change",		"main_does_not_change",     false },

		},

		{

			{ "main_might_sleep_with_subprogs",	"might_sleep",		    true },

			{ "main_might_sleep_with_subprogs",	"does_not_sleep",	    false },

			{ "main_might_sleep",			"main_might_sleep",	    true },

			{ "main_does_not_sleep",		"main_does_not_sleep",	    false },

		},

	};

	const char *pkt_err = "Extension program changes packet data";

	const char *slp_err = "Extension program may sleep";

	struct {

		const char *func;

		bool changes;

	} replacements[] = {

		{ "changes_pkt_data",         true },

		{ "does_not_change_pkt_data", false }

		bool has_side_effect;

		const char *err_msg;

	} replacements[2][2] = {

		{

			{ "changes_pkt_data",	      true,	pkt_err },

			{ "does_not_change_pkt_data", false,	pkt_err },

		},

		{

			{ "might_sleep",	      true,	slp_err },

			{ "does_not_sleep",	      false,	slp_err },

		},

	};

	char buf[64];



	for (int t = 0; t < 2; t++) {

		for (int i = 0; i < ARRAY_SIZE(mains); ++i) {

			for (int j = 0; j < ARRAY_SIZE(replacements); ++j) {

				snprintf(buf, sizeof(buf), "%s_with_%s",

				 mains[i].to_be_replaced, replacements[j].func);

					 mains[t][i].to_be_replaced, replacements[t][j].func);

				if (!test__start_subtest(buf))

					continue;

			test_aux(mains[i].main, mains[i].to_be_replaced, replacements[j].func,

				 mains[i].changes || !replacements[j].changes);

				test_aux(mains[t][i].main, mains[t][i].to_be_replaced, replacements[t][j].func,

					 mains[t][i].has_side_effect || !replacements[t][j].has_side_effect,

					 replacements[t][j].err_msg);

			}

		}

	}

}

tools/testing/selftests/bpf/progs/changes_pkt_data.c→tools/testing/selftests/bpf/progs/summarization.c

+78 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0



#include <linux/bpf.h>

#include <vmlinux.h>

#include <bpf/bpf_helpers.h>

#include "bpf_misc.h"



__noinline

long changes_pkt_data(struct __sk_buff *sk)
@@ -16,7 +17,7 @@ long does_not_change_pkt_data(struct __sk_buff *sk) 
}



SEC("?tc")

int main_with_subprogs(struct __sk_buff *sk)

int main_changes_with_subprogs(struct __sk_buff *sk)

{

	changes_pkt_data(sk);

	does_not_change_pkt_data(sk);
@@ -36,4 +37,42 @@ int main_does_not_change(struct __sk_buff *sk) 
	return 0;

}



__noinline

long might_sleep(struct pt_regs *ctx __arg_ctx)

{

	int i;



	bpf_copy_from_user(&i, sizeof(i), NULL);

	return i;

}



__noinline __weak

long does_not_sleep(struct pt_regs *ctx __arg_ctx)

{

	return 0;

}



SEC("?uprobe.s")

int main_might_sleep_with_subprogs(struct pt_regs *ctx)

{

	might_sleep(ctx);

	does_not_sleep(ctx);

	return 0;

}



SEC("?uprobe.s")

int main_might_sleep(struct pt_regs *ctx)

{

	int i;



	bpf_copy_from_user(&i, sizeof(i), NULL);

	return i;

}



SEC("?uprobe.s")

int main_does_not_sleep(struct pt_regs *ctx)

{

	return 0;

}



char _license[] SEC("license") = "GPL";

tools/testing/selftests/bpf/progs/changes_pkt_data_freplace.c→tools/testing/selftests/bpf/progs/summarization_freplace.c

+16 −1
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0



#include <linux/bpf.h>

#include <vmlinux.h>

#include <bpf/bpf_helpers.h>



SEC("?freplace")
@@ -15,4 +15,19 @@ long does_not_change_pkt_data(struct __sk_buff *sk) 
	return 0;

}



SEC("?freplace")

long might_sleep(struct pt_regs *ctx)

{

	int i;



	bpf_copy_from_user(&i, sizeof(i), NULL);

	return i;

}



SEC("?freplace")

long does_not_sleep(struct pt_regs *ctx)

{

	return 0;

}



char _license[] SEC("license") = "GPL";