From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752428AbdANMug (ORCPT ); Sat, 14 Jan 2017 07:50:36 -0500 Received: from terminus.zytor.com ([198.137.202.10]:52278 "EHLO terminus.zytor.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752221AbdANMue (ORCPT ); Sat, 14 Jan 2017 07:50:34 -0500 Date: Sat, 14 Jan 2017 04:49:57 -0800 From: tip-bot for Tejun Heo Message-ID: Cc: torvalds@linux-foundation.org, peterz@infradead.org, tj@kernel.org, mingo@kernel.org, tglx@linutronix.de, efault@gmx.de, hpa@zytor.com, akpm@linux-foundation.org, linux-kernel@vger.kernel.org, axboe@kernel.dk Reply-To: akpm@linux-foundation.org, axboe@kernel.dk, linux-kernel@vger.kernel.org, hpa@zytor.com, mingo@kernel.org, efault@gmx.de, tglx@linutronix.de, torvalds@linux-foundation.org, tj@kernel.org, peterz@infradead.org In-Reply-To: <1477673892-28940-3-git-send-email-tj@kernel.org> References: <1477673892-28940-3-git-send-email-tj@kernel.org> To: linux-tip-commits@vger.kernel.org Subject: [tip:sched/core] sched/core: Separate out io_schedule_prepare() and io_schedule_finish() Git-Commit-ID: 10ab56434f2f633a51e432ee8b7c29e12438e163 X-Mailer: tip-git-log-daemon Robot-ID: Robot-Unsubscribe: Contact to get blacklisted from these emails MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset=UTF-8 Content-Disposition: inline Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Commit-ID: 10ab56434f2f633a51e432ee8b7c29e12438e163 Gitweb: http://git.kernel.org/tip/10ab56434f2f633a51e432ee8b7c29e12438e163 Author: Tejun Heo AuthorDate: Fri, 28 Oct 2016 12:58:10 -0400 Committer: Ingo Molnar CommitDate: Sat, 14 Jan 2017 11:30:04 +0100 sched/core: Separate out io_schedule_prepare() and io_schedule_finish() Now that IO schedule accounting is done inside __schedule(), io_schedule() can be split into three steps - prep, schedule, and finish - where the schedule part doesn't need any special annotation. This allows marking a sleep as iowait by simply wrapping an existing blocking function with io_schedule_prepare() and io_schedule_finish(). Because task_struct->in_iowait is single bit, the caller of io_schedule_prepare() needs to record and the pass its state to io_schedule_finish() to be safe regarding nesting. While this isn't the prettiest, these functions are mostly gonna be used by core functions and we don't want to use more space for ->in_iowait. While at it, as it's simple to do now, reimplement io_schedule() without unnecessarily going through io_schedule_timeout(). Signed-off-by: Tejun Heo Signed-off-by: Peter Zijlstra (Intel) Cc: Andrew Morton Cc: Jens Axboe Cc: Linus Torvalds Cc: Mike Galbraith Cc: Peter Zijlstra Cc: Thomas Gleixner Cc: adilger.kernel@dilger.ca Cc: jack@suse.com Cc: kernel-team@fb.com Cc: mingbo@fb.com Cc: tytso@mit.edu Link: http://lkml.kernel.org/r/1477673892-28940-3-git-send-email-tj@kernel.org Signed-off-by: Ingo Molnar --- include/linux/sched.h | 8 +++----- kernel/sched/core.c | 33 ++++++++++++++++++++++++++++----- 2 files changed, 31 insertions(+), 10 deletions(-) diff --git a/include/linux/sched.h b/include/linux/sched.h index 94a48bb..a8daed9 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -461,12 +461,10 @@ extern signed long schedule_timeout_idle(signed long timeout); asmlinkage void schedule(void); extern void schedule_preempt_disabled(void); +extern int __must_check io_schedule_prepare(void); +extern void io_schedule_finish(int token); extern long io_schedule_timeout(long timeout); - -static inline void io_schedule(void) -{ - io_schedule_timeout(MAX_SCHEDULE_TIMEOUT); -} +extern void io_schedule(void); void __noreturn do_task_dead(void); diff --git a/kernel/sched/core.c b/kernel/sched/core.c index 9fd3716..49ce1cb 100644 --- a/kernel/sched/core.c +++ b/kernel/sched/core.c @@ -5128,25 +5128,48 @@ out_irq: } EXPORT_SYMBOL_GPL(yield_to); +int io_schedule_prepare(void) +{ + int old_iowait = current->in_iowait; + + current->in_iowait = 1; + blk_schedule_flush_plug(current); + + return old_iowait; +} + +void io_schedule_finish(int token) +{ + current->in_iowait = token; +} + /* * This task is about to go to sleep on IO. Increment rq->nr_iowait so * that process accounting knows that this is a task in IO wait state. */ long __sched io_schedule_timeout(long timeout) { - int old_iowait = current->in_iowait; + int token; long ret; - current->in_iowait = 1; - blk_schedule_flush_plug(current); - + token = io_schedule_prepare(); ret = schedule_timeout(timeout); - current->in_iowait = old_iowait; + io_schedule_finish(token); return ret; } EXPORT_SYMBOL(io_schedule_timeout); +void io_schedule(void) +{ + int token; + + token = io_schedule_prepare(); + schedule(); + io_schedule_finish(token); +} +EXPORT_SYMBOL(io_schedule); + /** * sys_sched_get_priority_max - return maximum RT priority. * @policy: scheduling class.