1 // SPDX-License-Identifier: GPL-2.0
3 * linux/fs/lockd/svclock.c
5 * Handling of server-side locks, mostly of the blocked variety.
6 * This is the ugliest part of lockd because we tread on very thin ice.
7 * GRANT and CANCEL calls may get stuck, meet in mid-flight, etc.
8 * IMNSHO introducing the grant callback into the NLM protocol was one
9 * of the worst ideas Sun ever had. Except maybe for the idea of doing
10 * NFS file locking at all.
12 * I'm trying hard to avoid race conditions by protecting most accesses
13 * to a file's list of blocked locks through a semaphore. The global
14 * list of blocked locks is not protected in this fashion however.
15 * Therefore, some functions (such as the RPC callback for the async grant
16 * call) move blocked locks towards the head of the list *while some other
17 * process might be traversing it*. This should not be a problem in
18 * practice, because this will only cause functions traversing the list
19 * to visit some blocks twice.
21 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
24 #include <linux/types.h>
25 #include <linux/slab.h>
26 #include <linux/errno.h>
27 #include <linux/kernel.h>
28 #include <linux/sched.h>
29 #include <linux/sunrpc/clnt.h>
30 #include <linux/sunrpc/svc_xprt.h>
31 #include <linux/lockd/nlm.h>
32 #include <linux/lockd/lockd.h>
33 #include <linux/kthread.h>
34 #include <linux/exportfs.h>
36 #define NLMDBG_FACILITY NLMDBG_SVCLOCK
38 #ifdef CONFIG_LOCKD_V4
39 #define nlm_deadlock nlm4_deadlock
41 #define nlm_deadlock nlm_lck_denied
44 static void nlmsvc_release_block(struct nlm_block *block);
45 static void nlmsvc_insert_block(struct nlm_block *block, unsigned long);
46 static void nlmsvc_remove_block(struct nlm_block *block);
48 static int nlmsvc_setgrantargs(struct nlm_rqst *call, struct nlm_lock *lock);
49 static void nlmsvc_freegrantargs(struct nlm_rqst *call);
50 static const struct rpc_call_ops nlmsvc_grant_ops;
53 * The list of blocked locks to retry
55 static LIST_HEAD(nlm_blocked);
56 static DEFINE_SPINLOCK(nlm_blocked_lock);
58 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
59 static const char *nlmdbg_cookie2a(const struct nlm_cookie *cookie)
62 * We can get away with a static buffer because this is only called
63 * from lockd, which is single-threaded.
65 static char buf[2*NLM_MAXCOOKIELEN+1];
66 unsigned int i, len = sizeof(buf);
69 len--; /* allow for trailing \0 */
72 for (i = 0 ; i < cookie->len ; i++) {
77 sprintf(p, "%02x", cookie->data[i]);
88 * Insert a blocked lock into the global list
91 nlmsvc_insert_block_locked(struct nlm_block *block, unsigned long when)
94 struct list_head *pos;
96 dprintk("lockd: nlmsvc_insert_block(%p, %ld)\n", block, when);
97 if (list_empty(&block->b_list)) {
98 kref_get(&block->b_count);
100 list_del_init(&block->b_list);
104 if (when != NLM_NEVER) {
105 if ((when += jiffies) == NLM_NEVER)
107 list_for_each(pos, &nlm_blocked) {
108 b = list_entry(pos, struct nlm_block, b_list);
109 if (time_after(b->b_when,when) || b->b_when == NLM_NEVER)
112 /* On normal exit from the loop, pos == &nlm_blocked,
113 * so we will be adding to the end of the list - good
117 list_add_tail(&block->b_list, pos);
118 block->b_when = when;
121 static void nlmsvc_insert_block(struct nlm_block *block, unsigned long when)
123 spin_lock(&nlm_blocked_lock);
124 nlmsvc_insert_block_locked(block, when);
125 spin_unlock(&nlm_blocked_lock);
129 * Remove a block from the global list
132 nlmsvc_remove_block(struct nlm_block *block)
134 if (!list_empty(&block->b_list)) {
135 spin_lock(&nlm_blocked_lock);
136 list_del_init(&block->b_list);
137 spin_unlock(&nlm_blocked_lock);
138 nlmsvc_release_block(block);
143 * Find a block for a given lock
145 static struct nlm_block *
146 nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock)
148 struct nlm_block *block;
149 struct file_lock *fl;
151 dprintk("lockd: nlmsvc_lookup_block f=%p pd=%d %Ld-%Ld ty=%d\n",
152 file, lock->fl.fl_pid,
153 (long long)lock->fl.fl_start,
154 (long long)lock->fl.fl_end, lock->fl.fl_type);
155 list_for_each_entry(block, &nlm_blocked, b_list) {
156 fl = &block->b_call->a_args.lock.fl;
157 dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%s\n",
158 block->b_file, fl->fl_pid,
159 (long long)fl->fl_start,
160 (long long)fl->fl_end, fl->fl_type,
161 nlmdbg_cookie2a(&block->b_call->a_args.cookie));
162 if (block->b_file == file && nlm_compare_locks(fl, &lock->fl)) {
163 kref_get(&block->b_count);
171 static inline int nlm_cookie_match(struct nlm_cookie *a, struct nlm_cookie *b)
173 if (a->len != b->len)
175 if (memcmp(a->data, b->data, a->len))
181 * Find a block with a given NLM cookie.
183 static inline struct nlm_block *
184 nlmsvc_find_block(struct nlm_cookie *cookie)
186 struct nlm_block *block;
188 list_for_each_entry(block, &nlm_blocked, b_list) {
189 if (nlm_cookie_match(&block->b_call->a_args.cookie,cookie))
196 dprintk("nlmsvc_find_block(%s): block=%p\n", nlmdbg_cookie2a(cookie), block);
197 kref_get(&block->b_count);
202 * Create a block and initialize it.
204 * Note: we explicitly set the cookie of the grant reply to that of
205 * the blocked lock request. The spec explicitly mentions that the client
206 * should _not_ rely on the callback containing the same cookie as the
207 * request, but (as I found out later) that's because some implementations
208 * do just this. Never mind the standards comittees, they support our
209 * logging industries.
211 * 10 years later: I hope we can safely ignore these old and broken
212 * clients by now. Let's fix this so we can uniquely identify an incoming
213 * GRANTED_RES message by cookie, without having to rely on the client's IP
216 static struct nlm_block *
217 nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_host *host,
218 struct nlm_file *file, struct nlm_lock *lock,
219 struct nlm_cookie *cookie)
221 struct nlm_block *block;
222 struct nlm_rqst *call = NULL;
224 call = nlm_alloc_call(host);
228 /* Allocate memory for block, and initialize arguments */
229 block = kzalloc(sizeof(*block), GFP_KERNEL);
232 kref_init(&block->b_count);
233 INIT_LIST_HEAD(&block->b_list);
234 INIT_LIST_HEAD(&block->b_flist);
236 if (!nlmsvc_setgrantargs(call, lock))
239 /* Set notifier function for VFS, and init args */
240 call->a_args.lock.fl.fl_flags |= FL_SLEEP;
241 call->a_args.lock.fl.fl_lmops = &nlmsvc_lock_operations;
242 nlmclnt_next_cookie(&call->a_args.cookie);
244 dprintk("lockd: created block %p...\n", block);
246 /* Create and initialize the block */
247 block->b_daemon = rqstp->rq_server;
248 block->b_host = host;
249 block->b_file = file;
252 /* Add to file's list of blocks */
253 list_add(&block->b_flist, &file->f_blocks);
255 /* Set up RPC arguments for callback */
256 block->b_call = call;
257 call->a_flags = RPC_TASK_ASYNC;
258 call->a_block = block;
265 nlmsvc_release_call(call);
271 * It is the caller's responsibility to check whether the file
272 * can be closed hereafter.
274 static int nlmsvc_unlink_block(struct nlm_block *block)
277 dprintk("lockd: unlinking block %p...\n", block);
279 /* Remove block from list */
280 status = locks_delete_block(&block->b_call->a_args.lock.fl);
281 nlmsvc_remove_block(block);
285 static void nlmsvc_free_block(struct kref *kref)
287 struct nlm_block *block = container_of(kref, struct nlm_block, b_count);
288 struct nlm_file *file = block->b_file;
290 dprintk("lockd: freeing block %p...\n", block);
292 /* Remove block from file's list of blocks */
293 list_del_init(&block->b_flist);
294 mutex_unlock(&file->f_mutex);
296 nlmsvc_freegrantargs(block->b_call);
297 nlmsvc_release_call(block->b_call);
298 nlm_release_file(block->b_file);
302 static void nlmsvc_release_block(struct nlm_block *block)
305 kref_put_mutex(&block->b_count, nlmsvc_free_block, &block->b_file->f_mutex);
309 * Loop over all blocks and delete blocks held by
312 void nlmsvc_traverse_blocks(struct nlm_host *host,
313 struct nlm_file *file,
314 nlm_host_match_fn_t match)
316 struct nlm_block *block, *next;
319 mutex_lock(&file->f_mutex);
320 list_for_each_entry_safe(block, next, &file->f_blocks, b_flist) {
321 if (!match(block->b_host, host))
323 /* Do not destroy blocks that are not on
324 * the global retry list - why? */
325 if (list_empty(&block->b_list))
327 kref_get(&block->b_count);
328 mutex_unlock(&file->f_mutex);
329 nlmsvc_unlink_block(block);
330 nlmsvc_release_block(block);
333 mutex_unlock(&file->f_mutex);
336 static struct nlm_lockowner *
337 nlmsvc_get_lockowner(struct nlm_lockowner *lockowner)
339 refcount_inc(&lockowner->count);
343 static void nlmsvc_put_lockowner(struct nlm_lockowner *lockowner)
345 if (!refcount_dec_and_lock(&lockowner->count, &lockowner->host->h_lock))
347 list_del(&lockowner->list);
348 spin_unlock(&lockowner->host->h_lock);
349 nlmsvc_release_host(lockowner->host);
353 static struct nlm_lockowner *__nlmsvc_find_lockowner(struct nlm_host *host, pid_t pid)
355 struct nlm_lockowner *lockowner;
356 list_for_each_entry(lockowner, &host->h_lockowners, list) {
357 if (lockowner->pid != pid)
359 return nlmsvc_get_lockowner(lockowner);
364 static struct nlm_lockowner *nlmsvc_find_lockowner(struct nlm_host *host, pid_t pid)
366 struct nlm_lockowner *res, *new = NULL;
368 spin_lock(&host->h_lock);
369 res = __nlmsvc_find_lockowner(host, pid);
372 spin_unlock(&host->h_lock);
373 new = kmalloc(sizeof(*res), GFP_KERNEL);
374 spin_lock(&host->h_lock);
375 res = __nlmsvc_find_lockowner(host, pid);
376 if (res == NULL && new != NULL) {
378 /* fs/locks.c will manage the refcount through lock_ops */
379 refcount_set(&new->count, 1);
381 new->host = nlm_get_host(host);
382 list_add(&new->list, &host->h_lockowners);
387 spin_unlock(&host->h_lock);
393 nlmsvc_release_lockowner(struct nlm_lock *lock)
395 if (lock->fl.fl_owner)
396 nlmsvc_put_lockowner(lock->fl.fl_owner);
399 void nlmsvc_locks_init_private(struct file_lock *fl, struct nlm_host *host,
402 fl->fl_owner = nlmsvc_find_lockowner(host, pid);
406 * Initialize arguments for GRANTED call. The nlm_rqst structure
407 * has been cleared already.
409 static int nlmsvc_setgrantargs(struct nlm_rqst *call, struct nlm_lock *lock)
411 locks_copy_lock(&call->a_args.lock.fl, &lock->fl);
412 memcpy(&call->a_args.lock.fh, &lock->fh, sizeof(call->a_args.lock.fh));
413 call->a_args.lock.caller = utsname()->nodename;
414 call->a_args.lock.oh.len = lock->oh.len;
416 /* set default data area */
417 call->a_args.lock.oh.data = call->a_owner;
418 call->a_args.lock.svid = ((struct nlm_lockowner *)lock->fl.fl_owner)->pid;
420 if (lock->oh.len > NLMCLNT_OHSIZE) {
421 void *data = kmalloc(lock->oh.len, GFP_KERNEL);
424 call->a_args.lock.oh.data = (u8 *) data;
427 memcpy(call->a_args.lock.oh.data, lock->oh.data, lock->oh.len);
431 static void nlmsvc_freegrantargs(struct nlm_rqst *call)
433 if (call->a_args.lock.oh.data != call->a_owner)
434 kfree(call->a_args.lock.oh.data);
436 locks_release_private(&call->a_args.lock.fl);
440 * Deferred lock request handling for non-blocking lock
443 nlmsvc_defer_lock_rqst(struct svc_rqst *rqstp, struct nlm_block *block)
445 __be32 status = nlm_lck_denied_nolocks;
447 block->b_flags |= B_QUEUED;
449 nlmsvc_insert_block(block, NLM_TIMEOUT);
451 block->b_cache_req = &rqstp->rq_chandle;
452 if (rqstp->rq_chandle.defer) {
453 block->b_deferred_req =
454 rqstp->rq_chandle.defer(block->b_cache_req);
455 if (block->b_deferred_req != NULL)
456 status = nlm_drop_reply;
458 dprintk("lockd: nlmsvc_defer_lock_rqst block %p flags %d status %d\n",
459 block, block->b_flags, ntohl(status));
465 * Attempt to establish a lock, and if it can't be granted, block it
469 nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
470 struct nlm_host *host, struct nlm_lock *lock, int wait,
471 struct nlm_cookie *cookie, int reclaim)
473 struct nlm_block *block = NULL;
474 struct inode *inode = nlmsvc_file_inode(file);
480 dprintk("lockd: nlmsvc_lock(%s/%ld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
481 inode->i_sb->s_id, inode->i_ino,
482 lock->fl.fl_type, lock->fl.fl_pid,
483 (long long)lock->fl.fl_start,
484 (long long)lock->fl.fl_end,
487 if (inode->i_sb->s_export_op->flags & EXPORT_OP_SYNC_LOCKS) {
492 /* Lock file against concurrent access */
493 mutex_lock(&file->f_mutex);
494 /* Get existing block (in case client is busy-waiting)
495 * or create new block
497 block = nlmsvc_lookup_block(file, lock);
499 block = nlmsvc_create_block(rqstp, host, file, lock, cookie);
500 ret = nlm_lck_denied_nolocks;
503 lock = &block->b_call->a_args.lock;
505 lock->fl.fl_flags &= ~FL_SLEEP;
507 if (block->b_flags & B_QUEUED) {
508 dprintk("lockd: nlmsvc_lock deferred block %p flags %d\n",
509 block, block->b_flags);
510 if (block->b_granted) {
511 nlmsvc_unlink_block(block);
515 if (block->b_flags & B_TIMED_OUT) {
516 nlmsvc_unlink_block(block);
517 ret = nlm_lck_denied;
520 ret = nlm_drop_reply;
524 if (locks_in_grace(SVC_NET(rqstp)) && !reclaim) {
525 ret = nlm_lck_denied_grace_period;
528 if (reclaim && !locks_in_grace(SVC_NET(rqstp))) {
529 ret = nlm_lck_denied_grace_period;
534 lock->fl.fl_flags &= ~FL_SLEEP;
535 mode = lock_to_openmode(&lock->fl);
536 error = vfs_lock_file(file->f_file[mode], F_SETLK, &lock->fl, NULL);
537 lock->fl.fl_flags &= ~FL_SLEEP;
539 dprintk("lockd: vfs_lock_file returned %d\n", error);
546 * If this is a blocking request for an
547 * already pending lock request then we need
548 * to put it back on lockd's block list
552 ret = async_block ? nlm_lck_blocked : nlm_lck_denied;
554 case FILE_LOCK_DEFERRED:
557 /* Filesystem lock operation is in progress
558 Add it to the queue waiting for callback */
559 ret = nlmsvc_defer_lock_rqst(rqstp, block);
564 default: /* includes ENOLCK */
565 ret = nlm_lck_denied_nolocks;
569 ret = nlm_lck_blocked;
571 /* Append to list of blocked */
572 nlmsvc_insert_block(block, NLM_NEVER);
574 mutex_unlock(&file->f_mutex);
575 nlmsvc_release_block(block);
576 dprintk("lockd: nlmsvc_lock returned %u\n", ret);
581 * Test for presence of a conflicting lock.
584 nlmsvc_testlock(struct svc_rqst *rqstp, struct nlm_file *file,
585 struct nlm_host *host, struct nlm_lock *lock,
586 struct nlm_lock *conflock, struct nlm_cookie *cookie)
591 struct nlm_lockowner *test_owner;
593 dprintk("lockd: nlmsvc_testlock(%s/%ld, ty=%d, %Ld-%Ld)\n",
594 nlmsvc_file_inode(file)->i_sb->s_id,
595 nlmsvc_file_inode(file)->i_ino,
597 (long long)lock->fl.fl_start,
598 (long long)lock->fl.fl_end);
600 if (locks_in_grace(SVC_NET(rqstp))) {
601 ret = nlm_lck_denied_grace_period;
605 /* If there's a conflicting lock, remember to clean up the test lock */
606 test_owner = (struct nlm_lockowner *)lock->fl.fl_owner;
608 mode = lock_to_openmode(&lock->fl);
609 error = vfs_test_lock(file->f_file[mode], &lock->fl);
611 /* We can't currently deal with deferred test requests */
612 if (error == FILE_LOCK_DEFERRED)
615 ret = nlm_lck_denied_nolocks;
619 if (lock->fl.fl_type == F_UNLCK) {
624 dprintk("lockd: conflicting lock(ty=%d, %Ld-%Ld)\n",
625 lock->fl.fl_type, (long long)lock->fl.fl_start,
626 (long long)lock->fl.fl_end);
627 conflock->caller = "somehost"; /* FIXME */
628 conflock->len = strlen(conflock->caller);
629 conflock->oh.len = 0; /* don't return OH info */
630 conflock->svid = lock->fl.fl_pid;
631 conflock->fl.fl_type = lock->fl.fl_type;
632 conflock->fl.fl_start = lock->fl.fl_start;
633 conflock->fl.fl_end = lock->fl.fl_end;
634 locks_release_private(&lock->fl);
636 /* Clean up the test lock */
637 lock->fl.fl_owner = NULL;
638 nlmsvc_put_lockowner(test_owner);
640 ret = nlm_lck_denied;
647 * This implies a CANCEL call: We send a GRANT_MSG, the client replies
648 * with a GRANT_RES call which gets lost, and calls UNLOCK immediately
649 * afterwards. In this case the block will still be there, and hence
653 nlmsvc_unlock(struct net *net, struct nlm_file *file, struct nlm_lock *lock)
657 dprintk("lockd: nlmsvc_unlock(%s/%ld, pi=%d, %Ld-%Ld)\n",
658 nlmsvc_file_inode(file)->i_sb->s_id,
659 nlmsvc_file_inode(file)->i_ino,
661 (long long)lock->fl.fl_start,
662 (long long)lock->fl.fl_end);
664 /* First, cancel any lock that might be there */
665 nlmsvc_cancel_blocked(net, file, lock);
667 lock->fl.fl_type = F_UNLCK;
668 if (file->f_file[O_RDONLY])
669 error = vfs_lock_file(file->f_file[O_RDONLY], F_SETLK,
671 if (file->f_file[O_WRONLY])
672 error = vfs_lock_file(file->f_file[O_WRONLY], F_SETLK,
675 return (error < 0)? nlm_lck_denied_nolocks : nlm_granted;
679 * Cancel a previously blocked request.
681 * A cancel request always overrides any grant that may currently
683 * The calling procedure must check whether the file can be closed.
686 nlmsvc_cancel_blocked(struct net *net, struct nlm_file *file, struct nlm_lock *lock)
688 struct nlm_block *block;
692 dprintk("lockd: nlmsvc_cancel(%s/%ld, pi=%d, %Ld-%Ld)\n",
693 nlmsvc_file_inode(file)->i_sb->s_id,
694 nlmsvc_file_inode(file)->i_ino,
696 (long long)lock->fl.fl_start,
697 (long long)lock->fl.fl_end);
699 if (locks_in_grace(net))
700 return nlm_lck_denied_grace_period;
702 mutex_lock(&file->f_mutex);
703 block = nlmsvc_lookup_block(file, lock);
704 mutex_unlock(&file->f_mutex);
706 mode = lock_to_openmode(&lock->fl);
707 vfs_cancel_lock(block->b_file->f_file[mode],
708 &block->b_call->a_args.lock.fl);
709 status = nlmsvc_unlink_block(block);
710 nlmsvc_release_block(block);
712 return status ? nlm_lck_denied : nlm_granted;
716 * This is a callback from the filesystem for VFS file lock requests.
717 * It will be used if lm_grant is defined and the filesystem can not
718 * respond to the request immediately.
719 * For SETLK or SETLKW request it will get the local posix lock.
720 * In all cases it will move the block to the head of nlm_blocked q where
721 * nlmsvc_retry_blocked() can send back a reply for SETLKW or revisit the
722 * deferred rpc for GETLK and SETLK.
725 nlmsvc_update_deferred_block(struct nlm_block *block, int result)
727 block->b_flags |= B_GOT_CALLBACK;
729 block->b_granted = 1;
731 block->b_flags |= B_TIMED_OUT;
734 static int nlmsvc_grant_deferred(struct file_lock *fl, int result)
736 struct nlm_block *block;
739 spin_lock(&nlm_blocked_lock);
740 list_for_each_entry(block, &nlm_blocked, b_list) {
741 if (nlm_compare_locks(&block->b_call->a_args.lock.fl, fl)) {
742 dprintk("lockd: nlmsvc_notify_blocked block %p flags %d\n",
743 block, block->b_flags);
744 if (block->b_flags & B_QUEUED) {
745 if (block->b_flags & B_TIMED_OUT) {
749 nlmsvc_update_deferred_block(block, result);
750 } else if (result == 0)
751 block->b_granted = 1;
753 nlmsvc_insert_block_locked(block, 0);
754 svc_wake_up(block->b_daemon);
759 spin_unlock(&nlm_blocked_lock);
761 printk(KERN_WARNING "lockd: grant for unknown block\n");
766 * Unblock a blocked lock request. This is a callback invoked from the
767 * VFS layer when a lock on which we blocked is removed.
769 * This function doesn't grant the blocked lock instantly, but rather moves
770 * the block to the head of nlm_blocked where it can be picked up by lockd.
773 nlmsvc_notify_blocked(struct file_lock *fl)
775 struct nlm_block *block;
777 dprintk("lockd: VFS unblock notification for block %p\n", fl);
778 spin_lock(&nlm_blocked_lock);
779 list_for_each_entry(block, &nlm_blocked, b_list) {
780 if (nlm_compare_locks(&block->b_call->a_args.lock.fl, fl)) {
781 nlmsvc_insert_block_locked(block, 0);
782 spin_unlock(&nlm_blocked_lock);
783 svc_wake_up(block->b_daemon);
787 spin_unlock(&nlm_blocked_lock);
788 printk(KERN_WARNING "lockd: notification for unknown block!\n");
791 static fl_owner_t nlmsvc_get_owner(fl_owner_t owner)
793 return nlmsvc_get_lockowner(owner);
796 static void nlmsvc_put_owner(fl_owner_t owner)
798 nlmsvc_put_lockowner(owner);
801 const struct lock_manager_operations nlmsvc_lock_operations = {
802 .lm_notify = nlmsvc_notify_blocked,
803 .lm_grant = nlmsvc_grant_deferred,
804 .lm_get_owner = nlmsvc_get_owner,
805 .lm_put_owner = nlmsvc_put_owner,
809 * Try to claim a lock that was previously blocked.
811 * Note that we use both the RPC_GRANTED_MSG call _and_ an async
812 * RPC thread when notifying the client. This seems like overkill...
814 * - we don't want to use a synchronous RPC thread, otherwise
815 * we might find ourselves hanging on a dead portmapper.
816 * - Some lockd implementations (e.g. HP) don't react to
817 * RPC_GRANTED calls; they seem to insist on RPC_GRANTED_MSG calls.
820 nlmsvc_grant_blocked(struct nlm_block *block)
822 struct nlm_file *file = block->b_file;
823 struct nlm_lock *lock = &block->b_call->a_args.lock;
826 loff_t fl_start, fl_end;
828 dprintk("lockd: grant blocked lock %p\n", block);
830 kref_get(&block->b_count);
832 /* Unlink block request from list */
833 nlmsvc_unlink_block(block);
835 /* If b_granted is true this means we've been here before.
836 * Just retry the grant callback, possibly refreshing the RPC
838 if (block->b_granted) {
839 nlm_rebind_host(block->b_host);
843 /* Try the lock operation again */
844 /* vfs_lock_file() can mangle fl_start and fl_end, but we need
845 * them unchanged for the GRANT_MSG
847 lock->fl.fl_flags |= FL_SLEEP;
848 fl_start = lock->fl.fl_start;
849 fl_end = lock->fl.fl_end;
850 mode = lock_to_openmode(&lock->fl);
851 error = vfs_lock_file(file->f_file[mode], F_SETLK, &lock->fl, NULL);
852 lock->fl.fl_flags &= ~FL_SLEEP;
853 lock->fl.fl_start = fl_start;
854 lock->fl.fl_end = fl_end;
859 case FILE_LOCK_DEFERRED:
860 dprintk("lockd: lock still blocked error %d\n", error);
861 nlmsvc_insert_block(block, NLM_NEVER);
862 nlmsvc_release_block(block);
865 printk(KERN_WARNING "lockd: unexpected error %d in %s!\n",
867 nlmsvc_insert_block(block, 10 * HZ);
868 nlmsvc_release_block(block);
873 /* Lock was granted by VFS. */
874 dprintk("lockd: GRANTing blocked lock.\n");
875 block->b_granted = 1;
877 /* keep block on the list, but don't reattempt until the RPC
878 * completes or the submission fails
880 nlmsvc_insert_block(block, NLM_NEVER);
882 /* Call the client -- use a soft RPC task since nlmsvc_retry_blocked
883 * will queue up a new one if this one times out
885 error = nlm_async_call(block->b_call, NLMPROC_GRANTED_MSG,
888 /* RPC submission failed, wait a bit and retry */
890 nlmsvc_insert_block(block, 10 * HZ);
894 * This is the callback from the RPC layer when the NLM_GRANTED_MSG
895 * RPC call has succeeded or timed out.
896 * Like all RPC callbacks, it is invoked by the rpciod process, so it
897 * better not sleep. Therefore, we put the blocked lock on the nlm_blocked
898 * chain once more in order to have it removed by lockd itself (which can
899 * then sleep on the file semaphore without disrupting e.g. the nfs client).
901 static void nlmsvc_grant_callback(struct rpc_task *task, void *data)
903 struct nlm_rqst *call = data;
904 struct nlm_block *block = call->a_block;
905 unsigned long timeout;
907 dprintk("lockd: GRANT_MSG RPC callback\n");
909 spin_lock(&nlm_blocked_lock);
910 /* if the block is not on a list at this point then it has
911 * been invalidated. Don't try to requeue it.
913 * FIXME: it's possible that the block is removed from the list
914 * after this check but before the nlmsvc_insert_block. In that
915 * case it will be added back. Perhaps we need better locking
918 if (list_empty(&block->b_list))
921 /* Technically, we should down the file semaphore here. Since we
922 * move the block towards the head of the queue only, no harm
923 * can be done, though. */
924 if (task->tk_status < 0) {
925 /* RPC error: Re-insert for retransmission */
928 /* Call was successful, now wait for client callback */
931 nlmsvc_insert_block_locked(block, timeout);
932 svc_wake_up(block->b_daemon);
934 spin_unlock(&nlm_blocked_lock);
938 * FIXME: nlmsvc_release_block() grabs a mutex. This is not allowed for an
939 * .rpc_release rpc_call_op
941 static void nlmsvc_grant_release(void *data)
943 struct nlm_rqst *call = data;
944 nlmsvc_release_block(call->a_block);
947 static const struct rpc_call_ops nlmsvc_grant_ops = {
948 .rpc_call_done = nlmsvc_grant_callback,
949 .rpc_release = nlmsvc_grant_release,
953 * We received a GRANT_RES callback. Try to find the corresponding
957 nlmsvc_grant_reply(struct nlm_cookie *cookie, __be32 status)
959 struct nlm_block *block;
961 dprintk("grant_reply: looking for cookie %x, s=%d \n",
962 *(unsigned int *)(cookie->data), status);
963 if (!(block = nlmsvc_find_block(cookie)))
966 if (status == nlm_lck_denied_grace_period) {
967 /* Try again in a couple of seconds */
968 nlmsvc_insert_block(block, 10 * HZ);
971 * Lock is now held by client, or has been rejected.
972 * In both cases, the block should be removed.
974 nlmsvc_unlink_block(block);
976 nlmsvc_release_block(block);
979 /* Helper function to handle retry of a deferred block.
980 * If it is a blocking lock, call grant_blocked.
981 * For a non-blocking lock or test lock, revisit the request.
984 retry_deferred_block(struct nlm_block *block)
986 if (!(block->b_flags & B_GOT_CALLBACK))
987 block->b_flags |= B_TIMED_OUT;
988 nlmsvc_insert_block(block, NLM_TIMEOUT);
989 dprintk("revisit block %p flags %d\n", block, block->b_flags);
990 if (block->b_deferred_req) {
991 block->b_deferred_req->revisit(block->b_deferred_req, 0);
992 block->b_deferred_req = NULL;
997 * Retry all blocked locks that have been notified. This is where lockd
998 * picks up locks that can be granted, or grant notifications that must
1002 nlmsvc_retry_blocked(void)
1004 unsigned long timeout = MAX_SCHEDULE_TIMEOUT;
1005 struct nlm_block *block;
1007 spin_lock(&nlm_blocked_lock);
1008 while (!list_empty(&nlm_blocked) && !kthread_should_stop()) {
1009 block = list_entry(nlm_blocked.next, struct nlm_block, b_list);
1011 if (block->b_when == NLM_NEVER)
1013 if (time_after(block->b_when, jiffies)) {
1014 timeout = block->b_when - jiffies;
1017 spin_unlock(&nlm_blocked_lock);
1019 dprintk("nlmsvc_retry_blocked(%p, when=%ld)\n",
1020 block, block->b_when);
1021 if (block->b_flags & B_QUEUED) {
1022 dprintk("nlmsvc_retry_blocked delete block (%p, granted=%d, flags=%d)\n",
1023 block, block->b_granted, block->b_flags);
1024 retry_deferred_block(block);
1026 nlmsvc_grant_blocked(block);
1027 spin_lock(&nlm_blocked_lock);
1029 spin_unlock(&nlm_blocked_lock);