From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755566AbbLKLbK (ORCPT ); Fri, 11 Dec 2015 06:31:10 -0500 Received: from mail-wm0-f49.google.com ([74.125.82.49]:34171 "EHLO mail-wm0-f49.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755122AbbLKLbF (ORCPT ); Fri, 11 Dec 2015 06:31:05 -0500 MIME-Version: 1.0 In-Reply-To: <20151210130948.GW6356@twins.programming.kicks-ass.net> References: <20151201130404.GL3816@twins.programming.kicks-ass.net> <20151208104712.GJ6356@twins.programming.kicks-ass.net> <87zixkph0m.fsf@notabene.neil.brown.name> <20151209074033.GF6357@twins.programming.kicks-ass.net> <87si3bpaxy.fsf@notabene.neil.brown.name> <20151210130948.GW6356@twins.programming.kicks-ass.net> From: Paul Turner Date: Fri, 11 Dec 2015 03:30:33 -0800 Message-ID: Subject: Re: [tip:locking/core] sched/wait: Fix signal handling in bit wait helpers To: Peter Zijlstra Cc: NeilBrown , Linus Torvalds , Thomas Gleixner , LKML , Mike Galbraith , Ingo Molnar , Peter Anvin , vladimir.murzin@arm.com, linux-tip-commits@vger.kernel.org, jstancek@redhat.com, Oleg Nesterov Content-Type: text/plain; charset=UTF-8 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Thu, Dec 10, 2015 at 5:09 AM, Peter Zijlstra wrote: > On Thu, Dec 10, 2015 at 08:30:01AM +1100, NeilBrown wrote: >> On Wed, Dec 09 2015, Peter Zijlstra wrote: >> >> > On Wed, Dec 09, 2015 at 12:06:33PM +1100, NeilBrown wrote: >> >> On Tue, Dec 08 2015, Peter Zijlstra wrote: >> >> >> >> >> >> >> > >> >> > *sigh*, so that patch was broken.. the below might fix it, but please >> >> > someone look at it, I seem to have a less than stellar track record >> >> > here... >> >> >> >> This new change seems to be more intrusive than should be needed. >> >> Can't we just do: >> >> >> >> >> >> __sched int bit_wait(struct wait_bit_key *word) >> >> { >> >> + long state = current->state; >> > >> > No, current->state can already be changed by this time. >> >> Does that matter? >> It can only have changed to TASK_RUNNING - right? >> In that case signal_pending_state() will return 0 and the bit_wait() acts >> as though the thread was woken up normally (which it was) rather than by >> a signal (which maybe it was too, but maybe that happened just a tiny >> bit later). >> >> As long as signal delivery doesn't change ->state, we should be safe. >> We should even be safe testing ->state *after* the call the schedule(). > > Blergh, all I've managed to far is to confuse myself further. Even > something like the original (+- the EINTR) should work when we consider > the looping, even when mixed with an occasional spurious wakeup. > > > int bit_wait() > { > if (signal_pending_state(current->state, current)) > return -EINTR; > schedule(); > } > > > This can go wrong against raising a signal thusly: > > prepare_to_wait() > 1: if (signal_pending_state(current->state, current)) > // false, nothing pending > schedule(); > set_tsk_thread_flag(t, TIF_SIGPENDING); > > > > prepare_to_wait() > wake_up_state(t, ...); > 2: if (signal_pending_state(current->state, current)) > // false, TASK_RUNNING > > schedule(); // doesn't block because pending Note that a quick inspection does not turn up _any_ TASK_INTERRUPTIBLE callers. When this previously occurred, it could likely only be with a fatal signal, which would have hidden these sins. > > prepare_to_wait() > 3: if (signal_pending_state(current->state, current)) > // true, pending > Hugh asked me about this after seeing a crash, here's another exciting way in which the current code breaks -- this one actually quite serious: Consider __lock_page: void __lock_page(struct page *page) { DEFINE_WAIT_BIT(wait, &page->flags, PG_locked); __wait_on_bit_lock(page_waitqueue(page), &wait, bit_wait_io, TASK_UNINTERRUPTIBLE); } With the current state of the world, __sched int bit_wait_io(struct wait_bit_key *word) { - if (signal_pending_state(current->state, current)) - return 1; io_schedule(); + if (signal_pending(current)) + return -EINTR; return 0; } Called from __wait_on_bit_lock. Previously, signal_pending_state() was checked under TASK_UNINTERRUPTIBLE (via prepare_to_wait_exclusive). Now, we simply check for the presence of any signal -- after we have returned to running state, e.g. post io_schedule() when somebody has kicked the wait-queue. However, this now means that _wait_on_bit_lock can return -EINTR up to __lock_page; which does not validate the return code and blindly returns. This looks to have been a previously existing bug, but it was at least masked by the fact that it required a fatal signal previously (and that the page we return unlocked is likely going to be freed from the dying process anyway). Peter's proposed follow-up above looks strictly more correct. We need to evaluate the potential existence of a signal, *after* we return from schedule, but in the context of the state which we previously _entered_ schedule() on. Reviewed-by: Paul Turner > > -- > To unsubscribe from this list: send the line "unsubscribe linux-kernel" in > the body of a message to majordomo@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html > Please read the FAQ at http://www.tux.org/lkml/