korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-11-23 20:24:12 +08:00
Code Issues Packages Projects Releases Wiki Activity

Orangefs: code sanitation

Browse Source 
Signed-off-by: Mike Marshall <hubcap@omnibond.com>
This commit is contained in:
Mike Marshall 2016-02-24 16:54:27 -05:00
parent d37c0f307a
commit adcf34a289
4 changed files with 29 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fs/orangefs/devorangefs-req.c
View File

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

2
fs/orangefs/orangefs-kernel.h
View File

@ -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,

4
fs/orangefs/super.c
View File

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

35
fs/orangefs/waitqueue.c
View File

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