Orangefs: code sanitation

Signed-off-by: Mike Marshall <hubcap@omnibond.com>

4 files changed, 29 insertions, 14 deletions

diff --git a/fs/orangefs/devorangefs-req.c b/fs/orangefs/devorangefs-req.c
index f7914f5d296f..0db3a57f974d 100644
--- a/fs/orangefs/devorangefs-req.c
+++ b/fs/orangefs/devorangefs-req.c
@@ -590,7 +590,7 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
 		 * remount all mounted orangefs volumes to regain the lost
 		 * dynamic mount tables (if any) -- NOTE: this is done
 		 * without keeping the superblock list locked due to the
-		 * upcall/downcall waiting.  also, the request semaphore is
+		 * upcall/downcall waiting.  also, the request mutex is
 		 * used to ensure that no operations will be serviced until
 		 * all of the remounts are serviced (to avoid ops between
 		 * mounts to fail)
diff --git a/fs/orangefs/orangefs-kernel.h b/fs/orangefs/orangefs-kernel.h
index 4ed64e555ca0..c3b3b22115eb 100644
--- a/fs/orangefs/orangefs-kernel.h
+++ b/fs/orangefs/orangefs-kernel.h
@@ -603,7 +603,7 @@ extern wait_queue_head_t orangefs_bufmap_init_waitq;
 #define ORANGEFS_OP_INTERRUPTIBLE 1   /* service_operation() is interruptible */
 #define ORANGEFS_OP_PRIORITY      2   /* service_operation() is high priority */
 #define ORANGEFS_OP_CANCELLATION  4   /* this is a cancellation */
-#define ORANGEFS_OP_NO_SEMAPHORE  8   /* don't acquire semaphore */
+#define ORANGEFS_OP_NO_MUTEX      8   /* don't acquire request_mutex */
 #define ORANGEFS_OP_ASYNC         16  /* Queue it, but don't wait */
 
 int service_operation(struct orangefs_kernel_op_s *op,
diff --git a/fs/orangefs/super.c b/fs/orangefs/super.c
index 93cc352be360..65ddc74e96b6 100644
--- a/fs/orangefs/super.c
+++ b/fs/orangefs/super.c
@@ -229,12 +229,12 @@ int orangefs_remount(struct super_block *sb)
 		     new_op->upcall.req.fs_mount.orangefs_config_server);
 
 	/*
-	 * we assume that the calling function has already acquire the
+	 * we assume that the calling function has already acquired the
 	 * request_mutex to prevent other operations from bypassing
 	 * this one
 	 */
 	ret = service_operation(new_op, "orangefs_remount",
-		ORANGEFS_OP_PRIORITY | ORANGEFS_OP_NO_SEMAPHORE);
+		ORANGEFS_OP_PRIORITY | ORANGEFS_OP_NO_MUTEX);
 	gossip_debug(GOSSIP_SUPER_DEBUG,
 		     "orangefs_remount: mount got return value of %d\n",
 		     ret);
diff --git a/fs/orangefs/waitqueue.c b/fs/orangefs/waitqueue.c
index 3f9e43066444..1eadf69cc919 100644
--- a/fs/orangefs/waitqueue.c
+++ b/fs/orangefs/waitqueue.c
@@ -56,7 +56,6 @@ int service_operation(struct orangefs_kernel_op_s *op,
 		      int flags)
 {
 	long timeout = MAX_SCHEDULE_TIMEOUT;
-	/* flags to modify behavior */
 	int ret = 0;
 
 	DEFINE_WAIT(wait_entry);
@@ -74,14 +73,20 @@ retry_servicing:
 		     current->comm,
 		     current->pid);
 
-	if (!(flags & ORANGEFS_OP_NO_SEMAPHORE)) {
+	/*
+	 * If ORANGEFS_OP_NO_MUTEX was set in flags, we need to avoid
+	 * aquiring the request_mutex because we're servicing a
+	 * high priority remount operation and the request_mutex is
+	 * already taken.
+	 */
+	if (!(flags & ORANGEFS_OP_NO_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
+		 * mutex
 		 */
 		if (ret < 0) {
 			op->downcall.status = ret;
@@ -95,6 +100,7 @@ retry_servicing:
 	spin_lock(&orangefs_request_list_lock);
 	spin_lock(&op->lock);
 	set_op_state_waiting(op);
+	/* add high priority remount op to the front of the line. */
 	if (flags & ORANGEFS_OP_PRIORITY)
 		list_add(&op->list, &orangefs_request_list);
 	else
@@ -109,7 +115,7 @@ retry_servicing:
 	}
 	spin_unlock(&orangefs_request_list_lock);
 
-	if (!(flags & ORANGEFS_OP_NO_SEMAPHORE))
+	if (!(flags & ORANGEFS_OP_NO_MUTEX))
 		mutex_unlock(&request_mutex);
 
 	ret = wait_for_matching_downcall(op, timeout,
@@ -132,10 +138,17 @@ retry_servicing:
 
 	/* failed to get matching downcall */
 	if (ret == -ETIMEDOUT) {
-		gossip_err("orangefs: %s -- wait timed out; aborting attempt.\n",
+		gossip_err("%s: %s -- wait timed out; aborting attempt.\n",
+			   __func__,
 			   op_name);
 	}
+
+	/*
+	 * remove waiting ops from the request list or
+	 * remove in-progress ops from the in-progress list.
+	 */
 	orangefs_clean_up_interrupted_operation(op);
+
 	op->downcall.status = ret;
 	/* retry if operation has not been serviced and if requested */
 	if (ret == -EAGAIN) {
@@ -148,11 +161,12 @@ retry_servicing:
 			     op_name,
 			     op->attempts);
 
+		/*
+		 * io ops (ops that use the shared memory buffer) have
+		 * to be returned to their caller for a retry. Other ops
+		 * can just be recycled here.
+		 */
 		if (!op->uses_shared_memory)
-			/*
-			 * this operation doesn't use the shared memory
-			 * system
-			 */
 			goto retry_servicing;
 	}
 
@@ -268,7 +282,8 @@ static int wait_for_matching_downcall(struct orangefs_kernel_op_s *op,
 	long n;
 
 	if (interruptible)
-		n = wait_for_completion_interruptible_timeout(&op->waitq, timeout);
+		n = wait_for_completion_interruptible_timeout(&op->waitq,
+							      timeout);
 	else
 		n = wait_for_completion_killable_timeout(&op->waitq, timeout);