From patchwork Thu May 2 01:35:01 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Colin Cross X-Patchwork-Id: 2509671 Return-Path: X-Original-To: patchwork-linux-pm@patchwork.kernel.org Delivered-To: patchwork-process-083081@patchwork1.kernel.org Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by patchwork1.kernel.org (Postfix) with ESMTP id 6D68D3FC5A for ; Thu, 2 May 2013 01:36:35 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1758941Ab3EBBfV (ORCPT ); Wed, 1 May 2013 21:35:21 -0400 Received: from mail-vc0-f202.google.com ([209.85.220.202]:59185 "EHLO mail-vc0-f202.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1758805Ab3EBBfR (ORCPT ); Wed, 1 May 2013 21:35:17 -0400 Received: by mail-vc0-f202.google.com with SMTP id gf12so14352vcb.3 for ; Wed, 01 May 2013 18:35:15 -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=8QzgB+fdpWDfKaWCi2H9dxu77BpOLnOG6UY0dhlUQ0s=; b=Ivee4cH8BwGNEnJNmPZHq5IYvoJax0r/HqUDtYjCU7W4z3+uIhKC3bGQTpbLsGy3CE Q4tii8Mn0PsqHMAaYpGIhAj894/gYzLoQSMPMSfKhz3DepLxsY7TFp+D09sR4RITDPZ7 S/9JT7MBzHRqQQgIauRc+iRPW9K/IK6XW9L6EGNcZPtjmdX8Ki7fa2K3uxzx2n/rLJ1m v5GLCx0tb8RCvfPnx5C7hylVL/bLdnnPwQ9sFaUfpPSegkkdu4+JlP2HQW2KdAtRR6TX QNDJlxJ+X7h3MLuG7cO0RaNpcdB84sje4x+yZNdXWMto8/Lr7QpdBTqq7+yHrToTScQ8 i9cg== X-Received: by 10.236.29.80 with SMTP id h56mr3638990yha.38.1367458515675; Wed, 01 May 2013 18:35:15 -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 q46si398627yhh.4.2013.05.01.18.35.15 for (version=TLSv1.1 cipher=AES128-SHA bits=128/128); Wed, 01 May 2013 18:35:15 -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 7145031C042; Wed, 1 May 2013 18:35:15 -0700 (PDT) Received: by walnut.mtv.corp.google.com (Postfix, from userid 99897) id 23CC1160D29; Wed, 1 May 2013 18:35:15 -0700 (PDT) From: Colin Cross To: linux-pm@vger.kernel.org Cc: linux-kernel@vger.kernel.org, "Rafael J. Wysocki" , arve@android.com, Tejun Heo , Oleg Nesterov , Colin Cross , Len Brown , Pavel Machek Subject: [PATCH v2 03/10] freezer: add new freezable helpers using freezer_do_not_count() Date: Wed, 1 May 2013 18:35:01 -0700 Message-Id: <1367458508-9133-4-git-send-email-ccross@android.com> X-Mailer: git-send-email 1.8.2.1 In-Reply-To: <1367458508-9133-1-git-send-email-ccross@android.com> References: <1367458508-9133-1-git-send-email-ccross@android.com> X-Gm-Message-State: ALoCoQkE5dDemyJnzLABFHLN+VOf3HsUru/uLVQwhT850J3YBVM0UY1ZY+QyAhcPb9wapYhZfIp74W2NVqZ6iQ3FTlfDcj4CATRftlrWjAMGZmYmMYhxH1BkgQbM8MIhjIGGxNmR7CqhU34Xxjs1jdCfsIY0XmrWhok+puCrc/o2AwK5Fi9D80UvCS1xw89vPVyBuzr+sMv4 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. This patch also converts the existing wait_event_freezable* wrappers to use freezer_do_not_count(). Additional patches will convert the most common locations that userspace blocks in to use freezable helpers. Signed-off-by: Colin Cross --- include/linux/freezer.h | 72 +++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 58 insertions(+), 14 deletions(-) diff --git a/include/linux/freezer.h b/include/linux/freezer.h index e70df40..b239f45 100644 --- a/include/linux/freezer.h +++ b/include/linux/freezer.h @@ -152,6 +152,26 @@ static inline bool freezer_should_skip(struct task_struct *p) freezer_count(); \ }) +/* Like schedule_timeout(), but should not block the freezer. */ +#define freezable_schedule_timeout(timeout) \ +({ \ + long __retval; \ + freezer_do_not_count(); \ + __retval = schedule_timeout(timeout); \ + freezer_count(); \ + __retval; \ +}) + +/* Like schedule_timeout_interruptible(), but should not block the freezer. */ +#define freezable_schedule_timeout_interruptible(timeout) \ +({ \ + long __retval; \ + freezer_do_not_count(); \ + __retval = schedule_timeout_interruptible(timeout); \ + freezer_count(); \ + __retval; \ +}) + /* Like schedule_timeout_killable(), but should not block the freezer. */ #define freezable_schedule_timeout_killable(timeout) \ ({ \ @@ -162,6 +182,17 @@ static inline bool freezer_should_skip(struct task_struct *p) __retval; \ }) +/* Like schedule_hrtimeout_range(), but should not block the freezer. */ +#define freezable_schedule_hrtimeout_range(expires, delta, mode) \ +({ \ + int __retval; \ + freezer_do_not_count(); \ + __retval = schedule_hrtimeout_range(expires, delta, mode); \ + freezer_count(); \ + __retval; \ +}) + + /* * Freezer-friendly wrappers around wait_event_interruptible(), * wait_event_killable() and wait_event_interruptible_timeout(), originally @@ -180,30 +211,32 @@ static inline bool freezer_should_skip(struct task_struct *p) #define wait_event_freezable(wq, condition) \ ({ \ int __retval; \ - for (;;) { \ - __retval = wait_event_interruptible(wq, \ - (condition) || freezing(current)); \ - if (__retval || (condition)) \ - break; \ - try_to_freeze(); \ - } \ + freezer_do_not_count(); \ + __retval = wait_event_interruptible(wq, (condition)); \ + freezer_count(); \ __retval; \ }) #define wait_event_freezable_timeout(wq, condition, timeout) \ ({ \ long __retval = timeout; \ - for (;;) { \ - __retval = wait_event_interruptible_timeout(wq, \ - (condition) || freezing(current), \ + freezer_do_not_count(); \ + __retval = wait_event_interruptible_timeout(wq, (condition), \ __retval); \ - if (__retval <= 0 || (condition)) \ - break; \ - try_to_freeze(); \ - } \ + freezer_count(); \ __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; } @@ -225,15 +258,26 @@ static inline void set_freezable(void) {} #define freezable_schedule() 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_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)