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

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



Daniel Borkmann says:

====================
pull-request: bpf 2018-07-13

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

The main changes are:

1) Fix AF_XDP TX error reporting before final kernel release such that it
   becomes consistent between copy mode and zero-copy, from Magnus.

2) Fix three different syzkaller reported issues: oob due to ld_abs
   rewrite with too large offset, another oob in l3 based skb test run
   and a bug leaving mangled prog in subprog JITing error path, from Daniel.

3) Fix BTF handling for bitfield extraction on big endian, from Okash.

4) Fix a missing linux/errno.h include in cgroup/BPF found by kbuild bot,
   from Roman.

5) Fix xdp2skb_meta.sh sample by using just command names instead of
   absolute paths for tc and ip and allow them to be redefined, from Taeung.

6) Fix availability probing for BPF seg6 helpers before final kernel ships
   so they can be detected at prog load time, from Mathieu.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents e78bfb07 5e3e6e83

include/linux/bpf-cgroup.h

+1 −0
Original line number Original line Diff line number Diff line
@@ -2,6 +2,7 @@ 
#ifndef _BPF_CGROUP_H

#ifndef _BPF_CGROUP_H

#define _BPF_CGROUP_H

#define _BPF_CGROUP_H





#include <linux/errno.h>

#include <linux/jump_label.h>

#include <linux/jump_label.h>

#include <uapi/linux/bpf.h>

#include <uapi/linux/bpf.h>

kernel/bpf/btf.c

+13 −17
Original line number Original line Diff line number Diff line
@@ -991,16 +991,13 @@ static void btf_int_bits_seq_show(const struct btf *btf, 
				  void *data, u8 bits_offset,

				  void *data, u8 bits_offset,

				  struct seq_file *m)

				  struct seq_file *m)

{

{

	u16 left_shift_bits, right_shift_bits;

	u32 int_data = btf_type_int(t);

	u32 int_data = btf_type_int(t);

	u16 nr_bits = BTF_INT_BITS(int_data);

	u16 nr_bits = BTF_INT_BITS(int_data);

	u16 total_bits_offset;

	u16 total_bits_offset;

	u16 nr_copy_bytes;

	u16 nr_copy_bytes;

	u16 nr_copy_bits;

	u16 nr_copy_bits;

	u8 nr_upper_bits;

	u64 print_num;

	union {

		u64 u64_num;

		u8  u8_nums[8];

	} print_num;





	total_bits_offset = bits_offset + BTF_INT_OFFSET(int_data);

	total_bits_offset = bits_offset + BTF_INT_OFFSET(int_data);

	data += BITS_ROUNDDOWN_BYTES(total_bits_offset);

	data += BITS_ROUNDDOWN_BYTES(total_bits_offset);
@@ -1008,21 +1005,20 @@ static void btf_int_bits_seq_show(const struct btf *btf, 
	nr_copy_bits = nr_bits + bits_offset;

	nr_copy_bits = nr_bits + bits_offset;

	nr_copy_bytes = BITS_ROUNDUP_BYTES(nr_copy_bits);

	nr_copy_bytes = BITS_ROUNDUP_BYTES(nr_copy_bits);





	print_num.u64_num = 0;

	print_num = 0;

	memcpy(&print_num.u64_num, data, nr_copy_bytes);

	memcpy(&print_num, data, nr_copy_bytes);





	/* Ditch the higher order bits */

#ifdef __BIG_ENDIAN_BITFIELD

	nr_upper_bits = BITS_PER_BYTE_MASKED(nr_copy_bits);

	left_shift_bits = bits_offset;

	if (nr_upper_bits) {

#else

		/* We need to mask out some bits of the upper byte. */

	left_shift_bits = BITS_PER_U64 - nr_copy_bits;

		u8 mask = (1 << nr_upper_bits) - 1;

#endif

	right_shift_bits = BITS_PER_U64 - nr_bits;





		print_num.u8_nums[nr_copy_bytes - 1] &= mask;

	print_num <<= left_shift_bits;

	}

	print_num >>= right_shift_bits;



	print_num.u64_num >>= bits_offset;





	seq_printf(m, "0x%llx", print_num.u64_num);

	seq_printf(m, "0x%llx", print_num);

}

}





static void btf_int_seq_show(const struct btf *btf, const struct btf_type *t,

static void btf_int_seq_show(const struct btf *btf, const struct btf_type *t,

kernel/bpf/verifier.c

+9 −2
Original line number Original line Diff line number Diff line
@@ -5430,6 +5430,10 @@ static int jit_subprogs(struct bpf_verifier_env *env) 
		if (insn->code != (BPF_JMP | BPF_CALL) ||

		if (insn->code != (BPF_JMP | BPF_CALL) ||

		    insn->src_reg != BPF_PSEUDO_CALL)

		    insn->src_reg != BPF_PSEUDO_CALL)

			continue;

			continue;

		/* Upon error here we cannot fall back to interpreter but

		 * need a hard reject of the program. Thus -EFAULT is

		 * propagated in any case.

		 */

		subprog = find_subprog(env, i + insn->imm + 1);

		subprog = find_subprog(env, i + insn->imm + 1);

		if (subprog < 0) {

		if (subprog < 0) {

			WARN_ONCE(1, "verifier bug. No program starts at insn %d\n",

			WARN_ONCE(1, "verifier bug. No program starts at insn %d\n",
@@ -5450,7 +5454,7 @@ static int jit_subprogs(struct bpf_verifier_env *env) 




	func = kcalloc(env->subprog_cnt, sizeof(prog), GFP_KERNEL);

	func = kcalloc(env->subprog_cnt, sizeof(prog), GFP_KERNEL);

	if (!func)

	if (!func)

		return -ENOMEM;

		goto out_undo_insn;





	for (i = 0; i < env->subprog_cnt; i++) {

	for (i = 0; i < env->subprog_cnt; i++) {

		subprog_start = subprog_end;

		subprog_start = subprog_end;
@@ -5515,7 +5519,7 @@ static int jit_subprogs(struct bpf_verifier_env *env) 
		tmp = bpf_int_jit_compile(func[i]);

		tmp = bpf_int_jit_compile(func[i]);

		if (tmp != func[i] || func[i]->bpf_func != old_bpf_func) {

		if (tmp != func[i] || func[i]->bpf_func != old_bpf_func) {

			verbose(env, "JIT doesn't support bpf-to-bpf calls\n");

			verbose(env, "JIT doesn't support bpf-to-bpf calls\n");

			err = -EFAULT;

			err = -ENOTSUPP;

			goto out_free;

			goto out_free;

		}

		}

		cond_resched();

		cond_resched();
@@ -5552,6 +5556,7 @@ out_free: 
		if (func[i])

		if (func[i])

			bpf_jit_free(func[i]);

			bpf_jit_free(func[i]);

	kfree(func);

	kfree(func);

out_undo_insn:

	/* cleanup main prog to be interpreted */

	/* cleanup main prog to be interpreted */

	prog->jit_requested = 0;

	prog->jit_requested = 0;

	for (i = 0, insn = prog->insnsi; i < prog->len; i++, insn++) {

	for (i = 0, insn = prog->insnsi; i < prog->len; i++, insn++) {
@@ -5578,6 +5583,8 @@ static int fixup_call_args(struct bpf_verifier_env *env) 
		err = jit_subprogs(env);

		err = jit_subprogs(env);

		if (err == 0)

		if (err == 0)

			return 0;

			return 0;

		if (err == -EFAULT)

			return err;

	}

	}

#ifndef CONFIG_BPF_JIT_ALWAYS_ON

#ifndef CONFIG_BPF_JIT_ALWAYS_ON

	for (i = 0; i < prog->len; i++, insn++) {

	for (i = 0; i < prog->len; i++, insn++) {

net/bpf/test_run.c

+14 −3
Original line number Original line Diff line number Diff line
@@ -96,6 +96,7 @@ int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr, 
	u32 size = kattr->test.data_size_in;

	u32 size = kattr->test.data_size_in;

	u32 repeat = kattr->test.repeat;

	u32 repeat = kattr->test.repeat;

	u32 retval, duration;

	u32 retval, duration;

	int hh_len = ETH_HLEN;

	struct sk_buff *skb;

	struct sk_buff *skb;

	void *data;

	void *data;

	int ret;

	int ret;
@@ -131,12 +132,22 @@ int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr, 
	skb_reset_network_header(skb);

	skb_reset_network_header(skb);





	if (is_l2)

	if (is_l2)

		__skb_push(skb, ETH_HLEN);

		__skb_push(skb, hh_len);

	if (is_direct_pkt_access)

	if (is_direct_pkt_access)

		bpf_compute_data_pointers(skb);

		bpf_compute_data_pointers(skb);

	retval = bpf_test_run(prog, skb, repeat, &duration);

	retval = bpf_test_run(prog, skb, repeat, &duration);

	if (!is_l2)

	if (!is_l2) {

		__skb_push(skb, ETH_HLEN);

		if (skb_headroom(skb) < hh_len) {

			int nhead = HH_DATA_ALIGN(hh_len - skb_headroom(skb));



			if (pskb_expand_head(skb, nhead, 0, GFP_USER)) {

				kfree_skb(skb);

				return -ENOMEM;

			}

		}

		memset(__skb_push(skb, hh_len), 0, hh_len);

	}



	size = skb->len;

	size = skb->len;

	/* bpf program can never convert linear skb to non-linear */

	/* bpf program can never convert linear skb to non-linear */

	if (WARN_ON_ONCE(skb_is_nonlinear(skb)))

	if (WARN_ON_ONCE(skb_is_nonlinear(skb)))

net/core/filter.c

+21 −18
Original line number Original line Diff line number Diff line
@@ -459,11 +459,21 @@ static bool convert_bpf_ld_abs(struct sock_filter *fp, struct bpf_insn **insnp) 
	     (!unaligned_ok && offset >= 0 &&

	     (!unaligned_ok && offset >= 0 &&

	      offset + ip_align >= 0 &&

	      offset + ip_align >= 0 &&

	      offset + ip_align % size == 0))) {

	      offset + ip_align % size == 0))) {

		bool ldx_off_ok = offset <= S16_MAX;



		*insn++ = BPF_MOV64_REG(BPF_REG_TMP, BPF_REG_H);

		*insn++ = BPF_MOV64_REG(BPF_REG_TMP, BPF_REG_H);

		*insn++ = BPF_ALU64_IMM(BPF_SUB, BPF_REG_TMP, offset);

		*insn++ = BPF_ALU64_IMM(BPF_SUB, BPF_REG_TMP, offset);

		*insn++ = BPF_JMP_IMM(BPF_JSLT, BPF_REG_TMP, size, 2 + endian);

		*insn++ = BPF_JMP_IMM(BPF_JSLT, BPF_REG_TMP,

		*insn++ = BPF_LDX_MEM(BPF_SIZE(fp->code), BPF_REG_A, BPF_REG_D,

				      size, 2 + endian + (!ldx_off_ok * 2));

				      offset);

		if (ldx_off_ok) {

			*insn++ = BPF_LDX_MEM(BPF_SIZE(fp->code), BPF_REG_A,

					      BPF_REG_D, offset);

		} else {

			*insn++ = BPF_MOV64_REG(BPF_REG_TMP, BPF_REG_D);

			*insn++ = BPF_ALU64_IMM(BPF_ADD, BPF_REG_TMP, offset);

			*insn++ = BPF_LDX_MEM(BPF_SIZE(fp->code), BPF_REG_A,

					      BPF_REG_TMP, 0);

		}

		if (endian)

		if (endian)

			*insn++ = BPF_ENDIAN(BPF_FROM_BE, BPF_REG_A, size * 8);

			*insn++ = BPF_ENDIAN(BPF_FROM_BE, BPF_REG_A, size * 8);

		*insn++ = BPF_JMP_A(8);

		*insn++ = BPF_JMP_A(8);
@@ -4526,10 +4536,10 @@ static const struct bpf_func_proto bpf_lwt_push_encap_proto = { 
	.arg4_type	= ARG_CONST_SIZE

	.arg4_type	= ARG_CONST_SIZE

};

};





#if IS_ENABLED(CONFIG_IPV6_SEG6_BPF)

BPF_CALL_4(bpf_lwt_seg6_store_bytes, struct sk_buff *, skb, u32, offset,

BPF_CALL_4(bpf_lwt_seg6_store_bytes, struct sk_buff *, skb, u32, offset,

	   const void *, from, u32, len)

	   const void *, from, u32, len)

{

{

#if IS_ENABLED(CONFIG_IPV6_SEG6_BPF)

	struct seg6_bpf_srh_state *srh_state =

	struct seg6_bpf_srh_state *srh_state =

		this_cpu_ptr(&seg6_bpf_srh_states);

		this_cpu_ptr(&seg6_bpf_srh_states);

	void *srh_tlvs, *srh_end, *ptr;

	void *srh_tlvs, *srh_end, *ptr;
@@ -4555,9 +4565,6 @@ BPF_CALL_4(bpf_lwt_seg6_store_bytes, struct sk_buff *, skb, u32, offset, 




	memcpy(skb->data + offset, from, len);

	memcpy(skb->data + offset, from, len);

	return 0;

	return 0;

#else /* CONFIG_IPV6_SEG6_BPF */

	return -EOPNOTSUPP;

#endif

}

}





static const struct bpf_func_proto bpf_lwt_seg6_store_bytes_proto = {

static const struct bpf_func_proto bpf_lwt_seg6_store_bytes_proto = {
@@ -4573,7 +4580,6 @@ static const struct bpf_func_proto bpf_lwt_seg6_store_bytes_proto = { 
BPF_CALL_4(bpf_lwt_seg6_action, struct sk_buff *, skb,

BPF_CALL_4(bpf_lwt_seg6_action, struct sk_buff *, skb,

	   u32, action, void *, param, u32, param_len)

	   u32, action, void *, param, u32, param_len)

{

{

#if IS_ENABLED(CONFIG_IPV6_SEG6_BPF)

	struct seg6_bpf_srh_state *srh_state =

	struct seg6_bpf_srh_state *srh_state =

		this_cpu_ptr(&seg6_bpf_srh_states);

		this_cpu_ptr(&seg6_bpf_srh_states);

	struct ipv6_sr_hdr *srh;

	struct ipv6_sr_hdr *srh;
@@ -4621,9 +4627,6 @@ BPF_CALL_4(bpf_lwt_seg6_action, struct sk_buff *, skb, 
	default:

	default:

		return -EINVAL;

		return -EINVAL;

	}

	}

#else /* CONFIG_IPV6_SEG6_BPF */

	return -EOPNOTSUPP;

#endif

}

}





static const struct bpf_func_proto bpf_lwt_seg6_action_proto = {

static const struct bpf_func_proto bpf_lwt_seg6_action_proto = {
@@ -4639,7 +4642,6 @@ static const struct bpf_func_proto bpf_lwt_seg6_action_proto = { 
BPF_CALL_3(bpf_lwt_seg6_adjust_srh, struct sk_buff *, skb, u32, offset,

BPF_CALL_3(bpf_lwt_seg6_adjust_srh, struct sk_buff *, skb, u32, offset,

	   s32, len)

	   s32, len)

{

{

#if IS_ENABLED(CONFIG_IPV6_SEG6_BPF)

	struct seg6_bpf_srh_state *srh_state =

	struct seg6_bpf_srh_state *srh_state =

		this_cpu_ptr(&seg6_bpf_srh_states);

		this_cpu_ptr(&seg6_bpf_srh_states);

	void *srh_end, *srh_tlvs, *ptr;

	void *srh_end, *srh_tlvs, *ptr;
@@ -4683,9 +4685,6 @@ BPF_CALL_3(bpf_lwt_seg6_adjust_srh, struct sk_buff *, skb, u32, offset, 
	srh_state->hdrlen += len;

	srh_state->hdrlen += len;

	srh_state->valid = 0;

	srh_state->valid = 0;

	return 0;

	return 0;

#else /* CONFIG_IPV6_SEG6_BPF */

	return -EOPNOTSUPP;

#endif

}

}





static const struct bpf_func_proto bpf_lwt_seg6_adjust_srh_proto = {

static const struct bpf_func_proto bpf_lwt_seg6_adjust_srh_proto = {
@@ -4696,6 +4695,7 @@ static const struct bpf_func_proto bpf_lwt_seg6_adjust_srh_proto = { 
	.arg2_type	= ARG_ANYTHING,

	.arg2_type	= ARG_ANYTHING,

	.arg3_type	= ARG_ANYTHING,

	.arg3_type	= ARG_ANYTHING,

};

};

#endif /* CONFIG_IPV6_SEG6_BPF */





bool bpf_helper_changes_pkt_data(void *func)

bool bpf_helper_changes_pkt_data(void *func)

{

{
@@ -4717,11 +4717,12 @@ bool bpf_helper_changes_pkt_data(void *func) 
	    func == bpf_xdp_adjust_meta ||

	    func == bpf_xdp_adjust_meta ||

	    func == bpf_msg_pull_data ||

	    func == bpf_msg_pull_data ||

	    func == bpf_xdp_adjust_tail ||

	    func == bpf_xdp_adjust_tail ||

	    func == bpf_lwt_push_encap ||

#if IS_ENABLED(CONFIG_IPV6_SEG6_BPF)

	    func == bpf_lwt_seg6_store_bytes ||

	    func == bpf_lwt_seg6_store_bytes ||

	    func == bpf_lwt_seg6_adjust_srh ||

	    func == bpf_lwt_seg6_adjust_srh ||

	    func == bpf_lwt_seg6_action

	    func == bpf_lwt_seg6_action ||

	    )

#endif

	    func == bpf_lwt_push_encap)

		return true;

		return true;





	return false;

	return false;
@@ -5056,12 +5057,14 @@ static const struct bpf_func_proto * 
lwt_seg6local_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

lwt_seg6local_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

{

{

	switch (func_id) {

	switch (func_id) {

#if IS_ENABLED(CONFIG_IPV6_SEG6_BPF)

	case BPF_FUNC_lwt_seg6_store_bytes:

	case BPF_FUNC_lwt_seg6_store_bytes:

		return &bpf_lwt_seg6_store_bytes_proto;

		return &bpf_lwt_seg6_store_bytes_proto;

	case BPF_FUNC_lwt_seg6_action:

	case BPF_FUNC_lwt_seg6_action:

		return &bpf_lwt_seg6_action_proto;

		return &bpf_lwt_seg6_action_proto;

	case BPF_FUNC_lwt_seg6_adjust_srh:

	case BPF_FUNC_lwt_seg6_adjust_srh:

		return &bpf_lwt_seg6_adjust_srh_proto;

		return &bpf_lwt_seg6_adjust_srh_proto;

#endif

	default:

	default:

		return lwt_out_func_proto(func_id, prog);

		return lwt_out_func_proto(func_id, prog);

	}

	}

CRA Git | Maintained and supported by SUSTech CRA and CCSE