Commit 0841d986 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-06-16

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

The main changes are:

1) Fix a panic in devmap handling in generic XDP where return type
   of __devmap_lookup_elem() got changed recently but generic XDP
   code missed the related update, from Toshiaki.

2) Fix a freeze when BPF progs are loaded that include BPF to BPF
   calls when JIT is enabled where we would later bail out via error
   path w/o dropping kallsyms, and another one to silence syzkaller
   splats from locking prog read-only, from Daniel.

3) Fix a bug in test_offloads.py BPF selftest which must not assume
   that the underlying system have no BPF progs loaded prior to test,
   and one in bpftool to fix accuracy of program load time, from Jakub.

4) Fix a bug in bpftool's probe for availability of the bpf(2)
   BPF_TASK_FD_QUERY subcommand, from Yonghong.

5) Fix a regression in AF_XDP's XDP_SKB receive path where queue
   id check got erroneously removed, from Björn.

6) Fix missing state cleanup in BPF's xfrm tunnel test, from William.

7) Check tunnel type more accurately in BPF's tunnel collect metadata
   kselftest, from Jian.

8) Fix missing Kconfig fragments for BPF kselftests, from Anders.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 35773c93 6d5fc195

include/linux/bpf.h

+12 −0
Original line number Diff line number Diff line
@@ -488,12 +488,15 @@ void bpf_patch_call_args(struct bpf_insn *insn, u32 stack_depth); 


/* Map specifics */

struct xdp_buff;

struct sk_buff;



struct bpf_dtab_netdev *__dev_map_lookup_elem(struct bpf_map *map, u32 key);

void __dev_map_insert_ctx(struct bpf_map *map, u32 index);

void __dev_map_flush(struct bpf_map *map);

int dev_map_enqueue(struct bpf_dtab_netdev *dst, struct xdp_buff *xdp,

		    struct net_device *dev_rx);

int dev_map_generic_redirect(struct bpf_dtab_netdev *dst, struct sk_buff *skb,

			     struct bpf_prog *xdp_prog);



struct bpf_cpu_map_entry *__cpu_map_lookup_elem(struct bpf_map *map, u32 key);

void __cpu_map_insert_ctx(struct bpf_map *map, u32 index);
@@ -586,6 +589,15 @@ int dev_map_enqueue(struct bpf_dtab_netdev *dst, struct xdp_buff *xdp, 
	return 0;

}



struct sk_buff;



static inline int dev_map_generic_redirect(struct bpf_dtab_netdev *dst,

					   struct sk_buff *skb,

					   struct bpf_prog *xdp_prog)

{

	return 0;

}



static inline

struct bpf_cpu_map_entry *__cpu_map_lookup_elem(struct bpf_map *map, u32 key)

{

include/linux/filter.h

+57 −22
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 
#include <linux/cryptohash.h>

#include <linux/set_memory.h>

#include <linux/kallsyms.h>

#include <linux/if_vlan.h>



#include <net/sch_generic.h>
@@ -469,7 +470,8 @@ struct sock_fprog_kern { 
};



struct bpf_binary_header {

	unsigned int pages;

	u16 pages;

	u16 locked:1;

	u8 image[];

};
@@ -671,15 +673,18 @@ bpf_ctx_narrow_access_ok(u32 off, u32 size, u32 size_default) 


#define bpf_classic_proglen(fprog) (fprog->len * sizeof(fprog->filter[0]))



#ifdef CONFIG_ARCH_HAS_SET_MEMORY

static inline void bpf_prog_lock_ro(struct bpf_prog *fp)

{

#ifdef CONFIG_ARCH_HAS_SET_MEMORY

	fp->locked = 1;

	WARN_ON_ONCE(set_memory_ro((unsigned long)fp, fp->pages));

	if (set_memory_ro((unsigned long)fp, fp->pages))

		fp->locked = 0;

#endif

}



static inline void bpf_prog_unlock_ro(struct bpf_prog *fp)

{

#ifdef CONFIG_ARCH_HAS_SET_MEMORY

	if (fp->locked) {

		WARN_ON_ONCE(set_memory_rw((unsigned long)fp, fp->pages));

		/* In case set_memory_rw() fails, we want to be the first
@@ -687,34 +692,30 @@ static inline void bpf_prog_unlock_ro(struct bpf_prog *fp) 
		 */

		fp->locked = 0;

	}

#endif

}



static inline void bpf_jit_binary_lock_ro(struct bpf_binary_header *hdr)

{

	WARN_ON_ONCE(set_memory_ro((unsigned long)hdr, hdr->pages));

#ifdef CONFIG_ARCH_HAS_SET_MEMORY

	hdr->locked = 1;

	if (set_memory_ro((unsigned long)hdr, hdr->pages))

		hdr->locked = 0;

#endif

}



static inline void bpf_jit_binary_unlock_ro(struct bpf_binary_header *hdr)

{

#ifdef CONFIG_ARCH_HAS_SET_MEMORY

	if (hdr->locked) {

		WARN_ON_ONCE(set_memory_rw((unsigned long)hdr, hdr->pages));

		/* In case set_memory_rw() fails, we want to be the first

		 * to crash here instead of some random place later on.

		 */

		hdr->locked = 0;

	}

#else

static inline void bpf_prog_lock_ro(struct bpf_prog *fp)

{

}



static inline void bpf_prog_unlock_ro(struct bpf_prog *fp)

{

}



static inline void bpf_jit_binary_lock_ro(struct bpf_binary_header *hdr)

{

}



static inline void bpf_jit_binary_unlock_ro(struct bpf_binary_header *hdr)

{

#endif

}

#endif /* CONFIG_ARCH_HAS_SET_MEMORY */



static inline struct bpf_binary_header *

bpf_jit_binary_hdr(const struct bpf_prog *fp)
@@ -725,6 +726,22 @@ bpf_jit_binary_hdr(const struct bpf_prog *fp) 
	return (void *)addr;

}



#ifdef CONFIG_ARCH_HAS_SET_MEMORY

static inline int bpf_prog_check_pages_ro_single(const struct bpf_prog *fp)

{

	if (!fp->locked)

		return -ENOLCK;

	if (fp->jited) {

		const struct bpf_binary_header *hdr = bpf_jit_binary_hdr(fp);



		if (!hdr->locked)

			return -ENOLCK;

	}



	return 0;

}

#endif



int sk_filter_trim_cap(struct sock *sk, struct sk_buff *skb, unsigned int cap);

static inline int sk_filter(struct sock *sk, struct sk_buff *skb)

{
@@ -786,6 +803,21 @@ static inline bool bpf_dump_raw_ok(void) 
struct bpf_prog *bpf_patch_insn_single(struct bpf_prog *prog, u32 off,

				       const struct bpf_insn *patch, u32 len);



static inline int __xdp_generic_ok_fwd_dev(struct sk_buff *skb,

					   struct net_device *fwd)

{

	unsigned int len;



	if (unlikely(!(fwd->flags & IFF_UP)))

		return -ENETDOWN;



	len = fwd->mtu + fwd->hard_header_len + VLAN_HLEN;

	if (skb->len > len)

		return -EMSGSIZE;



	return 0;

}



/* The pair of xdp_do_redirect and xdp_do_flush_map MUST be called in the

 * same cpu context. Further for best results no more than a single map

 * for the do_redirect/do_flush pair should be used. This limitation is
@@ -961,6 +993,9 @@ static inline void bpf_prog_kallsyms_del(struct bpf_prog *fp) 
}

#endif /* CONFIG_BPF_JIT */



void bpf_prog_kallsyms_del_subprogs(struct bpf_prog *fp);

void bpf_prog_kallsyms_del_all(struct bpf_prog *fp);



#define BPF_ANC		BIT(15)



static inline bool bpf_needs_clear_a(const struct sock_filter *first)

kernel/bpf/core.c

+62 −7
Original line number Diff line number Diff line
@@ -350,6 +350,20 @@ struct bpf_prog *bpf_patch_insn_single(struct bpf_prog *prog, u32 off, 
	return prog_adj;

}



void bpf_prog_kallsyms_del_subprogs(struct bpf_prog *fp)

{

	int i;



	for (i = 0; i < fp->aux->func_cnt; i++)

		bpf_prog_kallsyms_del(fp->aux->func[i]);

}



void bpf_prog_kallsyms_del_all(struct bpf_prog *fp)

{

	bpf_prog_kallsyms_del_subprogs(fp);

	bpf_prog_kallsyms_del(fp);

}



#ifdef CONFIG_BPF_JIT

/* All BPF JIT sysctl knobs here. */

int bpf_jit_enable   __read_mostly = IS_BUILTIN(CONFIG_BPF_JIT_ALWAYS_ON);
@@ -584,6 +598,8 @@ bpf_jit_binary_alloc(unsigned int proglen, u8 **image_ptr, 
	bpf_fill_ill_insns(hdr, size);



	hdr->pages = size / PAGE_SIZE;

	hdr->locked = 0;



	hole = min_t(unsigned int, size - (proglen + sizeof(*hdr)),

		     PAGE_SIZE - sizeof(*hdr));

	start = (get_random_int() % hole) & ~(alignment - 1);
@@ -1434,6 +1450,33 @@ static int bpf_check_tail_call(const struct bpf_prog *fp) 
	return 0;

}



static int bpf_prog_check_pages_ro_locked(const struct bpf_prog *fp)

{

#ifdef CONFIG_ARCH_HAS_SET_MEMORY

	int i, err;



	for (i = 0; i < fp->aux->func_cnt; i++) {

		err = bpf_prog_check_pages_ro_single(fp->aux->func[i]);

		if (err)

			return err;

	}



	return bpf_prog_check_pages_ro_single(fp);

#endif

	return 0;

}



static void bpf_prog_select_func(struct bpf_prog *fp)

{

#ifndef CONFIG_BPF_JIT_ALWAYS_ON

	u32 stack_depth = max_t(u32, fp->aux->stack_depth, 1);



	fp->bpf_func = interpreters[(round_up(stack_depth, 32) / 32) - 1];

#else

	fp->bpf_func = __bpf_prog_ret0_warn;

#endif

}



/**

 *	bpf_prog_select_runtime - select exec runtime for BPF program

 *	@fp: bpf_prog populated with internal BPF program
@@ -1444,13 +1487,13 @@ static int bpf_check_tail_call(const struct bpf_prog *fp) 
 */

struct bpf_prog *bpf_prog_select_runtime(struct bpf_prog *fp, int *err)

{

#ifndef CONFIG_BPF_JIT_ALWAYS_ON

	u32 stack_depth = max_t(u32, fp->aux->stack_depth, 1);

	/* In case of BPF to BPF calls, verifier did all the prep

	 * work with regards to JITing, etc.

	 */

	if (fp->bpf_func)

		goto finalize;



	fp->bpf_func = interpreters[(round_up(stack_depth, 32) / 32) - 1];

#else

	fp->bpf_func = __bpf_prog_ret0_warn;

#endif

	bpf_prog_select_func(fp);



	/* eBPF JITs can rewrite the program in case constant

	 * blinding is active. However, in case of error during
@@ -1471,6 +1514,8 @@ struct bpf_prog *bpf_prog_select_runtime(struct bpf_prog *fp, int *err) 
		if (*err)

			return fp;

	}



finalize:

	bpf_prog_lock_ro(fp);



	/* The tail call compatibility check can only be done at
@@ -1479,7 +1524,17 @@ struct bpf_prog *bpf_prog_select_runtime(struct bpf_prog *fp, int *err) 
	 * all eBPF JITs might immediately support all features.

	 */

	*err = bpf_check_tail_call(fp);

	if (*err)

		return fp;



	/* Checkpoint: at this point onwards any cBPF -> eBPF or

	 * native eBPF program is read-only. If we failed to change

	 * the page attributes (e.g. allocation failure from

	 * splitting large pages), then reject the whole program

	 * in order to guarantee not ending up with any W+X pages

	 * from BPF side in kernel.

	 */

	*err = bpf_prog_check_pages_ro_locked(fp);

	return fp;

}

EXPORT_SYMBOL_GPL(bpf_prog_select_runtime);

kernel/bpf/devmap.c

+14 −0
Original line number Diff line number Diff line
@@ -345,6 +345,20 @@ int dev_map_enqueue(struct bpf_dtab_netdev *dst, struct xdp_buff *xdp, 
	return bq_enqueue(dst, xdpf, dev_rx);

}



int dev_map_generic_redirect(struct bpf_dtab_netdev *dst, struct sk_buff *skb,

			     struct bpf_prog *xdp_prog)

{

	int err;



	err = __xdp_generic_ok_fwd_dev(skb, dst->dev);

	if (unlikely(err))

		return err;

	skb->dev = dst->dev;

	generic_xdp_tx(skb, xdp_prog);



	return 0;

}



static void *dev_map_lookup_elem(struct bpf_map *map, void *key)

{

	struct bpf_dtab_netdev *obj = __dev_map_lookup_elem(map, *(u32 *)key);

kernel/bpf/syscall.c

+3 −9
Original line number Diff line number Diff line
@@ -1034,14 +1034,9 @@ static void __bpf_prog_put_rcu(struct rcu_head *rcu) 
static void __bpf_prog_put(struct bpf_prog *prog, bool do_idr_lock)

{

	if (atomic_dec_and_test(&prog->aux->refcnt)) {

		int i;



		/* bpf_prog_free_id() must be called first */

		bpf_prog_free_id(prog, do_idr_lock);



		for (i = 0; i < prog->aux->func_cnt; i++)

			bpf_prog_kallsyms_del(prog->aux->func[i]);

		bpf_prog_kallsyms_del(prog);

		bpf_prog_kallsyms_del_all(prog);



		call_rcu(&prog->aux->rcu, __bpf_prog_put_rcu);

	}
@@ -1358,8 +1353,6 @@ static int bpf_prog_load(union bpf_attr *attr) 
	if (err < 0)

		goto free_used_maps;



	/* eBPF program is ready to be JITed */

	if (!prog->bpf_func)

	prog = bpf_prog_select_runtime(prog, &err);

	if (err < 0)

		goto free_used_maps;
@@ -1384,6 +1377,7 @@ static int bpf_prog_load(union bpf_attr *attr) 
	return err;



free_used_maps:

	bpf_prog_kallsyms_del_subprogs(prog);

	free_used_maps(prog->aux);

free_prog:

	bpf_prog_uncharge_memlock(prog);

CRA Git | Maintained and supported by SUSTech CRA and CCSE