Commit edb996fa authored by Bastien Curutchet (eBPF Foundation)'s avatar Bastien Curutchet (eBPF Foundation) Committed by Alexei Starovoitov
Browse files

selftests/bpf: test_xdp_veth: Add prog_config[] table 



The BPF program attached to each veth is hardcoded through the
use of the struct skeletons. It prevents from re-using the initialization
code in new test cases.

Replace the struct skeletons by a bpf_object table.
Add a struct prog_configuration that holds the name of BPF program to
load on a given veth pair.
Use bpf_object__find_program_by_name() / bpf_xdp_attach() API instead of
bpf_program__attach_xdp() to retrieve the BPF programs from their names.
Detach BPF progs in the cleanup() as it's not automatically done by this
API.

Signed-off-by: default avatarBastien Curutchet (eBPF Foundation) <bastien.curutchet@bootlin.com>
Signed-off-by: default avatarMartin KaFai Lau <martin.lau@kernel.org>
Acked-by: default avatarStanislav Fomichev <sdf@fomichev.me>
Link: https://patch.msgid.link/20250131-redirect-multi-v4-7-970b33678512@bootlin.com


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

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

+80 −53
Original line number Diff line number Diff line
@@ -38,12 +38,7 @@ 
#define VETH_NAME_MAX_LEN	16

#define IP_SRC				"10.1.1.11"

#define IP_DST				"10.1.1.33"



struct skeletons {

	struct xdp_dummy *xdp_dummy;

	struct xdp_tx *xdp_tx;

	struct xdp_redirect_map *xdp_redirect_maps;

};

#define PROG_NAME_MAX_LEN	128



struct veth_configuration {

	char local_veth[VETH_NAME_MAX_LEN]; /* Interface in main namespace */
@@ -77,55 +72,59 @@ static struct veth_configuration net_config[VETH_PAIRS_COUNT] = { 
	}

};



static int attach_programs_to_veth_pair(struct skeletons *skeletons, int index)

struct prog_configuration {

	char local_name[PROG_NAME_MAX_LEN]; /* BPF prog to attach to local_veth */

	char remote_name[PROG_NAME_MAX_LEN]; /* BPF prog to attach to remote_veth */

};



static int attach_programs_to_veth_pair(struct bpf_object **objs, size_t nb_obj,

					struct prog_configuration *prog, int index)

{

	struct bpf_program *local_prog, *remote_prog;

	struct bpf_link **local_link, **remote_link;

	struct nstoken *nstoken;

	struct bpf_link *link;

	int interface;



	switch (index) {

	case 0:

		local_prog = skeletons->xdp_redirect_maps->progs.xdp_redirect_map_0;

		local_link = &skeletons->xdp_redirect_maps->links.xdp_redirect_map_0;

		remote_prog = skeletons->xdp_dummy->progs.xdp_dummy_prog;

		remote_link = &skeletons->xdp_dummy->links.xdp_dummy_prog;

		break;

	case 1:

		local_prog = skeletons->xdp_redirect_maps->progs.xdp_redirect_map_1;

		local_link = &skeletons->xdp_redirect_maps->links.xdp_redirect_map_1;

		remote_prog = skeletons->xdp_tx->progs.xdp_tx;

		remote_link = &skeletons->xdp_tx->links.xdp_tx;

	int interface, ret, i;



	for (i = 0; i < nb_obj; i++) {

		local_prog = bpf_object__find_program_by_name(objs[i], prog[index].local_name);

		if (local_prog)

			break;

	case 2:

		local_prog = skeletons->xdp_redirect_maps->progs.xdp_redirect_map_2;

		local_link = &skeletons->xdp_redirect_maps->links.xdp_redirect_map_2;

		remote_prog = skeletons->xdp_dummy->progs.xdp_dummy_prog;

		remote_link = &skeletons->xdp_dummy->links.xdp_dummy_prog;

	}

	if (!ASSERT_OK_PTR(local_prog, "find local program"))

		return -1;



	for (i = 0; i < nb_obj; i++) {

		remote_prog = bpf_object__find_program_by_name(objs[i], prog[index].remote_name);

		if (remote_prog)

			break;

	}

	if (!ASSERT_OK_PTR(remote_prog, "find remote program"))

		return -1;



	interface = if_nametoindex(net_config[index].local_veth);

	if (!ASSERT_NEQ(interface, 0, "non zero interface index"))

		return -1;

	link = bpf_program__attach_xdp(local_prog, interface);

	if (!ASSERT_OK_PTR(link, "attach xdp program to local veth"))



	ret = bpf_xdp_attach(interface, bpf_program__fd(local_prog), 0, NULL);

	if (!ASSERT_OK(ret, "attach xdp program to local veth"))

		return -1;

	*local_link = link;



	nstoken = open_netns(net_config[index].namespace);

	if (!ASSERT_OK_PTR(nstoken, "switch to remote veth namespace"))

		return -1;



	interface = if_nametoindex(net_config[index].remote_veth);

	if (!ASSERT_NEQ(interface, 0, "non zero interface index")) {

		close_netns(nstoken);

		return -1;

	}

	link = bpf_program__attach_xdp(remote_prog, interface);

	*remote_link = link;



	ret = bpf_xdp_attach(interface, bpf_program__fd(remote_prog), 0, NULL);

	if (!ASSERT_OK(ret, "attach xdp program to remote veth")) {

		close_netns(nstoken);

	if (!ASSERT_OK_PTR(link, "attach xdp program to remote veth"))

		return -1;

	}



	close_netns(nstoken);

	return 0;

}
@@ -150,45 +149,73 @@ static int create_network(void) 


fail:

	return -1;



}



static void cleanup_network(void)

{

	struct nstoken *nstoken;

	int i;



	/* Deleting namespaces is enough to automatically remove veth pairs as well

	 */

	for (i = 0; i < VETH_PAIRS_COUNT; i++)

	for (i = 0; i < VETH_PAIRS_COUNT; i++) {

		bpf_xdp_detach(if_nametoindex(net_config[i].local_veth), 0, NULL);

		nstoken = open_netns(net_config[i].namespace);

		if (nstoken) {

			bpf_xdp_detach(if_nametoindex(net_config[i].remote_veth), 0, NULL);

			close_netns(nstoken);

		}

		/* in case the detach failed */

		SYS_NOFAIL("ip link del %s", net_config[i].local_veth);

		SYS_NOFAIL("ip netns del %s", net_config[i].namespace);

	}

}



#define VETH_REDIRECT_SKEL_NB	3

void test_xdp_veth_redirect(void)

{

	struct skeletons skeletons = {};

	struct prog_configuration ping_config[VETH_PAIRS_COUNT] = {

		{

			.local_name = "xdp_redirect_map_0",

			.remote_name = "xdp_dummy_prog",

		},

		{

			.local_name = "xdp_redirect_map_1",

			.remote_name = "xdp_tx",

		},

		{

			.local_name = "xdp_redirect_map_2",

			.remote_name = "xdp_dummy_prog",

		}

	};

	struct bpf_object *bpf_objs[VETH_REDIRECT_SKEL_NB];

	struct xdp_redirect_map *xdp_redirect_map;

	struct xdp_dummy *xdp_dummy;

	struct xdp_tx *xdp_tx;

	int map_fd;

	int i;



	skeletons.xdp_dummy = xdp_dummy__open_and_load();

	if (!ASSERT_OK_PTR(skeletons.xdp_dummy, "xdp_dummy__open_and_load"))

	xdp_dummy = xdp_dummy__open_and_load();

	if (!ASSERT_OK_PTR(xdp_dummy, "xdp_dummy__open_and_load"))

		return;



	skeletons.xdp_tx = xdp_tx__open_and_load();

	if (!ASSERT_OK_PTR(skeletons.xdp_tx, "xdp_tx__open_and_load"))

	xdp_tx = xdp_tx__open_and_load();

	if (!ASSERT_OK_PTR(xdp_tx, "xdp_tx__open_and_load"))

		goto destroy_xdp_dummy;



	skeletons.xdp_redirect_maps = xdp_redirect_map__open_and_load();

	if (!ASSERT_OK_PTR(skeletons.xdp_redirect_maps, "xdp_redirect_map__open_and_load"))

	xdp_redirect_map = xdp_redirect_map__open_and_load();

	if (!ASSERT_OK_PTR(xdp_redirect_map, "xdp_redirect_map__open_and_load"))

		goto destroy_xdp_tx;



	if (!ASSERT_OK(create_network(), "create_network"))

		goto destroy_xdp_redirect_map;



	/* Then configure the redirect map and attach programs to interfaces */

	map_fd = bpf_map__fd(skeletons.xdp_redirect_maps->maps.tx_port);

	map_fd = bpf_map__fd(xdp_redirect_map->maps.tx_port);

	if (!ASSERT_OK_FD(map_fd, "open redirect map"))

		goto destroy_xdp_redirect_map;



	bpf_objs[0] = xdp_dummy->obj;

	bpf_objs[1] = xdp_tx->obj;

	bpf_objs[2] = xdp_redirect_map->obj;

	for (i = 0; i < VETH_PAIRS_COUNT; i++) {

		int next_veth = net_config[i].next_veth;

		int interface_id;
@@ -200,7 +227,7 @@ void test_xdp_veth_redirect(void) 
		err = bpf_map_update_elem(map_fd, &i, &interface_id, BPF_ANY);

		if (!ASSERT_OK(err, "configure interface redirection through map"))

			goto destroy_xdp_redirect_map;

		if (attach_programs_to_veth_pair(&skeletons, i))

		if (attach_programs_to_veth_pair(bpf_objs, VETH_REDIRECT_SKEL_NB, ping_config, i))

			goto destroy_xdp_redirect_map;

	}
@@ -211,11 +238,11 @@ void test_xdp_veth_redirect(void) 
			     net_config[0].namespace, IP_DST), "ping");



destroy_xdp_redirect_map:

	xdp_redirect_map__destroy(skeletons.xdp_redirect_maps);

	xdp_redirect_map__destroy(xdp_redirect_map);

destroy_xdp_tx:

	xdp_tx__destroy(skeletons.xdp_tx);

	xdp_tx__destroy(xdp_tx);

destroy_xdp_dummy:

	xdp_dummy__destroy(skeletons.xdp_dummy);

	xdp_dummy__destroy(xdp_dummy);



	cleanup_network();

}