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))