introduce bpf_spin_lock
Subsystems (8)
Alexei Starovoitov
maintainerv3 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
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 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/bpf/arraymap.c | 23 +- kernel/bpf/btf.c | 42 ++ kernel/bpf/core.c | 2 + kernel/bpf/hashtab.c | 48 +- kernel/bpf/helpers.c | 71 +++ kernel/bpf/local_storage.c | 16 +- kernel/bpf/map_in_map.c | 5 + kernel/bpf/syscall.c | 45 +- kernel/bpf/verifier.c | 151 +++++- 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 | 4 + 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 | 459 ++++++++++++++++++- 24 files changed, 1222 insertions(+), 29 deletions(-) create mode 100644 tools/testing/selftests/bpf/test_map_lock.c create mode 100644 tools/testing/selftests/bpf/test_spin_lock.c
Signature · 1 line
2.17.1
Alexei Starovoitov
maintainerPATCH v3 1/9 bpf: introduce bpf_spin_lock
Introduce '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.
Implementation details:
- on !SMP bpf_spin_lock() becomes nop
- on architectures that don't support queued_spin_lock trivial lock is used. Note that arch_spin_lock cannot be used, since not all archs agree that zero == unlocked and sizeof(arch_spinlock_t) != sizeof(__u32).
- 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 coding 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/bpf/arraymap.c | 7 +- kernel/bpf/btf.c | 42 ++++++++++ kernel/bpf/core.c | 2 + kernel/bpf/hashtab.c | 6 +- kernel/bpf/helpers.c | 57 ++++++++++++++ kernel/bpf/map_in_map.c | 5 ++ kernel/bpf/syscall.c | 21 ++++- kernel/bpf/verifier.c | 149 ++++++++++++++++++++++++++++++++++- net/core/filter.c | 16 +++- 13 files changed, 335 insertions(+), 16 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 */
@@ -869,7 +899,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
@@ -2421,7 +2421,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
@@ -3054,4 +3056,7 @@ struct bpf_line_info { __u32 line_col; }; +struct bpf_spin_lock { +__u32 val; +};#endif /* _UAPI__LINUX_BPF_H__ */
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
@@ -2036,6 +2036,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 +5 -1
@@ -770,6 +770,8 @@ 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);
@@ -792,7 +794,9 @@ 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 { -memcpy (l_new->key +round_up (key_size,8 ), value, size); +copy_map_value (&htab->map, + l_new->key +round_up (key_size,8 ), + value); } l_new->hash = hash;
kernel/bpf/helpers.c +57 -0
63 lines not on this page · raw message
kernel/bpf/map_in_map.c +5 -0
@@ -36,6 +36,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 =kzalloc (sizeof (*inner_map_meta),GFP_USER );if (!inner_map_meta) {fdput (f);
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 +146 -3
227 lines not on this page · raw message
net/core/filter.c +13 -3
@@ -5306,10 +5306,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.17.1
Alexei Starovoitov
maintainerPATCH v3 2/9 bpf: add support for bpf_spin_lock to cgroup local storage
In reply to Alexei StarovoitovAllow '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.17.1
Alexei Starovoitov
maintainerPATCH v3 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
@@ -2421,7 +2421,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
@@ -3054,4 +3056,7 @@ struct bpf_line_info { __u32 line_col; }; +struct bpf_spin_lock { +__u32 val; +};#endif /* _UAPI__LINUX_BPF_H__ */
Signature · 1 line
2.17.1
Alexei Starovoitov
maintainerPATCH v3 4/9 selftests/bpf: add bpf_spin_lock 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 | 459 +++++++++++++++++++- 1 file changed, 458 insertions(+), 1 deletion(-)
tools/testing/selftests/bpf/test_verifier.c +458 -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>
@@ -49,7 +50,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
@@ -76,6 +77,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;
@@ -15599,6 +15601,361 @@ static struct bpf_test tests[] = { .result_unpriv = ACCEPT, .result = ACCEPT, }, + { + "spin_lock: test1 success", + .insns = { +BPF_ST_MEM (BPF_W ,BPF_REG_10 ,-4 ,0 ), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-4 ), +BPF_LD_MAP_FD (BPF_REG_1 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_map_lookup_elem), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), +BPF_MOV64_REG (BPF_REG_6 ,BPF_REG_0 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_0 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_lock), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_6 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_LDX_MEM (BPF_W ,BPF_REG_0 ,BPF_REG_6 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_unlock), +BPF_MOV64_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .fixup_map_spin_lock = { 3 }, + .result = ACCEPT, + .result_unpriv = REJECT, + .errstr_unpriv = "", + .prog_type = BPF_PROG_TYPE_CGROUP_SKB, + }, + { +"spin_lock: test2 direct ld/st" , + .insns = { +BPF_ST_MEM (BPF_W ,BPF_REG_10 ,-4 ,0 ), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-4 ), +BPF_LD_MAP_FD (BPF_REG_1 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_map_lookup_elem), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), +BPF_MOV64_REG (BPF_REG_6 ,BPF_REG_0 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_0 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_lock), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_6 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_LDX_MEM (BPF_W ,BPF_REG_0 ,BPF_REG_1 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_unlock), +BPF_MOV64_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .fixup_map_spin_lock = { 3 }, + .result = REJECT, + .errstr = "cannot be accessed directly", + .result_unpriv = REJECT, + .errstr_unpriv = "", + .prog_type = BPF_PROG_TYPE_CGROUP_SKB, + }, + { +"spin_lock: test3 direct ld/st" , + .insns = { +BPF_ST_MEM (BPF_W ,BPF_REG_10 ,-4 ,0 ), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-4 ), +BPF_LD_MAP_FD (BPF_REG_1 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_map_lookup_elem), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), +BPF_MOV64_REG (BPF_REG_6 ,BPF_REG_0 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_0 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_lock), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_6 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_LDX_MEM (BPF_W ,BPF_REG_0 ,BPF_REG_6 ,1 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_unlock), +BPF_MOV64_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .fixup_map_spin_lock = { 3 }, + .result = REJECT, + .errstr = "cannot be accessed directly", + .result_unpriv = REJECT, + .errstr_unpriv = "", + .prog_type = BPF_PROG_TYPE_CGROUP_SKB, + }, + { +"spin_lock: test4 direct ld/st" , + .insns = { +BPF_ST_MEM (BPF_W ,BPF_REG_10 ,-4 ,0 ), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-4 ), +BPF_LD_MAP_FD (BPF_REG_1 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_map_lookup_elem), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), +BPF_MOV64_REG (BPF_REG_6 ,BPF_REG_0 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_0 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_lock), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_6 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_LDX_MEM (BPF_H ,BPF_REG_0 ,BPF_REG_6 ,3 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_unlock), +BPF_MOV64_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .fixup_map_spin_lock = { 3 }, + .result = REJECT, + .errstr = "cannot be accessed directly", + .result_unpriv = REJECT, + .errstr_unpriv = "", + .prog_type = BPF_PROG_TYPE_CGROUP_SKB, + }, + { +"spin_lock: test5 call within a locked region" , + .insns = { +BPF_ST_MEM (BPF_W ,BPF_REG_10 ,-4 ,0 ), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-4 ), +BPF_LD_MAP_FD (BPF_REG_1 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_map_lookup_elem), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), +BPF_MOV64_REG (BPF_REG_6 ,BPF_REG_0 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_0 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_lock), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_get_prandom_u32), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_6 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_unlock), +BPF_MOV64_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .fixup_map_spin_lock = { 3 }, + .result = REJECT, + .errstr = "calls are not allowed", + .result_unpriv = REJECT, + .errstr_unpriv = "", + .prog_type = BPF_PROG_TYPE_CGROUP_SKB, + }, + { +"spin_lock: test6 missing unlock" , + .insns = { +BPF_ST_MEM (BPF_W ,BPF_REG_10 ,-4 ,0 ), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-4 ), +BPF_LD_MAP_FD (BPF_REG_1 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_map_lookup_elem), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), +BPF_MOV64_REG (BPF_REG_6 ,BPF_REG_0 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_0 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_lock), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_6 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_LDX_MEM (BPF_W ,BPF_REG_0 ,BPF_REG_6 ,0 ), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_unlock), +BPF_MOV64_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .fixup_map_spin_lock = { 3 }, + .result = REJECT, + .errstr = "unlock is missing", + .result_unpriv = REJECT, + .errstr_unpriv = "", + .prog_type = BPF_PROG_TYPE_CGROUP_SKB, + }, + { +"spin_lock: test7 unlock without lock" , + .insns = { +BPF_ST_MEM (BPF_W ,BPF_REG_10 ,-4 ,0 ), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-4 ), +BPF_LD_MAP_FD (BPF_REG_1 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_map_lookup_elem), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), +BPF_MOV64_REG (BPF_REG_6 ,BPF_REG_0 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_0 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_1 ,0 ,1 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_lock), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_6 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_LDX_MEM (BPF_W ,BPF_REG_0 ,BPF_REG_6 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_unlock), +BPF_MOV64_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .fixup_map_spin_lock = { 3 }, + .result = REJECT, + .errstr = "without taking a lock", + .result_unpriv = REJECT, + .errstr_unpriv = "", + .prog_type = BPF_PROG_TYPE_CGROUP_SKB, + }, + { +"spin_lock: test8 double lock" , + .insns = { +BPF_ST_MEM (BPF_W ,BPF_REG_10 ,-4 ,0 ), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-4 ), +BPF_LD_MAP_FD (BPF_REG_1 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_map_lookup_elem), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), +BPF_MOV64_REG (BPF_REG_6 ,BPF_REG_0 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_0 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_lock), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_6 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_lock), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_6 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_LDX_MEM (BPF_W ,BPF_REG_0 ,BPF_REG_6 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_unlock), +BPF_MOV64_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .fixup_map_spin_lock = { 3 }, + .result = REJECT, + .errstr = "calls are not allowed", + .result_unpriv = REJECT, + .errstr_unpriv = "", + .prog_type = BPF_PROG_TYPE_CGROUP_SKB, + }, + { +"spin_lock: test9 different lock" , + .insns = { +BPF_ST_MEM (BPF_W ,BPF_REG_10 ,-4 ,0 ), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-4 ), +BPF_LD_MAP_FD (BPF_REG_1 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_map_lookup_elem), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), +BPF_MOV64_REG (BPF_REG_6 ,BPF_REG_0 ), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-4 ), +BPF_LD_MAP_FD (BPF_REG_1 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_map_lookup_elem), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), +BPF_MOV64_REG (BPF_REG_7 ,BPF_REG_0 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_6 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_lock), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_7 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_unlock), +BPF_MOV64_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .fixup_map_spin_lock = { 3, 11 }, + .result = REJECT, + .errstr = "unlock of different lock", + .result_unpriv = REJECT, + .errstr_unpriv = "", + .prog_type = BPF_PROG_TYPE_CGROUP_SKB, + }, + { +"spin_lock: test10 lock in subprog without unlock" , + .insns = { +BPF_ST_MEM (BPF_W ,BPF_REG_10 ,-4 ,0 ), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-4 ), +BPF_LD_MAP_FD (BPF_REG_1 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_map_lookup_elem), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), +BPF_MOV64_REG (BPF_REG_6 ,BPF_REG_0 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_0 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,1 ,0 ,5 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_6 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_unlock), +BPF_MOV64_IMM (BPF_REG_0 ,1 ), +BPF_EXIT_INSN (), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_lock), +BPF_MOV64_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .fixup_map_spin_lock = { 3 }, + .result = REJECT, + .errstr = "unlock is missing", + .result_unpriv = REJECT, + .errstr_unpriv = "", + .prog_type = BPF_PROG_TYPE_CGROUP_SKB, + }, + { +"spin_lock: test11 ld_abs under lock" , + .insns = { +BPF_MOV64_REG (BPF_REG_6 ,BPF_REG_1 ), +BPF_ST_MEM (BPF_W ,BPF_REG_10 ,-4 ,0 ), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-4 ), +BPF_LD_MAP_FD (BPF_REG_1 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_map_lookup_elem), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), +BPF_MOV64_REG (BPF_REG_7 ,BPF_REG_0 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_0 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_lock), +BPF_LD_ABS (BPF_B ,0 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_7 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,4 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_spin_unlock), +BPF_MOV64_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .fixup_map_spin_lock = { 4 }, + .result = REJECT, + .errstr = "inside bpf_spin_lock", + .prog_type = BPF_PROG_TYPE_SCHED_CLS, + }, };static int probe_filter_length (const struct bpf_insn *fp)
@@ -15729,6 +16086,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,
@@ -15747,6 +16196,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);
@@ -15863,6 +16313,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)
Signature · 1 line
2.17.1
Alexei Starovoitov
maintainerPATCH v3 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
@@ -39,7 +39,7 @@ TEST_GEN_FILES = test_pkt_access.o test_xdp.o test_l4lb.o test_tcp_estats.o test 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_sk_lookup_kern.o test_xdp_vlan.o test_queue_map.o test_stack_map.o \ - xdp_dummy.o test_map_in_map.o + xdp_dummy.o test_map_in_map.o test_spin_lock.o # Order correspond to 'make run_tests' order TEST_PROGS := test_kmod.sh \
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.17.1
Alexei Starovoitov
maintainerPATCH v3 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 | 14 +++++++++++++ kernel/bpf/local_storage.c | 14 ++++++++++++- kernel/bpf/syscall.c | 25 +++++++++++++++++++++-- 7 files changed, 108 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
@@ -266,6 +266,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 |BPF_NOEXIST )))/* 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 +14 -0
@@ -278,6 +278,20 @@ 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; +____bpf_spin_lock (lock); +copy_map_value (map, dst, src); +____bpf_spin_unlock (lock); +} +#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.17.1
Alexei Starovoitov
maintainerPATCH v3 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
@@ -266,6 +266,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.17.1
Alexei Starovoitov
maintainerPATCH v3 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 | 4 ++++ 3 files changed, 19 insertions(+)
tools/lib/bpf/bpf.c +13 -0
@@ -357,6 +357,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 +4 -0
@@ -124,3 +124,7 @@ LIBBPF_0.0.1 { local: *; }; +LIBBPF_0.0.2 { + global: + bpf_map_lookup_elem_flags; +} LIBBPF_0.0.1;
Signature · 1 line
2.17.1
Alexei Starovoitov
maintainerPATCH v3 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
@@ -39,7 +39,7 @@ TEST_GEN_FILES = test_pkt_access.o test_xdp.o test_l4lb.o test_tcp_estats.o test 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_sk_lookup_kern.o test_xdp_vlan.o test_queue_map.o test_stack_map.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 # Order correspond to 'make run_tests' order TEST_PROGS := test_kmod.sh \
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.17.1