2 * linux/fs/lockd/svclock.c
4 * Handling of server-side locks, mostly of the blocked variety.
5 * This is the ugliest part of lockd because we tread on very thin ice.
6 * GRANT and CANCEL calls may get stuck, meet in mid-flight, etc.
7 * IMNSHO introducing the grant callback into the NLM protocol was one
8 * of the worst ideas Sun ever had. Except maybe for the idea of doing
9 * NFS file locking at all.
11 * I'm trying hard to avoid race conditions by protecting most accesses
12 * to a file's list of blocked locks through a semaphore. The global
13 * list of blocked locks is not protected in this fashion however.
14 * Therefore, some functions (such as the RPC callback for the async grant
15 * call) move blocked locks towards the head of the list *while some other
16 * process might be traversing it*. This should not be a problem in
17 * practice, because this will only cause functions traversing the list
18 * to visit some blocks twice.
20 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
23 #include <linux/types.h>
24 #include <linux/errno.h>
25 #include <linux/kernel.h>
26 #include <linux/sched.h>
27 #include <linux/smp_lock.h>
28 #include <linux/sunrpc/clnt.h>
29 #include <linux/sunrpc/svc.h>
30 #include <linux/lockd/nlm.h>
31 #include <linux/lockd/lockd.h>
32 #include <linux/kthread.h>
34 #define NLMDBG_FACILITY NLMDBG_SVCLOCK
36 #ifdef CONFIG_LOCKD_V4
37 #define nlm_deadlock nlm4_deadlock
39 #define nlm_deadlock nlm_lck_denied
42 static void nlmsvc_release_block(struct nlm_block
*block
);
43 static void nlmsvc_insert_block(struct nlm_block
*block
, unsigned long);
44 static void nlmsvc_remove_block(struct nlm_block
*block
);
46 static int nlmsvc_setgrantargs(struct nlm_rqst
*call
, struct nlm_lock
*lock
);
47 static void nlmsvc_freegrantargs(struct nlm_rqst
*call
);
48 static const struct rpc_call_ops nlmsvc_grant_ops
;
51 * The list of blocked locks to retry
53 static LIST_HEAD(nlm_blocked
);
56 * Insert a blocked lock into the global list
59 nlmsvc_insert_block(struct nlm_block
*block
, unsigned long when
)
62 struct list_head
*pos
;
64 dprintk("lockd: nlmsvc_insert_block(%p, %ld)\n", block
, when
);
65 if (list_empty(&block
->b_list
)) {
66 kref_get(&block
->b_count
);
68 list_del_init(&block
->b_list
);
72 if (when
!= NLM_NEVER
) {
73 if ((when
+= jiffies
) == NLM_NEVER
)
75 list_for_each(pos
, &nlm_blocked
) {
76 b
= list_entry(pos
, struct nlm_block
, b_list
);
77 if (time_after(b
->b_when
,when
) || b
->b_when
== NLM_NEVER
)
80 /* On normal exit from the loop, pos == &nlm_blocked,
81 * so we will be adding to the end of the list - good
85 list_add_tail(&block
->b_list
, pos
);
90 * Remove a block from the global list
93 nlmsvc_remove_block(struct nlm_block
*block
)
95 if (!list_empty(&block
->b_list
)) {
96 list_del_init(&block
->b_list
);
97 nlmsvc_release_block(block
);
102 * Find a block for a given lock
104 static struct nlm_block
*
105 nlmsvc_lookup_block(struct nlm_file
*file
, struct nlm_lock
*lock
)
107 struct nlm_block
*block
;
108 struct file_lock
*fl
;
110 dprintk("lockd: nlmsvc_lookup_block f=%p pd=%d %Ld-%Ld ty=%d\n",
111 file
, lock
->fl
.fl_pid
,
112 (long long)lock
->fl
.fl_start
,
113 (long long)lock
->fl
.fl_end
, lock
->fl
.fl_type
);
114 list_for_each_entry(block
, &nlm_blocked
, b_list
) {
115 fl
= &block
->b_call
->a_args
.lock
.fl
;
116 dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%s\n",
117 block
->b_file
, fl
->fl_pid
,
118 (long long)fl
->fl_start
,
119 (long long)fl
->fl_end
, fl
->fl_type
,
120 nlmdbg_cookie2a(&block
->b_call
->a_args
.cookie
));
121 if (block
->b_file
== file
&& nlm_compare_locks(fl
, &lock
->fl
)) {
122 kref_get(&block
->b_count
);
130 static inline int nlm_cookie_match(struct nlm_cookie
*a
, struct nlm_cookie
*b
)
132 if (a
->len
!= b
->len
)
134 if (memcmp(a
->data
, b
->data
, a
->len
))
140 * Find a block with a given NLM cookie.
142 static inline struct nlm_block
*
143 nlmsvc_find_block(struct nlm_cookie
*cookie
)
145 struct nlm_block
*block
;
147 list_for_each_entry(block
, &nlm_blocked
, b_list
) {
148 if (nlm_cookie_match(&block
->b_call
->a_args
.cookie
,cookie
))
155 dprintk("nlmsvc_find_block(%s): block=%p\n", nlmdbg_cookie2a(cookie
), block
);
156 kref_get(&block
->b_count
);
161 * Create a block and initialize it.
163 * Note: we explicitly set the cookie of the grant reply to that of
164 * the blocked lock request. The spec explicitly mentions that the client
165 * should _not_ rely on the callback containing the same cookie as the
166 * request, but (as I found out later) that's because some implementations
167 * do just this. Never mind the standards comittees, they support our
168 * logging industries.
170 * 10 years later: I hope we can safely ignore these old and broken
171 * clients by now. Let's fix this so we can uniquely identify an incoming
172 * GRANTED_RES message by cookie, without having to rely on the client's IP
175 static struct nlm_block
*
176 nlmsvc_create_block(struct svc_rqst
*rqstp
, struct nlm_host
*host
,
177 struct nlm_file
*file
, struct nlm_lock
*lock
,
178 struct nlm_cookie
*cookie
)
180 struct nlm_block
*block
;
181 struct nlm_rqst
*call
= NULL
;
184 call
= nlm_alloc_call(host
);
188 /* Allocate memory for block, and initialize arguments */
189 block
= kzalloc(sizeof(*block
), GFP_KERNEL
);
192 kref_init(&block
->b_count
);
193 INIT_LIST_HEAD(&block
->b_list
);
194 INIT_LIST_HEAD(&block
->b_flist
);
196 if (!nlmsvc_setgrantargs(call
, lock
))
199 /* Set notifier function for VFS, and init args */
200 call
->a_args
.lock
.fl
.fl_flags
|= FL_SLEEP
;
201 call
->a_args
.lock
.fl
.fl_lmops
= &nlmsvc_lock_operations
;
202 nlmclnt_next_cookie(&call
->a_args
.cookie
);
204 dprintk("lockd: created block %p...\n", block
);
206 /* Create and initialize the block */
207 block
->b_daemon
= rqstp
->rq_server
;
208 block
->b_host
= host
;
209 block
->b_file
= file
;
213 /* Add to file's list of blocks */
214 list_add(&block
->b_flist
, &file
->f_blocks
);
216 /* Set up RPC arguments for callback */
217 block
->b_call
= call
;
218 call
->a_flags
= RPC_TASK_ASYNC
;
219 call
->a_block
= block
;
226 nlm_release_call(call
);
232 * It is the caller's responsibility to check whether the file
233 * can be closed hereafter.
235 static int nlmsvc_unlink_block(struct nlm_block
*block
)
238 dprintk("lockd: unlinking block %p...\n", block
);
240 /* Remove block from list */
241 status
= posix_unblock_lock(block
->b_file
->f_file
, &block
->b_call
->a_args
.lock
.fl
);
242 nlmsvc_remove_block(block
);
246 static void nlmsvc_free_block(struct kref
*kref
)
248 struct nlm_block
*block
= container_of(kref
, struct nlm_block
, b_count
);
249 struct nlm_file
*file
= block
->b_file
;
251 dprintk("lockd: freeing block %p...\n", block
);
253 /* Remove block from file's list of blocks */
254 mutex_lock(&file
->f_mutex
);
255 list_del_init(&block
->b_flist
);
256 mutex_unlock(&file
->f_mutex
);
258 nlmsvc_freegrantargs(block
->b_call
);
259 nlm_release_call(block
->b_call
);
260 nlm_release_file(block
->b_file
);
265 static void nlmsvc_release_block(struct nlm_block
*block
)
268 kref_put(&block
->b_count
, nlmsvc_free_block
);
272 * Loop over all blocks and delete blocks held by
275 void nlmsvc_traverse_blocks(struct nlm_host
*host
,
276 struct nlm_file
*file
,
277 nlm_host_match_fn_t match
)
279 struct nlm_block
*block
, *next
;
282 mutex_lock(&file
->f_mutex
);
283 list_for_each_entry_safe(block
, next
, &file
->f_blocks
, b_flist
) {
284 if (!match(block
->b_host
, host
))
286 /* Do not destroy blocks that are not on
287 * the global retry list - why? */
288 if (list_empty(&block
->b_list
))
290 kref_get(&block
->b_count
);
291 mutex_unlock(&file
->f_mutex
);
292 nlmsvc_unlink_block(block
);
293 nlmsvc_release_block(block
);
296 mutex_unlock(&file
->f_mutex
);
300 * Initialize arguments for GRANTED call. The nlm_rqst structure
301 * has been cleared already.
303 static int nlmsvc_setgrantargs(struct nlm_rqst
*call
, struct nlm_lock
*lock
)
305 locks_copy_lock(&call
->a_args
.lock
.fl
, &lock
->fl
);
306 memcpy(&call
->a_args
.lock
.fh
, &lock
->fh
, sizeof(call
->a_args
.lock
.fh
));
307 call
->a_args
.lock
.caller
= utsname()->nodename
;
308 call
->a_args
.lock
.oh
.len
= lock
->oh
.len
;
310 /* set default data area */
311 call
->a_args
.lock
.oh
.data
= call
->a_owner
;
312 call
->a_args
.lock
.svid
= lock
->fl
.fl_pid
;
314 if (lock
->oh
.len
> NLMCLNT_OHSIZE
) {
315 void *data
= kmalloc(lock
->oh
.len
, GFP_KERNEL
);
318 call
->a_args
.lock
.oh
.data
= (u8
*) data
;
321 memcpy(call
->a_args
.lock
.oh
.data
, lock
->oh
.data
, lock
->oh
.len
);
325 static void nlmsvc_freegrantargs(struct nlm_rqst
*call
)
327 if (call
->a_args
.lock
.oh
.data
!= call
->a_owner
)
328 kfree(call
->a_args
.lock
.oh
.data
);
332 * Deferred lock request handling for non-blocking lock
335 nlmsvc_defer_lock_rqst(struct svc_rqst
*rqstp
, struct nlm_block
*block
)
337 __be32 status
= nlm_lck_denied_nolocks
;
339 block
->b_flags
|= B_QUEUED
;
341 nlmsvc_insert_block(block
, NLM_TIMEOUT
);
343 block
->b_cache_req
= &rqstp
->rq_chandle
;
344 if (rqstp
->rq_chandle
.defer
) {
345 block
->b_deferred_req
=
346 rqstp
->rq_chandle
.defer(block
->b_cache_req
);
347 if (block
->b_deferred_req
!= NULL
)
348 status
= nlm_drop_reply
;
350 dprintk("lockd: nlmsvc_defer_lock_rqst block %p flags %d status %d\n",
351 block
, block
->b_flags
, ntohl(status
));
357 * Attempt to establish a lock, and if it can't be granted, block it
361 nlmsvc_lock(struct svc_rqst
*rqstp
, struct nlm_file
*file
,
362 struct nlm_host
*host
, struct nlm_lock
*lock
, int wait
,
363 struct nlm_cookie
*cookie
)
365 struct nlm_block
*block
= NULL
;
369 dprintk("lockd: nlmsvc_lock(%s/%ld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
370 file
->f_file
->f_path
.dentry
->d_inode
->i_sb
->s_id
,
371 file
->f_file
->f_path
.dentry
->d_inode
->i_ino
,
372 lock
->fl
.fl_type
, lock
->fl
.fl_pid
,
373 (long long)lock
->fl
.fl_start
,
374 (long long)lock
->fl
.fl_end
,
377 /* Lock file against concurrent access */
378 mutex_lock(&file
->f_mutex
);
379 /* Get existing block (in case client is busy-waiting)
380 * or create new block
382 block
= nlmsvc_lookup_block(file
, lock
);
384 block
= nlmsvc_create_block(rqstp
, host
, file
, lock
, cookie
);
385 ret
= nlm_lck_denied_nolocks
;
388 lock
= &block
->b_call
->a_args
.lock
;
390 lock
->fl
.fl_flags
&= ~FL_SLEEP
;
392 if (block
->b_flags
& B_QUEUED
) {
393 dprintk("lockd: nlmsvc_lock deferred block %p flags %d\n",
394 block
, block
->b_flags
);
395 if (block
->b_granted
) {
396 nlmsvc_unlink_block(block
);
400 if (block
->b_flags
& B_TIMED_OUT
) {
401 nlmsvc_unlink_block(block
);
402 ret
= nlm_lck_denied
;
405 ret
= nlm_drop_reply
;
410 lock
->fl
.fl_flags
&= ~FL_SLEEP
;
411 error
= vfs_lock_file(file
->f_file
, F_SETLK
, &lock
->fl
, NULL
);
412 lock
->fl
.fl_flags
&= ~FL_SLEEP
;
414 dprintk("lockd: vfs_lock_file returned %d\n", error
);
420 ret
= nlm_lck_denied
;
422 case FILE_LOCK_DEFERRED
:
425 /* Filesystem lock operation is in progress
426 Add it to the queue waiting for callback */
427 ret
= nlmsvc_defer_lock_rqst(rqstp
, block
);
432 default: /* includes ENOLCK */
433 ret
= nlm_lck_denied_nolocks
;
437 ret
= nlm_lck_denied
;
441 ret
= nlm_lck_blocked
;
443 /* Append to list of blocked */
444 nlmsvc_insert_block(block
, NLM_NEVER
);
446 mutex_unlock(&file
->f_mutex
);
447 nlmsvc_release_block(block
);
448 dprintk("lockd: nlmsvc_lock returned %u\n", ret
);
453 * Test for presence of a conflicting lock.
456 nlmsvc_testlock(struct svc_rqst
*rqstp
, struct nlm_file
*file
,
457 struct nlm_host
*host
, struct nlm_lock
*lock
,
458 struct nlm_lock
*conflock
, struct nlm_cookie
*cookie
)
460 struct nlm_block
*block
= NULL
;
464 dprintk("lockd: nlmsvc_testlock(%s/%ld, ty=%d, %Ld-%Ld)\n",
465 file
->f_file
->f_path
.dentry
->d_inode
->i_sb
->s_id
,
466 file
->f_file
->f_path
.dentry
->d_inode
->i_ino
,
468 (long long)lock
->fl
.fl_start
,
469 (long long)lock
->fl
.fl_end
);
471 /* Get existing block (in case client is busy-waiting) */
472 block
= nlmsvc_lookup_block(file
, lock
);
475 struct file_lock
*conf
= kzalloc(sizeof(*conf
), GFP_KERNEL
);
479 block
= nlmsvc_create_block(rqstp
, host
, file
, lock
, cookie
);
486 if (block
->b_flags
& B_QUEUED
) {
487 dprintk("lockd: nlmsvc_testlock deferred block %p flags %d fl %p\n",
488 block
, block
->b_flags
, block
->b_fl
);
489 if (block
->b_flags
& B_TIMED_OUT
) {
490 nlmsvc_unlink_block(block
);
491 ret
= nlm_lck_denied
;
494 if (block
->b_flags
& B_GOT_CALLBACK
) {
495 nlmsvc_unlink_block(block
);
496 if (block
->b_fl
!= NULL
497 && block
->b_fl
->fl_type
!= F_UNLCK
) {
498 lock
->fl
= *block
->b_fl
;
505 ret
= nlm_drop_reply
;
509 error
= vfs_test_lock(file
->f_file
, &lock
->fl
);
510 if (error
== FILE_LOCK_DEFERRED
) {
511 ret
= nlmsvc_defer_lock_rqst(rqstp
, block
);
515 ret
= nlm_lck_denied_nolocks
;
518 if (lock
->fl
.fl_type
== F_UNLCK
) {
524 dprintk("lockd: conflicting lock(ty=%d, %Ld-%Ld)\n",
525 lock
->fl
.fl_type
, (long long)lock
->fl
.fl_start
,
526 (long long)lock
->fl
.fl_end
);
527 conflock
->caller
= "somehost"; /* FIXME */
528 conflock
->len
= strlen(conflock
->caller
);
529 conflock
->oh
.len
= 0; /* don't return OH info */
530 conflock
->svid
= lock
->fl
.fl_pid
;
531 conflock
->fl
.fl_type
= lock
->fl
.fl_type
;
532 conflock
->fl
.fl_start
= lock
->fl
.fl_start
;
533 conflock
->fl
.fl_end
= lock
->fl
.fl_end
;
534 ret
= nlm_lck_denied
;
537 nlmsvc_release_block(block
);
543 * This implies a CANCEL call: We send a GRANT_MSG, the client replies
544 * with a GRANT_RES call which gets lost, and calls UNLOCK immediately
545 * afterwards. In this case the block will still be there, and hence
549 nlmsvc_unlock(struct nlm_file
*file
, struct nlm_lock
*lock
)
553 dprintk("lockd: nlmsvc_unlock(%s/%ld, pi=%d, %Ld-%Ld)\n",
554 file
->f_file
->f_path
.dentry
->d_inode
->i_sb
->s_id
,
555 file
->f_file
->f_path
.dentry
->d_inode
->i_ino
,
557 (long long)lock
->fl
.fl_start
,
558 (long long)lock
->fl
.fl_end
);
560 /* First, cancel any lock that might be there */
561 nlmsvc_cancel_blocked(file
, lock
);
563 lock
->fl
.fl_type
= F_UNLCK
;
564 error
= vfs_lock_file(file
->f_file
, F_SETLK
, &lock
->fl
, NULL
);
566 return (error
< 0)? nlm_lck_denied_nolocks
: nlm_granted
;
570 * Cancel a previously blocked request.
572 * A cancel request always overrides any grant that may currently
574 * The calling procedure must check whether the file can be closed.
577 nlmsvc_cancel_blocked(struct nlm_file
*file
, struct nlm_lock
*lock
)
579 struct nlm_block
*block
;
582 dprintk("lockd: nlmsvc_cancel(%s/%ld, pi=%d, %Ld-%Ld)\n",
583 file
->f_file
->f_path
.dentry
->d_inode
->i_sb
->s_id
,
584 file
->f_file
->f_path
.dentry
->d_inode
->i_ino
,
586 (long long)lock
->fl
.fl_start
,
587 (long long)lock
->fl
.fl_end
);
589 mutex_lock(&file
->f_mutex
);
590 block
= nlmsvc_lookup_block(file
, lock
);
591 mutex_unlock(&file
->f_mutex
);
593 vfs_cancel_lock(block
->b_file
->f_file
,
594 &block
->b_call
->a_args
.lock
.fl
);
595 status
= nlmsvc_unlink_block(block
);
596 nlmsvc_release_block(block
);
598 return status
? nlm_lck_denied
: nlm_granted
;
602 * This is a callback from the filesystem for VFS file lock requests.
603 * It will be used if fl_grant is defined and the filesystem can not
604 * respond to the request immediately.
605 * For GETLK request it will copy the reply to the nlm_block.
606 * For SETLK or SETLKW request it will get the local posix lock.
607 * In all cases it will move the block to the head of nlm_blocked q where
608 * nlmsvc_retry_blocked() can send back a reply for SETLKW or revisit the
609 * deferred rpc for GETLK and SETLK.
612 nlmsvc_update_deferred_block(struct nlm_block
*block
, struct file_lock
*conf
,
615 block
->b_flags
|= B_GOT_CALLBACK
;
617 block
->b_granted
= 1;
619 block
->b_flags
|= B_TIMED_OUT
;
622 __locks_copy_lock(block
->b_fl
, conf
);
626 static int nlmsvc_grant_deferred(struct file_lock
*fl
, struct file_lock
*conf
,
629 struct nlm_block
*block
;
633 list_for_each_entry(block
, &nlm_blocked
, b_list
) {
634 if (nlm_compare_locks(&block
->b_call
->a_args
.lock
.fl
, fl
)) {
635 dprintk("lockd: nlmsvc_notify_blocked block %p flags %d\n",
636 block
, block
->b_flags
);
637 if (block
->b_flags
& B_QUEUED
) {
638 if (block
->b_flags
& B_TIMED_OUT
) {
642 nlmsvc_update_deferred_block(block
, conf
, result
);
643 } else if (result
== 0)
644 block
->b_granted
= 1;
646 nlmsvc_insert_block(block
, 0);
647 svc_wake_up(block
->b_daemon
);
654 printk(KERN_WARNING
"lockd: grant for unknown block\n");
659 * Unblock a blocked lock request. This is a callback invoked from the
660 * VFS layer when a lock on which we blocked is removed.
662 * This function doesn't grant the blocked lock instantly, but rather moves
663 * the block to the head of nlm_blocked where it can be picked up by lockd.
666 nlmsvc_notify_blocked(struct file_lock
*fl
)
668 struct nlm_block
*block
;
670 dprintk("lockd: VFS unblock notification for block %p\n", fl
);
671 list_for_each_entry(block
, &nlm_blocked
, b_list
) {
672 if (nlm_compare_locks(&block
->b_call
->a_args
.lock
.fl
, fl
)) {
673 nlmsvc_insert_block(block
, 0);
674 svc_wake_up(block
->b_daemon
);
679 printk(KERN_WARNING
"lockd: notification for unknown block!\n");
682 static int nlmsvc_same_owner(struct file_lock
*fl1
, struct file_lock
*fl2
)
684 return fl1
->fl_owner
== fl2
->fl_owner
&& fl1
->fl_pid
== fl2
->fl_pid
;
687 struct lock_manager_operations nlmsvc_lock_operations
= {
688 .fl_compare_owner
= nlmsvc_same_owner
,
689 .fl_notify
= nlmsvc_notify_blocked
,
690 .fl_grant
= nlmsvc_grant_deferred
,
694 * Try to claim a lock that was previously blocked.
696 * Note that we use both the RPC_GRANTED_MSG call _and_ an async
697 * RPC thread when notifying the client. This seems like overkill...
699 * - we don't want to use a synchronous RPC thread, otherwise
700 * we might find ourselves hanging on a dead portmapper.
701 * - Some lockd implementations (e.g. HP) don't react to
702 * RPC_GRANTED calls; they seem to insist on RPC_GRANTED_MSG calls.
705 nlmsvc_grant_blocked(struct nlm_block
*block
)
707 struct nlm_file
*file
= block
->b_file
;
708 struct nlm_lock
*lock
= &block
->b_call
->a_args
.lock
;
711 dprintk("lockd: grant blocked lock %p\n", block
);
713 kref_get(&block
->b_count
);
715 /* Unlink block request from list */
716 nlmsvc_unlink_block(block
);
718 /* If b_granted is true this means we've been here before.
719 * Just retry the grant callback, possibly refreshing the RPC
721 if (block
->b_granted
) {
722 nlm_rebind_host(block
->b_host
);
726 /* Try the lock operation again */
727 lock
->fl
.fl_flags
|= FL_SLEEP
;
728 error
= vfs_lock_file(file
->f_file
, F_SETLK
, &lock
->fl
, NULL
);
729 lock
->fl
.fl_flags
&= ~FL_SLEEP
;
734 case FILE_LOCK_DEFERRED
:
735 dprintk("lockd: lock still blocked error %d\n", error
);
736 nlmsvc_insert_block(block
, NLM_NEVER
);
737 nlmsvc_release_block(block
);
740 printk(KERN_WARNING
"lockd: unexpected error %d in %s!\n",
742 nlmsvc_insert_block(block
, 10 * HZ
);
743 nlmsvc_release_block(block
);
748 /* Lock was granted by VFS. */
749 dprintk("lockd: GRANTing blocked lock.\n");
750 block
->b_granted
= 1;
752 /* keep block on the list, but don't reattempt until the RPC
753 * completes or the submission fails
755 nlmsvc_insert_block(block
, NLM_NEVER
);
757 /* Call the client -- use a soft RPC task since nlmsvc_retry_blocked
758 * will queue up a new one if this one times out
760 error
= nlm_async_call(block
->b_call
, NLMPROC_GRANTED_MSG
,
763 /* RPC submission failed, wait a bit and retry */
765 nlmsvc_insert_block(block
, 10 * HZ
);
769 * This is the callback from the RPC layer when the NLM_GRANTED_MSG
770 * RPC call has succeeded or timed out.
771 * Like all RPC callbacks, it is invoked by the rpciod process, so it
772 * better not sleep. Therefore, we put the blocked lock on the nlm_blocked
773 * chain once more in order to have it removed by lockd itself (which can
774 * then sleep on the file semaphore without disrupting e.g. the nfs client).
776 static void nlmsvc_grant_callback(struct rpc_task
*task
, void *data
)
778 struct nlm_rqst
*call
= data
;
779 struct nlm_block
*block
= call
->a_block
;
780 unsigned long timeout
;
782 dprintk("lockd: GRANT_MSG RPC callback\n");
785 /* if the block is not on a list at this point then it has
786 * been invalidated. Don't try to requeue it.
788 * FIXME: it's possible that the block is removed from the list
789 * after this check but before the nlmsvc_insert_block. In that
790 * case it will be added back. Perhaps we need better locking
793 if (list_empty(&block
->b_list
))
796 /* Technically, we should down the file semaphore here. Since we
797 * move the block towards the head of the queue only, no harm
798 * can be done, though. */
799 if (task
->tk_status
< 0) {
800 /* RPC error: Re-insert for retransmission */
803 /* Call was successful, now wait for client callback */
806 nlmsvc_insert_block(block
, timeout
);
807 svc_wake_up(block
->b_daemon
);
812 static void nlmsvc_grant_release(void *data
)
814 struct nlm_rqst
*call
= data
;
817 nlmsvc_release_block(call
->a_block
);
821 static const struct rpc_call_ops nlmsvc_grant_ops
= {
822 .rpc_call_done
= nlmsvc_grant_callback
,
823 .rpc_release
= nlmsvc_grant_release
,
827 * We received a GRANT_RES callback. Try to find the corresponding
831 nlmsvc_grant_reply(struct nlm_cookie
*cookie
, __be32 status
)
833 struct nlm_block
*block
;
835 dprintk("grant_reply: looking for cookie %x, s=%d \n",
836 *(unsigned int *)(cookie
->data
), status
);
837 if (!(block
= nlmsvc_find_block(cookie
)))
841 if (status
== nlm_lck_denied_grace_period
) {
842 /* Try again in a couple of seconds */
843 nlmsvc_insert_block(block
, 10 * HZ
);
845 /* Lock is now held by client, or has been rejected.
846 * In both cases, the block should be removed. */
847 nlmsvc_unlink_block(block
);
850 nlmsvc_release_block(block
);
853 /* Helper function to handle retry of a deferred block.
854 * If it is a blocking lock, call grant_blocked.
855 * For a non-blocking lock or test lock, revisit the request.
858 retry_deferred_block(struct nlm_block
*block
)
860 if (!(block
->b_flags
& B_GOT_CALLBACK
))
861 block
->b_flags
|= B_TIMED_OUT
;
862 nlmsvc_insert_block(block
, NLM_TIMEOUT
);
863 dprintk("revisit block %p flags %d\n", block
, block
->b_flags
);
864 if (block
->b_deferred_req
) {
865 block
->b_deferred_req
->revisit(block
->b_deferred_req
, 0);
866 block
->b_deferred_req
= NULL
;
871 * Retry all blocked locks that have been notified. This is where lockd
872 * picks up locks that can be granted, or grant notifications that must
876 nlmsvc_retry_blocked(void)
878 unsigned long timeout
= MAX_SCHEDULE_TIMEOUT
;
879 struct nlm_block
*block
;
881 while (!list_empty(&nlm_blocked
) && !kthread_should_stop()) {
882 block
= list_entry(nlm_blocked
.next
, struct nlm_block
, b_list
);
884 if (block
->b_when
== NLM_NEVER
)
886 if (time_after(block
->b_when
, jiffies
)) {
887 timeout
= block
->b_when
- jiffies
;
891 dprintk("nlmsvc_retry_blocked(%p, when=%ld)\n",
892 block
, block
->b_when
);
893 if (block
->b_flags
& B_QUEUED
) {
894 dprintk("nlmsvc_retry_blocked delete block (%p, granted=%d, flags=%d)\n",
895 block
, block
->b_granted
, block
->b_flags
);
896 retry_deferred_block(block
);
898 nlmsvc_grant_blocked(block
);