linux-nfs.vger.kernel.org archive mirror
 help / color / mirror / Atom feed
* [PATCH] sunrpc/nfs: don't allow TASK_KILLABLE sleeps to block the freezer
@ 2011-12-01 21:33 Jeff Layton
  2011-12-01 21:52 ` Rafael J. Wysocki
  0 siblings, 1 reply; 4+ messages in thread
From: Jeff Layton @ 2011-12-01 21:33 UTC (permalink / raw)
  To: rjw
  Cc: linux-kernel, linux-nfs, linux-pm, tj, john, trond.myklebust,
	marek.belisko, awilliam

Allow the freezer to skip wait_on_bit_killable sleeps in the sunrpc
layer. This should allow suspend and hibernate events to proceed, even
when there are RPC's pending on the wire.

Also, wrap the TASK_KILLABLE sleeps in NFS layer in freezer_do_not_count
and freezer_count calls. This allows the freezer to skip tasks that are
sleeping while looping on EJUKEBOX or NFS4ERR_DELAY sorts of errors.

Rafael, I've gone ahead and combined the two patches into one here
and rebased this on top of the pm-freezer branch. Let me know if you'd
prefer to keep it as two patches.

Signed-off-by: Jeff Layton <jlayton@redhat.com>
---
 fs/nfs/inode.c          |    3 ++-
 fs/nfs/nfs3proc.c       |    3 ++-
 fs/nfs/nfs4proc.c       |    5 +++--
 fs/nfs/proc.c           |    3 ++-
 include/linux/freezer.h |   28 ++++++++++++++++++++++++++++
 net/sunrpc/sched.c      |    3 ++-
 6 files changed, 39 insertions(+), 6 deletions(-)

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 50a15fa..bf3a57b 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -38,6 +38,7 @@
 #include <linux/nfs_xdr.h>
 #include <linux/slab.h>
 #include <linux/compat.h>
+#include <linux/freezer.h>
 
 #include <asm/system.h>
 #include <asm/uaccess.h>
@@ -77,7 +78,7 @@ int nfs_wait_bit_killable(void *word)
 {
 	if (fatal_signal_pending(current))
 		return -ERESTARTSYS;
-	schedule();
+	freezable_schedule();
 	return 0;
 }
 
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index d4bc9ed9..9194395 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -17,6 +17,7 @@
 #include <linux/nfs_page.h>
 #include <linux/lockd/bind.h>
 #include <linux/nfs_mount.h>
+#include <linux/freezer.h>
 
 #include "iostat.h"
 #include "internal.h"
@@ -32,7 +33,7 @@ nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
 		res = rpc_call_sync(clnt, msg, flags);
 		if (res != -EJUKEBOX && res != -EKEYEXPIRED)
 			break;
-		schedule_timeout_killable(NFS_JUKEBOX_RETRY_TIME);
+		freezable_schedule_timeout_killable(NFS_JUKEBOX_RETRY_TIME);
 		res = -ERESTARTSYS;
 	} while (!fatal_signal_pending(current));
 	return res;
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index be2bbac..b28bb19 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -53,6 +53,7 @@
 #include <linux/sunrpc/bc_xprt.h>
 #include <linux/xattr.h>
 #include <linux/utsname.h>
+#include <linux/freezer.h>
 
 #include "nfs4_fs.h"
 #include "delegation.h"
@@ -241,7 +242,7 @@ static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
 		*timeout = NFS4_POLL_RETRY_MIN;
 	if (*timeout > NFS4_POLL_RETRY_MAX)
 		*timeout = NFS4_POLL_RETRY_MAX;
-	schedule_timeout_killable(*timeout);
+	freezable_schedule_timeout_killable(*timeout);
 	if (fatal_signal_pending(current))
 		res = -ERESTARTSYS;
 	*timeout <<= 1;
@@ -3950,7 +3951,7 @@ int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4
 static unsigned long
 nfs4_set_lock_task_retry(unsigned long timeout)
 {
-	schedule_timeout_killable(timeout);
+	freezable_schedule_timeout_killable(timeout);
 	timeout <<= 1;
 	if (timeout > NFS4_LOCK_MAXTIMEOUT)
 		return NFS4_LOCK_MAXTIMEOUT;
diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
index f48125d..0c672588 100644
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
@@ -41,6 +41,7 @@
 #include <linux/nfs_fs.h>
 #include <linux/nfs_page.h>
 #include <linux/lockd/bind.h>
+#include <linux/freezer.h>
 #include "internal.h"
 
 #define NFSDBG_FACILITY		NFSDBG_PROC
@@ -59,7 +60,7 @@ nfs_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
 		res = rpc_call_sync(clnt, msg, flags);
 		if (res != -EKEYEXPIRED)
 			break;
-		schedule_timeout_killable(NFS_JUKEBOX_RETRY_TIME);
+		freezable_schedule_timeout_killable(NFS_JUKEBOX_RETRY_TIME);
 		res = -ERESTARTSYS;
 	} while (!fatal_signal_pending(current));
 	return res;
diff --git a/include/linux/freezer.h b/include/linux/freezer.h
index c1ee283..30f06c2 100644
--- a/include/linux/freezer.h
+++ b/include/linux/freezer.h
@@ -105,6 +105,29 @@ static inline int freezer_should_skip(struct task_struct *p)
 }
 
 /*
+ * These macros are intended to be used whenever you want allow a task that's
+ * sleeping in TASK_UNINTERRUPTIBLE or TASK_KILLABLE state to be frozen. Note
+ * that neither return any clear indication of whether a freeze event happened
+ * while in this function.
+ */
+
+/* Like schedule(), but should not block the freezer. */
+#define freezable_schedule()						\
+({									\
+	freezer_do_not_count();						\
+	schedule();							\
+	freezer_count();						\
+})
+
+/* Like schedule_timeout_killable(), but should not block the freezer. */
+#define freezable_schedule_timeout_killable(timeout)			\
+({									\
+	freezer_do_not_count();						\
+	schedule_timeout_killable(timeout);				\
+	freezer_count();						\
+})
+
+/*
  * Freezer-friendly wrappers around wait_event_interruptible(),
  * wait_event_killable() and wait_event_interruptible_timeout(), originally
  * defined in <linux/wait.h>
@@ -163,6 +186,11 @@ static inline void freezer_count(void) {}
 static inline int freezer_should_skip(struct task_struct *p) { return 0; }
 static inline void set_freezable(void) {}
 
+#define freezable_schedule()  schedule()
+
+#define freezable_schedule_timeout_killable(timeout)			\
+	schedule_timeout_killable(timeout)
+
 #define wait_event_freezable(wq, condition)				\
 		wait_event_interruptible(wq, condition)
 
diff --git a/net/sunrpc/sched.c b/net/sunrpc/sched.c
index d12ffa5..5317b93 100644
--- a/net/sunrpc/sched.c
+++ b/net/sunrpc/sched.c
@@ -18,6 +18,7 @@
 #include <linux/smp.h>
 #include <linux/spinlock.h>
 #include <linux/mutex.h>
+#include <linux/freezer.h>
 
 #include <linux/sunrpc/clnt.h>
 
@@ -231,7 +232,7 @@ static int rpc_wait_bit_killable(void *word)
 {
 	if (fatal_signal_pending(current))
 		return -ERESTARTSYS;
-	schedule();
+	freezable_schedule();
 	return 0;
 }
 
-- 
1.7.6.4


^ permalink raw reply related	[flat|nested] 4+ messages in thread

* Re: [PATCH] sunrpc/nfs: don't allow TASK_KILLABLE sleeps to block the freezer
  2011-12-01 21:33 [PATCH] sunrpc/nfs: don't allow TASK_KILLABLE sleeps to block the freezer Jeff Layton
@ 2011-12-01 21:52 ` Rafael J. Wysocki
  2011-12-23 13:11   ` Jeff Layton
  0 siblings, 1 reply; 4+ messages in thread
From: Rafael J. Wysocki @ 2011-12-01 21:52 UTC (permalink / raw)
  To: Jeff Layton
  Cc: linux-kernel, linux-nfs, linux-pm, tj, john, trond.myklebust,
	marek.belisko, awilliam

On Thursday, December 01, 2011, Jeff Layton wrote:
> Allow the freezer to skip wait_on_bit_killable sleeps in the sunrpc
> layer. This should allow suspend and hibernate events to proceed, even
> when there are RPC's pending on the wire.
> 
> Also, wrap the TASK_KILLABLE sleeps in NFS layer in freezer_do_not_count
> and freezer_count calls. This allows the freezer to skip tasks that are
> sleeping while looping on EJUKEBOX or NFS4ERR_DELAY sorts of errors.
> 
> Rafael, I've gone ahead and combined the two patches into one here
> and rebased this on top of the pm-freezer branch. Let me know if you'd
> prefer to keep it as two patches.

One patch is just fine for me, applied to linux-pm/linux-next.

Thanks,
Rafael


> Signed-off-by: Jeff Layton <jlayton@redhat.com>
> ---
>  fs/nfs/inode.c          |    3 ++-
>  fs/nfs/nfs3proc.c       |    3 ++-
>  fs/nfs/nfs4proc.c       |    5 +++--
>  fs/nfs/proc.c           |    3 ++-
>  include/linux/freezer.h |   28 ++++++++++++++++++++++++++++
>  net/sunrpc/sched.c      |    3 ++-
>  6 files changed, 39 insertions(+), 6 deletions(-)
> 
> diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
> index 50a15fa..bf3a57b 100644
> --- a/fs/nfs/inode.c
> +++ b/fs/nfs/inode.c
> @@ -38,6 +38,7 @@
>  #include <linux/nfs_xdr.h>
>  #include <linux/slab.h>
>  #include <linux/compat.h>
> +#include <linux/freezer.h>
>  
>  #include <asm/system.h>
>  #include <asm/uaccess.h>
> @@ -77,7 +78,7 @@ int nfs_wait_bit_killable(void *word)
>  {
>  	if (fatal_signal_pending(current))
>  		return -ERESTARTSYS;
> -	schedule();
> +	freezable_schedule();
>  	return 0;
>  }
>  
> diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
> index d4bc9ed9..9194395 100644
> --- a/fs/nfs/nfs3proc.c
> +++ b/fs/nfs/nfs3proc.c
> @@ -17,6 +17,7 @@
>  #include <linux/nfs_page.h>
>  #include <linux/lockd/bind.h>
>  #include <linux/nfs_mount.h>
> +#include <linux/freezer.h>
>  
>  #include "iostat.h"
>  #include "internal.h"
> @@ -32,7 +33,7 @@ nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
>  		res = rpc_call_sync(clnt, msg, flags);
>  		if (res != -EJUKEBOX && res != -EKEYEXPIRED)
>  			break;
> -		schedule_timeout_killable(NFS_JUKEBOX_RETRY_TIME);
> +		freezable_schedule_timeout_killable(NFS_JUKEBOX_RETRY_TIME);
>  		res = -ERESTARTSYS;
>  	} while (!fatal_signal_pending(current));
>  	return res;
> diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
> index be2bbac..b28bb19 100644
> --- a/fs/nfs/nfs4proc.c
> +++ b/fs/nfs/nfs4proc.c
> @@ -53,6 +53,7 @@
>  #include <linux/sunrpc/bc_xprt.h>
>  #include <linux/xattr.h>
>  #include <linux/utsname.h>
> +#include <linux/freezer.h>
>  
>  #include "nfs4_fs.h"
>  #include "delegation.h"
> @@ -241,7 +242,7 @@ static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
>  		*timeout = NFS4_POLL_RETRY_MIN;
>  	if (*timeout > NFS4_POLL_RETRY_MAX)
>  		*timeout = NFS4_POLL_RETRY_MAX;
> -	schedule_timeout_killable(*timeout);
> +	freezable_schedule_timeout_killable(*timeout);
>  	if (fatal_signal_pending(current))
>  		res = -ERESTARTSYS;
>  	*timeout <<= 1;
> @@ -3950,7 +3951,7 @@ int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4
>  static unsigned long
>  nfs4_set_lock_task_retry(unsigned long timeout)
>  {
> -	schedule_timeout_killable(timeout);
> +	freezable_schedule_timeout_killable(timeout);
>  	timeout <<= 1;
>  	if (timeout > NFS4_LOCK_MAXTIMEOUT)
>  		return NFS4_LOCK_MAXTIMEOUT;
> diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
> index f48125d..0c672588 100644
> --- a/fs/nfs/proc.c
> +++ b/fs/nfs/proc.c
> @@ -41,6 +41,7 @@
>  #include <linux/nfs_fs.h>
>  #include <linux/nfs_page.h>
>  #include <linux/lockd/bind.h>
> +#include <linux/freezer.h>
>  #include "internal.h"
>  
>  #define NFSDBG_FACILITY		NFSDBG_PROC
> @@ -59,7 +60,7 @@ nfs_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
>  		res = rpc_call_sync(clnt, msg, flags);
>  		if (res != -EKEYEXPIRED)
>  			break;
> -		schedule_timeout_killable(NFS_JUKEBOX_RETRY_TIME);
> +		freezable_schedule_timeout_killable(NFS_JUKEBOX_RETRY_TIME);
>  		res = -ERESTARTSYS;
>  	} while (!fatal_signal_pending(current));
>  	return res;
> diff --git a/include/linux/freezer.h b/include/linux/freezer.h
> index c1ee283..30f06c2 100644
> --- a/include/linux/freezer.h
> +++ b/include/linux/freezer.h
> @@ -105,6 +105,29 @@ static inline int freezer_should_skip(struct task_struct *p)
>  }
>  
>  /*
> + * These macros are intended to be used whenever you want allow a task that's
> + * sleeping in TASK_UNINTERRUPTIBLE or TASK_KILLABLE state to be frozen. Note
> + * that neither return any clear indication of whether a freeze event happened
> + * while in this function.
> + */
> +
> +/* Like schedule(), but should not block the freezer. */
> +#define freezable_schedule()						\
> +({									\
> +	freezer_do_not_count();						\
> +	schedule();							\
> +	freezer_count();						\
> +})
> +
> +/* Like schedule_timeout_killable(), but should not block the freezer. */
> +#define freezable_schedule_timeout_killable(timeout)			\
> +({									\
> +	freezer_do_not_count();						\
> +	schedule_timeout_killable(timeout);				\
> +	freezer_count();						\
> +})
> +
> +/*
>   * Freezer-friendly wrappers around wait_event_interruptible(),
>   * wait_event_killable() and wait_event_interruptible_timeout(), originally
>   * defined in <linux/wait.h>
> @@ -163,6 +186,11 @@ static inline void freezer_count(void) {}
>  static inline int freezer_should_skip(struct task_struct *p) { return 0; }
>  static inline void set_freezable(void) {}
>  
> +#define freezable_schedule()  schedule()
> +
> +#define freezable_schedule_timeout_killable(timeout)			\
> +	schedule_timeout_killable(timeout)
> +
>  #define wait_event_freezable(wq, condition)				\
>  		wait_event_interruptible(wq, condition)
>  
> diff --git a/net/sunrpc/sched.c b/net/sunrpc/sched.c
> index d12ffa5..5317b93 100644
> --- a/net/sunrpc/sched.c
> +++ b/net/sunrpc/sched.c
> @@ -18,6 +18,7 @@
>  #include <linux/smp.h>
>  #include <linux/spinlock.h>
>  #include <linux/mutex.h>
> +#include <linux/freezer.h>
>  
>  #include <linux/sunrpc/clnt.h>
>  
> @@ -231,7 +232,7 @@ static int rpc_wait_bit_killable(void *word)
>  {
>  	if (fatal_signal_pending(current))
>  		return -ERESTARTSYS;
> -	schedule();
> +	freezable_schedule();
>  	return 0;
>  }
>  
> 


^ permalink raw reply	[flat|nested] 4+ messages in thread

* Re: [PATCH] sunrpc/nfs: don't allow TASK_KILLABLE sleeps to block the freezer
  2011-12-01 21:52 ` Rafael J. Wysocki
@ 2011-12-23 13:11   ` Jeff Layton
  2011-12-23 22:37     ` Rafael J. Wysocki
  0 siblings, 1 reply; 4+ messages in thread
From: Jeff Layton @ 2011-12-23 13:11 UTC (permalink / raw)
  To: Rafael J. Wysocki
  Cc: linux-kernel, linux-nfs, linux-pm, tj, john, trond.myklebust,
	marek.belisko, awilliam

On Thu, 1 Dec 2011 22:52:13 +0100
"Rafael J. Wysocki" <rjw@sisk.pl> wrote:

> On Thursday, December 01, 2011, Jeff Layton wrote:
> > Allow the freezer to skip wait_on_bit_killable sleeps in the sunrpc
> > layer. This should allow suspend and hibernate events to proceed, even
> > when there are RPC's pending on the wire.
> > 
> > Also, wrap the TASK_KILLABLE sleeps in NFS layer in freezer_do_not_count
> > and freezer_count calls. This allows the freezer to skip tasks that are
> > sleeping while looping on EJUKEBOX or NFS4ERR_DELAY sorts of errors.
> > 
> > Rafael, I've gone ahead and combined the two patches into one here
> > and rebased this on top of the pm-freezer branch. Let me know if you'd
> > prefer to keep it as two patches.
> 
> One patch is just fine for me, applied to linux-pm/linux-next.
> 
> Thanks,
> Rafael
> 
> 

-------------------[snip]----------------

> > +
> > +/* Like schedule_timeout_killable(), but should not block the freezer. */
> > +#define freezable_schedule_timeout_killable(timeout)			\
> > +({									\
> > +	freezer_do_not_count();						\
> > +	schedule_timeout_killable(timeout);				\
> > +	freezer_count();						\
> > +})
> > +


Whoops...I just noticed a problem with this patch.

freezable_schedule_timeout_killable does not return the return code
from schedule_timeout_killable. Would you prefer for me to respin this
patch, or send a new patch on top of this one that just fixes that bug?

-- 
Jeff Layton <jlayton@redhat.com>

^ permalink raw reply	[flat|nested] 4+ messages in thread

* Re: [PATCH] sunrpc/nfs: don't allow TASK_KILLABLE sleeps to block the freezer
  2011-12-23 13:11   ` Jeff Layton
@ 2011-12-23 22:37     ` Rafael J. Wysocki
  0 siblings, 0 replies; 4+ messages in thread
From: Rafael J. Wysocki @ 2011-12-23 22:37 UTC (permalink / raw)
  To: Jeff Layton
  Cc: linux-kernel, linux-nfs, linux-pm, tj, john, trond.myklebust,
	marek.belisko, awilliam

On Friday, December 23, 2011, Jeff Layton wrote:
> On Thu, 1 Dec 2011 22:52:13 +0100
> "Rafael J. Wysocki" <rjw@sisk.pl> wrote:
> 
> > On Thursday, December 01, 2011, Jeff Layton wrote:
> > > Allow the freezer to skip wait_on_bit_killable sleeps in the sunrpc
> > > layer. This should allow suspend and hibernate events to proceed, even
> > > when there are RPC's pending on the wire.
> > > 
> > > Also, wrap the TASK_KILLABLE sleeps in NFS layer in freezer_do_not_count
> > > and freezer_count calls. This allows the freezer to skip tasks that are
> > > sleeping while looping on EJUKEBOX or NFS4ERR_DELAY sorts of errors.
> > > 
> > > Rafael, I've gone ahead and combined the two patches into one here
> > > and rebased this on top of the pm-freezer branch. Let me know if you'd
> > > prefer to keep it as two patches.
> > 
> > One patch is just fine for me, applied to linux-pm/linux-next.
> > 
> > Thanks,
> > Rafael
> > 
> > 
> 
> -------------------[snip]----------------
> 
> > > +
> > > +/* Like schedule_timeout_killable(), but should not block the freezer. */
> > > +#define freezable_schedule_timeout_killable(timeout)			\
> > > +({									\
> > > +	freezer_do_not_count();						\
> > > +	schedule_timeout_killable(timeout);				\
> > > +	freezer_count();						\
> > > +})
> > > +
> 
> 
> Whoops...I just noticed a problem with this patch.
> 
> freezable_schedule_timeout_killable does not return the return code
> from schedule_timeout_killable. Would you prefer for me to respin this
> patch, or send a new patch on top of this one that just fixes that bug?

Please send a new fix patch on top of it.

Thanks,
Rafael

^ permalink raw reply	[flat|nested] 4+ messages in thread

end of thread, other threads:[~2011-12-23 22:34 UTC | newest]

Thread overview: 4+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2011-12-01 21:33 [PATCH] sunrpc/nfs: don't allow TASK_KILLABLE sleeps to block the freezer Jeff Layton
2011-12-01 21:52 ` Rafael J. Wysocki
2011-12-23 13:11   ` Jeff Layton
2011-12-23 22:37     ` Rafael J. Wysocki

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).