/*
* Cancel a blocked lock request.
* We always use an async RPC call for this in order not to hang a
* process that has been Ctrl-C'ed.
*/
int
nlmclnt_cancel(struct nlm_host *host, struct file_lock *fl)
{
struct nlm_rqst *req;
unsigned long flags;
sigset_t oldset;
int status;
/* Block all signals while setting up call */
spin_lock_irqsave(¤t->sighand->siglock, flags);
oldset = current->blocked;
sigfillset(¤t->blocked);
recalc_sigpending();
spin_unlock_irqrestore(¤t->sighand->siglock, flags);
req = nlmclnt_alloc_call();
if (!req)
return -ENOMEM;
req->a_host = host;
req->a_flags = RPC_TASK_ASYNC;
nlmclnt_setlockargs(req, fl);
status = nlmclnt_async_call(req, NLMPROC_CANCEL,
nlmclnt_cancel_callback);
if (status < 0)
kfree(req);
spin_lock_irqsave(¤t->sighand->siglock, flags);
current->blocked = oldset;
recalc_sigpending();
spin_unlock_irqrestore(¤t->sighand->siglock, flags);
return status;
}
/*
* RECLAIM: Try to reclaim a lock
*/
int
nlmclnt_reclaim(struct nlm_host *host, struct file_lock *fl)
{
struct nlm_rqst reqst, *req;
int status;
req = &reqst;
memset(req, 0, sizeof(*req));
locks_init_lock(&req->a_args.lock.fl);
locks_init_lock(&req->a_res.lock.fl);
req->a_host = host;
req->a_flags = 0;
/* Set up the argument struct */
nlmclnt_setlockargs(req, fl);
req->a_args.reclaim = 1;
if ((status = nlmclnt_call(req, NLMPROC_LOCK)) >= 0
&& req->a_res.status == NLM_LCK_GRANTED)
return 0;
printk(KERN_WARNING "lockd: failed to reclaim lock for pid %d "
"(errno %d, status %d)\n", fl->fl_pid,
status, req->a_res.status);
/*
* FIXME: This is a serious failure. We can
*
* a. Ignore the problem
* b. Send the owning process some signal (Linux doesn't have
* SIGLOST, though...)
* c. Retry the operation
*
* Until someone comes up with a simple implementation
* for b or c, I'll choose option a.
*/
return -ENOLCK;
}
/*
* Cancel a blocked lock request.
* We always use an async RPC call for this in order not to hang a
* process that has been Ctrl-C'ed.
*/
int
nlmclnt_cancel(struct nlm_host *host, struct file_lock *fl)
{
struct nlm_rqst *req;
unsigned long flags;
sigset_t oldset;
int status;
/* Block all signals while setting up call */
spin_lock_irqsave(¤t->sigmask_lock, flags);
oldset = current->blocked;
sigfillset(¤t->blocked);
recalc_sigpending(current);
spin_unlock_irqrestore(¤t->sigmask_lock, flags);
do {
req = (struct nlm_rqst *) rpc_allocate(RPC_TASK_ASYNC,
sizeof(*req));
} while (req == NULL);
req->a_host = host;
req->a_flags = RPC_TASK_ASYNC;
nlmclnt_setlockargs(req, fl);
status = nlmclnt_async_call(req, NLMPROC_CANCEL,
nlmclnt_cancel_callback);
if (status < 0)
rpc_free(req);
spin_lock_irqsave(¤t->sigmask_lock, flags);
current->blocked = oldset;
recalc_sigpending(current);
spin_unlock_irqrestore(¤t->sigmask_lock, flags);
return status;
}
/*
* This is the main entry point for the NLM client.
*/
int
nlmclnt_proc(struct inode *inode, int cmd, struct file_lock *fl)
{
struct nfs_server *nfssrv = NFS_SERVER(inode);
struct nlm_host *host;
struct nlm_rqst reqst, *call = &reqst;
sigset_t oldset;
unsigned long flags;
int status;
/* Always use NLM version 1 over UDP for now... */
if (!(host = nlmclnt_lookup_host(NFS_ADDR(inode), IPPROTO_UDP, 1)))
return -ENOLCK;
/* Create RPC client handle if not there, and copy soft
* and intr flags from NFS client. */
if (host->h_rpcclnt == NULL) {
struct rpc_clnt *clnt;
/* Bind an rpc client to this host handle (does not
* perform a portmapper lookup) */
if (!(clnt = nlm_bind_host(host))) {
status = -ENOLCK;
goto done;
}
clnt->cl_softrtry = nfssrv->client->cl_softrtry;
clnt->cl_intr = nfssrv->client->cl_intr;
clnt->cl_chatty = nfssrv->client->cl_chatty;
}
/* Keep the old signal mask */
spin_lock_irqsave(¤t->sigmask_lock, flags);
oldset = current->blocked;
/* If we're cleaning up locks because the process is exiting,
* perform the RPC call asynchronously. */
if ((cmd == F_SETLK || cmd == F_SETLKW)
&& fl->fl_type == F_UNLCK
&& (current->flags & PF_EXITING)) {
sigfillset(¤t->blocked); /* Mask all signals */
recalc_sigpending(current);
spin_unlock_irqrestore(¤t->sigmask_lock, flags);
call = nlmclnt_alloc_call();
call->a_flags = RPC_TASK_ASYNC;
} else {
spin_unlock_irqrestore(¤t->sigmask_lock, flags);
call->a_flags = 0;
}
call->a_host = host;
/* Set up the argument struct */
nlmclnt_setlockargs(call, fl);
if (cmd == F_GETLK) {
status = nlmclnt_test(call, fl);
} else if ((cmd == F_SETLK || cmd == F_SETLKW)
&& fl->fl_type == F_UNLCK) {
status = nlmclnt_unlock(call, fl);
} else if (cmd == F_SETLK || cmd == F_SETLKW) {
call->a_args.block = (cmd == F_SETLKW)? 1 : 0;
status = nlmclnt_lock(call, fl);
} else {
status = -EINVAL;
}
if (status < 0 && (call->a_flags & RPC_TASK_ASYNC))
rpc_free(call);
spin_lock_irqsave(¤t->sigmask_lock, flags);
current->blocked = oldset;
recalc_sigpending(current);
spin_unlock_irqrestore(¤t->sigmask_lock, flags);
done:
dprintk("lockd: clnt proc returns %d\n", status);
nlm_release_host(host);
return status;
}
/*
* This is the main entry point for the NLM client.
*/
int
nlmclnt_proc(struct inode *inode, int cmd, struct file_lock *fl)
{
struct nfs_server *nfssrv = NFS_SERVER(inode);
struct nlm_host *host;
struct nlm_rqst reqst, *call = &reqst;
sigset_t oldset;
unsigned long flags;
int status, proto, vers;
vers = (NFS_PROTO(inode)->version == 3) ? 4 : 1;
if (NFS_PROTO(inode)->version > 3) {
printk(KERN_NOTICE "NFSv4 file locking not implemented!\n");
return -ENOLCK;
}
/* Retrieve transport protocol from NFS client */
proto = NFS_CLIENT(inode)->cl_xprt->prot;
if (!(host = nlmclnt_lookup_host(NFS_ADDR(inode), proto, vers)))
return -ENOLCK;
/* Create RPC client handle if not there, and copy soft
* and intr flags from NFS client. */
if (host->h_rpcclnt == NULL) {
struct rpc_clnt *clnt;
/* Bind an rpc client to this host handle (does not
* perform a portmapper lookup) */
if (!(clnt = nlm_bind_host(host))) {
status = -ENOLCK;
goto done;
}
clnt->cl_softrtry = nfssrv->client->cl_softrtry;
clnt->cl_intr = nfssrv->client->cl_intr;
clnt->cl_chatty = nfssrv->client->cl_chatty;
}
/* Keep the old signal mask */
spin_lock_irqsave(¤t->sighand->siglock, flags);
oldset = current->blocked;
/* If we're cleaning up locks because the process is exiting,
* perform the RPC call asynchronously. */
if ((IS_SETLK(cmd) || IS_SETLKW(cmd))
&& fl->fl_type == F_UNLCK
&& (current->flags & PF_EXITING)) {
sigfillset(¤t->blocked); /* Mask all signals */
recalc_sigpending();
spin_unlock_irqrestore(¤t->sighand->siglock, flags);
call = nlmclnt_alloc_call();
if (!call) {
status = -ENOMEM;
goto out_restore;
}
call->a_flags = RPC_TASK_ASYNC;
} else {
spin_unlock_irqrestore(¤t->sighand->siglock, flags);
memset(call, 0, sizeof(*call));
locks_init_lock(&call->a_args.lock.fl);
locks_init_lock(&call->a_res.lock.fl);
}
call->a_host = host;
/* Set up the argument struct */
nlmclnt_setlockargs(call, fl);
if (IS_SETLK(cmd) || IS_SETLKW(cmd)) {
if (fl->fl_type != F_UNLCK) {
call->a_args.block = IS_SETLKW(cmd) ? 1 : 0;
status = nlmclnt_lock(call, fl);
} else
status = nlmclnt_unlock(call, fl);
} else if (IS_GETLK(cmd))
status = nlmclnt_test(call, fl);
else
status = -EINVAL;
if (status < 0 && (call->a_flags & RPC_TASK_ASYNC))
kfree(call);
out_restore:
spin_lock_irqsave(¤t->sighand->siglock, flags);
current->blocked = oldset;
recalc_sigpending();
spin_unlock_irqrestore(¤t->sighand->siglock, flags);
done:
dprintk("lockd: clnt proc returns %d\n", status);
nlm_release_host(host);
return status;
}
