cgroup bpf auto-detachment
Subsystems (7)
v3 cover cgroup bpf auto-detachment
This patchset implements a cgroup bpf auto-detachment functionality:
bpf programs are detached as soon as possible after removal of the cgroup, without waiting for the release of all associated resources.
Patches 2 and 3 are required to implement a corresponding kselftest in patch 4.
v3:
1) some minor changes and typo fixes
v2:
1) removed a bogus check in patch 4
2) moved buf[len] = 0 in patch 2
Roman Gushchin (4):
bpf: decouple the lifetime of cgroup_bpf from cgroup itself selftests/bpf: convert test_cgrp2_attach2 example into kselftest selftests/bpf: enable all available cgroup v2 controllers selftests/bpf: add auto-detach test
include/linux/bpf-cgroup.h | 8 +- include/linux/cgroup.h | 18 +++ kernel/bpf/cgroup.c | 25 ++- kernel/cgroup/cgroup.c | 11 +- samples/bpf/Makefile | 2 - tools/testing/selftests/bpf/Makefile | 4 +- tools/testing/selftests/bpf/cgroup_helpers.c | 57 +++++++ .../selftests/bpf/test_cgroup_attach.c | 146 ++++++++++++++++-- 8 files changed, 243 insertions(+), 28 deletions(-) rename samples/bpf/test_cgrp2_attach2.c => tools/testing/selftests/bpf/test_cgroup_attach.c (79%)
Signature · 1 line
2.20.1
PATCH v3 1/4 bpf: decouple the lifetime of cgroup_bpf from cgroup itself
Currently the lifetime of bpf programs attached to a cgroup is bound to the lifetime of the cgroup itself. It means that if a user forgets (or intentionally avoids) to detach a bpf program before removing the cgroup, it will stay attached up to the release of the cgroup. Since the cgroup can stay in the dying state (the state between being rmdir()'ed and being released) for a very long time, it leads to a waste of memory. Also, it blocks a possibility to implement the memcg-based memory accounting for bpf objects, because a circular reference dependency will occur. Charged memory pages are pinning the corresponding memory cgroup, and if the memory cgroup is pinning the attached bpf program, nothing will be ever released.
A dying cgroup can not contain any processes, so the only chance for an attached bpf program to be executed is a live socket associated with the cgroup. So in order to release all bpf data early, let's count associated sockets using a new percpu refcounter. On cgroup removal the counter is transitioned to the atomic mode, and as soon as it reaches 0, all bpf programs are detached.
The reference counter is not socket specific, and can be used for any other types of programs, which can be executed from a cgroup-bpf hook outside of the process context, had such a need arise in the future.
--- include/linux/bpf-cgroup.h | 8 ++++++-- include/linux/cgroup.h | 18 ++++++++++++++++++ kernel/bpf/cgroup.c | 25 ++++++++++++++++++++++--- kernel/cgroup/cgroup.c | 11 ++++++++--- 4 files changed, 54 insertions(+), 8 deletions(-)
include/linux/bpf-cgroup.h +6 -2
@@ -6,6 +6,7 @@#include <linux/errno.h> #include <linux/jump_label.h> #include <linux/percpu.h> +#include <linux/percpu-refcount.h> #include <linux/rbtree.h> #include <uapi/linux/bpf.h>
@@ -72,10 +73,13 @@ struct cgroup_bpf {/* temp storage for effective prog array used by prog_attach/detach */ struct bpf_prog_array __rcu *inactive; + +/* reference counter used to detach bpf programs after cgroup removal */ +struct percpu_ref refcnt; }; -void cgroup_bpf_put (struct cgroup *cgrp);int cgroup_bpf_inherit (struct cgroup *cgrp); +void cgroup_bpf_offline (struct cgroup *cgrp);int __cgroup_bpf_attach (struct cgroup *cgrp,struct bpf_prog *prog,enum bpf_attach_type type,u32 flags);
@@ -283,8 +287,8 @@ int cgroup_bpf_prog_query(const union bpf_attr *attr,struct bpf_prog ;struct cgroup_bpf {}; -static inline void cgroup_bpf_put (struct cgroup *cgrp) {}static inline int cgroup_bpf_inherit (struct cgroup *cgrp) {return 0 ; } +static inline void cgroup_bpf_offline (struct cgroup *cgrp) {} static inline int cgroup_bpf_prog_attach(const union bpf_attr *attr, enum bpf_prog_type ptype,
include/linux/cgroup.h +18 -0
@@ -924,4 +924,22 @@ static inline bool cgroup_task_frozen(struct task_struct *task)#endif /* !CONFIG_CGROUPS */ +#ifdef CONFIG_CGROUP_BPF +static inline void cgroup_bpf_get (struct cgroup *cgrp) +{ +percpu_ref_get (&cgrp->bpf.refcnt); +} + +static inline void cgroup_bpf_put (struct cgroup *cgrp) +{ +percpu_ref_put (&cgrp->bpf.refcnt); +} + +#else /* CONFIG_CGROUP_BPF */ + +static inline void cgroup_bpf_get (struct cgroup *cgrp) {} +static inline void cgroup_bpf_put (struct cgroup *cgrp) {} + +#endif /* CONFIG_CGROUP_BPF */ +#endif /* _LINUX_CGROUP_H */
kernel/bpf/cgroup.c +22 -3
@@ -22,12 +22,20 @@DEFINE_STATIC_KEY_FALSE (cgroup_bpf_enabled_key);EXPORT_SYMBOL (cgroup_bpf_enabled_key); +void cgroup_bpf_offline (struct cgroup *cgrp) +{ +cgroup_get (cgrp); +percpu_ref_kill (&cgrp->bpf.refcnt); +} +/** -* cgroup_bpf_put() - put references of all bpf programs +* cgroup_bpf_release() - put references of all bpf programs and +* release all cgroup bpf data * @cgrp: the cgroup to modify */ -void cgroup_bpf_put (struct cgroup *cgrp) +static void cgroup_bpf_release (struct percpu_ref *ref) { + struct cgroup *cgrp = container_of(ref, struct cgroup, bpf.refcnt);enum bpf_cgroup_storage_type stype;unsigned int type;
@@ -47,6 +55,9 @@ void cgroup_bpf_put(struct cgroup *cgrp) }bpf_prog_array_free (cgrp->bpf.effective[type]); } + +percpu_ref_exit (&cgrp->bpf.refcnt); +cgroup_put (cgrp); }/* count number of elements in the list.
@@ -167,7 +178,12 @@ int cgroup_bpf_inherit(struct cgroup *cgrp)*/ #define NR ARRAY_SIZE(cgrp->bpf.effective)struct bpf_prog_array __rcu *arrays[NR ] = {}; -int i; +int ret, i; + + ret =percpu_ref_init (&cgrp->bpf.refcnt, cgroup_bpf_release,0 , +GFP_KERNEL ); +if (ret) +return ret;for (i =0 ; i <NR ; i++)INIT_LIST_HEAD (&cgrp->bpf.progs[i]);
@@ -183,6 +199,9 @@ int cgroup_bpf_inherit(struct cgroup *cgrp) cleanup:for (i =0 ; i <NR ; i++)bpf_prog_array_free (arrays[i]); + +percpu_ref_exit (&cgrp->bpf.refcnt); +return -ENOMEM ; }
kernel/cgroup/cgroup.c +8 -3
@@ -4955,8 +4955,6 @@ static void css_release_work_fn(struct work_struct *work)if (cgrp->kn)RCU_INIT_POINTER (*(void __rcu __force **)&cgrp->kn->priv,NULL ); - -cgroup_bpf_put (cgrp); }mutex_unlock (&cgroup_mutex);
@@ -5482,6 +5480,8 @@ static int cgroup_destroy_locked(struct cgroup *cgrp)cgroup1_check_for_release (parent); +cgroup_bpf_offline (cgrp); +/* put the base reference */ percpu_ref_kill (&cgrp->self.refcnt);
@@ -6221,6 +6221,7 @@ void cgroup_sk_alloc(struct sock_cgroup_data *skcd)* Don't use cgroup_get_live(). */ cgroup_get (sock_cgroup_ptr (skcd)); +cgroup_bpf_get (sock_cgroup_ptr (skcd));return ; }
@@ -6232,6 +6233,7 @@ void cgroup_sk_alloc(struct sock_cgroup_data *skcd) cset =task_css_set (current);if (likely (cgroup_tryget (cset->dfl_cgrp))) { skcd->val = (unsigned long )cset->dfl_cgrp; +cgroup_bpf_get (cset->dfl_cgrp);break ; }cpu_relax ();
@@ -6242,7 +6244,10 @@ void cgroup_sk_alloc(struct sock_cgroup_data *skcd)void cgroup_sk_free (struct sock_cgroup_data *skcd) { -cgroup_put (sock_cgroup_ptr (skcd)); +struct cgroup *cgrp =sock_cgroup_ptr (skcd); + +cgroup_bpf_put (cgrp); +cgroup_put (cgrp); }#endif /* CONFIG_SOCK_CGROUP_DATA */
Signature · 1 line
2.20.1
PATCH v3 2/4 selftests/bpf: convert test_cgrp2_attach2 example into kselftest
In reply to Roman GushchinConvert test_cgrp2_attach2 example into a proper test_cgroup_attach kselftest. It's better because we do run kselftest on a constant basis, so there are better chances to spot a potential regression.
Also make it slightly less verbose to conform kselftests output style.
Output example:
$ ./test_cgroup_attach #override:PASS #multi:PASS test_cgroup_attach:PASS
--- samples/bpf/Makefile | 2 - tools/testing/selftests/bpf/Makefile | 4 +- .../selftests/bpf/test_cgroup_attach.c | 50 ++++++++++++------- 3 files changed, 36 insertions(+), 20 deletions(-) rename samples/bpf/test_cgrp2_attach2.c => tools/testing/selftests/bpf/test_cgroup_attach.c (91%)
samples/bpf/Makefile +0 -2
@@ -26,7 +26,6 @@ hostprogs-y += map_perf_test hostprogs-y += test_overhead hostprogs-y += test_cgrp2_array_pin hostprogs-y += test_cgrp2_attach -hostprogs-y += test_cgrp2_attach2 hostprogs-y += test_cgrp2_sock hostprogs-y += test_cgrp2_sock2 hostprogs-y += xdp1
@@ -81,7 +80,6 @@ map_perf_test-objs := bpf_load.o map_perf_test_user.o test_overhead-objs := bpf_load.o test_overhead_user.o test_cgrp2_array_pin-objs := test_cgrp2_array_pin.o test_cgrp2_attach-objs := test_cgrp2_attach.o -test_cgrp2_attach2-objs := test_cgrp2_attach2.o $(CGROUP_HELPERS) test_cgrp2_sock-objs := test_cgrp2_sock.o test_cgrp2_sock2-objs := bpf_load.o test_cgrp2_sock2.o xdp1-objs := xdp1_user.o
tools/testing/selftests/bpf/Makefile +3 -1
@@ -23,7 +23,8 @@ TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map test test_align test_verifier_log test_dev_cgroup test_tcpbpf_user \ test_sock test_btf test_sockmap test_lirc_mode2_user get_cgroup_id_user \ test_socket_cookie test_cgroup_storage test_select_reuseport test_section_names \ - test_netcnt test_tcpnotify_user test_sock_fields test_sysctl + test_netcnt test_tcpnotify_user test_sock_fields test_sysctl \ + test_cgroup_attach BPF_OBJ_FILES = $(patsubst %.c,%.o, $(notdir $(wildcard progs/*.c))) TEST_GEN_FILES = $(BPF_OBJ_FILES)
@@ -96,6 +97,7 @@ $(OUTPUT)/test_cgroup_storage: cgroup_helpers.c $(OUTPUT)/test_netcnt: cgroup_helpers.c $(OUTPUT)/test_sock_fields: cgroup_helpers.c $(OUTPUT)/test_sysctl: cgroup_helpers.c +$(OUTPUT)/test_cgroup_attach: cgroup_helpers.c .PHONY: force
tools/testing/selftests/bpf/test_cgroup_attach.c renamed from samples/bpf/test_cgrp2_attach2.c +33 -17
119 lines not on this page · raw message
Signature · 1 line
2.20.1
PATCH v3 3/4 selftests/bpf: enable all available cgroup v2 controllers
In reply to Roman GushchinEnable all available cgroup v2 controllers when setting up the environment for the bpf kselftests. It's required to properly test the bpf prog auto-detach feature. Also it will generally increase the code coverage.
--- tools/testing/selftests/bpf/cgroup_helpers.c | 57 ++++++++++++++++++++ 1 file changed, 57 insertions(+)
tools/testing/selftests/bpf/cgroup_helpers.c +57 -0
@@ -33,6 +33,60 @@snprintf (buf,sizeof (buf),"%s%s%s" ,CGROUP_MOUNT_PATH , \CGROUP_WORK_DIR , path) +/** +* enable_all_controllers() - Enable all available cgroup v2 controllers +* +* Enable all available cgroup v2 controllers in order to increase +* the code coverage. +* +* If successful, 0 is returned. + */ +int enable_all_controllers (char *cgroup_path) +{ +char path[PATH_MAX +1 ]; +char buf[PATH_MAX ]; +char *c, *c2; +int fd, cfd; +size_t len; + +snprintf (path,sizeof (path),"%s/cgroup.controllers" , cgroup_path); + fd =open (path,O_RDONLY ); +if (fd <0 ) { +log_err ("Opening cgroup.controllers: %s" , path); +return 1 ; + } + + len =read (fd, buf,sizeof (buf) -1 ); +if (len <0 ) { +close (fd); +log_err ("Reading cgroup.controllers: %s" , path); +return 1 ; + } + buf[len] =0 ; +close (fd); + +/* No controllers available? We're probably on cgroup v1. */ +if (len ==0 ) +return 0 ; + +snprintf (path,sizeof (path),"%s/cgroup.subtree_control" , cgroup_path); + cfd =open (path,O_RDWR ); +if (cfd <0 ) { +log_err ("Opening cgroup.subtree_control: %s" , path); +return 1 ; + } + +for (c =strtok_r (buf," " , &c2); c; c =strtok_r (NULL ," " , &c2)) { +if (dprintf (cfd,"+%s\n" , c) <=0 ) { +log_err ("Enabling controller %s: %s" , c, path); +close (cfd); +return 1 ; + } + } +close (cfd); +return 0 ; +} +/** * setup_cgroup_environment() - Setup the cgroup environment *
@@ -71,6 +125,9 @@ int setup_cgroup_environment(void)return 1 ; } +if (enable_all_controllers (cgroup_workdir)) +return 1 ; +return 0 ; }
Signature · 1 line
2.20.1
PATCH v3 4/4 selftests/bpf: add auto-detach test
In reply to Roman GushchinAdd a kselftest to cover bpf auto-detachment functionality. The test creates a cgroup, associates some resources with it, attaches a couple of bpf programs and deletes the cgroup.
Then it checks that bpf programs are going away in 5 seconds.
Expected output:
$ ./test_cgroup_attach #override:PASS #multi:PASS #autodetach:PASS test_cgroup_attach:PASS
On a kernel without auto-detaching:
$ ./test_cgroup_attach #override:PASS #multi:PASS #autodetach:FAIL test_cgroup_attach:FAIL
--- .../selftests/bpf/test_cgroup_attach.c | 98 ++++++++++++++++++- 1 file changed, 97 insertions(+), 1 deletion(-)
tools/testing/selftests/bpf/test_cgroup_attach.c +97 -1
@@ -456,9 +456,105 @@ static int test_multiprog(void)return rc; } +static int test_autodetach (void ) +{ +__u32 prog_cnt =4 , attach_flags; +int allow_prog[2 ] = {0 }; +__u32 prog_ids[2 ] = {0 }; +int cg =0 , i, rc =-1 ; +void *ptr =NULL ; +int attempts; + +for (i =0 ; i <ARRAY_SIZE (allow_prog); i++) { + allow_prog[i] =prog_load_cnt (1 ,1 << i); +if (!allow_prog[i]) + goto err; + } + +if (setup_cgroup_environment ()) + goto err; + +/* create a cgroup, attach two programs and remember their ids */ + cg =create_and_get_cgroup ("/cg_autodetach" ); +if (cg <0 ) + goto err; + +if (join_cgroup ("/cg_autodetach" )) + goto err; + +for (i =0 ; i <ARRAY_SIZE (allow_prog); i++) { +if (bpf_prog_attach (allow_prog[i], cg,BPF_CGROUP_INET_EGRESS , +BPF_F_ALLOW_MULTI )) { +log_err ("Attaching prog[%d] to cg:egress" , i); + goto err; + } + } + +/* make sure that programs are attached and run some traffic */ +assert (bpf_prog_query (cg,BPF_CGROUP_INET_EGRESS ,0 , &attach_flags, + prog_ids, &prog_cnt) ==0 ); +assert (system (PING_CMD ) ==0 ); + +/* allocate some memory (4Mb) to pin the original cgroup */ + ptr =malloc (4 * (1 <<20 )); +if (!ptr) + goto err; + +/* close programs and cgroup fd */ +for (i =0 ; i <ARRAY_SIZE (allow_prog); i++) { +close (allow_prog[i]); + allow_prog[i] =0 ; + } + +close (cg); + cg =0 ; + +/* leave the cgroup and remove it. don't detach programs */ +cleanup_cgroup_environment (); + +/* wait for the asynchronous auto-detachment. +* wait for no more than 5 sec and give up. +*/ +for (i =0 ; i <ARRAY_SIZE (prog_ids); i++) { +for (attempts =5 ; attempts >=0 ; attempts--) { +int fd =bpf_prog_get_fd_by_id (prog_ids[i]); + +if (fd <0 ) +break ; + +/* don't leave the fd open */ +close (fd); + +if (!attempts) + goto err; + +sleep (1 ); + } + } + + rc =0 ; +err: +for (i =0 ; i <ARRAY_SIZE (allow_prog); i++) +if (allow_prog[i] >0 ) +close (allow_prog[i]); +if (cg) +close (cg); +free (ptr); +cleanup_cgroup_environment (); +if (!rc) +printf ("#autodetach:PASS\n" ); +else +printf ("#autodetach:FAIL\n" ); +return rc; +} +int main (void ) { -int (*tests[])(void ) = {test_foo_bar, test_multiprog}; +int (*tests[])(void ) = { + test_foo_bar, + test_multiprog, + test_autodetach, + };int errors =0 ;int i;
Signature · 1 line
2.20.1
Re: [PATCH v3 bpf-next 4/4] selftests/bpf: add auto-detach test
Quoted 13 lines · Roman Gushchin
Add a kselftest to cover bpf auto-detachment functionality. The test creates a cgroup, associates some resources with it, attaches a couple of bpf programs and deletes the cgroup.
Then it checks that bpf programs are going away in 5 seconds.
Expected output:
$ ./test_cgroup_attach #override:PASS #multi:PASS #autodetach:PASS test_cgroup_attach:PASS
Quoted 8 lines
On a kernel without auto-detaching:
$ ./test_cgroup_attach #override:PASS #multi:PASS #autodetach:FAIL test_cgroup_attach:FAILSigned-off-by Roman Gushchin <[email protected]>
Looks good to me. It will be good if you can add test_cgroup_attach to .gitignore to avoid it shows up in git status. With that,
Quoted 116 lines
--- .../selftests/bpf/test_cgroup_attach.c | 98 ++++++++++++++++++- 1 file changed, 97 insertions(+), 1 deletion(-)tools/testing/selftests/bpf/test_cgroup_attach.c +97
-1@@ -456,9 +456,105 @@ static int test_multiprog(void)return rc; } +static int test_autodetach (void ) +{ +__u32 prog_cnt =4 , attach_flags; +int allow_prog[2 ] = {0 }; +__u32 prog_ids[2 ] = {0 }; +int cg =0 , i, rc =-1 ; +void *ptr =NULL ; +int attempts; + +for (i =0 ; i <ARRAY_SIZE (allow_prog); i++) { + allow_prog[i] =prog_load_cnt (1 ,1 << i); +if (!allow_prog[i]) + goto err; + } + +if (setup_cgroup_environment ()) + goto err; + +/* create a cgroup, attach two programs and remember their ids */ + cg =create_and_get_cgroup ("/cg_autodetach" ); +if (cg <0 ) + goto err; + +if (join_cgroup ("/cg_autodetach" )) + goto err; + +for (i =0 ; i <ARRAY_SIZE (allow_prog); i++) { +if (bpf_prog_attach (allow_prog[i], cg,BPF_CGROUP_INET_EGRESS , +BPF_F_ALLOW_MULTI )) { +log_err ("Attaching prog[%d] to cg:egress" , i); + goto err; + } + } + +/* make sure that programs are attached and run some traffic */ +assert (bpf_prog_query (cg,BPF_CGROUP_INET_EGRESS ,0 , &attach_flags, + prog_ids, &prog_cnt) ==0 ); +assert (system (PING_CMD ) ==0 ); + +/* allocate some memory (4Mb) to pin the original cgroup */ + ptr =malloc (4 * (1 <<20 )); +if (!ptr) + goto err; + +/* close programs and cgroup fd */ +for (i =0 ; i <ARRAY_SIZE (allow_prog); i++) { +close (allow_prog[i]); + allow_prog[i] =0 ; + } + +close (cg); + cg =0 ; + +/* leave the cgroup and remove it. don't detach programs */ +cleanup_cgroup_environment (); + +/* wait for the asynchronous auto-detachment. +* wait for no more than 5 sec and give up. +*/ +for (i =0 ; i <ARRAY_SIZE (prog_ids); i++) { +for (attempts =5 ; attempts >=0 ; attempts--) { +int fd =bpf_prog_get_fd_by_id (prog_ids[i]); + +if (fd <0 ) +break ; + +/* don't leave the fd open */ +close (fd); + +if (!attempts) + goto err; + +sleep (1 ); + } + } + + rc =0 ; +err: +for (i =0 ; i <ARRAY_SIZE (allow_prog); i++) +if (allow_prog[i] >0 ) +close (allow_prog[i]); +if (cg) +close (cg); +free (ptr); +cleanup_cgroup_environment (); +if (!rc) +printf ("#autodetach:PASS\n" ); +else +printf ("#autodetach:FAIL\n" ); +return rc; +} +int main (void ) { -int (*tests[])(void ) = {test_foo_bar, test_multiprog}; +int (*tests[])(void ) = { + test_foo_bar, + test_multiprog, + test_autodetach, + };int errors =0 ;int i;
Re: [PATCH v3 bpf-next 4/4] selftests/bpf: add auto-detach test
Quoted 23 lines · Yonghong Song
Quoted 20 lines · Roman Gushchin
Add a kselftest to cover bpf auto-detachment functionality. The test creates a cgroup, associates some resources with it, attaches a couple of bpf programs and deletes the cgroup.
Then it checks that bpf programs are going away in 5 seconds.
Expected output:
$ ./test_cgroup_attach #override:PASS #multi:PASS #autodetach:PASS test_cgroup_attach:PASSOn a kernel without auto-detaching:
$ ./test_cgroup_attach #override:PASS #multi:PASS #autodetach:FAIL test_cgroup_attach:FAIL
Quoted 4 lines
Quoted 1 line
Signed-off-by Roman Gushchin <[email protected]>Looks good to me. It will be good if you can add
test_cgroup_attachto .gitignore to avoid it shows up ingit status. With that,
I don't think it deserves a new version, I'll prepare a separate patch for it.
Quoted 2 lines
Acked-by Yonghong Song <[email protected]>
Thank you for the review!
Re: [PATCH v3 bpf-next 4/4] selftests/bpf: add auto-detach test
In reply to Yonghong SongQuoted 23 lines · Yonghong Song
Quoted 20 lines · Roman Gushchin
Add a kselftest to cover bpf auto-detachment functionality. The test creates a cgroup, associates some resources with it, attaches a couple of bpf programs and deletes the cgroup.
Then it checks that bpf programs are going away in 5 seconds.
Expected output:
$ ./test_cgroup_attach #override:PASS #multi:PASS #autodetach:PASS test_cgroup_attach:PASSOn a kernel without auto-detaching:
$ ./test_cgroup_attach #override:PASS #multi:PASS #autodetach:FAIL test_cgroup_attach:FAIL
Quoted 5 lines
Quoted 1 line
Signed-off-by Roman Gushchin <[email protected]>Looks good to me. It will be good if you can add
test_cgroup_attachto .gitignore to avoid it shows up ingit status. With that,
Here it is!
Thanks!
---
From 150fb4db7ab37f0e8b6482386e8830f3d11b64e1 Mon Sep 17 00:00:00 2001
From: Roman Gushchin <[email protected]>
Date: Thu, 23 May 2019 16:46:58 -0700
Subject: [PATCH bpf-next] selftests/bpf: add test_cgroup_attach to .gitignore
Add test_cgroup_attach binary to .gitignore.
--- tools/testing/selftests/bpf/.gitignore | 1 + 1 file changed, 1 insertion(+)
tools/testing/selftests/bpf/.gitignore +1 -0
@@ -22,6 +22,7 @@ test_lirc_mode2_user get_cgroup_id_user test_skb_cgroup_id_user test_socket_cookie +test_cgroup_attach test_cgroup_storage test_select_reuseport test_flow_dissector
Signature · 1 line
2.20.1
Quoted 3 lines · Roman Gushchin
This patchset implements a cgroup bpf auto-detachment functionality:
bpf programs are detached as soon as possible after removal of the cgroup, without waiting for the release of all associated resources.
The idea looks great, but doesn't quite work:
$ ./test_cgroup_attach #override:PASS [ 66.475219] BUG: sleeping function called from invalid context at ../include/linux/percpu-rwsem.h:34 [ 66.476095] in_atomic(): 1, irqs_disabled(): 0, pid: 21, name: ksoftirqd/2 [ 66.476706] CPU: 2 PID: 21 Comm: ksoftirqd/2 Not tainted 5.2.0-rc1-00211-g1861420d0162 #1564 [ 66.477595] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.11.0-2.el7 04/01/2014 [ 66.478360] Call Trace: [ 66.478591] dump_stack+0x5b/0x8b [ 66.478892] ___might_sleep+0x22f/0x290 [ 66.479230] cpus_read_lock+0x18/0x50 [ 66.479550] static_key_slow_dec+0x41/0x70 [ 66.479914] cgroup_bpf_release+0x1a6/0x400 [ 66.480285] percpu_ref_switch_to_atomic_rcu+0x203/0x330 [ 66.480754] rcu_core+0x475/0xcc0 [ 66.481047] ? switch_mm_irqs_off+0x684/0xa40 [ 66.481422] ? rcu_note_context_switch+0x260/0x260 [ 66.481842] __do_softirq+0x1cf/0x5ff [ 66.482174] ? takeover_tasklets+0x5f0/0x5f0 [ 66.482542] ? smpboot_thread_fn+0xab/0x780 [ 66.482911] run_ksoftirqd+0x1a/0x40 [ 66.483225] smpboot_thread_fn+0x3ad/0x780 [ 66.483583] ? sort_range+0x20/0x20 [ 66.483894] ? __kthread_parkme+0xb0/0x190 [ 66.484253] ? sort_range+0x20/0x20 [ 66.484562] ? sort_range+0x20/0x20 [ 66.484878] kthread+0x2e2/0x3e0 [ 66.485166] ? kthread_create_worker_on_cpu+0xb0/0xb0 [ 66.485620] ret_from_fork+0x1f/0x30
Same test runs fine before the patches.
Quoted 36 lines · Alexei Starovoitov
Quoted 3 lines · Roman Gushchin
This patchset implements a cgroup bpf auto-detachment functionality:
bpf programs are detached as soon as possible after removal of the cgroup, without waiting for the release of all associated resources.The idea looks great, but doesn't quite work:
$ ./test_cgroup_attach #override:PASS [ 66.475219] BUG: sleeping function called from invalid context at ../include/linux/percpu-rwsem.h:34 [ 66.476095] in_atomic(): 1, irqs_disabled(): 0, pid: 21, name: ksoftirqd/2 [ 66.476706] CPU: 2 PID: 21 Comm: ksoftirqd/2 Not tainted 5.2.0-rc1-00211-g1861420d0162 #1564 [ 66.477595] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.11.0-2.el7 04/01/2014 [ 66.478360] Call Trace: [ 66.478591] dump_stack+0x5b/0x8b [ 66.478892] ___might_sleep+0x22f/0x290 [ 66.479230] cpus_read_lock+0x18/0x50 [ 66.479550] static_key_slow_dec+0x41/0x70 [ 66.479914] cgroup_bpf_release+0x1a6/0x400 [ 66.480285] percpu_ref_switch_to_atomic_rcu+0x203/0x330 [ 66.480754] rcu_core+0x475/0xcc0 [ 66.481047] ? switch_mm_irqs_off+0x684/0xa40 [ 66.481422] ? rcu_note_context_switch+0x260/0x260 [ 66.481842] __do_softirq+0x1cf/0x5ff [ 66.482174] ? takeover_tasklets+0x5f0/0x5f0 [ 66.482542] ? smpboot_thread_fn+0xab/0x780 [ 66.482911] run_ksoftirqd+0x1a/0x40 [ 66.483225] smpboot_thread_fn+0x3ad/0x780 [ 66.483583] ? sort_range+0x20/0x20 [ 66.483894] ? __kthread_parkme+0xb0/0x190 [ 66.484253] ? sort_range+0x20/0x20 [ 66.484562] ? sort_range+0x20/0x20 [ 66.484878] kthread+0x2e2/0x3e0 [ 66.485166] ? kthread_create_worker_on_cpu+0xb0/0xb0 [ 66.485620] ret_from_fork+0x1f/0x30
Quoted 2 lines
Same test runs fine before the patches.
Ouch, static_branch_dec() might block, so it's not possible to call it from percpu ref counter release callback. It's not what I expected, tbh.
Good catch, thanks!