introduce bpf_spin_lock
Subsystems (8)
Alexei Starovoitov
maintainerv7 cover introduce bpf_spin_lock
Many algorithms need to read and modify several variables atomically. Until now it was hard to impossible to implement such algorithms in BPF. Hence introduce support for bpf_spin_lock.
The api consists of 'struct bpf_spin_lock' that should be placed inside hash/array/cgroup_local_storage element
and bpf_spin_lock/unlock() helper function.
Example:
struct hash_elem {
int cnt;
struct bpf_spin_lock lock;
};
struct hash_elem * val = bpf_map_lookup_elem(&hash_map, &key);
if (val) {
bpf_spin_lock(&val->lock);
val->cnt++;
bpf_spin_unlock(&val->lock);
}and BPF_F_LOCK flag for lookup/update bpf syscall commands that allows user space to read/write map elements under lock.
Together these primitives allow race free access to map elements from bpf programs and from user space.
Key restriction: root only.
Key requirement: maps must be annotated with BTF.
This concept was discussed at Linux Plumbers Conference 2018. Thank you everyone who participated and helped to iron out details of api and implementation.
Patch 1: bpf_spin_lock support in the verifier, BTF, hash, array. Patch 2: bpf_spin_lock in cgroup local storage.
Patches 3,4,5: tests
Patch 6: BPF_F_LOCK flag to lookup/update
Patches 7,8,9: tests
v6->v7:
- fixed this_cpu->__this_cpu per Peter's suggestion and added Ack.
- simplified bpf_spin_lock and load/store overlap check in the verifier as suggested by Andrii
- rebase
v5->v6:
- adopted arch_spinlock approach suggested by Peter
- switched to spin_lock_irqsave equivalent as the simplest way to avoid deadlocks in rare case of nested networking progs (cgroup-bpf prog in preempt_disable vs clsbpf in softirq sharing the same map with bpf_spin_lock)
bpf_spin_lock is only allowed in networking progs that don't have arbitrary entry points unlike tracing progs.
- rebase and split test_verifier tests
v4->v5:
- disallow bpf_spin_lock for tracing progs due to insufficient preemption checks
- socket filter progs cannot use bpf_spin_lock due to missing preempt_disable
- fix atomic_set_release. Spotted by Peter.
- fixed hash_of_maps
v3->v4:
- fix BPF_EXIST | BPF_NOEXIST check patch 6. Spotted by Jakub. Thanks!
- rebase
v2->v3:
- fixed build on ia64 and archs where qspinlock is not supported
- fixed missing lock init during lookup w/o BPF_F_LOCK. Spotted by Martin
v1->v2:
- addressed several issues spotted by Daniel and Martin in patch 1
- added test11 to patch 4 as suggested by Daniel
Alexei Starovoitov (9):
bpf: introduce bpf_spin_lock
bpf: add support for bpf_spin_lock to cgroup local storage tools/bpf: sync include/uapi/linux/bpf.h selftests/bpf: add bpf_spin_lock verifier tests selftests/bpf: add bpf_spin_lock C test
bpf: introduce BPF_F_LOCK flag
tools/bpf: sync uapi/bpf.h
libbpf: introduce bpf_map_lookup_elem_flags() selftests/bpf: test for BPF_F_LOCK
include/linux/bpf.h | 39 ++- include/linux/bpf_verifier.h | 1 + include/linux/btf.h | 1 + include/uapi/linux/bpf.h | 8 +- kernel/Kconfig.locks | 3 + kernel/bpf/arraymap.c | 23 +- kernel/bpf/btf.c | 42 +++ kernel/bpf/core.c | 2 + kernel/bpf/hashtab.c | 63 +++- kernel/bpf/helpers.c | 96 +++++ kernel/bpf/local_storage.c | 16 +- kernel/bpf/map_in_map.c | 5 + kernel/bpf/syscall.c | 45 ++- kernel/bpf/verifier.c | 171 ++++++++- net/core/filter.c | 16 +- tools/include/uapi/linux/bpf.h | 8 +- tools/lib/bpf/bpf.c | 13 + tools/lib/bpf/bpf.h | 2 + tools/lib/bpf/libbpf.map | 1 + tools/testing/selftests/bpf/Makefile | 2 +- tools/testing/selftests/bpf/bpf_helpers.h | 4 + tools/testing/selftests/bpf/test_map_lock.c | 66 ++++ tools/testing/selftests/bpf/test_progs.c | 117 ++++++- tools/testing/selftests/bpf/test_spin_lock.c | 108 ++++++ tools/testing/selftests/bpf/test_verifier.c | 104 +++++- .../selftests/bpf/verifier/spin_lock.c | 331 ++++++++++++++++++ 26 files changed, 1248 insertions(+), 39 deletions(-) create mode 100644 tools/testing/selftests/bpf/test_map_lock.c create mode 100644 tools/testing/selftests/bpf/test_spin_lock.c create mode 100644 tools/testing/selftests/bpf/verifier/spin_lock.c
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH v7 2/9 bpf: add support for bpf_spin_lock to cgroup local storage
Allow 'struct bpf_spin_lock' to reside inside cgroup local storage.
--- kernel/bpf/local_storage.c | 2 ++ kernel/bpf/syscall.c | 3 ++- kernel/bpf/verifier.c | 2 ++ 3 files changed, 6 insertions(+), 1 deletion(-)
kernel/bpf/local_storage.c +2 -0
@@ -147,6 +147,7 @@ static int cgroup_storage_update_elem(struct bpf_map *map, void *_key,return -ENOMEM ;memcpy (&new->data[0 ], value, map->value_size); +check_and_init_map_lock (map, new->data); new =xchg (&storage->buf, new);kfree_rcu (new, rcu);
@@ -483,6 +484,7 @@ struct bpf_cgroup_storage *bpf_cgroup_storage_alloc(struct bpf_prog *prog, storage->buf =kmalloc_node (size, flags, map->numa_node);if (!storage->buf) goto enomem; +check_and_init_map_lock (map, storage->buf->data); }else { storage->percpu_buf =__alloc_percpu_gfp (size,8 , flags);if (!storage->percpu_buf)
kernel/bpf/syscall.c +2 -1
@@ -482,7 +482,8 @@ static int map_check_btf(struct bpf_map *map, const struct btf *btf,if (map_value_has_spin_lock (map)) {if (map->map_type !=BPF_MAP_TYPE_HASH && - map->map_type !=BPF_MAP_TYPE_ARRAY ) + map->map_type !=BPF_MAP_TYPE_ARRAY && + map->map_type !=BPF_MAP_TYPE_CGROUP_STORAGE )return -ENOTSUPP ;if (map->spin_lock_off +sizeof (struct bpf_spin_lock ) > map->value_size) {
kernel/bpf/verifier.c +2 -0
@@ -3089,6 +3089,8 @@ static int check_helper_call(struct bpf_verifier_env *env, int func_id, int insn regs[BPF_REG_0 ].map_ptr = meta.map_ptr;if (fn->ret_type ==RET_PTR_TO_MAP_VALUE ) { regs[BPF_REG_0 ].type =PTR_TO_MAP_VALUE ; +if (map_value_has_spin_lock (meta.map_ptr)) + regs[BPF_REG_0 ].id = ++env->id_gen; }else { regs[BPF_REG_0 ].type =PTR_TO_MAP_VALUE_OR_NULL ; regs[BPF_REG_0 ].id = ++env->id_gen;
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH v7 3/9 tools/bpf: sync include/uapi/linux/bpf.h
In reply to Alexei Starovoitovsync bpf.h
--- tools/include/uapi/linux/bpf.h | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
tools/include/uapi/linux/bpf.h +6 -1
@@ -2422,7 +2422,9 @@ union bpf_attr {FN (map_peek_elem), \FN (msg_push_data), \FN (msg_pop_data), \ -FN (rc_pointer_rel), +FN (rc_pointer_rel), \ +FN (spin_lock), \ +FN (spin_unlock),/* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call
@@ -3056,4 +3058,7 @@ struct bpf_line_info { __u32 line_col; }; +struct bpf_spin_lock { +__u32 val; +};#endif /* _UAPI__LINUX_BPF_H__ */
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH v7 1/9 bpf: introduce bpf_spin_lock
In reply to Alexei StarovoitovIntroduce 'struct bpf_spin_lock' and bpf_spin_lock/unlock() helpers to let bpf program serialize access to other variables.
Example:
struct hash_elem {
int cnt;
struct bpf_spin_lock lock;
};
struct hash_elem * val = bpf_map_lookup_elem(&hash_map, &key);
if (val) {
bpf_spin_lock(&val->lock);
val->cnt++;
bpf_spin_unlock(&val->lock);
}Restrictions and safety checks:
- bpf_spin_lock is only allowed inside HASH and ARRAY maps.
- BTF description of the map is mandatory for safety analysis.
- bpf program can take one bpf_spin_lock at a time, since two or more can cause dead locks.
- only one 'struct bpf_spin_lock' is allowed per map element.
It drastically simplifies implementation yet allows bpf program to use any number of bpf_spin_locks.
- when bpf_spin_lock is taken the calls (either bpf2bpf or helpers) are not allowed.
- bpf program must bpf_spin_unlock() before return.
- bpf program can access 'struct bpf_spin_lock' only via bpf_spin_lock()/bpf_spin_unlock() helpers.
- load/store into 'struct bpf_spin_lock lock;' field is not allowed.
- to use bpf_spin_lock() helper the BTF description of map value must be a struct and have 'struct bpf_spin_lock anyname;' field at the top level. Nested lock inside another struct is not allowed.
- syscall map_lookup doesn't copy bpf_spin_lock field to user space.
- syscall map_update and program map_update do not update bpf_spin_lock field.
- bpf_spin_lock cannot be on the stack or inside networking packet. bpf_spin_lock can only be inside HASH or ARRAY map value.
- bpf_spin_lock is available to root only and to all program types.
- bpf_spin_lock is not allowed in inner maps of map-in-map.
- ld_abs is not allowed inside spin_lock-ed region.
- tracing progs and socket filter progs cannot use bpf_spin_lock due to insufficient preemption checks
Implementation details:
- cgroup-bpf class of programs can nest with xdp/tc programs. Hence bpf_spin_lock is equivalent to spin_lock_irqsave. Other solutions to avoid nested bpf_spin_lock are possible. Like making sure that all networking progs run with softirq disabled. spin_lock_irqsave is the simplest and doesn't add overhead to the programs that don't use it.
- arch_spinlock_t is used when its implemented as queued_spin_lock
- archs can force their own arch_spinlock_t
- on architectures where queued_spin_lock is not available and sizeof(arch_spinlock_t) != sizeof(__u32) trivial lock is used.
- presence of bpf_spin_lock inside map value could have been indicated via extra flag during map_create, but specifying it via BTF is cleaner. It provides introspection for map key/value and reduces user mistakes.
Next steps:
- allow bpf_spin_lock in other map types (like cgroup local storage)
- introduce BPF_F_LOCK flag for bpf_map_update() syscall and helper to request kernel to grab bpf_spin_lock before rewriting the value. That will serialize access to map elements.
--- include/linux/bpf.h | 37 +++++++- include/linux/bpf_verifier.h | 1 + include/linux/btf.h | 1 + include/uapi/linux/bpf.h | 7 +- kernel/Kconfig.locks | 3 + kernel/bpf/arraymap.c | 7 +- kernel/bpf/btf.c | 42 +++++++++ kernel/bpf/core.c | 2 + kernel/bpf/hashtab.c | 21 +++-- kernel/bpf/helpers.c | 80 +++++++++++++++++ kernel/bpf/map_in_map.c | 5 ++ kernel/bpf/syscall.c | 21 ++++- kernel/bpf/verifier.c | 169 ++++++++++++++++++++++++++++++++++- net/core/filter.c | 16 +++- 14 files changed, 386 insertions(+), 26 deletions(-)
include/linux/bpf.h +34 -3
@@ -72,14 +72,15 @@ struct bpf_map {u32 value_size;u32 max_entries;u32 map_flags; -u32 pages; +int spin_lock_off;/* >=0 valid offset, <0 error */ u32 id;int numa_node;u32 btf_key_type_id;u32 btf_value_type_id;struct btf *btf; +u32 pages;bool unpriv_array; -/* 55 bytes hole */ +/* 51 bytes hole */ /* The 3rd and 4th cacheline with misc members to avoid false sharing * particularly with refcounting.
@@ -91,6 +92,34 @@ struct bpf_map {char name[BPF_OBJ_NAME_LEN ]; }; +static inline bool map_value_has_spin_lock (const struct bpf_map *map) +{ +return map->spin_lock_off >=0 ; +} + +static inline void check_and_init_map_lock (struct bpf_map *map,void *dst) +{ +if (likely (!map_value_has_spin_lock (map))) +return ; + *(struct bpf_spin_lock *)(dst + map->spin_lock_off) = + (struct bpf_spin_lock ){}; +} + +/* copy everything but bpf_spin_lock */ +static inline void copy_map_value (struct bpf_map *map,void *dst,void *src) +{ +if (unlikely (map_value_has_spin_lock (map))) { +u32 off = map->spin_lock_off; + +memcpy (dst, src, off); +memcpy (dst + off +sizeof (struct bpf_spin_lock ), + src + off +sizeof (struct bpf_spin_lock ), + map->value_size - off -sizeof (struct bpf_spin_lock )); + }else { +memcpy (dst, src, map->value_size); + } +} +struct bpf_offload_dev ;struct bpf_offloaded_map ;
@@ -162,6 +191,7 @@ enum bpf_arg_type {ARG_PTR_TO_CTX ,/* pointer to context */ ARG_ANYTHING ,/* any (initialized) argument is ok */ ARG_PTR_TO_SOCKET ,/* pointer to bpf_sock */ + ARG_PTR_TO_SPIN_LOCK, /* pointer to bpf_spin_lock */ };/* type of values returned from helper functions */
@@ -879,7 +909,8 @@ extern const struct bpf_func_proto bpf_msg_redirect_hash_proto;extern const struct bpf_func_proto bpf_msg_redirect_map_proto;extern const struct bpf_func_proto bpf_sk_redirect_hash_proto;extern const struct bpf_func_proto bpf_sk_redirect_map_proto; - +extern const struct bpf_func_proto bpf_spin_lock_proto; +extern const struct bpf_func_proto bpf_spin_unlock_proto;extern const struct bpf_func_proto bpf_get_local_storage_proto;/* Shared helpers among cBPF and eBPF. */
include/linux/bpf_verifier.h +1 -0
@@ -148,6 +148,7 @@ struct bpf_verifier_state {/* call stack tracking */ struct bpf_func_state *frame[MAX_CALL_FRAMES ];u32 curframe; +u32 active_spin_lock;bool speculative; };
include/linux/btf.h +1 -0
@@ -50,6 +50,7 @@ u32 btf_id(const struct btf *btf);bool btf_member_is_reg_int (const struct btf *btf,const struct btf_type *s,const struct btf_member *m,u32 expected_offset,u32 expected_size); +int btf_find_spin_lock (const struct btf *btf,const struct btf_type *t);#ifdef CONFIG_BPF_SYSCALL const struct btf_type *btf_type_by_id (const struct btf *btf,u32 type_id);
include/uapi/linux/bpf.h +6 -1
@@ -2422,7 +2422,9 @@ union bpf_attr {FN (map_peek_elem), \FN (msg_push_data), \FN (msg_pop_data), \ -FN (rc_pointer_rel), +FN (rc_pointer_rel), \ +FN (spin_lock), \ +FN (spin_unlock),/* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call
@@ -3056,4 +3058,7 @@ struct bpf_line_info { __u32 line_col; }; +struct bpf_spin_lock { +__u32 val; +};#endif /* _UAPI__LINUX_BPF_H__ */
kernel/Kconfig.locks +3 -0
@@ -242,6 +242,9 @@ config QUEUED_SPINLOCKS def_bool y if ARCH_USE_QUEUED_SPINLOCKS depends on SMP +config BPF_ARCH_SPINLOCK + bool + config ARCH_USE_QUEUED_RWLOCKS bool
kernel/bpf/arraymap.c +4 -3
@@ -270,9 +270,10 @@ static int array_map_update_elem(struct bpf_map *map, void *key, void *value,memcpy (this_cpu_ptr (array->pptrs[index & array->index_mask]), value, map->value_size); else - memcpy(array->value + - array->elem_size * (index & array->index_mask), - value, map->value_size); + copy_map_value(map, + array->value + + array->elem_size * (index & array->index_mask), +value );return 0 ; }
kernel/bpf/btf.c +42 -0
54 lines not on this page · raw message
kernel/bpf/core.c +2 -0
@@ -2002,6 +2002,8 @@ const struct bpf_func_proto bpf_map_delete_elem_proto __weak;const struct bpf_func_proto bpf_map_push_elem_proto__weak ;const struct bpf_func_proto bpf_map_pop_elem_proto__weak ;const struct bpf_func_proto bpf_map_peek_elem_proto__weak ; +const struct bpf_func_proto bpf_spin_lock_proto__weak ; +const struct bpf_func_proto bpf_spin_unlock_proto__weak ;const struct bpf_func_proto bpf_get_prandom_u32_proto__weak ;const struct bpf_func_proto bpf_get_smp_processor_id_proto__weak ;
kernel/bpf/hashtab.c +10 -11
@@ -718,21 +718,12 @@ static bool fd_htab_map_needs_adjust(const struct bpf_htab *htab)BITS_PER_LONG ==64 ; } -static u32 htab_size_value (const struct bpf_htab *htab,bool percpu) -{ -u32 size = htab->map.value_size; - -if (percpu ||fd_htab_map_needs_adjust (htab)) - size =round_up (size,8 ); -return size; -} -static struct htab_elem *alloc_htab_elem (struct bpf_htab *htab,void *key,void *value,u32 key_size,u32 hash,bool percpu,bool onallcpus,struct htab_elem *old_elem) { -u32 size =htab_size_value (htab, percpu); +u32 size = htab->map.value_size;bool prealloc =htab_is_prealloc (htab);struct htab_elem *l_new, **pl_new;void __percpu *pptr;
@@ -770,10 +761,13 @@ static struct htab_elem *alloc_htab_elem(struct bpf_htab *htab, void *key, l_new =ERR_PTR (-ENOMEM ); goto dec_count; } +check_and_init_map_lock (&htab->map, + l_new->key +round_up (key_size,8 )); }memcpy (l_new->key, key, key_size);if (percpu) { + size =round_up (size,8 );if (prealloc) { pptr =htab_elem_get_ptr (l_new, key_size); }else {
@@ -791,8 +785,13 @@ static struct htab_elem *alloc_htab_elem(struct bpf_htab *htab, void *key,if (!prealloc)htab_elem_set_ptr (l_new, key_size, pptr); - }else { + }else if (fd_htab_map_needs_adjust (htab)) { + size =round_up (size,8 );memcpy (l_new->key +round_up (key_size,8 ), value, size); + }else { +copy_map_value (&htab->map, + l_new->key +round_up (key_size,8 ), + value); } l_new->hash = hash;
kernel/bpf/helpers.c +80 -0
86 lines not on this page · raw message
kernel/bpf/map_in_map.c +5 -0
@@ -37,6 +37,11 @@ struct bpf_map *bpf_map_meta_alloc(int inner_map_ufd)return ERR_PTR (-EINVAL ); } +if (map_value_has_spin_lock (inner_map)) { +fdput (f); +return ERR_PTR (-ENOTSUPP ); + } + inner_map_meta_size =sizeof (*inner_map_meta);/* In some cases verifier needs to access beyond just base map. */ if (inner_map->ops == &array_map_ops)
kernel/bpf/syscall.c +19 -2
@@ -463,7 +463,7 @@ int map_check_no_btf(const struct bpf_map *map,return -ENOTSUPP ; } -static int map_check_btf (const struct bpf_map *map,const struct btf *btf, +static int map_check_btf (struct bpf_map *map,const struct btf *btf,u32 btf_key_id,u32 btf_value_id) {const struct btf_type *key_type, *value_type;
@@ -478,6 +478,21 @@ static int map_check_btf(const struct bpf_map *map, const struct btf *btf,if (!value_type || value_size != map->value_size)return -EINVAL ; + map->spin_lock_off =btf_find_spin_lock (btf, value_type); + +if (map_value_has_spin_lock (map)) { +if (map->map_type !=BPF_MAP_TYPE_HASH && + map->map_type !=BPF_MAP_TYPE_ARRAY ) +return -ENOTSUPP ; +if (map->spin_lock_off +sizeof (struct bpf_spin_lock ) > + map->value_size) { +WARN_ONCE (1 , +"verifier bug spin_lock_off %d value_size %d\n" , + map->spin_lock_off, map->value_size); +return -EFAULT ; + } + } +if (map->ops->map_check_btf) ret = map->ops->map_check_btf (map, btf, key_type, value_type);
@@ -542,6 +557,8 @@ static int map_create(union bpf_attr *attr) map->btf = btf; map->btf_key_type_id = attr->btf_key_type_id; map->btf_value_type_id = attr->btf_value_type_id; + }else { + map->spin_lock_off = -EINVAL ; } err =security_bpf_map_alloc (map);
@@ -740,7 +757,7 @@ static int map_lookup_elem(union bpf_attr *attr) err = -ENOENT ; }else { err =0 ; -memcpy (value, ptr, value_size); +copy_map_value (map, value, ptr); }rcu_read_unlock (); }
kernel/bpf/verifier.c +166 -3
259 lines not on this page · raw message
net/core/filter.c +13 -3
@@ -5314,10 +5314,20 @@ bpf_base_func_proto(enum bpf_func_id func_id)return &bpf_tail_call_proto;case BPF_FUNC_ktime_get_ns:return &bpf_ktime_get_ns_proto; +default : +break ; + } + +if (!capable (CAP_SYS_ADMIN )) +return NULL ; + +switch (func_id) { +case BPF_FUNC_spin_lock: +return &bpf_spin_lock_proto; +case BPF_FUNC_spin_unlock: +return &bpf_spin_unlock_proto;case BPF_FUNC_trace_printk: -if (capable (CAP_SYS_ADMIN )) -return bpf_get_trace_printk_proto (); -/* else, fall through */ +return bpf_get_trace_printk_proto ();default :return NULL ; }
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH v7 4/9 selftests/bpf: add bpf_spin_lock verifier tests
In reply to Alexei Starovoitovadd bpf_spin_lock tests to test_verifier.c that don't require latest llvm with BTF support
--- tools/testing/selftests/bpf/test_verifier.c | 104 +++++- .../selftests/bpf/verifier/spin_lock.c | 331 ++++++++++++++++++ 2 files changed, 434 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/bpf/verifier/spin_lock.c
tools/testing/selftests/bpf/test_verifier.c +103 -1
@@ -32,6 +32,7 @@#include <linux/bpf_perf_event.h> #include <linux/bpf.h> #include <linux/if_ether.h> +#include <linux/btf.h> #include <bpf/bpf.h> #include <bpf/libbpf.h>
@@ -50,7 +51,7 @@#define MAX_INSNS BPF_MAXINSNS#define MAX_FIXUPS 8 -#define MAX_NR_MAPS 13 +#define MAX_NR_MAPS 14#define MAX_TEST_RUNS 8#define POINTER_VALUE 0xcafe4all#define TEST_DATA_LEN 64
@@ -78,6 +79,7 @@ struct bpf_test {int fixup_map_in_map[MAX_FIXUPS ];int fixup_cgroup_storage[MAX_FIXUPS ];int fixup_percpu_cgroup_storage[MAX_FIXUPS ]; +int fixup_map_spin_lock[MAX_FIXUPS ];const char *errstr;const char *errstr_unpriv;uint32_t retval, retval_unpriv, insn_processed;
@@ -406,6 +408,98 @@ static int create_cgroup_storage(bool percpu)return fd; } +#define BTF_INFO_ENC (kind, kind_flag, vlen) \ + ((!!(kind_flag) << 31) | ((kind) << 24) | ((vlen) & BTF_MAX_VLEN)) +#define BTF_TYPE_ENC (name, info, size_or_type) \ + (name), (info), (size_or_type) +#define BTF_INT_ENC (encoding, bits_offset, nr_bits) \ + ((encoding) << 24 | (bits_offset) << 16 | (nr_bits)) +#define BTF_TYPE_INT_ENC (name, encoding, bits_offset, bits, sz) \ + BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_INT, 0, 0), sz), \ + BTF_INT_ENC(encoding, bits_offset, bits) +#define BTF_MEMBER_ENC (name, type, bits_offset) \ + (name), (type), (bits_offset) + +struct btf_raw_data { +__u32 raw_types[64 ]; +const char *str_sec; +__u32 str_sec_size; +}; + +/* struct bpf_spin_lock { +* int val; +* }; +* struct val { +* int cnt; +* struct bpf_spin_lock l; +* }; +*/ +static const char btf_str_sec[] ="\0bpf_spin_lock\0val\0cnt\0l" ; +static __u32 btf_raw_types[] = { +/* int */ +BTF_TYPE_INT_ENC (0 ,BTF_INT_SIGNED ,0 ,32 ,4 ),/* [1] */ +/* struct bpf_spin_lock */ /* [2] */ +BTF_TYPE_ENC (1 ,BTF_INFO_ENC (BTF_KIND_STRUCT ,0 ,1 ),4 ), +BTF_MEMBER_ENC (15 ,1 ,0 ),/* int val; */ +/* struct val */ /* [3] */ +BTF_TYPE_ENC (15 ,BTF_INFO_ENC (BTF_KIND_STRUCT ,0 ,2 ),8 ), +BTF_MEMBER_ENC (19 ,1 ,0 ),/* int cnt; */ +BTF_MEMBER_ENC (23 ,2 ,32 ),/* struct bpf_spin_lock l; */ +}; + +static int load_btf (void ) +{ +struct btf_header hdr = { + .magic =BTF_MAGIC , + .version =BTF_VERSION , + .hdr_len =sizeof (struct btf_header ), + .type_len =sizeof (btf_raw_types), + .str_off =sizeof (btf_raw_types), + .str_len =sizeof (btf_str_sec), + }; +void *ptr, *raw_btf; +int btf_fd; + + ptr = raw_btf =malloc (sizeof (hdr) +sizeof (btf_raw_types) + +sizeof (btf_str_sec)); + +memcpy (ptr, &hdr,sizeof (hdr)); + ptr +=sizeof (hdr); +memcpy (ptr, btf_raw_types, hdr.type_len); + ptr += hdr.type_len; +memcpy (ptr, btf_str_sec, hdr.str_len); + ptr += hdr.str_len; + + btf_fd =bpf_load_btf (raw_btf, ptr - raw_btf,0 ,0 ,0 ); +free (raw_btf); +if (btf_fd <0 ) +return -1 ; +return btf_fd; +} + +static int create_map_spin_lock (void ) +{ +struct bpf_create_map_attr attr = { + .name ="test_map" , + .map_type =BPF_MAP_TYPE_ARRAY , + .key_size =4 , + .value_size =8 , + .max_entries =1 , + .btf_key_type_id =1 , + .btf_value_type_id =3 , + }; +int fd, btf_fd; + + btf_fd =load_btf (); +if (btf_fd <0 ) +return -1 ; + attr.btf_fd = btf_fd; + fd =bpf_create_map_xattr (&attr); +if (fd <0 ) +printf ("Failed to create map with spin_lock\n" ); +return fd; +} +static char bpf_vlog[UINT_MAX >>8 ]; static void do_test_fixup(struct bpf_test *test, enum bpf_prog_type prog_type,
@@ -424,6 +518,7 @@ static void do_test_fixup(struct bpf_test *test, enum bpf_prog_type prog_type,int *fixup_map_in_map = test->fixup_map_in_map;int *fixup_cgroup_storage = test->fixup_cgroup_storage;int *fixup_percpu_cgroup_storage = test->fixup_percpu_cgroup_storage; +int *fixup_map_spin_lock = test->fixup_map_spin_lock;if (test->fill_helper) test->fill_helper (test);
@@ -540,6 +635,13 @@ static void do_test_fixup(struct bpf_test *test, enum bpf_prog_type prog_type, fixup_map_stacktrace++; }while (*fixup_map_stacktrace); } +if (*fixup_map_spin_lock) { + map_fds[13 ] =create_map_spin_lock (); +do { + prog[*fixup_map_spin_lock].imm = map_fds[13 ]; + fixup_map_spin_lock++; + }while (*fixup_map_spin_lock); + } }static int set_admin (bool admin)
tools/testing/selftests/bpf/verifier/spin_lock.c new file +331 -0
331 lines not on this page · raw message
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH v7 6/9 bpf: introduce BPF_F_LOCK flag
In reply to Alexei StarovoitovIntroduce BPF_F_LOCK flag for map_lookup and map_update syscall commands and for map_update() helper function.
In all these cases take a lock of existing element (which was provided in BTF description) before copying (in or out) the rest of map value.
Implementation details that are part of uapi:
Array:
The array map takes the element lock for lookup/update.
Hash:
hash map also takes the lock for lookup/update and tries to avoid the bucket lock. If old element exists it takes the element lock and updates the element in place. If element doesn't exist it allocates new one and inserts into hash table while holding the bucket lock.
In rare case the hashmap has to take both the bucket lock and the element lock to update old value in place.
Cgroup local storage:
It is similar to array. update in place and lookup are done with lock taken.
--- include/linux/bpf.h | 2 ++ include/uapi/linux/bpf.h | 1 + kernel/bpf/arraymap.c | 24 ++++++++++++++-------- kernel/bpf/hashtab.c | 42 +++++++++++++++++++++++++++++++++++--- kernel/bpf/helpers.c | 16 +++++++++++++++ kernel/bpf/local_storage.c | 14 ++++++++++++- kernel/bpf/syscall.c | 25 +++++++++++++++++++++-- 7 files changed, 110 insertions(+), 14 deletions(-)
include/linux/bpf.h +2 -0
@@ -119,6 +119,8 @@ static inline void copy_map_value(struct bpf_map *map, void *dst, void *src)memcpy (dst, src, map->value_size); } } +void copy_map_value_locked (struct bpf_map *map,void *dst,void *src, +bool lock_src);struct bpf_offload_dev ;struct bpf_offloaded_map ;
include/uapi/linux/bpf.h +1 -0
@@ -267,6 +267,7 @@ enum bpf_attach_type {#define BPF_ANY 0/* create new element or update existing */ #define BPF_NOEXIST 1/* create new element if it didn't exist */ #define BPF_EXIST 2/* update existing element */ +#define BPF_F_LOCK 4/* spin_lock-ed map_lookup/map_update */ /* flags for BPF_MAP_CREATE command */ #define BPF_F_NO_PREALLOC (1U << 0)
kernel/bpf/arraymap.c +16 -8
@@ -253,8 +253,9 @@ static int array_map_update_elem(struct bpf_map *map, void *key, void *value, { struct bpf_array *array = container_of(map, struct bpf_array, map);u32 index = *(u32 *)key; +char *val; -if (unlikely (map_flags >BPF_EXIST )) +if (unlikely ((map_flags & ~BPF_F_LOCK ) >BPF_EXIST ))/* unknown flags */ return -EINVAL ;
@@ -262,18 +263,25 @@ static int array_map_update_elem(struct bpf_map *map, void *key, void *value,/* all elements were pre-allocated, cannot insert a new one */ return -E2BIG ; -if (unlikely (map_flags ==BPF_NOEXIST )) +if (unlikely (map_flags &BPF_NOEXIST ))/* all elements already exist */ return -EEXIST ; -if (array->map.map_type ==BPF_MAP_TYPE_PERCPU_ARRAY ) +if (unlikely ((map_flags &BPF_F_LOCK ) && + !map_value_has_spin_lock (map))) +return -EINVAL ; + +if (array->map.map_type ==BPF_MAP_TYPE_PERCPU_ARRAY ) {memcpy (this_cpu_ptr (array->pptrs[index & array->index_mask]), value, map->value_size); -else -copy_map_value (map, - array->value + - array->elem_size * (index & array->index_mask), - value); + }else { + val = array->value + + array->elem_size * (index & array->index_mask); +if (map_flags &BPF_F_LOCK ) +copy_map_value_locked (map, val, value, false); +else +copy_map_value (map, val, value); + }return 0 ; }
kernel/bpf/hashtab.c +39 -3
69 lines not on this page · raw message
kernel/bpf/helpers.c +16 -0
@@ -301,6 +301,22 @@ const struct bpf_func_proto bpf_spin_unlock_proto = { .arg1_type = ARG_PTR_TO_SPIN_LOCK, }; +void copy_map_value_locked (struct bpf_map *map,void *dst,void *src, +bool lock_src) +{ +struct bpf_spin_lock *lock; + +if (lock_src) + lock = src + map->spin_lock_off; +else + lock = dst + map->spin_lock_off; +preempt_disable (); +____bpf_spin_lock (lock); +copy_map_value (map, dst, src); +____bpf_spin_unlock (lock); +preempt_enable (); +} +#ifdef CONFIG_CGROUPS BPF_CALL_0 (bpf_get_current_cgroup_id) {
kernel/bpf/local_storage.c +13 -1
@@ -131,7 +131,14 @@ static int cgroup_storage_update_elem(struct bpf_map *map, void *_key,struct bpf_cgroup_storage *storage;struct bpf_storage_buffer *new; -if (flags !=BPF_ANY && flags !=BPF_EXIST ) +if (unlikely (flags & ~(BPF_F_LOCK |BPF_EXIST |BPF_NOEXIST ))) +return -EINVAL ; + +if (unlikely (flags &BPF_NOEXIST )) +return -EINVAL ; + +if (unlikely ((flags &BPF_F_LOCK ) && + !map_value_has_spin_lock (map)))return -EINVAL ; storage = cgroup_storage_lookup((struct bpf_cgroup_storage_map *)map,
@@ -139,6 +146,11 @@ static int cgroup_storage_update_elem(struct bpf_map *map, void *_key,if (!storage)return -ENOENT ; +if (flags &BPF_F_LOCK ) { +copy_map_value_locked (map, storage->buf->data, value, false); +return 0 ; + } + new = kmalloc_node(sizeof(struct bpf_storage_buffer) + map->value_size, __GFP_ZERO | GFP_ATOMIC | __GFP_NOWARN,
kernel/bpf/syscall.c +23 -2
@@ -682,7 +682,7 @@ static void *__bpf_copy_key(void __user *ukey, u64 key_size) }/* last field in 'union bpf_attr' used by this command */ -#define BPF_MAP_LOOKUP_ELEM_LAST_FIELD value +#define BPF_MAP_LOOKUP_ELEM_LAST_FIELD flagsstatic int map_lookup_elem (union bpf_attr *attr) {
@@ -698,6 +698,9 @@ static int map_lookup_elem(union bpf_attr *attr)if (CHECK_ATTR (BPF_MAP_LOOKUP_ELEM ))return -EINVAL ; +if (attr->flags & ~BPF_F_LOCK ) +return -EINVAL ; + f =fdget (ufd); map =__bpf_map_get (f);if (IS_ERR (map))
@@ -708,6 +711,12 @@ static int map_lookup_elem(union bpf_attr *attr) goto err_put; } +if ((attr->flags &BPF_F_LOCK ) && + !map_value_has_spin_lock (map)) { + err = -EINVAL ; + goto err_put; + } + key =__bpf_copy_key (ukey, map->key_size);if (IS_ERR (key)) { err =PTR_ERR (key);
@@ -758,7 +767,13 @@ static int map_lookup_elem(union bpf_attr *attr) err = -ENOENT ; }else { err =0 ; -copy_map_value (map, value, ptr); +if (attr->flags &BPF_F_LOCK ) +/* lock 'ptr' and copy everything but lock */ +copy_map_value_locked (map, value, ptr, true); +else +copy_map_value (map, value, ptr); +/* mask lock, since value wasn't zero inited */ +check_and_init_map_lock (map, value); }rcu_read_unlock (); }
@@ -818,6 +833,12 @@ static int map_update_elem(union bpf_attr *attr) goto err_put; } +if ((attr->flags &BPF_F_LOCK ) && + !map_value_has_spin_lock (map)) { + err = -EINVAL ; + goto err_put; + } + key =__bpf_copy_key (ukey, map->key_size);if (IS_ERR (key)) { err =PTR_ERR (key);
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH v7 5/9 selftests/bpf: add bpf_spin_lock C test
In reply to Alexei Starovoitovadd bpf_spin_lock C based test that requires latest llvm with BTF support
--- tools/testing/selftests/bpf/Makefile | 2 +- tools/testing/selftests/bpf/bpf_helpers.h | 4 + tools/testing/selftests/bpf/test_progs.c | 43 +++++++- tools/testing/selftests/bpf/test_spin_lock.c | 108 +++++++++++++++++++ 4 files changed, 155 insertions(+), 2 deletions(-) create mode 100644 tools/testing/selftests/bpf/test_spin_lock.c
tools/testing/selftests/bpf/Makefile +1 -1
@@ -35,7 +35,7 @@ BPF_OBJ_FILES = \ sendmsg4_prog.o sendmsg6_prog.o test_lirc_mode2_kern.o \ get_cgroup_id_kern.o socket_cookie_prog.o test_select_reuseport_kern.o \ test_skb_cgroup_id_kern.o bpf_flow.o netcnt_prog.o test_xdp_vlan.o \ - xdp_dummy.o test_map_in_map.o + xdp_dummy.o test_map_in_map.o test_spin_lock.o # Objects are built with default compilation flags and with sub-register # code-gen enabled.
tools/testing/selftests/bpf/bpf_helpers.h +4 -0
@@ -172,6 +172,10 @@ static int (*bpf_skb_vlan_pop)(void *ctx) = (void *) BPF_FUNC_skb_vlan_pop;static int (*bpf_rc_pointer_rel)(void *ctx,int rel_x,int rel_y) = (void *) BPF_FUNC_rc_pointer_rel; +static void (*bpf_spin_lock)(struct bpf_spin_lock *lock) = + (void *) BPF_FUNC_spin_lock; +static void (*bpf_spin_unlock)(struct bpf_spin_lock *lock) = + (void *) BPF_FUNC_spin_unlock;/* llvm builtin functions that eBPF C program may use to * emit BPF_LD_ABS and BPF_LD_IND instructions
tools/testing/selftests/bpf/test_progs.c +42 -1
61 lines not on this page · raw message
tools/testing/selftests/bpf/test_spin_lock.c new file +108 -0
108 lines not on this page · raw message
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH v7 7/9 tools/bpf: sync uapi/bpf.h
In reply to Alexei Starovoitovadd BPF_F_LOCK definition to tools/include/uapi/linux/bpf.h
--- tools/include/uapi/linux/bpf.h | 1 + 1 file changed, 1 insertion(+)
tools/include/uapi/linux/bpf.h +1 -0
@@ -267,6 +267,7 @@ enum bpf_attach_type {#define BPF_ANY 0/* create new element or update existing */ #define BPF_NOEXIST 1/* create new element if it didn't exist */ #define BPF_EXIST 2/* update existing element */ +#define BPF_F_LOCK 4/* spin_lock-ed map_lookup/map_update */ /* flags for BPF_MAP_CREATE command */ #define BPF_F_NO_PREALLOC (1U << 0)
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH v7 8/9 libbpf: introduce bpf_map_lookup_elem_flags()
In reply to Alexei StarovoitovIntroduce
int bpf_map_lookup_elem_flags(int fd, const void *key, void *value, __u64 flags) helper to lookup array/hash/cgroup_local_storage elements with BPF_F_LOCK flag.
--- tools/lib/bpf/bpf.c | 13 +++++++++++++ tools/lib/bpf/bpf.h | 2 ++ tools/lib/bpf/libbpf.map | 1 + 3 files changed, 16 insertions(+)
tools/lib/bpf/bpf.c +13 -0
@@ -368,6 +368,19 @@ int bpf_map_lookup_elem(int fd, const void *key, void *value)return sys_bpf (BPF_MAP_LOOKUP_ELEM , &attr,sizeof (attr)); } +int bpf_map_lookup_elem_flags (int fd,const void *key,void *value,__u64 flags) +{ +union bpf_attr attr; + +bzero (&attr,sizeof (attr)); + attr.map_fd = fd; + attr.key =ptr_to_u64 (key); + attr.value =ptr_to_u64 (value); + attr.flags = flags; + +return sys_bpf (BPF_MAP_LOOKUP_ELEM , &attr,sizeof (attr)); +} +int bpf_map_lookup_and_delete_elem (int fd,const void *key,void *value) {union bpf_attr attr;
tools/lib/bpf/bpf.h +2 -0
@@ -110,6 +110,8 @@ LIBBPF_API int bpf_map_update_elem(int fd, const void *key, const void *value, __u64 flags); LIBBPF_API int bpf_map_lookup_elem(int fd, const void *key, void *value); +LIBBPF_API int bpf_map_lookup_elem_flags(int fd, const void *key, void *value, +__u64 flags); LIBBPF_API int bpf_map_lookup_and_delete_elem(int fd, const void *key,void *value); LIBBPF_API int bpf_map_delete_elem(int fd, const void *key);
tools/lib/bpf/libbpf.map +1 -0
@@ -130,4 +130,5 @@ LIBBPF_0.0.2 { bpf_probe_helper; bpf_probe_map_type; bpf_probe_prog_type; + bpf_map_lookup_elem_flags; } LIBBPF_0.0.1;
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH v7 9/9 selftests/bpf: test for BPF_F_LOCK
In reply to Alexei StarovoitovAdd C based test that runs 4 bpf programs in parallel
that update the same hash and array maps.
And another 2 threads that read from these two maps
via lookup(key, value, BPF_F_LOCK) api
to make sure the user space sees consistent value in both hash and array elements while user space races with kernel bpf progs.
--- tools/testing/selftests/bpf/Makefile | 2 +- tools/testing/selftests/bpf/test_map_lock.c | 66 ++++++++++++++++++ tools/testing/selftests/bpf/test_progs.c | 74 +++++++++++++++++++++ 3 files changed, 141 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/bpf/test_map_lock.c
tools/testing/selftests/bpf/Makefile +1 -1
@@ -35,7 +35,7 @@ BPF_OBJ_FILES = \ sendmsg4_prog.o sendmsg6_prog.o test_lirc_mode2_kern.o \ get_cgroup_id_kern.o socket_cookie_prog.o test_select_reuseport_kern.o \ test_skb_cgroup_id_kern.o bpf_flow.o netcnt_prog.o test_xdp_vlan.o \ - xdp_dummy.o test_map_in_map.o test_spin_lock.o + xdp_dummy.o test_map_in_map.o test_spin_lock.o test_map_lock.o # Objects are built with default compilation flags and with sub-register # code-gen enabled.
tools/testing/selftests/bpf/test_map_lock.c new file +66 -0
66 lines not on this page · raw message
tools/testing/selftests/bpf/test_progs.c +74 -0
86 lines not on this page · raw message
Signature · 1 line
2.20.0
Quoted 106 lines · Alexei Starovoitov
Many algorithms need to read and modify several variables atomically. Until now it was hard to impossible to implement such algorithms in BPF. Hence introduce support for
bpf_spin_lock.The api consists of 'struct
bpf_spin_lock' that should be placed inside hash/array/cgroup_local_storage element
and bpf_spin_lock/unlock() helper function.Example:
struct hash_elem { int cnt; struct bpf_spin_lock lock; }; struct hash_elem * val = bpf_map_lookup_elem(&hash_map, &key); if (val) { bpf_spin_lock(&val->lock); val->cnt++; bpf_spin_unlock(&val->lock); }and
BPF_F_LOCKflag for lookup/update bpf syscall commands that allows user space to read/write map elements under lock.Together these primitives allow race free access to map elements from bpf programs and from user space.
Key restriction: root only.
Key requirement: maps must be annotated with BTF.This concept was discussed at Linux Plumbers Conference 2018. Thank you everyone who participated and helped to iron out details of api and implementation.
Patch 1:
bpf_spin_locksupport in the verifier, BTF, hash, array. Patch 2:bpf_spin_lockin cgroup local storage.
Patches 3,4,5: tests
Patch 6:BPF_F_LOCKflag to lookup/update
Patches 7,8,9: tests
v6->v7:
- fixedthis_cpu->__this_cpuper Peter's suggestion and added Ack.
- simplifiedbpf_spin_lockand load/store overlap check in the verifier as suggested by Andrii
- rebase
v5->v6:
- adoptedarch_spinlockapproach suggested by Peter
- switched tospin_lock_irqsaveequivalent as the simplest way to avoid deadlocks in rare case of nested networking progs (cgroup-bpf prog inpreempt_disablevs clsbpf in softirq sharing the same map withbpf_spin_lock)
bpf_spin_lockis only allowed in networking progs that don't have arbitrary entry points unlike tracing progs.
- rebase and splittest_verifiertests
v4->v5:
- disallowbpf_spin_lockfor tracing progs due to insufficient preemption checks
- socket filter progs cannot usebpf_spin_lockdue to missingpreempt_disable
- fixatomic_set_release. Spotted by Peter.
- fixedhash_of_maps
v3->v4:
- fixBPF_EXIST|BPF_NOEXISTcheck patch 6. Spotted by Jakub. Thanks!
- rebase
v2->v3:
- fixed build on ia64 and archs where qspinlock is not supported
- fixed missing lock init during lookup w/oBPF_F_LOCK. Spotted by Martin
v1->v2:
- addressed several issues spotted by Daniel and Martin in patch 1
- added test11 to patch 4 as suggested by DanielAlexei Starovoitov (9):
bpf: introducebpf_spin_lock
bpf: add support forbpf_spin_lockto cgroup local storagetools/bpf: syncinclude/uapi/linux/bpf.hselftests/bpf: addbpf_spin_lockverifier tests selftests/bpf: addbpf_spin_lockC test
bpf: introduceBPF_F_LOCKflag
tools/bpf: syncuapi/bpf.h
libbpf: introducebpf_map_lookup_elem_flags()selftests/bpf: test forBPF_F_LOCKinclude/linux/bpf.h | 39 ++- include/linux/bpf_verifier.h | 1 + include/linux/btf.h | 1 + include/uapi/linux/bpf.h | 8 +- kernel/Kconfig.locks | 3 + kernel/bpf/arraymap.c | 23 +- kernel/bpf/btf.c | 42 +++ kernel/bpf/core.c | 2 + kernel/bpf/hashtab.c | 63 +++- kernel/bpf/helpers.c | 96 +++++ kernel/bpf/local_storage.c | 16 +- kernel/bpf/map_in_map.c | 5 + kernel/bpf/syscall.c | 45 ++- kernel/bpf/verifier.c | 171 ++++++++- net/core/filter.c | 16 +- tools/include/uapi/linux/bpf.h | 8 +- tools/lib/bpf/bpf.c | 13 + tools/lib/bpf/bpf.h | 2 + tools/lib/bpf/libbpf.map | 1 + tools/testing/selftests/bpf/Makefile | 2 +- tools/testing/selftests/bpf/bpf_helpers.h | 4 + tools/testing/selftests/bpf/test_map_lock.c | 66 ++++
Quoted 9 lines
tools/testing/selftests/bpf/test_progs.c | 117 ++++++- tools/testing/selftests/bpf/test_spin_lock.c | 108 ++++++ tools/testing/selftests/bpf/test_verifier.c | 104 +++++- .../selftests/bpf/verifier/spin_lock.c | 331 ++++++++++++++++++ 26 files changed, 1248 insertions(+), 39 deletions(-) create mode 100644 tools/testing/selftests/bpf/test_map_lock.c create mode 100644 tools/testing/selftests/bpf/test_spin_lock.c create mode 100644 tools/testing/selftests/bpf/verifier/spin_lock.c
Applied, thanks!