Commit 7b16509b 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 

Alexei Starovoitov says:

====================
pull-request: bpf-next 2021-05-19

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

We've added 43 non-merge commits during the last 11 day(s) which contain
a total of 74 files changed, 3717 insertions(+), 578 deletions(-).

The main changes are:

1) syscall program type, fd array, and light skeleton, from Alexei.

2) Stop emitting static variables in skeleton, from Andrii.

3) Low level tc-bpf api, from Kumar.

4) Reduce verifier kmalloc/kfree churn, from Lorenz.
====================
parents 9287aa2b 3a2daa72

arch/arm64/net/bpf_jit_comp.c

+6 −13
Original line number Diff line number Diff line
@@ -178,9 +178,6 @@ static bool is_addsub_imm(u32 imm) 
	return !(imm & ~0xfff) || !(imm & ~0xfff000);

}



/* Stack must be multiples of 16B */

#define STACK_ALIGN(sz) (((sz) + 15) & ~15)



/* Tail call offset to jump into */

#if IS_ENABLED(CONFIG_ARM64_BTI_KERNEL)

#define PROLOGUE_OFFSET 8
@@ -255,7 +252,8 @@ static int build_prologue(struct jit_ctx *ctx, bool ebpf_from_cbpf) 
			emit(A64_BTI_J, ctx);

	}



	ctx->stack_size = STACK_ALIGN(prog->aux->stack_depth);

	/* Stack must be multiples of 16B */

	ctx->stack_size = round_up(prog->aux->stack_depth, 16);



	/* Set up function call stack */

	emit(A64_SUB_I(1, A64_SP, A64_SP, ctx->stack_size), ctx);
@@ -487,18 +485,13 @@ static int build_insn(const struct bpf_insn *insn, struct jit_ctx *ctx, 
		break;

	case BPF_ALU | BPF_DIV | BPF_X:

	case BPF_ALU64 | BPF_DIV | BPF_X:

	case BPF_ALU | BPF_MOD | BPF_X:

	case BPF_ALU64 | BPF_MOD | BPF_X:

		switch (BPF_OP(code)) {

		case BPF_DIV:

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

		break;

		case BPF_MOD:

	case BPF_ALU | BPF_MOD | BPF_X:

	case BPF_ALU64 | BPF_MOD | BPF_X:

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

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

		break;

		}

		break;

	case BPF_ALU | BPF_LSH | BPF_X:

	case BPF_ALU64 | BPF_LSH | BPF_X:

		emit(A64_LSLV(is64, dst, dst, src), ctx);

include/linux/bpf.h

+15 −4
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
#include <linux/sched/mm.h>

#include <linux/slab.h>

#include <linux/percpu-refcount.h>

#include <linux/bpfptr.h>



struct bpf_verifier_env;

struct bpf_verifier_log;
@@ -1428,7 +1429,7 @@ struct bpf_iter__bpf_map_elem { 
int bpf_iter_reg_target(const struct bpf_iter_reg *reg_info);

void bpf_iter_unreg_target(const struct bpf_iter_reg *reg_info);

bool bpf_iter_prog_supported(struct bpf_prog *prog);

int bpf_iter_link_attach(const union bpf_attr *attr, struct bpf_prog *prog);

int bpf_iter_link_attach(const union bpf_attr *attr, bpfptr_t uattr, struct bpf_prog *prog);

int bpf_iter_new_fd(struct bpf_link *link);

bool bpf_link_is_iter(struct bpf_link *link);

struct bpf_prog *bpf_iter_get_info(struct bpf_iter_meta *meta, bool in_stop);
@@ -1459,7 +1460,7 @@ int bpf_fd_htab_map_update_elem(struct bpf_map *map, struct file *map_file, 
int bpf_fd_htab_map_lookup_elem(struct bpf_map *map, void *key, u32 *value);



int bpf_get_file_flag(int flags);

int bpf_check_uarg_tail_zero(void __user *uaddr, size_t expected_size,

int bpf_check_uarg_tail_zero(bpfptr_t uaddr, size_t expected_size,

			     size_t actual_size);



/* memcpy that is used with 8-byte aligned pointers, power-of-8 size and
@@ -1479,8 +1480,7 @@ static inline void bpf_long_memcpy(void *dst, const void *src, u32 size) 
}



/* verify correctness of eBPF program */

int bpf_check(struct bpf_prog **fp, union bpf_attr *attr,

	      union bpf_attr __user *uattr);

int bpf_check(struct bpf_prog **fp, union bpf_attr *attr, bpfptr_t uattr);



#ifndef CONFIG_BPF_JIT_ALWAYS_ON

void bpf_patch_call_args(struct bpf_insn *insn, u32 stack_depth);
@@ -1826,6 +1826,9 @@ static inline bool bpf_map_is_dev_bound(struct bpf_map *map) 


struct bpf_map *bpf_map_offload_map_alloc(union bpf_attr *attr);

void bpf_map_offload_map_free(struct bpf_map *map);

int bpf_prog_test_run_syscall(struct bpf_prog *prog,

			      const union bpf_attr *kattr,

			      union bpf_attr __user *uattr);

#else

static inline int bpf_prog_offload_init(struct bpf_prog *prog,

					union bpf_attr *attr)
@@ -1851,6 +1854,13 @@ static inline struct bpf_map *bpf_map_offload_map_alloc(union bpf_attr *attr) 
static inline void bpf_map_offload_map_free(struct bpf_map *map)

{

}



static inline int bpf_prog_test_run_syscall(struct bpf_prog *prog,

					    const union bpf_attr *kattr,

					    union bpf_attr __user *uattr)

{

	return -ENOTSUPP;

}

#endif /* CONFIG_NET && CONFIG_BPF_SYSCALL */



#if defined(CONFIG_INET) && defined(CONFIG_BPF_SYSCALL)
@@ -1964,6 +1974,7 @@ extern const struct bpf_func_proto bpf_get_socket_ptr_cookie_proto; 
extern const struct bpf_func_proto bpf_task_storage_get_proto;

extern const struct bpf_func_proto bpf_task_storage_delete_proto;

extern const struct bpf_func_proto bpf_for_each_map_elem_proto;

extern const struct bpf_func_proto bpf_btf_find_by_name_kind_proto;



const struct bpf_func_proto *bpf_tracing_func_proto(

	enum bpf_func_id func_id, const struct bpf_prog *prog);

include/linux/bpf_types.h

+2 −0
Original line number Diff line number Diff line
@@ -77,6 +77,8 @@ BPF_PROG_TYPE(BPF_PROG_TYPE_LSM, lsm, 
	       void *, void *)

#endif /* CONFIG_BPF_LSM */

#endif

BPF_PROG_TYPE(BPF_PROG_TYPE_SYSCALL, bpf_syscall,

	      void *, void *)



BPF_MAP_TYPE(BPF_MAP_TYPE_ARRAY, array_map_ops)

BPF_MAP_TYPE(BPF_MAP_TYPE_PERCPU_ARRAY, percpu_array_map_ops)

include/linux/bpf_verifier.h

+9 −0
Original line number Diff line number Diff line
@@ -215,6 +215,13 @@ struct bpf_idx_pair { 
	u32 idx;

};



struct bpf_id_pair {

	u32 old;

	u32 cur;

};



/* Maximum number of register states that can exist at once */

#define BPF_ID_MAP_SIZE (MAX_BPF_REG + MAX_BPF_STACK / BPF_REG_SIZE)

#define MAX_CALL_FRAMES 8

struct bpf_verifier_state {

	/* call stack tracking */
@@ -418,6 +425,7 @@ struct bpf_verifier_env { 
	const struct bpf_line_info *prev_linfo;

	struct bpf_verifier_log log;

	struct bpf_subprog_info subprog_info[BPF_MAX_SUBPROGS + 1];

	struct bpf_id_pair idmap_scratch[BPF_ID_MAP_SIZE];

	struct {

		int *insn_state;

		int *insn_stack;
@@ -442,6 +450,7 @@ struct bpf_verifier_env { 
	u32 peak_states;

	/* longest register parentage chain walked for liveness marking */

	u32 longest_mark_read_walk;

	bpfptr_t fd_array;

};



__printf(2, 0) void bpf_verifier_vlog(struct bpf_verifier_log *log,

include/linux/bpfptr.h

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

/* A pointer that can point to either kernel or userspace memory. */

#ifndef _LINUX_BPFPTR_H

#define _LINUX_BPFPTR_H



#include <linux/sockptr.h>



typedef sockptr_t bpfptr_t;



static inline bool bpfptr_is_kernel(bpfptr_t bpfptr)

{

	return bpfptr.is_kernel;

}



static inline bpfptr_t KERNEL_BPFPTR(void *p)

{

	return (bpfptr_t) { .kernel = p, .is_kernel = true };

}



static inline bpfptr_t USER_BPFPTR(void __user *p)

{

	return (bpfptr_t) { .user = p };

}



static inline bpfptr_t make_bpfptr(u64 addr, bool is_kernel)

{

	if (is_kernel)

		return KERNEL_BPFPTR((void*) (uintptr_t) addr);

	else

		return USER_BPFPTR(u64_to_user_ptr(addr));

}



static inline bool bpfptr_is_null(bpfptr_t bpfptr)

{

	if (bpfptr_is_kernel(bpfptr))

		return !bpfptr.kernel;

	return !bpfptr.user;

}



static inline void bpfptr_add(bpfptr_t *bpfptr, size_t val)

{

	if (bpfptr_is_kernel(*bpfptr))

		bpfptr->kernel += val;

	else

		bpfptr->user += val;

}



static inline int copy_from_bpfptr_offset(void *dst, bpfptr_t src,

					  size_t offset, size_t size)

{

	return copy_from_sockptr_offset(dst, (sockptr_t) src, offset, size);

}



static inline int copy_from_bpfptr(void *dst, bpfptr_t src, size_t size)

{

	return copy_from_bpfptr_offset(dst, src, 0, size);

}



static inline int copy_to_bpfptr_offset(bpfptr_t dst, size_t offset,

					const void *src, size_t size)

{

	return copy_to_sockptr_offset((sockptr_t) dst, offset, src, size);

}



static inline void *memdup_bpfptr(bpfptr_t src, size_t len)

{

	return memdup_sockptr((sockptr_t) src, len);

}



static inline long strncpy_from_bpfptr(char *dst, bpfptr_t src, size_t count)

{

	return strncpy_from_sockptr(dst, (sockptr_t) src, count);

}



#endif /* _LINUX_BPFPTR_H */