bpf: cgroup_sock lsm flavor
Subsystems (11)
v11 cover bpf: cgroup_sock lsm flavor
This series implements new lsm flavor for attaching per-cgroup programs to existing lsm hooks. The cgroup is taken out of 'current', unless the first argument of the hook is 'struct socket'. In this case, the cgroup association is taken out of socket. The attachment looks like a regular per-cgroup attachment: we add new BPF_LSM_CGROUP attach type which, together with attach_btf_id, signals per-cgroup lsm. Behind the scenes, we allocate trampoline shim program and attach to lsm. This program looks up cgroup from current/socket and runs cgroup's effective prog array. The rest of the per-cgroup BPF stays the same: hierarchy, local storage, retval conventions (return 1 == success).
Current limitations:
* haven't considered sleepable bpf; can be extended later on
* not sure the verifier does the right thing with null checks; see latest selftest for details
* total of 10 (global) per-cgroup LSM attach points
v11:
- Martin: address selftest memory & fd leaks
- Martin: address moving into root (instead have another temp leaf cgroup)
- Martin: move tools/include/uapi/linux/bpf.h change from libbpf patch into 'sync tools' patch
v10:
- Martin: reword commit message, drop outdated items
- Martin: remove rcu_real_lock from __cgroup_bpf_run_lsm_current
- Martin: remove CONFIG_BPF_LSM from cgroup_bpf_release
- Martin: fix leaking shim reference in bpf_cgroup_link_release
- Martin: WARN_ON_ONCE for bpf_trampoline_lookup in bpf_trampoline_unlink_cgroup_shim
- Martin: sync tools/include/linux/btf_ids.h
- Martin: move progs/flags closer to the places where they are used in __cgroup_bpf_query
- Martin: remove sk_clone_security & sctp_bind_connect from bpf_lsm_locked_sockopt_hooks
- Martin: try to determine vmlinux btf_id in bpftool
- Martin: update tools header in a separate commit
- Quentin: do libbpf_find_kernel_btf from the ops that need it
- [email protected]: another build failure
v9:
Major change since last version is the switch to bpf_setsockopt to change the socket state instead of letting the progs poke socket directly. This, in turn, highlights the challenge that we need to care about whether the socket is locked or not when we call bpf_setsockopt. (with my original example selftest, the hooks are running early in the init phase for this not to matter).
For now, I've added two btf id lists:
* hooks where we know the socket is locked and it's safe to call bpf_setsockopt
* hooks where we know the socket is _not_ locked, but the hook works on the socket that's not yet exposed to userspace so it should be safe (for this mode, special new set of bpf_{s,g}etsockopt helpers
is added; they don't have sock_owned_by_me check)
Going forward, for the rest of the hooks, this might be a good motivation to expand lsm cgroup to support sleeping bpf and allow the callers to lock/unlock sockets or have a new bpf_setsockopt variant that does the locking.
- ifdef around cleanup in cgroup_bpf_release
- Andrii: a few nits in libbpf patches
- Martin: remove unused btf_id_set_index
- Martin: bring back refcnt for cgroup_atype
- Martin: make __cgroup_bpf_query a bit more readable
- Martin: expose dst_prog->aux->attach_btf as attach_btf_obj_id as well
- Martin: reorg check_return_code path for BPF_LSM_CGROUP
- Martin: return directly from check_helper_call (instead of goto err)
- Martin: add note to new warning in check_return_code, print only for void hooks
- Martin: remove confusing shim reuse
- Martin: use bpf_{s,g}etsockopt instead of poking into socket data
- Martin: use CONFIG_CGROUP_BPF in bpf_prog_alloc_no_stats/bpf_prog_free_deferred
v8:
- CI: fix compile issue
- CI: fix broken bpf_cookie
- Yonghong: remove __bpf_trampoline_unlink_prog comment
- Yonghong: move cgroup_atype around to fill the gap
- Yonghong: make bpf_lsm_find_cgroup_shim void
- Yonghong: rename regs to args
- Yonghong: remove if(current) check
- Martin: move refcnt into bpf_link
- Martin: move shim management to bpf_link ops
- Martin: use cgroup_atype for shim only
- Martin: go back to arrays for managing cgroup_atype(s)
- Martin: export bpf_obj_id(aux->attach_btf)
- Andrii: reorder SEC_DEF("lsm_cgroup+")
- Andrii: OPTS_SET instead of OPTS_HAS
- Andrii: rename attach_btf_func_id
- Andrii: move into 1.0 map
v7:
- there were a lot of comments last time, hope I didn't forget anything, some of the bigger ones:
- Martin: use/extend BTF_SOCK_TYPE_SOCKET
- Martin: expose bpf_set_retval
- Martin: reject 'return 0' at the verifier for 'void' hooks
- Martin: prog_query returns all BPF_LSM_CGROUP, prog_info returns attach_btf_func_id
- Andrii: split libbpf changes
- Andrii: add field access test to test_progs, not test_verifier (still using asm though)
- things that I haven't addressed, stating them here explicitly, let me know if some of these are still problematic:
1. Andrii: exposing only link-based api: seems like the changes to support non-link-based ones are minimal, couple of lines, so seems like it worth having it?
2. Alexei: applying cgroup_atype for all cgroup hooks, not only cgroup lsm: looks a bit harder to apply everywhere that I originally thought; with lsm cgroup, we have a shim_prog pointer where we store cgroup_atype; for non-lsm programs, we don't have a trace program where to store it, so we still need some kind of global table to map from "static" hook to "dynamic" slot. So I'm dropping this "can be easily extended" clause from the description for now. I have converted this whole machinery to an RCU-managed list to remove synchronize_rcu().
- also note that I had to introduce new bpf_shim_tramp_link and moved refcnt there; we need something to manage new bpf_tramp_link
v6:
- remove active count & stats for shim program (Martin KaFai Lau)
- remove NULL/error check for btf_vmlinux (Martin)
- don't check cgroup_atype in bpf_cgroup_lsm_shim_release (Martin)
- use old_prog (instead of passed one) in __cgroup_bpf_detach (Martin)
- make sure attach_btf_id is the same in __cgroup_bpf_replace (Martin)
- enable cgroup local storage and test it (Martin)
- properly implement prog query and add bpftool & tests (Martin)
- prohibit non-shared cgroup storage mode for BPF_LSM_CGROUP (Martin)
v5:
- __cgroup_bpf_run_lsm_socket remove NULL sock/sk checks (Martin KaFai Lau)
- __cgroup_bpf_run_lsm_{socket,current} s/prog/shim_prog/ (Martin)
- make sure bpf_lsm_find_cgroup_shim works for hooks without args (Martin)
- __cgroup_bpf_attach make sure attach_btf_id is the same when replacing (Martin)
- call bpf_cgroup_lsm_shim_release only for LSM_CGROUP (Martin)
- drop BPF_LSM_CGROUP from bpf_attach_type_to_tramp (Martin)
- drop jited check from cgroup_shim_find (Martin)
- new patch to convert cgroup_bpf to hlist_node (Jakub Sitnicki)
- new shim flavor for 'struct sock' + list of exceptions (Martin)
v4:
- fix build when jit is on but syscall is off
v3:
- add BPF_LSM_CGROUP to bpftool
- use simple int instead of refcnt_t (to avoid use-after-free false positive)
v2:
- addressed build bot failures
Stanislav Fomichev (11):
bpf: add bpf_func_t and trampoline helpers
bpf: convert cgroup_bpf.progs to hlist
bpf: per-cgroup lsm flavor
bpf: minimize number of allocated lsm slots per program
bpf: implement BPF_PROG_QUERY for BPF_LSM_CGROUP
bpf: expose bpf_{g,s}etsockopt to lsm cgroup tools/bpf: Sync btf_ids.h to tools
libbpf: add lsm_cgoup_sock type
libbpf: implement bpf_prog_query_opts
bpftool: implement cgroup tree for BPF_LSM_CGROUP selftests/bpf: lsm_cgroup functional test
arch/x86/net/bpf_jit_comp.c | 24 +- include/linux/bpf-cgroup-defs.h | 13 +- include/linux/bpf-cgroup.h | 9 +- include/linux/bpf.h | 44 ++- include/linux/bpf_lsm.h | 7 + include/linux/btf_ids.h | 3 +- include/uapi/linux/bpf.h | 4 + kernel/bpf/bpf_lsm.c | 81 ++++ kernel/bpf/btf.c | 1 + kernel/bpf/cgroup.c | 350 ++++++++++++++---- kernel/bpf/core.c | 9 + kernel/bpf/syscall.c | 18 +- kernel/bpf/trampoline.c | 262 +++++++++++-- kernel/bpf/verifier.c | 32 ++ net/core/filter.c | 60 ++- tools/bpf/bpftool/cgroup.c | 109 ++++-- tools/include/linux/btf_ids.h | 35 +- tools/include/uapi/linux/bpf.h | 4 + tools/lib/bpf/bpf.c | 38 +- tools/lib/bpf/bpf.h | 15 + tools/lib/bpf/libbpf.c | 3 + tools/lib/bpf/libbpf.map | 1 + .../selftests/bpf/prog_tests/lsm_cgroup.c | 293 +++++++++++++++ .../selftests/bpf/prog_tests/resolve_btfids.c | 2 +- .../selftests/bpf/progs/bpf_tracing_net.h | 1 + .../testing/selftests/bpf/progs/lsm_cgroup.c | 180 +++++++++ 26 files changed, 1432 insertions(+), 166 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/lsm_cgroup.c create mode 100644 tools/testing/selftests/bpf/progs/lsm_cgroup.c
Signature · 1 line
2.37.0.rc0.161.g10f37bed90-goog
PATCH v11 1/11 bpf: add bpf_func_t and trampoline helpers
I'll be adding lsm cgroup specific helpers that grab trampoline mutex.
No functional changes.
--- include/linux/bpf.h | 11 ++++--- kernel/bpf/trampoline.c | 63 +++++++++++++++++++++-------------------- 2 files changed, 38 insertions(+), 36 deletions(-)
include/linux/bpf.h +5 -6
@@ -56,6 +56,8 @@ typedef u64 (*bpf_callback_t)(u64, u64, u64, u64, u64);typedef int (*bpf_iter_init_seq_priv_t )(void *private_data,struct bpf_iter_aux_info *aux);typedef void (*bpf_iter_fini_seq_priv_t )(void *private_data); +typedef unsigned int (*bpf_func_t )(const void *, +const struct bpf_insn *);struct bpf_iter_seq_info {const struct seq_operations *seq_ops;bpf_iter_init_seq_priv_t init_seq_private;
@@ -879,8 +881,7 @@ struct bpf_dispatcher { static __always_inline __nocfi unsigned int bpf_dispatcher_nop_func(const void *ctx,const struct bpf_insn *insnsi, -unsigned int (*bpf_func)(const void *, -const struct bpf_insn *)) +bpf_func_t bpf_func) {return bpf_func (ctx, insnsi); }
@@ -909,8 +910,7 @@ int arch_prepare_bpf_dispatcher(void *image, s64 *funcs, int num_funcs); noinline __nocfi unsigned int bpf_dispatcher_##name##_func( \const void *ctx, \const struct bpf_insn *insnsi, \ -unsigned int (*bpf_func)(const void *, \ -const struct bpf_insn *)) \ +bpf_func_t bpf_func) \ { \return bpf_func (ctx, insnsi); \ } \
@@ -921,8 +921,7 @@ int arch_prepare_bpf_dispatcher(void *image, s64 *funcs, int num_funcs); unsigned int bpf_dispatcher_##name##_func( \ const void *ctx, \ const struct bpf_insn *insnsi, \ - unsigned int (*bpf_func)(const void *, \ - const struct bpf_insn *)); \ + bpf_func_t bpf_func); \ extern struct bpf_dispatcher bpf_dispatcher_##name;#define BPF_DISPATCHER_FUNC (name) bpf_dispatcher_##name##_func#define BPF_DISPATCHER_PTR (name) (&bpf_dispatcher_##name)
kernel/bpf/trampoline.c +33 -30
114 lines not on this page · raw message
Signature · 1 line
2.37.0.rc0.161.g10f37bed90-goog
PATCH v11 2/11 bpf: convert cgroup_bpf.progs to hlist
In reply to Stanislav FomichevThis lets us reclaim some space to be used by new cgroup lsm slots.
Before:
struct cgroup_bpf {
struct bpf_prog_array * effective[23]; /* 0 184 */
/* --- cacheline 2 boundary (128 bytes) was 56 bytes ago --- */
struct list_head progs[23]; /* 184 368 */
/* --- cacheline 8 boundary (512 bytes) was 40 bytes ago --- */
u32 flags[23]; /* 552 92 */
/* XXX 4 bytes hole, try to pack */
/* --- cacheline 10 boundary (640 bytes) was 8 bytes ago --- */
struct list_head storages; /* 648 16 */
struct bpf_prog_array * inactive; /* 664 8 */
struct percpu_ref refcnt; /* 672 16 */
struct work_struct release_work; /* 688 32 */
/* size: 720, cachelines: 12, members: 7 */
/* sum members: 716, holes: 1, sum holes: 4 */
/* last cacheline: 16 bytes */
};After:
struct cgroup_bpf {
struct bpf_prog_array * effective[23]; /* 0 184 */
/* --- cacheline 2 boundary (128 bytes) was 56 bytes ago --- */
struct hlist_head progs[23]; /* 184 184 */
/* --- cacheline 5 boundary (320 bytes) was 48 bytes ago --- */
u8 flags[23]; /* 368 23 */
/* XXX 1 byte hole, try to pack */
/* --- cacheline 6 boundary (384 bytes) was 8 bytes ago --- */
struct list_head storages; /* 392 16 */
struct bpf_prog_array * inactive; /* 408 8 */
struct percpu_ref refcnt; /* 416 16 */
struct work_struct release_work; /* 432 72 */
/* size: 504, cachelines: 8, members: 7 */
/* sum members: 503, holes: 1, sum holes: 1 */
/* last cacheline: 56 bytes */
};--- include/linux/bpf-cgroup-defs.h | 4 +- include/linux/bpf-cgroup.h | 2 +- kernel/bpf/cgroup.c | 76 +++++++++++++++++++-------------- 3 files changed, 47 insertions(+), 35 deletions(-)
include/linux/bpf-cgroup-defs.h +2 -2
@@ -47,8 +47,8 @@ struct cgroup_bpf {* have either zero or one element * when BPF_F_ALLOW_MULTI the list can have up to BPF_CGROUP_MAX_PROGS */ -struct list_head progs[MAX_CGROUP_BPF_ATTACH_TYPE ]; -u32 flags[MAX_CGROUP_BPF_ATTACH_TYPE ]; +struct hlist_head progs[MAX_CGROUP_BPF_ATTACH_TYPE ]; +u8 flags[MAX_CGROUP_BPF_ATTACH_TYPE ];/* list of cgroup shared storages */ struct list_head storages;
include/linux/bpf-cgroup.h +1 -1
@@ -95,7 +95,7 @@ struct bpf_cgroup_link { };struct bpf_prog_list { -struct list_head node; +struct hlist_node node;struct bpf_prog *prog;struct bpf_cgroup_link *link;struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE ];
kernel/bpf/cgroup.c +44 -32
240 lines not on this page · raw message
Signature · 1 line
2.37.0.rc0.161.g10f37bed90-goog
PATCH v11 3/11 bpf: per-cgroup lsm flavor
In reply to Stanislav FomichevAllow attaching to lsm hooks in the cgroup context.
Attaching to per-cgroup LSM works exactly like attaching to other per-cgroup hooks. New BPF_LSM_CGROUP is added to trigger new mode; the actual lsm hook we attach to is signaled via existing attach_btf_id.
For the hooks that have 'struct socket' or 'struct sock' as its first argument, we use the cgroup associated with that socket. For the rest, we use 'current' cgroup (this is all on default hierarchy == v2 only). Note that for some hooks that work on 'struct sock' we still take the cgroup from 'current' because some of them work on the socket that hasn't been properly initialized yet.
Behind the scenes, we allocate a shim program that is attached to the trampoline and runs cgroup effective BPF programs array. This shim has some rudimentary ref counting and can be shared between several programs attaching to the same lsm hook from different cgroups.
Note that this patch bloats cgroup size because we add 211 cgroup_bpf_attach_type(s) for simplicity sake. This will be addressed in the subsequent patch.
Also note that we only add non-sleepable flavor for now. To enable sleepable use-cases, bpf_prog_run_array_cg has to grab trace rcu, shim programs have to be freed via trace rcu, cgroup_bpf.effective should be also trace-rcu-managed + maybe some other changes that I'm not aware of.
--- arch/x86/net/bpf_jit_comp.c | 24 ++-- include/linux/bpf-cgroup-defs.h | 8 ++ include/linux/bpf-cgroup.h | 7 ++ include/linux/bpf.h | 24 ++++ include/linux/bpf_lsm.h | 13 +++ include/linux/btf_ids.h | 3 +- include/uapi/linux/bpf.h | 1 + kernel/bpf/bpf_lsm.c | 48 ++++++++ kernel/bpf/btf.c | 11 ++ kernel/bpf/cgroup.c | 136 ++++++++++++++++++++-- kernel/bpf/core.c | 2 + kernel/bpf/syscall.c | 10 ++ kernel/bpf/trampoline.c | 198 ++++++++++++++++++++++++++++++++ kernel/bpf/verifier.c | 32 ++++++ tools/include/uapi/linux/bpf.h | 1 + 15 files changed, 498 insertions(+), 20 deletions(-)
arch/x86/net/bpf_jit_comp.c +16 -8
@@ -1770,6 +1770,10 @@ static int invoke_bpf_prog(const struct btf_func_model *m, u8 **pprog, struct bpf_tramp_link *l, int stack_size, int run_ctx_off, bool save_ret) { + void (*exit)(struct bpf_prog *prog, u64 start, +struct bpf_tramp_run_ctx *run_ctx) = __bpf_prog_exit; +u64 (*enter)(struct bpf_prog *prog, +struct bpf_tramp_run_ctx *run_ctx) = __bpf_prog_enter;u8 *prog = *pprog;u8 *jmp_insn;int ctx_cookie_off = offsetof(struct bpf_tramp_run_ctx , bpf_cookie);
@@ -1788,15 +1792,21 @@ static int invoke_bpf_prog(const struct btf_func_model *m, u8 **pprog,*/ emit_stx (&prog,BPF_DW ,BPF_REG_FP ,BPF_REG_1 , -run_ctx_off + ctx_cookie_off); +if (p->aux->sleepable) { + enter = __bpf_prog_enter_sleepable; + exit = __bpf_prog_exit_sleepable; + }else if (p->expected_attach_type ==BPF_LSM_CGROUP ) { + enter = __bpf_prog_enter_lsm_cgroup; + exit = __bpf_prog_exit_lsm_cgroup; + } +/* arg1: mov rdi, progs[i] */ emit_mov_imm64 (&prog,BPF_REG_1 , (long ) p >>32 , (u32 ) (long ) p);/* arg2: lea rsi, [rbp - ctx_cookie_off] */ EMIT4 (0x48 ,0x8D ,0x75 , -run_ctx_off); -if (emit_call (&prog, - p->aux->sleepable ? __bpf_prog_enter_sleepable : - __bpf_prog_enter, prog)) -return -EINVAL ; +if (emit_call (&prog, enter, prog)) +return -EINVAL ;/* remember prog start time returned by __bpf_prog_enter */ emit_mov_reg (&prog, true,BPF_REG_6 ,BPF_REG_0 );
@@ -1840,10 +1850,8 @@ static int invoke_bpf_prog(const struct btf_func_model *m, u8 **pprog,emit_mov_reg (&prog, true,BPF_REG_2 ,BPF_REG_6 );/* arg3: lea rdx, [rbp - run_ctx_off] */ EMIT4 (0x48 ,0x8D ,0x55 , -run_ctx_off); -if (emit_call (&prog, - p->aux->sleepable ? __bpf_prog_exit_sleepable : - __bpf_prog_exit, prog)) -return -EINVAL ; +if (emit_call (&prog, exit, prog)) +return -EINVAL ; *pprog = prog;return 0 ;
include/linux/bpf-cgroup-defs.h +8 -0
@@ -10,6 +10,12 @@struct bpf_prog_array ; +#ifdef CONFIG_BPF_LSM +#define CGROUP_LSM_NUM 211/* will be addressed in the next patch */ +#else +#define CGROUP_LSM_NUM 0 +#endif +enum cgroup_bpf_attach_type {CGROUP_BPF_ATTACH_TYPE_INVALID =-1 ,CGROUP_INET_INGRESS =0 ,
@@ -35,6 +41,8 @@ enum cgroup_bpf_attach_type {CGROUP_INET4_GETSOCKNAME ,CGROUP_INET6_GETSOCKNAME ,CGROUP_INET_SOCK_RELEASE , +CGROUP_LSM_START , +CGROUP_LSM_END =CGROUP_LSM_START +CGROUP_LSM_NUM -1 , MAX_CGROUP_BPF_ATTACH_TYPE };
include/linux/bpf-cgroup.h +7 -0
@@ -23,6 +23,13 @@ struct ctl_table;struct ctl_table_header ;struct task_struct ; +unsigned int __cgroup_bpf_run_lsm_sock (const void *ctx, +const struct bpf_insn *insn); +unsigned int __cgroup_bpf_run_lsm_socket (const void *ctx, +const struct bpf_insn *insn); +unsigned int __cgroup_bpf_run_lsm_current (const void *ctx, +const struct bpf_insn *insn); +#ifdef CONFIG_CGROUP_BPF #define CGROUP_ATYPE (type) \
include/linux/bpf.h +24 -0
@@ -794,6 +794,10 @@ void notrace __bpf_prog_exit(struct bpf_prog *prog, u64 start, struct bpf_tramp_ u64 notrace __bpf_prog_enter_sleepable(struct bpf_prog *prog, struct bpf_tramp_run_ctx *run_ctx); void notrace __bpf_prog_exit_sleepable(struct bpf_prog *prog, u64 start,struct bpf_tramp_run_ctx *run_ctx); +u64 notrace __bpf_prog_enter_lsm_cgroup(struct bpf_prog *prog, +struct bpf_tramp_run_ctx *run_ctx); +void notrace __bpf_prog_exit_lsm_cgroup(struct bpf_prog *prog, u64 start, +struct bpf_tramp_run_ctx *run_ctx); void notrace __bpf_tramp_enter(struct bpf_tramp_image *tr); void notrace __bpf_tramp_exit(struct bpf_tramp_image *tr);
@@ -1060,6 +1064,7 @@ struct bpf_prog_aux {struct user_struct *user;u64 load_time;/* ns since boottime */ u32 verified_insns; +int cgroup_atype;/* enum cgroup_bpf_attach_type */ struct bpf_map *cgroup_storage[MAX_BPF_CGROUP_STORAGE_TYPE ];char name[BPF_OBJ_NAME_LEN ];#ifdef CONFIG_SECURITY
@@ -1167,6 +1172,11 @@ struct bpf_tramp_link {u64 cookie; }; +struct bpf_shim_tramp_link { +struct bpf_tramp_link link; +struct bpf_trampoline *trampoline; +}; +struct bpf_tracing_link {struct bpf_tramp_link link;enum bpf_attach_type attach_type;
@@ -1245,6 +1255,9 @@ struct bpf_dummy_ops {int bpf_struct_ops_test_run (struct bpf_prog *prog,const union bpf_attr *kattr,union bpf_attr __user *uattr);#endif +int bpf_trampoline_link_cgroup_shim (struct bpf_prog *prog, +int cgroup_atype); +void bpf_trampoline_unlink_cgroup_shim (struct bpf_prog *prog);#else static inline const struct bpf_struct_ops *bpf_struct_ops_find (u32 type_id) {
@@ -1268,6 +1281,14 @@ static inline int bpf_struct_ops_map_sys_lookup_elem(struct bpf_map *map, {return -EINVAL ; } +static inline int bpf_trampoline_link_cgroup_shim (struct bpf_prog *prog, +int cgroup_atype) +{ +return -EOPNOTSUPP ; +} +static inline void bpf_trampoline_unlink_cgroup_shim (struct bpf_prog *prog) +{ +}#endif struct bpf_array {
@@ -2368,6 +2389,8 @@ extern const struct bpf_func_proto bpf_sk_getsockopt_proto;extern const struct bpf_func_proto bpf_find_vma_proto;extern const struct bpf_func_proto bpf_loop_proto;extern const struct bpf_func_proto bpf_copy_from_user_task_proto; +extern const struct bpf_func_proto bpf_set_retval_proto; +extern const struct bpf_func_proto bpf_get_retval_proto;const struct bpf_func_proto *tracing_prog_func_proto (enum bpf_func_id func_id,const struct bpf_prog *prog);
@@ -2485,6 +2508,7 @@ int bpf_arch_text_invalidate(void *dst, size_t len);struct btf_id_set ;bool btf_id_set_contains (const struct btf_id_set *set,u32 id); +int btf_id_set_index (const struct btf_id_set *set,u32 id);#define MAX_BPRINTF_VARARGS 12
include/linux/bpf_lsm.h +13 -0
@@ -42,6 +42,9 @@ extern const struct bpf_func_proto bpf_inode_storage_get_proto;extern const struct bpf_func_proto bpf_inode_storage_delete_proto;void bpf_inode_storage_free (struct inode *inode); +int bpf_lsm_hook_idx (u32 btf_id); +void bpf_lsm_find_cgroup_shim (const struct bpf_prog *prog,bpf_func_t *bpf_func); +#else /* !CONFIG_BPF_LSM */ static inline bool bpf_lsm_is_sleepable_hook (u32 btf_id)
@@ -65,6 +68,16 @@ static inline void bpf_inode_storage_free(struct inode *inode) { } +static inline void bpf_lsm_find_cgroup_shim (const struct bpf_prog *prog, +bpf_func_t *bpf_func) +{ +} + +static inline int bpf_lsm_hook_idx (u32 btf_id) +{ +return -EINVAL ; +} +#endif /* CONFIG_BPF_LSM */ #endif /* _LINUX_BPF_LSM_H */
include/linux/btf_ids.h +2 -1
@@ -179,7 +179,8 @@ extern struct btf_id_set name; BTF_SOCK_TYPE(BTF_SOCK_TYPE_UDP, udp_sock) \ BTF_SOCK_TYPE(BTF_SOCK_TYPE_UDP6, udp6_sock) \ BTF_SOCK_TYPE(BTF_SOCK_TYPE_UNIX, unix_sock) \ - BTF_SOCK_TYPE(BTF_SOCK_TYPE_MPTCP, mptcp_sock) + BTF_SOCK_TYPE(BTF_SOCK_TYPE_MPTCP, mptcp_sock) \ + BTF_SOCK_TYPE(BTF_SOCK_TYPE_SOCKET, socket) enum {#define BTF_SOCK_TYPE (name, str) name,
include/uapi/linux/bpf.h +1 -0
@@ -998,6 +998,7 @@ enum bpf_attach_type {BPF_SK_REUSEPORT_SELECT_OR_MIGRATE ,BPF_PERF_EVENT ,BPF_TRACE_KPROBE_MULTI , +BPF_LSM_CGROUP , __MAX_BPF_ATTACH_TYPE };
kernel/bpf/bpf_lsm.c +48 -0
66 lines not on this page · raw message
kernel/bpf/btf.c +11 -0
@@ -5363,6 +5363,7 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type,if (arg == nr_args) {switch (prog->expected_attach_type) { +case BPF_LSM_CGROUP :case BPF_LSM_MAC :case BPF_TRACE_FEXIT :/* When LSM programs are attached to void LSM hooks
@@ -6842,6 +6843,16 @@ static int btf_id_cmp_func(const void *a, const void *b)return *pa - *pb; } +int btf_id_set_index (const struct btf_id_set *set,u32 id) +{ +const u32 *p; + + p =bsearch (&id, set->ids, set->cnt,sizeof (u32), btf_id_cmp_func); +if (!p) +return -1 ; +return p - set->ids; +} +bool btf_id_set_contains (const struct btf_id_set *set,u32 id) {return bsearch (&id, set->ids, set->cnt,sizeof (u32), btf_id_cmp_func) !=NULL ;
kernel/bpf/cgroup.c +125 -11
221 lines not on this page · raw message
kernel/bpf/core.c +2 -0
@@ -2666,6 +2666,8 @@ const struct bpf_func_proto bpf_get_local_storage_proto __weak;const struct bpf_func_proto bpf_get_ns_current_pid_tgid_proto__weak ;const struct bpf_func_proto bpf_snprintf_btf_proto__weak ;const struct bpf_func_proto bpf_seq_printf_btf_proto__weak ; +const struct bpf_func_proto bpf_set_retval_proto__weak ; +const struct bpf_func_proto bpf_get_retval_proto__weak ;const struct bpf_func_proto *__weak bpf_get_trace_printk_proto (void ) {
kernel/bpf/syscall.c +10 -0
@@ -3416,6 +3416,8 @@ attach_type_to_prog_type(enum bpf_attach_type attach_type)return BPF_PROG_TYPE_SK_LOOKUP ;case BPF_XDP :return BPF_PROG_TYPE_XDP ; +case BPF_LSM_CGROUP : +return BPF_PROG_TYPE_LSM ;default :return BPF_PROG_TYPE_UNSPEC ; }
@@ -3469,6 +3471,11 @@ static int bpf_prog_attach(const union bpf_attr *attr)case BPF_PROG_TYPE_CGROUP_SOCKOPT :case BPF_PROG_TYPE_CGROUP_SYSCTL :case BPF_PROG_TYPE_SOCK_OPS : +case BPF_PROG_TYPE_LSM : +if (ptype ==BPF_PROG_TYPE_LSM && + prog->expected_attach_type !=BPF_LSM_CGROUP ) +return -EINVAL ; + ret =cgroup_bpf_prog_attach (attr, ptype, prog);break ;default :
@@ -3506,6 +3513,7 @@ static int bpf_prog_detach(const union bpf_attr *attr)case BPF_PROG_TYPE_CGROUP_SOCKOPT :case BPF_PROG_TYPE_CGROUP_SYSCTL :case BPF_PROG_TYPE_SOCK_OPS : +case BPF_PROG_TYPE_LSM :return cgroup_bpf_prog_detach (attr, ptype);default :return -EINVAL ;
@@ -4540,6 +4548,8 @@ static int link_create(union bpf_attr *attr, bpfptr_t uattr) ret =bpf_raw_tp_link_attach (prog,NULL ); else if (prog->expected_attach_type == BPF_TRACE_ITER) ret =bpf_iter_link_attach (attr, uattr, prog); + else if (prog->expected_attach_type == BPF_LSM_CGROUP) + ret =cgroup_bpf_link_attach (attr, prog); else ret = bpf_tracing_prog_attach(prog, attr->link_create.target_fd,
kernel/bpf/trampoline.c +198 -0
216 lines not on this page · raw message
kernel/bpf/verifier.c +32 -0
@@ -7322,6 +7322,18 @@ static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insn reg_type_str(env, regs[BPF_REG_1].type));return -EACCES ; } +break ; +case BPF_FUNC_set_retval: +if (env->prog->expected_attach_type ==BPF_LSM_CGROUP ) { +if (!env->prog->aux->attach_func_proto->type) { +/* Make sure programs that attach to void +* hooks don't try to modify return value. +*/ +verbose (env,"BPF_LSM_CGROUP that attach to void LSM hooks can't modify return value!\n" ); +return -EINVAL ; + } + } +break ; }if (err)
@@ -10527,6 +10539,22 @@ static int check_return_code(struct bpf_verifier_env *env)case BPF_PROG_TYPE_SK_LOOKUP : range =tnum_range (SK_DROP ,SK_PASS );break ; + +case BPF_PROG_TYPE_LSM : +if (env->prog->expected_attach_type !=BPF_LSM_CGROUP ) { +/* Regular BPF_PROG_TYPE_LSM programs can return +* any value. +*/ +return 0 ; + } +if (!env->prog->aux->attach_func_proto->type) { +/* Make sure programs that attach to void +* hooks don't try to modify return value. +*/ + range =tnum_range (1 ,1 ); + } +break ; +case BPF_PROG_TYPE_EXT :/* freplace program can return anything as its return value * depends on the to-be-replaced kernel func or bpf program.
@@ -10543,6 +10571,9 @@ static int check_return_code(struct bpf_verifier_env *env)if (!tnum_in (range, reg->var_off)) {verbose_invalid_scalar (env, reg, &range,"program exit" ,"R0" ); +if (prog->expected_attach_type ==BPF_LSM_CGROUP && + !prog->aux->attach_func_proto->type) +verbose (env,"Note, BPF_LSM_CGROUP that attach to void LSM hooks can't modify return value!\n" );return -EINVAL ; }
@@ -14902,6 +14933,7 @@ int bpf_check_attach_target(struct bpf_verifier_log *log, fallthrough;case BPF_MODIFY_RETURN :case BPF_LSM_MAC : +case BPF_LSM_CGROUP :case BPF_TRACE_FENTRY :case BPF_TRACE_FEXIT :if (!btf_type_is_func (t)) {
tools/include/uapi/linux/bpf.h +1 -0
@@ -998,6 +998,7 @@ enum bpf_attach_type {BPF_SK_REUSEPORT_SELECT_OR_MIGRATE ,BPF_PERF_EVENT ,BPF_TRACE_KPROBE_MULTI , +BPF_LSM_CGROUP , __MAX_BPF_ATTACH_TYPE };
Signature · 1 line
2.37.0.rc0.161.g10f37bed90-goog
PATCH v11 4/11 bpf: minimize number of allocated lsm slots per program
In reply to Stanislav FomichevPrevious patch adds 1:1 mapping between all 211 LSM hooks and bpf_cgroup program array. Instead of reserving a slot per possible hook, reserve 10 slots per cgroup for lsm programs. Those slots are dynamically allocated on demand and reclaimed.
struct cgroup_bpf {
struct bpf_prog_array * effective[33]; /* 0 264 */
/* --- cacheline 4 boundary (256 bytes) was 8 bytes ago --- */
struct hlist_head progs[33]; /* 264 264 */
/* --- cacheline 8 boundary (512 bytes) was 16 bytes ago --- */
u8 flags[33]; /* 528 33 */
/* XXX 7 bytes hole, try to pack */
struct list_head storages; /* 568 16 */
/* --- cacheline 9 boundary (576 bytes) was 8 bytes ago --- */
struct bpf_prog_array * inactive; /* 584 8 */
struct percpu_ref refcnt; /* 592 16 */
struct work_struct release_work; /* 608 72 */
/* size: 680, cachelines: 11, members: 7 */
/* sum members: 673, holes: 1, sum holes: 7 */
/* last cacheline: 40 bytes */
};--- include/linux/bpf-cgroup-defs.h | 3 ++- include/linux/bpf.h | 9 ++++++- include/linux/bpf_lsm.h | 6 ----- kernel/bpf/bpf_lsm.c | 5 ---- kernel/bpf/btf.c | 10 ------- kernel/bpf/cgroup.c | 47 ++++++++++++++++++++++++++++++++- kernel/bpf/core.c | 7 +++++ kernel/bpf/trampoline.c | 1 + 8 files changed, 64 insertions(+), 24 deletions(-)
include/linux/bpf-cgroup-defs.h +2 -1
@@ -11,7 +11,8 @@struct bpf_prog_array ;#ifdef CONFIG_BPF_LSM -#define CGROUP_LSM_NUM 211/* will be addressed in the next patch */ +/* Maximum number of concurrently attachable per-cgroup LSM hooks. */ +#define CGROUP_LSM_NUM 10#else #define CGROUP_LSM_NUM 0#endif
include/linux/bpf.h +8 -1
@@ -2508,7 +2508,6 @@ int bpf_arch_text_invalidate(void *dst, size_t len);struct btf_id_set ;bool btf_id_set_contains (const struct btf_id_set *set,u32 id); -int btf_id_set_index (const struct btf_id_set *set,u32 id);#define MAX_BPRINTF_VARARGS 12
@@ -2545,4 +2544,12 @@ void bpf_dynptr_init(struct bpf_dynptr_kern *ptr, void *data,void bpf_dynptr_set_null (struct bpf_dynptr_kern *ptr);int bpf_dynptr_check_size (u32 size); +#ifdef CONFIG_BPF_LSM +void bpf_cgroup_atype_get (u32 attach_btf_id,int cgroup_atype); +void bpf_cgroup_atype_put (int cgroup_atype); +#else +static inline void bpf_cgroup_atype_get (u32 attach_btf_id,int cgroup_atype) {} +static inline void bpf_cgroup_atype_put (int cgroup_atype) {} +#endif /* CONFIG_BPF_LSM */ +#endif /* _LINUX_BPF_H */
include/linux/bpf_lsm.h +0 -6
@@ -42,7 +42,6 @@ extern const struct bpf_func_proto bpf_inode_storage_get_proto;extern const struct bpf_func_proto bpf_inode_storage_delete_proto;void bpf_inode_storage_free (struct inode *inode); -int bpf_lsm_hook_idx (u32 btf_id);void bpf_lsm_find_cgroup_shim (const struct bpf_prog *prog,bpf_func_t *bpf_func);#else /* !CONFIG_BPF_LSM */
@@ -73,11 +72,6 @@ static inline void bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog, { } -static inline int bpf_lsm_hook_idx (u32 btf_id) -{ -return -EINVAL ; -} -#endif /* CONFIG_BPF_LSM */ #endif /* _LINUX_BPF_LSM_H */
kernel/bpf/bpf_lsm.c +0 -5
@@ -69,11 +69,6 @@ void bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog, *bpf_func = __cgroup_bpf_run_lsm_current; } -int bpf_lsm_hook_idx (u32 btf_id) -{ -return btf_id_set_index (&bpf_lsm_hooks, btf_id); -} -int bpf_lsm_verify_prog (struct bpf_verifier_log *vlog,const struct bpf_prog *prog) {
kernel/bpf/btf.c +0 -10
@@ -6843,16 +6843,6 @@ static int btf_id_cmp_func(const void *a, const void *b)return *pa - *pb; } -int btf_id_set_index (const struct btf_id_set *set,u32 id) -{ -const u32 *p; - - p =bsearch (&id, set->ids, set->cnt,sizeof (u32), btf_id_cmp_func); -if (!p) -return -1 ; -return p - set->ids; -} -bool btf_id_set_contains (const struct btf_id_set *set,u32 id) {return bsearch (&id, set->ids, set->cnt,sizeof (u32), btf_id_cmp_func) !=NULL ;
kernel/bpf/cgroup.c +46 -1
58 lines not on this page · raw message
kernel/bpf/core.c +7 -0
@@ -107,6 +107,9 @@ struct bpf_prog *bpf_prog_alloc_no_stats(unsigned int size, gfp_t gfp_extra_flag fp->aux->prog = fp; fp->jit_requested =ebpf_jit_enabled (); fp->blinding_requested =bpf_jit_blinding_enabled (fp); +#ifdef CONFIG_CGROUP_BPF + aux->cgroup_atype =CGROUP_BPF_ATTACH_TYPE_INVALID ; +#endif INIT_LIST_HEAD_RCU (&fp->aux->ksym.lnode);mutex_init (&fp->aux->used_maps_mutex);
@@ -2569,6 +2572,10 @@ static void bpf_prog_free_deferred(struct work_struct *work) aux = container_of(work, struct bpf_prog_aux, work);#ifdef CONFIG_BPF_SYSCALL bpf_free_kfunc_btf_tab (aux->kfunc_btf_tab); +#endif +#ifdef CONFIG_CGROUP_BPF +if (aux->cgroup_atype !=CGROUP_BPF_ATTACH_TYPE_INVALID ) +bpf_cgroup_atype_put (aux->cgroup_atype);#endif bpf_free_used_maps (aux);bpf_free_used_btfs (aux);
kernel/bpf/trampoline.c +1 -0
@@ -555,6 +555,7 @@ static struct bpf_shim_tramp_link *cgroup_shim_alloc(const struct bpf_prog *progbpf_prog_inc (p);bpf_link_init (&shim_link->link.link,BPF_LINK_TYPE_UNSPEC , &bpf_shim_tramp_link_lops, p); +bpf_cgroup_atype_get (p->aux->attach_btf_id, cgroup_atype);return shim_link; }
Signature · 1 line
2.37.0.rc0.161.g10f37bed90-goog
PATCH v11 5/11 bpf: implement BPF_PROG_QUERY for BPF_LSM_CGROUP
In reply to Stanislav FomichevWe have two options:
1. Treat all BPF_LSM_CGROUP the same, regardless of attach_btf_id
2. Treat BPF_LSM_CGROUP+attach_btf_id as a separate hook point
I was doing (2) in the original patch, but switching to (1) here:
* bpf_prog_query returns all attached BPF_LSM_CGROUP programs regardless of attach_btf_id
* attach_btf_id is exported via bpf_prog_info
--- include/uapi/linux/bpf.h | 3 ++ kernel/bpf/cgroup.c | 95 +++++++++++++++++++++++++++------------- kernel/bpf/syscall.c | 8 +++- 3 files changed, 74 insertions(+), 32 deletions(-)
include/uapi/linux/bpf.h +3 -0
@@ -1432,6 +1432,7 @@ union bpf_attr {__u32 attach_flags;__aligned_u64 prog_ids;__u32 prog_cnt; +__aligned_u64 prog_attach_flags;/* output: per-program attach_flags */ } query;struct {/* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */
@@ -6076,6 +6077,8 @@ struct bpf_prog_info {__u64 run_cnt;__u64 recursion_misses;__u32 verified_insns; +__u32 attach_btf_obj_id; +__u32 attach_btf_id; } __attribute__((aligned(8)));struct bpf_map_info {
kernel/bpf/cgroup.c +64 -31
121 lines not on this page · raw message
kernel/bpf/syscall.c +7 -1
@@ -3520,7 +3520,7 @@ static int bpf_prog_detach(const union bpf_attr *attr) } } -#define BPF_PROG_QUERY_LAST_FIELD query.prog_cnt +#define BPF_PROG_QUERY_LAST_FIELD query.prog_attach_flagsstatic int bpf_prog_query (const union bpf_attr *attr,union bpf_attr __user *uattr)
@@ -3556,6 +3556,7 @@ static int bpf_prog_query(const union bpf_attr *attr,case BPF_CGROUP_SYSCTL :case BPF_CGROUP_GETSOCKOPT :case BPF_CGROUP_SETSOCKOPT : +case BPF_LSM_CGROUP :return cgroup_bpf_prog_query (attr, uattr);case BPF_LIRC_MODE2 :return lirc_prog_query (attr, uattr);
@@ -4066,6 +4067,11 @@ static int bpf_prog_get_info_by_fd(struct file *file,if (prog->aux->btf) info.btf_id =btf_obj_id (prog->aux->btf); + info.attach_btf_id = prog->aux->attach_btf_id; +if (prog->aux->attach_btf) + info.attach_btf_obj_id =btf_obj_id (prog->aux->attach_btf); +else if (prog->aux->dst_prog) + info.attach_btf_obj_id =btf_obj_id (prog->aux->dst_prog->aux->attach_btf); ulen = info.nr_func_info; info.nr_func_info = prog->aux->func_info_cnt;
Signature · 1 line
2.37.0.rc0.161.g10f37bed90-goog
PATCH v11 6/11 bpf: expose bpf_{g,s}etsockopt to lsm cgroup
In reply to Stanislav FomichevI don't see how to make it nice without introducing btf id lists for the hooks where these helpers are allowed. Some LSM hooks work on the locked sockets, some are triggering early and don't grab any locks, so have two lists for now:
1. LSM hooks which trigger under socket lock - minority of the hooks, but ideal case for us, we can expose existing BTF-based helpers
2. LSM hooks which trigger without socket lock, but they trigger early in the socket creation path where it should be safe to do setsockopt without any locks
3. The rest are prohibited. I'm thinking that this use-case might be a good gateway to sleeping lsm cgroup hooks in the future. We can either expose lock/unlock operations (and add tracking to the verifier) or have another set of bpf_setsockopt wrapper that grab the locks and might sleep.
--- include/linux/bpf.h | 2 ++ kernel/bpf/bpf_lsm.c | 38 ++++++++++++++++++++++++++++ net/core/filter.c | 60 ++++++++++++++++++++++++++++++++++++++------ 3 files changed, 93 insertions(+), 7 deletions(-)
include/linux/bpf.h +2 -0
@@ -2386,6 +2386,8 @@ extern const struct bpf_func_proto bpf_for_each_map_elem_proto;extern const struct bpf_func_proto bpf_btf_find_by_name_kind_proto;extern const struct bpf_func_proto bpf_sk_setsockopt_proto;extern const struct bpf_func_proto bpf_sk_getsockopt_proto; +extern const struct bpf_func_proto bpf_unlocked_sk_setsockopt_proto; +extern const struct bpf_func_proto bpf_unlocked_sk_getsockopt_proto;extern const struct bpf_func_proto bpf_find_vma_proto;extern const struct bpf_func_proto bpf_loop_proto;extern const struct bpf_func_proto bpf_copy_from_user_task_proto;
kernel/bpf/bpf_lsm.c +38 -0
@@ -45,6 +45,24 @@ BTF_ID(func, bpf_lsm_sk_alloc_security) BTF_ID(func, bpf_lsm_sk_free_security)BTF_SET_END (bpf_lsm_current_hooks) +/* List of LSM hooks that trigger while the socket is properly locked. +*/ +BTF_SET_START (bpf_lsm_locked_sockopt_hooks ) +BTF_ID (func, bpf_lsm_socket_sock_rcv_skb) +BTF_ID (func, bpf_lsm_sock_graft) +BTF_ID (func, bpf_lsm_inet_csk_clone) +BTF_ID (func, bpf_lsm_inet_conn_established) +BTF_SET_END (bpf_lsm_locked_sockopt_hooks) + +/* List of LSM hooks that trigger while the socket is _not_ locked, +* but it's ok to call bpf_{g,s}etsockopt because the socket is still +* in the early init phase. +*/ +BTF_SET_START (bpf_lsm_unlocked_sockopt_hooks) +BTF_ID (func, bpf_lsm_socket_post_create) +BTF_ID (func, bpf_lsm_socket_socketpair) +BTF_SET_END (bpf_lsm_unlocked_sockopt_hooks) + void bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog, bpf_func_t *bpf_func) {
@@ -201,6 +219,26 @@ bpf_lsm_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)case BPF_FUNC_get_retval:return prog->expected_attach_type ==BPF_LSM_CGROUP ? &bpf_get_retval_proto :NULL ; +case BPF_FUNC_setsockopt: +if (prog->expected_attach_type !=BPF_LSM_CGROUP ) +return NULL ; +if (btf_id_set_contains (&bpf_lsm_locked_sockopt_hooks, + prog->aux->attach_btf_id)) +return &bpf_sk_setsockopt_proto; +if (btf_id_set_contains (&bpf_lsm_unlocked_sockopt_hooks, + prog->aux->attach_btf_id)) +return &bpf_unlocked_sk_setsockopt_proto; +return NULL ; +case BPF_FUNC_getsockopt: +if (prog->expected_attach_type !=BPF_LSM_CGROUP ) +return NULL ; +if (btf_id_set_contains (&bpf_lsm_locked_sockopt_hooks, + prog->aux->attach_btf_id)) +return &bpf_sk_getsockopt_proto; +if (btf_id_set_contains (&bpf_lsm_unlocked_sockopt_hooks, + prog->aux->attach_btf_id)) +return &bpf_unlocked_sk_getsockopt_proto; +return NULL ;default :return tracing_prog_func_proto (func_id, prog); }
net/core/filter.c +53 -7
95 lines not on this page · raw message
Signature · 1 line
2.37.0.rc0.161.g10f37bed90-goog
PATCH v11 7/11 tools/bpf: Sync btf_ids.h to tools
In reply to Stanislav FomichevHas been slowly getting out of sync, let's update it.
resolve_btfids usage has been updated to match the header changes.
Also bring new parts of tools/include/uapi/linux/bpf.h.
--- tools/include/linux/btf_ids.h | 35 +++++++++++++++---- tools/include/uapi/linux/bpf.h | 3 ++ .../selftests/bpf/prog_tests/resolve_btfids.c | 2 +- 3 files changed, 32 insertions(+), 8 deletions(-)
tools/include/linux/btf_ids.h +28 -7
@@ -73,7 +73,7 @@ asm( \ __BTF_ID_LIST(name, local) \extern u32 name[]; -#define BTF_ID_LIST_GLOBAL (name) \ +#define BTF_ID_LIST_GLOBAL (name, n) \ __BTF_ID_LIST(name, globl)/* The BTF_ID_LIST_SINGLE macro defines a BTF_ID_LIST with
@@ -82,6 +82,9 @@ __BTF_ID_LIST(name, globl)#define BTF_ID_LIST_SINGLE (name, prefix, typename) \ BTF_ID_LIST(name) \ BTF_ID(prefix, typename) +#define BTF_ID_LIST_GLOBAL_SINGLE (name, prefix, typename) \ + BTF_ID_LIST_GLOBAL(name, 1) \ + BTF_ID(prefix, typename)/* * The BTF_ID_UNUSED macro defines 4 zero bytes.
@@ -143,13 +146,14 @@ extern struct btf_id_set name;#else -#define BTF_ID_LIST (name) static u32 name[5]; +#define BTF_ID_LIST (name) static u32 __maybe_unused name[5];#define BTF_ID (prefix, name)#define BTF_ID_UNUSED -#define BTF_ID_LIST_GLOBAL (name) u32 name[1]; -#define BTF_ID_LIST_SINGLE (name, prefix, typename) static u32 name[1]; -#define BTF_SET_START (name) static struct btf_id_set name = { 0 }; -#define BTF_SET_START_GLOBAL (name) static struct btf_id_set name = { 0 }; +#define BTF_ID_LIST_GLOBAL (name, n) u32 __maybe_unused name[n]; +#define BTF_ID_LIST_SINGLE (name, prefix, typename) static u32 __maybe_unused name[1]; +#define BTF_ID_LIST_GLOBAL_SINGLE (name, prefix, typename) u32 __maybe_unused name[1]; +#define BTF_SET_START (name) static struct btf_id_set __maybe_unused name = { 0 }; +#define BTF_SET_START_GLOBAL (name) static struct btf_id_set __maybe_unused name = { 0 };#define BTF_SET_END (name)#endif /* CONFIG_DEBUG_INFO_BTF */
@@ -172,7 +176,10 @@ extern struct btf_id_set name; BTF_SOCK_TYPE(BTF_SOCK_TYPE_TCP_TW, tcp_timewait_sock) \ BTF_SOCK_TYPE(BTF_SOCK_TYPE_TCP6, tcp6_sock) \ BTF_SOCK_TYPE(BTF_SOCK_TYPE_UDP, udp_sock) \ - BTF_SOCK_TYPE(BTF_SOCK_TYPE_UDP6, udp6_sock) + BTF_SOCK_TYPE(BTF_SOCK_TYPE_UDP6, udp6_sock) \ + BTF_SOCK_TYPE(BTF_SOCK_TYPE_UNIX, unix_sock) \ + BTF_SOCK_TYPE(BTF_SOCK_TYPE_MPTCP, mptcp_sock) \ + BTF_SOCK_TYPE(BTF_SOCK_TYPE_SOCKET, socket) enum {#define BTF_SOCK_TYPE (name, str) name,
@@ -184,4 +191,18 @@ MAX_BTF_SOCK_TYPE,extern u32 btf_sock_ids[];#endif +#define BTF_TRACING_TYPE_xxx \ + BTF_TRACING_TYPE(BTF_TRACING_TYPE_TASK, task_struct) \ + BTF_TRACING_TYPE(BTF_TRACING_TYPE_FILE, file) \ + BTF_TRACING_TYPE(BTF_TRACING_TYPE_VMA, vm_area_struct) + +enum { +#define BTF_TRACING_TYPE(name, type) name, +BTF_TRACING_TYPE_xxx +#undef BTF_TRACING_TYPE +MAX_BTF_TRACING_TYPE , +}; + +extern u32 btf_tracing_ids[]; +#endif
tools/include/uapi/linux/bpf.h +3 -0
@@ -1432,6 +1432,7 @@ union bpf_attr {__u32 attach_flags;__aligned_u64 prog_ids;__u32 prog_cnt; +__aligned_u64 prog_attach_flags;/* output: per-program attach_flags */ } query;struct {/* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */
@@ -6076,6 +6077,8 @@ struct bpf_prog_info {__u64 run_cnt;__u64 recursion_misses;__u32 verified_insns; +__u32 attach_btf_obj_id; +__u32 attach_btf_id; } __attribute__((aligned(8)));struct bpf_map_info {
tools/testing/selftests/bpf/prog_tests/resolve_btfids.c +1 -1
@@ -44,7 +44,7 @@ BTF_ID(union, U) BTF_ID(func, func)extern __u32 test_list_global[]; -BTF_ID_LIST_GLOBAL(test_list_global) +BTF_ID_LIST_GLOBAL(test_list_global, 1) BTF_ID_UNUSED BTF_ID(typedef, S) BTF_ID(typedef, T)
Signature · 1 line
2.37.0.rc0.161.g10f37bed90-goog
PATCH v11 8/11 libbpf: add lsm_cgoup_sock type
In reply to Stanislav Fomichevlsm_cgroup/ is the prefix for BPF_LSM_CGROUP.
--- tools/lib/bpf/libbpf.c | 3 +++ 1 file changed, 3 insertions(+)
tools/lib/bpf/libbpf.c +3 -0
@@ -107,6 +107,7 @@ static const char * const attach_type_name[] = { [BPF_TRACE_FEXIT] = "trace_fexit", [BPF_MODIFY_RETURN] = "modify_return", [BPF_LSM_MAC] = "lsm_mac", + [BPF_LSM_CGROUP] = "lsm_cgroup", [BPF_SK_LOOKUP] = "sk_lookup", [BPF_TRACE_ITER] = "trace_iter", [BPF_XDP_DEVMAP] = "xdp_devmap",
@@ -9133,6 +9134,7 @@ static const struct bpf_sec_def section_defs[] = {SEC_DEF ("freplace+" ,EXT ,0 ,SEC_ATTACH_BTF , attach_trace),SEC_DEF ("lsm+" ,LSM ,BPF_LSM_MAC ,SEC_ATTACH_BTF , attach_lsm),SEC_DEF ("lsm.s+" ,LSM ,BPF_LSM_MAC ,SEC_ATTACH_BTF |SEC_SLEEPABLE , attach_lsm), +SEC_DEF ("lsm_cgroup+" ,LSM ,BPF_LSM_CGROUP ,SEC_ATTACH_BTF ),SEC_DEF ("iter+" ,TRACING ,BPF_TRACE_ITER ,SEC_ATTACH_BTF , attach_iter),SEC_DEF ("iter.s+" ,TRACING ,BPF_TRACE_ITER ,SEC_ATTACH_BTF |SEC_SLEEPABLE , attach_iter), SEC_DEF("syscall", SYSCALL, 0, SEC_SLEEPABLE),
@@ -9586,6 +9588,7 @@ void btf_get_kernel_prefix_kind(enum bpf_attach_type attach_type, *kind =BTF_KIND_TYPEDEF ;break ;case BPF_LSM_MAC : +case BPF_LSM_CGROUP : *prefix =BTF_LSM_PREFIX ; *kind =BTF_KIND_FUNC ;break ;
Signature · 1 line
2.37.0.rc0.161.g10f37bed90-goog
PATCH v11 9/11 libbpf: implement bpf_prog_query_opts
In reply to Stanislav FomichevImplement bpf_prog_query_opts as a more expendable version of bpf_prog_query. Expose new prog_attach_flags and attach_btf_func_id as well:
* prog_attach_flags is a per-program attach_type; relevant only for lsm cgroup program which might have different attach_flags per attach_btf_id
* attach_btf_func_id is a new field expose for prog_query which specifies real btf function id for lsm cgroup attachments
--- tools/lib/bpf/bpf.c | 38 +++++++++++++++++++++++++++++++------- tools/lib/bpf/bpf.h | 15 +++++++++++++++ tools/lib/bpf/libbpf.map | 1 + 3 files changed, 47 insertions(+), 7 deletions(-)
tools/lib/bpf/bpf.c +31 -7
@@ -888,24 +888,48 @@ int bpf_iter_create(int link_fd)return libbpf_err_errno (fd); } -int bpf_prog_query (int target_fd,enum bpf_attach_type type,__u32 query_flags, -__u32 *attach_flags,__u32 *prog_ids,__u32 *prog_cnt) +int bpf_prog_query_opts (int target_fd, +enum bpf_attach_type type, +struct bpf_prog_query_opts *opts) {union bpf_attr attr;int ret; +if (!OPTS_VALID (opts, bpf_prog_query_opts)) +return libbpf_err (-EINVAL ); +memset (&attr,0 ,sizeof (attr)); + attr.query.target_fd = target_fd; attr.query.attach_type = type; - attr.query.query_flags = query_flags; - attr.query.prog_cnt = *prog_cnt; - attr.query.prog_ids =ptr_to_u64 (prog_ids); + attr.query.query_flags =OPTS_GET (opts, query_flags,0 ); + attr.query.prog_cnt =OPTS_GET (opts, prog_cnt,0 ); + attr.query.prog_ids =ptr_to_u64 (OPTS_GET (opts, prog_ids,NULL )); + attr.query.prog_attach_flags =ptr_to_u64 (OPTS_GET (opts, prog_attach_flags,NULL )); ret =sys_bpf (BPF_PROG_QUERY , &attr,sizeof (attr)); +OPTS_SET (opts, attach_flags, attr.query.attach_flags); +OPTS_SET (opts, prog_cnt, attr.query.prog_cnt); + +return libbpf_err_errno (ret); +} + +int bpf_prog_query (int target_fd,enum bpf_attach_type type,__u32 query_flags, +__u32 *attach_flags,__u32 *prog_ids,__u32 *prog_cnt) +{ +LIBBPF_OPTS (bpf_prog_query_opts, opts); +int ret; + + opts.query_flags = query_flags; + opts.prog_ids = prog_ids; + opts.prog_cnt = *prog_cnt; + + ret =bpf_prog_query_opts (target_fd, type, &opts); +if (attach_flags) - *attach_flags = attr.query.attach_flags; - *prog_cnt = attr.query.prog_cnt; + *attach_flags = opts.attach_flags; + *prog_cnt = opts.prog_cnt;return libbpf_err_errno (ret); }
tools/lib/bpf/bpf.h +15 -0
@@ -442,9 +442,24 @@ LIBBPF_API int bpf_map_get_fd_by_id(__u32 id); LIBBPF_API int bpf_btf_get_fd_by_id(__u32 id); LIBBPF_API int bpf_link_get_fd_by_id(__u32 id); LIBBPF_API int bpf_obj_get_info_by_fd(int bpf_fd, void *info, __u32 *info_len); + +struct bpf_prog_query_opts { +size_t sz;/* size of this struct for forward/backward compatibility */ +__u32 query_flags; +__u32 attach_flags;/* output argument */ +__u32 *prog_ids; +__u32 prog_cnt;/* input+output argument */ +__u32 *prog_attach_flags; +}; +#define bpf_prog_query_opts__last_field prog_attach_flags + +LIBBPF_API int bpf_prog_query_opts(int target_fd, +enum bpf_attach_type type, +struct bpf_prog_query_opts *opts); LIBBPF_API int bpf_prog_query(int target_fd, enum bpf_attach_type type,__u32 query_flags,__u32 *attach_flags,__u32 *prog_ids,__u32 *prog_cnt); + LIBBPF_API int bpf_raw_tracepoint_open(const char *name, int prog_fd); LIBBPF_API int bpf_task_fd_query(int pid, int fd, __u32 flags, char *buf, __u32 *buf_len, __u32 *prog_id, __u32 *fd_type,
tools/lib/bpf/libbpf.map +1 -0
@@ -462,6 +462,7 @@ LIBBPF_0.8.0 { LIBBPF_1.0.0 { global: + bpf_prog_query_opts; btf__add_enum64; btf__add_enum64_value; libbpf_bpf_attach_type_str;
Signature · 1 line
2.37.0.rc0.161.g10f37bed90-goog
PATCH v11 10/11 bpftool: implement cgroup tree for BPF_LSM_CGROUP
In reply to Stanislav Fomichev$ bpftool --nomount prog loadall $KDIR/tools/testing/selftests/bpf/lsm_cgroup.o /sys/fs/bpf/x $ bpftool cgroup attach /sys/fs/cgroup lsm_cgroup pinned /sys/fs/bpf/x/socket_alloc $ bpftool cgroup attach /sys/fs/cgroup lsm_cgroup pinned /sys/fs/bpf/x/socket_bind $ bpftool cgroup attach /sys/fs/cgroup lsm_cgroup pinned /sys/fs/bpf/x/socket_clone $ bpftool cgroup attach /sys/fs/cgroup lsm_cgroup pinned /sys/fs/bpf/x/socket_post_create $ bpftool cgroup tree CgroupPath ID AttachType AttachFlags Name /sys/fs/cgroup 6 lsm_cgroup socket_post_create bpf_lsm_socket_post_create 8 lsm_cgroup socket_bind bpf_lsm_socket_bind 10 lsm_cgroup socket_alloc bpf_lsm_sk_alloc_security 11 lsm_cgroup socket_clone bpf_lsm_inet_csk_clone
$ bpftool cgroup detach /sys/fs/cgroup lsm_cgroup pinned /sys/fs/bpf/x/socket_post_create $ bpftool cgroup tree CgroupPath ID AttachType AttachFlags Name /sys/fs/cgroup 8 lsm_cgroup socket_bind bpf_lsm_socket_bind 10 lsm_cgroup socket_alloc bpf_lsm_sk_alloc_security 11 lsm_cgroup socket_clone bpf_lsm_inet_csk_clone
--- tools/bpf/bpftool/cgroup.c | 109 +++++++++++++++++++++++++++++-------- 1 file changed, 87 insertions(+), 22 deletions(-)
tools/bpf/bpftool/cgroup.c +87 -22
@@ -15,6 +15,7 @@#include <unistd.h> #include <bpf/bpf.h> +#include <bpf/btf.h> #include "main.h"
@@ -36,6 +37,8 @@" cgroup_inet_sock_release }" static unsigned int query_flags; +static struct btf *btf_vmlinux; +static __u32 btf_vmlinux_id;static enum bpf_attach_type parse_attach_type (const char *str) {
@@ -64,11 +67,38 @@ static enum bpf_attach_type parse_attach_type(const char *str)return __MAX_BPF_ATTACH_TYPE; } +static void guess_vmlinux_btf_id (__u32 attach_btf_obj_id) +{ +struct bpf_btf_info btf_info = {}; +__u32 btf_len =sizeof (btf_info); +char name[16 ] = {}; +int err; +int fd; + + btf_info.name =ptr_to_u64 (name); + btf_info.name_len =sizeof (name); + + fd =bpf_btf_get_fd_by_id (attach_btf_obj_id); +if (fd <0 ) +return ; + + err =bpf_obj_get_info_by_fd (fd, &btf_info, &btf_len); +if (err) + goto out; + +if (btf_info.kernel_btf &&strncmp (name,"vmlinux" ,sizeof (name)) ==0 ) + btf_vmlinux_id = btf_info.id; + +out: +close (fd); +} +static int show_bpf_prog (int id,enum bpf_attach_type attach_type,const char *attach_flags_str,int level) {char prog_name[MAX_PROG_FULL_NAME ]; +const char *attach_btf_name =NULL ;struct bpf_prog_info info = {};const char *attach_type_str;__u32 info_len =sizeof (info);
@@ -84,6 +114,20 @@ static int show_bpf_prog(int id, enum bpf_attach_type attach_type, } attach_type_str =libbpf_bpf_attach_type_str (attach_type); + +if (btf_vmlinux) { +if (!btf_vmlinux_id) +guess_vmlinux_btf_id (info.attach_btf_obj_id); + +if (btf_vmlinux_id == info.attach_btf_obj_id && + info.attach_btf_id <btf__type_cnt (btf_vmlinux)) { +const struct btf_type *t = +btf__type_by_id (btf_vmlinux, info.attach_btf_id); + attach_btf_name = +btf__name_by_offset (btf_vmlinux, t->name_off); + } + } +get_prog_full_name (&info, prog_fd, prog_name,sizeof (prog_name));if (json_output) {jsonw_start_object (json_wtr);
@@ -95,6 +139,10 @@ static int show_bpf_prog(int id, enum bpf_attach_type attach_type,jsonw_string_field (json_wtr,"attach_flags" , attach_flags_str);jsonw_string_field (json_wtr,"name" , prog_name); +if (attach_btf_name) +jsonw_string_field (json_wtr,"attach_btf_name" , attach_btf_name); +jsonw_uint_field (json_wtr,"attach_btf_obj_id" , info.attach_btf_obj_id); +jsonw_uint_field (json_wtr,"attach_btf_id" , info.attach_btf_id);jsonw_end_object (json_wtr); }else {printf ("%s%-8u " , level ?" " :"" , info.id);
@@ -102,7 +150,13 @@ static int show_bpf_prog(int id, enum bpf_attach_type attach_type,printf ("%-15s" , attach_type_str); else printf("type %-10u", attach_type); -printf (" %-15s %-15s\n" , attach_flags_str, prog_name); +printf (" %-15s %-15s" , attach_flags_str, prog_name); +if (attach_btf_name) +printf (" %-15s" , attach_btf_name); +else if (info.attach_btf_id) +printf (" attach_btf_obj_id=%d attach_btf_id=%d" , + info.attach_btf_obj_id, info.attach_btf_id); +printf ("\n" ); }close (prog_fd);
@@ -144,40 +198,49 @@ static int cgroup_has_attached_progs(int cgroup_fd)static int show_attached_bpf_progs (int cgroup_fd,enum bpf_attach_type type,int level) { +LIBBPF_OPTS (bpf_prog_query_opts, p); +__u32 prog_attach_flags[1024 ] = {0 };const char *attach_flags_str;__u32 prog_ids[1024 ] = {0 }; -__u32 prog_cnt, iter; -__u32 attach_flags;char buf[32 ]; +__u32 iter;int ret; - prog_cnt =ARRAY_SIZE (prog_ids); - ret =bpf_prog_query (cgroup_fd, type, query_flags, &attach_flags, - prog_ids, &prog_cnt); + p.query_flags = query_flags; + p.prog_cnt =ARRAY_SIZE (prog_ids); + p.prog_ids = prog_ids; + p.prog_attach_flags = prog_attach_flags; + + ret =bpf_prog_query_opts (cgroup_fd, type, &p);if (ret)return ret; -if (prog_cnt ==0 ) +if (p.prog_cnt ==0 )return 0 ; -switch (attach_flags) { -case BPF_F_ALLOW_MULTI : - attach_flags_str ="multi" ; -break ; -case BPF_F_ALLOW_OVERRIDE : - attach_flags_str ="override" ; -break ; -case 0 : - attach_flags_str ="" ; -break ; -default : -snprintf (buf,sizeof (buf),"unknown(%x)" , attach_flags); - attach_flags_str = buf; - } +for (iter =0 ; iter < p.prog_cnt; iter++) { +__u32 attach_flags; + + attach_flags = prog_attach_flags[iter] ?: p.attach_flags; + +switch (attach_flags) { +case BPF_F_ALLOW_MULTI : + attach_flags_str ="multi" ; +break ; +case BPF_F_ALLOW_OVERRIDE : + attach_flags_str ="override" ; +break ; +case 0 : + attach_flags_str ="" ; +break ; +default : +snprintf (buf,sizeof (buf),"unknown(%x)" , attach_flags); + attach_flags_str = buf; + } -for (iter =0 ; iter < prog_cnt; iter++)show_bpf_prog (prog_ids[iter], type, attach_flags_str, level); + }return 0 ; }
@@ -233,6 +296,7 @@ static int do_show(int argc, char **argv)printf ("%-8s %-15s %-15s %-15s\n" ,"ID" ,"AttachType" ,"AttachFlags" ,"Name" ); + btf_vmlinux =libbpf_find_kernel_btf ();for (type =0 ; type < __MAX_BPF_ATTACH_TYPE; type++) {/* * Not all attach types may be supported, so it's expected,
@@ -296,6 +360,7 @@ static int do_show_tree_fn(const char *fpath, const struct stat *sb,printf ("%s\n" , fpath); } + btf_vmlinux =libbpf_find_kernel_btf ();for (type =0 ; type < __MAX_BPF_ATTACH_TYPE; type++)show_attached_bpf_progs (cgroup_fd, type, ftw->level);
Signature · 1 line
2.37.0.rc0.161.g10f37bed90-goog
PATCH v11 11/11 selftests/bpf: lsm_cgroup functional test
In reply to Stanislav FomichevFunctional test that exercises the following:
1. apply default sk_priority policy
2. permit TX-only AF_PACKET socket
3. cgroup attach/detach/replace
4. reusing trampoline shim
--- .../selftests/bpf/prog_tests/lsm_cgroup.c | 293 ++++++++++++++++++ .../selftests/bpf/progs/bpf_tracing_net.h | 1 + .../testing/selftests/bpf/progs/lsm_cgroup.c | 180 +++++++++++ 3 files changed, 474 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/lsm_cgroup.c create mode 100644 tools/testing/selftests/bpf/progs/lsm_cgroup.c
tools/testing/selftests/bpf/prog_tests/lsm_cgroup.c new file +293 -0
@@ -0,0 +1,293 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <sys/types.h> +#include <sys/socket.h> +#include <test_progs.h> +#include <bpf/btf.h> + +#include "lsm_cgroup.skel.h" +#include "cgroup_helpers.h" +#include "network_helpers.h" + +static struct btf *btf; + +static __u32 query_prog_cnt (int cgroup_fd,const char *attach_func) +{ +LIBBPF_OPTS (bpf_prog_query_opts, p); +int cnt =0 ; +int i; + +ASSERT_OK (bpf_prog_query_opts (cgroup_fd,BPF_LSM_CGROUP , &p),"prog_query" ); + +if (!attach_func) +return p.prog_cnt; + +/* When attach_func is provided, count the number of progs that +* attach to the given symbol. +*/ + +if (!btf) + btf =btf__load_vmlinux_btf (); +if (!ASSERT_OK (libbpf_get_error (btf),"btf_vmlinux" )) +return -1 ; + + p.prog_ids =malloc (sizeof (u32) * p.prog_cnt); + p.prog_attach_flags =malloc (sizeof (u32) * p.prog_cnt); +ASSERT_OK (bpf_prog_query_opts (cgroup_fd,BPF_LSM_CGROUP , &p),"prog_query" ); + +for (i =0 ; i < p.prog_cnt; i++) { +struct bpf_prog_info info = {}; +__u32 info_len =sizeof (info); +int fd; + + fd =bpf_prog_get_fd_by_id (p.prog_ids[i]); +ASSERT_GE (fd,0 ,"prog_get_fd_by_id" ); +ASSERT_OK (bpf_obj_get_info_by_fd (fd, &info, &info_len),"prog_info_by_fd" ); +close (fd); + +if (info.attach_btf_id == +btf__find_by_name_kind (btf, attach_func,BTF_KIND_FUNC )) + cnt++; + } + +free (p.prog_ids); +free (p.prog_attach_flags); + +return cnt; +} + +static void test_lsm_cgroup_functional (void ) +{ +DECLARE_LIBBPF_OPTS (bpf_prog_attach_opts, attach_opts); +DECLARE_LIBBPF_OPTS (bpf_link_update_opts, update_opts); +int cgroup_fd =-1 , cgroup_fd2 =-1 , cgroup_fd3 =-1 ; +int listen_fd, client_fd, accepted_fd; +struct lsm_cgroup *skel =NULL ; +int post_create_prog_fd2 =-1 ; +int post_create_prog_fd =-1 ; +int bind_link_fd2 =-1 ; +int bind_prog_fd2 =-1 ; +int alloc_prog_fd =-1 ; +int bind_prog_fd =-1 ; +int bind_link_fd =-1 ; +int clone_prog_fd =-1 ; +int err, fd, prio; +socklen_t socklen; + + cgroup_fd3 =test__join_cgroup ("/sock_policy_empty" ); +if (!ASSERT_GE (cgroup_fd3,0 ,"create empty cgroup" )) + goto close_cgroup; + + cgroup_fd2 =test__join_cgroup ("/sock_policy_reuse" ); +if (!ASSERT_GE (cgroup_fd2,0 ,"create cgroup for reuse" )) + goto close_cgroup; + + cgroup_fd =test__join_cgroup ("/sock_policy" ); +if (!ASSERT_GE (cgroup_fd,0 ,"join_cgroup" )) + goto close_cgroup; + + skel =lsm_cgroup__open_and_load (); +if (!ASSERT_OK_PTR (skel,"open_and_load" )) + goto close_cgroup; + + post_create_prog_fd =bpf_program__fd (skel->progs.socket_post_create); + post_create_prog_fd2 =bpf_program__fd (skel->progs.socket_post_create2); + bind_prog_fd =bpf_program__fd (skel->progs.socket_bind); + bind_prog_fd2 =bpf_program__fd (skel->progs.socket_bind2); + alloc_prog_fd =bpf_program__fd (skel->progs.socket_alloc); + clone_prog_fd =bpf_program__fd (skel->progs.socket_clone); + +ASSERT_EQ (query_prog_cnt (cgroup_fd,"bpf_lsm_sk_alloc_security" ),0 ,"prog count" ); +ASSERT_EQ (query_prog_cnt (cgroup_fd,NULL ),0 ,"total prog count" ); + err =bpf_prog_attach (alloc_prog_fd, cgroup_fd,BPF_LSM_CGROUP ,0 ); +if (!ASSERT_OK (err,"attach alloc_prog_fd" )) + goto detach_cgroup; +ASSERT_EQ (query_prog_cnt (cgroup_fd,"bpf_lsm_sk_alloc_security" ),1 ,"prog count" ); +ASSERT_EQ (query_prog_cnt (cgroup_fd,NULL ),1 ,"total prog count" ); + +ASSERT_EQ (query_prog_cnt (cgroup_fd,"bpf_lsm_inet_csk_clone" ),0 ,"prog count" ); + err =bpf_prog_attach (clone_prog_fd, cgroup_fd,BPF_LSM_CGROUP ,0 ); +if (!ASSERT_OK (err,"attach clone_prog_fd" )) + goto detach_cgroup; +ASSERT_EQ (query_prog_cnt (cgroup_fd,"bpf_lsm_inet_csk_clone" ),1 ,"prog count" ); +ASSERT_EQ (query_prog_cnt (cgroup_fd,NULL ),2 ,"total prog count" ); + +/* Make sure replacing works. */ + +ASSERT_EQ (query_prog_cnt (cgroup_fd,"bpf_lsm_socket_post_create" ),0 ,"prog count" ); + err =bpf_prog_attach (post_create_prog_fd, cgroup_fd, +BPF_LSM_CGROUP ,0 ); +if (!ASSERT_OK (err,"attach post_create_prog_fd" )) + goto detach_cgroup; +ASSERT_EQ (query_prog_cnt (cgroup_fd,"bpf_lsm_socket_post_create" ),1 ,"prog count" ); +ASSERT_EQ (query_prog_cnt (cgroup_fd,NULL ),3 ,"total prog count" ); + + attach_opts.replace_prog_fd = post_create_prog_fd; + err =bpf_prog_attach_opts (post_create_prog_fd2, cgroup_fd, +BPF_LSM_CGROUP , &attach_opts); +if (!ASSERT_OK (err,"prog replace post_create_prog_fd" )) + goto detach_cgroup; +ASSERT_EQ (query_prog_cnt (cgroup_fd,"bpf_lsm_socket_post_create" ),1 ,"prog count" ); +ASSERT_EQ (query_prog_cnt (cgroup_fd,NULL ),3 ,"total prog count" ); + +/* Try the same attach/replace via link API. */ + +ASSERT_EQ (query_prog_cnt (cgroup_fd,"bpf_lsm_socket_bind" ),0 ,"prog count" ); + bind_link_fd =bpf_link_create (bind_prog_fd, cgroup_fd, +BPF_LSM_CGROUP ,NULL ); +if (!ASSERT_GE (bind_link_fd,0 ,"link create bind_prog_fd" )) + goto detach_cgroup; +ASSERT_EQ (query_prog_cnt (cgroup_fd,"bpf_lsm_socket_bind" ),1 ,"prog count" ); +ASSERT_EQ (query_prog_cnt (cgroup_fd,NULL ),4 ,"total prog count" ); + + update_opts.old_prog_fd = bind_prog_fd; + update_opts.flags =BPF_F_REPLACE ; + + err =bpf_link_update (bind_link_fd, bind_prog_fd2, &update_opts); +if (!ASSERT_OK (err,"link update bind_prog_fd" )) + goto detach_cgroup; +ASSERT_EQ (query_prog_cnt (cgroup_fd,"bpf_lsm_socket_bind" ),1 ,"prog count" ); +ASSERT_EQ (query_prog_cnt (cgroup_fd,NULL ),4 ,"total prog count" ); + +/* Attach another instance of bind program to another cgroup. +* This should trigger the reuse of the trampoline shim (two +* programs attaching to the same btf_id). +*/ + +ASSERT_EQ (query_prog_cnt (cgroup_fd,"bpf_lsm_socket_bind" ),1 ,"prog count" ); +ASSERT_EQ (query_prog_cnt (cgroup_fd2,"bpf_lsm_socket_bind" ),0 ,"prog count" ); + bind_link_fd2 =bpf_link_create (bind_prog_fd2, cgroup_fd2, +BPF_LSM_CGROUP ,NULL ); +if (!ASSERT_GE (bind_link_fd2,0 ,"link create bind_prog_fd2" )) + goto detach_cgroup; +ASSERT_EQ (query_prog_cnt (cgroup_fd2,"bpf_lsm_socket_bind" ),1 ,"prog count" ); +ASSERT_EQ (query_prog_cnt (cgroup_fd,NULL ),4 ,"total prog count" ); +ASSERT_EQ (query_prog_cnt (cgroup_fd2,NULL ),1 ,"total prog count" ); + +/* AF_UNIX is prohibited. */ + + fd =socket (AF_UNIX ,SOCK_STREAM ,0 ); +ASSERT_LT (fd,0 ,"socket(AF_UNIX)" ); +close (fd); + +/* AF_INET6 gets default policy (sk_priority). */ + + fd =socket (AF_INET6 ,SOCK_STREAM ,0 ); +if (!ASSERT_GE (fd,0 ,"socket(SOCK_STREAM)" )) + goto detach_cgroup; + + prio =0 ; + socklen =sizeof (prio); +ASSERT_GE (getsockopt (fd,SOL_SOCKET ,SO_PRIORITY , &prio, &socklen),0 , +"getsockopt" ); +ASSERT_EQ (prio,123 ,"sk_priority" ); + +close (fd); + +/* TX-only AF_PACKET is allowed. */ + +ASSERT_LT (socket (AF_PACKET ,SOCK_RAW ,htons (ETH_P_ALL )),0 , +"socket(AF_PACKET, ..., ETH_P_ALL)" ); + + fd =socket (AF_PACKET ,SOCK_RAW ,0 ); +ASSERT_GE (fd,0 ,"socket(AF_PACKET, ..., 0)" ); + +/* TX-only AF_PACKET can not be rebound. */ + +struct sockaddr_ll sa = { + .sll_family =AF_PACKET , + .sll_protocol =htons (ETH_P_ALL ), + }; +ASSERT_LT (bind (fd, (struct sockaddr *)&sa,sizeof (sa)),0 , +"bind(ETH_P_ALL)" ); + +close (fd); + +/* Trigger passive open. */ + + listen_fd =start_server (AF_INET6 ,SOCK_STREAM ,"::1" ,0 ,0 ); +ASSERT_GE (listen_fd,0 ,"start_server" ); + client_fd =connect_to_fd (listen_fd,0 ); +ASSERT_GE (client_fd,0 ,"connect_to_fd" ); + accepted_fd =accept (listen_fd,NULL ,NULL ); +ASSERT_GE (accepted_fd,0 ,"accept" ); + + prio =0 ; + socklen =sizeof (prio); +ASSERT_GE (getsockopt (accepted_fd,SOL_SOCKET ,SO_PRIORITY , &prio, &socklen),0 , +"getsockopt" ); +ASSERT_EQ (prio,234 ,"sk_priority" ); + +/* These are replaced and never called. */ +ASSERT_EQ (skel->bss->called_socket_post_create,0 ,"called_create" ); +ASSERT_EQ (skel->bss->called_socket_bind,0 ,"called_bind" ); + +/* AF_INET6+SOCK_STREAM +* AF_PACKET+SOCK_RAW +* listen_fd +* client_fd +* accepted_fd +*/ +ASSERT_EQ (skel->bss->called_socket_post_create2,5 ,"called_create2" ); + +/* start_server +* bind(ETH_P_ALL) +*/ +ASSERT_EQ (skel->bss->called_socket_bind2,2 ,"called_bind2" ); +/* Single accept(). */ +ASSERT_EQ (skel->bss->called_socket_clone,1 ,"called_clone" ); + +/* AF_UNIX+SOCK_STREAM (failed) +* AF_INET6+SOCK_STREAM +* AF_PACKET+SOCK_RAW (failed) +* AF_PACKET+SOCK_RAW +* listen_fd +* client_fd +* accepted_fd +*/ +ASSERT_EQ (skel->bss->called_socket_alloc,7 ,"called_alloc" ); + +close (listen_fd); +close (client_fd); +close (accepted_fd); + +/* Make sure other cgroup doesn't trigger the programs. */ + +if (!ASSERT_OK (join_cgroup ("/sock_policy_empty" ),"join root cgroup" )) + goto detach_cgroup; + + fd =socket (AF_INET6 ,SOCK_STREAM ,0 ); +if (!ASSERT_GE (fd,0 ,"socket(SOCK_STREAM)" )) + goto detach_cgroup; + + prio =0 ; + socklen =sizeof (prio); +ASSERT_GE (getsockopt (fd,SOL_SOCKET ,SO_PRIORITY , &prio, &socklen),0 , +"getsockopt" ); +ASSERT_EQ (prio,0 ,"sk_priority" ); + +close (fd); + +detach_cgroup: +ASSERT_GE (bpf_prog_detach2 (post_create_prog_fd2, cgroup_fd, +BPF_LSM_CGROUP ),0 ,"detach_create" ); +close (bind_link_fd); +/* Don't close bind_link_fd2, exercise cgroup release cleanup. */ +ASSERT_GE (bpf_prog_detach2 (alloc_prog_fd, cgroup_fd, +BPF_LSM_CGROUP ),0 ,"detach_alloc" ); +ASSERT_GE (bpf_prog_detach2 (clone_prog_fd, cgroup_fd, +BPF_LSM_CGROUP ),0 ,"detach_clone" ); + +close_cgroup: +close (cgroup_fd); +close (cgroup_fd2); +close (cgroup_fd3); +lsm_cgroup__destroy (skel); +} + +void test_lsm_cgroup (void ) +{ +if (test__start_subtest ("functional" )) +test_lsm_cgroup_functional (); +btf__free (btf); +}
tools/testing/selftests/bpf/progs/bpf_tracing_net.h +1 -0
@@ -8,6 +8,7 @@#define SOL_SOCKET 1#define SO_SNDBUF 7#define __SO_ACCEPTCON (1 << 16) +#define SO_PRIORITY 12#define SOL_TCP 6#define TCP_CONGESTION 13
tools/testing/selftests/bpf/progs/lsm_cgroup.c new file +180 -0
180 lines not on this page · raw message
Signature · 1 line
2.37.0.rc0.161.g10f37bed90-goog
Re: [PATCH bpf-next v11 11/11] selftests/bpf: lsm_cgroup functional test
Quoted 6 lines · Stanislav Fomichev
Functional test that exercises the following:
1. apply default
sk_prioritypolicy
2. permit TX-onlyAF_PACKETsocket
3. cgroup attach/detach/replace
4. reusing trampoline shim
Re: [PATCH bpf-next v11 11/11] selftests/bpf: lsm_cgroup functional test
In reply to Stanislav FomichevReview
Quoted 2 lines · Stanislav Fomichev
(quoted diff) +2
-0+ +static void test_lsm_cgroup_functional(void)
It fails BPF CI on s390:
test_lsm_cgroup_functional:FAIL:attach alloc_prog_fd unexpected error:
-524 (errno 524) test_lsm_cgroup_functional:FAIL:detach_create unexpecteddetach_create: actual -2 < expected 0 test_lsm_cgroup_functional:FAIL:detach_alloc unexpected detach_alloc:
actual -2 < expected 0 test_lsm_cgroup_functional:FAIL:detach_clone unexpected detach_clone:
actual -2 < expected 0
https://github.com/kernel-patches/bpf/runs/7100626120?check_suite_focus=true
but I pushed it to bpf-next anyway.
Thanks a lot for this work and please follow up with a fix.
Thanks a lot Martin for the code reviews.
Re: [PATCH bpf-next v11 11/11] selftests/bpf: lsm_cgroup functional test
Quoted 16 lines · Alexei Starovoitov
Review
Quoted 2 lines · Stanislav Fomichev
(quoted diff) +2
-0+ +static void test_lsm_cgroup_functional(void)It fails BPF CI on s390:
test_lsm_cgroup_functional:FAIL:attach
alloc_prog_fdunexpected error:
-524 (errno 524) test_lsm_cgroup_functional:FAIL:detach_create unexpecteddetach_create: actual -2 < expected 0 test_lsm_cgroup_functional:FAIL:detach_alloc unexpecteddetach_alloc:
actual -2 < expected 0 test_lsm_cgroup_functional:FAIL:detach_clone unexpecteddetach_clone:
actual -2 < expected 0
Quoted 4 lines
https://github.com/kernel-patches/bpf/runs/7100626120?check_suite_focus=true
but I pushed it to bpf-next anyway.
Thanks a lot for this work and please follow up with a fix.
Thanks, I'll take a look!
Quoted 1 line
Thanks a lot Martin for the code reviews.
+1, thanks Martin. I was trying to keep respinning at most once per week, I hope I haven't overwhelmed you. The end result is so much better because of your inputs.
Re: [PATCH bpf-next v11 11/11] selftests/bpf: lsm_cgroup functional test
Quoted 19 lines · Stanislav Fomichev
Quoted 16 lines · Alexei Starovoitov
Review
Quoted 2 lines · Stanislav Fomichev
(quoted diff) +2
-0+ +static void test_lsm_cgroup_functional(void)It fails BPF CI on s390:
test_lsm_cgroup_functional:FAIL:attach
alloc_prog_fdunexpected error:
-524 (errno 524) test_lsm_cgroup_functional:FAIL:detach_create unexpecteddetach_create: actual -2 < expected 0 test_lsm_cgroup_functional:FAIL:detach_alloc unexpecteddetach_alloc:
actual -2 < expected 0 test_lsm_cgroup_functional:FAIL:detach_clone unexpecteddetach_clone:
actual -2 < expected 0
Quoted 6 lines
Quoted 4 lines
https://github.com/kernel-patches/bpf/runs/7100626120?check_suite_focus=true
but I pushed it to bpf-next anyway.
Thanks a lot for this work and please follow up with a fix.Thanks, I'll take a look!
Looks like this needs a blacklist entry in
https://github.com/kernel-patches/vmtest/blob/master/travis-ci/vmtest/configs/blacklist/BLACKLIST-latest.s390x
Or, I can make tests more flexible by doing the following (copy-pasting into gmail, so tabs are broken):
(quoted diff) +0 -0
b/tools/testing/selftests/bpf/prog_tests/lsm_cgroup.c index d40810a742fa..904b02a17598 100644
tools/testing/selftests/bpf/prog_tests/lsm_cgroup.c +0 -0
@@ -100,6 +100,10 @@ static void test_lsm_cgroup_functional(void) ASSERT_EQ(query_prog_cnt(cgroup_fd, "bpf_lsm_sk_alloc_security"), 0,
"prog count");
ASSERT_EQ(query_prog_cnt(cgroup_fd, NULL), 0, "total prog count"); err = bpf_prog_attach(alloc_prog_fd, cgroup_fd, BPF_LSM_CGROUP, 0);
+ if (err < 0 && errno == ENOTSUPP) {
+ test__skip();
+ return;
+ }
if (!ASSERT_OK(err, "attach alloc_prog_fd"))
goto detach_cgroup;
ASSERT_EQ(query_prog_cnt(cgroup_fd, "bpf_lsm_sk_alloc_security"), 1,
"prog count");
Any preference?
Re: [PATCH bpf-next v11 11/11] selftests/bpf: lsm_cgroup functional test
Quoted 53 lines · Stanislav Fomichev
Quoted 19 lines · Stanislav Fomichev
Quoted 16 lines · Alexei Starovoitov
Review
Quoted 2 lines · Stanislav Fomichev
(quoted diff) +2
-0+ +static void test_lsm_cgroup_functional(void)It fails BPF CI on s390:
test_lsm_cgroup_functional:FAIL:attach
alloc_prog_fdunexpected error:
-524 (errno 524) test_lsm_cgroup_functional:FAIL:detach_create unexpecteddetach_create: actual -2 < expected 0 test_lsm_cgroup_functional:FAIL:detach_alloc unexpecteddetach_alloc:
actual -2 < expected 0 test_lsm_cgroup_functional:FAIL:detach_clone unexpecteddetach_clone:
actual -2 < expected 0Quoted 6 lines
Quoted 4 lines
https://github.com/kernel-patches/bpf/runs/7100626120?check_suite_focus=true
but I pushed it to bpf-next anyway.
Thanks a lot for this work and please follow up with a fix.Thanks, I'll take a look!
Looks like this needs a blacklist entry in
https://github.com/kernel-patches/vmtest/blob/master/travis-ci/vmtest/configs/blacklist/BLACKLIST-latest.s390xOr, I can make tests more flexible by doing the following (copy-pasting into gmail, so tabs are broken):
tools/testing/selftests/bpf/prog_tests/lsm_cgroup.c +4
-0@@ -100,6 +100,10 @@ static void test_lsm_cgroup_functional(void)ASSERT_EQ (query_prog_cnt (cgroup_fd,"bpf_lsm_sk_alloc_security" ),0 ,"prog count" );ASSERT_EQ (query_prog_cnt (cgroup_fd,NULL ),0 ,"total prog count" ); err =bpf_prog_attach (alloc_prog_fd, cgroup_fd,BPF_LSM_CGROUP ,0 ); +if (err <0 && errno ==ENOTSUPP ) { +test__skip (); +return ; + }if (!ASSERT_OK (err,"attach alloc_prog_fd" )) goto detach_cgroup;ASSERT_EQ(query_prog_cnt(cgroup_fd, "
bpf_lsm_sk_alloc_security"), 1,
"prog count");
Quoted 1 line
Any preference?
Ahh. Right. s390 lacks bpf trampoline support.
We've been blacklisting the tests manually,
but if it's fixable this way it's better to do it in the test, so when s390 (and other archs) gain trampoline support the test will be executed automatically without waiting for CI maintainers to unlist the tests.
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Hello:
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Quoted 12 lines · On Tue, 28 Jun 2022 10:43:03 -0700 you wrote:
This series implements new lsm flavor for attaching per-cgroup programs to existing lsm hooks. The cgroup is taken out of 'current', unless the first argument of the hook is 'struct socket'. In this case, the cgroup association is taken out of socket. The attachment looks like a regular per-cgroup attachment: we add new
BPF_LSM_CGROUPattach type which, together withattach_btf_id, signals per-cgroup lsm. Behind the scenes, we allocate trampoline shim program and attach to lsm. This program looks up cgroup from current/socket and runs cgroup's effective prog array. The rest of the per-cgroup BPF stays the same: hierarchy, local storage, retval conventions (return 1 == success).
Quoted 1 line
[...]
Here is the summary with links:
- [bpf-next,v11,01/11] bpf: add bpf_func_t and trampoline helpers
https://git.kernel.org/bpf/bpf-next/c/af3f4134006b - [bpf-next,v11,02/11] bpf: convert cgroup_bpf.progs to hlist https://git.kernel.org/bpf/bpf-next/c/00442143a2ab - [bpf-next,v11,03/11] bpf: per-cgroup lsm flavor https://git.kernel.org/bpf/bpf-next/c/69fd337a975c - [bpf-next,v11,04/11] bpf: minimize number of allocated lsm slots per program https://git.kernel.org/bpf/bpf-next/c/c0e19f2c9a3e - [bpf-next,v11,05/11] bpf: implement BPF_PROG_QUERY for BPF_LSM_CGROUP https://git.kernel.org/bpf/bpf-next/c/b79c9fc9551b - [bpf-next,v11,06/11] bpf: expose bpf_{g,s}etsockopt to lsm cgroup https://git.kernel.org/bpf/bpf-next/c/9113d7e48e91 - [bpf-next,v11,07/11] tools/bpf: Sync btf_ids.h to tools https://git.kernel.org/bpf/bpf-next/c/3b34bcb946c2 - [bpf-next,v11,08/11] libbpf: add lsm_cgoup_sock type https://git.kernel.org/bpf/bpf-next/c/bffcf34878b1 - [bpf-next,v11,09/11] libbpf: implement bpf_prog_query_opts https://git.kernel.org/bpf/bpf-next/c/a4b2f3cf699f - [bpf-next,v11,10/11] bpftool: implement cgroup tree for BPF_LSM_CGROUP https://git.kernel.org/bpf/bpf-next/c/596f5fb2ea2a - [bpf-next,v11,11/11] selftests/bpf: lsm_cgroup functional test https://git.kernel.org/bpf/bpf-next/c/dca85aac8895
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html