Two BPF fixes
Subsystems (4)
Daniel Borkmann
maintainercover Two BPF fixes
This set contains two BPF fixes for net, one that addresses the complaint from Geert wrt static allocations, and the other is a fix wrt mem accounting that I found recently during testing.
Thanks!
Daniel Borkmann (2):
bpf: dynamically allocate digest scratch buffer
bpf: fix overflow in prog accounting
include/linux/bpf.h | 2 +- include/linux/filter.h | 17 ++++++++-- kernel/bpf/core.c | 88 ++++++++++++++++++++++++++++++++++++++++++-------- kernel/bpf/syscall.c | 27 +--------------- kernel/bpf/verifier.c | 6 ++-- 5 files changed, 94 insertions(+), 46 deletions(-)
Signature · 1 line
1.9.3
Daniel Borkmann
maintainerPATCH 1/2 bpf: dynamically allocate digest scratch buffer
Geert rightfully complained that 7bd509e311f4 ("bpf: add prog_digest and expose it via fdinfo/netlink") added a too large allocation of variable 'raw' from bss section, and should instead be done dynamically:
# ./scripts/bloat-o-meter kernel/bpf/core.o.1 kernel/bpf/core.o.2 add/remove: 3/0 grow/shrink: 0/0 up/down: 33291/0 (33291) function old new delta raw - 32832 +32832 [...]
Since this is only relevant during program creation path, which can be considered slow-path anyway, lets allocate that dynamically and be not implicitly dependent on verifier mutex. Move bpf_prog_calc_digest() at the beginning of replace_map_fd_with_map_ptr() and also error handling stays straight forward.
--- include/linux/bpf.h | 2 +- include/linux/filter.h | 14 +++++++++++--- kernel/bpf/core.c | 27 ++++++++++++++++----------- kernel/bpf/syscall.c | 2 +- kernel/bpf/verifier.c | 6 ++++-- 5 files changed, 33 insertions(+), 18 deletions(-)
include/linux/bpf.h +1 -1
@@ -216,7 +216,7 @@ struct bpf_event_entry {u64 bpf_get_stackid (u64 r1,u64 r2,u64 r3,u64 r4,u64 r5);bool bpf_prog_array_compatible (struct bpf_array *array,const struct bpf_prog *fp); -void bpf_prog_calc_digest (struct bpf_prog *fp); +int bpf_prog_calc_digest (struct bpf_prog *fp);const struct bpf_func_proto *bpf_get_trace_printk_proto (void );
include/linux/filter.h +11 -3
@@ -57,9 +57,6 @@/* BPF program can access up to 512 bytes of stack space. */ #define MAX_BPF_STACK 512 -/* Maximum BPF program size in bytes. */ -#define MAX_BPF_SIZE (BPF_MAXINSNS * sizeof(struct bpf_insn)) -/* Helper macros for filter block array initializers. */ /* ALU ops on registers, bpf_add|sub|...: dst_reg += src_reg */
@@ -517,6 +514,17 @@ static __always_inline u32 bpf_prog_run_xdp(const struct bpf_prog *prog,return BPF_PROG_RUN (prog, xdp); } +static inline u32 bpf_prog_insn_size (const struct bpf_prog *prog) +{ +return prog->len *sizeof (struct bpf_insn ); +} + +static inline u32 bpf_prog_digest_scratch_size (const struct bpf_prog *prog) +{ +return round_up (bpf_prog_insn_size (prog) + +sizeof (__be64) +1 ,SHA_MESSAGE_BYTES ); +} +static inline unsigned int bpf_prog_size (unsigned int proglen) { return max(sizeof(struct bpf_prog),
kernel/bpf/core.c +16 -11
@@ -136,28 +136,29 @@ void __bpf_prog_free(struct bpf_prog *fp)vfree (fp); } -#define SHA_BPF_RAW_SIZE \ - round_up(MAX_BPF_SIZE + sizeof(__be64) + 1, SHA_MESSAGE_BYTES) - -/* Called under verifier mutex. */ -void bpf_prog_calc_digest (struct bpf_prog *fp) +int bpf_prog_calc_digest (struct bpf_prog *fp) {const u32 bits_offset =SHA_MESSAGE_BYTES -sizeof (__be64); -static u32 ws[SHA_WORKSPACE_WORDS ]; -static u8 raw[SHA_BPF_RAW_SIZE ]; -struct bpf_insn *dst = (void *)raw; +u32 raw_size =bpf_prog_digest_scratch_size (fp); +u32 ws[SHA_WORKSPACE_WORDS ];u32 i, bsize, psize, blocks; +struct bpf_insn *dst;bool was_ld_map; -u8 *todo = raw; +u8 *raw, *todo;__be32 *result;__be64 *bits; + raw =vmalloc (raw_size); +if (!raw) +return -ENOMEM ; +sha_init (fp->digest);memset (ws,0 ,sizeof (ws));/* We need to take out the map fd for the digest calculation * since they are unstable from user space side. */ + dst = (void *)raw;for (i =0 , was_ld_map = false; i < fp->len; i++) { dst[i] = fp->insnsi[i]; if (!was_ld_map &&
@@ -177,12 +178,13 @@ void bpf_prog_calc_digest(struct bpf_prog *fp) } } - psize = fp->len *sizeof (struct bpf_insn ); -memset (&raw[psize],0 ,sizeof (raw) - psize); + psize =bpf_prog_insn_size (fp); +memset (&raw[psize],0 , raw_size - psize); raw[psize++] =0x80 ; bsize =round_up (psize,SHA_MESSAGE_BYTES ); blocks = bsize /SHA_MESSAGE_BYTES ; + todo = raw;if (bsize - psize >=sizeof (__be64)) { bits = (__be64 *)(todo + bsize -sizeof (__be64)); }else {
@@ -199,6 +201,9 @@ void bpf_prog_calc_digest(struct bpf_prog *fp) result = (__force __be32 *)fp->digest;for (i =0 ; i <SHA_DIGEST_WORDS ; i++) result[i] =cpu_to_be32 (fp->digest[i]); + +vfree (raw); +return 0 ; }static bool bpf_is_jmp_and_has_target (const struct bpf_insn *insn)
kernel/bpf/syscall.c +1 -1
@@ -811,7 +811,7 @@ static int bpf_prog_load(union bpf_attr *attr) err = -EFAULT ;if (copy_from_user (prog->insns,u64_to_user_ptr (attr->insns), - prog->len *sizeof (struct bpf_insn )) !=0 ) +bpf_prog_insn_size (prog)) !=0 ) goto free_prog; prog->orig_prog =NULL ;
kernel/bpf/verifier.c +4 -2
@@ -2931,6 +2931,10 @@ static int replace_map_fd_with_map_ptr(struct bpf_verifier_env *env)int insn_cnt = env->prog->len;int i, j, err; + err =bpf_prog_calc_digest (env->prog); +if (err) +return err; +for (i =0 ; i < insn_cnt; i++, insn++) {if (BPF_CLASS (insn->code) ==BPF_LDX && (BPF_MODE (insn->code) !=BPF_MEM || insn->imm !=0 )) {
@@ -3178,8 +3182,6 @@ int bpf_check(struct bpf_prog **prog, union bpf_attr *attr) log_level =0 ; } -bpf_prog_calc_digest (env->prog); - ret =replace_map_fd_with_map_ptr (env);if (ret <0 ) goto skip_full_check;
Signature · 1 line
1.9.3
Daniel Borkmann
maintainerPATCH 2/2 bpf: fix overflow in prog accounting
In reply to Daniel BorkmannCommit aaac3ba95e4c ("bpf: charge user for creation of BPF maps and programs") made a wrong assumption of charging against prog->pages. Unlike map->pages, prog->pages are still subject to change when we need to expand the program through bpf_prog_realloc().
This can for example happen during verification stage when we need to expand and rewrite parts of the program. Should the required space cross a page boundary, then prog->pages is not the same anymore as its original value that we used to bpf_prog_charge_memlock() on. Thus, we'll hit a wrap-around during bpf_prog_uncharge_memlock() when prog is freed eventually. I noticed this that despite having unlimited memlock, programs suddenly refused to load with EPERM error due to insufficient memlock.
There are two ways to fix this issue. One would be to add a cached variable to struct bpf_prog that takes a snapshot of prog->pages at the time of charging. The other approach is to also account for resizes. I chose to go with the latter for a couple of reasons: i) We want accounting rather to be more accurate instead of further fooling limits, ii) adding yet another page counter on struct bpf_prog would also be a waste just for this purpose. We also do want to charge as early as possible to avoid going into the verifier just to find out later on that we crossed limits. The only place that needs to be fixed is bpf_prog_realloc(), since only here we expand the program, so we try to account for the needed delta and should we fail, call-sites check for outcome anyway. On cBPF to eBPF migrations, we don't grab a reference to the user as they are charged differently. With that in place, my test case worked fine.
--- include/linux/filter.h | 3 +++ kernel/bpf/core.c | 61 +++++++++++++++++++++++++++++++++++++++++++++++--- kernel/bpf/syscall.c | 25 --------------------- 3 files changed, 61 insertions(+), 28 deletions(-)
include/linux/filter.h +3 -0
@@ -577,6 +577,9 @@ struct bpf_prog *bpf_prog_realloc(struct bpf_prog *fp_old, unsigned int size, gfp_t gfp_extra_flags);void __bpf_prog_free (struct bpf_prog *fp); +int bpf_prog_charge_memlock (struct bpf_prog *prog); +void bpf_prog_uncharge_memlock (struct bpf_prog *prog); +static inline void bpf_prog_unlock_free (struct bpf_prog *fp) {bpf_prog_unlock_ro (fp);
kernel/bpf/core.c +58 -3
83 lines not on this page · raw message
kernel/bpf/syscall.c +0 -25
@@ -615,31 +615,6 @@ static void free_used_maps(struct bpf_prog_aux *aux)kfree (aux->used_maps); } -static int bpf_prog_charge_memlock (struct bpf_prog *prog) -{ -struct user_struct *user =get_current_user (); -unsigned long memlock_limit; - - memlock_limit =rlimit (RLIMIT_MEMLOCK ) >>PAGE_SHIFT ; - -atomic_long_add (prog->pages, &user->locked_vm); -if (atomic_long_read (&user->locked_vm) > memlock_limit) { -atomic_long_sub (prog->pages, &user->locked_vm); -free_uid (user); -return -EPERM ; - } - prog->aux->user = user; -return 0 ; -} - -static void bpf_prog_uncharge_memlock (struct bpf_prog *prog) -{ -struct user_struct *user = prog->aux->user; - -atomic_long_sub (prog->pages, &user->locked_vm); -free_uid (user); -} -static void __bpf_prog_put_rcu (struct rcu_head *rcu) { struct bpf_prog_aux *aux = container_of(rcu, struct bpf_prog_aux, rcu);
Signature · 1 line
1.9.3
kbuild test robot
build botRe: [PATCH net 2/2] bpf: fix overflow in prog accounting
url: https://github.com/0day-ci/linux/commits/Daniel-Borkmann/bpf-dynamically-allocate-digest-scratch-buffer/20161217-090046 config: sparc-defconfig (attached as .config) compiler: sparc-linux-gcc…
Hi Daniel,
[auto build test ERROR on net/master]
url: https://github.com/0day-ci/linux/commits/Daniel-Borkmann/bpf-dynamically-allocate-digest-scratch-buffer/20161217-090046
config: sparc-defconfig (attached as .config)
compiler: sparc-linux-gcc (GCC) 6.2.0
reproduce:
wget https://git.kernel.org/cgit/linux/kernel/git/wfg/lkp-tests.git/plain/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
make.cross ARCH=sparc
All errors (new ones prefixed by >>):
kernel/bpf/core.c: In function '__bpf_prog_charge':
>> kernel/bpf/core.c:80:50: error: 'struct user_struct' has no member named 'locked_vm'; did you mean 'locked_shm'?
user_bufs = atomic_long_add_return(pages, &user->locked_vm);
^~
kernel/bpf/core.c:82:32: error: 'struct user_struct' has no member named 'locked_vm'; did you mean 'locked_shm'?
atomic_long_sub(pages, &user->locked_vm);
^~
kernel/bpf/core.c: In function '__bpf_prog_uncharge':
kernel/bpf/core.c:93:31: error: 'struct user_struct' has no member named 'locked_vm'; did you mean 'locked_shm'?
atomic_long_sub(pages, &user->locked_vm);
^~vim +80 kernel/bpf/core.c
74 static int __bpf_prog_charge(struct user_struct *user, u32 pages)
75 {
76 unsigned long memlock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
77 unsigned long user_bufs;
78
79 if (user) {
> 80 user_bufs = atomic_long_add_return(pages, &user->locked_vm);
81 if (user_bufs > memlock_limit) {
82 atomic_long_sub(pages, &user->locked_vm);
83 return -EPERM;---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
kbuild test robot
build botRe: [PATCH net 2/2] bpf: fix overflow in prog accounting
In reply to Daniel Borkmannurl: https://github.com/0day-ci/linux/commits/Daniel-Borkmann/bpf-dynamically-allocate-digest-scratch-buffer/20161217-090046 config: openrisc-or1ksim_defconfig (attached as .config) compiler…
Hi Daniel,
[auto build test ERROR on net/master]
url: https://github.com/0day-ci/linux/commits/Daniel-Borkmann/bpf-dynamically-allocate-digest-scratch-buffer/20161217-090046
config: openrisc-or1ksim_defconfig (attached as .config)
compiler: or32-linux-gcc (GCC) 4.5.1-or32-1.0rc1
reproduce:
wget https://git.kernel.org/cgit/linux/kernel/git/wfg/lkp-tests.git/plain/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
make.cross ARCH=openrisc
All errors (new ones prefixed by >>):
kernel/bpf/core.c: In function '__bpf_prog_charge':
>> kernel/bpf/core.c:80:50: error: 'struct user_struct' has no member named 'locked_vm'
kernel/bpf/core.c:82:32: error: 'struct user_struct' has no member named 'locked_vm' kernel/bpf/core.c: In function '__bpf_prog_uncharge':
kernel/bpf/core.c:93:31: error: 'struct user_struct' has no member named 'locked_vm'
vim +80 kernel/bpf/core.c
74 static int __bpf_prog_charge(struct user_struct *user, u32 pages)
75 {
76 unsigned long memlock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
77 unsigned long user_bufs;
78
79 if (user) {
> 80 user_bufs = atomic_long_add_return(pages, &user->locked_vm);
81 if (user_bufs > memlock_limit) {
82 atomic_long_sub(pages, &user->locked_vm);
83 return -EPERM;---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
Daniel Borkmann
maintainerRe: [PATCH net 2/2] bpf: fix overflow in prog accounting
In reply to kbuild test robotQuoted 17 lines · kbuild test robot
Hi Daniel,
[auto build test ERROR on net/master]
url: https://github.com/0day-ci/linux/commits/Daniel-Borkmann/bpf-dynamically-allocate-digest-scratch-buffer/20161217-090046
config: sparc-defconfig (attached as .config)
compiler: sparc-linux-gcc (GCC) 6.2.0
reproduce:
wget https://git.kernel.org/cgit/linux/kernel/git/wfg/lkp-tests.git/plain/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
make.cross ARCH=sparcAll errors (new ones prefixed by >>):
kernel/bpf/core.c: In function '__bpf_prog_charge':Quoted 1 line
Quoted 1 line
kernel/bpf/core.c:80:50: error: 'structuser_struct' has no member named 'locked_vm'; did you mean 'locked_shm'?
Quoted 8 lines
user_bufs = atomic_long_add_return(pages, &user->locked_vm);
^~
kernel/bpf/core.c:82:32: error: 'struct user_struct' has no member named 'locked_vm'; did you mean 'locked_shm'?
atomic_long_sub(pages, &user->locked_vm);
^~
kernel/bpf/core.c: In function '__bpf_prog_uncharge':
kernel/bpf/core.c:93:31: error: 'struct user_struct' has no member named 'locked_vm'; did you mean 'locked_shm'?
atomic_long_sub(pages, &user->locked_vm);Argh, right, I'll send v2 later today.