Commit 39316183 authored by Delyan Kratunov's avatar Delyan Kratunov Committed by Andrii Nakryiko
Browse files

selftests/bpf: Migrate from bpf_prog_test_run_xattr 



bpf_prog_test_run_xattr is being deprecated in favor of the OPTS-based
bpf_prog_test_run_opts.
We end up unable to use CHECK_ATTR so replace usages with ASSERT_* calls.
Also, prog_run_xattr is now prog_run_opts.

Signed-off-by: default avatarDelyan Kratunov <delyank@fb.com>
Signed-off-by: default avatarAndrii Nakryiko <andrii@kernel.org>
Link: https://lore.kernel.org/bpf/20220202235423.1097270-3-delyank@fb.com
parent 04fcb5f9

tools/testing/selftests/bpf/prog_tests/check_mtu.c

+13 −27
Original line number Diff line number Diff line
@@ -79,28 +79,21 @@ static void test_check_mtu_run_xdp(struct test_check_mtu *skel, 
				   struct bpf_program *prog,

				   __u32 mtu_expect)

{

	const char *prog_name = bpf_program__name(prog);

	int retval_expect = XDP_PASS;

	__u32 mtu_result = 0;

	char buf[256] = {};

	int err;

	struct bpf_prog_test_run_attr tattr = {

	int err, prog_fd = bpf_program__fd(prog);

	LIBBPF_OPTS(bpf_test_run_opts, topts,

		.repeat = 1,

		.data_in = &pkt_v4,

		.data_size_in = sizeof(pkt_v4),

		.data_out = buf,

		.data_size_out = sizeof(buf),

		.prog_fd = bpf_program__fd(prog),

	};



	err = bpf_prog_test_run_xattr(&tattr);

	CHECK_ATTR(err != 0, "bpf_prog_test_run",

		   "prog_name:%s (err %d errno %d retval %d)\n",

		   prog_name, err, errno, tattr.retval);

	);



	CHECK(tattr.retval != retval_expect, "retval",

	      "progname:%s unexpected retval=%d expected=%d\n",

	      prog_name, tattr.retval, retval_expect);

	err = bpf_prog_test_run_opts(prog_fd, &topts);

	ASSERT_OK(err, "test_run");

	ASSERT_EQ(topts.retval, retval_expect, "retval");



	/* Extract MTU that BPF-prog got */

	mtu_result = skel->bss->global_bpf_mtu_xdp;
@@ -139,28 +132,21 @@ static void test_check_mtu_run_tc(struct test_check_mtu *skel, 
				  struct bpf_program *prog,

				  __u32 mtu_expect)

{

	const char *prog_name = bpf_program__name(prog);

	int retval_expect = BPF_OK;

	__u32 mtu_result = 0;

	char buf[256] = {};

	int err;

	struct bpf_prog_test_run_attr tattr = {

		.repeat = 1,

	int err, prog_fd = bpf_program__fd(prog);

	LIBBPF_OPTS(bpf_test_run_opts, topts,

		.data_in = &pkt_v4,

		.data_size_in = sizeof(pkt_v4),

		.data_out = buf,

		.data_size_out = sizeof(buf),

		.prog_fd = bpf_program__fd(prog),

	};



	err = bpf_prog_test_run_xattr(&tattr);

	CHECK_ATTR(err != 0, "bpf_prog_test_run",

		   "prog_name:%s (err %d errno %d retval %d)\n",

		   prog_name, err, errno, tattr.retval);

		.repeat = 1,

	);



	CHECK(tattr.retval != retval_expect, "retval",

	      "progname:%s unexpected retval=%d expected=%d\n",

	      prog_name, tattr.retval, retval_expect);

	err = bpf_prog_test_run_opts(prog_fd, &topts);

	ASSERT_OK(err, "test_run");

	ASSERT_EQ(topts.retval, retval_expect, "retval");



	/* Extract MTU that BPF-prog got */

	mtu_result = skel->bss->global_bpf_mtu_tc;

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

+5 −5
Original line number Diff line number Diff line
@@ -161,7 +161,7 @@ static socklen_t prepare_addr(struct sockaddr_storage *addr, int family) 
	}

}



static bool was_decapsulated(struct bpf_prog_test_run_attr *tattr)

static bool was_decapsulated(struct bpf_test_run_opts *tattr)

{

	return tattr->data_size_out < tattr->data_size_in;

}
@@ -367,12 +367,12 @@ static void close_fds(int *fds, int n) 


static void test_cls_redirect_common(struct bpf_program *prog)

{

	struct bpf_prog_test_run_attr tattr = {};

	LIBBPF_OPTS(bpf_test_run_opts, tattr);

	int families[] = { AF_INET, AF_INET6 };

	struct sockaddr_storage ss;

	struct sockaddr *addr;

	socklen_t slen;

	int i, j, err;

	int i, j, err, prog_fd;

	int servers[__NR_KIND][ARRAY_SIZE(families)] = {};

	int conns[__NR_KIND][ARRAY_SIZE(families)] = {};

	struct tuple tuples[__NR_KIND][ARRAY_SIZE(families)];
@@ -394,7 +394,7 @@ static void test_cls_redirect_common(struct bpf_program *prog) 
			goto cleanup;

	}



	tattr.prog_fd = bpf_program__fd(prog);

	prog_fd = bpf_program__fd(prog);

	for (i = 0; i < ARRAY_SIZE(tests); i++) {

		struct test_cfg *test = &tests[i];
@@ -415,7 +415,7 @@ static void test_cls_redirect_common(struct bpf_program *prog) 
			if (CHECK_FAIL(!tattr.data_size_in))

				continue;



			err = bpf_prog_test_run_xattr(&tattr);

			err = bpf_prog_test_run_opts(prog_fd, &tattr);

			if (CHECK_FAIL(err))

				continue;

tools/testing/selftests/bpf/prog_tests/dummy_st_ops.c

+12 −15
Original line number Diff line number Diff line
@@ -26,10 +26,10 @@ static void test_dummy_st_ops_attach(void) 
static void test_dummy_init_ret_value(void)

{

	__u64 args[1] = {0};

	struct bpf_prog_test_run_attr attr = {

		.ctx_size_in = sizeof(args),

	LIBBPF_OPTS(bpf_test_run_opts, attr,

		.ctx_in = args,

	};

		.ctx_size_in = sizeof(args),

	);

	struct dummy_st_ops *skel;

	int fd, err;
@@ -38,8 +38,7 @@ static void test_dummy_init_ret_value(void) 
		return;



	fd = bpf_program__fd(skel->progs.test_1);

	attr.prog_fd = fd;

	err = bpf_prog_test_run_xattr(&attr);

	err = bpf_prog_test_run_opts(fd, &attr);

	ASSERT_OK(err, "test_run");

	ASSERT_EQ(attr.retval, 0xf2f3f4f5, "test_ret");
@@ -53,10 +52,10 @@ static void test_dummy_init_ptr_arg(void) 
		.val = exp_retval,

	};

	__u64 args[1] = {(unsigned long)&in_state};

	struct bpf_prog_test_run_attr attr = {

		.ctx_size_in = sizeof(args),

	LIBBPF_OPTS(bpf_test_run_opts, attr,

		.ctx_in = args,

	};

		.ctx_size_in = sizeof(args),

	);

	struct dummy_st_ops *skel;

	int fd, err;
@@ -65,8 +64,7 @@ static void test_dummy_init_ptr_arg(void) 
		return;



	fd = bpf_program__fd(skel->progs.test_1);

	attr.prog_fd = fd;

	err = bpf_prog_test_run_xattr(&attr);

	err = bpf_prog_test_run_opts(fd, &attr);

	ASSERT_OK(err, "test_run");

	ASSERT_EQ(in_state.val, 0x5a, "test_ptr_ret");

	ASSERT_EQ(attr.retval, exp_retval, "test_ret");
@@ -77,10 +75,10 @@ static void test_dummy_init_ptr_arg(void) 
static void test_dummy_multiple_args(void)

{

	__u64 args[5] = {0, -100, 0x8a5f, 'c', 0x1234567887654321ULL};

	struct bpf_prog_test_run_attr attr = {

		.ctx_size_in = sizeof(args),

	LIBBPF_OPTS(bpf_test_run_opts, attr,

		.ctx_in = args,

	};

		.ctx_size_in = sizeof(args),

	);

	struct dummy_st_ops *skel;

	int fd, err;

	size_t i;
@@ -91,8 +89,7 @@ static void test_dummy_multiple_args(void) 
		return;



	fd = bpf_program__fd(skel->progs.test_2);

	attr.prog_fd = fd;

	err = bpf_prog_test_run_xattr(&attr);

	err = bpf_prog_test_run_opts(fd, &attr);

	ASSERT_OK(err, "test_run");

	for (i = 0; i < ARRAY_SIZE(args); i++) {

		snprintf(name, sizeof(name), "arg %zu", i);

tools/testing/selftests/bpf/prog_tests/flow_dissector.c

+14 −17
Original line number Diff line number Diff line
@@ -13,8 +13,9 @@ 
#endif



#define CHECK_FLOW_KEYS(desc, got, expected)				\

	CHECK_ATTR(memcmp(&got, &expected, sizeof(got)) != 0,		\

	_CHECK(memcmp(&got, &expected, sizeof(got)) != 0,		\

	      desc,							\

	      topts.duration,						\

	      "nhoff=%u/%u "						\

	      "thoff=%u/%u "						\

	      "addr_proto=0x%x/0x%x "					\
@@ -487,7 +488,7 @@ static void run_tests_skb_less(int tap_fd, struct bpf_map *keys) 
		/* Keep in sync with 'flags' from eth_get_headlen. */

		__u32 eth_get_headlen_flags =

			BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG;

		struct bpf_prog_test_run_attr tattr = {};

		LIBBPF_OPTS(bpf_test_run_opts, topts);

		struct bpf_flow_keys flow_keys = {};

		__u32 key = (__u32)(tests[i].keys.sport) << 16 |

			    tests[i].keys.dport;
@@ -503,13 +504,12 @@ static void run_tests_skb_less(int tap_fd, struct bpf_map *keys) 
		CHECK(err < 0, "tx_tap", "err %d errno %d\n", err, errno);



		err = bpf_map_lookup_elem(keys_fd, &key, &flow_keys);

		CHECK_ATTR(err, tests[i].name, "bpf_map_lookup_elem %d\n", err);

		ASSERT_OK(err, "bpf_map_lookup_elem");



		CHECK_ATTR(err, tests[i].name, "skb-less err %d\n", err);

		CHECK_FLOW_KEYS(tests[i].name, flow_keys, tests[i].keys);



		err = bpf_map_delete_elem(keys_fd, &key);

		CHECK_ATTR(err, tests[i].name, "bpf_map_delete_elem %d\n", err);

		ASSERT_OK(err, "bpf_map_delete_elem");

	}

}
@@ -573,27 +573,24 @@ void test_flow_dissector(void) 


	for (i = 0; i < ARRAY_SIZE(tests); i++) {

		struct bpf_flow_keys flow_keys;

		struct bpf_prog_test_run_attr tattr = {

			.prog_fd = prog_fd,

		LIBBPF_OPTS(bpf_test_run_opts, topts,

			.data_in = &tests[i].pkt,

			.data_size_in = sizeof(tests[i].pkt),

			.data_out = &flow_keys,

		};

		);

		static struct bpf_flow_keys ctx = {};



		if (tests[i].flags) {

			tattr.ctx_in = &ctx;

			tattr.ctx_size_in = sizeof(ctx);

			topts.ctx_in = &ctx;

			topts.ctx_size_in = sizeof(ctx);

			ctx.flags = tests[i].flags;

		}



		err = bpf_prog_test_run_xattr(&tattr);

		CHECK_ATTR(tattr.data_size_out != sizeof(flow_keys) ||

			   err || tattr.retval != 1,

			   tests[i].name,

			   "err %d errno %d retval %d duration %d size %u/%zu\n",

			   err, errno, tattr.retval, tattr.duration,

			   tattr.data_size_out, sizeof(flow_keys));

		err = bpf_prog_test_run_opts(prog_fd, &topts);

		ASSERT_OK(err, "test_run");

		ASSERT_EQ(topts.retval, 1, "test_run retval");

		ASSERT_EQ(topts.data_size_out, sizeof(flow_keys),

			  "test_run data_size_out");

		CHECK_FLOW_KEYS(tests[i].name, flow_keys, tests[i].keys);

	}

tools/testing/selftests/bpf/prog_tests/kfree_skb.c

+7 −9
Original line number Diff line number Diff line
@@ -53,24 +53,24 @@ static void on_sample(void *ctx, int cpu, void *data, __u32 size) 
void serial_test_kfree_skb(void)

{

	struct __sk_buff skb = {};

	struct bpf_prog_test_run_attr tattr = {

	LIBBPF_OPTS(bpf_test_run_opts, topts,

		.data_in = &pkt_v6,

		.data_size_in = sizeof(pkt_v6),

		.ctx_in = &skb,

		.ctx_size_in = sizeof(skb),

	};

	);

	struct kfree_skb *skel = NULL;

	struct bpf_link *link;

	struct bpf_object *obj;

	struct perf_buffer *pb = NULL;

	int err;

	int err, prog_fd;

	bool passed = false;

	__u32 duration = 0;

	const int zero = 0;

	bool test_ok[2];



	err = bpf_prog_test_load("./test_pkt_access.o", BPF_PROG_TYPE_SCHED_CLS,

			    &obj, &tattr.prog_fd);

				 &obj, &prog_fd);

	if (CHECK(err, "prog_load sched cls", "err %d errno %d\n", err, errno))

		return;
@@ -100,11 +100,9 @@ void serial_test_kfree_skb(void) 
		goto close_prog;



	memcpy(skb.cb, &cb, sizeof(cb));

	err = bpf_prog_test_run_xattr(&tattr);

	duration = tattr.duration;

	CHECK(err || tattr.retval, "ipv6",

	      "err %d errno %d retval %d duration %d\n",

	      err, errno, tattr.retval, duration);

	err = bpf_prog_test_run_opts(prog_fd, &topts);

	ASSERT_OK(err, "ipv6 test_run");

	ASSERT_OK(topts.retval, "ipv6 test_run retval");



	/* read perf buffer */

	err = perf_buffer__poll(pb, 100);