static int do_unlk(struct file *filp, int cmd, struct file_lock *fl)
{
struct inode *inode = filp->f_mapping->host;
sigset_t oldset;
int status;
rpc_clnt_sigmask(NFS_CLIENT(inode), &oldset);
/*
* Flush all pending writes before doing anything
* with locks..
*/
nfs_sync_mapping(filp->f_mapping);
/* NOTE: special case
* If we're signalled while cleaning up locks on process exit, we
* still need to complete the unlock.
*/
lock_kernel();
/* Use local locking if mounted with "-onolock" */
if (!(NFS_SERVER(inode)->flags & NFS_MOUNT_NONLM))
status = NFS_PROTO(inode)->lock(filp, cmd, fl);
else
status = do_vfs_lock(filp, fl);
unlock_kernel();
rpc_clnt_sigunmask(NFS_CLIENT(inode), &oldset);
return status;
}
/*
* New rpc_call implementation
*/
int rpc_call_sync(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
{
struct rpc_task my_task, *task = &my_task;
sigset_t oldset;
int status;
/* If this client is slain all further I/O fails */
if (clnt->cl_dead)
return -EIO;
if (flags & RPC_TASK_ASYNC) {
printk("rpc_call_sync: Illegal flag combination for synchronous task\n");
flags &= ~RPC_TASK_ASYNC;
}
rpc_clnt_sigmask(clnt, &oldset);
/* Create/initialize a new RPC task */
rpc_init_task(task, clnt, NULL, flags);
rpc_call_setup(task, msg, 0);
/* Set up the call info struct and execute the task */
if (task->tk_status == 0)
status = rpc_execute(task);
else {
status = task->tk_status;
rpc_release_task(task);
}
rpc_clnt_sigunmask(clnt, &oldset);
return status;
}
static int do_setlk(struct file *filp, int cmd, struct file_lock *fl)
{
struct inode *inode = filp->f_mapping->host;
sigset_t oldset;
int status;
rpc_clnt_sigmask(NFS_CLIENT(inode), &oldset);
/*
* Flush all pending writes before doing anything
* with locks..
*/
status = filemap_fdatawrite(filp->f_mapping);
if (status == 0) {
down(&inode->i_sem);
status = nfs_wb_all(inode);
up(&inode->i_sem);
if (status == 0)
status = filemap_fdatawait(filp->f_mapping);
}
if (status < 0)
goto out;
lock_kernel();
/* Use local locking if mounted with "-onolock" */
if (!(NFS_SERVER(inode)->flags & NFS_MOUNT_NONLM)) {
status = NFS_PROTO(inode)->lock(filp, cmd, fl);
/* If we were signalled we still need to ensure that
* we clean up any state on the server. We therefore
* record the lock call as having succeeded in order to
* ensure that locks_remove_posix() cleans it out when
* the process exits.
*/
if (status == -EINTR || status == -ERESTARTSYS)
do_vfs_lock(filp, fl);
} else
status = do_vfs_lock(filp, fl);
unlock_kernel();
if (status < 0)
goto out;
/*
* Make sure we clear the cache whenever we try to get the lock.
* This makes locking act as a cache coherency point.
*/
filemap_fdatawrite(filp->f_mapping);
down(&inode->i_sem);
nfs_wb_all(inode); /* we may have slept */
up(&inode->i_sem);
filemap_fdatawait(filp->f_mapping);
nfs_zap_caches(inode);
out:
rpc_clnt_sigunmask(NFS_CLIENT(inode), &oldset);
return status;
}
/* A wrapper to handle the EJUKEBOX error message */
static int
nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
{
sigset_t oldset;
int res;
rpc_clnt_sigmask(clnt, &oldset);
do {
res = rpc_call_sync(clnt, msg, flags);
if (res != -EJUKEBOX)
break;
schedule_timeout_interruptible(NFS_JUKEBOX_RETRY_TIME);
res = -ERESTARTSYS;
} while (!signalled());
rpc_clnt_sigunmask(clnt, &oldset);
return res;
}
/*
* New rpc_call implementation
*/
int
rpc_do_call(struct rpc_clnt *clnt, u32 proc, void *argp, void *resp,
int flags, rpc_action func, void *data)
{
struct rpc_task my_task, *task = &my_task;
sigset_t oldset;
int async, status;
/* If this client is slain all further I/O fails */
if (clnt->cl_dead)
return -EIO;
rpc_clnt_sigmask(clnt, &oldset);
/* Create/initialize a new RPC task */
if ((async = (flags & RPC_TASK_ASYNC)) != 0) {
if (!func)
func = rpc_default_callback;
status = -ENOMEM;
if (!(task = rpc_new_task(clnt, func, flags)))
goto out;
task->tk_calldata = data;
} else {
rpc_init_task(task, clnt, NULL, flags);
}
/* Bind the user cred, set up the call info struct and
* execute the task */
if (rpcauth_lookupcred(task) != NULL) {
rpc_call_setup(task, proc, argp, resp, 0);
rpc_execute(task);
} else
async = 0;
status = 0;
if (!async) {
status = task->tk_status;
rpc_release_task(task);
}
out:
rpc_clnt_sigunmask(clnt, &oldset);
return status;
}
/**
* nfs_wait_on_request - Wait for a request to complete.
* @req: request to wait upon.
*
* Interruptible by signals only if mounted with intr flag.
* The user is responsible for holding a count on the request.
*/
int
nfs_wait_on_request(struct nfs_page *req)
{
struct rpc_clnt *clnt = NFS_CLIENT(req->wb_context->dentry->d_inode);
sigset_t oldmask;
int ret = 0;
if (!test_bit(PG_BUSY, &req->wb_flags))
goto out;
/*
* Note: the call to rpc_clnt_sigmask() suffices to ensure that we
* are not interrupted if intr flag is not set
*/
rpc_clnt_sigmask(clnt, &oldmask);
ret = out_of_line_wait_on_bit(&req->wb_flags, PG_BUSY,
nfs_wait_bit_interruptible, TASK_INTERRUPTIBLE);
rpc_clnt_sigunmask(clnt, &oldmask);
out:
return ret;
}
/*
* New rpc_call implementation
*/
int
rpc_call_async(struct rpc_clnt *clnt, struct rpc_message *msg, int flags,
rpc_action callback, void *data)
{
struct rpc_task *task;
sigset_t oldset;
int status;
/* If this client is slain all further I/O fails */
if (clnt->cl_dead)
return -EIO;
flags |= RPC_TASK_ASYNC;
rpc_clnt_sigmask(clnt, &oldset);
/* Create/initialize a new RPC task */
if (!callback)
callback = rpc_default_callback;
status = -ENOMEM;
if (!(task = rpc_new_task(clnt, callback, flags)))
goto out;
task->tk_calldata = data;
rpc_call_setup(task, msg, 0);
/* Set up the call info struct and execute the task */
if (task->tk_status == 0)
status = rpc_execute(task);
else {
status = task->tk_status;
rpc_release_task(task);
}
out:
rpc_clnt_sigunmask(clnt, &oldset);
return status;
}
