bpf/test_run: fix unkillable BPF_PROG_TEST_RUN
Subsystems (5)
PATCH 1/2 bpf/test_run: fix unkillable BPF_PROG_TEST_RUN
Syzbot found out that running BPF_PROG_TEST_RUN with repeat=0xffffffff makes process unkillable. The problem is that when CONFIG_PREEMPT is enabled, we never see need_resched() return true. This is due to the fact that preempt_enable() (which we do in bpf_test_run_one on each iteration) now handles resched if it's needed.
Let's disable preemption for the whole run, not per test. In this case we can properly see whether resched is needed.
Let's also properly return -EINTR to the userspace in case of a signal interrupt.
See recent discussion:
http://lore.kernel.org/netdev/CAH3MdRWHr4N8jei8jxDppXjmw-Nw=puNDLbu1dQOFQHxfU2onA@mail.gmail.com
I'll follow up with the same fix bpf_prog_test_run_flow_dissector in bpf-next.
--- net/bpf/test_run.c | 45 ++++++++++++++++++++++++--------------------- 1 file changed, 24 insertions(+), 21 deletions(-)
net/bpf/test_run.c +24 -21
@@ -13,27 +13,13 @@#include <net/sock.h> #include <net/tcp.h> -static __always_inline u32 bpf_test_run_one(struct bpf_prog *prog, void *ctx, -struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE ]) -{ -u32 ret; - -preempt_disable (); -rcu_read_lock (); -bpf_cgroup_storage_set (storage); - ret =BPF_PROG_RUN (prog, ctx); -rcu_read_unlock (); -preempt_enable (); - -return ret; -} - -static int bpf_test_run (struct bpf_prog *prog,void *ctx,u32 repeat,u32 *ret, -u32 *time) +static int bpf_test_run (struct bpf_prog *prog,void *ctx,u32 repeat, +u32 *retval,u32 *time) {struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE ] = {0 };enum bpf_cgroup_storage_type stype;u64 time_start, time_spent =0 ; +int ret =0 ;u32 i;for_each_cgroup_storage_type (stype) {
@@ -48,25 +34,42 @@ static int bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat, u32 *ret,if (!repeat) repeat =1 ; + +rcu_read_lock (); +preempt_disable (); time_start =ktime_get_ns ();for (i =0 ; i < repeat; i++) { - *ret =bpf_test_run_one (prog, ctx, storage); +bpf_cgroup_storage_set (storage); + *retval =BPF_PROG_RUN (prog, ctx); + +if (signal_pending (current)) { + ret = -EINTR ; +break ; + } +if (need_resched ()) { -if (signal_pending (current)) -break ; time_spent +=ktime_get_ns () - time_start; +preempt_enable (); +rcu_read_unlock (); +cond_resched (); + +rcu_read_lock (); +preempt_disable (); time_start =ktime_get_ns (); } } time_spent +=ktime_get_ns () - time_start; +preempt_enable (); +rcu_read_unlock (); +do_div (time_spent, repeat); *time = time_spent >U32_MAX ?U32_MAX : (u32 )time_spent;for_each_cgroup_storage_type (stype)bpf_cgroup_storage_free (storage[stype]); -return 0 ; +return ret; } static int bpf_test_finish(const union bpf_attr *kattr,
Signature · 1 line
2.20.1.791.gb4d0f1c61a-goog
PATCH 2/2 selftests/bpf: make sure signal interrupts BPF_PROG_TEST_RUN
Simple test that I used to reproduce the issue in the previous commit:
Do BPF_PROG_TEST_RUN with max iterations, each program is 4096 simple move instructions. File alarm in 0.1 second and check that bpf_prog_test_run is interrupted (i.e. test doesn't hang).
Feel free to ignore it if you feel like that's just a one-off fix and it doesn't require a test going forward.
--- tools/testing/selftests/bpf/test_progs.c | 44 ++++++++++++++++++++++++ 1 file changed, 44 insertions(+)
tools/testing/selftests/bpf/test_progs.c +44 -0
@@ -11,6 +11,7 @@#include <assert.h> #include <stdlib.h> #include <time.h> +#include <signal.h> #include <linux/types.h> typedef __u16 __sum16 ;
@@ -27,6 +28,7 @@ typedef __u16 __sum16;#include <sys/ioctl.h> #include <sys/wait.h> #include <sys/types.h> +#include <sys/time.h> #include <fcntl.h> #include <linux/bpf.h>
@@ -1912,6 +1914,47 @@ static void test_queue_stack_map(int type)bpf_object__close (obj); } +static void sigalrm_handler (int s) {} +static struct sigaction sigalrm_action = { + .sa_handler = sigalrm_handler, +}; + +static void test_signal_pending (void ) +{ +struct bpf_insn prog[4096 ]; +struct itimerval timeo = { + .it_value.tv_usec =100000 ,/* 100ms */ + }; +__u32 duration, retval; +int prog_fd; +int err; +int i; + +for (i =0 ; i <ARRAY_SIZE (prog); i++) + prog[i] =BPF_ALU64_IMM (BPF_MOV ,BPF_REG_0 ,0 ); + prog[ARRAY_SIZE (prog) -1 ] =BPF_EXIT_INSN (); + + prog_fd =bpf_load_program (BPF_PROG_TYPE_SOCKET_FILTER , + prog,ARRAY_SIZE (prog), +"GPL" ,0 ,NULL ,0 ); +CHECK (prog_fd <0 ,"test-run" ,"errno %d\n" , errno); + + err =sigaction (SIGALRM , &sigalrm_action,NULL ); +CHECK (err,"test-run-signal-sigaction" ,"errno %d\n" , errno); + + err =setitimer (ITIMER_REAL , &timeo,NULL ); +CHECK (err,"test-run-signal-timer" ,"errno %d\n" , errno); + + err =bpf_prog_test_run (prog_fd,0xffffffff , &pkt_v4,sizeof (pkt_v4), +NULL ,NULL , &retval, &duration); +CHECK (err !=-1 || errno !=EINTR || duration >1000000000 , +"test-run-signal-run" , +"err %d errno %d retval %d\n" , + err, errno, retval); + +signal (SIGALRM ,SIG_DFL ); +} +int main (void ) {srand (time (NULL ));
@@ -1939,6 +1982,7 @@ int main(void)test_reference_tracking ();test_queue_stack_map (QUEUE );test_queue_stack_map (STACK ); +test_signal_pending ();printf ("Summary: %d PASSED, %d FAILED\n" , pass_cnt, error_cnt);return error_cnt ?EXIT_FAILURE :EXIT_SUCCESS ;
Signature · 1 line
2.20.1.791.gb4d0f1c61a-goog
Daniel Borkmann
maintainerQuoted 65 lines · Stanislav Fomichev
Syzbot found out that running
BPF_PROG_TEST_RUNwith repeat=0xffffffff makes process unkillable. The problem is that whenCONFIG_PREEMPTis enabled, we never seeneed_resched()return true. This is due to the fact thatpreempt_enable()(which we do inbpf_test_run_oneon each iteration) now handles resched if it's needed.Let's disable preemption for the whole run, not per test. In this case we can properly see whether resched is needed.
Let's also properly return-EINTRto the userspace in case of a signal interrupt.See recent discussion:
http://lore.kernel.org/netdev/CAH3MdRWHr4N8jei8jxDppXjmw-Nw=puNDLbu1dQOFQHxfU2onA@mail.gmail.comI'll follow up with the same fix
bpf_prog_test_run_flow_dissectorin bpf-next.Reported-by syzbot <[email protected]>Signed-off-by Stanislav Fomichev <[email protected]>--- net/bpf/test_run.c | 45 ++++++++++++++++++++++++--------------------- 1 file changed, 24 insertions(+), 21 deletions(-)net/bpf/test_run.c +6
-17@@ -13,27 +13,13 @@#include <net/sock.h> #include <net/tcp.h> -static __always_inline u32 bpf_test_run_one(struct bpf_prog *prog, void *ctx, -struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE ]) -{ -u32 ret; - -preempt_disable (); -rcu_read_lock (); -bpf_cgroup_storage_set (storage); - ret =BPF_PROG_RUN (prog, ctx); -rcu_read_unlock (); -preempt_enable (); - -return ret; -} - -static int bpf_test_run (struct bpf_prog *prog,void *ctx,u32 repeat,u32 *ret, -u32 *time) +static int bpf_test_run (struct bpf_prog *prog,void *ctx,u32 repeat, +u32 *retval,u32 *time) {struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE ] = {0 };enum bpf_cgroup_storage_type stype;u64 time_start, time_spent =0 ; +int ret =0 ;u32 i;for_each_cgroup_storage_type (stype) {@@ -48,25 +34,42 @@ static int bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat, u32 *ret,if (!repeat) repeat =1 ; + +rcu_read_lock (); +preempt_disable ();
net/bpf/test_run.c static int bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat, u32 *ret, · line 48
Quoted 10 lines
net/bpf/test_run.c +7
-1time_start =ktime_get_ns ();for (i =0 ; i < repeat; i++) { - *ret =bpf_test_run_one (prog, ctx, storage); +bpf_cgroup_storage_set (storage); + *retval =BPF_PROG_RUN (prog, ctx); + +if (signal_pending (current)) { + ret = -EINTR ; +break ; + }
Wouldn't it be enough to just move the signal_pending() test to the above as you did to actually fix the unkillable issue? For CONFIG_PREEMPT the below need_resched() is never triggered as you mention as preempt_enable() handles rescheduling internally in this situation, so moving it only out should suffice.
The rationale for disabling preemption for the whole run is imho a bit different, namely that you would not screw up the ktime measurements due to rescheduling happening in between otherwise.
But then, once preemption is disabled for the whole run, is there a need to move out the extra signal_pending() test (presumably as need_resched() does not handle TIF_SIGPENDING but only TIF_NEED_RESCHED but we still wouldn't get into a unkillable situation here, no)?
Quoted 30 lines
net/bpf/test_run.c +10
-3if (need_resched ()) { -if (signal_pending (current)) -break ; time_spent +=ktime_get_ns () - time_start; +preempt_enable (); +rcu_read_unlock (); +cond_resched (); + +rcu_read_lock (); +preempt_disable (); time_start =ktime_get_ns (); } } time_spent +=ktime_get_ns () - time_start; +preempt_enable (); +rcu_read_unlock (); +do_div (time_spent, repeat); *time = time_spent >U32_MAX ?U32_MAX : (u32 )time_spent;for_each_cgroup_storage_type (stype)bpf_cgroup_storage_free (storage[stype]); -return 0 ; +return ret; } static int bpf_test_finish(const union bpf_attr *kattr,
Quoted 83 lines · Daniel Borkmann
Quoted 65 lines · Stanislav Fomichev
Syzbot found out that running
BPF_PROG_TEST_RUNwith repeat=0xffffffff makes process unkillable. The problem is that whenCONFIG_PREEMPTis enabled, we never seeneed_resched()return true. This is due to the fact thatpreempt_enable()(which we do inbpf_test_run_oneon each iteration) now handles resched if it's needed.Let's disable preemption for the whole run, not per test. In this case we can properly see whether resched is needed.
Let's also properly return-EINTRto the userspace in case of a signal interrupt.See recent discussion:
http://lore.kernel.org/netdev/CAH3MdRWHr4N8jei8jxDppXjmw-Nw=puNDLbu1dQOFQHxfU2onA@mail.gmail.comI'll follow up with the same fix
bpf_prog_test_run_flow_dissectorin bpf-next.Reported-by syzbot <[email protected]>Signed-off-by Stanislav Fomichev <[email protected]>--- net/bpf/test_run.c | 45 ++++++++++++++++++++++++--------------------- 1 file changed, 24 insertions(+), 21 deletions(-)net/bpf/test_run.c +6
-17@@ -13,27 +13,13 @@#include <net/sock.h> #include <net/tcp.h> -static __always_inline u32 bpf_test_run_one(struct bpf_prog *prog, void *ctx, -struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE ]) -{ -u32 ret; - -preempt_disable (); -rcu_read_lock (); -bpf_cgroup_storage_set (storage); - ret =BPF_PROG_RUN (prog, ctx); -rcu_read_unlock (); -preempt_enable (); - -return ret; -} - -static int bpf_test_run (struct bpf_prog *prog,void *ctx,u32 repeat,u32 *ret, -u32 *time) +static int bpf_test_run (struct bpf_prog *prog,void *ctx,u32 repeat, +u32 *retval,u32 *time) {struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE ] = {0 };enum bpf_cgroup_storage_type stype;u64 time_start, time_spent =0 ; +int ret =0 ;u32 i;for_each_cgroup_storage_type (stype) {@@ -48,25 +34,42 @@ static int bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat, u32 *ret,if (!repeat) repeat =1 ; + +rcu_read_lock (); +preempt_disable ();net/bpf/test_run.c static int bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat, u32 *ret, · line 48
Quoted 10 lines
net/bpf/test_run.c +7
-1time_start =ktime_get_ns ();for (i =0 ; i < repeat; i++) { - *ret =bpf_test_run_one (prog, ctx, storage); +bpf_cgroup_storage_set (storage); + *retval =BPF_PROG_RUN (prog, ctx); + +if (signal_pending (current)) { + ret = -EINTR ; +break ; + }Wouldn't it be enough to just move the
signal_pending()test to the above as you did to actually fix the unkillable issue? ForCONFIG_PREEMPTthe belowneed_resched()is never triggered as you mention aspreempt_enable()handles rescheduling internally in this situation, so moving it only out should suffice.
Quoted 3 lines
The rationale for disabling preemption for the whole run is imho a bit different, namely that you would not screw up the ktime measurements due to rescheduling happening in between otherwise.
That's exactly the reason why we need to preempt_disable() the whole run; we can't preempt on preempt_enable(), it would screw up our ktime estimation.
Quoted 4 lines
But then, once preemption is disabled for the whole run, is there a need to move out the extra
signal_pending()test (presumably asneed_resched()does not handleTIF_SIGPENDINGbut onlyTIF_NEED_RESCHEDbut we still wouldn't get into a unkillable situation here, no)?
I'm not sure, they look like two separate flags, it feels safer to handle them separately (and we have a precedent in do_check in verifier.c). While we do set them both when sending signal, it looks like need_resched is for the cases where we wake up a task with a higher priority. So, in theory, we can have a signal_pending without need_resched. (Also, with CONFIG_PREEMT=y kernel, there is another complication with preempt_count()).
Quoted 32 lines
Quoted 31 lines
net/bpf/test_run.c +10
-3if (need_resched ()) { -if (signal_pending (current)) -break ; time_spent +=ktime_get_ns () - time_start; +preempt_enable (); +rcu_read_unlock (); +cond_resched (); + +rcu_read_lock (); +preempt_disable (); time_start =ktime_get_ns (); } } time_spent +=ktime_get_ns () - time_start; +preempt_enable (); +rcu_read_unlock (); +do_div (time_spent, repeat); *time = time_spent >U32_MAX ?U32_MAX : (u32 )time_spent;for_each_cgroup_storage_type (stype)bpf_cgroup_storage_free (storage[stype]); -return 0 ; +return ret; } static int bpf_test_finish(const union bpf_attr *kattr,
Daniel Borkmann
maintainerQuoted 95 lines · Stanislav Fomichev
Quoted 83 lines · Daniel Borkmann
Quoted 65 lines · Stanislav Fomichev
Syzbot found out that running
BPF_PROG_TEST_RUNwith repeat=0xffffffff makes process unkillable. The problem is that whenCONFIG_PREEMPTis enabled, we never seeneed_resched()return true. This is due to the fact thatpreempt_enable()(which we do inbpf_test_run_oneon each iteration) now handles resched if it's needed.Let's disable preemption for the whole run, not per test. In this case we can properly see whether resched is needed.
Let's also properly return-EINTRto the userspace in case of a signal interrupt.See recent discussion:
http://lore.kernel.org/netdev/CAH3MdRWHr4N8jei8jxDppXjmw-Nw=puNDLbu1dQOFQHxfU2onA@mail.gmail.comI'll follow up with the same fix
bpf_prog_test_run_flow_dissectorin bpf-next.Reported-by syzbot <[email protected]>Signed-off-by Stanislav Fomichev <[email protected]>--- net/bpf/test_run.c | 45 ++++++++++++++++++++++++--------------------- 1 file changed, 24 insertions(+), 21 deletions(-)net/bpf/test_run.c +6
-17@@ -13,27 +13,13 @@#include <net/sock.h> #include <net/tcp.h> -static __always_inline u32 bpf_test_run_one(struct bpf_prog *prog, void *ctx, -struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE ]) -{ -u32 ret; - -preempt_disable (); -rcu_read_lock (); -bpf_cgroup_storage_set (storage); - ret =BPF_PROG_RUN (prog, ctx); -rcu_read_unlock (); -preempt_enable (); - -return ret; -} - -static int bpf_test_run (struct bpf_prog *prog,void *ctx,u32 repeat,u32 *ret, -u32 *time) +static int bpf_test_run (struct bpf_prog *prog,void *ctx,u32 repeat, +u32 *retval,u32 *time) {struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE ] = {0 };enum bpf_cgroup_storage_type stype;u64 time_start, time_spent =0 ; +int ret =0 ;u32 i;for_each_cgroup_storage_type (stype) {@@ -48,25 +34,42 @@ static int bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat, u32 *ret,if (!repeat) repeat =1 ; + +rcu_read_lock (); +preempt_disable ();net/bpf/test_run.c static int bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat, u32 *ret, · line 48
Quoted 10 lines
net/bpf/test_run.c +7
-1time_start =ktime_get_ns ();for (i =0 ; i < repeat; i++) { - *ret =bpf_test_run_one (prog, ctx, storage); +bpf_cgroup_storage_set (storage); + *retval =BPF_PROG_RUN (prog, ctx); + +if (signal_pending (current)) { + ret = -EINTR ; +break ; + }Wouldn't it be enough to just move the
signal_pending()test to the above as you did to actually fix the unkillable issue? ForCONFIG_PREEMPTthe belowneed_resched()is never triggered as you mention aspreempt_enable()handles rescheduling internally in this situation, so moving it only out should suffice.Quoted 3 lines
The rationale for disabling preemption for the whole run is imho a bit different, namely that you would not screw up the ktime measurements due to rescheduling happening in between otherwise.
That's exactly the reason why we need to
preempt_disable()the whole run; we can't preempt onpreempt_enable(), it would screw up our ktime estimation.Quoted 4 lines
But then, once preemption is disabled for the whole run, is there a need to move out the extra
signal_pending()test (presumably asneed_resched()does not handleTIF_SIGPENDINGbut onlyTIF_NEED_RESCHEDbut we still wouldn't get into a unkillable situation here, no)?
Quoted 7 lines
I'm not sure, they look like two separate flags, it feels safer to handle them separately (and we have a precedent in
do_checkinverifier.c). While we do set them both when sending signal, it looks likeneed_reschedis for the cases where we wake up a task with a higher priority. So, in theory, we can have asignal_pendingwithoutneed_resched. (Also, withCONFIG_PREEMT=ykernel, there is another complication withpreempt_count()).
Yeah, given there is no separation, it's better to move it out, agree. Applied both, thanks!
Quoted 31 lines
Quoted 31 lines
Quoted 30 lines
net/bpf/test_run.c +10
-3if (need_resched ()) { -if (signal_pending (current)) -break ; time_spent +=ktime_get_ns () - time_start; +preempt_enable (); +rcu_read_unlock (); +cond_resched (); + +rcu_read_lock (); +preempt_disable (); time_start =ktime_get_ns (); } } time_spent +=ktime_get_ns () - time_start; +preempt_enable (); +rcu_read_unlock (); +do_div (time_spent, repeat); *time = time_spent >U32_MAX ?U32_MAX : (u32 )time_spent;for_each_cgroup_storage_type (stype)bpf_cgroup_storage_free (storage[stype]); -return 0 ; +return ret; } static int bpf_test_finish(const union bpf_attr *kattr,