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 refcount_inc(&lockowner
->count
);
55 static void nlm_put_lockowner(struct nlm_lockowner
*lockowner
)
57 if (!refcount_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 refcount_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
;
128 char *nodename
= req
->a_host
->h_rpcclnt
->cl_nodename
;
130 nlmclnt_next_cookie(&argp
->cookie
);
131 memcpy(&lock
->fh
, NFS_FH(file_inode(fl
->fl_file
)), sizeof(struct nfs_fh
));
132 lock
->caller
= nodename
;
133 lock
->oh
.data
= req
->a_owner
;
134 lock
->oh
.len
= snprintf(req
->a_owner
, sizeof(req
->a_owner
), "%u@%s",
135 (unsigned int)fl
->fl_u
.nfs_fl
.owner
->pid
,
137 lock
->svid
= fl
->fl_u
.nfs_fl
.owner
->pid
;
138 lock
->fl
.fl_start
= fl
->fl_start
;
139 lock
->fl
.fl_end
= fl
->fl_end
;
140 lock
->fl
.fl_type
= fl
->fl_type
;
143 static void nlmclnt_release_lockargs(struct nlm_rqst
*req
)
145 WARN_ON_ONCE(req
->a_args
.lock
.fl
.fl_ops
!= NULL
);
149 * nlmclnt_proc - Perform a single client-side lock request
150 * @host: address of a valid nlm_host context representing the NLM server
151 * @cmd: fcntl-style file lock operation to perform
152 * @fl: address of arguments for the lock operation
153 * @data: address of data to be sent to callback operations
156 int nlmclnt_proc(struct nlm_host
*host
, int cmd
, struct file_lock
*fl
, void *data
)
158 struct nlm_rqst
*call
;
160 const struct nlmclnt_operations
*nlmclnt_ops
= host
->h_nlmclnt_ops
;
162 call
= nlm_alloc_call(host
);
166 if (nlmclnt_ops
&& nlmclnt_ops
->nlmclnt_alloc_call
)
167 nlmclnt_ops
->nlmclnt_alloc_call(data
);
169 nlmclnt_locks_init_private(fl
, host
);
170 if (!fl
->fl_u
.nfs_fl
.owner
) {
171 /* lockowner allocation has failed */
172 nlmclnt_release_call(call
);
175 /* Set up the argument struct */
176 nlmclnt_setlockargs(call
, fl
);
177 call
->a_callback_data
= data
;
179 if (IS_SETLK(cmd
) || IS_SETLKW(cmd
)) {
180 if (fl
->fl_type
!= F_UNLCK
) {
181 call
->a_args
.block
= IS_SETLKW(cmd
) ? 1 : 0;
182 status
= nlmclnt_lock(call
, fl
);
184 status
= nlmclnt_unlock(call
, fl
);
185 } else if (IS_GETLK(cmd
))
186 status
= nlmclnt_test(call
, fl
);
189 fl
->fl_ops
->fl_release_private(fl
);
192 dprintk("lockd: clnt proc returns %d\n", status
);
195 EXPORT_SYMBOL_GPL(nlmclnt_proc
);
198 * Allocate an NLM RPC call struct
200 struct nlm_rqst
*nlm_alloc_call(struct nlm_host
*host
)
202 struct nlm_rqst
*call
;
205 call
= kzalloc(sizeof(*call
), GFP_KERNEL
);
207 refcount_set(&call
->a_count
, 1);
208 locks_init_lock(&call
->a_args
.lock
.fl
);
209 locks_init_lock(&call
->a_res
.lock
.fl
);
210 call
->a_host
= nlm_get_host(host
);
215 printk("nlm_alloc_call: failed, waiting for memory\n");
216 schedule_timeout_interruptible(5*HZ
);
221 void nlmclnt_release_call(struct nlm_rqst
*call
)
223 const struct nlmclnt_operations
*nlmclnt_ops
= call
->a_host
->h_nlmclnt_ops
;
225 if (!refcount_dec_and_test(&call
->a_count
))
227 if (nlmclnt_ops
&& nlmclnt_ops
->nlmclnt_release_call
)
228 nlmclnt_ops
->nlmclnt_release_call(call
->a_callback_data
);
229 nlmclnt_release_host(call
->a_host
);
230 nlmclnt_release_lockargs(call
);
234 static void nlmclnt_rpc_release(void *data
)
236 nlmclnt_release_call(data
);
239 static int nlm_wait_on_grace(wait_queue_head_t
*queue
)
244 prepare_to_wait(queue
, &wait
, TASK_INTERRUPTIBLE
);
246 schedule_timeout(NLMCLNT_GRACE_WAIT
);
251 finish_wait(queue
, &wait
);
259 nlmclnt_call(struct rpc_cred
*cred
, struct nlm_rqst
*req
, u32 proc
)
261 struct nlm_host
*host
= req
->a_host
;
262 struct rpc_clnt
*clnt
;
263 struct nlm_args
*argp
= &req
->a_args
;
264 struct nlm_res
*resp
= &req
->a_res
;
265 struct rpc_message msg
= {
272 dprintk("lockd: call procedure %d on %s\n",
273 (int)proc
, host
->h_name
);
276 if (host
->h_reclaiming
&& !argp
->reclaim
)
277 goto in_grace_period
;
279 /* If we have no RPC client yet, create one. */
280 if ((clnt
= nlm_bind_host(host
)) == NULL
)
282 msg
.rpc_proc
= &clnt
->cl_procinfo
[proc
];
284 /* Perform the RPC call. If an error occurs, try again */
285 if ((status
= rpc_call_sync(clnt
, &msg
, 0)) < 0) {
286 dprintk("lockd: rpc_call returned error %d\n", -status
);
288 case -EPROTONOSUPPORT
:
294 nlm_rebind_host(host
);
298 return signalled () ? -EINTR
: status
;
304 if (resp
->status
== nlm_lck_denied_grace_period
) {
305 dprintk("lockd: server in grace period\n");
308 "lockd: spurious grace period reject?!\n");
312 if (!argp
->reclaim
) {
313 /* We appear to be out of the grace period */
314 wake_up_all(&host
->h_gracewait
);
316 dprintk("lockd: server returns status %d\n",
317 ntohl(resp
->status
));
318 return 0; /* Okay, call complete */
323 * The server has rebooted and appears to be in the grace
324 * period during which locks are only allowed to be
326 * We can only back off and try again later.
328 status
= nlm_wait_on_grace(&host
->h_gracewait
);
329 } while (status
== 0);
335 * Generic NLM call, async version.
337 static struct rpc_task
*__nlm_async_call(struct nlm_rqst
*req
, u32 proc
, struct rpc_message
*msg
, const struct rpc_call_ops
*tk_ops
)
339 struct nlm_host
*host
= req
->a_host
;
340 struct rpc_clnt
*clnt
;
341 struct rpc_task_setup task_setup_data
= {
343 .callback_ops
= tk_ops
,
344 .callback_data
= req
,
345 .flags
= RPC_TASK_ASYNC
,
348 dprintk("lockd: call procedure %d on %s (async)\n",
349 (int)proc
, host
->h_name
);
351 /* If we have no RPC client yet, create one. */
352 clnt
= nlm_bind_host(host
);
355 msg
->rpc_proc
= &clnt
->cl_procinfo
[proc
];
356 task_setup_data
.rpc_client
= clnt
;
358 /* bootstrap and kick off the async RPC call */
359 return rpc_run_task(&task_setup_data
);
361 tk_ops
->rpc_release(req
);
362 return ERR_PTR(-ENOLCK
);
365 static int nlm_do_async_call(struct nlm_rqst
*req
, u32 proc
, struct rpc_message
*msg
, const struct rpc_call_ops
*tk_ops
)
367 struct rpc_task
*task
;
369 task
= __nlm_async_call(req
, proc
, msg
, tk_ops
);
371 return PTR_ERR(task
);
377 * NLM asynchronous call.
379 int nlm_async_call(struct nlm_rqst
*req
, u32 proc
, const struct rpc_call_ops
*tk_ops
)
381 struct rpc_message msg
= {
382 .rpc_argp
= &req
->a_args
,
383 .rpc_resp
= &req
->a_res
,
385 return nlm_do_async_call(req
, proc
, &msg
, tk_ops
);
388 int nlm_async_reply(struct nlm_rqst
*req
, u32 proc
, const struct rpc_call_ops
*tk_ops
)
390 struct rpc_message msg
= {
391 .rpc_argp
= &req
->a_res
,
393 return nlm_do_async_call(req
, proc
, &msg
, tk_ops
);
397 * NLM client asynchronous call.
399 * Note that although the calls are asynchronous, and are therefore
400 * guaranteed to complete, we still always attempt to wait for
401 * completion in order to be able to correctly track the lock
404 static int nlmclnt_async_call(struct rpc_cred
*cred
, struct nlm_rqst
*req
, u32 proc
, const struct rpc_call_ops
*tk_ops
)
406 struct rpc_message msg
= {
407 .rpc_argp
= &req
->a_args
,
408 .rpc_resp
= &req
->a_res
,
411 struct rpc_task
*task
;
414 task
= __nlm_async_call(req
, proc
, &msg
, tk_ops
);
416 return PTR_ERR(task
);
417 err
= rpc_wait_for_completion_task(task
);
423 * TEST for the presence of a conflicting lock
426 nlmclnt_test(struct nlm_rqst
*req
, struct file_lock
*fl
)
430 status
= nlmclnt_call(nfs_file_cred(fl
->fl_file
), req
, NLMPROC_TEST
);
434 switch (req
->a_res
.status
) {
436 fl
->fl_type
= F_UNLCK
;
440 * Report the conflicting lock back to the application.
442 fl
->fl_start
= req
->a_res
.lock
.fl
.fl_start
;
443 fl
->fl_end
= req
->a_res
.lock
.fl
.fl_end
;
444 fl
->fl_type
= req
->a_res
.lock
.fl
.fl_type
;
448 status
= nlm_stat_to_errno(req
->a_res
.status
);
451 nlmclnt_release_call(req
);
455 static void nlmclnt_locks_copy_lock(struct file_lock
*new, struct file_lock
*fl
)
457 spin_lock(&fl
->fl_u
.nfs_fl
.owner
->host
->h_lock
);
458 new->fl_u
.nfs_fl
.state
= fl
->fl_u
.nfs_fl
.state
;
459 new->fl_u
.nfs_fl
.owner
= nlm_get_lockowner(fl
->fl_u
.nfs_fl
.owner
);
460 list_add_tail(&new->fl_u
.nfs_fl
.list
, &fl
->fl_u
.nfs_fl
.owner
->host
->h_granted
);
461 spin_unlock(&fl
->fl_u
.nfs_fl
.owner
->host
->h_lock
);
464 static void nlmclnt_locks_release_private(struct file_lock
*fl
)
466 spin_lock(&fl
->fl_u
.nfs_fl
.owner
->host
->h_lock
);
467 list_del(&fl
->fl_u
.nfs_fl
.list
);
468 spin_unlock(&fl
->fl_u
.nfs_fl
.owner
->host
->h_lock
);
469 nlm_put_lockowner(fl
->fl_u
.nfs_fl
.owner
);
472 static const struct file_lock_operations nlmclnt_lock_ops
= {
473 .fl_copy_lock
= nlmclnt_locks_copy_lock
,
474 .fl_release_private
= nlmclnt_locks_release_private
,
477 static void nlmclnt_locks_init_private(struct file_lock
*fl
, struct nlm_host
*host
)
479 fl
->fl_u
.nfs_fl
.state
= 0;
480 fl
->fl_u
.nfs_fl
.owner
= nlm_find_lockowner(host
, fl
->fl_owner
);
481 INIT_LIST_HEAD(&fl
->fl_u
.nfs_fl
.list
);
482 fl
->fl_ops
= &nlmclnt_lock_ops
;
485 static int do_vfs_lock(struct file_lock
*fl
)
487 return locks_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
,
619 struct nlm_rqst
*req
)
623 memset(req
, 0, sizeof(*req
));
624 locks_init_lock(&req
->a_args
.lock
.fl
);
625 locks_init_lock(&req
->a_res
.lock
.fl
);
628 /* Set up the argument struct */
629 nlmclnt_setlockargs(req
, fl
);
630 req
->a_args
.reclaim
= 1;
632 status
= nlmclnt_call(nfs_file_cred(fl
->fl_file
), req
, NLMPROC_LOCK
);
633 if (status
>= 0 && req
->a_res
.status
== nlm_granted
)
636 printk(KERN_WARNING
"lockd: failed to reclaim lock for pid %d "
637 "(errno %d, status %d)\n", fl
->fl_pid
,
638 status
, ntohl(req
->a_res
.status
));
641 * FIXME: This is a serious failure. We can
643 * a. Ignore the problem
644 * b. Send the owning process some signal (Linux doesn't have
645 * SIGLOST, though...)
646 * c. Retry the operation
648 * Until someone comes up with a simple implementation
649 * for b or c, I'll choose option a.
656 * UNLOCK: remove an existing lock
659 nlmclnt_unlock(struct nlm_rqst
*req
, struct file_lock
*fl
)
661 struct nlm_host
*host
= req
->a_host
;
662 struct nlm_res
*resp
= &req
->a_res
;
664 unsigned char fl_flags
= fl
->fl_flags
;
667 * Note: the server is supposed to either grant us the unlock
668 * request, or to deny it with NLM_LCK_DENIED_GRACE_PERIOD. In either
669 * case, we want to unlock.
671 fl
->fl_flags
|= FL_EXISTS
;
672 down_read(&host
->h_rwsem
);
673 status
= do_vfs_lock(fl
);
674 up_read(&host
->h_rwsem
);
675 fl
->fl_flags
= fl_flags
;
676 if (status
== -ENOENT
) {
681 refcount_inc(&req
->a_count
);
682 status
= nlmclnt_async_call(nfs_file_cred(fl
->fl_file
), req
,
683 NLMPROC_UNLOCK
, &nlmclnt_unlock_ops
);
687 if (resp
->status
== nlm_granted
)
690 if (resp
->status
!= nlm_lck_denied_nolocks
)
691 printk("lockd: unexpected unlock status: %d\n",
692 ntohl(resp
->status
));
693 /* What to do now? I'm out of my depth... */
696 nlmclnt_release_call(req
);
700 static void nlmclnt_unlock_prepare(struct rpc_task
*task
, void *data
)
702 struct nlm_rqst
*req
= data
;
703 const struct nlmclnt_operations
*nlmclnt_ops
= req
->a_host
->h_nlmclnt_ops
;
704 bool defer_call
= false;
706 if (nlmclnt_ops
&& nlmclnt_ops
->nlmclnt_unlock_prepare
)
707 defer_call
= nlmclnt_ops
->nlmclnt_unlock_prepare(task
, req
->a_callback_data
);
710 rpc_call_start(task
);
713 static void nlmclnt_unlock_callback(struct rpc_task
*task
, void *data
)
715 struct nlm_rqst
*req
= data
;
716 u32 status
= ntohl(req
->a_res
.status
);
718 if (RPC_ASSASSINATED(task
))
721 if (task
->tk_status
< 0) {
722 dprintk("lockd: unlock failed (err = %d)\n", -task
->tk_status
);
723 switch (task
->tk_status
) {
731 if (status
== NLM_LCK_DENIED_GRACE_PERIOD
) {
732 rpc_delay(task
, NLMCLNT_GRACE_WAIT
);
735 if (status
!= NLM_LCK_GRANTED
)
736 printk(KERN_WARNING
"lockd: unexpected unlock status: %d\n", status
);
740 nlm_rebind_host(req
->a_host
);
742 rpc_restart_call(task
);
745 static const struct rpc_call_ops nlmclnt_unlock_ops
= {
746 .rpc_call_prepare
= nlmclnt_unlock_prepare
,
747 .rpc_call_done
= nlmclnt_unlock_callback
,
748 .rpc_release
= nlmclnt_rpc_release
,
752 * Cancel a blocked lock request.
753 * We always use an async RPC call for this in order not to hang a
754 * process that has been Ctrl-C'ed.
756 static int nlmclnt_cancel(struct nlm_host
*host
, int block
, struct file_lock
*fl
)
758 struct nlm_rqst
*req
;
761 dprintk("lockd: blocking lock attempt was interrupted by a signal.\n"
762 " Attempting to cancel lock.\n");
764 req
= nlm_alloc_call(host
);
767 req
->a_flags
= RPC_TASK_ASYNC
;
769 nlmclnt_setlockargs(req
, fl
);
770 req
->a_args
.block
= block
;
772 refcount_inc(&req
->a_count
);
773 status
= nlmclnt_async_call(nfs_file_cred(fl
->fl_file
), req
,
774 NLMPROC_CANCEL
, &nlmclnt_cancel_ops
);
775 if (status
== 0 && req
->a_res
.status
== nlm_lck_denied
)
777 nlmclnt_release_call(req
);
781 static void nlmclnt_cancel_callback(struct rpc_task
*task
, void *data
)
783 struct nlm_rqst
*req
= data
;
784 u32 status
= ntohl(req
->a_res
.status
);
786 if (RPC_ASSASSINATED(task
))
789 if (task
->tk_status
< 0) {
790 dprintk("lockd: CANCEL call error %d, retrying.\n",
795 dprintk("lockd: cancel status %u (task %u)\n",
796 status
, task
->tk_pid
);
799 case NLM_LCK_GRANTED
:
800 case NLM_LCK_DENIED_GRACE_PERIOD
:
802 /* Everything's good */
804 case NLM_LCK_DENIED_NOLOCKS
:
805 dprintk("lockd: CANCEL failed (server has no locks)\n");
808 printk(KERN_NOTICE
"lockd: weird return %d for CANCEL call\n",
816 /* Don't ever retry more than 3 times */
817 if (req
->a_retries
++ >= NLMCLNT_MAX_RETRIES
)
819 nlm_rebind_host(req
->a_host
);
820 rpc_restart_call(task
);
821 rpc_delay(task
, 30 * HZ
);
824 static const struct rpc_call_ops nlmclnt_cancel_ops
= {
825 .rpc_call_done
= nlmclnt_cancel_callback
,
826 .rpc_release
= nlmclnt_rpc_release
,
830 * Convert an NLM status code to a generic kernel errno
833 nlm_stat_to_errno(__be32 status
)
835 switch(ntohl(status
)) {
836 case NLM_LCK_GRANTED
:
840 case NLM_LCK_DENIED_NOLOCKS
:
841 case NLM_LCK_DENIED_GRACE_PERIOD
:
843 case NLM_LCK_BLOCKED
:
844 printk(KERN_NOTICE
"lockd: unexpected status NLM_BLOCKED\n");
846 #ifdef CONFIG_LOCKD_V4
859 printk(KERN_NOTICE
"lockd: unexpected server status %d\n",