From patchwork Mon May 6 23:50:14 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Colin Cross X-Patchwork-Id: 2529001 Return-Path: X-Original-To: patchwork-linux-pm@patchwork.kernel.org Delivered-To: patchwork-process-083081@patchwork2.kernel.org Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by patchwork2.kernel.org (Postfix) with ESMTP id 562A6DFB79 for ; Mon, 6 May 2013 23:53:59 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S933013Ab3EFXxm (ORCPT ); Mon, 6 May 2013 19:53:42 -0400 Received: from mail-gg0-f201.google.com ([209.85.161.201]:50725 "EHLO mail-gg0-f201.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932347Ab3EFXua (ORCPT ); Mon, 6 May 2013 19:50:30 -0400 Received: by mail-gg0-f201.google.com with SMTP id k25so424974ggl.0 for ; Mon, 06 May 2013 16:50:28 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20120113; h=x-received:from:to:cc:subject:date:message-id:x-mailer:in-reply-to :references:x-gm-message-state; bh=EzeB8cvADFVhXwHNdGBg4GHa9rWWJqxZ6l6jwTX9y+s=; b=UJXkAhmT5G6gRWOFu7DWpw5YEizsEWJjRiLFHRmsRhfuU6nTCnHRa7Nh5+/uSkFFXT ivhFAk6wkyP57ksI81rPttmo2bmexDQHhKfxGayTkv3dXWdH1TgwFln9vL5+BNPpEqwg SENQ+eVHHCm/nivfFepg8cI83Z301dnjijJ3mlYWDllUg78nLjjIpJ/Clnu3ah4+pUEr gHduaAH9W9SLAPbMbgcQETreh27MXlwdqQxuhF8QzkBu2epH+WwBA8uGZIW1fg6GpcC3 74UmvJjCTwXrnf7t3EFt5upRrlB8jsBRzvFgB5sgqPWvMUtkcpnCtgQux47roFeaROUD 5O5A== X-Received: by 10.236.19.198 with SMTP id n46mr17242776yhn.8.1367884228322; Mon, 06 May 2013 16:50:28 -0700 (PDT) Received: from corp2gmr1-1.hot.corp.google.com (corp2gmr1-1.hot.corp.google.com [172.24.189.92]) by gmr-mx.google.com with ESMTPS id q46si2639812yhh.4.2013.05.06.16.50.28 for (version=TLSv1.1 cipher=AES128-SHA bits=128/128); Mon, 06 May 2013 16:50:28 -0700 (PDT) Received: from walnut.mtv.corp.google.com (walnut.mtv.corp.google.com [172.18.105.48]) by corp2gmr1-1.hot.corp.google.com (Postfix) with ESMTP id 1A9B931C078; Mon, 6 May 2013 16:50:28 -0700 (PDT) Received: by walnut.mtv.corp.google.com (Postfix, from userid 99897) id EF95A16078C; Mon, 6 May 2013 16:50:27 -0700 (PDT) From: Colin Cross To: linux-kernel@vger.kernel.org Cc: Pavel Machek , "Rafael J. Wysocki" , Peter Zijlstra , Ingo Molnar , Andrew Morton , Mandeep Singh Baines , Colin Cross , Oleg Nesterov , linux-nfs@vger.kernel.org, linux-pm@vger.kernel.org, netdev@vger.kernel.org, Linus Torvalds , Tejun Heo , Len Brown Subject: [PATCH v3 09/16] freezer: add new freezable helpers using freezer_do_not_count() Date: Mon, 6 May 2013 16:50:14 -0700 Message-Id: <1367884221-20462-10-git-send-email-ccross@android.com> X-Mailer: git-send-email 1.8.2.1 In-Reply-To: <1367884221-20462-1-git-send-email-ccross@android.com> References: <1367884221-20462-1-git-send-email-ccross@android.com> X-Gm-Message-State: ALoCoQmhVtg/Gsh4/HH5oHCjcfPTcHtJs5nLPc0C2QCoe1nxXeg8K+B977g4e8mJ3rgB6gEpVLu3Qq9EUlFYou0o3Mp9GFUEvUgdm0y0dyVzUJEF+MWvrWBuGq5/XQwMuf1r+9VTuRx91e4z0bpNV7Ujdq1svM9Kpt+yMTDHKfyWwzIVLJAVRXZmVz/wCfWtJoM0O9oxhm1k Sender: linux-pm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pm@vger.kernel.org Freezing tasks will wake up almost every userspace task from where it is blocking and force it to run until it hits a call to try_to_sleep(), generally on the exit path from the syscall it is blocking in. On resume each task will run again, usually restarting the syscall and running until it hits the same blocking call as it was originally blocked in. To allow tasks to avoid running on every suspend/resume cycle, this patch adds additional freezable wrappers around blocking calls that call freezer_do_not_count(). Combined with the previous patch, these tasks will not run during suspend or resume unless they wake up for another reason, in which case they will run until they hit the try_to_freeze() in freezer_count(), and then continue processing the wakeup after tasks are thawed. Additional patches will convert the most common locations that userspace blocks in to use freezable helpers. Signed-off-by: Colin Cross --- v3: split out the changes to existing helpers to a separate patch include/linux/freezer.h | 61 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) diff --git a/include/linux/freezer.h b/include/linux/freezer.h index 8430d4c5..7fd81b8 100644 --- a/include/linux/freezer.h +++ b/include/linux/freezer.h @@ -180,6 +180,32 @@ static inline void freezable_schedule_unsafe(void) freezer_count_unsafe(); } +/* + * Like freezable_schedule_timeout(), but should not block the freezer. Do not + * call this with locks held. + */ +static inline long freezable_schedule_timeout(long timeout) +{ + long __retval; + freezer_do_not_count(); + __retval = schedule_timeout(timeout); + freezer_count(); + return __retval; +} + +/* + * Like schedule_timeout_interruptible(), but should not block the freezer. Do not + * call this with locks held. + */ +static inline long freezable_schedule_timeout_interruptible(long timeout) +{ + long __retval; + freezer_do_not_count(); + __retval = schedule_timeout_interruptible(timeout); + freezer_count(); + return __retval; +} + /* Like schedule_timeout_killable(), but should not block the freezer. */ static inline long freezable_schedule_timeout_killable(long timeout) { @@ -201,6 +227,20 @@ static inline long freezable_schedule_timeout_killable_unsafe(long timeout) } /* + * Like schedule_hrtimeout_range(), but should not block the freezer. Do not + * call this with locks held. + */ +static inline int freezable_schedule_hrtimeout_range(ktime_t *expires, + unsigned long delta, const enum hrtimer_mode mode) +{ + int __retval; + freezer_do_not_count(); + __retval = schedule_hrtimeout_range(expires, delta, mode); + freezer_count(); + return __retval; +} + +/* * Freezer-friendly wrappers around wait_event_interruptible(), * wait_event_killable() and wait_event_interruptible_timeout(), originally * defined in @@ -244,6 +284,16 @@ static inline long freezable_schedule_timeout_killable_unsafe(long timeout) __retval; \ }) +#define wait_event_freezable_exclusive(wq, condition) \ +({ \ + int __retval; \ + freezer_do_not_count(); \ + __retval = wait_event_interruptible_exclusive(wq, condition); \ + freezer_count(); \ + __retval; \ +}) + + #else /* !CONFIG_FREEZER */ static inline bool frozen(struct task_struct *p) { return false; } static inline bool freezing(struct task_struct *p) { return false; } @@ -267,18 +317,29 @@ static inline void set_freezable(void) {} #define freezable_schedule_unsafe() schedule() +#define freezable_schedule_timeout(timeout) schedule_timeout(timeout) + +#define freezable_schedule_timeout_interruptible(timeout) \ + schedule_timeout_interruptible(timeout) + #define freezable_schedule_timeout_killable(timeout) \ schedule_timeout_killable(timeout) #define freezable_schedule_timeout_killable_unsafe(timeout) \ schedule_timeout_killable(timeout) +#define freezable_schedule_hrtimeout_range(expires, delta, mode) \ + schedule_hrtimeout_range(expires, delta, mode) + #define wait_event_freezable(wq, condition) \ wait_event_interruptible(wq, condition) #define wait_event_freezable_timeout(wq, condition, timeout) \ wait_event_interruptible_timeout(wq, condition, timeout) +#define wait_event_freezable_exclusive(wq, condition) \ + wait_event_interruptible_exclusive(wq, condition) + #define wait_event_freezekillable(wq, condition) \ wait_event_killable(wq, condition)