Commit 0d2ec5b5 authored by Alexei Starovoitov's avatar Alexei Starovoitov
Browse files

Merge branch 'share-umem' 



Magnus Karlsson says:

====================
This patch set extends libbpf and the xdpsock sample program to
demonstrate the shared umem mode (XDP_SHARED_UMEM) as well as Rx-only
and Tx-only sockets. This in order for users to have an example to use
as a blue print and also so that these modes will be exercised more
frequently.

Note that the user needs to supply an XDP program with the
XDP_SHARED_UMEM mode that distributes the packets over the sockets
according to some policy. There is an example supplied with the
xdpsock program, but there is no default one in libbpf similarly to
when XDP_SHARED_UMEM is not used. The reason for this is that I felt
that supplying one that would work for all users in this mode is
futile. There are just tons of ways to distribute packets, so whatever
I come up with and build into libbpf would be wrong in most cases.

This patch has been applied against commit 30ee348c ("Merge branch 'bpf-libbpf-fixes'")

Structure of the patch set:

Patch 1: Adds shared umem support to libbpf
Patch 2: Shared umem support and example XPD program added to xdpsock sample
Patch 3: Adds Rx-only and Tx-only support to libbpf
Patch 4: Uses Rx-only sockets for rxdrop and Tx-only sockets for txpush in
         the xdpsock sample
Patch 5: Add documentation entries for these two features
====================

Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parents 472aeb38 57afa8b0

Documentation/networking/af_xdp.rst

+23 −5
Original line number Diff line number Diff line
@@ -295,7 +295,7 @@ round-robin example of distributing packets is shown below: 
   {

	rr = (rr + 1) & (MAX_SOCKS - 1);



	return bpf_redirect_map(&xsks_map, rr, 0);

	return bpf_redirect_map(&xsks_map, rr, XDP_DROP);

   }



Note, that since there is only a single set of FILL and COMPLETION
@@ -304,6 +304,12 @@ to make sure that multiple processes or threads do not use these rings 
concurrently. There are no synchronization primitives in the

libbpf code that protects multiple users at this point in time.



Libbpf uses this mode if you create more than one socket tied to the

same umem. However, note that you need to supply the

XSK_LIBBPF_FLAGS__INHIBIT_PROG_LOAD libbpf_flag with the

xsk_socket__create calls and load your own XDP program as there is no

built in one in libbpf that will route the traffic for you.



XDP_USE_NEED_WAKEUP bind flag

-----------------------------
@@ -355,10 +361,22 @@ to set the size of at least one of the RX and TX rings. If you set 
both, you will be able to both receive and send traffic from your

application, but if you only want to do one of them, you can save

resources by only setting up one of them. Both the FILL ring and the

COMPLETION ring are mandatory if you have a UMEM tied to your socket,

which is the normal case. But if the XDP_SHARED_UMEM flag is used, any

socket after the first one does not have a UMEM and should in that

case not have any FILL or COMPLETION rings created.

COMPLETION ring are mandatory as you need to have a UMEM tied to your

socket. But if the XDP_SHARED_UMEM flag is used, any socket after the

first one does not have a UMEM and should in that case not have any

FILL or COMPLETION rings created as the ones from the shared umem will

be used. Note, that the rings are single-producer single-consumer, so

do not try to access them from multiple processes at the same

time. See the XDP_SHARED_UMEM section.



In libbpf, you can create Rx-only and Tx-only sockets by supplying

NULL to the rx and tx arguments, respectively, to the

xsk_socket__create function.



If you create a Tx-only socket, we recommend that you do not put any

packets on the fill ring. If you do this, drivers might think you are

going to receive something when you in fact will not, and this can

negatively impact performance.



XDP_UMEM_REG setsockopt

-----------------------

samples/bpf/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -167,6 +167,7 @@ always += xdp_sample_pkts_kern.o 
always += ibumad_kern.o

always += hbm_out_kern.o

always += hbm_edt_kern.o

always += xdpsock_kern.o



ifeq ($(ARCH), arm)

# Strip all except -D__LINUX_ARM_ARCH__ option needed to handle linux

samples/bpf/xdpsock.h

0 → 100644
+11 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0

 *

 * Copyright(c) 2019 Intel Corporation.

 */



#ifndef XDPSOCK_H_

#define XDPSOCK_H_



#define MAX_SOCKS 4



#endif /* XDPSOCK_H */

samples/bpf/xdpsock_kern.c

0 → 100644
+24 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

#include <linux/bpf.h>

#include "bpf_helpers.h"

#include "xdpsock.h"



/* This XDP program is only needed for the XDP_SHARED_UMEM mode.

 * If you do not use this mode, libbpf can supply an XDP program for you.

 */



struct {

	__uint(type, BPF_MAP_TYPE_XSKMAP);

	__uint(max_entries, MAX_SOCKS);

	__uint(key_size, sizeof(int));

	__uint(value_size, sizeof(int));

} xsks_map SEC(".maps");



static unsigned int rr;



SEC("xdp_sock") int xdp_sock_prog(struct xdp_md *ctx)

{

	rr = (rr + 1) & (MAX_SOCKS - 1);



	return bpf_redirect_map(&xsks_map, rr, XDP_DROP);

}

samples/bpf/xdpsock_user.c

+116 −42
Original line number Diff line number Diff line
@@ -29,6 +29,7 @@ 


#include "libbpf.h"

#include "xsk.h"

#include "xdpsock.h"

#include <bpf/bpf.h>



#ifndef SOL_XDP
@@ -47,7 +48,6 @@ 
#define BATCH_SIZE 64



#define DEBUG_HEXDUMP 0

#define MAX_SOCKS 8



typedef __u64 u64;

typedef __u32 u32;
@@ -75,7 +75,8 @@ static u32 opt_xdp_bind_flags; 
static int opt_xsk_frame_size = XSK_UMEM__DEFAULT_FRAME_SIZE;

static int opt_timeout = 1000;

static bool opt_need_wakeup = true;

static __u32 prog_id;

static u32 opt_num_xsks = 1;

static u32 prog_id;



struct xsk_umem_info {

	struct xsk_ring_prod fq;
@@ -179,7 +180,7 @@ static void *poller(void *arg) 


static void remove_xdp_program(void)

{

	__u32 curr_prog_id = 0;

	u32 curr_prog_id = 0;



	if (bpf_get_link_xdp_id(opt_ifindex, &curr_prog_id, opt_xdp_flags)) {

		printf("bpf_get_link_xdp_id failed\n");
@@ -196,11 +197,11 @@ static void remove_xdp_program(void) 
static void int_exit(int sig)

{

	struct xsk_umem *umem = xsks[0]->umem->umem;



	(void)sig;

	int i;



	dump_stats();

	xsk_socket__delete(xsks[0]->xsk);

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

		xsk_socket__delete(xsks[i]->xsk);

	(void)xsk_umem__delete(umem);

	remove_xdp_program();
@@ -290,7 +291,6 @@ static struct xsk_umem_info *xsk_configure_umem(void *buffer, u64 size) 
		.frame_headroom = XSK_UMEM__DEFAULT_FRAME_HEADROOM,

		.flags = opt_umem_flags

	};



	int ret;



	umem = calloc(1, sizeof(*umem));
@@ -299,7 +299,6 @@ static struct xsk_umem_info *xsk_configure_umem(void *buffer, u64 size) 


	ret = xsk_umem__create(&umem->umem, buffer, size, &umem->fq, &umem->cq,

			       &cfg);



	if (ret)

		exit_with_error(-ret);
@@ -307,13 +306,29 @@ static struct xsk_umem_info *xsk_configure_umem(void *buffer, u64 size) 
	return umem;

}



static struct xsk_socket_info *xsk_configure_socket(struct xsk_umem_info *umem)

static void xsk_populate_fill_ring(struct xsk_umem_info *umem)

{

	int ret, i;

	u32 idx;



	ret = xsk_ring_prod__reserve(&umem->fq,

				     XSK_RING_PROD__DEFAULT_NUM_DESCS, &idx);

	if (ret != XSK_RING_PROD__DEFAULT_NUM_DESCS)

		exit_with_error(-ret);

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

		*xsk_ring_prod__fill_addr(&umem->fq, idx++) =

			i * opt_xsk_frame_size;

	xsk_ring_prod__submit(&umem->fq, XSK_RING_PROD__DEFAULT_NUM_DESCS);

}



static struct xsk_socket_info *xsk_configure_socket(struct xsk_umem_info *umem,

						    bool rx, bool tx)

{

	struct xsk_socket_config cfg;

	struct xsk_socket_info *xsk;

	struct xsk_ring_cons *rxr;

	struct xsk_ring_prod *txr;

	int ret;

	u32 idx;

	int i;



	xsk = calloc(1, sizeof(*xsk));

	if (!xsk)
@@ -322,11 +337,17 @@ static struct xsk_socket_info *xsk_configure_socket(struct xsk_umem_info *umem) 
	xsk->umem = umem;

	cfg.rx_size = XSK_RING_CONS__DEFAULT_NUM_DESCS;

	cfg.tx_size = XSK_RING_PROD__DEFAULT_NUM_DESCS;

	if (opt_num_xsks > 1)

		cfg.libbpf_flags = XSK_LIBBPF_FLAGS__INHIBIT_PROG_LOAD;

	else

		cfg.libbpf_flags = 0;

	cfg.xdp_flags = opt_xdp_flags;

	cfg.bind_flags = opt_xdp_bind_flags;



	rxr = rx ? &xsk->rx : NULL;

	txr = tx ? &xsk->tx : NULL;

	ret = xsk_socket__create(&xsk->xsk, opt_if, opt_queue, umem->umem,

				 &xsk->rx, &xsk->tx, &cfg);

				 rxr, txr, &cfg);

	if (ret)

		exit_with_error(-ret);
@@ -334,17 +355,6 @@ static struct xsk_socket_info *xsk_configure_socket(struct xsk_umem_info *umem) 
	if (ret)

		exit_with_error(-ret);



	ret = xsk_ring_prod__reserve(&xsk->umem->fq,

				     XSK_RING_PROD__DEFAULT_NUM_DESCS,

				     &idx);

	if (ret != XSK_RING_PROD__DEFAULT_NUM_DESCS)

		exit_with_error(-ret);

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

		*xsk_ring_prod__fill_addr(&xsk->umem->fq, idx++) =

			i * opt_xsk_frame_size;

	xsk_ring_prod__submit(&xsk->umem->fq,

			      XSK_RING_PROD__DEFAULT_NUM_DESCS);



	return xsk;

}
@@ -363,6 +373,7 @@ static struct option long_options[] = { 
	{"frame-size", required_argument, 0, 'f'},

	{"no-need-wakeup", no_argument, 0, 'm'},

	{"unaligned", no_argument, 0, 'u'},

	{"shared-umem", no_argument, 0, 'M'},

	{0, 0, 0, 0}

};
@@ -386,6 +397,7 @@ static void usage(const char *prog) 
		"  -m, --no-need-wakeup Turn off use of driver need wakeup flag.\n"

		"  -f, --frame-size=n   Set the frame size (must be a power of two in aligned mode, default is %d).\n"

		"  -u, --unaligned	Enable unaligned chunk placement\n"

		"  -M, --shared-umem	Enable XDP_SHARED_UMEM\n"

		"\n";

	fprintf(stderr, str, prog, XSK_UMEM__DEFAULT_FRAME_SIZE);

	exit(EXIT_FAILURE);
@@ -398,7 +410,7 @@ static void parse_command_line(int argc, char **argv) 
	opterr = 0;



	for (;;) {

		c = getopt_long(argc, argv, "Frtli:q:psSNn:czf:mu",

		c = getopt_long(argc, argv, "Frtli:q:psSNn:czf:muM",

				long_options, &option_index);

		if (c == -1)

			break;
@@ -448,11 +460,14 @@ static void parse_command_line(int argc, char **argv) 
			break;

		case 'f':

			opt_xsk_frame_size = atoi(optarg);

			break;

		case 'm':

			opt_need_wakeup = false;

			opt_xdp_bind_flags &= ~XDP_USE_NEED_WAKEUP;

			break;



		case 'M':

			opt_num_xsks = MAX_SOCKS;

			break;

		default:

			usage(basename(argv[0]));

		}
@@ -586,11 +601,9 @@ static void rx_drop(struct xsk_socket_info *xsk, struct pollfd *fds) 


static void rx_drop_all(void)

{

	struct pollfd fds[MAX_SOCKS + 1];

	struct pollfd fds[MAX_SOCKS] = {};

	int i, ret;



	memset(fds, 0, sizeof(fds));



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

		fds[i].fd = xsk_socket__fd(xsks[i]->xsk);

		fds[i].events = POLLIN;
@@ -633,11 +646,10 @@ static void tx_only(struct xsk_socket_info *xsk, u32 frame_nb) 


static void tx_only_all(void)

{

	struct pollfd fds[MAX_SOCKS];

	struct pollfd fds[MAX_SOCKS] = {};

	u32 frame_nb[MAX_SOCKS] = {};

	int i, ret;



	memset(fds, 0, sizeof(fds));

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

		fds[0].fd = xsk_socket__fd(xsks[i]->xsk);

		fds[0].events = POLLOUT;
@@ -706,11 +718,9 @@ static void l2fwd(struct xsk_socket_info *xsk, struct pollfd *fds) 


static void l2fwd_all(void)

{

	struct pollfd fds[MAX_SOCKS];

	struct pollfd fds[MAX_SOCKS] = {};

	int i, ret;



	memset(fds, 0, sizeof(fds));



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

		fds[i].fd = xsk_socket__fd(xsks[i]->xsk);

		fds[i].events = POLLOUT | POLLIN;
@@ -728,13 +738,66 @@ static void l2fwd_all(void) 
	}

}



static void load_xdp_program(char **argv, struct bpf_object **obj)

{

	struct bpf_prog_load_attr prog_load_attr = {

		.prog_type      = BPF_PROG_TYPE_XDP,

	};

	char xdp_filename[256];

	int prog_fd;



	snprintf(xdp_filename, sizeof(xdp_filename), "%s_kern.o", argv[0]);

	prog_load_attr.file = xdp_filename;



	if (bpf_prog_load_xattr(&prog_load_attr, obj, &prog_fd))

		exit(EXIT_FAILURE);

	if (prog_fd < 0) {

		fprintf(stderr, "ERROR: no program found: %s\n",

			strerror(prog_fd));

		exit(EXIT_FAILURE);

	}



	if (bpf_set_link_xdp_fd(opt_ifindex, prog_fd, opt_xdp_flags) < 0) {

		fprintf(stderr, "ERROR: link set xdp fd failed\n");

		exit(EXIT_FAILURE);

	}

}



static void enter_xsks_into_map(struct bpf_object *obj)

{

	struct bpf_map *map;

	int i, xsks_map;



	map = bpf_object__find_map_by_name(obj, "xsks_map");

	xsks_map = bpf_map__fd(map);

	if (xsks_map < 0) {

		fprintf(stderr, "ERROR: no xsks map found: %s\n",

			strerror(xsks_map));

			exit(EXIT_FAILURE);

	}



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

		int fd = xsk_socket__fd(xsks[i]->xsk);

		int key, ret;



		key = i;

		ret = bpf_map_update_elem(xsks_map, &key, &fd, 0);

		if (ret) {

			fprintf(stderr, "ERROR: bpf_map_update_elem %d\n", i);

			exit(EXIT_FAILURE);

		}

	}

}



int main(int argc, char **argv)

{

	struct rlimit r = {RLIM_INFINITY, RLIM_INFINITY};

	bool rx = false, tx = false;

	struct xsk_umem_info *umem;

	struct bpf_object *obj;

	pthread_t pt;

	int i, ret;

	void *bufs;

	int ret;



	parse_command_line(argc, argv);
@@ -744,6 +807,9 @@ int main(int argc, char **argv) 
		exit(EXIT_FAILURE);

	}



	if (opt_num_xsks > 1)

		load_xdp_program(argv, &obj);



	/* Reserve memory for the umem. Use hugepages if unaligned chunk mode */

	bufs = mmap(NULL, NUM_FRAMES * opt_xsk_frame_size,

		    PROT_READ | PROT_WRITE,
@@ -752,16 +818,24 @@ int main(int argc, char **argv) 
		printf("ERROR: mmap failed\n");

		exit(EXIT_FAILURE);

	}



	/* Create sockets... */

	umem = xsk_configure_umem(bufs, NUM_FRAMES * opt_xsk_frame_size);

	xsks[num_socks++] = xsk_configure_socket(umem);



	if (opt_bench == BENCH_TXONLY) {

		int i;

	if (opt_bench == BENCH_RXDROP || opt_bench == BENCH_L2FWD) {

		rx = true;

		xsk_populate_fill_ring(umem);

	}

	if (opt_bench == BENCH_L2FWD || opt_bench == BENCH_TXONLY)

		tx = true;

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

		xsks[num_socks++] = xsk_configure_socket(umem, rx, tx);



	if (opt_bench == BENCH_TXONLY)

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

			(void)gen_eth_frame(umem, i * opt_xsk_frame_size);

	}

			gen_eth_frame(umem, i * opt_xsk_frame_size);



	if (opt_num_xsks > 1 && opt_bench != BENCH_TXONLY)

		enter_xsks_into_map(obj);



	signal(SIGINT, int_exit);

	signal(SIGTERM, int_exit);

CRA Git | Maintained and supported by SUSTech CRA and CCSE