2 * linux/fs/lockd/clntproc.c
4 * RPC procedures for the client side NLM implementation
6 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
9 #include <linux/module.h>
10 #include <linux/slab.h>
11 #include <linux/types.h>
12 #include <linux/errno.h>
14 #include <linux/nfs_fs.h>
15 #include <linux/utsname.h>
16 #include <linux/freezer.h>
17 #include <linux/sunrpc/clnt.h>
18 #include <linux/sunrpc/svc.h>
19 #include <linux/lockd/lockd.h>
21 #define NLMDBG_FACILITY NLMDBG_CLIENT
22 #define NLMCLNT_GRACE_WAIT (5*HZ)
23 #define NLMCLNT_POLL_TIMEOUT (30*HZ)
24 #define NLMCLNT_MAX_RETRIES 3
26 static int nlmclnt_test(struct nlm_rqst
*, struct file_lock
*);
27 static int nlmclnt_lock(struct nlm_rqst
*, struct file_lock
*);
28 static int nlmclnt_unlock(struct nlm_rqst
*, struct file_lock
*);
29 static int nlm_stat_to_errno(__be32 stat
);
30 static void nlmclnt_locks_init_private(struct file_lock
*fl
, struct nlm_host
*host
);
31 static int nlmclnt_cancel(struct nlm_host
*, int , struct file_lock
*);
33 static const struct rpc_call_ops nlmclnt_unlock_ops
;
34 static const struct rpc_call_ops nlmclnt_cancel_ops
;
37 * Cookie counter for NLM requests
39 static atomic_t nlm_cookie
= ATOMIC_INIT(0x1234);
41 void nlmclnt_next_cookie(struct nlm_cookie
*c
)
43 u32 cookie
= atomic_inc_return(&nlm_cookie
);
45 memcpy(c
->data
, &cookie
, 4);
49 static struct nlm_lockowner
*nlm_get_lockowner(struct nlm_lockowner
*lockowner
)
51 atomic_inc(&lockowner
->count
);
55 static void nlm_put_lockowner(struct nlm_lockowner
*lockowner
)
57 if (!atomic_dec_and_lock(&lockowner
->count
, &lockowner
->host
->h_lock
))
59 list_del(&lockowner
->list
);
60 spin_unlock(&lockowner
->host
->h_lock
);
61 nlmclnt_release_host(lockowner
->host
);
65 static inline int nlm_pidbusy(struct nlm_host
*host
, uint32_t pid
)
67 struct nlm_lockowner
*lockowner
;
68 list_for_each_entry(lockowner
, &host
->h_lockowners
, list
) {
69 if (lockowner
->pid
== pid
)
75 static inline uint32_t __nlm_alloc_pid(struct nlm_host
*host
)
79 res
= host
->h_pidcount
++;
80 } while (nlm_pidbusy(host
, res
) < 0);
84 static struct nlm_lockowner
*__nlm_find_lockowner(struct nlm_host
*host
, fl_owner_t owner
)
86 struct nlm_lockowner
*lockowner
;
87 list_for_each_entry(lockowner
, &host
->h_lockowners
, list
) {
88 if (lockowner
->owner
!= owner
)
90 return nlm_get_lockowner(lockowner
);
95 static struct nlm_lockowner
*nlm_find_lockowner(struct nlm_host
*host
, fl_owner_t owner
)
97 struct nlm_lockowner
*res
, *new = NULL
;
99 spin_lock(&host
->h_lock
);
100 res
= __nlm_find_lockowner(host
, owner
);
102 spin_unlock(&host
->h_lock
);
103 new = kmalloc(sizeof(*new), GFP_KERNEL
);
104 spin_lock(&host
->h_lock
);
105 res
= __nlm_find_lockowner(host
, owner
);
106 if (res
== NULL
&& new != NULL
) {
108 atomic_set(&new->count
, 1);
110 new->pid
= __nlm_alloc_pid(host
);
111 new->host
= nlm_get_host(host
);
112 list_add(&new->list
, &host
->h_lockowners
);
116 spin_unlock(&host
->h_lock
);
122 * Initialize arguments for TEST/LOCK/UNLOCK/CANCEL calls
124 static void nlmclnt_setlockargs(struct nlm_rqst
*req
, struct file_lock
*fl
)
126 struct nlm_args
*argp
= &req
->a_args
;
127 struct nlm_lock
*lock
= &argp
->lock
;
129 nlmclnt_next_cookie(&argp
->cookie
);
130 memcpy(&lock
->fh
, NFS_FH(fl
->fl_file
->f_path
.dentry
->d_inode
), sizeof(struct nfs_fh
));
131 lock
->caller
= utsname()->nodename
;
132 lock
->oh
.data
= req
->a_owner
;
133 lock
->oh
.len
= snprintf(req
->a_owner
, sizeof(req
->a_owner
), "%u@%s",
134 (unsigned int)fl
->fl_u
.nfs_fl
.owner
->pid
,
135 utsname()->nodename
);
136 lock
->svid
= fl
->fl_u
.nfs_fl
.owner
->pid
;
137 lock
->fl
.fl_start
= fl
->fl_start
;
138 lock
->fl
.fl_end
= fl
->fl_end
;
139 lock
->fl
.fl_type
= fl
->fl_type
;
142 static void nlmclnt_release_lockargs(struct nlm_rqst
*req
)
144 BUG_ON(req
->a_args
.lock
.fl
.fl_ops
!= NULL
);
148 * nlmclnt_proc - Perform a single client-side lock request
149 * @host: address of a valid nlm_host context representing the NLM server
150 * @cmd: fcntl-style file lock operation to perform
151 * @fl: address of arguments for the lock operation
154 int nlmclnt_proc(struct nlm_host
*host
, int cmd
, struct file_lock
*fl
)
156 struct nlm_rqst
*call
;
160 call
= nlm_alloc_call(host
);
164 nlmclnt_locks_init_private(fl
, host
);
165 /* Set up the argument struct */
166 nlmclnt_setlockargs(call
, fl
);
168 if (IS_SETLK(cmd
) || IS_SETLKW(cmd
)) {
169 if (fl
->fl_type
!= F_UNLCK
) {
170 call
->a_args
.block
= IS_SETLKW(cmd
) ? 1 : 0;
171 status
= nlmclnt_lock(call
, fl
);
173 status
= nlmclnt_unlock(call
, fl
);
174 } else if (IS_GETLK(cmd
))
175 status
= nlmclnt_test(call
, fl
);
178 fl
->fl_ops
->fl_release_private(fl
);
181 dprintk("lockd: clnt proc returns %d\n", status
);
184 EXPORT_SYMBOL_GPL(nlmclnt_proc
);
187 * Allocate an NLM RPC call struct
189 * Note: the caller must hold a reference to host. In case of failure,
190 * this reference will be released.
192 struct nlm_rqst
*nlm_alloc_call(struct nlm_host
*host
)
194 struct nlm_rqst
*call
;
197 call
= kzalloc(sizeof(*call
), GFP_KERNEL
);
199 atomic_set(&call
->a_count
, 1);
200 locks_init_lock(&call
->a_args
.lock
.fl
);
201 locks_init_lock(&call
->a_res
.lock
.fl
);
207 printk("nlm_alloc_call: failed, waiting for memory\n");
208 schedule_timeout_interruptible(5*HZ
);
210 nlmclnt_release_host(host
);
214 void nlmclnt_release_call(struct nlm_rqst
*call
)
216 if (!atomic_dec_and_test(&call
->a_count
))
218 nlmclnt_release_host(call
->a_host
);
219 nlmclnt_release_lockargs(call
);
223 static void nlmclnt_rpc_release(void *data
)
225 nlmclnt_release_call(data
);
228 static int nlm_wait_on_grace(wait_queue_head_t
*queue
)
233 prepare_to_wait(queue
, &wait
, TASK_INTERRUPTIBLE
);
235 schedule_timeout(NLMCLNT_GRACE_WAIT
);
240 finish_wait(queue
, &wait
);
248 nlmclnt_call(struct rpc_cred
*cred
, struct nlm_rqst
*req
, u32 proc
)
250 struct nlm_host
*host
= req
->a_host
;
251 struct rpc_clnt
*clnt
;
252 struct nlm_args
*argp
= &req
->a_args
;
253 struct nlm_res
*resp
= &req
->a_res
;
254 struct rpc_message msg
= {
261 dprintk("lockd: call procedure %d on %s\n",
262 (int)proc
, host
->h_name
);
265 if (host
->h_reclaiming
&& !argp
->reclaim
)
266 goto in_grace_period
;
268 /* If we have no RPC client yet, create one. */
269 if ((clnt
= nlm_bind_host(host
)) == NULL
)
271 msg
.rpc_proc
= &clnt
->cl_procinfo
[proc
];
273 /* Perform the RPC call. If an error occurs, try again */
274 if ((status
= rpc_call_sync(clnt
, &msg
, 0)) < 0) {
275 dprintk("lockd: rpc_call returned error %d\n", -status
);
277 case -EPROTONOSUPPORT
:
283 nlm_rebind_host(host
);
287 return signalled () ? -EINTR
: status
;
293 if (resp
->status
== nlm_lck_denied_grace_period
) {
294 dprintk("lockd: server in grace period\n");
297 "lockd: spurious grace period reject?!\n");
301 if (!argp
->reclaim
) {
302 /* We appear to be out of the grace period */
303 wake_up_all(&host
->h_gracewait
);
305 dprintk("lockd: server returns status %d\n", resp
->status
);
306 return 0; /* Okay, call complete */
311 * The server has rebooted and appears to be in the grace
312 * period during which locks are only allowed to be
314 * We can only back off and try again later.
316 status
= nlm_wait_on_grace(&host
->h_gracewait
);
317 } while (status
== 0);
323 * Generic NLM call, async version.
325 static struct rpc_task
*__nlm_async_call(struct nlm_rqst
*req
, u32 proc
, struct rpc_message
*msg
, const struct rpc_call_ops
*tk_ops
)
327 struct nlm_host
*host
= req
->a_host
;
328 struct rpc_clnt
*clnt
;
329 struct rpc_task_setup task_setup_data
= {
331 .callback_ops
= tk_ops
,
332 .callback_data
= req
,
333 .flags
= RPC_TASK_ASYNC
,
336 dprintk("lockd: call procedure %d on %s (async)\n",
337 (int)proc
, host
->h_name
);
339 /* If we have no RPC client yet, create one. */
340 clnt
= nlm_bind_host(host
);
343 msg
->rpc_proc
= &clnt
->cl_procinfo
[proc
];
344 task_setup_data
.rpc_client
= clnt
;
346 /* bootstrap and kick off the async RPC call */
347 return rpc_run_task(&task_setup_data
);
349 tk_ops
->rpc_release(req
);
350 return ERR_PTR(-ENOLCK
);
353 static int nlm_do_async_call(struct nlm_rqst
*req
, u32 proc
, struct rpc_message
*msg
, const struct rpc_call_ops
*tk_ops
)
355 struct rpc_task
*task
;
357 task
= __nlm_async_call(req
, proc
, msg
, tk_ops
);
359 return PTR_ERR(task
);
365 * NLM asynchronous call.
367 int nlm_async_call(struct nlm_rqst
*req
, u32 proc
, const struct rpc_call_ops
*tk_ops
)
369 struct rpc_message msg
= {
370 .rpc_argp
= &req
->a_args
,
371 .rpc_resp
= &req
->a_res
,
373 return nlm_do_async_call(req
, proc
, &msg
, tk_ops
);
376 int nlm_async_reply(struct nlm_rqst
*req
, u32 proc
, const struct rpc_call_ops
*tk_ops
)
378 struct rpc_message msg
= {
379 .rpc_argp
= &req
->a_res
,
381 return nlm_do_async_call(req
, proc
, &msg
, tk_ops
);
385 * NLM client asynchronous call.
387 * Note that although the calls are asynchronous, and are therefore
388 * guaranteed to complete, we still always attempt to wait for
389 * completion in order to be able to correctly track the lock
392 static int nlmclnt_async_call(struct rpc_cred
*cred
, struct nlm_rqst
*req
, u32 proc
, const struct rpc_call_ops
*tk_ops
)
394 struct rpc_message msg
= {
395 .rpc_argp
= &req
->a_args
,
396 .rpc_resp
= &req
->a_res
,
399 struct rpc_task
*task
;
402 task
= __nlm_async_call(req
, proc
, &msg
, tk_ops
);
404 return PTR_ERR(task
);
405 err
= rpc_wait_for_completion_task(task
);
411 * TEST for the presence of a conflicting lock
414 nlmclnt_test(struct nlm_rqst
*req
, struct file_lock
*fl
)
418 status
= nlmclnt_call(nfs_file_cred(fl
->fl_file
), req
, NLMPROC_TEST
);
422 switch (req
->a_res
.status
) {
424 fl
->fl_type
= F_UNLCK
;
428 * Report the conflicting lock back to the application.
430 fl
->fl_start
= req
->a_res
.lock
.fl
.fl_start
;
431 fl
->fl_end
= req
->a_res
.lock
.fl
.fl_end
;
432 fl
->fl_type
= req
->a_res
.lock
.fl
.fl_type
;
436 status
= nlm_stat_to_errno(req
->a_res
.status
);
439 nlmclnt_release_call(req
);
443 static void nlmclnt_locks_copy_lock(struct file_lock
*new, struct file_lock
*fl
)
445 spin_lock(&fl
->fl_u
.nfs_fl
.owner
->host
->h_lock
);
446 new->fl_u
.nfs_fl
.state
= fl
->fl_u
.nfs_fl
.state
;
447 new->fl_u
.nfs_fl
.owner
= nlm_get_lockowner(fl
->fl_u
.nfs_fl
.owner
);
448 list_add_tail(&new->fl_u
.nfs_fl
.list
, &fl
->fl_u
.nfs_fl
.owner
->host
->h_granted
);
449 spin_unlock(&fl
->fl_u
.nfs_fl
.owner
->host
->h_lock
);
452 static void nlmclnt_locks_release_private(struct file_lock
*fl
)
454 spin_lock(&fl
->fl_u
.nfs_fl
.owner
->host
->h_lock
);
455 list_del(&fl
->fl_u
.nfs_fl
.list
);
456 spin_unlock(&fl
->fl_u
.nfs_fl
.owner
->host
->h_lock
);
457 nlm_put_lockowner(fl
->fl_u
.nfs_fl
.owner
);
460 static const struct file_lock_operations nlmclnt_lock_ops
= {
461 .fl_copy_lock
= nlmclnt_locks_copy_lock
,
462 .fl_release_private
= nlmclnt_locks_release_private
,
465 static void nlmclnt_locks_init_private(struct file_lock
*fl
, struct nlm_host
*host
)
467 BUG_ON(fl
->fl_ops
!= NULL
);
468 fl
->fl_u
.nfs_fl
.state
= 0;
469 fl
->fl_u
.nfs_fl
.owner
= nlm_find_lockowner(host
, fl
->fl_owner
);
470 INIT_LIST_HEAD(&fl
->fl_u
.nfs_fl
.list
);
471 fl
->fl_ops
= &nlmclnt_lock_ops
;
474 static int do_vfs_lock(struct file_lock
*fl
)
477 switch (fl
->fl_flags
& (FL_POSIX
|FL_FLOCK
)) {
479 res
= posix_lock_file_wait(fl
->fl_file
, fl
);
482 res
= flock_lock_file_wait(fl
->fl_file
, fl
);
491 * LOCK: Try to create a lock
493 * Programmer Harassment Alert
495 * When given a blocking lock request in a sync RPC call, the HPUX lockd
496 * will faithfully return LCK_BLOCKED but never cares to notify us when
497 * the lock could be granted. This way, our local process could hang
498 * around forever waiting for the callback.
500 * Solution A: Implement busy-waiting
501 * Solution B: Use the async version of the call (NLM_LOCK_{MSG,RES})
503 * For now I am implementing solution A, because I hate the idea of
504 * re-implementing lockd for a third time in two months. The async
505 * calls shouldn't be too hard to do, however.
507 * This is one of the lovely things about standards in the NFS area:
508 * they're so soft and squishy you can't really blame HP for doing this.
511 nlmclnt_lock(struct nlm_rqst
*req
, struct file_lock
*fl
)
513 struct rpc_cred
*cred
= nfs_file_cred(fl
->fl_file
);
514 struct nlm_host
*host
= req
->a_host
;
515 struct nlm_res
*resp
= &req
->a_res
;
516 struct nlm_wait
*block
= NULL
;
517 unsigned char fl_flags
= fl
->fl_flags
;
518 unsigned char fl_type
;
519 int status
= -ENOLCK
;
521 if (nsm_monitor(host
) < 0)
523 req
->a_args
.state
= nsm_local_state
;
525 fl
->fl_flags
|= FL_ACCESS
;
526 status
= do_vfs_lock(fl
);
527 fl
->fl_flags
= fl_flags
;
531 block
= nlmclnt_prepare_block(host
, fl
);
534 * Initialise resp->status to a valid non-zero value,
535 * since 0 == nlm_lck_granted
537 resp
->status
= nlm_lck_blocked
;
539 /* Reboot protection */
540 fl
->fl_u
.nfs_fl
.state
= host
->h_state
;
541 status
= nlmclnt_call(cred
, req
, NLMPROC_LOCK
);
544 /* Did a reclaimer thread notify us of a server reboot? */
545 if (resp
->status
== nlm_lck_denied_grace_period
)
547 if (resp
->status
!= nlm_lck_blocked
)
549 /* Wait on an NLM blocking lock */
550 status
= nlmclnt_block(block
, req
, NLMCLNT_POLL_TIMEOUT
);
553 if (resp
->status
!= nlm_lck_blocked
)
557 /* if we were interrupted while blocking, then cancel the lock request
560 if (resp
->status
== nlm_lck_blocked
) {
561 if (!req
->a_args
.block
)
563 if (nlmclnt_cancel(host
, req
->a_args
.block
, fl
) == 0)
567 if (resp
->status
== nlm_granted
) {
568 down_read(&host
->h_rwsem
);
569 /* Check whether or not the server has rebooted */
570 if (fl
->fl_u
.nfs_fl
.state
!= host
->h_state
) {
571 up_read(&host
->h_rwsem
);
574 /* Ensure the resulting lock will get added to granted list */
575 fl
->fl_flags
|= FL_SLEEP
;
576 if (do_vfs_lock(fl
) < 0)
577 printk(KERN_WARNING
"%s: VFS is out of sync with lock manager!\n", __func__
);
578 up_read(&host
->h_rwsem
);
579 fl
->fl_flags
= fl_flags
;
585 * EAGAIN doesn't make sense for sleeping locks, and in some
586 * cases NLM_LCK_DENIED is returned for a permanent error. So
587 * turn it into an ENOLCK.
589 if (resp
->status
== nlm_lck_denied
&& (fl_flags
& FL_SLEEP
))
592 status
= nlm_stat_to_errno(resp
->status
);
594 nlmclnt_finish_block(block
);
596 nlmclnt_release_call(req
);
599 /* Fatal error: ensure that we remove the lock altogether */
600 dprintk("lockd: lock attempt ended in fatal error.\n"
601 " Attempting to unlock.\n");
602 nlmclnt_finish_block(block
);
603 fl_type
= fl
->fl_type
;
604 fl
->fl_type
= F_UNLCK
;
605 down_read(&host
->h_rwsem
);
607 up_read(&host
->h_rwsem
);
608 fl
->fl_type
= fl_type
;
609 fl
->fl_flags
= fl_flags
;
610 nlmclnt_async_call(cred
, req
, NLMPROC_UNLOCK
, &nlmclnt_unlock_ops
);
615 * RECLAIM: Try to reclaim a lock
618 nlmclnt_reclaim(struct nlm_host
*host
, struct file_lock
*fl
)
620 struct nlm_rqst reqst
, *req
;
624 memset(req
, 0, sizeof(*req
));
625 locks_init_lock(&req
->a_args
.lock
.fl
);
626 locks_init_lock(&req
->a_res
.lock
.fl
);
630 /* Set up the argument struct */
631 nlmclnt_setlockargs(req
, fl
);
632 req
->a_args
.reclaim
= 1;
634 status
= nlmclnt_call(nfs_file_cred(fl
->fl_file
), req
, NLMPROC_LOCK
);
635 if (status
>= 0 && req
->a_res
.status
== nlm_granted
)
638 printk(KERN_WARNING
"lockd: failed to reclaim lock for pid %d "
639 "(errno %d, status %d)\n", fl
->fl_pid
,
640 status
, ntohl(req
->a_res
.status
));
643 * FIXME: This is a serious failure. We can
645 * a. Ignore the problem
646 * b. Send the owning process some signal (Linux doesn't have
647 * SIGLOST, though...)
648 * c. Retry the operation
650 * Until someone comes up with a simple implementation
651 * for b or c, I'll choose option a.
658 * UNLOCK: remove an existing lock
661 nlmclnt_unlock(struct nlm_rqst
*req
, struct file_lock
*fl
)
663 struct nlm_host
*host
= req
->a_host
;
664 struct nlm_res
*resp
= &req
->a_res
;
666 unsigned char fl_flags
= fl
->fl_flags
;
669 * Note: the server is supposed to either grant us the unlock
670 * request, or to deny it with NLM_LCK_DENIED_GRACE_PERIOD. In either
671 * case, we want to unlock.
673 fl
->fl_flags
|= FL_EXISTS
;
674 down_read(&host
->h_rwsem
);
675 status
= do_vfs_lock(fl
);
676 up_read(&host
->h_rwsem
);
677 fl
->fl_flags
= fl_flags
;
678 if (status
== -ENOENT
) {
683 atomic_inc(&req
->a_count
);
684 status
= nlmclnt_async_call(nfs_file_cred(fl
->fl_file
), req
,
685 NLMPROC_UNLOCK
, &nlmclnt_unlock_ops
);
689 if (resp
->status
== nlm_granted
)
692 if (resp
->status
!= nlm_lck_denied_nolocks
)
693 printk("lockd: unexpected unlock status: %d\n", resp
->status
);
694 /* What to do now? I'm out of my depth... */
697 nlmclnt_release_call(req
);
701 static void nlmclnt_unlock_callback(struct rpc_task
*task
, void *data
)
703 struct nlm_rqst
*req
= data
;
704 u32 status
= ntohl(req
->a_res
.status
);
706 if (RPC_ASSASSINATED(task
))
709 if (task
->tk_status
< 0) {
710 dprintk("lockd: unlock failed (err = %d)\n", -task
->tk_status
);
713 if (status
== NLM_LCK_DENIED_GRACE_PERIOD
) {
714 rpc_delay(task
, NLMCLNT_GRACE_WAIT
);
717 if (status
!= NLM_LCK_GRANTED
)
718 printk(KERN_WARNING
"lockd: unexpected unlock status: %d\n", status
);
722 nlm_rebind_host(req
->a_host
);
724 rpc_restart_call(task
);
727 static const struct rpc_call_ops nlmclnt_unlock_ops
= {
728 .rpc_call_done
= nlmclnt_unlock_callback
,
729 .rpc_release
= nlmclnt_rpc_release
,
733 * Cancel a blocked lock request.
734 * We always use an async RPC call for this in order not to hang a
735 * process that has been Ctrl-C'ed.
737 static int nlmclnt_cancel(struct nlm_host
*host
, int block
, struct file_lock
*fl
)
739 struct nlm_rqst
*req
;
742 dprintk("lockd: blocking lock attempt was interrupted by a signal.\n"
743 " Attempting to cancel lock.\n");
745 req
= nlm_alloc_call(nlm_get_host(host
));
748 req
->a_flags
= RPC_TASK_ASYNC
;
750 nlmclnt_setlockargs(req
, fl
);
751 req
->a_args
.block
= block
;
753 atomic_inc(&req
->a_count
);
754 status
= nlmclnt_async_call(nfs_file_cred(fl
->fl_file
), req
,
755 NLMPROC_CANCEL
, &nlmclnt_cancel_ops
);
756 if (status
== 0 && req
->a_res
.status
== nlm_lck_denied
)
758 nlmclnt_release_call(req
);
762 static void nlmclnt_cancel_callback(struct rpc_task
*task
, void *data
)
764 struct nlm_rqst
*req
= data
;
765 u32 status
= ntohl(req
->a_res
.status
);
767 if (RPC_ASSASSINATED(task
))
770 if (task
->tk_status
< 0) {
771 dprintk("lockd: CANCEL call error %d, retrying.\n",
776 dprintk("lockd: cancel status %u (task %u)\n",
777 status
, task
->tk_pid
);
780 case NLM_LCK_GRANTED
:
781 case NLM_LCK_DENIED_GRACE_PERIOD
:
783 /* Everything's good */
785 case NLM_LCK_DENIED_NOLOCKS
:
786 dprintk("lockd: CANCEL failed (server has no locks)\n");
789 printk(KERN_NOTICE
"lockd: weird return %d for CANCEL call\n",
797 /* Don't ever retry more than 3 times */
798 if (req
->a_retries
++ >= NLMCLNT_MAX_RETRIES
)
800 nlm_rebind_host(req
->a_host
);
801 rpc_restart_call(task
);
802 rpc_delay(task
, 30 * HZ
);
805 static const struct rpc_call_ops nlmclnt_cancel_ops
= {
806 .rpc_call_done
= nlmclnt_cancel_callback
,
807 .rpc_release
= nlmclnt_rpc_release
,
811 * Convert an NLM status code to a generic kernel errno
814 nlm_stat_to_errno(__be32 status
)
816 switch(ntohl(status
)) {
817 case NLM_LCK_GRANTED
:
821 case NLM_LCK_DENIED_NOLOCKS
:
822 case NLM_LCK_DENIED_GRACE_PERIOD
:
824 case NLM_LCK_BLOCKED
:
825 printk(KERN_NOTICE
"lockd: unexpected status NLM_BLOCKED\n");
827 #ifdef CONFIG_LOCKD_V4
840 printk(KERN_NOTICE
"lockd: unexpected server status %d\n", status
);