Commit 0fc6025c authored by Martin KaFai Lau's avatar Martin KaFai Lau
Browse files

Merge branch 'selftests-bpf-migrate-test_xdp_redirect_multi-sh-to-test_progs' 

Bastien Curutchet says:

====================
This patch series continues the work to migrate the *.sh tests into
prog_tests framework.

test_xdp_redirect_multi.sh tests the XDP redirections done through
bpf_redirect_map().

This is already partly covered by test_xdp_veth.c that already tests
map redirections at XDP level. What isn't covered yet by test_xdp_veth is
the use of the broadcast flags (BPF_F_BROADCAST or BPF_F_EXCLUDE_INGRESS)
and XDP egress programs.

Hence, this patch series add test cases to test_xdp_veth.c to get rid of
the test_xdp_redirect_multi.sh:
 - PATCH 1 & 2 Rework test_xdp_veth.c to avoid using the root namespace
 - PATCH 3 and 4 cover the broadcast flags
 - PATCH 5 covers the XDP egress programs

NOTE: While working on this iteration I ran into a memory leak in
net/core/rtnetlink.c that leads to oom-kill when running ./test_progs in
a loop. This leak has been fixed by commit 1438f5d0 ("rtnetlink:
fix netns leak with rtnl_setlink()") in the net tree.
====================

Link: https://patch.msgid.link/20250212-redirect-multi-v5-0-fd0d39fca6e6@bootlin.com


Signed-off-by: default avatarMartin KaFai Lau <martin.lau@kernel.org>
parents 50b77eb5 e06f5bfd

tools/testing/selftests/bpf/Makefile

+0 −2
Original line number Diff line number Diff line
@@ -100,7 +100,6 @@ TEST_FILES = xsk_prereqs.sh $(wildcard progs/btf_dump_test_case_*.c) 


# Order correspond to 'make run_tests' order

TEST_PROGS := test_kmod.sh \

	test_xdp_redirect_multi.sh \

	test_tunnel.sh \

	test_lwt_seg6local.sh \

	test_lirc_mode2.sh \
@@ -135,7 +134,6 @@ TEST_GEN_PROGS_EXTENDED = \ 
	veristat \

	xdp_features \

	xdp_hw_metadata \

	xdp_redirect_multi \

	xdp_synproxy \

	xdping \

	xskxceiver

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

+374 −61
Original line number Diff line number Diff line
@@ -9,7 +9,11 @@ 
 *  | veth11 |        | veth22 |       | veth33 |

 *  ----|-----        -----|----       -----|----

 *      |                  |                |

 *    veth1              veth2            veth3

 *  ----|------------------|----------------|----

 *  | veth1              veth2            veth3 |

 *  |                                           |

 *  |                     NSO                   |

 *  ---------------------------------------------

 *

 * Test cases:

 *  - [test_xdp_veth_redirect] : ping veth33 from veth11
@@ -24,6 +28,25 @@ 
 *      | |                | |                | |

 *      | ------------------ ------------------ |

 *      -----------------------------------------

 *

 * - [test_xdp_veth_broadcast_redirect]: broadcast from veth11

 *     - IPv4 ping : BPF_F_BROADCAST | BPF_F_EXCLUDE_INGRESS

 *          -> echo request received by all except veth11

 *     - IPv4 ping : BPF_F_BROADCAST

 *          -> echo request received by all veth

 * - [test_xdp_veth_egress]:

 *     - all src mac should be the magic mac

 *

 *    veth11             veth22              veth33

 *  (XDP_PASS)         (XDP_PASS)          (XDP_PASS)

 *       |                  |                  |

 *       |                  |                  |

 *     veth1		  veth2              veth3

 * (XDP_REDIRECT)     (XDP_REDIRECT)     (XDP_REDIRECT)

 *      |                   ^                  ^

 *      |                   |                  |

 *      ----------------------------------------

 *

 */



#define _GNU_SOURCE
@@ -32,6 +55,7 @@ 
#include "network_helpers.h"

#include "xdp_dummy.skel.h"

#include "xdp_redirect_map.skel.h"

#include "xdp_redirect_multi_kern.skel.h"

#include "xdp_tx.skel.h"

#include <uapi/linux/if_link.h>
@@ -40,6 +64,7 @@ 
#define IP_MAX_LEN		16

#define IP_SRC				"10.1.1.11"

#define IP_DST				"10.1.1.33"

#define IP_NEIGH			"10.1.1.253"

#define PROG_NAME_MAX_LEN	128

#define NS_NAME_MAX_LEN		32
@@ -51,7 +76,14 @@ struct veth_configuration { 
	char remote_addr[IP_MAX_LEN]; /* IP address of the remote veth */

};



static const struct veth_configuration default_config[VETH_PAIRS_COUNT] = {

struct net_configuration {

	char ns0_name[NS_NAME_MAX_LEN];

	struct veth_configuration veth_cfg[VETH_PAIRS_COUNT];

};



static const struct net_configuration default_config = {

	.ns0_name = "ns0-",

	{

		{

			.local_veth = "veth1-",

			.remote_veth = "veth11",
@@ -73,6 +105,7 @@ static const struct veth_configuration default_config[VETH_PAIRS_COUNT] = { 
			.remote_addr = IP_DST,

			.namespace = "ns-veth33-"

		}

	}

};



struct prog_configuration {
@@ -83,7 +116,7 @@ struct prog_configuration { 
};



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

					struct veth_configuration *net_config,

					struct net_configuration *net_config,

					struct prog_configuration *prog, int index)

{

	struct bpf_program *local_prog, *remote_prog;
@@ -106,7 +139,7 @@ static int attach_programs_to_veth_pair(struct bpf_object **objs, size_t nb_obj, 
	if (!ASSERT_OK_PTR(remote_prog, "find remote program"))

		return -1;



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

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

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

		return -1;
@@ -115,11 +148,11 @@ static int attach_programs_to_veth_pair(struct bpf_object **objs, size_t nb_obj, 
	if (!ASSERT_OK(ret, "attach xdp program to local veth"))

		return -1;



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

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

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

		return -1;



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

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

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

		close_netns(nstoken);

		return -1;
@@ -136,55 +169,60 @@ static int attach_programs_to_veth_pair(struct bpf_object **objs, size_t nb_obj, 
	return 0;

}



static int create_network(struct veth_configuration *net_config)

static int create_network(struct net_configuration *net_config)

{

	struct nstoken *nstoken = NULL;

	int i, err;



	memcpy(net_config, default_config, VETH_PAIRS_COUNT * sizeof(struct veth_configuration));

	memcpy(net_config, &default_config, sizeof(struct net_configuration));



	/* Create unique namespaces */

	err = append_tid(net_config->ns0_name, NS_NAME_MAX_LEN);

	if (!ASSERT_OK(err, "append TID to ns0 name"))

		goto fail;

	SYS(fail, "ip netns add %s", net_config->ns0_name);



	/* First create and configure all interfaces */

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

		err = append_tid(net_config[i].namespace, NS_NAME_MAX_LEN);

		err = append_tid(net_config->veth_cfg[i].namespace, NS_NAME_MAX_LEN);

		if (!ASSERT_OK(err, "append TID to ns name"))

			return -1;

			goto fail;

		SYS(fail, "ip netns add %s", net_config->veth_cfg[i].namespace);

	}



		err = append_tid(net_config[i].local_veth, VETH_NAME_MAX_LEN);

		if (!ASSERT_OK(err, "append TID to local veth name"))

			return -1;

	/* Create interfaces */

	nstoken = open_netns(net_config->ns0_name);

	if (!nstoken)

		goto fail;



		SYS(fail, "ip netns add %s", net_config[i].namespace);

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

		SYS(fail, "ip link add %s type veth peer name %s netns %s",

		    net_config[i].local_veth, net_config[i].remote_veth, net_config[i].namespace);

		SYS(fail, "ip link set dev %s up", net_config[i].local_veth);

		if (net_config[i].remote_addr[0])

			SYS(fail, "ip -n %s addr add %s/24 dev %s",	net_config[i].namespace,

			    net_config[i].remote_addr, net_config[i].remote_veth);

		SYS(fail, "ip -n %s link set dev %s up", net_config[i].namespace,

		    net_config[i].remote_veth);

		    net_config->veth_cfg[i].local_veth, net_config->veth_cfg[i].remote_veth,

		    net_config->veth_cfg[i].namespace);

		SYS(fail, "ip link set dev %s up", net_config->veth_cfg[i].local_veth);

		if (net_config->veth_cfg[i].remote_addr[0])

			SYS(fail, "ip -n %s addr add %s/24 dev %s",

			    net_config->veth_cfg[i].namespace,

			    net_config->veth_cfg[i].remote_addr,

			    net_config->veth_cfg[i].remote_veth);

		SYS(fail, "ip -n %s link set dev %s up", net_config->veth_cfg[i].namespace,

		    net_config->veth_cfg[i].remote_veth);

	}



	close_netns(nstoken);

	return 0;



fail:

	close_netns(nstoken);

	return -1;

}



static void cleanup_network(struct veth_configuration *net_config)

static void cleanup_network(struct net_configuration *net_config)

{

	struct nstoken *nstoken;

	int 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);

	}

	SYS_NOFAIL("ip netns del %s", net_config->ns0_name);

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

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

}



#define VETH_REDIRECT_SKEL_NB	3
@@ -210,9 +248,10 @@ static void xdp_veth_redirect(u32 flags) 
			.remote_flags = flags,

		}

	};

	struct veth_configuration net_config[VETH_PAIRS_COUNT];

	struct bpf_object *bpf_objs[VETH_REDIRECT_SKEL_NB];

	struct xdp_redirect_map *xdp_redirect_map;

	struct net_configuration net_config;

	struct nstoken *nstoken = NULL;

	struct xdp_dummy *xdp_dummy;

	struct xdp_tx *xdp_tx;

	int map_fd;
@@ -230,7 +269,7 @@ static void xdp_veth_redirect(u32 flags) 
	if (!ASSERT_OK_PTR(xdp_redirect_map, "xdp_redirect_map__open_and_load"))

		goto destroy_xdp_tx;



	if (!ASSERT_OK(create_network(net_config), "create network"))

	if (!ASSERT_OK(create_network(&net_config), "create network"))

		goto destroy_xdp_redirect_map;



	/* Then configure the redirect map and attach programs to interfaces */
@@ -241,19 +280,24 @@ static void xdp_veth_redirect(u32 flags) 
	bpf_objs[0] = xdp_dummy->obj;

	bpf_objs[1] = xdp_tx->obj;

	bpf_objs[2] = xdp_redirect_map->obj;



	nstoken = open_netns(net_config.ns0_name);

	if (!ASSERT_OK_PTR(nstoken, "open NS0"))

		goto destroy_xdp_redirect_map;



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

		int next_veth = net_config[i].next_veth;

		int next_veth = net_config.veth_cfg[i].next_veth;

		int interface_id;

		int err;



		interface_id = if_nametoindex(net_config[next_veth].local_veth);

		interface_id = if_nametoindex(net_config.veth_cfg[next_veth].local_veth);

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

			goto destroy_xdp_redirect_map;

		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(bpf_objs, VETH_REDIRECT_SKEL_NB,

						 net_config, ping_config, i))

						 &net_config, ping_config, i))

			goto destroy_xdp_redirect_map;

	}
@@ -261,16 +305,250 @@ static void xdp_veth_redirect(u32 flags) 
	 * veth33 from veth11

	 */

	ASSERT_OK(SYS_NOFAIL("ip netns exec %s ping -c 1 -W 1 %s > /dev/null",

			     net_config[0].namespace, IP_DST), "ping");

			     net_config.veth_cfg[0].namespace, IP_DST), "ping");



destroy_xdp_redirect_map:

	close_netns(nstoken);

	xdp_redirect_map__destroy(xdp_redirect_map);

destroy_xdp_tx:

	xdp_tx__destroy(xdp_tx);

destroy_xdp_dummy:

	xdp_dummy__destroy(xdp_dummy);



	cleanup_network(net_config);

	cleanup_network(&net_config);

}



#define BROADCAST_REDIRECT_SKEL_NB	2

static void xdp_veth_broadcast_redirect(u32 attach_flags, u64 redirect_flags)

{

	struct prog_configuration prog_cfg[VETH_PAIRS_COUNT] = {

		{

			.local_name = "xdp_redirect_map_multi_prog",

			.remote_name = "xdp_count_0",

			.local_flags = attach_flags,

			.remote_flags = attach_flags,

		},

		{

			.local_name = "xdp_redirect_map_multi_prog",

			.remote_name = "xdp_count_1",

			.local_flags = attach_flags,

			.remote_flags = attach_flags,

		},

		{

			.local_name = "xdp_redirect_map_multi_prog",

			.remote_name = "xdp_count_2",

			.local_flags = attach_flags,

			.remote_flags = attach_flags,

		}

	};

	struct bpf_object *bpf_objs[BROADCAST_REDIRECT_SKEL_NB];

	struct xdp_redirect_multi_kern *xdp_redirect_multi_kern;

	struct xdp_redirect_map *xdp_redirect_map;

	struct bpf_devmap_val devmap_val = {};

	struct net_configuration net_config;

	struct nstoken *nstoken = NULL;

	u16 protocol = ETH_P_IP;

	int group_map;

	int flags_map;

	int cnt_map;

	u64 cnt = 0;

	int i, err;



	xdp_redirect_multi_kern = xdp_redirect_multi_kern__open_and_load();

	if (!ASSERT_OK_PTR(xdp_redirect_multi_kern, "xdp_redirect_multi_kern__open_and_load"))

		return;



	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_redirect_multi_kern;



	if (!ASSERT_OK(create_network(&net_config), "create network"))

		goto destroy_xdp_redirect_map;



	group_map = bpf_map__fd(xdp_redirect_multi_kern->maps.map_all);

	if (!ASSERT_OK_FD(group_map, "open map_all"))

		goto destroy_xdp_redirect_map;



	flags_map = bpf_map__fd(xdp_redirect_multi_kern->maps.redirect_flags);

	if (!ASSERT_OK_FD(group_map, "open map_all"))

		goto destroy_xdp_redirect_map;



	err = bpf_map_update_elem(flags_map, &protocol, &redirect_flags, BPF_NOEXIST);

	if (!ASSERT_OK(err, "init IP count"))

		goto destroy_xdp_redirect_map;



	cnt_map = bpf_map__fd(xdp_redirect_map->maps.rxcnt);

	if (!ASSERT_OK_FD(cnt_map, "open rxcnt map"))

		goto destroy_xdp_redirect_map;



	bpf_objs[0] = xdp_redirect_multi_kern->obj;

	bpf_objs[1] = xdp_redirect_map->obj;



	nstoken = open_netns(net_config.ns0_name);

	if (!ASSERT_OK_PTR(nstoken, "open NS0"))

		goto destroy_xdp_redirect_map;



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

		int ifindex = if_nametoindex(net_config.veth_cfg[i].local_veth);



		if (attach_programs_to_veth_pair(bpf_objs, BROADCAST_REDIRECT_SKEL_NB,

						 &net_config, prog_cfg, i))

			goto destroy_xdp_redirect_map;



		SYS(destroy_xdp_redirect_map,

		    "ip -n %s neigh add %s lladdr 00:00:00:00:00:01 dev %s",

		    net_config.veth_cfg[i].namespace, IP_NEIGH, net_config.veth_cfg[i].remote_veth);



		devmap_val.ifindex = ifindex;

		err = bpf_map_update_elem(group_map, &ifindex, &devmap_val, 0);

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

			goto destroy_xdp_redirect_map;



	}



	SYS_NOFAIL("ip netns exec %s ping %s -i 0.1 -c 4 -W1 > /dev/null ",

		    net_config.veth_cfg[0].namespace, IP_NEIGH);



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

		err =  bpf_map_lookup_elem(cnt_map, &i, &cnt);

		if (!ASSERT_OK(err, "get IP cnt"))

			goto destroy_xdp_redirect_map;



		if (redirect_flags & BPF_F_EXCLUDE_INGRESS)

			/* veth11 shouldn't receive the ICMP requests;

			 * others should

			 */

			ASSERT_EQ(cnt, i ? 4 : 0, "compare IP cnt");

		else

			/* All remote veth should receive the ICMP requests */

			ASSERT_EQ(cnt, 4, "compare IP cnt");

	}



destroy_xdp_redirect_map:

	close_netns(nstoken);

	xdp_redirect_map__destroy(xdp_redirect_map);

destroy_xdp_redirect_multi_kern:

	xdp_redirect_multi_kern__destroy(xdp_redirect_multi_kern);



	cleanup_network(&net_config);

}



#define VETH_EGRESS_SKEL_NB	3

static void xdp_veth_egress(u32 flags)

{

	struct prog_configuration prog_cfg[VETH_PAIRS_COUNT] = {

		{

			.local_name = "xdp_redirect_map_all_prog",

			.remote_name = "xdp_dummy_prog",

			.local_flags = flags,

			.remote_flags = flags,

		},

		{

			.local_name = "xdp_redirect_map_all_prog",

			.remote_name = "store_mac_1",

			.local_flags = flags,

			.remote_flags = flags,

		},

		{

			.local_name = "xdp_redirect_map_all_prog",

			.remote_name = "store_mac_2",

			.local_flags = flags,

			.remote_flags = flags,

		}

	};

	const char magic_mac[6] = { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF};

	struct xdp_redirect_multi_kern *xdp_redirect_multi_kern;

	struct bpf_object *bpf_objs[VETH_EGRESS_SKEL_NB];

	struct xdp_redirect_map *xdp_redirect_map;

	struct bpf_devmap_val devmap_val = {};

	struct net_configuration net_config;

	int mac_map, egress_map, res_map;

	struct nstoken *nstoken = NULL;

	struct xdp_dummy *xdp_dummy;

	int err;

	int i;



	xdp_dummy = xdp_dummy__open_and_load();

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

		return;



	xdp_redirect_multi_kern = xdp_redirect_multi_kern__open_and_load();

	if (!ASSERT_OK_PTR(xdp_redirect_multi_kern, "xdp_redirect_multi_kern__open_and_load"))

		goto destroy_xdp_dummy;



	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_redirect_multi_kern;



	if (!ASSERT_OK(create_network(&net_config), "create network"))

		goto destroy_xdp_redirect_map;



	mac_map = bpf_map__fd(xdp_redirect_multi_kern->maps.mac_map);

	if (!ASSERT_OK_FD(mac_map, "open mac_map"))

		goto destroy_xdp_redirect_map;



	egress_map = bpf_map__fd(xdp_redirect_multi_kern->maps.map_egress);

	if (!ASSERT_OK_FD(egress_map, "open map_egress"))

		goto destroy_xdp_redirect_map;



	devmap_val.bpf_prog.fd = bpf_program__fd(xdp_redirect_multi_kern->progs.xdp_devmap_prog);



	bpf_objs[0] = xdp_dummy->obj;

	bpf_objs[1] = xdp_redirect_multi_kern->obj;

	bpf_objs[2] = xdp_redirect_map->obj;



	nstoken = open_netns(net_config.ns0_name);

	if (!ASSERT_OK_PTR(nstoken, "open NS0"))

		goto destroy_xdp_redirect_map;



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

		int ifindex = if_nametoindex(net_config.veth_cfg[i].local_veth);



		SYS(destroy_xdp_redirect_map,

		    "ip -n %s neigh add %s lladdr 00:00:00:00:00:01 dev %s",

		    net_config.veth_cfg[i].namespace, IP_NEIGH, net_config.veth_cfg[i].remote_veth);



		if (attach_programs_to_veth_pair(bpf_objs, VETH_REDIRECT_SKEL_NB,

						 &net_config, prog_cfg, i))

			goto destroy_xdp_redirect_map;



		err = bpf_map_update_elem(mac_map, &ifindex, magic_mac, 0);

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

			goto destroy_xdp_redirect_map;



		devmap_val.ifindex = ifindex;

		err = bpf_map_update_elem(egress_map, &ifindex, &devmap_val, 0);

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

			goto destroy_xdp_redirect_map;

	}



	SYS_NOFAIL("ip netns exec %s ping %s -i 0.1 -c 4 -W1 > /dev/null ",

		    net_config.veth_cfg[0].namespace, IP_NEIGH);



	res_map = bpf_map__fd(xdp_redirect_map->maps.rx_mac);

	if (!ASSERT_OK_FD(res_map, "open rx_map"))

		goto destroy_xdp_redirect_map;



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

		u32 key = i;

		u64 res;



		err = bpf_map_lookup_elem(res_map, &key, &res);

		if (!ASSERT_OK(err, "get MAC res"))

			goto destroy_xdp_redirect_map;



		ASSERT_STRNEQ((const char *)&res, magic_mac, ETH_ALEN, "compare mac");

	}



destroy_xdp_redirect_map:

	close_netns(nstoken);

	xdp_redirect_map__destroy(xdp_redirect_map);

destroy_xdp_redirect_multi_kern:

	xdp_redirect_multi_kern__destroy(xdp_redirect_multi_kern);

destroy_xdp_dummy:

	xdp_dummy__destroy(xdp_dummy);



	cleanup_network(&net_config);

}



void test_xdp_veth_redirect(void)
@@ -284,3 +562,38 @@ void test_xdp_veth_redirect(void) 
	if (test__start_subtest("SKB_MODE"))

		xdp_veth_redirect(XDP_FLAGS_SKB_MODE);

}



void test_xdp_veth_broadcast_redirect(void)

{

	if (test__start_subtest("0/BROADCAST"))

		xdp_veth_broadcast_redirect(0, BPF_F_BROADCAST);



	if (test__start_subtest("0/(BROADCAST | EXCLUDE_INGRESS)"))

		xdp_veth_broadcast_redirect(0, BPF_F_BROADCAST | BPF_F_EXCLUDE_INGRESS);



	if (test__start_subtest("DRV_MODE/BROADCAST"))

		xdp_veth_broadcast_redirect(XDP_FLAGS_DRV_MODE, BPF_F_BROADCAST);



	if (test__start_subtest("DRV_MODE/(BROADCAST | EXCLUDE_INGRESS)"))

		xdp_veth_broadcast_redirect(XDP_FLAGS_DRV_MODE,

					    BPF_F_BROADCAST | BPF_F_EXCLUDE_INGRESS);



	if (test__start_subtest("SKB_MODE/BROADCAST"))

		xdp_veth_broadcast_redirect(XDP_FLAGS_SKB_MODE, BPF_F_BROADCAST);



	if (test__start_subtest("SKB_MODE/(BROADCAST | EXCLUDE_INGRESS)"))

		xdp_veth_broadcast_redirect(XDP_FLAGS_SKB_MODE,

					    BPF_F_BROADCAST | BPF_F_EXCLUDE_INGRESS);

}



void test_xdp_veth_egress(void)

{

	if (test__start_subtest("0/egress"))

		xdp_veth_egress(0);



	if (test__start_subtest("DRV_MODE/egress"))

		xdp_veth_egress(XDP_FLAGS_DRV_MODE);



	if (test__start_subtest("SKB_MODE/egress"))

		xdp_veth_egress(XDP_FLAGS_SKB_MODE);

}

tools/testing/selftests/bpf/progs/xdp_redirect_map.c

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



#include <linux/if_ether.h>



#include <linux/bpf.h>

#include <bpf/bpf_helpers.h>

#include <bpf/bpf_endian.h>



struct {

	__uint(type, BPF_MAP_TYPE_DEVMAP);
@@ -28,4 +31,89 @@ int xdp_redirect_map_2(struct xdp_md *xdp) 
	return bpf_redirect_map(&tx_port, 2, 0);

}



struct {

	__uint(type, BPF_MAP_TYPE_ARRAY);

	__uint(max_entries, 3);

	__type(key, __u32);

	__type(value, __u64);

} rxcnt SEC(".maps");



static int xdp_count(struct xdp_md *xdp, __u32 key)

{

	void *data_end = (void *)(long)xdp->data_end;

	void *data = (void *)(long)xdp->data;

	struct ethhdr *eth = data;

	__u64 *count;



	if (data + sizeof(*eth) > data_end)

		return XDP_DROP;



	if (bpf_htons(eth->h_proto) == ETH_P_IP) {

		/* We only count IPv4 packets */

		count = bpf_map_lookup_elem(&rxcnt, &key);

		if (count)

			*count += 1;

	}



	return XDP_PASS;

}



SEC("xdp")

int xdp_count_0(struct xdp_md *xdp)

{

	return xdp_count(xdp, 0);

}



SEC("xdp")

int xdp_count_1(struct xdp_md *xdp)

{

	return xdp_count(xdp, 1);

}



SEC("xdp")

int xdp_count_2(struct xdp_md *xdp)

{

	return xdp_count(xdp, 2);

}



struct {

	__uint(type, BPF_MAP_TYPE_ARRAY);

	__uint(max_entries, 2);

	__type(key, __u32);

	__type(value, __be64);

} rx_mac SEC(".maps");



static int store_mac(struct xdp_md *xdp, __u32 id)

{

	void *data_end = (void *)(long)xdp->data_end;

	void *data = (void *)(long)xdp->data;

	struct ethhdr *eth = data;

	__u32 key = id;

	__be64 mac = 0;



	if (data + sizeof(*eth) > data_end)

		return XDP_DROP;



	/* Only store IPv4 MAC to avoid being polluted by IPv6 packets */

	if (eth->h_proto == bpf_htons(ETH_P_IP)) {

		__builtin_memcpy(&mac, eth->h_source, ETH_ALEN);

		bpf_map_update_elem(&rx_mac, &key, &mac, 0);

		bpf_printk("%s - %x", __func__, mac);

	}



	return XDP_PASS;

}



SEC("xdp")

int store_mac_1(struct xdp_md *xdp)

{

	return store_mac(xdp, 0);

}



SEC("xdp")

int store_mac_2(struct xdp_md *xdp)

{

	return store_mac(xdp, 1);

}



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

tools/testing/selftests/bpf/progs/xdp_redirect_multi_kern.c

+29 −12
Original line number Diff line number Diff line
@@ -34,6 +34,14 @@ struct { 
	__uint(max_entries, 128);

} mac_map SEC(".maps");



/* map to store redirect flags for each protocol*/

struct {

	__uint(type, BPF_MAP_TYPE_HASH);

	__type(key, __u16);

	__type(value, __u64);

	__uint(max_entries, 16);

} redirect_flags SEC(".maps");



SEC("xdp")

int xdp_redirect_map_multi_prog(struct xdp_md *ctx)

{
@@ -41,25 +49,34 @@ int xdp_redirect_map_multi_prog(struct xdp_md *ctx) 
	void *data = (void *)(long)ctx->data;

	int if_index = ctx->ingress_ifindex;

	struct ethhdr *eth = data;

	__u64 *flags_from_map;

	__u16 h_proto;

	__u64 nh_off;

	__u64 flags;



	nh_off = sizeof(*eth);

	if (data + nh_off > data_end)

		return XDP_DROP;



	h_proto = eth->h_proto;

	h_proto = bpf_htons(eth->h_proto);



	/* Using IPv4 for (BPF_F_BROADCAST | BPF_F_EXCLUDE_INGRESS) testing */

	if (h_proto == bpf_htons(ETH_P_IP))

		return bpf_redirect_map(&map_all, 0,

					BPF_F_BROADCAST | BPF_F_EXCLUDE_INGRESS);

	/* Using IPv6 for none flag testing */

	else if (h_proto == bpf_htons(ETH_P_IPV6))

		return bpf_redirect_map(&map_all, if_index, 0);

	/* All others for BPF_F_BROADCAST testing */

	else

		return bpf_redirect_map(&map_all, 0, BPF_F_BROADCAST);

	flags_from_map = bpf_map_lookup_elem(&redirect_flags, &h_proto);



	/* Default flags for IPv4 : (BPF_F_BROADCAST | BPF_F_EXCLUDE_INGRESS) */

	if (h_proto == ETH_P_IP) {

		flags = flags_from_map ? *flags_from_map : BPF_F_BROADCAST | BPF_F_EXCLUDE_INGRESS;

		return bpf_redirect_map(&map_all, 0, flags);

	}

	/* Default flags for IPv6 : 0 */

	if (h_proto == ETH_P_IPV6) {

		flags = flags_from_map ? *flags_from_map : 0;

		return bpf_redirect_map(&map_all, if_index, flags);

	}

	/* Default flags for others BPF_F_BROADCAST : 0 */

	else {

		flags = flags_from_map ? *flags_from_map : BPF_F_BROADCAST;

		return bpf_redirect_map(&map_all, 0, flags);

	}

}



/* The following 2 progs are for 2nd devmap prog testing */

tools/testing/selftests/bpf/test_xdp_redirect_multi.sh

deleted100755 → 0
+0 −214

File deleted.

Preview size limit exceeded, changes collapsed.