bpf: cgroup_sock lsm flavor
Subsystems (9)
v3 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; this bloats bpf_cgroup a bit
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 (7):
bpf: add bpf_func_t and trampoline helpers
bpf: per-cgroup lsm flavor
bpf: minimize number of allocated lsm slots per program
bpf: allow writing to a subset of sock fields from lsm progtype
libbpf: add lsm_cgoup_sock type
selftests/bpf: lsm_cgroup functional test selftests/bpf: verify lsm_cgroup struct sock access
include/linux/bpf-cgroup-defs.h | 8 + include/linux/bpf.h | 24 +- include/linux/bpf_lsm.h | 8 + include/uapi/linux/bpf.h | 1 + kernel/bpf/bpf_lsm.c | 147 ++++++++++++ kernel/bpf/btf.c | 11 + kernel/bpf/cgroup.c | 210 ++++++++++++++++-- kernel/bpf/syscall.c | 10 + kernel/bpf/trampoline.c | 205 ++++++++++++++--- kernel/bpf/verifier.c | 4 +- tools/bpf/bpftool/common.c | 1 + tools/include/uapi/linux/bpf.h | 1 + tools/lib/bpf/libbpf.c | 2 + .../selftests/bpf/prog_tests/lsm_cgroup.c | 158 +++++++++++++ .../testing/selftests/bpf/progs/lsm_cgroup.c | 94 ++++++++ tools/testing/selftests/bpf/test_verifier.c | 54 ++++- .../selftests/bpf/verifier/lsm_cgroup.c | 34 +++ 17 files changed, 914 insertions(+), 58 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/lsm_cgroup.c create mode 100644 tools/testing/selftests/bpf/progs/lsm_cgroup.c create mode 100644 tools/testing/selftests/bpf/verifier/lsm_cgroup.c
Signature · 1 line
2.35.1.1178.g4f1659d476-goog
PATCH v3 1/7 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, 40 insertions(+), 34 deletions(-)
include/linux/bpf.h +5 -6
@@ -52,6 +52,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;
@@ -798,8 +800,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); }
@@ -827,8 +828,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); \ } \
@@ -839,8 +839,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 +35 -28
107 lines not on this page · raw message
Signature · 1 line
2.35.1.1178.g4f1659d476-goog
PATCH v3 2/7 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' 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 the hooks that work on 'struct sock' we still take the cgroup from 'current' because most of the time, the 'sock' argument is not properly initialized.
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 per-cgroup lsm hook.
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.
--- include/linux/bpf-cgroup-defs.h | 6 ++ include/linux/bpf.h | 13 +++ include/linux/bpf_lsm.h | 14 ++++ include/uapi/linux/bpf.h | 1 + kernel/bpf/bpf_lsm.c | 92 ++++++++++++++++++++ kernel/bpf/btf.c | 11 +++ kernel/bpf/cgroup.c | 116 ++++++++++++++++++++++--- kernel/bpf/syscall.c | 10 +++ kernel/bpf/trampoline.c | 144 ++++++++++++++++++++++++++++++++ kernel/bpf/verifier.c | 1 + tools/include/uapi/linux/bpf.h | 1 + 11 files changed, 397 insertions(+), 12 deletions(-)
include/linux/bpf-cgroup-defs.h +6 -0
@@ -10,6 +10,8 @@struct bpf_prog_array ; +#define CGROUP_LSM_NUM 211/* will be addressed in the next patch */ +enum cgroup_bpf_attach_type {CGROUP_BPF_ATTACH_TYPE_INVALID =-1 ,CGROUP_INET_INGRESS =0 ,
@@ -35,6 +37,10 @@ enum cgroup_bpf_attach_type {CGROUP_INET4_GETSOCKNAME ,CGROUP_INET6_GETSOCKNAME ,CGROUP_INET_SOCK_RELEASE , +#ifdef CONFIG_BPF_LSM +CGROUP_LSM_START , +CGROUP_LSM_END =CGROUP_LSM_START +CGROUP_LSM_NUM -1 , +#endif MAX_CGROUP_BPF_ATTACH_TYPE };
include/linux/bpf.h +13 -0
@@ -807,6 +807,9 @@ static __always_inline __nocfi unsigned int bpf_dispatcher_nop_func(#ifdef CONFIG_BPF_JIT int bpf_trampoline_link_prog (struct bpf_prog *prog,struct bpf_trampoline *tr);int bpf_trampoline_unlink_prog (struct bpf_prog *prog,struct bpf_trampoline *tr); +int bpf_trampoline_link_cgroup_shim (struct bpf_prog *prog, +struct bpf_attach_target_info *tgt_info); +void bpf_trampoline_unlink_cgroup_shim (struct bpf_prog *prog);struct bpf_trampoline *bpf_trampoline_get (u64 key,struct bpf_attach_target_info *tgt_info);void bpf_trampoline_put (struct bpf_trampoline *tr);
@@ -865,6 +868,14 @@ static inline int bpf_trampoline_unlink_prog(struct bpf_prog *prog, {return -ENOTSUPP ; } +static inline int bpf_trampoline_link_cgroup_shim (struct bpf_prog *prog, +struct bpf_attach_target_info *tgt_info) +{ +return -EOPNOTSUPP ; +} +static inline void bpf_trampoline_unlink_cgroup_shim (struct bpf_prog *prog) +{ +}static inline struct bpf_trampoline *bpf_trampoline_get (u64 key,struct bpf_attach_target_info *tgt_info) {
@@ -980,6 +991,7 @@ struct bpf_prog_aux {u64 load_time;/* ns since boottime */ u32 verified_insns;struct bpf_map *cgroup_storage[MAX_BPF_CGROUP_STORAGE_TYPE ]; +int cgroup_atype;/* enum cgroup_bpf_attach_type */ char name[BPF_OBJ_NAME_LEN ];#ifdef CONFIG_SECURITY void *security;
@@ -2383,6 +2395,7 @@ void *bpf_arch_text_copy(void *dst, void *src, 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 +14 -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_find_cgroup_shim (const struct bpf_prog *prog,bpf_func_t *bpf_func); +int bpf_lsm_hook_idx (u32 btf_id); +#else /* !CONFIG_BPF_LSM */ static inline bool bpf_lsm_is_sleepable_hook (u32 btf_id)
@@ -65,6 +68,17 @@ static inline void bpf_inode_storage_free(struct inode *inode) { } +static inline int bpf_lsm_find_cgroup_shim (const struct bpf_prog *prog, +bpf_func_t *bpf_func) +{ +return -ENOENT ; +} + +static inline int bpf_lsm_hook_idx (u32 btf_id) +{ +return -EINVAL ; +} +#endif /* CONFIG_BPF_LSM */ #endif /* _LINUX_BPF_LSM_H */
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 +92 -0
98 lines not on this page · raw message
kernel/bpf/btf.c +11 -0
@@ -4971,6 +4971,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
@@ -6396,6 +6397,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 +104 -12
196 lines not on this page · raw message
kernel/bpf/syscall.c +10 -0
@@ -3139,6 +3139,11 @@ static int bpf_prog_attach_check_attach_type(const struct bpf_prog *prog,return prog->enforce_expected_attach_type && prog->expected_attach_type != attach_type ? -EINVAL :0 ; +case BPF_PROG_TYPE_LSM : +if (prog->expected_attach_type !=BPF_LSM_CGROUP ) +return -EINVAL ; +return 0 ; +default :return 0 ; }
@@ -3194,6 +3199,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 ; }
@@ -3247,6 +3254,7 @@ 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 : ret =cgroup_bpf_prog_attach (attr, ptype, prog);break ;default :
@@ -3284,6 +3292,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 ;
@@ -4317,6 +4326,7 @@ static int link_create(union bpf_attr *attr, bpfptr_t uattr)case BPF_PROG_TYPE_CGROUP_DEVICE :case BPF_PROG_TYPE_CGROUP_SYSCTL :case BPF_PROG_TYPE_CGROUP_SOCKOPT : +case BPF_PROG_TYPE_LSM : ret =cgroup_bpf_link_attach (attr, prog);break ;case BPF_PROG_TYPE_TRACING :
kernel/bpf/trampoline.c +144 -0
162 lines not on this page · raw message
kernel/bpf/verifier.c +1 -0
@@ -14197,6 +14197,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.35.1.1178.g4f1659d476-goog
kernel test robot
build botRe: [PATCH bpf-next v3 2/7] bpf: per-cgroup lsm flavor
Thank you for the patch! Yet something to improve:
Hi Stanislav,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on bpf-next/master]
url: https://github.com/intel-lab-lkp/linux/commits/Stanislav-Fomichev/bpf-cgroup_sock-lsm-flavor/20220408-063705 base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master config: arm64-randconfig-r011-20220408 (https://download.01.org/0day-ci/archive/20220408/[email protected]/config) compiler: aarch64-linux-gcc (GCC) 11.2.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/intel-lab-lkp/linux/commit/3c3f15b5422ca616e2585d699c47aa4e7b7dcf1d
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review Stanislav-Fomichev/bpf-cgroup_sock-lsm-flavor/20220408-063705 git checkout 3c3f15b5422ca616e2585d699c47aa4e7b7dcf1d
# save the config file to linux build tree
mkdir build_dir
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross O=build_dir ARCH=arm64 SHELL=/bin/bash
If you fix the issue, kindly add following tag as appropriate
All errors (new ones prefixed by >>):
aarch64-linux-ld: Unexpected GOT/PLT entries detected!
aarch64-linux-ld: Unexpected run-time procedure linkages detected!
aarch64-linux-ld: ID map text too big or misaligned
aarch64-linux-ld: kernel/bpf/trampoline.o: in function `bpf_trampoline_compute_key':
include/linux/bpf_verifier.h:540: undefined reference to `btf_obj_id'
>> aarch64-linux-ld: include/linux/bpf_verifier.h:540: undefined reference to `btf_obj_id'
Signature · 2 lines
0-DAY CI Kernel Test Service https://01.org/lkp
kernel test robot
build botRe: [PATCH bpf-next v3 2/7] bpf: per-cgroup lsm flavor
In reply to Stanislav FomichevThank you for the patch! Yet something to improve:
Hi Stanislav,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on bpf-next/master]
url: https://github.com/intel-lab-lkp/linux/commits/Stanislav-Fomichev/bpf-cgroup_sock-lsm-flavor/20220408-063705 base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master config: x86_64-randconfig-a005 (https://download.01.org/0day-ci/archive/20220408/[email protected]/config) compiler: clang version 15.0.0 (https://github.com/llvm/llvm-project c29a51b3a257908aebc01cd7c4655665db317d66)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/intel-lab-lkp/linux/commit/3c3f15b5422ca616e2585d699c47aa4e7b7dcf1d
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review Stanislav-Fomichev/bpf-cgroup_sock-lsm-flavor/20220408-063705 git checkout 3c3f15b5422ca616e2585d699c47aa4e7b7dcf1d
# save the config file to linux build tree
mkdir build_dir
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=x86_64 SHELL=/bin/bash
If you fix the issue, kindly add following tag as appropriate
All errors (new ones prefixed by >>):
>> ld.lld: error: undefined symbol: btf_obj_id >>> referenced by trampoline.c >>> bpf/trampoline.o:(bpf_trampoline_link_cgroup_shim) in archive kernel/built-in.a >>> referenced by trampoline.c >>> bpf/trampoline.o:(bpf_trampoline_unlink_cgroup_shim) in archive kernel/built-in.a
Signature · 2 lines
0-DAY CI Kernel Test Service https://01.org/lkp
Re: [PATCH bpf-next v3 2/7] bpf: per-cgroup lsm flavor
Quoted 21 lines · kernel test robot
Hi Stanislav,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on bpf-next/master]
url: https://github.com/intel-lab-lkp/linux/commits/Stanislav-Fomichev/bpf-cgroup_sock-lsm-flavor/20220408-063705 base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master config: x86_64-randconfig-a005 (https://download.01.org/0day-ci/archive/20220408/202204082305.Qs2g5Dzf-lkp(a)intel.com/config) compiler: clang version 15.0.0 (https://github.com/llvm/llvm-project c29a51b3a257908aebc01cd7c4655665db317d66)reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/intel-lab-lkp/linux/commit/3c3f15b5422ca616e2585d699c47aa4e7b7dcf1d
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review Stanislav-Fomichev/bpf-cgroup_sock-lsm-flavor/20220408-063705 git checkout3c3f15b5422ca616e2585d699c47aa4e7b7dcf1d
# save the config file to linux build tree
mkdirbuild_dir
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=x86_64 SHELL=/bin/bash
Quoted 10 lines
If you fix the issue, kindly add following tag as appropriate
Reported-by kernel test robot <[email protected]>All errors (new ones prefixed by >>):
Quoted 5 lines
Quoted 5 lines
ld.lld: error: undefined symbol:
btf_obj_idQuoted 4 lines
referenced by
trampoline.c
bpf/trampoline.o:(bpf_trampoline_link_cgroup_shim) in archivekernel/built-in.a
referenced bytrampoline.c
bpf/trampoline.o:(bpf_trampoline_unlink_cgroup_shim) in archivekernel/built-in.a
It is probably because obj-$(CONFIG_BPF_JIT) += trampoline.o while obj-$(CONFIG_BPF_SYSCALL) += btf.o.
Good catch but seems minor and should not affect the review. Please hold off the respin a little first so that the review can continue on this revision.
Dan Carpenter
build botRe: [PATCH bpf-next v3 2/7] bpf: per-cgroup lsm flavor
In reply to Stanislav FomichevCC: kbuild-all(a)lists.01.org BCC: lkp(a)intel.com In-Reply-To: <[email protected]> References: <[email protected]> TO: Stanislav Fomichev…
CC: kbuild-all(a)lists.01.org
BCC: lkp(a)intel.com
In-Reply-To: <[email protected]>
References: <[email protected]>
TO: Stanislav Fomichev <[email protected]>
TO: netdev(a)vger.kernel.org
TO: bpf(a)vger.kernel.org
CC: ast(a)kernel.org
CC: daniel(a)iogearbox.net
CC: andrii(a)kernel.org
CC: Stanislav Fomichev <[email protected]>
Hi Stanislav,
Thank you for the patch! Perhaps something to improve:
[auto build test WARNING on bpf-next/master]
url: https://github.com/intel-lab-lkp/linux/commits/Stanislav-Fomichev/bpf-cgroup_sock-lsm-flavor/20220408-063705 base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master
:::::: branch date: 23 hours ago
:::::: commit date: 23 hours ago
config: openrisc-randconfig-m031-20220408 (https://download.01.org/0day-ci/archive/20220409/202204090535.gy7lTeMG-lkp(a)intel.com/config)
compiler: or1k-linux-gcc (GCC) 11.2.0
If you fix the issue, kindly add following tag as appropriate
smatch warnings:kernel/bpf/cgroup.c:575 __cgroup_bpf_attach() warn: missing error code 'err'
vim +/err +575 kernel/bpf/cgroup.c
af6eea57437a83 Andrii Nakryiko 2020-03-29 457
3007098494bec6 Daniel Mack 2016-11-23 458 /**
af6eea57437a83 Andrii Nakryiko 2020-03-29 459 * __cgroup_bpf_attach() - Attach the program or the link to a cgroup, and
3007098494bec6 Daniel Mack 2016-11-23 460 * propagate the change to descendants
3007098494bec6 Daniel Mack 2016-11-23 461 * @cgrp: The cgroup which descendants to traverse
324bda9e6c5add Alexei Starovoitov 2017-10-02 462 * @prog: A program to attach
af6eea57437a83 Andrii Nakryiko 2020-03-29 463 * @link: A link to attach
7dd68b3279f179 Andrey Ignatov 2019-12-18 464 * @replace_prog: Previously attached program to replace if BPF_F_REPLACE is set
324bda9e6c5add Alexei Starovoitov 2017-10-02 465 * @type: Type of attach operation
1832f4ef5867fd Valdis Kletnieks 2019-01-29 466 * @flags: Option flags
3007098494bec6 Daniel Mack 2016-11-23 467 *
af6eea57437a83 Andrii Nakryiko 2020-03-29 468 * Exactly one of @prog or @link can be non-null.
3007098494bec6 Daniel Mack 2016-11-23 469 * Must be called with cgroup_mutex held.
3007098494bec6 Daniel Mack 2016-11-23 470 */
588e5d8766486e He Fengqing 2021-10-29 471 static int __cgroup_bpf_attach(struct cgroup *cgrp,
af6eea57437a83 Andrii Nakryiko 2020-03-29 472 struct bpf_prog *prog, struct bpf_prog *replace_prog,
af6eea57437a83 Andrii Nakryiko 2020-03-29 473 struct bpf_cgroup_link *link,
324bda9e6c5add Alexei Starovoitov 2017-10-02 474 enum bpf_attach_type type, u32 flags)
3007098494bec6 Daniel Mack 2016-11-23 475 {
7dd68b3279f179 Andrey Ignatov 2019-12-18 476 u32 saved_flags = (flags & (BPF_F_ALLOW_OVERRIDE | BPF_F_ALLOW_MULTI));
324bda9e6c5add Alexei Starovoitov 2017-10-02 477 struct bpf_prog *old_prog = NULL;
62039c30c19dca Andrii Nakryiko 2020-03-09 478 struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE] = {};
7d9c3427894fe7 YiFei Zhu 2020-07-23 479 struct bpf_cgroup_storage *new_storage[MAX_BPF_CGROUP_STORAGE_TYPE] = {};
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 480 struct bpf_attach_target_info tgt_info = {};
6fc88c354f3af8 Dave Marchevsky 2021-08-19 481 enum cgroup_bpf_attach_type atype;
af6eea57437a83 Andrii Nakryiko 2020-03-29 482 struct bpf_prog_list *pl;
6fc88c354f3af8 Dave Marchevsky 2021-08-19 483 struct list_head *progs;
324bda9e6c5add Alexei Starovoitov 2017-10-02 484 int err;
324bda9e6c5add Alexei Starovoitov 2017-10-02 485
7dd68b3279f179 Andrey Ignatov 2019-12-18 486 if (((flags & BPF_F_ALLOW_OVERRIDE) && (flags & BPF_F_ALLOW_MULTI)) ||
7dd68b3279f179 Andrey Ignatov 2019-12-18 487 ((flags & BPF_F_REPLACE) && !(flags & BPF_F_ALLOW_MULTI)))
324bda9e6c5add Alexei Starovoitov 2017-10-02 488 /* invalid combination */
324bda9e6c5add Alexei Starovoitov 2017-10-02 489 return -EINVAL;
af6eea57437a83 Andrii Nakryiko 2020-03-29 490 if (link && (prog || replace_prog))
af6eea57437a83 Andrii Nakryiko 2020-03-29 491 /* only either link or prog/replace_prog can be specified */
af6eea57437a83 Andrii Nakryiko 2020-03-29 492 return -EINVAL;
af6eea57437a83 Andrii Nakryiko 2020-03-29 493 if (!!replace_prog != !!(flags & BPF_F_REPLACE))
af6eea57437a83 Andrii Nakryiko 2020-03-29 494 /* replace_prog implies BPF_F_REPLACE, and vice versa */
af6eea57437a83 Andrii Nakryiko 2020-03-29 495 return -EINVAL;
324bda9e6c5add Alexei Starovoitov 2017-10-02 496
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 497 if (type == BPF_LSM_CGROUP) {
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 498 struct bpf_prog *p = prog ? : link->link.prog;
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 499
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 500 if (replace_prog) {
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 501 /* Reusing shim from the original program.
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 502 */
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 503 atype = replace_prog->aux->cgroup_atype;
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 504 } else {
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 505 err = bpf_check_attach_target(NULL, p, NULL,
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 506 p->aux->attach_btf_id,
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 507 &tgt_info);
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 508 if (err)
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 509 return -EINVAL;
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 510
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 511 atype = bpf_lsm_attach_type_get(p->aux->attach_btf_id);
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 512 if (atype < 0)
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 513 return atype;
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 514 }
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 515
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 516 p->aux->cgroup_atype = atype;
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 517 } else {
6fc88c354f3af8 Dave Marchevsky 2021-08-19 518 atype = to_cgroup_bpf_attach_type(type);
6fc88c354f3af8 Dave Marchevsky 2021-08-19 519 if (atype < 0)
6fc88c354f3af8 Dave Marchevsky 2021-08-19 520 return -EINVAL;
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 521 }
6fc88c354f3af8 Dave Marchevsky 2021-08-19 522
6fc88c354f3af8 Dave Marchevsky 2021-08-19 523 progs = &cgrp->bpf.progs[atype];
6fc88c354f3af8 Dave Marchevsky 2021-08-19 524
6fc88c354f3af8 Dave Marchevsky 2021-08-19 525 if (!hierarchy_allows_attach(cgrp, atype))
7f677633379b4a Alexei Starovoitov 2017-02-10 526 return -EPERM;
7f677633379b4a Alexei Starovoitov 2017-02-10 527
6fc88c354f3af8 Dave Marchevsky 2021-08-19 528 if (!list_empty(progs) && cgrp->bpf.flags[atype] != saved_flags)
324bda9e6c5add Alexei Starovoitov 2017-10-02 529 /* Disallow attaching non-overridable on top
324bda9e6c5add Alexei Starovoitov 2017-10-02 530 * of existing overridable in this cgroup.
324bda9e6c5add Alexei Starovoitov 2017-10-02 531 * Disallow attaching multi-prog if overridable or none
7f677633379b4a Alexei Starovoitov 2017-02-10 532 */
7f677633379b4a Alexei Starovoitov 2017-02-10 533 return -EPERM;
7f677633379b4a Alexei Starovoitov 2017-02-10 534
324bda9e6c5add Alexei Starovoitov 2017-10-02 535 if (prog_list_length(progs) >= BPF_CGROUP_MAX_PROGS)
324bda9e6c5add Alexei Starovoitov 2017-10-02 536 return -E2BIG;
324bda9e6c5add Alexei Starovoitov 2017-10-02 537
af6eea57437a83 Andrii Nakryiko 2020-03-29 538 pl = find_attach_entry(progs, prog, link, replace_prog,
af6eea57437a83 Andrii Nakryiko 2020-03-29 539 flags & BPF_F_ALLOW_MULTI);
af6eea57437a83 Andrii Nakryiko 2020-03-29 540 if (IS_ERR(pl))
af6eea57437a83 Andrii Nakryiko 2020-03-29 541 return PTR_ERR(pl);
324bda9e6c5add Alexei Starovoitov 2017-10-02 542
7d9c3427894fe7 YiFei Zhu 2020-07-23 543 if (bpf_cgroup_storages_alloc(storage, new_storage, type,
7d9c3427894fe7 YiFei Zhu 2020-07-23 544 prog ? : link->link.prog, cgrp))
324bda9e6c5add Alexei Starovoitov 2017-10-02 545 return -ENOMEM;
d7bf2c10af0531 Roman Gushchin 2018-08-02 546
af6eea57437a83 Andrii Nakryiko 2020-03-29 547 if (pl) {
1020c1f24a946e Andrey Ignatov 2019-12-18 548 old_prog = pl->prog;
324bda9e6c5add Alexei Starovoitov 2017-10-02 549 } else {
324bda9e6c5add Alexei Starovoitov 2017-10-02 550 pl = kmalloc(sizeof(*pl), GFP_KERNEL);
d7bf2c10af0531 Roman Gushchin 2018-08-02 551 if (!pl) {
7d9c3427894fe7 YiFei Zhu 2020-07-23 552 bpf_cgroup_storages_free(new_storage);
324bda9e6c5add Alexei Starovoitov 2017-10-02 553 return -ENOMEM;
d7bf2c10af0531 Roman Gushchin 2018-08-02 554 }
324bda9e6c5add Alexei Starovoitov 2017-10-02 555 list_add_tail(&pl->node, progs);
324bda9e6c5add Alexei Starovoitov 2017-10-02 556 }
1020c1f24a946e Andrey Ignatov 2019-12-18 557
324bda9e6c5add Alexei Starovoitov 2017-10-02 558 pl->prog = prog;
af6eea57437a83 Andrii Nakryiko 2020-03-29 559 pl->link = link;
00c4eddf7ee5cb Andrii Nakryiko 2020-03-24 560 bpf_cgroup_storages_assign(pl->storage, storage);
6fc88c354f3af8 Dave Marchevsky 2021-08-19 561 cgrp->bpf.flags[atype] = saved_flags;
324bda9e6c5add Alexei Starovoitov 2017-10-02 562
6fc88c354f3af8 Dave Marchevsky 2021-08-19 563 err = update_effective_progs(cgrp, atype);
324bda9e6c5add Alexei Starovoitov 2017-10-02 564 if (err)
324bda9e6c5add Alexei Starovoitov 2017-10-02 565 goto cleanup;
324bda9e6c5add Alexei Starovoitov 2017-10-02 566
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 567 bpf_cgroup_storages_link(new_storage, cgrp, type);
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 568
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 569 if (type == BPF_LSM_CGROUP && !old_prog) {
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 570 struct bpf_prog *p = prog ? : link->link.prog;
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 571 int err;
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 572
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 573 err = bpf_trampoline_link_cgroup_shim(p, &tgt_info);
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 574 if (err)
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 @575 goto cleanup_trampoline;
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 576 }
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 577
af6eea57437a83 Andrii Nakryiko 2020-03-29 578 if (old_prog)
324bda9e6c5add Alexei Starovoitov 2017-10-02 579 bpf_prog_put(old_prog);
af6eea57437a83 Andrii Nakryiko 2020-03-29 580 else
6fc88c354f3af8 Dave Marchevsky 2021-08-19 581 static_branch_inc(&cgroup_bpf_enabled_key[atype]);
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 582
324bda9e6c5add Alexei Starovoitov 2017-10-02 583 return 0;
324bda9e6c5add Alexei Starovoitov 2017-10-02 584
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 585 cleanup_trampoline:
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 586 bpf_cgroup_storages_unlink(new_storage);
3c3f15b5422ca6 Stanislav Fomichev 2022-04-07 587
324bda9e6c5add Alexei Starovoitov 2017-10-02 588 cleanup:
af6eea57437a83 Andrii Nakryiko 2020-03-29 589 if (old_prog) {
324bda9e6c5add Alexei Starovoitov 2017-10-02 590 pl->prog = old_prog;
af6eea57437a83 Andrii Nakryiko 2020-03-29 591 pl->link = NULL;
8bad74f9840f87 Roman Gushchin 2018-09-28 592 }
7d9c3427894fe7 YiFei Zhu 2020-07-23 593 bpf_cgroup_storages_free(new_storage);
af6eea57437a83 Andrii Nakryiko 2020-03-29 594 if (!old_prog) {
324bda9e6c5add Alexei Starovoitov 2017-10-02 595 list_del(&pl->node);
324bda9e6c5add Alexei Starovoitov 2017-10-02 596 kfree(pl);
324bda9e6c5add Alexei Starovoitov 2017-10-02 597 }
324bda9e6c5add Alexei Starovoitov 2017-10-02 598 return err;
324bda9e6c5add Alexei Starovoitov 2017-10-02 599 }
324bda9e6c5add Alexei Starovoitov 2017-10-02 600 Signature · 2 lines
0-DAY CI Kernel Test Service https://01.org/lkp
Re: [PATCH bpf-next v3 2/7] bpf: per-cgroup lsm flavor
In reply to Stanislav FomichevQuoted 12 lines · Stanislav Fomichev
kernel/bpf/bpf_lsm.c +4
-0@@ -35,6 +35,98 @@ BTF_SET_START(bpf_lsm_hooks)#undef LSM_HOOKBTF_SET_END (bpf_lsm_hooks) +static unsigned int __cgroup_bpf_run_lsm_socket(const void *ctx, +const struct bpf_insn *insn) +{ +const struct bpf_prog *prog;
kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 51
Quoted 10 lines
kernel/bpf/bpf_lsm.c +10
-0+struct socket *sock; +struct cgroup *cgrp; +struct sock *sk; +int ret =0 ; +u64 *regs; + + regs = (u64 *)ctx; + sock = (void *)(unsigned long )regs[BPF_REG_0 ]; +/*prog = container_of(insn, struct bpf_prog, insnsi);*/ + prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi));
nit. Rename prog to shim_prog.
kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 53
Quoted 2 lines
kernel/bpf/bpf_lsm.c +2
-0+ +if (unlikely (!sock))
Is it possible in the lsm hooks? Can these hooks
be rejected at the load time instead?
kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 57
Quoted 4 lines
kernel/bpf/bpf_lsm.c +4
-0+return 0 ; + + sk = sock->sk; +if (unlikely (!sk))
Same here.
Quoted 11 lines
kernel/bpf/bpf_lsm.c +11
-0+return 0 ; + + cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data); +if (likely (cgrp)) + ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], + ctx, bpf_prog_run,0 ); +return ret; +} + +static unsigned int __cgroup_bpf_run_lsm_current (const void *ctx, +const struct bpf_insn *insn)
kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 78
Quoted 10 lines
kernel/bpf/bpf_lsm.c +10
-0+{ +const struct bpf_prog *prog; +struct cgroup *cgrp; +int ret =0 ; + +if (unlikely (!current)) +return 0 ; + +/*prog = container_of(insn, struct bpf_prog, insnsi);*/ + prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi));
nit. shim_prog here also.
Quoted 11 lines
kernel/bpf/bpf_lsm.c +11
-0+ +rcu_read_lock (); + cgrp =task_dfl_cgroup (current); +if (likely (cgrp)) + ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], + ctx, bpf_prog_run,0 ); +rcu_read_unlock (); +return ret; +} + +int bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,
kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 99
Quoted 10 lines
kernel/bpf/bpf_lsm.c +10
-0+ bpf_func_t *bpf_func) +{ +const struct btf_type *first_arg_type; +const struct btf_type *sock_type; +const struct btf *btf_vmlinux; +const struct btf_param *args; +s32 type_id; + +if (!prog->aux->attach_func_proto || + !btf_type_is_func_proto (prog->aux->attach_func_proto))
Are these cases possible at the attaching time or they have already been rejected at the load time? If it is the latter, these tests can be removed.
kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 102
Quoted 3 lines
kernel/bpf/bpf_lsm.c +3
-0+return -EINVAL ; + +if (btf_type_vlen (prog->aux->attach_func_proto) <1 )
Is it consistent with the existing BPF_LSM_MAC? or is there something special about BPF_LSM_CGROUP that it cannot support this func ?
kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 105
Quoted 3 lines
kernel/bpf/bpf_lsm.c +3
-0+return -EINVAL ; + + args = (const struct btf_param *)(prog->aux->attach_func_proto +1 );
nit.
args = btf_params(prog->aux->attach_func_proto);
Quoted 105 lines
kernel/bpf/bpf_lsm.c +24
-0+ + btf_vmlinux =bpf_get_btf_vmlinux (); +if (!btf_vmlinux) +return -EINVAL ; + + type_id =btf_find_by_name_kind (btf_vmlinux,"socket" ,BTF_KIND_STRUCT ); +if (type_id <0 ) +return -EINVAL ; + sock_type =btf_type_by_id (btf_vmlinux, type_id); + + first_arg_type =btf_type_resolve_ptr (btf_vmlinux, args[0 ].type,NULL ); +if (first_arg_type == sock_type) + *bpf_func = __cgroup_bpf_run_lsm_socket; +else + *bpf_func = __cgroup_bpf_run_lsm_current; + +return 0 ; +} + +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 +11
-0@@ -4971,6 +4971,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 @@ -6396,6 +6397,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 +23
-0@@ -14,6 +14,9 @@#include <linux/string.h> #include <linux/bpf.h> #include <linux/bpf-cgroup.h> +#include <linux/btf_ids.h> +#include <linux/bpf_lsm.h> +#include <linux/bpf_verifier.h> #include <net/sock.h> #include <net/bpf_sk_storage.h> @@ -22,6 +25,18 @@DEFINE_STATIC_KEY_ARRAY_FALSE (cgroup_bpf_enabled_key,MAX_CGROUP_BPF_ATTACH_TYPE );EXPORT_SYMBOL (cgroup_bpf_enabled_key); +#ifdef CONFIG_BPF_LSM +static enum cgroup_bpf_attach_type bpf_lsm_attach_type_get (u32 attach_btf_id) +{ +return CGROUP_LSM_START +bpf_lsm_hook_idx (attach_btf_id); +} +#else +static enum cgroup_bpf_attach_type bpf_lsm_attach_type_get (u32 attach_btf_id) +{ +return -EOPNOTSUPP ; +} +#endif +void cgroup_bpf_offline (struct cgroup *cgrp) {cgroup_get (cgrp);@@ -89,6 +104,14 @@ static void bpf_cgroup_storages_link(struct bpf_cgroup_storage *storages[],bpf_cgroup_storage_link (storages[stype], cgrp, attach_type); } +static void bpf_cgroup_storages_unlink (struct bpf_cgroup_storage *storages[]) +{ +enum bpf_cgroup_storage_type stype; + +for_each_cgroup_storage_type (stype) +bpf_cgroup_storage_unlink (storages[stype]); +} +/* Called when bpf_cgroup_link is auto-detached from dying cgroup. * It drops cgroup and bpf_prog refcounts, and marks bpf_link as defunct. It * doesn't free link memory, which will eventually be done by bpf_link's
kernel/bpf/cgroup.c static void bpf_cgroup_link_auto_detach(struct bpf_cgroup_link *link) · line 129
Quoted 7 lines
kernel/bpf/cgroup.c +4
-0@@ -100,6 +123,15 @@ static void bpf_cgroup_link_auto_detach(struct bpf_cgroup_link *link) link->cgroup =NULL ; } +static void bpf_cgroup_lsm_shim_release (struct bpf_prog *prog, +enum cgroup_bpf_attach_type atype) +{ +if (!prog || atype != prog->aux->cgroup_atype)
prog cannot be NULL here, no?
The 'atype != prog->aux->cgroup_atype' looks suspicious also considering prog->aux->cgroup_atype is only initialized (and meaningful) for BPF_LSM_CGROUP. I suspect incorrectly passing this test will crash in the below bpf_trampoline_unlink_cgroup_shim(). More on this later.
kernel/bpf/cgroup.c static void cgroup_bpf_release(struct work_struct *work)
Quoted 9 lines
kernel/bpf/cgroup.c +5
-0+return ; + +bpf_trampoline_unlink_cgroup_shim (prog); +} +/** * cgroup_bpf_release() - put references of all bpf programs and * release all cgroup bpf data @@ -123,10 +155,16 @@ static void cgroup_bpf_release(struct work_struct *work)
Copying some missing loop context here:
for (atype = 0; atype < ARRAY_SIZE(cgrp->bpf.progs); atype++) {
struct list_head *progs = &cgrp->bpf.progs[atype];
struct bpf_prog_list *pl, *pltmp;kernel/bpf/cgroup.c static void cgroup_bpf_release(struct work_struct *work) · line 160
Quoted 7 lines
kernel/bpf/cgroup.c +3
-1list_for_each_entry_safe (pl, pltmp, progs, node) {list_del (&pl->node); -if (pl->prog) +if (pl->prog) { +bpf_cgroup_lsm_shim_release (pl->prog, + atype);
atype could be 0 (CGROUP_INET_INGRESS) here. bpf_cgroup_lsm_shim_release() above will go ahead with bpf_trampoline_unlink_cgroup_shim(). It will break some of the assumptions. e.g. prog->aux->attach_btf is NULL for CGROUP_INET_INGRESS.
Instead, only call bpf_cgroup_lsm_shim_release() for BPF_LSM_CGROUP ?
If the above observation is sane, I wonder if the existing test_progs have uncovered it or may be the existing tests just always detach cleanly itself before cleaning the cgroup which then avoided this case.
Quoted 36 lines
kernel/bpf/cgroup.c +16
-4bpf_prog_put (pl->prog); -if (pl->link) + } +if (pl->link) { +bpf_cgroup_lsm_shim_release (pl->link->link.prog, + atype);bpf_cgroup_link_auto_detach (pl->link); + }kfree (pl);static_branch_dec (&cgroup_bpf_enabled_key[atype]); }@@ -439,6 +477,7 @@ static int __cgroup_bpf_attach(struct cgroup *cgrp,struct bpf_prog *old_prog =NULL ;struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE ] = {};struct bpf_cgroup_storage *new_storage[MAX_BPF_CGROUP_STORAGE_TYPE ] = {}; +struct bpf_attach_target_info tgt_info = {};enum cgroup_bpf_attach_type atype;struct bpf_prog_list *pl;struct list_head *progs;@@ -455,9 +494,31 @@ static int __cgroup_bpf_attach(struct cgroup *cgrp,/* replace_prog implies BPF_F_REPLACE, and vice versa */ return -EINVAL ; - atype =to_cgroup_bpf_attach_type (type); -if (atype <0 ) -return -EINVAL ; +if (type ==BPF_LSM_CGROUP ) { +struct bpf_prog *p = prog ? : link->link.prog; + +if (replace_prog) { +/* Reusing shim from the original program. +*/ + atype = replace_prog->aux->cgroup_atype; + }else { + err = bpf_check_attach_target(NULL, p, NULL, + p->aux->attach_btf_id,
kernel/bpf/cgroup.c static int __cgroup_bpf_attach(struct cgroup *cgrp, · line 516
Quoted 10 lines
kernel/bpf/cgroup.c +10
-0+ &tgt_info); +if (err) +return -EINVAL ; + + atype =bpf_lsm_attach_type_get (p->aux->attach_btf_id); +if (atype <0 ) +return atype; + } + + p->aux->cgroup_atype = atype;
hmm.... not sure about this assignment for the replace_prog case. In particular, the attaching prog's cgroup_atype can be decided by the replace_prog's cgroup_atype? Was there some checks before to ensure the replace_prog and the attaching prog have the same attach_btf_id?
Quoted 94 lines
kernel/bpf/cgroup.c +43
-7+ }else { + atype =to_cgroup_bpf_attach_type (type); +if (atype <0 ) +return -EINVAL ; + } progs = &cgrp->bpf.progs[atype];@@ -503,13 +564,27 @@ static int __cgroup_bpf_attach(struct cgroup *cgrp,if (err) goto cleanup; +bpf_cgroup_storages_link (new_storage, cgrp, type); + +if (type ==BPF_LSM_CGROUP && !old_prog) { +struct bpf_prog *p = prog ? : link->link.prog; +int err; + + err =bpf_trampoline_link_cgroup_shim (p, &tgt_info); +if (err) + goto cleanup_trampoline; + } +if (old_prog)bpf_prog_put (old_prog);else static_branch_inc (&cgroup_bpf_enabled_key[atype]); -bpf_cgroup_storages_link (new_storage, cgrp, type); +return 0 ; +cleanup_trampoline: +bpf_cgroup_storages_unlink (new_storage); + cleanup:if (old_prog) { pl->prog = old_prog;@@ -601,9 +676,13 @@ static int __cgroup_bpf_replace(struct cgroup *cgrp,struct list_head *progs;bool found = false; - atype =to_cgroup_bpf_attach_type (link->type); -if (atype <0 ) -return -EINVAL ; +if (link->type ==BPF_LSM_CGROUP ) { + atype = link->link.prog->aux->cgroup_atype; + }else { + atype =to_cgroup_bpf_attach_type (link->type); +if (atype <0 ) +return -EINVAL ; + } progs = &cgrp->bpf.progs[atype];@@ -619,6 +698,9 @@ static int __cgroup_bpf_replace(struct cgroup *cgrp,if (!found)return -ENOENT ; +if (link->type ==BPF_LSM_CGROUP ) + new_prog->aux->cgroup_atype = atype; + old_prog =xchg (&link->link.prog, new_prog);replace_effective_prog (cgrp, atype, link);bpf_prog_put (old_prog);@@ -702,9 +784,15 @@ static int __cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog,u32 flags;int err; - atype =to_cgroup_bpf_attach_type (type); -if (atype <0 ) -return -EINVAL ; +if (type ==BPF_LSM_CGROUP ) { +struct bpf_prog *p = prog ? : link->link.prog; + + atype = p->aux->cgroup_atype; + }else { + atype =to_cgroup_bpf_attach_type (type); +if (atype <0 ) +return -EINVAL ; + } progs = &cgrp->bpf.progs[atype]; flags = cgrp->bpf.flags[atype];@@ -726,6 +814,10 @@ static int __cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog,if (err) goto cleanup; +if (type ==BPF_LSM_CGROUP ) +bpf_cgroup_lsm_shim_release (prog ? : link->link.prog, + atype); +/* now can actually delete it from this cgroup list */ list_del (&pl->node);kfree (pl);
[ ... ]
Quoted 14 lines
kernel/bpf/trampoline.c +2
-0@@ -11,6 +11,8 @@#include <linux/rcupdate_wait.h> #include <linux/module.h> #include <linux/static_call.h> +#include <linux/bpf_verifier.h> +#include <linux/bpf_lsm.h> /* dummy _ops. The verifier will operate on target program's ops. */ const struct bpf_verifier_ops bpf_extension_verifier_ops = {
kernel/bpf/trampoline.c static enum bpf_tramp_prog_type bpf_attach_type_to_tramp(struct bpf_prog *prog) · line 399
Quoted 4 lines
kernel/bpf/trampoline.c +1
-0@@ -394,6 +396,7 @@ static enum bpf_tramp_prog_type bpf_attach_type_to_tramp(struct bpf_prog *prog)return BPF_TRAMP_MODIFY_RETURN ;case BPF_TRACE_FEXIT :return BPF_TRAMP_FEXIT ; +case BPF_LSM_CGROUP :
Considering BPF_LSM_CGROUP is added here and the 'prog' for the case concerning here is the shim_prog ... (more below)
Quoted 16 lines
kernel/bpf/trampoline.c +9
-0case BPF_LSM_MAC :if (!prog->aux->attach_func_proto->type)/* The function returns void, we cannot modify its @@ -485,6 +488,147 @@ int bpf_trampoline_unlink_prog(struct bpf_prog *prog, struct bpf_trampoline *tr)return err; } +static struct bpf_prog *cgroup_shim_alloc (const struct bpf_prog *prog, +bpf_func_t bpf_func) +{ +struct bpf_prog *p; + + p =bpf_prog_alloc (1 ,0 ); +if (!p) +return NULL ; +
kernel/bpf/trampoline.c int bpf_trampoline_unlink_prog(struct bpf_prog *prog, struct bpf_trampoline *tr) · line 509
Quoted 10 lines
kernel/bpf/trampoline.c +10
-0+ p->jited = false; + p->bpf_func = bpf_func; + + p->aux->cgroup_atype = prog->aux->cgroup_atype; + p->aux->attach_func_proto = prog->aux->attach_func_proto; + p->aux->attach_btf_id = prog->aux->attach_btf_id; + p->aux->attach_btf = prog->aux->attach_btf; +btf_get (p->aux->attach_btf); + p->type =BPF_PROG_TYPE_LSM ; + p->expected_attach_type =BPF_LSM_MAC ;
... should this be BPF_LSM_CGROUP instead ?
or the above 'case BPF_LSM_CGROUP:' addition is not needed ?
kernel/bpf/trampoline.c int bpf_trampoline_unlink_prog(struct bpf_prog *prog, struct bpf_trampoline *tr) · line 521
Quoted 12 lines
kernel/bpf/trampoline.c +12
-0+bpf_prog_inc (p); + +return p; +} + +static struct bpf_prog *cgroup_shim_find (struct bpf_trampoline *tr, +bpf_func_t bpf_func) +{ +const struct bpf_prog_aux *aux; +int kind; + +for (kind =0 ; kind <BPF_TRAMP_MAX ; kind++) {
Can bpf_attach_type_to_tramp() be used here instead of looping all ?
kernel/bpf/trampoline.c int bpf_trampoline_unlink_prog(struct bpf_prog *prog, struct bpf_trampoline *tr) · line 525
Quoted 4 lines
kernel/bpf/trampoline.c +4
-0+hlist_for_each_entry (aux, &tr->progs_hlist[kind], tramp_hlist) { +struct bpf_prog *p = aux->prog; + +if (!p->jited && p->bpf_func == bpf_func)
Is the "!p->jited" test needed ?
Quoted 23 lines
kernel/bpf/trampoline.c +23
-0+return p; + } + } + +return NULL ; +} + +int bpf_trampoline_link_cgroup_shim (struct bpf_prog *prog, +struct bpf_attach_target_info *tgt_info) +{ +struct bpf_prog *shim_prog =NULL ; +struct bpf_trampoline *tr; +bpf_func_t bpf_func; +u64 key; +int err; + + key =bpf_trampoline_compute_key (NULL , prog->aux->attach_btf, + prog->aux->attach_btf_id); + + err =bpf_lsm_find_cgroup_shim (prog, &bpf_func); +if (err) +return err; +
kernel/bpf/trampoline.c int bpf_trampoline_unlink_prog(struct bpf_prog *prog, struct bpf_trampoline *tr) · line 558
Quoted 10 lines
kernel/bpf/trampoline.c +10
-0+ tr =bpf_trampoline_get (key, tgt_info); +if (!tr) +return -ENOMEM ; + +mutex_lock (&tr->mutex); + + shim_prog =cgroup_shim_find (tr, bpf_func); +if (shim_prog) { +/* Reusing existing shim attached by the other program. +*/
The shim_prog is reused by >1 BPF_LSM_CGROUP progs and shim_prog is hidden from the userspace also (no id), so it may worth to bring this up:
In __bpf_prog_enter(), other than some bpf stats of the shim_prog will become useless which is a very minor thing, it is also checking shim_prog->active and bump the misses counter. Now, the misses counter is no longer visible to users. Since it is actually running the cgroup prog, may be there is no need for the active check ?
Quoted 73 lines
kernel/bpf/trampoline.c +73
-0+bpf_prog_inc (shim_prog); +mutex_unlock (&tr->mutex); +return 0 ; + } + +/* Allocate and install new shim. +*/ + + shim_prog =cgroup_shim_alloc (prog, bpf_func); +if (!shim_prog) { + err = -ENOMEM ; + goto out; + } + + err =__bpf_trampoline_link_prog (shim_prog, tr); +if (err) + goto out; + +mutex_unlock (&tr->mutex); + +return 0 ; +out: +if (shim_prog) +bpf_prog_put (shim_prog); + +mutex_unlock (&tr->mutex); +return err; +} + +void bpf_trampoline_unlink_cgroup_shim (struct bpf_prog *prog) +{ +struct bpf_prog *shim_prog; +struct bpf_trampoline *tr; +bpf_func_t bpf_func; +u64 key; +int err; + + key =bpf_trampoline_compute_key (NULL , prog->aux->attach_btf, + prog->aux->attach_btf_id); + + err =bpf_lsm_find_cgroup_shim (prog, &bpf_func); +if (err) +return ; + + tr =bpf_trampoline_lookup (key); +if (!tr) +return ; + +mutex_lock (&tr->mutex); + + shim_prog =cgroup_shim_find (tr, bpf_func); +if (shim_prog) { +/* We use shim_prog refcnt for tracking whether to +* remove the shim program from the trampoline. +* Trampoline's mutex is held while refcnt is +* added/subtracted so we don't need to care about +* potential races. +*/ + +if (atomic64_read (&shim_prog->aux->refcnt) ==1 ) +WARN_ON_ONCE (__bpf_trampoline_unlink_prog (shim_prog, tr)); + +bpf_prog_put (shim_prog); + } + +mutex_unlock (&tr->mutex); + +bpf_trampoline_put (tr);/* bpf_trampoline_lookup */ + +if (shim_prog) +bpf_trampoline_put (tr); +} +
Re: [PATCH bpf-next v3 2/7] bpf: per-cgroup lsm flavor
": , wi
Quoted 26 lines · Martin KaFai Lau
Quoted 12 lines · Stanislav Fomichev
kernel/bpf/bpf_lsm.c +4
-0@@ -35,6 +35,98 @@ BTF_SET_START(bpf_lsm_hooks)#undef LSM_HOOKBTF_SET_END (bpf_lsm_hooks) +static unsigned int __cgroup_bpf_run_lsm_socket(const void *ctx, +const struct bpf_insn *insn) +{ +const struct bpf_prog *prog;kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 51
Quoted 10 lines
kernel/bpf/bpf_lsm.c +10
-0+struct socket *sock; +struct cgroup *cgrp; +struct sock *sk; +int ret =0 ; +u64 *regs; + + regs = (u64 *)ctx; + sock = (void *)(unsigned long )regs[BPF_REG_0 ]; +/*prog = container_of(insn, struct bpf_prog, insnsi);*/ + prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi));nit. Rename prog to
shim_prog.
Quoted 4 lines
kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 53
Quoted 2 lines
kernel/bpf/bpf_lsm.c +2
-0+ +if (unlikely (!sock))Is it possible in the lsm hooks? Can these hooks
be rejected at the load time instead?
Doesn't seem like it can be null, at least from the quick review that I had; I'll take a deeper look.
I guess in general I wanted to be more defensive here because there are 200+ hooks, the new ones might arrive, and it's better to have the check?
Quoted 45 lines
kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 57
Quoted 4 lines
kernel/bpf/bpf_lsm.c +4
-0+return 0 ; + + sk = sock->sk; +if (unlikely (!sk))Same here.
Quoted 11 lines
kernel/bpf/bpf_lsm.c +11
-0+return 0 ; + + cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data); +if (likely (cgrp)) + ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], + ctx, bpf_prog_run,0 ); +return ret; +} + +static unsigned int __cgroup_bpf_run_lsm_current (const void *ctx, +const struct bpf_insn *insn)kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 78
Quoted 10 lines
kernel/bpf/bpf_lsm.c +10
-0+{ +const struct bpf_prog *prog; +struct cgroup *cgrp; +int ret =0 ; + +if (unlikely (!current)) +return 0 ; + +/*prog = container_of(insn, struct bpf_prog, insnsi);*/ + prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi));nit.
shim_proghere also.Quoted 16 lines
kernel/bpf/bpf_lsm.c +16
-0+ +rcu_read_lock (); + cgrp =task_dfl_cgroup (current); +if (likely (cgrp)) + ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], + ctx, bpf_prog_run,0 ); +rcu_read_unlock (); +return ret; +} + +int bpf_lsm_find_cgroup_shim (const struct bpf_prog *prog, +bpf_func_t *bpf_func) +{ +const struct btf_type *first_arg_type; +const struct btf_type *sock_type; +const struct btf *btf_vmlinux;
Quoted 8 lines
kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 99
Quoted 5 lines
kernel/bpf/bpf_lsm.c +5
-0+const struct btf_param *args; +s32 type_id; + +if (!prog->aux->attach_func_proto || + !btf_type_is_func_proto (prog->aux->attach_func_proto))Are these cases possible at the attaching time or they have already been rejected at the load time? If it is the latter, these tests can be removed.
I think you're right, should be rejected at loading time, I'll check.
Quoted 6 lines
kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 102
Quoted 3 lines
kernel/bpf/bpf_lsm.c +3
-0+return -EINVAL ; + +if (btf_type_vlen (prog->aux->attach_func_proto) <1 )Is it consistent with the existing
BPF_LSM_MAC? or is there something special aboutBPF_LSM_CGROUPthat it cannot support this func ?
Looks like there is a lsm hook that doesn't take any arguments, so yeah, it's inconsistent, I'll have to fix that, thanks!
Quoted 152 lines
kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 105
Quoted 3 lines
kernel/bpf/bpf_lsm.c +3
-0+return -EINVAL ; + + args = (const struct btf_param *)(prog->aux->attach_func_proto +1 );nit.
args = btf_params(prog->aux->attach_func_proto);Quoted 105 lines
kernel/bpf/bpf_lsm.c +24
-0+ + btf_vmlinux =bpf_get_btf_vmlinux (); +if (!btf_vmlinux) +return -EINVAL ; + + type_id =btf_find_by_name_kind (btf_vmlinux,"socket" ,BTF_KIND_STRUCT ); +if (type_id <0 ) +return -EINVAL ; + sock_type =btf_type_by_id (btf_vmlinux, type_id); + + first_arg_type =btf_type_resolve_ptr (btf_vmlinux, args[0 ].type,NULL ); +if (first_arg_type == sock_type) + *bpf_func = __cgroup_bpf_run_lsm_socket; +else + *bpf_func = __cgroup_bpf_run_lsm_current; + +return 0 ; +} + +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 +11
-0@@ -4971,6 +4971,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 @@ -6396,6 +6397,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 +23
-0@@ -14,6 +14,9 @@#include <linux/string.h> #include <linux/bpf.h> #include <linux/bpf-cgroup.h> +#include <linux/btf_ids.h> +#include <linux/bpf_lsm.h> +#include <linux/bpf_verifier.h> #include <net/sock.h> #include <net/bpf_sk_storage.h> @@ -22,6 +25,18 @@DEFINE_STATIC_KEY_ARRAY_FALSE (cgroup_bpf_enabled_key,MAX_CGROUP_BPF_ATTACH_TYPE );EXPORT_SYMBOL (cgroup_bpf_enabled_key); +#ifdef CONFIG_BPF_LSM +static enum cgroup_bpf_attach_type bpf_lsm_attach_type_get (u32 attach_btf_id) +{ +return CGROUP_LSM_START +bpf_lsm_hook_idx (attach_btf_id); +} +#else +static enum cgroup_bpf_attach_type bpf_lsm_attach_type_get (u32 attach_btf_id) +{ +return -EOPNOTSUPP ; +} +#endif +void cgroup_bpf_offline (struct cgroup *cgrp) {cgroup_get (cgrp);@@ -89,6 +104,14 @@ static void bpf_cgroup_storages_link(struct bpf_cgroup_storage *storages[],bpf_cgroup_storage_link (storages[stype], cgrp, attach_type); } +static void bpf_cgroup_storages_unlink (struct bpf_cgroup_storage *storages[]) +{ +enum bpf_cgroup_storage_type stype; + +for_each_cgroup_storage_type (stype) +bpf_cgroup_storage_unlink (storages[stype]); +} +/* Called when bpf_cgroup_link is auto-detached from dying cgroup. * It drops cgroup and bpf_prog refcounts, and marks bpf_link as defunct. It * doesn't free link memory, which will eventually be done by bpf_link's kernel/bpf/cgroup.c static void bpf_cgroup_link_auto_detach(struct bpf_cgroup_link *link) · line 129
Quoted 7 lines
kernel/bpf/cgroup.c +4
-0@@ -100,6 +123,15 @@ static void bpf_cgroup_link_auto_detach(struct bpf_cgroup_link *link) link->cgroup =NULL ; } +static void bpf_cgroup_lsm_shim_release (struct bpf_prog *prog, +enum cgroup_bpf_attach_type atype) +{ +if (!prog || atype != prog->aux->cgroup_atype)prog cannot be NULL here, no?
The 'atype !=
prog->aux->cgroup_atype' looks suspicious also consideringprog->aux->cgroup_atypeis only initialized (and meaningful) forBPF_LSM_CGROUP. I suspect incorrectly passing this test will crash in the belowbpf_trampoline_unlink_cgroup_shim(). More on this later.kernel/bpf/cgroup.c static void cgroup_bpf_release(struct work_struct *work)
Quoted 9 lines
kernel/bpf/cgroup.c +5
-0+return ; + +bpf_trampoline_unlink_cgroup_shim (prog); +} +/** * cgroup_bpf_release() - put references of all bpf programs and * release all cgroup bpf data @@ -123,10 +155,16 @@ static void cgroup_bpf_release(struct work_struct *work)Copying some missing loop context here:
for (atype = 0; atype < ARRAY_SIZE(cgrp->bpf.progs); atype++) { struct list_head *progs = &cgrp->bpf.progs[atype]; struct bpf_prog_list *pl, *pltmp;kernel/bpf/cgroup.c static void cgroup_bpf_release(struct work_struct *work) · line 160
Quoted 7 lines
kernel/bpf/cgroup.c +3
-1list_for_each_entry_safe (pl, pltmp, progs, node) {list_del (&pl->node); -if (pl->prog) +if (pl->prog) { +bpf_cgroup_lsm_shim_release (pl->prog, + atype);atype could be 0 (
CGROUP_INET_INGRESS) here.bpf_cgroup_lsm_shim_release()above will go ahead withbpf_trampoline_unlink_cgroup_shim(). It will break some of the assumptions. e.g.prog->aux->attach_btfis NULL forCGROUP_INET_INGRESS.
Quoted 5 lines
Instead, only call
bpf_cgroup_lsm_shim_release()forBPF_LSM_CGROUP?If the above observation is sane, I wonder if the existing
test_progshave uncovered it or may be the existing tests just always detach cleanly itself before cleaning the cgroup which then avoided this case.
Might be what's happening here:
https://github.com/kernel-patches/bpf/runs/5876983908?check_suite_focus=true
Although, I'm not sure why it's z15 only. Good point on filtering by BPF_LSM_CGROUP, will do.
Quoted 43 lines
Quoted 43 lines
kernel/bpf/cgroup.c +23
-4bpf_prog_put (pl->prog); -if (pl->link) + } +if (pl->link) { +bpf_cgroup_lsm_shim_release (pl->link->link.prog, + atype);bpf_cgroup_link_auto_detach (pl->link); + }kfree (pl);static_branch_dec (&cgroup_bpf_enabled_key[atype]); }@@ -439,6 +477,7 @@ static int __cgroup_bpf_attach(struct cgroup *cgrp,struct bpf_prog *old_prog =NULL ;struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE ] = {};struct bpf_cgroup_storage *new_storage[MAX_BPF_CGROUP_STORAGE_TYPE ] = {}; +struct bpf_attach_target_info tgt_info = {};enum cgroup_bpf_attach_type atype;struct bpf_prog_list *pl;struct list_head *progs;@@ -455,9 +494,31 @@ static int __cgroup_bpf_attach(struct cgroup *cgrp,/* replace_prog implies BPF_F_REPLACE, and vice versa */ return -EINVAL ; - atype =to_cgroup_bpf_attach_type (type); -if (atype <0 ) -return -EINVAL ; +if (type ==BPF_LSM_CGROUP ) { +struct bpf_prog *p = prog ? : link->link.prog; + +if (replace_prog) { +/* Reusing shim from the original program. +*/ + atype = replace_prog->aux->cgroup_atype; + }else { + err =bpf_check_attach_target (NULL , p,NULL , + p->aux->attach_btf_id, + &tgt_info); +if (err) +return -EINVAL ; + + atype =bpf_lsm_attach_type_get (p->aux->attach_btf_id); +if (atype <0 ) +return atype;
Quoted 8 lines
kernel/bpf/cgroup.c static int __cgroup_bpf_attach(struct cgroup *cgrp, · line 516
Quoted 3 lines
kernel/bpf/cgroup.c +3
-0+ } + + p->aux->cgroup_atype = atype;hmm.... not sure about this assignment for the
replace_progcase. In particular, the attaching prog'scgroup_atypecan be decided by the replace_prog'scgroup_atype? Was there some checks before to ensure thereplace_progand the attaching prog have the sameattach_btf_id?
I was assuming that yes, there should be some checks to confirm we are replacing the prog with the same type. Will verify.
Quoted 146 lines
Quoted 94 lines
kernel/bpf/cgroup.c +43
-7+ }else { + atype =to_cgroup_bpf_attach_type (type); +if (atype <0 ) +return -EINVAL ; + } progs = &cgrp->bpf.progs[atype];@@ -503,13 +564,27 @@ static int __cgroup_bpf_attach(struct cgroup *cgrp,if (err) goto cleanup; +bpf_cgroup_storages_link (new_storage, cgrp, type); + +if (type ==BPF_LSM_CGROUP && !old_prog) { +struct bpf_prog *p = prog ? : link->link.prog; +int err; + + err =bpf_trampoline_link_cgroup_shim (p, &tgt_info); +if (err) + goto cleanup_trampoline; + } +if (old_prog)bpf_prog_put (old_prog);else static_branch_inc (&cgroup_bpf_enabled_key[atype]); -bpf_cgroup_storages_link (new_storage, cgrp, type); +return 0 ; +cleanup_trampoline: +bpf_cgroup_storages_unlink (new_storage); + cleanup:if (old_prog) { pl->prog = old_prog;@@ -601,9 +676,13 @@ static int __cgroup_bpf_replace(struct cgroup *cgrp,struct list_head *progs;bool found = false; - atype =to_cgroup_bpf_attach_type (link->type); -if (atype <0 ) -return -EINVAL ; +if (link->type ==BPF_LSM_CGROUP ) { + atype = link->link.prog->aux->cgroup_atype; + }else { + atype =to_cgroup_bpf_attach_type (link->type); +if (atype <0 ) +return -EINVAL ; + } progs = &cgrp->bpf.progs[atype];@@ -619,6 +698,9 @@ static int __cgroup_bpf_replace(struct cgroup *cgrp,if (!found)return -ENOENT ; +if (link->type ==BPF_LSM_CGROUP ) + new_prog->aux->cgroup_atype = atype; + old_prog =xchg (&link->link.prog, new_prog);replace_effective_prog (cgrp, atype, link);bpf_prog_put (old_prog);@@ -702,9 +784,15 @@ static int __cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog,u32 flags;int err; - atype =to_cgroup_bpf_attach_type (type); -if (atype <0 ) -return -EINVAL ; +if (type ==BPF_LSM_CGROUP ) { +struct bpf_prog *p = prog ? : link->link.prog; + + atype = p->aux->cgroup_atype; + }else { + atype =to_cgroup_bpf_attach_type (type); +if (atype <0 ) +return -EINVAL ; + } progs = &cgrp->bpf.progs[atype]; flags = cgrp->bpf.flags[atype];@@ -726,6 +814,10 @@ static int __cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog,if (err) goto cleanup; +if (type ==BPF_LSM_CGROUP ) +bpf_cgroup_lsm_shim_release (prog ? : link->link.prog, + atype); +/* now can actually delete it from this cgroup list */ list_del (&pl->node);kfree (pl);[ ... ]
Quoted 14 lines
kernel/bpf/trampoline.c +2
-0@@ -11,6 +11,8 @@#include <linux/rcupdate_wait.h> #include <linux/module.h> #include <linux/static_call.h> +#include <linux/bpf_verifier.h> +#include <linux/bpf_lsm.h> /* dummy _ops. The verifier will operate on target program's ops. */ const struct bpf_verifier_ops bpf_extension_verifier_ops = {kernel/bpf/trampoline.c static enum bpf_tramp_prog_type bpf_attach_type_to_tramp(struct bpf_prog *prog) · line 399
Quoted 4 lines
kernel/bpf/trampoline.c +1
-0@@ -394,6 +396,7 @@ static enum bpf_tramp_prog_type bpf_attach_type_to_tramp(struct bpf_prog *prog)return BPF_TRAMP_MODIFY_RETURN ;case BPF_TRACE_FEXIT :return BPF_TRAMP_FEXIT ; +case BPF_LSM_CGROUP :Considering
BPF_LSM_CGROUPis added here and the 'prog' for the case concerning here is theshim_prog... (more below)Quoted 16 lines
kernel/bpf/trampoline.c +9
-0case BPF_LSM_MAC :if (!prog->aux->attach_func_proto->type)/* The function returns void, we cannot modify its @@ -485,6 +488,147 @@ int bpf_trampoline_unlink_prog(struct bpf_prog *prog, struct bpf_trampoline *tr)return err; } +static struct bpf_prog *cgroup_shim_alloc (const struct bpf_prog *prog, +bpf_func_t bpf_func) +{ +struct bpf_prog *p; + + p =bpf_prog_alloc (1 ,0 ); +if (!p) +return NULL ; +kernel/bpf/trampoline.c int bpf_trampoline_unlink_prog(struct bpf_prog *prog, struct bpf_trampoline *tr) · line 509
Quoted 10 lines
kernel/bpf/trampoline.c +10
-0+ p->jited = false; + p->bpf_func = bpf_func; + + p->aux->cgroup_atype = prog->aux->cgroup_atype; + p->aux->attach_func_proto = prog->aux->attach_func_proto; + p->aux->attach_btf_id = prog->aux->attach_btf_id; + p->aux->attach_btf = prog->aux->attach_btf; +btf_get (p->aux->attach_btf); + p->type =BPF_PROG_TYPE_LSM ; + p->expected_attach_type =BPF_LSM_MAC ;... should this be
BPF_LSM_CGROUPinstead ?
Quoted 1 line
or the above 'case
BPF_LSM_CGROUP:' addition is not needed ?
Yeah, not needed, will remove.
Quoted 6 lines
Quoted 6 lines
kernel/bpf/trampoline.c +6
-0+bpf_prog_inc (p); + +return p; +} + +static struct bpf_prog *cgroup_shim_find(struct bpf_trampoline *tr,
Quoted 8 lines
kernel/bpf/trampoline.c int bpf_trampoline_unlink_prog(struct bpf_prog *prog, struct bpf_trampoline *tr) · line 521
Quoted 6 lines
kernel/bpf/trampoline.c +6
-0+ bpf_func_t bpf_func) +{ +const struct bpf_prog_aux *aux; +int kind; + +for (kind =0 ; kind <BPF_TRAMP_MAX ; kind++) {Can
bpf_attach_type_to_tramp()be used here instead of looping all ?
Seems like it needs a bpf_prog as an argument, so it's easier to loop?
Quoted 5 lines
kernel/bpf/trampoline.c int bpf_trampoline_unlink_prog(struct bpf_prog *prog, struct bpf_trampoline *tr) · line 525
Quoted 4 lines
kernel/bpf/trampoline.c +4
-0+hlist_for_each_entry (aux, &tr->progs_hlist[kind], tramp_hlist) { +struct bpf_prog *p = aux->prog; + +if (!p->jited && p->bpf_func == bpf_func)Is the "!p->jited" test needed ?
Not really, will drop.
Quoted 37 lines
Quoted 23 lines
kernel/bpf/trampoline.c +23
-0+return p; + } + } + +return NULL ; +} + +int bpf_trampoline_link_cgroup_shim (struct bpf_prog *prog, +struct bpf_attach_target_info *tgt_info) +{ +struct bpf_prog *shim_prog =NULL ; +struct bpf_trampoline *tr; +bpf_func_t bpf_func; +u64 key; +int err; + + key =bpf_trampoline_compute_key (NULL , prog->aux->attach_btf, + prog->aux->attach_btf_id); + + err =bpf_lsm_find_cgroup_shim (prog, &bpf_func); +if (err) +return err; +kernel/bpf/trampoline.c int bpf_trampoline_unlink_prog(struct bpf_prog *prog, struct bpf_trampoline *tr) · line 558
Quoted 10 lines
kernel/bpf/trampoline.c +10
-0+ tr =bpf_trampoline_get (key, tgt_info); +if (!tr) +return -ENOMEM ; + +mutex_lock (&tr->mutex); + + shim_prog =cgroup_shim_find (tr, bpf_func); +if (shim_prog) { +/* Reusing existing shim attached by the other program. +*/ The
shim_progis reused by >1BPF_LSM_CGROUPprogs andshim_progis hidden from the userspace also (no id), so it may worth to bring this up:
Quoted 5 lines
In
__bpf_prog_enter(), other than some bpf stats of theshim_progwill become useless which is a very minor thing, it is also checkingshim_prog->activeand bump the misses counter. Now, the misses counter is no longer visible to users. Since it is actually running the cgroup prog, may be there is no need for the active check ?
Agree that the active counter will probably be taken care of when the actual program runs; but now sure it worth the effort in trying to remove it here?
Regarding "no longer visible to users": that's a good point. Should I actually add those shim progs to the prog_idr? Or just hide it as "internal implementation detail"?
Thank you for the review!
Quoted 73 lines
Quoted 73 lines
kernel/bpf/trampoline.c +73
-0+bpf_prog_inc (shim_prog); +mutex_unlock (&tr->mutex); +return 0 ; + } + +/* Allocate and install new shim. +*/ + + shim_prog =cgroup_shim_alloc (prog, bpf_func); +if (!shim_prog) { + err = -ENOMEM ; + goto out; + } + + err =__bpf_trampoline_link_prog (shim_prog, tr); +if (err) + goto out; + +mutex_unlock (&tr->mutex); + +return 0 ; +out: +if (shim_prog) +bpf_prog_put (shim_prog); + +mutex_unlock (&tr->mutex); +return err; +} + +void bpf_trampoline_unlink_cgroup_shim (struct bpf_prog *prog) +{ +struct bpf_prog *shim_prog; +struct bpf_trampoline *tr; +bpf_func_t bpf_func; +u64 key; +int err; + + key =bpf_trampoline_compute_key (NULL , prog->aux->attach_btf, + prog->aux->attach_btf_id); + + err =bpf_lsm_find_cgroup_shim (prog, &bpf_func); +if (err) +return ; + + tr =bpf_trampoline_lookup (key); +if (!tr) +return ; + +mutex_lock (&tr->mutex); + + shim_prog =cgroup_shim_find (tr, bpf_func); +if (shim_prog) { +/* We use shim_prog refcnt for tracking whether to +* remove the shim program from the trampoline. +* Trampoline's mutex is held while refcnt is +* added/subtracted so we don't need to care about +* potential races. +*/ + +if (atomic64_read (&shim_prog->aux->refcnt) ==1 ) +WARN_ON_ONCE (__bpf_trampoline_unlink_prog (shim_prog, tr)); + +bpf_prog_put (shim_prog); + } + +mutex_unlock (&tr->mutex); + +bpf_trampoline_put (tr);/* bpf_trampoline_lookup */ + +if (shim_prog) +bpf_trampoline_put (tr); +} +
Re: [PATCH bpf-next v3 2/7] bpf: per-cgroup lsm flavor
Quoted 33 lines · Stanislav Fomichev
": , wi
Quoted 28 lines · Martin KaFai Lau
Quoted 12 lines · Stanislav Fomichev
kernel/bpf/bpf_lsm.c +4
-0@@ -35,6 +35,98 @@ BTF_SET_START(bpf_lsm_hooks)#undef LSM_HOOKBTF_SET_END (bpf_lsm_hooks) +static unsigned int __cgroup_bpf_run_lsm_socket(const void *ctx, +const struct bpf_insn *insn) +{ +const struct bpf_prog *prog;kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 51
Quoted 10 lines
kernel/bpf/bpf_lsm.c +10
-0+struct socket *sock; +struct cgroup *cgrp; +struct sock *sk; +int ret =0 ; +u64 *regs; + + regs = (u64 *)ctx; + sock = (void *)(unsigned long )regs[BPF_REG_0 ]; +/*prog = container_of(insn, struct bpf_prog, insnsi);*/ + prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi));nit. Rename prog to
shim_prog.Quoted 2 lines
kernel/bpf/bpf_lsm.c +2
-0+ +if (unlikely (!sock))
Quoted 8 lines
Quoted 2 lines
Is it possible in the lsm hooks? Can these hooks
be rejected at the load time instead?Doesn't seem like it can be null, at least from the quick review that I had; I'll take a deeper look.
I guess in general I wanted to be more defensive here because there are 200+ hooks, the new ones might arrive, and it's better to have the check?
not too worried about an extra runtime check for now.
Instead, have a concern that it will be a usage surprise when a successfully attached bpf program is then always silently ignored.
Another question, for example, the inet_conn_request lsm_hook:
LSM_HOOK(int, 0, inet_conn_request, const struct sock *sk, struct sk_buff *skb,
struct request_sock *req)
'struct sock *sk' is the first argument, so it will use the current's cgroup. inet_conn_request() is likely run in a softirq though and then it will be incorrect. This runs in softirq case may not be limited to hooks that take sk/sock argument also, not sure.
Quoted 10 lines
Quoted 10 lines
kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 57
Quoted 4 lines
kernel/bpf/bpf_lsm.c +4
-0+return 0 ; + + sk = sock->sk; +if (unlikely (!sk))Same here.
Quoted 4 lines
kernel/bpf/bpf_lsm.c +4
-0+return 0 ; + + cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data); +if (likely (cgrp))
unrelated, but while talking extra check,
I think the shim_prog has already acted as a higher level (per attach-btf_id) knob but do you think it may still worth to do a bpf_empty_prog_array check here in case a cgroup may not have prog to run ?
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
kernel/bpf/bpf_lsm.c +2
-0+ ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], + ctx, bpf_prog_run,0 );
[ ... ]
Quoted 44 lines
Quoted 44 lines
kernel/bpf/bpf_lsm.c static void bpf_cgroup_link_auto_detach(struct bpf_cgroup_link *link) · line 129
Quoted 8 lines
kernel/bpf/bpf_lsm.c +4
-0@@ -100,6 +123,15 @@ static void bpf_cgroup_link_auto_detach(struct bpf_cgroup_link *link) link->cgroup =NULL ; } +static void bpf_cgroup_lsm_shim_release (struct bpf_prog *prog, +enum cgroup_bpf_attach_type atype) +{ +if (!prog || atype != prog->aux->cgroup_atype)prog cannot be NULL here, no?
The 'atype !=
prog->aux->cgroup_atype' looks suspicious also consideringprog->aux->cgroup_atypeis only initialized (and meaningful) forBPF_LSM_CGROUP. I suspect incorrectly passing this test will crash in the belowbpf_trampoline_unlink_cgroup_shim(). More on this later.kernel/bpf/bpf_lsm.c static void cgroup_bpf_release(struct work_struct *work)
Quoted 9 lines
kernel/bpf/bpf_lsm.c +5
-0+return ; + +bpf_trampoline_unlink_cgroup_shim (prog); +} +/** * cgroup_bpf_release() - put references of all bpf programs and * release all cgroup bpf data @@ -123,10 +155,16 @@ static void cgroup_bpf_release(struct work_struct *work)Copying some missing loop context here:
for (atype = 0; atype < ARRAY_SIZE(cgrp->bpf.progs); atype++) { struct list_head *progs = &cgrp->bpf.progs[atype]; struct bpf_prog_list *pl, *pltmp;kernel/bpf/bpf_lsm.c static void cgroup_bpf_release(struct work_struct *work) · line 159
Quoted 7 lines
kernel/bpf/bpf_lsm.c +3
-1list_for_each_entry_safe (pl, pltmp, progs, node) {list_del (&pl->node); -if (pl->prog) +if (pl->prog) { +bpf_cgroup_lsm_shim_release (pl->prog, + atype);atype could be 0 (
CGROUP_INET_INGRESS) here.bpf_cgroup_lsm_shim_release()above will go ahead withbpf_trampoline_unlink_cgroup_shim(). It will break some of the assumptions. e.g.prog->aux->attach_btfis NULL forCGROUP_INET_INGRESS.Instead, only call
bpf_cgroup_lsm_shim_release()forBPF_LSM_CGROUP?
Quoted 7 lines
Quoted 3 lines
If the above observation is sane, I wonder if the existing
test_progshave uncovered it or may be the existing tests just always detach cleanly itself before cleaning the cgroup which then avoided this case.Might be what's happening here:
https://github.com/kernel-patches/bpf/runs/5876983908?check_suite_focus=true
hmm.... this one looks different. I am thinking the oops should happen in bpf_obj_id() which is not inlined. didn't ring any bell for now after a quick look, so yeah let's fix the known first.
Quoted 15 lines
Although, I'm not sure why it's z15 only. Good point on filtering by
BPF_LSM_CGROUP, will do.Quoted 11 lines
Quoted 11 lines
kernel/bpf/bpf_lsm.c +5
-1bpf_prog_put (pl->prog); -if (pl->link) + } +if (pl->link) { +bpf_cgroup_lsm_shim_release (pl->link->link.prog, + atype);bpf_cgroup_link_auto_detach (pl->link); + }kfree (pl);static_branch_dec (&cgroup_bpf_enabled_key[atype]); }
[ ... ]
Quoted 30 lines
Quoted 30 lines
Quoted 16 lines
kernel/bpf/bpf_lsm.c +16
-0+int bpf_trampoline_link_cgroup_shim (struct bpf_prog *prog, +struct bpf_attach_target_info *tgt_info) +{ +struct bpf_prog *shim_prog =NULL ; +struct bpf_trampoline *tr; +bpf_func_t bpf_func; +u64 key; +int err; + + key =bpf_trampoline_compute_key (NULL , prog->aux->attach_btf, + prog->aux->attach_btf_id); + + err =bpf_lsm_find_cgroup_shim (prog, &bpf_func); +if (err) +return err; +kernel/bpf/bpf_lsm.c
Quoted 10 lines
kernel/bpf/bpf_lsm.c +10
-0+ tr =bpf_trampoline_get (key, tgt_info); +if (!tr) +return -ENOMEM ; + +mutex_lock (&tr->mutex); + + shim_prog =cgroup_shim_find (tr, bpf_func); +if (shim_prog) { +/* Reusing existing shim attached by the other program. +*/ The
shim_progis reused by >1BPF_LSM_CGROUPprogs andshim_progis hidden from the userspace also (no id), so it may worth to bring this up:
Quoted 8 lines
Quoted 5 lines
In
__bpf_prog_enter(), other than some bpf stats of theshim_progwill become useless which is a very minor thing, it is also checkingshim_prog->activeand bump the misses counter. Now, the misses counter is no longer visible to users. Since it is actually running the cgroup prog, may be there is no need for the active check ?Agree that the active counter will probably be taken care of when the actual program runs;
iirc, the BPF_PROG_RUN_ARRAY_CG does not need the active counter.
Quoted 2 lines
but now sure it worth the effort in trying to
remove it here?
I was thinking if the active counter got triggered and missed calling the BPF_LSM_CGROUP, then there is no way to tell this case got hit without exposing the stats of the shim_prog and it could be a pretty hard problem to chase. It probably won't be an issue for non-sleepable now if the rcu_read_lock() maps to preempt_disable(). Not sure about the future sleepable case.
I am thinking to avoid doing all the active count and stats count in __bpf_prog_enter() and __bpf_prog_exit() for BPF_LSM_CGROUP. afaik, only the rcu_read_lock and rcu_read_unlock are useful to protect the shim_prog itself. May be a __bpf_nostats_enter() and __bpf_nostats_exit().
Quoted 3 lines
Regarding "no longer visible to users": that's a good point. Should I actually add those shim progs to the
prog_idr? Or just hide it as "internal implementation detail"?
Then no need to expose the shim_progs to the idr.
~~~~
[ btw, while thinking the shim_prog, I also think there is no need for one
shim_prog for each attach_btf_id which is essentially prog->aux->cgroup_atype. The static prog->aux->cgroup_atype can be passed in the stack when preparing the trampoline.
just an idea and not suggesting must be done now. This can be optimized later since it does not affect the API. ]
Re: [PATCH bpf-next v3 2/7] bpf: per-cgroup lsm flavor
Quoted 44 lines · Martin KaFai Lau
Quoted 29 lines · Stanislav Fomichev
Quoted 28 lines · Martin KaFai Lau
Quoted 12 lines · Stanislav Fomichev
kernel/bpf/bpf_lsm.c +4
-0@@ -35,6 +35,98 @@ BTF_SET_START(bpf_lsm_hooks)#undef LSM_HOOKBTF_SET_END (bpf_lsm_hooks) +static unsigned int __cgroup_bpf_run_lsm_socket(const void *ctx, +const struct bpf_insn *insn) +{ +const struct bpf_prog *prog;kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 51
Quoted 10 lines
kernel/bpf/bpf_lsm.c +10
-0+struct socket *sock; +struct cgroup *cgrp; +struct sock *sk; +int ret =0 ; +u64 *regs; + + regs = (u64 *)ctx; + sock = (void *)(unsigned long )regs[BPF_REG_0 ]; +/*prog = container_of(insn, struct bpf_prog, insnsi);*/ + prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi));nit. Rename prog to
shim_prog.Quoted 2 lines
kernel/bpf/bpf_lsm.c +2
-0+ +if (unlikely (!sock))Quoted 8 lines
Quoted 2 lines
Is it possible in the lsm hooks? Can these hooks
be rejected at the load time instead?Doesn't seem like it can be null, at least from the quick review that I had; I'll take a deeper look.
I guess in general I wanted to be more defensive here because there are 200+ hooks, the new ones might arrive, and it's better to have the check?not too worried about an extra runtime check for now.
Instead, have a concern that it will be a usage surprise when a successfully attached bpf program is then always silently ignored.
Quoted 8 lines
Another question, for example, the
inet_conn_requestlsm_hook:
LSM_HOOK(int, 0,inet_conn_request, const struct sock *sk, structsk_buff*skb,
structrequest_sock*req)'struct sock *sk' is the first argument, so it will use the current's cgroup.
inet_conn_request()is likely run in a softirq though and then it will be incorrect. This runs in softirq case may not be limited to hooks that take sk/sock argument also, not sure.
For now, I decided not to treat 'struct sock' cases as 'socket' because of cases like sk_alloc_security where 'struct sock' is not initialized. Looks like treating them as 'current' is also not 100% foolproof. I guess we'd still have to have some special cases/exceptions. Let me bring back that 'struct sock' handler and add some btf-set to treat other non-inet_conn_request as the exception for now.
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
kernel/bpf/bpf_lsm.c BTF_SET_START(bpf_lsm_hooks) · line 57
Quoted 4 lines
kernel/bpf/bpf_lsm.c +4
-0+return 0 ; + + sk = sock->sk; +if (unlikely (!sk))Same here.
Quoted 4 lines
kernel/bpf/bpf_lsm.c +4
-0+return 0 ; + + cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data); +if (likely (cgrp))
Quoted 5 lines
unrelated, but while talking extra check,
I think the
shim_proghas already acted as a higher level (per attach-btf_id) knob but do you think it may still worth to do abpf_empty_prog_arraycheck here in case a cgroup may not have prog to run ?
Oh yeah, good idea, let me add those cgroup_bpf_sock_enabled.
Quoted 127 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
kernel/bpf/bpf_lsm.c +2
-0+ ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], + ctx, bpf_prog_run,0 );[ ... ]
Quoted 44 lines
Quoted 44 lines
kernel/bpf/bpf_lsm.c static void bpf_cgroup_link_auto_detach(struct bpf_cgroup_link *link) · line 129
Quoted 8 lines
kernel/bpf/bpf_lsm.c +4
-0@@ -100,6 +123,15 @@ static void bpf_cgroup_link_auto_detach(struct bpf_cgroup_link *link) link->cgroup =NULL ; } +static void bpf_cgroup_lsm_shim_release (struct bpf_prog *prog, +enum cgroup_bpf_attach_type atype) +{ +if (!prog || atype != prog->aux->cgroup_atype)prog cannot be NULL here, no?
The 'atype !=
prog->aux->cgroup_atype' looks suspicious also consideringprog->aux->cgroup_atypeis only initialized (and meaningful) forBPF_LSM_CGROUP. I suspect incorrectly passing this test will crash in the belowbpf_trampoline_unlink_cgroup_shim(). More on this later.kernel/bpf/bpf_lsm.c static void cgroup_bpf_release(struct work_struct *work)
Quoted 9 lines
kernel/bpf/bpf_lsm.c +5
-0+return ; + +bpf_trampoline_unlink_cgroup_shim (prog); +} +/** * cgroup_bpf_release() - put references of all bpf programs and * release all cgroup bpf data @@ -123,10 +155,16 @@ static void cgroup_bpf_release(struct work_struct *work)Copying some missing loop context here:
for (atype = 0; atype < ARRAY_SIZE(cgrp->bpf.progs); atype++) { struct list_head *progs = &cgrp->bpf.progs[atype]; struct bpf_prog_list *pl, *pltmp;kernel/bpf/bpf_lsm.c static void cgroup_bpf_release(struct work_struct *work) · line 159
Quoted 7 lines
kernel/bpf/bpf_lsm.c +3
-1list_for_each_entry_safe (pl, pltmp, progs, node) {list_del (&pl->node); -if (pl->prog) +if (pl->prog) { +bpf_cgroup_lsm_shim_release (pl->prog, + atype);atype could be 0 (
CGROUP_INET_INGRESS) here.bpf_cgroup_lsm_shim_release()above will go ahead withbpf_trampoline_unlink_cgroup_shim(). It will break some of the assumptions. e.g.prog->aux->attach_btfis NULL forCGROUP_INET_INGRESS.Instead, only call
bpf_cgroup_lsm_shim_release()forBPF_LSM_CGROUP?Quoted 7 lines
Quoted 3 lines
If the above observation is sane, I wonder if the existing
test_progshave uncovered it or may be the existing tests just always detach cleanly itself before cleaning the cgroup which then avoided this case.Might be what's happening here:
https://github.com/kernel-patches/bpf/runs/5876983908?check_suite_focus=true
hmm.... this one looks different. I am thinking the oops should happen in
bpf_obj_id()which is not inlined. didn't ring any bell for now after a quick look, so yeah let's fix the known first.Quoted 15 lines
Although, I'm not sure why it's z15 only. Good point on filtering by
BPF_LSM_CGROUP, will do.Quoted 11 lines
Quoted 11 lines
kernel/bpf/bpf_lsm.c +5
-1bpf_prog_put (pl->prog); -if (pl->link) + } +if (pl->link) { +bpf_cgroup_lsm_shim_release (pl->link->link.prog, + atype);bpf_cgroup_link_auto_detach (pl->link); + }kfree (pl);static_branch_dec (&cgroup_bpf_enabled_key[atype]); }[ ... ]
Quoted 30 lines
Quoted 30 lines
Quoted 16 lines
kernel/bpf/bpf_lsm.c +16
-0+int bpf_trampoline_link_cgroup_shim (struct bpf_prog *prog, +struct bpf_attach_target_info *tgt_info) +{ +struct bpf_prog *shim_prog =NULL ; +struct bpf_trampoline *tr; +bpf_func_t bpf_func; +u64 key; +int err; + + key =bpf_trampoline_compute_key (NULL , prog->aux->attach_btf, + prog->aux->attach_btf_id); + + err =bpf_lsm_find_cgroup_shim (prog, &bpf_func); +if (err) +return err; +kernel/bpf/bpf_lsm.c
Quoted 10 lines
kernel/bpf/bpf_lsm.c +10
-0+ tr =bpf_trampoline_get (key, tgt_info); +if (!tr) +return -ENOMEM ; + +mutex_lock (&tr->mutex); + + shim_prog =cgroup_shim_find (tr, bpf_func); +if (shim_prog) { +/* Reusing existing shim attached by the other program. +*/ The
shim_progis reused by >1BPF_LSM_CGROUPprogs andshim_progis hidden from the userspace also (no id), so it may worth to bring this up:Quoted 8 lines
Quoted 5 lines
In
__bpf_prog_enter(), other than some bpf stats of theshim_progwill become useless which is a very minor thing, it is also checkingshim_prog->activeand bump the misses counter. Now, the misses counter is no longer visible to users. Since it is actually running the cgroup prog, may be there is no need for the active check ?Agree that the active counter will probably be taken care of when the actual program runs;
iirc, the
BPF_PROG_RUN_ARRAY_CGdoes not need the active counter.Quoted 2 lines
but now sure it worth the effort in trying to
remove it here?I was thinking if the active counter got triggered and missed calling the
BPF_LSM_CGROUP, then there is no way to tell this case got hit without exposing the stats of theshim_progand it could be a pretty hard problem to chase. It probably won't be an issue for non-sleepable now if thercu_read_lock()maps topreempt_disable(). Not sure about the future sleepable case.
Quoted 5 lines
I am thinking to avoid doing all the active count and stats count in
__bpf_prog_enter()and__bpf_prog_exit()forBPF_LSM_CGROUP. afaik, only thercu_read_lockandrcu_read_unlockare useful to protect theshim_progitself. May be a__bpf_nostats_enter()and__bpf_nostats_exit().
SG, let me try to skip that for BPF_LSM_CGROUP case.
Quoted 5 lines
Quoted 3 lines
Regarding "no longer visible to users": that's a good point. Should I actually add those shim progs to the
prog_idr? Or just hide it as "internal implementation detail"?Then no need to expose the
shim_progsto the idr.
Quoted 7 lines
~~~~
[ btw, while thinking theshim_prog, I also think there is no need for one
shim_progfor eachattach_btf_idwhich is essentiallyprog->aux->cgroup_atype. The staticprog->aux->cgroup_atypecan be passed in the stack when preparing the trampoline.
just an idea and not suggesting must be done now. This can be optimized later since it does not affect the API. ]
Ack, I guess in theory, there needs to be only two "global" shim_progs, one for 'struct socket' and another for 'current' (or more, for other types). I went with allocating an instance per trampoline to avoid having that global state. Working under tr->mutex simplifies things a bit imo, but, as you said, we can optimize here if needed.
PATCH v3 3/7 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. This still adds some bloat to the cgroup and brings us back to roughly pre-cgroup_bpf_attach_type times.
It should be possible to eventually extend this idea to all hooks if the memory consumption is unacceptable and shrink overall effective programs array.
--- include/linux/bpf-cgroup-defs.h | 4 +- include/linux/bpf_lsm.h | 6 --- kernel/bpf/bpf_lsm.c | 9 ++-- kernel/bpf/cgroup.c | 96 ++++++++++++++++++++++++++++----- 4 files changed, 90 insertions(+), 25 deletions(-)
include/linux/bpf-cgroup-defs.h +3 -1
@@ -10,7 +10,9 @@struct bpf_prog_array ; -#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 10enum cgroup_bpf_attach_type {CGROUP_BPF_ATTACH_TYPE_INVALID =-1 ,
include/linux/bpf_lsm.h +0 -6
@@ -43,7 +43,6 @@ extern const struct bpf_func_proto bpf_inode_storage_delete_proto;void bpf_inode_storage_free (struct inode *inode);int bpf_lsm_find_cgroup_shim (const struct bpf_prog *prog,bpf_func_t *bpf_func); -int bpf_lsm_hook_idx (u32 btf_id);#else /* !CONFIG_BPF_LSM */
@@ -74,11 +73,6 @@ static inline int bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,return -ENOENT ; } -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 +3 -6
@@ -57,10 +57,12 @@ static unsigned int __cgroup_bpf_run_lsm_socket(const void *ctx,if (unlikely (!sk))return 0 ; +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data);if (likely (cgrp)) ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], ctx, bpf_prog_run,0 ); +rcu_read_unlock ();return ret; }
@@ -77,7 +79,7 @@ static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx,/*prog = container_of(insn, struct bpf_prog, insnsi);*/ prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi)); -rcu_read_lock (); +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ cgrp =task_dfl_cgroup (current);if (likely (cgrp)) ret = BPF_PROG_RUN_ARRAY_CG(cgrp->bpf.effective[prog->aux->cgroup_atype],
@@ -122,11 +124,6 @@ int bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,return 0 ; } -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/cgroup.c +84 -12
145 lines not on this page · raw message
Signature · 1 line
2.35.1.1178.g4f1659d476-goog
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
Quoted 24 lines · Stanislav Fomichev
Previous patch adds 1:1 mapping between all 211 LSM hooks and
bpf_cgroupprogram 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. This still adds some bloat to the cgroup and brings us back to roughly pre-cgroup_bpf_attach_type times.It should be possible to eventually extend this idea to all hooks if the memory consumption is unacceptable and shrink overall effective programs array.
Signed-off-by Stanislav Fomichev <[email protected]>--- include/linux/bpf-cgroup-defs.h | 4 +- include/linux/bpf_lsm.h | 6 --- kernel/bpf/bpf_lsm.c | 9 ++-- kernel/bpf/cgroup.c | 96 ++++++++++++++++++++++++++++----- 4 files changed, 90 insertions(+), 25 deletions(-)include/linux/bpf-cgroup-defs.h +0
-0
include/linux/bpf-cgroup-defs.h line 15
Quoted 7 lines
include/linux/bpf-cgroup-defs.h +3
-1@@ -10,7 +10,9 @@struct bpf_prog_array ; -#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
hmm...only 10 different lsm hooks (or 10 different attach_btf_ids) can have BPF_LSM_CGROUP programs attached. This feels quite limited but having a static 211 (and potentially growing in the future) is not good either. I currently do not have a better idea also. :/
Have you thought about other dynamic schemes or they would be too slow ?
Quoted 44 lines
include/linux/bpf-cgroup-defs.h +0
-0enum cgroup_bpf_attach_type {CGROUP_BPF_ATTACH_TYPE_INVALID =-1 ,include/linux/bpf_lsm.h +0
-6@@ -43,7 +43,6 @@ extern const struct bpf_func_proto bpf_inode_storage_delete_proto;void bpf_inode_storage_free (struct inode *inode);int bpf_lsm_find_cgroup_shim (const struct bpf_prog *prog,bpf_func_t *bpf_func); -int bpf_lsm_hook_idx (u32 btf_id);#else /* !CONFIG_BPF_LSM */ @@ -74,11 +73,6 @@ static inline int bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,return -ENOENT ; } -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 +2
-0@@ -57,10 +57,12 @@ static unsigned int __cgroup_bpf_run_lsm_socket(const void *ctx,if (unlikely (!sk))return 0 ; +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data);if (likely (cgrp)) ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], ctx, bpf_prog_run,0 ); +rcu_read_unlock ();return ret; }
kernel/bpf/bpf_lsm.c static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx, · line 82
Quoted 5 lines
kernel/bpf/bpf_lsm.c +1
-1@@ -77,7 +79,7 @@ static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx,/*prog = container_of(insn, struct bpf_prog, insnsi);*/ prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi)); -rcu_read_lock (); +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */
I think this is also needed for task_dfl_cgroup(). If yes, will be a good idea to adjust the comment if it ends up using the 'CGROUP_LSM_NUM 10' scheme.
While at rcu_read_lock(), have you thought about what major things are needed to make BPF_LSM_CGROUP sleepable ?
The cgroup local storage could be one that require changes but it seems the cgroup local storage is not available to BPF_LSM_GROUP in this change set. The current use case doesn't need it?
Quoted 15 lines
kernel/bpf/bpf_lsm.c +0
-5cgrp =task_dfl_cgroup (current);if (likely (cgrp)) ret = BPF_PROG_RUN_ARRAY_CG(cgrp->bpf.effective[prog->aux->cgroup_atype],@@ -122,11 +124,6 @@ int bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,return 0 ; } -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) {
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
Quoted 37 lines · Martin KaFai Lau
Quoted 24 lines · Stanislav Fomichev
Previous patch adds 1:1 mapping between all 211 LSM hooks and
bpf_cgroupprogram 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. This still adds some bloat to the cgroup and brings us back to roughly pre-cgroup_bpf_attach_type times.It should be possible to eventually extend this idea to all hooks if the memory consumption is unacceptable and shrink overall effective programs array.
Signed-off-by Stanislav Fomichev <[email protected]>--- include/linux/bpf-cgroup-defs.h | 4 +- include/linux/bpf_lsm.h | 6 --- kernel/bpf/bpf_lsm.c | 9 ++-- kernel/bpf/cgroup.c | 96 ++++++++++++++++++++++++++++----- 4 files changed, 90 insertions(+), 25 deletions(-)include/linux/bpf-cgroup-defs.h +0
-0include/linux/bpf-cgroup-defs.h line 15
Quoted 7 lines
include/linux/bpf-cgroup-defs.h +3
-1@@ -10,7 +10,9 @@struct bpf_prog_array ; -#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 10hmm...only 10 different lsm hooks (or 10 different
attach_btf_ids) can haveBPF_LSM_CGROUPprograms attached. This feels quite limited but having a static 211 (and potentially growing in the future) is not good either. I currently do not have a better idea also. :/
Quoted 1 line
Have you thought about other dynamic schemes or they would be too slow ?
As long as we're talking ideas - how about a 2-level lookup?
L1: 0..255 -> { 0..31, -1 }, where -1 is inactive cgroup_bp_attach_type
L2: 0..31 -> struct bpf_prog_array * for cgroup->bpf.effective[],
struct hlist_head [^1] for cgroup->bpf.progs[],
u32 for cgroup->bpf.flags[],This way we could have 32 distinct _active_ attachment types for each cgroup instance, to be shared among regular cgroup attach types and BPF LSM attach types.
It is 9 extra slots in comparison to today, so if anyone has cgroups that make use of all available attach types at the same time, we don't break their setup.
The L1 lookup table would still a few slots for new cgroup [^2] or LSM hooks:
256 - 23 (cgroup attach types) - 211 (LSM hooks) = 22
Memory bloat:
+256 B - L1 lookup table
+ 72 B - extra effective[] slots
+ 72 B - extra progs[] slots
+ 36 B - extra flags[] slots
-184 B - savings from switching to hlist_head
------
+252 B per cgroup instance
Total cgroup_bpf{} size change - 720 B -> 968 B.
WDYT?
[^1] It looks like we can easily switch from cgroup->bpf.progs[] from
list_head to hlist_head and save some bytes!
We only access the list tail in __cgroup_bpf_attach(). We can either iterate over the list and eat the cost there or push the new prog onto the front.
I think we treat cgroup->bpf.progs[] everywhere like an unordered set. Except for __cgroup_bpf_query, where the user might notice the order change in the BPF_PROG_QUERY dump.
[^2] Unrelated, but we would like to propose a
CGROUP_INET[46]_POST_CONNECT hook in the near future to make it easier to bind UDP sockets to 4-tuple without creating conflicts:
https://github.com/cloudflare/cloudflare-blog/tree/master/2022-02-connectx/ebpf_connect4
[...]
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
Quoted 71 lines · Jakub Sitnicki
Quoted 37 lines · Martin KaFai Lau
Quoted 24 lines · Stanislav Fomichev
Previous patch adds 1:1 mapping between all 211 LSM hooks and
bpf_cgroupprogram 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. This still adds some bloat to the cgroup and brings us back to roughly pre-cgroup_bpf_attach_type times.It should be possible to eventually extend this idea to all hooks if the memory consumption is unacceptable and shrink overall effective programs array.
Signed-off-by Stanislav Fomichev <[email protected]>--- include/linux/bpf-cgroup-defs.h | 4 +- include/linux/bpf_lsm.h | 6 --- kernel/bpf/bpf_lsm.c | 9 ++-- kernel/bpf/cgroup.c | 96 ++++++++++++++++++++++++++++----- 4 files changed, 90 insertions(+), 25 deletions(-)include/linux/bpf-cgroup-defs.h +0
-0include/linux/bpf-cgroup-defs.h line 15
Quoted 7 lines
include/linux/bpf-cgroup-defs.h +3
-1@@ -10,7 +10,9 @@struct bpf_prog_array ; -#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 10hmm...only 10 different lsm hooks (or 10 different
attach_btf_ids) can haveBPF_LSM_CGROUPprograms attached. This feels quite limited but having a static 211 (and potentially growing in the future) is not good either. I currently do not have a better idea also. :/Quoted 1 line
Have you thought about other dynamic schemes or they would be too slow ?
As long as we're talking ideas - how about a 2-level lookup?
L1: 0..255 -> { 0..31, -1 }, where -1 is inactive
cgroup_bp_attach_type
L2: 0..31 -> structbpf_prog_array* for cgroup->bpf.effective[],struct hlist_head [^1] for cgroup->bpf.progs[], u32 for cgroup->bpf.flags[],This way we could have 32 distinct _active_ attachment types for each cgroup instance, to be shared among regular cgroup attach types and BPF LSM attach types.
It is 9 extra slots in comparison to today, so if anyone has cgroups that make use of all available attach types at the same time, we don't break their setup.
The L1 lookup table would still a few slots for new cgroup [^2] or LSM hooks:
256 - 23 (cgroup attach types) - 211 (LSM hooks) = 22
Memory bloat:
+256 B - L1 lookup table
+ 72 B - extra effective[] slots
+ 72 B - extra progs[] slots
+ 36 B - extra flags[] slots
-184 B - savings from switching tohlist_head
------
+252 B per cgroup instance
Quoted 3 lines
Total cgroup_bpf{} size change - 720 B -> 968 B.
WDYT?
Sounds workable, thanks! Let me try and see how it goes. I guess we don't even have to increase the size of the effective array with this mode,;having 23 unique slots per cgroup seems like a good start? So the cgroup_bpf{} growth would be +256B L1 (technically, we only need 5 bits per entry, so can shrink to 160B) -185B for hlist_head
Quoted 10 lines
[^1] It looks like we can easily switch from cgroup->bpf.progs[] from
list_headtohlist_headand save some bytes!We only access the list tail in
__cgroup_bpf_attach(). We can either iterate over the list and eat the cost there or push the new prog onto the front.I think we treat cgroup->bpf.progs[] everywhere like an unordered set. Except for
__cgroup_bpf_query, where the user might notice the order change in theBPF_PROG_QUERYdump.
[...]
Quoted 5 lines
[^2] Unrelated, but we would like to propose a
CGROUP_INET[46]_POST_CONNECT hook in the near future to make it easier to bind UDP sockets to 4-tuple without creating conflicts:https://github.com/cloudflare/cloudflare-blog/tree/master/2022-02-connectx/ebpf_connect4
Do you think those new lsm hooks can be used instead? If not, what's missing?
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
Quoted 1 line · Stanislav Fomichev
On Sat, Apr 9, 2022 at 11:10 AM Jakub Sitnicki <[email protected]> wrote:
[...]
Quoted 14 lines
Quoted 10 lines
[^1] It looks like we can easily switch from cgroup->bpf.progs[] from
list_headtohlist_headand save some bytes!We only access the list tail in
__cgroup_bpf_attach(). We can either iterate over the list and eat the cost there or push the new prog onto the front.I think we treat cgroup->bpf.progs[] everywhere like an unordered set. Except for
__cgroup_bpf_query, where the user might notice the order change in theBPF_PROG_QUERYdump.[...]
Quoted 7 lines
Quoted 5 lines
[^2] Unrelated, but we would like to propose a
CGROUP_INET[46]_POST_CONNECT hook in the near future to make it easier to bind UDP sockets to 4-tuple without creating conflicts:https://github.com/cloudflare/cloudflare-blog/tree/master/2022-02-connectx/ebpf_connect4
Do you think those new lsm hooks can be used instead? If not, what's missing?
Same as for CGROUP_INET hooks, there is no post-connect() LSM hook.
Why are we looking for a post-connect hook?
Having a pre- and a post- connect hook, would allow us to turn the whole connect() syscall into a critical section with synchronization done in BPF - lock on pre-connect, unlock on post-connect.
Why do we want to serialize connect() calls?
To check for 4-tuple conflict with an existing unicast UDP socket, in which case we want fail connect() if there is a conflict.
That said, ideally we would rather have a mechanism like IP_BIND_ADDRESS_NO_PORT, but for UDP, and one that allows selecting both an local IP and port.
We're hoping to put together an RFC sometime this quarter.
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
Quoted 24 lines · Jakub Sitnicki
Quoted 1 line · Stanislav Fomichev
On Sat, Apr 9, 2022 at 11:10 AM Jakub Sitnicki <[email protected]> wrote:
[...]
Quoted 18 lines
Quoted 10 lines
[^1] It looks like we can easily switch from cgroup->bpf.progs[] from
list_headtohlist_headand save some bytes!We only access the list tail in
__cgroup_bpf_attach(). We can either iterate over the list and eat the cost there or push the new prog onto the front.I think we treat cgroup->bpf.progs[] everywhere like an unordered set. Except for
__cgroup_bpf_query, where the user might notice the order change in theBPF_PROG_QUERYdump.[...]
Quoted 4 lines
[^2] Unrelated, but we would like to propose a
CGROUP_INET[46]_POST_CONNECT hook in the near future to make it easier to bind UDP sockets to 4-tuple without creating conflicts:
Quoted 5 lines
Quoted 3 lines
Quoted 1 line
https://github.com/cloudflare/cloudflare-blog/tree/master/2022-02-connectx/ebpf_connect4
Do you think those new lsm hooks can be used instead? If not, what's missing?
Same as for
CGROUP_INEThooks, there is no post-connect() LSM hook.
There is inet_conn_established, but looks like it triggers only for tcp. Selinux is the only user, so I'm assuming we should be able to extend it as needed?
I'm not sure how far we can go with adding custom hooks :-( So moving to fentry/lsm seems like the way to go. Maybe we should follow up with a per-cgroup fentry as well :-D
Quoted 16 lines
Why are we looking for a post-connect hook?
Having a pre- and a post- connect hook, would allow us to turn the whole
connect()syscall into a critical section with synchronization done in BPF - lock on pre-connect, unlock on post-connect.Why do we want to serialize
connect()calls?To check for 4-tuple conflict with an existing unicast UDP socket, in which case we want fail
connect()if there is a conflict.That said, ideally we would rather have a mechanism like
IP_BIND_ADDRESS_NO_PORT, but for UDP, and one that allows selecting both an local IP and port.We're hoping to put together an RFC sometime this quarter.
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
In reply to Jakub SitnickiQuoted 34 lines · Jakub Sitnicki
Quoted 17 lines
include/linux/bpf-cgroup-defs.h line 15
Quoted 12 lines
include/linux/bpf-cgroup-defs.h +3
-1@@ -10,7 +10,9 @@struct bpf_prog_array ; -#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 10hmm...only 10 different lsm hooks (or 10 different
attach_btf_ids) can haveBPF_LSM_CGROUPprograms attached. This feels quite limited but having a static 211 (and potentially growing in the future) is not good either. I currently do not have a better idea also. :/Quoted 1 line
Have you thought about other dynamic schemes or they would be too slow ?
As long as we're talking ideas - how about a 2-level lookup?
L1: 0..255 -> { 0..31, -1 }, where -1 is inactive
cgroup_bp_attach_type
L2: 0..31 -> structbpf_prog_array* for cgroup->bpf.effective[],struct hlist_head [^1] for cgroup->bpf.progs[], u32 for cgroup->bpf.flags[],This way we could have 32 distinct _active_ attachment types for each cgroup instance, to be shared among regular cgroup attach types and BPF LSM attach types.
It is 9 extra slots in comparison to today, so if anyone has cgroups that make use of all available attach types at the same time, we don't break their setup.
Quoted 8 lines
The L1 lookup table would still a few slots for new cgroup [^2] or LSM hooks:
256 - 23 (cgroup attach types) - 211 (LSM hooks) = 22
Memory bloat:
+256 B - L1 lookup table
Does L1 need to be per cgroup ?
or different cgroups usually have a very different active(/effective) set ?
Quoted 29 lines
+ 72 B - extra effective[] slots
+ 72 B - extra progs[] slots
+ 36 B - extra flags[] slots
-184 B - savings from switching tohlist_head
------
+252 B per cgroup instanceTotal cgroup_bpf{} size change - 720 B -> 968 B.
WDYT?
[^1] It looks like we can easily switch from cgroup->bpf.progs[] from
list_headtohlist_headand save some bytes!We only access the list tail in
__cgroup_bpf_attach(). We can either iterate over the list and eat the cost there or push the new prog onto the front.I think we treat cgroup->bpf.progs[] everywhere like an unordered set. Except for
__cgroup_bpf_query, where the user might notice the order change in theBPF_PROG_QUERYdump.[^2] Unrelated, but we would like to propose a
CGROUP_INET[46]_POST_CONNECT hook in the near future to make it easier to bind UDP sockets to 4-tuple without creating conflicts:https://github.com/cloudflare/cloudflare-blog/tree/master/2022-02-connectx/ebpf_connect4
[...]
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
Quoted 39 lines · Martin KaFai Lau
Quoted 37 lines · Jakub Sitnicki
Quoted 17 lines
include/linux/bpf-cgroup-defs.h line 15
Quoted 12 lines
include/linux/bpf-cgroup-defs.h +3
-1@@ -10,7 +10,9 @@struct bpf_prog_array ; -#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 10hmm...only 10 different lsm hooks (or 10 different
attach_btf_ids) can haveBPF_LSM_CGROUPprograms attached. This feels quite limited but having a static 211 (and potentially growing in the future) is not good either. I currently do not have a better idea also. :/Quoted 1 line
Have you thought about other dynamic schemes or they would be too slow ?
As long as we're talking ideas - how about a 2-level lookup?
L1: 0..255 -> { 0..31, -1 }, where -1 is inactive
cgroup_bp_attach_type
L2: 0..31 -> structbpf_prog_array* for cgroup->bpf.effective[],struct hlist_head [^1] for cgroup->bpf.progs[], u32 for cgroup->bpf.flags[],This way we could have 32 distinct _active_ attachment types for each cgroup instance, to be shared among regular cgroup attach types and BPF LSM attach types.
It is 9 extra slots in comparison to today, so if anyone has cgroups that make use of all available attach types at the same time, we don't break their setup.
The L1 lookup table would still a few slots for new cgroup [^2] or LSM hooks:
Quoted 8 lines
Quoted 5 lines
256 - 23 (cgroup attach types) - 211 (LSM hooks) = 22
Memory bloat:
+256 B - L1 lookup table
Does L1 need to be per cgroup ?
or different cgroups usually have a very different active(/effective) set ?
I'm assuming the suggestion is to have it per cgroup. Otherwise, if it's global, it's close to whatever I'm proposing in the original patch. As I mentioned in the commit message, in theory, all cgroup_bpf can be managed the way I propose to manage 10 lsm slots if we get to the point where 10 slots is not enough.
I've played with this mode a bit and it looks a bit complicated :-( Since it's per cgroup, we have to be careful to preserve this mapping during cgroup_bpf_inherit.
I'll see what I can do, but I'll most likely revert to my initial version for now (I'll also include list_head->hlist_head conversion patch, very nice idea).
Quoted 29 lines
Quoted 29 lines
+ 72 B - extra effective[] slots
+ 72 B - extra progs[] slots
+ 36 B - extra flags[] slots
-184 B - savings from switching tohlist_head
------
+252 B per cgroup instanceTotal cgroup_bpf{} size change - 720 B -> 968 B.
WDYT?
[^1] It looks like we can easily switch from cgroup->bpf.progs[] from
list_headtohlist_headand save some bytes!We only access the list tail in
__cgroup_bpf_attach(). We can either iterate over the list and eat the cost there or push the new prog onto the front.I think we treat cgroup->bpf.progs[] everywhere like an unordered set. Except for
__cgroup_bpf_query, where the user might notice the order change in theBPF_PROG_QUERYdump.[^2] Unrelated, but we would like to propose a
CGROUP_INET[46]_POST_CONNECT hook in the near future to make it easier to bind UDP sockets to 4-tuple without creating conflicts:https://github.com/cloudflare/cloudflare-blog/tree/master/2022-02-connectx/ebpf_connect4
[...]
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
Quoted 47 lines · Stanislav Fomichev
Quoted 46 lines · Martin KaFai Lau
Quoted 34 lines · Jakub Sitnicki
Quoted 17 lines
include/linux/bpf-cgroup-defs.h line 15
Quoted 12 lines
include/linux/bpf-cgroup-defs.h +3
-1@@ -10,7 +10,9 @@struct bpf_prog_array ; -#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 10hmm...only 10 different lsm hooks (or 10 different
attach_btf_ids) can haveBPF_LSM_CGROUPprograms attached. This feels quite limited but having a static 211 (and potentially growing in the future) is not good either. I currently do not have a better idea also. :/Quoted 1 line
Have you thought about other dynamic schemes or they would be too slow ?
As long as we're talking ideas - how about a 2-level lookup?
L1: 0..255 -> { 0..31, -1 }, where -1 is inactive
cgroup_bp_attach_type
L2: 0..31 -> structbpf_prog_array* for cgroup->bpf.effective[],struct hlist_head [^1] for cgroup->bpf.progs[], u32 for cgroup->bpf.flags[],This way we could have 32 distinct _active_ attachment types for each cgroup instance, to be shared among regular cgroup attach types and BPF LSM attach types.
It is 9 extra slots in comparison to today, so if anyone has cgroups that make use of all available attach types at the same time, we don't break their setup.
Quoted 8 lines
The L1 lookup table would still a few slots for new cgroup [^2] or LSM hooks:
256 - 23 (cgroup attach types) - 211 (LSM hooks) = 22
Memory bloat:
+256 B - L1 lookup table
Does L1 need to be per cgroup ?
Quoted 7 lines
Quoted 1 line
or different cgroups usually have a very different active(/effective) set ?
I'm assuming the suggestion is to have it per cgroup. Otherwise, if it's global, it's close to whatever I'm proposing in the original patch. As I mentioned in the commit message, in theory, all
cgroup_bpfcan be managed the way I propose to manage 10 lsm slots if we get to the point where 10 slots is not enough.
Ah, indeed. The global one will be similar to the original patch. I was thinking only use the spaces saved from list_head->hlist_head to get a larger progs[] instead of spending it on L1 lookup table.
Also, I think u8 should be enough for the flags[].
Quoted 6 lines
I've played with this mode a bit and it looks a bit complicated :-( Since it's per cgroup, we have to be careful to preserve this mapping during
cgroup_bpf_inherit.
I'll see what I can do, but I'll most likely revert to my initial version for now (I'll also includelist_head->hlist_headconversion patch, very nice idea).
sgtm.
Quoted 32 lines
Quoted 32 lines
Quoted 32 lines
+ 72 B - extra effective[] slots
+ 72 B - extra progs[] slots
+ 36 B - extra flags[] slots
-184 B - savings from switching tohlist_head
------
+252 B per cgroup instanceTotal cgroup_bpf{} size change - 720 B -> 968 B.
WDYT?
[^1] It looks like we can easily switch from cgroup->bpf.progs[] from
list_headtohlist_headand save some bytes!We only access the list tail in
__cgroup_bpf_attach(). We can either iterate over the list and eat the cost there or push the new prog onto the front.I think we treat cgroup->bpf.progs[] everywhere like an unordered set. Except for
__cgroup_bpf_query, where the user might notice the order change in theBPF_PROG_QUERYdump.[^2] Unrelated, but we would like to propose a
CGROUP_INET[46]_POST_CONNECT hook in the near future to make it easier to bind UDP sockets to 4-tuple without creating conflicts:https://github.com/cloudflare/cloudflare-blog/tree/master/2022-02-connectx/ebpf_connect4
[...]
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
In reply to Martin KaFai LauQuoted 93 lines · Martin KaFai Lau
Quoted 24 lines · Stanislav Fomichev
Previous patch adds 1:1 mapping between all 211 LSM hooks and
bpf_cgroupprogram 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. This still adds some bloat to the cgroup and brings us back to roughly pre-cgroup_bpf_attach_type times.It should be possible to eventually extend this idea to all hooks if the memory consumption is unacceptable and shrink overall effective programs array.
Signed-off-by Stanislav Fomichev <[email protected]>--- include/linux/bpf-cgroup-defs.h | 4 +- include/linux/bpf_lsm.h | 6 --- kernel/bpf/bpf_lsm.c | 9 ++-- kernel/bpf/cgroup.c | 96 ++++++++++++++++++++++++++++----- 4 files changed, 90 insertions(+), 25 deletions(-)include/linux/bpf-cgroup-defs.h +0
-0include/linux/bpf-cgroup-defs.h line 15
Quoted 7 lines
include/linux/bpf-cgroup-defs.h +3
-1@@ -10,7 +10,9 @@struct bpf_prog_array ; -#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 10hmm...only 10 different lsm hooks (or 10 different
attach_btf_ids) can haveBPF_LSM_CGROUPprograms attached. This feels quite limited but having a static 211 (and potentially growing in the future) is not good either. I currently do not have a better idea also. :/Have you thought about other dynamic schemes or they would be too slow ?
Quoted 44 lines
include/linux/bpf-cgroup-defs.h +0
-0enum cgroup_bpf_attach_type {CGROUP_BPF_ATTACH_TYPE_INVALID =-1 ,include/linux/bpf_lsm.h +0
-6@@ -43,7 +43,6 @@ extern const struct bpf_func_proto bpf_inode_storage_delete_proto;void bpf_inode_storage_free (struct inode *inode);int bpf_lsm_find_cgroup_shim (const struct bpf_prog *prog,bpf_func_t *bpf_func); -int bpf_lsm_hook_idx (u32 btf_id);#else /* !CONFIG_BPF_LSM */ @@ -74,11 +73,6 @@ static inline int bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,return -ENOENT ; } -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 +2
-0@@ -57,10 +57,12 @@ static unsigned int __cgroup_bpf_run_lsm_socket(const void *ctx,if (unlikely (!sk))return 0 ; +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data);if (likely (cgrp)) ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], ctx, bpf_prog_run,0 ); +rcu_read_unlock ();return ret; }kernel/bpf/bpf_lsm.c static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx, · line 82
Quoted 5 lines
kernel/bpf/bpf_lsm.c +1
-1@@ -77,7 +79,7 @@ static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx,/*prog = container_of(insn, struct bpf_prog, insnsi);*/ prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi)); -rcu_read_lock (); +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ I think this is also needed for
task_dfl_cgroup(). If yes, will be a good idea to adjust the comment if it ends up using the 'CGROUP_LSM_NUM10' scheme.
Quoted 6 lines
While at
rcu_read_lock(), have you thought about what major things are needed to makeBPF_LSM_CGROUPsleepable ?The cgroup local storage could be one that require changes but it seems the cgroup local storage is not available to
BPF_LSM_GROUPin this change set. The current use case doesn't need it?
No, I haven't thought about sleepable at all yet :-( But seems like having that rcu lock here might be problematic if we want to sleep? In this case, Jakub's suggestion seems better.
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
Quoted 97 lines · Stanislav Fomichev
Quoted 96 lines · Martin KaFai Lau
Quoted 24 lines · Stanislav Fomichev
Previous patch adds 1:1 mapping between all 211 LSM hooks and
bpf_cgroupprogram 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. This still adds some bloat to the cgroup and brings us back to roughly pre-cgroup_bpf_attach_type times.It should be possible to eventually extend this idea to all hooks if the memory consumption is unacceptable and shrink overall effective programs array.
Signed-off-by Stanislav Fomichev <[email protected]>--- include/linux/bpf-cgroup-defs.h | 4 +- include/linux/bpf_lsm.h | 6 --- kernel/bpf/bpf_lsm.c | 9 ++-- kernel/bpf/cgroup.c | 96 ++++++++++++++++++++++++++++----- 4 files changed, 90 insertions(+), 25 deletions(-)include/linux/bpf-cgroup-defs.h +0
-0include/linux/bpf-cgroup-defs.h line 15
Quoted 7 lines
include/linux/bpf-cgroup-defs.h +3
-1@@ -10,7 +10,9 @@struct bpf_prog_array ; -#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 10hmm...only 10 different lsm hooks (or 10 different
attach_btf_ids) can haveBPF_LSM_CGROUPprograms attached. This feels quite limited but having a static 211 (and potentially growing in the future) is not good either. I currently do not have a better idea also. :/Have you thought about other dynamic schemes or they would be too slow ?
Quoted 44 lines
include/linux/bpf-cgroup-defs.h +0
-0enum cgroup_bpf_attach_type {CGROUP_BPF_ATTACH_TYPE_INVALID =-1 ,include/linux/bpf_lsm.h +0
-6@@ -43,7 +43,6 @@ extern const struct bpf_func_proto bpf_inode_storage_delete_proto;void bpf_inode_storage_free (struct inode *inode);int bpf_lsm_find_cgroup_shim (const struct bpf_prog *prog,bpf_func_t *bpf_func); -int bpf_lsm_hook_idx (u32 btf_id);#else /* !CONFIG_BPF_LSM */ @@ -74,11 +73,6 @@ static inline int bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,return -ENOENT ; } -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 +2
-0@@ -57,10 +57,12 @@ static unsigned int __cgroup_bpf_run_lsm_socket(const void *ctx,if (unlikely (!sk))return 0 ; +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data);if (likely (cgrp)) ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], ctx, bpf_prog_run,0 ); +rcu_read_unlock ();return ret; }kernel/bpf/bpf_lsm.c static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx, · line 82
Quoted 5 lines
kernel/bpf/bpf_lsm.c +1
-1@@ -77,7 +79,7 @@ static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx,/*prog = container_of(insn, struct bpf_prog, insnsi);*/ prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi)); -rcu_read_lock (); +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ I think this is also needed for
task_dfl_cgroup(). If yes, will be a good idea to adjust the comment if it ends up using the 'CGROUP_LSM_NUM10' scheme.While at
rcu_read_lock(), have you thought about what major things are needed to makeBPF_LSM_CGROUPsleepable ?
Quoted 7 lines
Quoted 3 lines
The cgroup local storage could be one that require changes but it seems the cgroup local storage is not available to
BPF_LSM_GROUPin this change set. The current use case doesn't need it?No, I haven't thought about sleepable at all yet :-( But seems like having that rcu lock here might be problematic if we want to sleep? In this case, Jakub's suggestion seems better.
The new rcu_read_lock() here seems fine after some thoughts.
I was looking at the helpers in cgroup_base_func_proto() to get a sense on sleepable support. Only the bpf_get_local_storage caught my eyes for now because it uses a call_rcu to free the storage. That will be the major one to change for sleepable that I can think of for now.
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
Quoted 106 lines · Martin KaFai Lau
Quoted 97 lines · Stanislav Fomichev
Quoted 96 lines · Martin KaFai Lau
Quoted 24 lines · Stanislav Fomichev
Previous patch adds 1:1 mapping between all 211 LSM hooks and
bpf_cgroupprogram 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. This still adds some bloat to the cgroup and brings us back to roughly pre-cgroup_bpf_attach_type times.It should be possible to eventually extend this idea to all hooks if the memory consumption is unacceptable and shrink overall effective programs array.
Signed-off-by Stanislav Fomichev <[email protected]>--- include/linux/bpf-cgroup-defs.h | 4 +- include/linux/bpf_lsm.h | 6 --- kernel/bpf/bpf_lsm.c | 9 ++-- kernel/bpf/cgroup.c | 96 ++++++++++++++++++++++++++++----- 4 files changed, 90 insertions(+), 25 deletions(-)include/linux/bpf-cgroup-defs.h +0
-0include/linux/bpf-cgroup-defs.h line 15
Quoted 7 lines
include/linux/bpf-cgroup-defs.h +3
-1@@ -10,7 +10,9 @@struct bpf_prog_array ; -#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 10hmm...only 10 different lsm hooks (or 10 different
attach_btf_ids) can haveBPF_LSM_CGROUPprograms attached. This feels quite limited but having a static 211 (and potentially growing in the future) is not good either. I currently do not have a better idea also. :/Have you thought about other dynamic schemes or they would be too slow ?
Quoted 44 lines
include/linux/bpf-cgroup-defs.h +0
-0enum cgroup_bpf_attach_type {CGROUP_BPF_ATTACH_TYPE_INVALID =-1 ,include/linux/bpf_lsm.h +0
-6@@ -43,7 +43,6 @@ extern const struct bpf_func_proto bpf_inode_storage_delete_proto;void bpf_inode_storage_free (struct inode *inode);int bpf_lsm_find_cgroup_shim (const struct bpf_prog *prog,bpf_func_t *bpf_func); -int bpf_lsm_hook_idx (u32 btf_id);#else /* !CONFIG_BPF_LSM */ @@ -74,11 +73,6 @@ static inline int bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,return -ENOENT ; } -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 +2
-0@@ -57,10 +57,12 @@ static unsigned int __cgroup_bpf_run_lsm_socket(const void *ctx,if (unlikely (!sk))return 0 ; +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data);if (likely (cgrp)) ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], ctx, bpf_prog_run,0 ); +rcu_read_unlock ();return ret; }kernel/bpf/bpf_lsm.c static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx, · line 82
Quoted 5 lines
kernel/bpf/bpf_lsm.c +1
-1@@ -77,7 +79,7 @@ static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx,/*prog = container_of(insn, struct bpf_prog, insnsi);*/ prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi)); -rcu_read_lock (); +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ I think this is also needed for
task_dfl_cgroup(). If yes, will be a good idea to adjust the comment if it ends up using the 'CGROUP_LSM_NUM10' scheme.While at
rcu_read_lock(), have you thought about what major things are needed to makeBPF_LSM_CGROUPsleepable ?Quoted 7 lines
Quoted 3 lines
The cgroup local storage could be one that require changes but it seems the cgroup local storage is not available to
BPF_LSM_GROUPin this change set. The current use case doesn't need it?No, I haven't thought about sleepable at all yet :-( But seems like having that rcu lock here might be problematic if we want to sleep? In this case, Jakub's suggestion seems better.
Quoted 6 lines
The new
rcu_read_lock()here seems fine after some thoughts.I was looking at the helpers in
cgroup_base_func_proto()to get a sense on sleepable support. Only thebpf_get_local_storagecaught my eyes for now because it uses acall_rcuto free the storage. That will be the major one to change for sleepable that I can think of for now.
That rcu_read_lock should be switched over to rcu_read_lock_trace in the sleepable case I'm assuming? Are we allowed to sleep while holding rcu_read_lock_trace?
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
Quoted 109 lines · Stanislav Fomichev
Quoted 108 lines · Martin KaFai Lau
Quoted 97 lines · Stanislav Fomichev
Quoted 96 lines · Martin KaFai Lau
Quoted 24 lines · Stanislav Fomichev
Previous patch adds 1:1 mapping between all 211 LSM hooks and
bpf_cgroupprogram 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. This still adds some bloat to the cgroup and brings us back to roughly pre-cgroup_bpf_attach_type times.It should be possible to eventually extend this idea to all hooks if the memory consumption is unacceptable and shrink overall effective programs array.
Signed-off-by Stanislav Fomichev <[email protected]>--- include/linux/bpf-cgroup-defs.h | 4 +- include/linux/bpf_lsm.h | 6 --- kernel/bpf/bpf_lsm.c | 9 ++-- kernel/bpf/cgroup.c | 96 ++++++++++++++++++++++++++++----- 4 files changed, 90 insertions(+), 25 deletions(-)include/linux/bpf-cgroup-defs.h +0
-0include/linux/bpf-cgroup-defs.h line 15
Quoted 7 lines
include/linux/bpf-cgroup-defs.h +3
-1@@ -10,7 +10,9 @@struct bpf_prog_array ; -#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 10hmm...only 10 different lsm hooks (or 10 different
attach_btf_ids) can haveBPF_LSM_CGROUPprograms attached. This feels quite limited but having a static 211 (and potentially growing in the future) is not good either. I currently do not have a better idea also. :/Have you thought about other dynamic schemes or they would be too slow ?
Quoted 44 lines
include/linux/bpf-cgroup-defs.h +0
-0enum cgroup_bpf_attach_type {CGROUP_BPF_ATTACH_TYPE_INVALID =-1 ,include/linux/bpf_lsm.h +0
-6@@ -43,7 +43,6 @@ extern const struct bpf_func_proto bpf_inode_storage_delete_proto;void bpf_inode_storage_free (struct inode *inode);int bpf_lsm_find_cgroup_shim (const struct bpf_prog *prog,bpf_func_t *bpf_func); -int bpf_lsm_hook_idx (u32 btf_id);#else /* !CONFIG_BPF_LSM */ @@ -74,11 +73,6 @@ static inline int bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,return -ENOENT ; } -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 +2
-0@@ -57,10 +57,12 @@ static unsigned int __cgroup_bpf_run_lsm_socket(const void *ctx,if (unlikely (!sk))return 0 ; +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data);if (likely (cgrp)) ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], ctx, bpf_prog_run,0 ); +rcu_read_unlock ();return ret; }kernel/bpf/bpf_lsm.c static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx, · line 82
Quoted 5 lines
kernel/bpf/bpf_lsm.c +1
-1@@ -77,7 +79,7 @@ static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx,/*prog = container_of(insn, struct bpf_prog, insnsi);*/ prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi)); -rcu_read_lock (); +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ I think this is also needed for
task_dfl_cgroup(). If yes, will be a good idea to adjust the comment if it ends up using the 'CGROUP_LSM_NUM10' scheme.While at
rcu_read_lock(), have you thought about what major things are needed to makeBPF_LSM_CGROUPsleepable ?Quoted 7 lines
Quoted 3 lines
The cgroup local storage could be one that require changes but it seems the cgroup local storage is not available to
BPF_LSM_GROUPin this change set. The current use case doesn't need it?No, I haven't thought about sleepable at all yet :-( But seems like having that rcu lock here might be problematic if we want to sleep? In this case, Jakub's suggestion seems better.
The new
rcu_read_lock()here seems fine after some thoughts.
Quoted 8 lines
Quoted 4 lines
I was looking at the helpers in
cgroup_base_func_proto()to get a sense on sleepable support. Only thebpf_get_local_storagecaught my eyes for now because it uses acall_rcuto free the storage. That will be the major one to change for sleepable that I can think of for now.That
rcu_read_lockshould be switched over torcu_read_lock_tracein the sleepable case I'm assuming? Are we allowed to sleep while holdingrcu_read_lock_trace?
Ah. right, suddenly forgot the obvious in between emails :(
In that sense, may as well remove the rcu_read_lock() here and let the trampoline to decide which one (rcu_read_lock or rcu_read_lock_trace) to call before calling the shim_prog. The __bpf_prog_enter(_sleepable) will call the right rcu_read_lock(_trace) based on the prog is sleepable or not.
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
Quoted 119 lines · Martin KaFai Lau
Quoted 109 lines · Stanislav Fomichev
Quoted 108 lines · Martin KaFai Lau
Quoted 97 lines · Stanislav Fomichev
Quoted 96 lines · Martin KaFai Lau
Quoted 24 lines · Stanislav Fomichev
Previous patch adds 1:1 mapping between all 211 LSM hooks and
bpf_cgroupprogram 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. This still adds some bloat to the cgroup and brings us back to roughly pre-cgroup_bpf_attach_type times.It should be possible to eventually extend this idea to all hooks if the memory consumption is unacceptable and shrink overall effective programs array.
Signed-off-by Stanislav Fomichev <[email protected]>--- include/linux/bpf-cgroup-defs.h | 4 +- include/linux/bpf_lsm.h | 6 --- kernel/bpf/bpf_lsm.c | 9 ++-- kernel/bpf/cgroup.c | 96 ++++++++++++++++++++++++++++----- 4 files changed, 90 insertions(+), 25 deletions(-)include/linux/bpf-cgroup-defs.h +0
-0include/linux/bpf-cgroup-defs.h line 15
Quoted 7 lines
include/linux/bpf-cgroup-defs.h +3
-1@@ -10,7 +10,9 @@struct bpf_prog_array ; -#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 10hmm...only 10 different lsm hooks (or 10 different
attach_btf_ids) can haveBPF_LSM_CGROUPprograms attached. This feels quite limited but having a static 211 (and potentially growing in the future) is not good either. I currently do not have a better idea also. :/Have you thought about other dynamic schemes or they would be too slow ?
Quoted 44 lines
include/linux/bpf-cgroup-defs.h +0
-0enum cgroup_bpf_attach_type {CGROUP_BPF_ATTACH_TYPE_INVALID =-1 ,include/linux/bpf_lsm.h +0
-6@@ -43,7 +43,6 @@ extern const struct bpf_func_proto bpf_inode_storage_delete_proto;void bpf_inode_storage_free (struct inode *inode);int bpf_lsm_find_cgroup_shim (const struct bpf_prog *prog,bpf_func_t *bpf_func); -int bpf_lsm_hook_idx (u32 btf_id);#else /* !CONFIG_BPF_LSM */ @@ -74,11 +73,6 @@ static inline int bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,return -ENOENT ; } -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 +2
-0@@ -57,10 +57,12 @@ static unsigned int __cgroup_bpf_run_lsm_socket(const void *ctx,if (unlikely (!sk))return 0 ; +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data);if (likely (cgrp)) ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], ctx, bpf_prog_run,0 ); +rcu_read_unlock ();return ret; }kernel/bpf/bpf_lsm.c static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx, · line 82
Quoted 5 lines
kernel/bpf/bpf_lsm.c +1
-1@@ -77,7 +79,7 @@ static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx,/*prog = container_of(insn, struct bpf_prog, insnsi);*/ prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi)); -rcu_read_lock (); +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ I think this is also needed for
task_dfl_cgroup(). If yes, will be a good idea to adjust the comment if it ends up using the 'CGROUP_LSM_NUM10' scheme.While at
rcu_read_lock(), have you thought about what major things are needed to makeBPF_LSM_CGROUPsleepable ?Quoted 7 lines
Quoted 3 lines
The cgroup local storage could be one that require changes but it seems the cgroup local storage is not available to
BPF_LSM_GROUPin this change set. The current use case doesn't need it?No, I haven't thought about sleepable at all yet :-( But seems like having that rcu lock here might be problematic if we want to sleep? In this case, Jakub's suggestion seems better.
The new
rcu_read_lock()here seems fine after some thoughts.Quoted 8 lines
Quoted 4 lines
I was looking at the helpers in
cgroup_base_func_proto()to get a sense on sleepable support. Only thebpf_get_local_storagecaught my eyes for now because it uses acall_rcuto free the storage. That will be the major one to change for sleepable that I can think of for now.That
rcu_read_lockshould be switched over torcu_read_lock_tracein the sleepable case I'm assuming? Are we allowed to sleep while holdingrcu_read_lock_trace?
Quoted 6 lines
Ah. right, suddenly forgot the obvious in between emails :(
In that sense, may as well remove the
rcu_read_lock()here and let the trampoline to decide which one (rcu_read_lockorrcu_read_lock_trace) to call before calling theshim_prog. The__bpf_prog_enter(_sleepable)will call the rightrcu_read_lock(_trace)based on the prog is sleepable or not.
Removing rcu_read_lock in __cgroup_bpf_run_lsm_current might be problematic because we also want to guarantee current's cgroup doesn't go away. I'm assuming things like task migrating to a new cgroup and the old one being freed can happen while we are trying to get cgroup's effective array.
I guess BPF_PROG_RUN_ARRAY_CG will also need some work before sleepable can happen (it calls rcu_read_lock unconditionally).
Also, it doesn't seem like BPF_PROG_RUN_ARRAY_CG rcu usage is correct. It receives __rcu array_rcu, takes rcu read lock and does deref. I'm assuming that array_rcu can be free'd before we even get to BPF_PROG_RUN_ARRAY_CG's rcu_read_lock? (so having rcu_read_lock around BPF_PROG_RUN_ARRAY_CG makes sense)
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
Quoted 127 lines · Stanislav Fomichev
Quoted 119 lines · Martin KaFai Lau
Quoted 109 lines · Stanislav Fomichev
Quoted 108 lines · Martin KaFai Lau
Quoted 97 lines · Stanislav Fomichev
Quoted 96 lines · Martin KaFai Lau
Quoted 24 lines · Stanislav Fomichev
Previous patch adds 1:1 mapping between all 211 LSM hooks and
bpf_cgroupprogram 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. This still adds some bloat to the cgroup and brings us back to roughly pre-cgroup_bpf_attach_type times.It should be possible to eventually extend this idea to all hooks if the memory consumption is unacceptable and shrink overall effective programs array.
Signed-off-by Stanislav Fomichev <[email protected]>--- include/linux/bpf-cgroup-defs.h | 4 +- include/linux/bpf_lsm.h | 6 --- kernel/bpf/bpf_lsm.c | 9 ++-- kernel/bpf/cgroup.c | 96 ++++++++++++++++++++++++++++----- 4 files changed, 90 insertions(+), 25 deletions(-)include/linux/bpf-cgroup-defs.h +0
-0include/linux/bpf-cgroup-defs.h line 15
Quoted 7 lines
include/linux/bpf-cgroup-defs.h +3
-1@@ -10,7 +10,9 @@struct bpf_prog_array ; -#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 10hmm...only 10 different lsm hooks (or 10 different
attach_btf_ids) can haveBPF_LSM_CGROUPprograms attached. This feels quite limited but having a static 211 (and potentially growing in the future) is not good either. I currently do not have a better idea also. :/Have you thought about other dynamic schemes or they would be too slow ?
Quoted 44 lines
include/linux/bpf-cgroup-defs.h +0
-0enum cgroup_bpf_attach_type {CGROUP_BPF_ATTACH_TYPE_INVALID =-1 ,include/linux/bpf_lsm.h +0
-6@@ -43,7 +43,6 @@ extern const struct bpf_func_proto bpf_inode_storage_delete_proto;void bpf_inode_storage_free (struct inode *inode);int bpf_lsm_find_cgroup_shim (const struct bpf_prog *prog,bpf_func_t *bpf_func); -int bpf_lsm_hook_idx (u32 btf_id);#else /* !CONFIG_BPF_LSM */ @@ -74,11 +73,6 @@ static inline int bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,return -ENOENT ; } -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 +2
-0@@ -57,10 +57,12 @@ static unsigned int __cgroup_bpf_run_lsm_socket(const void *ctx,if (unlikely (!sk))return 0 ; +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data);if (likely (cgrp)) ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], ctx, bpf_prog_run,0 ); +rcu_read_unlock ();return ret; }kernel/bpf/bpf_lsm.c static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx, · line 82
Quoted 5 lines
kernel/bpf/bpf_lsm.c +1
-1@@ -77,7 +79,7 @@ static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx,/*prog = container_of(insn, struct bpf_prog, insnsi);*/ prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi)); -rcu_read_lock (); +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ I think this is also needed for
task_dfl_cgroup(). If yes, will be a good idea to adjust the comment if it ends up using the 'CGROUP_LSM_NUM10' scheme.While at
rcu_read_lock(), have you thought about what major things are needed to makeBPF_LSM_CGROUPsleepable ?Quoted 7 lines
Quoted 3 lines
The cgroup local storage could be one that require changes but it seems the cgroup local storage is not available to
BPF_LSM_GROUPin this change set. The current use case doesn't need it?No, I haven't thought about sleepable at all yet :-( But seems like having that rcu lock here might be problematic if we want to sleep? In this case, Jakub's suggestion seems better.
The new
rcu_read_lock()here seems fine after some thoughts.Quoted 8 lines
Quoted 4 lines
I was looking at the helpers in
cgroup_base_func_proto()to get a sense on sleepable support. Only thebpf_get_local_storagecaught my eyes for now because it uses acall_rcuto free the storage. That will be the major one to change for sleepable that I can think of for now.That
rcu_read_lockshould be switched over torcu_read_lock_tracein the sleepable case I'm assuming? Are we allowed to sleep while holdingrcu_read_lock_trace?Quoted 6 lines
Ah. right, suddenly forgot the obvious in between emails :(
In that sense, may as well remove the
rcu_read_lock()here and let the trampoline to decide which one (rcu_read_lockorrcu_read_lock_trace) to call before calling theshim_prog. The__bpf_prog_enter(_sleepable)will call the rightrcu_read_lock(_trace)based on the prog is sleepable or not.
Quoted 5 lines
Removing
rcu_read_lockin__cgroup_bpf_run_lsm_currentmight be problematic because we also want to guarantee current's cgroup doesn't go away. I'm assuming things like task migrating to a new cgroup and the old one being freed can happen while we are trying to get cgroup's effective array.
Right, sleepable one may need a short rcu_read_lock only upto a point that the cgrp->bpf.effective[...] is obtained. call_rcu_tasks_trace() is then needed to free the bpf_prog_array.
The future sleepable one may be better off to have a different shim func, not sure. rcu_read_lock() can be added back later if it ends up reusing the same shim func is cleaner.
Quoted 2 lines
I guess
BPF_PROG_RUN_ARRAY_CGwill also need some work before sleepable can happen (it callsrcu_read_lockunconditionally).
Yep. I think so.
Quoted 6 lines
Also, it doesn't seem like
BPF_PROG_RUN_ARRAY_CGrcu usage is correct. It receives__rcuarray_rcu, takes rcu read lock and does deref. I'm assuming thatarray_rcucan be free'd before we even get to BPF_PROG_RUN_ARRAY_CG'srcu_read_lock? (so havingrcu_read_lockaroundBPF_PROG_RUN_ARRAY_CGmakes sense)
BPF_PROG_RUN_ARRAY_CG is __always_inline though.
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
Quoted 134 lines · Martin KaFai Lau
Quoted 127 lines · Stanislav Fomichev
Quoted 119 lines · Martin KaFai Lau
Quoted 109 lines · Stanislav Fomichev
Quoted 108 lines · Martin KaFai Lau
Quoted 97 lines · Stanislav Fomichev
Quoted 96 lines · Martin KaFai Lau
Quoted 24 lines · Stanislav Fomichev
Previous patch adds 1:1 mapping between all 211 LSM hooks and
bpf_cgroupprogram 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. This still adds some bloat to the cgroup and brings us back to roughly pre-cgroup_bpf_attach_type times.It should be possible to eventually extend this idea to all hooks if the memory consumption is unacceptable and shrink overall effective programs array.
Signed-off-by Stanislav Fomichev <[email protected]>--- include/linux/bpf-cgroup-defs.h | 4 +- include/linux/bpf_lsm.h | 6 --- kernel/bpf/bpf_lsm.c | 9 ++-- kernel/bpf/cgroup.c | 96 ++++++++++++++++++++++++++++----- 4 files changed, 90 insertions(+), 25 deletions(-)include/linux/bpf-cgroup-defs.h +0
-0include/linux/bpf-cgroup-defs.h line 15
Quoted 7 lines
include/linux/bpf-cgroup-defs.h +3
-1@@ -10,7 +10,9 @@struct bpf_prog_array ; -#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 10hmm...only 10 different lsm hooks (or 10 different
attach_btf_ids) can haveBPF_LSM_CGROUPprograms attached. This feels quite limited but having a static 211 (and potentially growing in the future) is not good either. I currently do not have a better idea also. :/Have you thought about other dynamic schemes or they would be too slow ?
Quoted 44 lines
include/linux/bpf-cgroup-defs.h +0
-0enum cgroup_bpf_attach_type {CGROUP_BPF_ATTACH_TYPE_INVALID =-1 ,include/linux/bpf_lsm.h +0
-6@@ -43,7 +43,6 @@ extern const struct bpf_func_proto bpf_inode_storage_delete_proto;void bpf_inode_storage_free (struct inode *inode);int bpf_lsm_find_cgroup_shim (const struct bpf_prog *prog,bpf_func_t *bpf_func); -int bpf_lsm_hook_idx (u32 btf_id);#else /* !CONFIG_BPF_LSM */ @@ -74,11 +73,6 @@ static inline int bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,return -ENOENT ; } -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 +2
-0@@ -57,10 +57,12 @@ static unsigned int __cgroup_bpf_run_lsm_socket(const void *ctx,if (unlikely (!sk))return 0 ; +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data);if (likely (cgrp)) ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], ctx, bpf_prog_run,0 ); +rcu_read_unlock ();return ret; }kernel/bpf/bpf_lsm.c static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx, · line 82
Quoted 5 lines
kernel/bpf/bpf_lsm.c +1
-1@@ -77,7 +79,7 @@ static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx,/*prog = container_of(insn, struct bpf_prog, insnsi);*/ prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi)); -rcu_read_lock (); +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ I think this is also needed for
task_dfl_cgroup(). If yes, will be a good idea to adjust the comment if it ends up using the 'CGROUP_LSM_NUM10' scheme.While at
rcu_read_lock(), have you thought about what major things are needed to makeBPF_LSM_CGROUPsleepable ?Quoted 7 lines
Quoted 3 lines
The cgroup local storage could be one that require changes but it seems the cgroup local storage is not available to
BPF_LSM_GROUPin this change set. The current use case doesn't need it?No, I haven't thought about sleepable at all yet :-( But seems like having that rcu lock here might be problematic if we want to sleep? In this case, Jakub's suggestion seems better.
The new
rcu_read_lock()here seems fine after some thoughts.Quoted 8 lines
Quoted 4 lines
I was looking at the helpers in
cgroup_base_func_proto()to get a sense on sleepable support. Only thebpf_get_local_storagecaught my eyes for now because it uses acall_rcuto free the storage. That will be the major one to change for sleepable that I can think of for now.That
rcu_read_lockshould be switched over torcu_read_lock_tracein the sleepable case I'm assuming? Are we allowed to sleep while holdingrcu_read_lock_trace?Quoted 6 lines
Ah. right, suddenly forgot the obvious in between emails :(
In that sense, may as well remove the
rcu_read_lock()here and let the trampoline to decide which one (rcu_read_lockorrcu_read_lock_trace) to call before calling theshim_prog. The__bpf_prog_enter(_sleepable)will call the rightrcu_read_lock(_trace)based on the prog is sleepable or not.Quoted 5 lines
Removing
rcu_read_lockin__cgroup_bpf_run_lsm_currentmight be problematic because we also want to guarantee current's cgroup doesn't go away. I'm assuming things like task migrating to a new cgroup and the old one being freed can happen while we are trying to get cgroup's effective array.
Quoted 7 lines
Right, sleepable one may need a short
rcu_read_lockonly upto a point that the cgrp->bpf.effective[...] is obtained.call_rcu_tasks_trace()is then needed to free thebpf_prog_array.The future sleepable one may be better off to have a different shim func, not sure.
rcu_read_lock()can be added back later if it ends up reusing the same shim func is cleaner.
In this case I'll probably have rcu_read_lock for cgroup+bpf_lsm_attach_type_get for the current shim.
Quoted 11 lines
Quoted 2 lines
I guess
BPF_PROG_RUN_ARRAY_CGwill also need some work before sleepable can happen (it callsrcu_read_lockunconditionally).Yep. I think so.
Quoted 6 lines
Also, it doesn't seem like
BPF_PROG_RUN_ARRAY_CGrcu usage is correct. It receives__rcuarray_rcu, takes rcu read lock and does deref. I'm assuming thatarray_rcucan be free'd before we even get to BPF_PROG_RUN_ARRAY_CG'srcu_read_lock? (so havingrcu_read_lockaroundBPF_PROG_RUN_ARRAY_CGmakes sense)
BPF_PROG_RUN_ARRAY_CGis__always_inlinethough.
Does it help? This should still expand to the following, right?
array_rcu = cgrp->bpf.effective[atype];
/* theoretically, array_rcu can be freed here? */
rcu_read_lock();
array = rcu_dereference(array_rcu);
...
Feels like the callers of BPF_PROG_RUN_ARRAY_CG really have to care about rcu locking, not the BPF_PROG_RUN_ARRAY_CG itself.
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
Quoted 139 lines · Stanislav Fomichev
Quoted 138 lines · Martin KaFai Lau
Quoted 127 lines · Stanislav Fomichev
Quoted 119 lines · Martin KaFai Lau
Quoted 109 lines · Stanislav Fomichev
Quoted 108 lines · Martin KaFai Lau
Quoted 97 lines · Stanislav Fomichev
Quoted 96 lines · Martin KaFai Lau
Quoted 24 lines · Stanislav Fomichev
Previous patch adds 1:1 mapping between all 211 LSM hooks and
bpf_cgroupprogram 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. This still adds some bloat to the cgroup and brings us back to roughly pre-cgroup_bpf_attach_type times.It should be possible to eventually extend this idea to all hooks if the memory consumption is unacceptable and shrink overall effective programs array.
Signed-off-by Stanislav Fomichev <[email protected]>--- include/linux/bpf-cgroup-defs.h | 4 +- include/linux/bpf_lsm.h | 6 --- kernel/bpf/bpf_lsm.c | 9 ++-- kernel/bpf/cgroup.c | 96 ++++++++++++++++++++++++++++----- 4 files changed, 90 insertions(+), 25 deletions(-)include/linux/bpf-cgroup-defs.h +0
-0include/linux/bpf-cgroup-defs.h line 15
Quoted 7 lines
include/linux/bpf-cgroup-defs.h +3
-1@@ -10,7 +10,9 @@struct bpf_prog_array ; -#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 10hmm...only 10 different lsm hooks (or 10 different
attach_btf_ids) can haveBPF_LSM_CGROUPprograms attached. This feels quite limited but having a static 211 (and potentially growing in the future) is not good either. I currently do not have a better idea also. :/Have you thought about other dynamic schemes or they would be too slow ?
Quoted 44 lines
include/linux/bpf-cgroup-defs.h +0
-0enum cgroup_bpf_attach_type {CGROUP_BPF_ATTACH_TYPE_INVALID =-1 ,include/linux/bpf_lsm.h +0
-6@@ -43,7 +43,6 @@ extern const struct bpf_func_proto bpf_inode_storage_delete_proto;void bpf_inode_storage_free (struct inode *inode);int bpf_lsm_find_cgroup_shim (const struct bpf_prog *prog,bpf_func_t *bpf_func); -int bpf_lsm_hook_idx (u32 btf_id);#else /* !CONFIG_BPF_LSM */ @@ -74,11 +73,6 @@ static inline int bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,return -ENOENT ; } -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 +2
-0@@ -57,10 +57,12 @@ static unsigned int __cgroup_bpf_run_lsm_socket(const void *ctx,if (unlikely (!sk))return 0 ; +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data);if (likely (cgrp)) ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], ctx, bpf_prog_run,0 ); +rcu_read_unlock ();return ret; }kernel/bpf/bpf_lsm.c static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx, · line 82
Quoted 5 lines
kernel/bpf/bpf_lsm.c +1
-1@@ -77,7 +79,7 @@ static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx,/*prog = container_of(insn, struct bpf_prog, insnsi);*/ prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi)); -rcu_read_lock (); +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ I think this is also needed for
task_dfl_cgroup(). If yes, will be a good idea to adjust the comment if it ends up using the 'CGROUP_LSM_NUM10' scheme.While at
rcu_read_lock(), have you thought about what major things are needed to makeBPF_LSM_CGROUPsleepable ?Quoted 7 lines
Quoted 3 lines
The cgroup local storage could be one that require changes but it seems the cgroup local storage is not available to
BPF_LSM_GROUPin this change set. The current use case doesn't need it?No, I haven't thought about sleepable at all yet :-( But seems like having that rcu lock here might be problematic if we want to sleep? In this case, Jakub's suggestion seems better.
The new
rcu_read_lock()here seems fine after some thoughts.Quoted 8 lines
Quoted 4 lines
I was looking at the helpers in
cgroup_base_func_proto()to get a sense on sleepable support. Only thebpf_get_local_storagecaught my eyes for now because it uses acall_rcuto free the storage. That will be the major one to change for sleepable that I can think of for now.That
rcu_read_lockshould be switched over torcu_read_lock_tracein the sleepable case I'm assuming? Are we allowed to sleep while holdingrcu_read_lock_trace?Quoted 6 lines
Ah. right, suddenly forgot the obvious in between emails :(
In that sense, may as well remove the
rcu_read_lock()here and let the trampoline to decide which one (rcu_read_lockorrcu_read_lock_trace) to call before calling theshim_prog. The__bpf_prog_enter(_sleepable)will call the rightrcu_read_lock(_trace)based on the prog is sleepable or not.Quoted 5 lines
Removing
rcu_read_lockin__cgroup_bpf_run_lsm_currentmight be problematic because we also want to guarantee current's cgroup doesn't go away. I'm assuming things like task migrating to a new cgroup and the old one being freed can happen while we are trying to get cgroup's effective array.Right, sleepable one may need a short
rcu_read_lockonly upto a point that the cgrp->bpf.effective[...] is obtained.call_rcu_tasks_trace()is then needed to free thebpf_prog_array.
Quoted 6 lines
Quoted 3 lines
The future sleepable one may be better off to have a different shim func, not sure.
rcu_read_lock()can be added back later if it ends up reusing the same shim func is cleaner.In this case I'll probably have
rcu_read_lockfor cgroup+bpf_lsm_attach_type_get for the current shim.
yeah, depending on rcu grace period to free up cgroup_lsm_atype_btf_id should be fine. It just needs to wait another grace period for sleepable in the future.
Also, just came to my mind, if it wants sleepable and non-sleepable to be in the same cgrp->bpf.effective[] array. It may need more thoughts on when to do the rcu_read_lock() and rcu_read_trace_lock().
Quoted 10 lines
Quoted 10 lines
Quoted 2 lines
I guess
BPF_PROG_RUN_ARRAY_CGwill also need some work before sleepable can happen (it callsrcu_read_lockunconditionally).Yep. I think so.
Quoted 6 lines
Also, it doesn't seem like
BPF_PROG_RUN_ARRAY_CGrcu usage is correct. It receives__rcuarray_rcu, takes rcu read lock and does deref. I'm assuming thatarray_rcucan be free'd before we even get to BPF_PROG_RUN_ARRAY_CG'srcu_read_lock? (so havingrcu_read_lockaroundBPF_PROG_RUN_ARRAY_CGmakes sense)
Quoted 5 lines
Quoted 1 line
BPF_PROG_RUN_ARRAY_CGis__always_inlinethough.Does it help? This should still expand to the following, right?
array_rcu= cgrp->bpf.effective[atype];
I think you are right:
86 ret = BPF_PROG_RUN_ARRAY_CG(cgrp->bpf.effective[prog->aux->cgroup_atype],0xffffffff812534bb <+155>: mov -0x10(%rbx),%rdx0xffffffff812534bf <+159>: movl $0x0,-0x38(%rbp)0xffffffff812534c6 <+166>: movslq 0x300(%rdx),%rdx0xffffffff812534cd <+173>: mov 0x500(%rax,%rdx,8),%rbx
[ ... ]
1375 array = rcu_dereference(array_rcu);
0xffffffff8125350d <+237>: callq 0xffffffff81145a50 <rcu_read_lock_held> 0xffffffff81253512 <+242>: test %eax,%eax 0xffffffff81253514 <+244>: je 0xffffffff812537a7 <__cgroup_bpf_run_lsm_current+903>
[ ... ]
1376 item = &array->items[0];
0xffffffff8125351a <+250>: lea -0x40(%rbp),%rdx 0xffffffff8125351e <+254>: mov %gs:0x1af40,%rax 0xffffffff81253527 <+263>: lea 0x10(%rbx),%r12
[ ... ]
1378 while ((prog = READ_ONCE(item->prog))) {
0xffffffff81253541 <+289>: test %rbx,%rbx 0xffffffff81253544 <+292>: je 0xffffffff81253596 <__cgroup_bpf_run_lsm_current+374>
Do you know if a macro can work as expected ?
Quoted 8 lines
/* theoretically,
array_rcucan be freed here? */
rcu_read_lock();
array =rcu_dereference(array_rcu);
...Feels like the callers of
BPF_PROG_RUN_ARRAY_CGreally have to care about rcu locking, not theBPF_PROG_RUN_ARRAY_CGitself.
Re: [PATCH bpf-next v3 3/7] bpf: minimize number of allocated lsm slots per program
Quoted 147 lines · Martin KaFai Lau
Quoted 139 lines · Stanislav Fomichev
Quoted 138 lines · Martin KaFai Lau
Quoted 127 lines · Stanislav Fomichev
Quoted 119 lines · Martin KaFai Lau
Quoted 109 lines · Stanislav Fomichev
Quoted 108 lines · Martin KaFai Lau
Quoted 97 lines · Stanislav Fomichev
Quoted 96 lines · Martin KaFai Lau
Quoted 24 lines · Stanislav Fomichev
Previous patch adds 1:1 mapping between all 211 LSM hooks and
bpf_cgroupprogram 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. This still adds some bloat to the cgroup and brings us back to roughly pre-cgroup_bpf_attach_type times.It should be possible to eventually extend this idea to all hooks if the memory consumption is unacceptable and shrink overall effective programs array.
Signed-off-by Stanislav Fomichev <[email protected]>--- include/linux/bpf-cgroup-defs.h | 4 +- include/linux/bpf_lsm.h | 6 --- kernel/bpf/bpf_lsm.c | 9 ++-- kernel/bpf/cgroup.c | 96 ++++++++++++++++++++++++++++----- 4 files changed, 90 insertions(+), 25 deletions(-)include/linux/bpf-cgroup-defs.h +0
-0include/linux/bpf-cgroup-defs.h line 15
Quoted 7 lines
include/linux/bpf-cgroup-defs.h +3
-1@@ -10,7 +10,9 @@struct bpf_prog_array ; -#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 10hmm...only 10 different lsm hooks (or 10 different
attach_btf_ids) can haveBPF_LSM_CGROUPprograms attached. This feels quite limited but having a static 211 (and potentially growing in the future) is not good either. I currently do not have a better idea also. :/Have you thought about other dynamic schemes or they would be too slow ?
Quoted 44 lines
include/linux/bpf-cgroup-defs.h +0
-0enum cgroup_bpf_attach_type {CGROUP_BPF_ATTACH_TYPE_INVALID =-1 ,include/linux/bpf_lsm.h +0
-6@@ -43,7 +43,6 @@ extern const struct bpf_func_proto bpf_inode_storage_delete_proto;void bpf_inode_storage_free (struct inode *inode);int bpf_lsm_find_cgroup_shim (const struct bpf_prog *prog,bpf_func_t *bpf_func); -int bpf_lsm_hook_idx (u32 btf_id);#else /* !CONFIG_BPF_LSM */ @@ -74,11 +73,6 @@ static inline int bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,return -ENOENT ; } -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 +2
-0@@ -57,10 +57,12 @@ static unsigned int __cgroup_bpf_run_lsm_socket(const void *ctx,if (unlikely (!sk))return 0 ; +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data);if (likely (cgrp)) ret =BPF_PROG_RUN_ARRAY_CG (cgrp->bpf.effective[prog->aux->cgroup_atype], ctx, bpf_prog_run,0 ); +rcu_read_unlock ();return ret; }kernel/bpf/bpf_lsm.c static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx, · line 82
Quoted 5 lines
kernel/bpf/bpf_lsm.c +1
-1@@ -77,7 +79,7 @@ static unsigned int __cgroup_bpf_run_lsm_current(const void *ctx,/*prog = container_of(insn, struct bpf_prog, insnsi);*/ prog = (const struct bpf_prog *)((void *)insn - offsetof(struct bpf_prog , insnsi)); -rcu_read_lock (); +rcu_read_lock ();/* See bpf_lsm_attach_type_get(). */ I think this is also needed for
task_dfl_cgroup(). If yes, will be a good idea to adjust the comment if it ends up using the 'CGROUP_LSM_NUM10' scheme.While at
rcu_read_lock(), have you thought about what major things are needed to makeBPF_LSM_CGROUPsleepable ?Quoted 7 lines
Quoted 3 lines
The cgroup local storage could be one that require changes but it seems the cgroup local storage is not available to
BPF_LSM_GROUPin this change set. The current use case doesn't need it?No, I haven't thought about sleepable at all yet :-( But seems like having that rcu lock here might be problematic if we want to sleep? In this case, Jakub's suggestion seems better.
The new
rcu_read_lock()here seems fine after some thoughts.Quoted 8 lines
Quoted 4 lines
I was looking at the helpers in
cgroup_base_func_proto()to get a sense on sleepable support. Only thebpf_get_local_storagecaught my eyes for now because it uses acall_rcuto free the storage. That will be the major one to change for sleepable that I can think of for now.That
rcu_read_lockshould be switched over torcu_read_lock_tracein the sleepable case I'm assuming? Are we allowed to sleep while holdingrcu_read_lock_trace?Quoted 6 lines
Ah. right, suddenly forgot the obvious in between emails :(
In that sense, may as well remove the
rcu_read_lock()here and let the trampoline to decide which one (rcu_read_lockorrcu_read_lock_trace) to call before calling theshim_prog. The__bpf_prog_enter(_sleepable)will call the rightrcu_read_lock(_trace)based on the prog is sleepable or not.Quoted 5 lines
Removing
rcu_read_lockin__cgroup_bpf_run_lsm_currentmight be problematic because we also want to guarantee current's cgroup doesn't go away. I'm assuming things like task migrating to a new cgroup and the old one being freed can happen while we are trying to get cgroup's effective array.Right, sleepable one may need a short
rcu_read_lockonly upto a point that the cgrp->bpf.effective[...] is obtained.call_rcu_tasks_trace()is then needed to free thebpf_prog_array.Quoted 6 lines
Quoted 3 lines
The future sleepable one may be better off to have a different shim func, not sure.
rcu_read_lock()can be added back later if it ends up reusing the same shim func is cleaner.In this case I'll probably have
rcu_read_lockfor cgroup+bpf_lsm_attach_type_get for the current shim.
Quoted 7 lines
yeah, depending on rcu grace period to free up
cgroup_lsm_atype_btf_idshould be fine. It just needs to wait another grace period for sleepable in the future.Also, just came to my mind, if it wants sleepable and non-sleepable to be in the same cgrp->bpf.effective[] array. It may need more thoughts on when to do the
rcu_read_lock()andrcu_read_trace_lock().
Ack. I'll try to put these details into a commit message so once we get to the sleepable support we won't have to do these investigations again.
Quoted 37 lines
Quoted 10 lines
Quoted 10 lines
Quoted 2 lines
I guess
BPF_PROG_RUN_ARRAY_CGwill also need some work before sleepable can happen (it callsrcu_read_lockunconditionally).Yep. I think so.
Quoted 6 lines
Also, it doesn't seem like
BPF_PROG_RUN_ARRAY_CGrcu usage is correct. It receives__rcuarray_rcu, takes rcu read lock and does deref. I'm assuming thatarray_rcucan be free'd before we even get to BPF_PROG_RUN_ARRAY_CG'srcu_read_lock? (so havingrcu_read_lockaroundBPF_PROG_RUN_ARRAY_CGmakes sense)Quoted 5 lines
Quoted 1 line
BPF_PROG_RUN_ARRAY_CGis__always_inlinethough.Does it help? This should still expand to the following, right?
array_rcu= cgrp->bpf.effective[atype];I think you are right:
86 ret = BPF_PROG_RUN_ARRAY_CG(cgrp->bpf.effective[prog->aux->cgroup_atype],
0xffffffff812534bb <+155>: mov -0x10(%rbx),%rdx 0xffffffff812534bf <+159>: movl $0x0,-0x38(%rbp) 0xffffffff812534c6 <+166>: movslq 0x300(%rdx),%rdx 0xffffffff812534cd <+173>: mov 0x500(%rax,%rdx,8),%rbx[ ... ]
1375 array =
rcu_dereference(array_rcu);0xffffffff8125350d <+237>: callq 0xffffffff81145a50 <rcu_read_lock_held> 0xffffffff81253512 <+242>: test %eax,%eax 0xffffffff81253514 <+244>: je 0xffffffff812537a7 <__cgroup_bpf_run_lsm_current+903>[ ... ]
1376 item = &array->items[0];
0xffffffff8125351a <+250>: lea -0x40(%rbp),%rdx 0xffffffff8125351e <+254>: mov %gs:0x1af40,%rax 0xffffffff81253527 <+263>: lea 0x10(%rbx),%r12
Quoted 18 lines
[ ... ]
1378 while ((prog =
READ_ONCE(item->prog))) {0xffffffff81253541 <+289>: test %rbx,%rbx 0xffffffff81253544 <+292>: je 0xffffffff81253596 <__cgroup_bpf_run_lsm_current+374>Do you know if a macro can work as expected ?
Quoted 8 lines
/* theoretically,
array_rcucan be freed here? */
rcu_read_lock();
array =rcu_dereference(array_rcu);
...Feels like the callers of
BPF_PROG_RUN_ARRAY_CGreally have to care about rcu locking, not theBPF_PROG_RUN_ARRAY_CGitself.
Oh, right, they've been broken since we converted from a define to an inline function. With the define it should've been working correctly.
I can move those rcu_read_lock to the callers of BPF_PROG_RUN_ARRAY_CG_FLAGS/BPF_PROG_RUN_ARRAY_CG/BPF_PROG_RUN_ARRAY. Doesn't seem like going back to the defines is the way to go.
PATCH v3 4/7 bpf: allow writing to a subset of sock fields from lsm progtype
In reply to Stanislav FomichevFor now, allow only the obvious ones, like sk_priority and sk_mark.
--- kernel/bpf/bpf_lsm.c | 58 +++++++++++++++++++++++++++++++++++++++++++ kernel/bpf/verifier.c | 3 ++- 2 files changed, 60 insertions(+), 1 deletion(-)
kernel/bpf/bpf_lsm.c +58 -0
@@ -332,7 +332,65 @@ bool bpf_lsm_is_sleepable_hook(u32 btf_id)const struct bpf_prog_ops lsm_prog_ops = { }; +static int lsm_btf_struct_access (struct bpf_verifier_log *log, +const struct btf *btf, +const struct btf_type *t,int off, +int size,enum bpf_access_type atype, +u32 *next_btf_id, +enum bpf_type_flag *flag) +{ +const struct btf_type *sock_type; +struct btf *btf_vmlinux; +s32 type_id; +size_t end; + +if (atype ==BPF_READ ) +return btf_struct_access (log, btf, t, off, size, atype, next_btf_id, + flag); + + btf_vmlinux =bpf_get_btf_vmlinux (); +if (!btf_vmlinux) { +bpf_log (log,"no vmlinux btf\n" ); +return -EOPNOTSUPP ; + } + + type_id =btf_find_by_name_kind (btf_vmlinux,"sock" ,BTF_KIND_STRUCT ); +if (type_id <0 ) { +bpf_log (log,"'struct sock' not found in vmlinux btf\n" ); +return -EINVAL ; + } + + sock_type =btf_type_by_id (btf_vmlinux, type_id); + +if (t != sock_type) { +bpf_log (log,"only 'struct sock' writes are supported\n" ); +return -EACCES ; + } + +switch (off) { + case bpf_ctx_range(struct sock, sk_priority): + end = offsetofend(struct sock, sk_priority); +break ; + case bpf_ctx_range(struct sock, sk_mark): + end = offsetofend(struct sock, sk_mark); +break ; +default : +bpf_log (log,"no write support to 'struct sock' at off %d\n" , off); +return -EACCES ; + } + +if (off + size > end) { +bpf_log (log, +"write access at off %d with size %d beyond the member of 'struct sock' ended at %zu\n" , + off, size, end); +return -EACCES ; + } + +return NOT_INIT ; +} +const struct bpf_verifier_ops lsm_verifier_ops = { .get_func_proto = bpf_lsm_func_proto, .is_valid_access = btf_ctx_access, + .btf_struct_access = lsm_btf_struct_access, };
kernel/bpf/verifier.c +2 -1
@@ -12872,7 +12872,8 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env) insn->code =BPF_LDX |BPF_PROBE_MEM |BPF_SIZE ((insn)->code); env->prog->aux->num_exentries++; - }else if (resolve_prog_type (env->prog) !=BPF_PROG_TYPE_STRUCT_OPS ) { + }else if (resolve_prog_type (env->prog) !=BPF_PROG_TYPE_STRUCT_OPS && +resolve_prog_type (env->prog) !=BPF_PROG_TYPE_LSM ) {verbose (env,"Writes through BTF pointers are not allowed\n" );return -EINVAL ; }
Signature · 1 line
2.35.1.1178.g4f1659d476-goog
PATCH v3 5/7 libbpf: add lsm_cgoup_sock type
In reply to Stanislav Fomichevlsm_cgroup/ is the prefix for BPF_LSM_CGROUP.
--- tools/bpf/bpftool/common.c | 1 + tools/lib/bpf/libbpf.c | 2 ++ 2 files changed, 3 insertions(+)
tools/bpf/bpftool/common.c +1 -0
@@ -67,6 +67,7 @@ const char * const attach_type_name[__MAX_BPF_ATTACH_TYPE] = { [BPF_TRACE_FEXIT] = "fexit", [BPF_MODIFY_RETURN] = "mod_ret", [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",
tools/lib/bpf/libbpf.c +2 -0
@@ -8691,6 +8691,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),
@@ -9112,6 +9113,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.35.1.1178.g4f1659d476-goog
PATCH v3 6/7 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 | 158 ++++++++++++++++++ .../testing/selftests/bpf/progs/lsm_cgroup.c | 94 +++++++++++ 2 files changed, 252 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 +158 -0
@@ -0,0 +1,158 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <sys/types.h> +#include <sys/socket.h> +#include <test_progs.h> + +#include "lsm_cgroup.skel.h" +#include "cgroup_helpers.h" + +void test_lsm_cgroup (void ) +{ +DECLARE_LIBBPF_OPTS (bpf_prog_attach_opts, attach_opts); +DECLARE_LIBBPF_OPTS (bpf_link_update_opts, update_opts); +int cgroup_fd, cgroup_fd2, err, fd, prio; +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 ; +socklen_t socklen; + + cgroup_fd =test__join_cgroup ("/sock_policy" ); +if (!ASSERT_GE (cgroup_fd,0 ,"join_cgroup" )) + goto close_skel; + + cgroup_fd2 =create_and_get_cgroup ("/sock_policy2" ); +if (!ASSERT_GE (cgroup_fd2,0 ,"create second cgroup" )) + goto close_skel; + + 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); + + err =bpf_prog_attach (alloc_prog_fd, cgroup_fd,BPF_LSM_CGROUP ,0 ); +if (!ASSERT_OK (err,"attach alloc_prog_fd" )) + goto detach_cgroup; + +/* Make sure replacing works. +*/ + + err =bpf_prog_attach (post_create_prog_fd, cgroup_fd, +BPF_LSM_CGROUP ,0 ); +if (!ASSERT_OK (err,"attach post_create_prog_fd" )) + goto close_cgroup; + + 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; + +/* Try the same attach/replace via link API. +*/ + + 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; + + 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; + +/* 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). +*/ + + 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; + +/* AF_UNIX is prohibited. +*/ + + fd =socket (AF_UNIX ,SOCK_STREAM ,0 ); +ASSERT_LT (fd,0 ,"socket(AF_UNIX)" ); + +/* 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); + +/* Make sure other cgroup doesn't trigger the programs. +*/ + +if (!ASSERT_OK (join_cgroup ("" ),"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" ); + +close_cgroup: +close (cgroup_fd); +close_skel: +lsm_cgroup__destroy (skel); +}
tools/testing/selftests/bpf/progs/lsm_cgroup.c new file +94 -0
94 lines not on this page · raw message
Signature · 1 line
2.35.1.1178.g4f1659d476-goog
PATCH v3 7/7 selftests/bpf: verify lsm_cgroup struct sock access
In reply to Stanislav Fomichevsk_priority & sk_mark are writable, the rest is readonly.
Add new ldx_offset fixups to lookup the offset of struct field. Allow using test.kfunc regardless of prog_type.
One interesting thing here is that the verifier doesn't really force me to add NULL checks anywhere :-/
--- tools/testing/selftests/bpf/test_verifier.c | 54 ++++++++++++++++++- .../selftests/bpf/verifier/lsm_cgroup.c | 34 ++++++++++++ 2 files changed, 87 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/bpf/verifier/lsm_cgroup.c
tools/testing/selftests/bpf/test_verifier.c +53 -1
@@ -75,6 +75,12 @@ struct kfunc_btf_id_pair {int insn_idx; }; +struct ldx_offset { +const char *strct; +const char *field; +int insn_idx; +}; +struct bpf_test {const char *descr;struct bpf_insn insns[MAX_INSNS ];
@@ -102,6 +108,7 @@ struct bpf_test {int fixup_map_ringbuf[MAX_FIXUPS ];int fixup_map_timer[MAX_FIXUPS ];struct kfunc_btf_id_pair fixup_kfunc_btf_id[MAX_FIXUPS ]; +struct ldx_offset fixup_ldx[MAX_FIXUPS ];/* Expected verifier log output for result REJECT or VERBOSE_ACCEPT. * Can be a tab-separated sequence of expected strings. An empty string * means no log verification.
@@ -755,6 +762,7 @@ static void do_test_fixup(struct bpf_test *test, enum bpf_prog_type prog_type,int *fixup_map_ringbuf = test->fixup_map_ringbuf;int *fixup_map_timer = test->fixup_map_timer;struct kfunc_btf_id_pair *fixup_kfunc_btf_id = test->fixup_kfunc_btf_id; +struct ldx_offset *fixup_ldx = test->fixup_ldx;if (test->fill_helper) { test->fill_insns =calloc (MAX_TEST_INSNS ,sizeof (struct bpf_insn ));
@@ -967,6 +975,50 @@ static void do_test_fixup(struct bpf_test *test, enum bpf_prog_type prog_type, fixup_kfunc_btf_id++; }while (fixup_kfunc_btf_id->kfunc); } + +if (fixup_ldx->strct) { +const struct btf_member *memb; +const struct btf_type *tp; +const char *name; +struct btf *btf; +int btf_id; +int off; +int i; + + btf =btf__load_vmlinux_btf (); + +do { + off =-1 ; +if (!btf) + goto next_ldx; + + btf_id =btf__find_by_name_kind (btf, + fixup_ldx->strct, +BTF_KIND_STRUCT ); +if (btf_id <0 ) + goto next_ldx; + + tp =btf__type_by_id (btf, btf_id); + memb =btf_members (tp); + +for (i =0 ; i <btf_vlen (tp); i++) { + name =btf__name_by_offset (btf, + memb->name_off); +if (strcmp (fixup_ldx->field, name) ==0 ) { + off = memb->offset /8 ; +break ; + } + memb++; + } + +next_ldx: + prog[fixup_ldx->insn_idx].off = off; + fixup_ldx++; + + }while (fixup_ldx->strct); + +btf__free (btf); + } }struct libcap {
@@ -1131,7 +1183,7 @@ static void do_test_single(struct bpf_test *test, bool unpriv, opts.log_level =4 ; opts.prog_flags = pflags; -if (prog_type ==BPF_PROG_TYPE_TRACING && test->kfunc) { +if (test->kfunc) {int attach_btf_id; attach_btf_id = libbpf_find_vmlinux_btf_id(test->kfunc,
tools/testing/selftests/bpf/verifier/lsm_cgroup.c new file +34 -0
@@ -0,0 +1,34 @@ +#define SK_WRITABLE_FIELD (tp, field, size, res) \ +{ \ + .descr = field, \ + .insns = { \ +/* r1 = *(u64 *)(r1 + 0) */ \ +BPF_LDX_MEM (BPF_DW ,BPF_REG_1 ,BPF_REG_1 ,0 ), \ +/* r1 = *(u64 *)(r1 + offsetof(struct socket, sk)) */ \ +BPF_LDX_MEM (BPF_DW ,BPF_REG_1 ,BPF_REG_1 ,0 ), \ +/* r2 = *(u64 *)(r1 + offsetof(struct sock, <field>)) */ \ +BPF_LDX_MEM (size,BPF_REG_2 ,BPF_REG_1 ,0 ), \ +/* *(u64 *)(r1 + offsetof(struct sock, <field>)) = r2 */ \ +BPF_STX_MEM (size,BPF_REG_1 ,BPF_REG_2 ,0 ), \ +BPF_MOV64_IMM (BPF_REG_0 ,1 ), \ + BPF_EXIT_INSN(), \ + }, \ + .result = res, \ + .errstr = res ? "no write support to 'struct sock' at off" : "", \ + .prog_type = BPF_PROG_TYPE_LSM, \ + .expected_attach_type = BPF_LSM_CGROUP, \ + .kfunc = "socket_post_create", \ + .fixup_ldx = { \ + { "socket", "sk", 1 }, \ + { tp, field, 2 }, \ + { tp, field, 3 }, \ + }, \ +} + +SK_WRITABLE_FIELD ("sock_common" ,"skc_family" ,BPF_H ,REJECT ), +SK_WRITABLE_FIELD ("sock" ,"sk_sndtimeo" ,BPF_DW ,REJECT ), +SK_WRITABLE_FIELD ("sock" ,"sk_priority" ,BPF_W ,ACCEPT ), +SK_WRITABLE_FIELD ("sock" ,"sk_mark" ,BPF_W ,ACCEPT ), +SK_WRITABLE_FIELD ("sock" ,"sk_pacing_rate" ,BPF_DW ,REJECT ), + +#undef SK_WRITABLE_FIELD
Signature · 1 line
2.35.1.1178.g4f1659d476-goog