service_operation(): don't block signals, just use ..._killable

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Mike Marshall <hubcap@omnibond.com>

3 files changed, 14 insertions, 40 deletions

diff --git a/fs/orangefs/orangefs-kernel.h b/fs/orangefs/orangefs-kernel.h
index de898bda7859..8613d4166d0f 100644
--- a/fs/orangefs/orangefs-kernel.h
+++ b/fs/orangefs/orangefs-kernel.h
@@ -580,10 +580,6 @@ int orangefs_inode_setattr(struct inode *inode, struct iattr *iattr);
 
 void orangefs_make_bad_inode(struct inode *inode);
 
-void orangefs_block_signals(sigset_t *);
-
-void orangefs_set_signals(sigset_t *);
-
 int orangefs_unmount_sb(struct super_block *sb);
 
 bool orangefs_cancel_op_in_progress(struct orangefs_kernel_op_s *op);
diff --git a/fs/orangefs/orangefs-utils.c b/fs/orangefs/orangefs-utils.c
index 63e8c9bc912e..488f3501b09c 100644
--- a/fs/orangefs/orangefs-utils.c
+++ b/fs/orangefs/orangefs-utils.c
@@ -707,27 +707,6 @@ void orangefs_make_bad_inode(struct inode *inode)
 	}
 }
 
-/* Block all blockable signals... */
-void orangefs_block_signals(sigset_t *orig_sigset)
-{
-	sigset_t mask;
-
-	/*
-	 * Initialize all entries in the signal set to the
-	 * inverse of the given mask.
-	 */
-	siginitsetinv(&mask, sigmask(SIGKILL));
-
-	/* Block 'em Danno... */
-	sigprocmask(SIG_BLOCK, &mask, orig_sigset);
-}
-
-/* set the signal mask to the given template... */
-void orangefs_set_signals(sigset_t *sigset)
-{
-	sigprocmask(SIG_SETMASK, sigset, NULL);
-}
-
 /*
  * The following is a very dirty hack that is now a permanent part of the
  * ORANGEFS protocol. See protocol.h for more error definitions.
diff --git a/fs/orangefs/waitqueue.c b/fs/orangefs/waitqueue.c
index 6cae77400a5b..86b4b1fc0b14 100644
--- a/fs/orangefs/waitqueue.c
+++ b/fs/orangefs/waitqueue.c
@@ -16,7 +16,7 @@
 #include "orangefs-kernel.h"
 #include "orangefs-bufmap.h"
 
-static int wait_for_matching_downcall(struct orangefs_kernel_op_s *);
+static int wait_for_matching_downcall(struct orangefs_kernel_op_s *, bool);
 static void orangefs_clean_up_interrupted_operation(struct orangefs_kernel_op_s *);
 
 /*
@@ -56,7 +56,6 @@ int service_operation(struct orangefs_kernel_op_s *op,
 		      int flags)
 {
 	/* flags to modify behavior */
-	sigset_t orig_sigset;
 	int ret = 0;
 
 	DEFINE_WAIT(wait_entry);
@@ -75,19 +74,16 @@ retry_servicing:
 		     current->comm,
 		     current->pid);
 
-	/* mask out signals if this operation is not to be interrupted */
-	if (!(flags & ORANGEFS_OP_INTERRUPTIBLE))
-		orangefs_block_signals(&orig_sigset);
-
 	if (!(flags & ORANGEFS_OP_NO_SEMAPHORE)) {
-		ret = mutex_lock_interruptible(&request_mutex);
+		if (flags & ORANGEFS_OP_INTERRUPTIBLE)
+			ret = mutex_lock_interruptible(&request_mutex);
+		else
+			ret = mutex_lock_killable(&request_mutex);
 		/*
 		 * check to see if we were interrupted while waiting for
 		 * semaphore
 		 */
 		if (ret < 0) {
-			if (!(flags & ORANGEFS_OP_INTERRUPTIBLE))
-				orangefs_set_signals(&orig_sigset);
 			op->downcall.status = ret;
 			gossip_debug(GOSSIP_WAIT_DEBUG,
 				     "orangefs: service_operation interrupted.\n");
@@ -128,7 +124,7 @@ retry_servicing:
 	if (flags & ORANGEFS_OP_ASYNC)
 		return 0;
 
-	ret = wait_for_matching_downcall(op);
+	ret = wait_for_matching_downcall(op, flags & ORANGEFS_OP_INTERRUPTIBLE);
 
 	if (ret < 0) {
 		/* failed to get matching downcall */
@@ -146,9 +142,6 @@ retry_servicing:
 		ret = op->downcall.status;
 	}
 
-	if (!(flags & ORANGEFS_OP_INTERRUPTIBLE))
-		orangefs_set_signals(&orig_sigset);
-
 	BUG_ON(ret != op->downcall.status);
 	/* retry if operation has not been serviced and if requested */
 	if (!op_state_serviced(op) && op->downcall.status == -EAGAIN) {
@@ -334,12 +327,18 @@ static void orangefs_clean_up_interrupted_operation(struct orangefs_kernel_op_s
  *
  * Returns with op->lock taken.
  */
-static int wait_for_matching_downcall(struct orangefs_kernel_op_s *op)
+static int wait_for_matching_downcall(struct orangefs_kernel_op_s *op,
+				      bool interruptible)
 {
 	long timeout, n;
 
 	timeout = op->attempts ? op_timeout_secs * HZ : MAX_SCHEDULE_TIMEOUT;
-	n = wait_for_completion_interruptible_timeout(&op->waitq, timeout);
+
+	if (interruptible)
+		n = wait_for_completion_interruptible_timeout(&op->waitq, timeout);
+	else
+		n = wait_for_completion_killable_timeout(&op->waitq, timeout);
+
 	spin_lock(&op->lock);
 
 	if (op_state_serviced(op))