From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id DC57BC43381 for ; Sat, 16 Feb 2019 01:33:38 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id B5EB9222D0 for ; Sat, 16 Feb 2019 01:33:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1732602AbfBPBdh (ORCPT ); Fri, 15 Feb 2019 20:33:37 -0500 Received: from www62.your-server.de ([213.133.104.62]:37154 "EHLO www62.your-server.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730194AbfBPBdh (ORCPT ); Fri, 15 Feb 2019 20:33:37 -0500 Received: from [78.46.172.2] (helo=sslproxy05.your-server.de) by www62.your-server.de with esmtpsa (TLSv1.2:DHE-RSA-AES256-GCM-SHA384:256) (Exim 4.89_1) (envelope-from ) id 1guobG-0005oP-KA; Sat, 16 Feb 2019 02:17:02 +0100 Received: from [178.197.248.36] (helo=linux.home) by sslproxy05.your-server.de with esmtpsa (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.89) (envelope-from ) id 1guobG-000KOO-D3; Sat, 16 Feb 2019 02:17:02 +0100 Subject: Re: [PATCH bpf 1/2] bpf/test_run: fix unkillable BPF_PROG_TEST_RUN To: Stanislav Fomichev , netdev@vger.kernel.org Cc: davem@davemloft.net, ast@kernel.org, syzbot References: <20190212234239.174386-1-sdf@google.com> From: Daniel Borkmann Message-ID: <74457479-d54c-69fa-958a-3cfb1ee9e5a2@iogearbox.net> Date: Sat, 16 Feb 2019 02:17:01 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.3.0 MIME-Version: 1.0 In-Reply-To: <20190212234239.174386-1-sdf@google.com> Content-Type: text/plain; charset=utf-8 Content-Language: en-US Content-Transfer-Encoding: 7bit X-Authenticated-Sender: daniel@iogearbox.net X-Virus-Scanned: Clear (ClamAV 0.100.2/25361/Fri Feb 15 12:07:11 2019) Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org On 02/13/2019 12:42 AM, Stanislav Fomichev wrote: > 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. > > Reported-by: syzbot > Signed-off-by: Stanislav Fomichev > --- > net/bpf/test_run.c | 45 ++++++++++++++++++++++++--------------------- > 1 file changed, 24 insertions(+), 21 deletions(-) > > diff --git a/net/bpf/test_run.c b/net/bpf/test_run.c > index fa2644d276ef..e31e1b20f7f4 100644 > --- a/net/bpf/test_run.c > +++ b/net/bpf/test_run.c > @@ -13,27 +13,13 @@ > #include > #include > > -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; > + } 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)? > 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, >