Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1e46c09e authored by David S. Miller's avatar David S. Miller
Browse files

Merge git://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next 



Daniel Borkmann says:

====================
The following pull-request contains BPF updates for your *net-next* tree.

The main changes are:

1) Add the ability to use unaligned chunks in the AF_XDP umem. By
   relaxing where the chunks can be placed, it allows to use an
   arbitrary buffer size and place whenever there is a free
   address in the umem. Helps more seamless DPDK AF_XDP driver
   integration. Support for i40e, ixgbe and mlx5e, from Kevin and
   Maxim.

2) Addition of a wakeup flag for AF_XDP tx and fill rings so the
   application can wake up the kernel for rx/tx processing which
   avoids busy-spinning of the latter, useful when app and driver
   is located on the same core. Support for i40e, ixgbe and mlx5e,
   from Magnus and Maxim.

3) bpftool fixes for printf()-like functions so compiler can actually
   enforce checks, bpftool build system improvements for custom output
   directories, and addition of 'bpftool map freeze' command, from Quentin.

4) Support attaching/detaching XDP programs from 'bpftool net' command,
   from Daniel.

5) Automatic xskmap cleanup when AF_XDP socket is released, and several
   barrier/{read,write}_once fixes in AF_XDP code, from Björn.

6) Relicense of bpf_helpers.h/bpf_endian.h for future libbpf
   inclusion as well as libbpf versioning improvements, from Andrii.

7) Several new BPF kselftests for verifier precision tracking, from Alexei.

8) Several BPF kselftest fixes wrt endianess to run on s390x, from Ilya.

9) And more BPF kselftest improvements all over the place, from Stanislav.

10) Add simple BPF map op cache for nfp driver to batch dumps, from Jakub.

11) AF_XDP socket umem mapping improvements for 32bit archs, from Ivan.

12) Add BPF-to-BPF call and BTF line info support for s390x JIT, from Yauheni.

13) Small optimization in arm64 JIT to spare 1 insns for BPF_MOD, from Jerin.

14) Fix an error check in bpf_tcp_gen_syncookie() helper, from Petar.

15) Various minor fixes and cleanups, from Nathan, Masahiro, Masanari,
    Peter, Wei, Yue.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents f9bcfe21 593f191a

Documentation/networking/af_xdp.rst

+6 −4
Original line number Diff line number Diff line
@@ -153,10 +153,12 @@ an example, if the UMEM is 64k and each chunk is 4k, then the UMEM has 


Frames passed to the kernel are used for the ingress path (RX rings).



The user application produces UMEM addrs to this ring. Note that the

kernel will mask the incoming addr. E.g. for a chunk size of 2k, the

log2(2048) LSB of the addr will be masked off, meaning that 2048, 2050

and 3000 refers to the same chunk.

The user application produces UMEM addrs to this ring. Note that, if

running the application with aligned chunk mode, the kernel will mask

the incoming addr.  E.g. for a chunk size of 2k, the log2(2048) LSB of

the addr will be masked off, meaning that 2048, 2050 and 3000 refers

to the same chunk. If the user application is run in the unaligned

chunks mode, then the incoming addr will be left untouched.





UMEM Completion Ring

arch/arm64/net/bpf_jit.h

+3 −0
Original line number Diff line number Diff line
@@ -171,6 +171,9 @@ 
/* Rd = Ra + Rn * Rm */

#define A64_MADD(sf, Rd, Ra, Rn, Rm) aarch64_insn_gen_data3(Rd, Ra, Rn, Rm, \

	A64_VARIANT(sf), AARCH64_INSN_DATA3_MADD)

/* Rd = Ra - Rn * Rm */

#define A64_MSUB(sf, Rd, Ra, Rn, Rm) aarch64_insn_gen_data3(Rd, Ra, Rn, Rm, \

	A64_VARIANT(sf), AARCH64_INSN_DATA3_MSUB)

/* Rd = Rn * Rm */

#define A64_MUL(sf, Rd, Rn, Rm) A64_MADD(sf, Rd, A64_ZR, Rn, Rm)

arch/arm64/net/bpf_jit_comp.c

+2 −4
Original line number Diff line number Diff line
@@ -409,8 +409,7 @@ static int build_insn(const struct bpf_insn *insn, struct jit_ctx *ctx, 
			break;

		case BPF_MOD:

			emit(A64_UDIV(is64, tmp, dst, src), ctx);

			emit(A64_MUL(is64, tmp, tmp, src), ctx);

			emit(A64_SUB(is64, dst, dst, tmp), ctx);

			emit(A64_MSUB(is64, dst, dst, tmp, src), ctx);

			break;

		}

		break;
@@ -516,8 +515,7 @@ static int build_insn(const struct bpf_insn *insn, struct jit_ctx *ctx, 
	case BPF_ALU64 | BPF_MOD | BPF_K:

		emit_a64_mov_i(is64, tmp2, imm, ctx);

		emit(A64_UDIV(is64, tmp, dst, tmp2), ctx);

		emit(A64_MUL(is64, tmp, tmp, tmp2), ctx);

		emit(A64_SUB(is64, dst, dst, tmp), ctx);

		emit(A64_MSUB(is64, dst, dst, tmp, tmp2), ctx);

		break;

	case BPF_ALU | BPF_LSH | BPF_K:

	case BPF_ALU64 | BPF_LSH | BPF_K:

arch/s390/net/bpf_jit_comp.c

+56 −11
Original line number Diff line number Diff line
@@ -502,7 +502,8 @@ static void bpf_jit_epilogue(struct bpf_jit *jit, u32 stack_depth) 
 * NOTE: Use noinline because for gcov (-fprofile-arcs) gcc allocates a lot of

 * stack space for the large switch statement.

 */

static noinline int bpf_jit_insn(struct bpf_jit *jit, struct bpf_prog *fp, int i)

static noinline int bpf_jit_insn(struct bpf_jit *jit, struct bpf_prog *fp,

				 int i, bool extra_pass)

{

	struct bpf_insn *insn = &fp->insnsi[i];

	int jmp_off, last, insn_count = 1;
@@ -1011,10 +1012,14 @@ static noinline int bpf_jit_insn(struct bpf_jit *jit, struct bpf_prog *fp, int i 
	 */

	case BPF_JMP | BPF_CALL:

	{

		/*

		 * b0 = (__bpf_call_base + imm)(b1, b2, b3, b4, b5)

		 */

		const u64 func = (u64)__bpf_call_base + imm;

		u64 func;

		bool func_addr_fixed;

		int ret;



		ret = bpf_jit_get_func_addr(fp, insn, extra_pass,

					    &func, &func_addr_fixed);

		if (ret < 0)

			return -1;



		REG_SET_SEEN(BPF_REG_5);

		jit->seen |= SEEN_FUNC;
@@ -1283,7 +1288,8 @@ static noinline int bpf_jit_insn(struct bpf_jit *jit, struct bpf_prog *fp, int i 
/*

 * Compile eBPF program into s390x code

 */

static int bpf_jit_prog(struct bpf_jit *jit, struct bpf_prog *fp)

static int bpf_jit_prog(struct bpf_jit *jit, struct bpf_prog *fp,

			bool extra_pass)

{

	int i, insn_count;
@@ -1292,7 +1298,7 @@ static int bpf_jit_prog(struct bpf_jit *jit, struct bpf_prog *fp) 


	bpf_jit_prologue(jit, fp->aux->stack_depth);

	for (i = 0; i < fp->len; i += insn_count) {

		insn_count = bpf_jit_insn(jit, fp, i);

		insn_count = bpf_jit_insn(jit, fp, i, extra_pass);

		if (insn_count < 0)

			return -1;

		/* Next instruction address */
@@ -1311,6 +1317,12 @@ bool bpf_jit_needs_zext(void) 
	return true;

}



struct s390_jit_data {

	struct bpf_binary_header *header;

	struct bpf_jit ctx;

	int pass;

};



/*

 * Compile eBPF program "fp"

 */
@@ -1318,7 +1330,9 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *fp) 
{

	struct bpf_prog *tmp, *orig_fp = fp;

	struct bpf_binary_header *header;

	struct s390_jit_data *jit_data;

	bool tmp_blinded = false;

	bool extra_pass = false;

	struct bpf_jit jit;

	int pass;
@@ -1337,6 +1351,23 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *fp) 
		fp = tmp;

	}



	jit_data = fp->aux->jit_data;

	if (!jit_data) {

		jit_data = kzalloc(sizeof(*jit_data), GFP_KERNEL);

		if (!jit_data) {

			fp = orig_fp;

			goto out;

		}

		fp->aux->jit_data = jit_data;

	}

	if (jit_data->ctx.addrs) {

		jit = jit_data->ctx;

		header = jit_data->header;

		extra_pass = true;

		pass = jit_data->pass + 1;

		goto skip_init_ctx;

	}



	memset(&jit, 0, sizeof(jit));

	jit.addrs = kcalloc(fp->len + 1, sizeof(*jit.addrs), GFP_KERNEL);

	if (jit.addrs == NULL) {
@@ -1349,7 +1380,7 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *fp) 
	 *   - 3:   Calculate program size and addrs arrray

	 */

	for (pass = 1; pass <= 3; pass++) {

		if (bpf_jit_prog(&jit, fp)) {

		if (bpf_jit_prog(&jit, fp, extra_pass)) {

			fp = orig_fp;

			goto free_addrs;

		}
@@ -1361,12 +1392,14 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *fp) 
		fp = orig_fp;

		goto free_addrs;

	}



	header = bpf_jit_binary_alloc(jit.size, &jit.prg_buf, 2, jit_fill_hole);

	if (!header) {

		fp = orig_fp;

		goto free_addrs;

	}

	if (bpf_jit_prog(&jit, fp)) {

skip_init_ctx:

	if (bpf_jit_prog(&jit, fp, extra_pass)) {

		bpf_jit_binary_free(header);

		fp = orig_fp;

		goto free_addrs;
@@ -1375,12 +1408,24 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *fp) 
		bpf_jit_dump(fp->len, jit.size, pass, jit.prg_buf);

		print_fn_code(jit.prg_buf, jit.size_prg);

	}

	if (!fp->is_func || extra_pass) {

		bpf_jit_binary_lock_ro(header);

	} else {

		jit_data->header = header;

		jit_data->ctx = jit;

		jit_data->pass = pass;

	}

	fp->bpf_func = (void *) jit.prg_buf;

	fp->jited = 1;

	fp->jited_len = jit.size;



	if (!fp->is_func || extra_pass) {

		bpf_prog_fill_jited_linfo(fp, jit.addrs + 1);

free_addrs:

		kfree(jit.addrs);

		kfree(jit_data);

		fp->aux->jit_data = NULL;

	}

out:

	if (tmp_blinded)

		bpf_jit_prog_release_other(fp, fp == orig_fp ?

drivers/net/ethernet/intel/i40e/i40e_main.c

+3 −2
Original line number Diff line number Diff line
@@ -12530,7 +12530,8 @@ static int i40e_xdp_setup(struct i40e_vsi *vsi, 
	if (need_reset && prog)

		for (i = 0; i < vsi->num_queue_pairs; i++)

			if (vsi->xdp_rings[i]->xsk_umem)

				(void)i40e_xsk_async_xmit(vsi->netdev, i);

				(void)i40e_xsk_wakeup(vsi->netdev, i,

						      XDP_WAKEUP_RX);



	return 0;

}
@@ -12852,7 +12853,7 @@ static const struct net_device_ops i40e_netdev_ops = { 
	.ndo_bridge_setlink	= i40e_ndo_bridge_setlink,

	.ndo_bpf		= i40e_xdp,

	.ndo_xdp_xmit		= i40e_xdp_xmit,

	.ndo_xsk_async_xmit	= i40e_xsk_async_xmit,

	.ndo_xsk_wakeup	        = i40e_xsk_wakeup,

	.ndo_dfwd_add_station	= i40e_fwd_add,

	.ndo_dfwd_del_station	= i40e_fwd_del,

};