blob: d120ec39bcb0ea5c472fc7c1f3ba277b9308709d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/lockd/svclock.c
3 *
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.
10 *
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.
19 *
20 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
21 */
22
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#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
33#define NLMDBG_FACILITY NLMDBG_SVCLOCK
34
35#ifdef CONFIG_LOCKD_V4
36#define nlm_deadlock nlm4_deadlock
37#else
38#define nlm_deadlock nlm_lck_denied
39#endif
40
Trond Myklebust6849c0c2006-03-20 13:44:39 -050041static void nlmsvc_release_block(struct nlm_block *block);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042static void nlmsvc_insert_block(struct nlm_block *block, unsigned long);
Olaf Kirch68a2d762006-10-04 02:15:57 -070043static void nlmsvc_remove_block(struct nlm_block *block);
Trond Myklebust963d8fe2006-01-03 09:55:04 +010044
Trond Myklebust5e1abf82006-03-20 13:44:39 -050045static int nlmsvc_setgrantargs(struct nlm_rqst *call, struct nlm_lock *lock);
46static void nlmsvc_freegrantargs(struct nlm_rqst *call);
Trond Myklebust963d8fe2006-01-03 09:55:04 +010047static const struct rpc_call_ops nlmsvc_grant_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
49/*
50 * The list of blocked locks to retry
51 */
Olaf Kirch68a2d762006-10-04 02:15:57 -070052static LIST_HEAD(nlm_blocked);
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
54/*
55 * Insert a blocked lock into the global list
56 */
57static void
58nlmsvc_insert_block(struct nlm_block *block, unsigned long when)
59{
Olaf Kirch68a2d762006-10-04 02:15:57 -070060 struct nlm_block *b;
61 struct list_head *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
63 dprintk("lockd: nlmsvc_insert_block(%p, %ld)\n", block, when);
Olaf Kirch68a2d762006-10-04 02:15:57 -070064 if (list_empty(&block->b_list)) {
65 kref_get(&block->b_count);
66 } else {
67 list_del_init(&block->b_list);
68 }
69
70 pos = &nlm_blocked;
Linus Torvalds1da177e2005-04-16 15:20:36 -070071 if (when != NLM_NEVER) {
72 if ((when += jiffies) == NLM_NEVER)
73 when ++;
Olaf Kirch68a2d762006-10-04 02:15:57 -070074 list_for_each(pos, &nlm_blocked) {
75 b = list_entry(pos, struct nlm_block, b_list);
76 if (time_after(b->b_when,when) || b->b_when == NLM_NEVER)
77 break;
78 }
79 /* On normal exit from the loop, pos == &nlm_blocked,
80 * so we will be adding to the end of the list - good
81 */
82 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
Olaf Kirch68a2d762006-10-04 02:15:57 -070084 list_add_tail(&block->b_list, pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 block->b_when = when;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086}
87
88/*
89 * Remove a block from the global list
90 */
Olaf Kirch68a2d762006-10-04 02:15:57 -070091static inline void
Linus Torvalds1da177e2005-04-16 15:20:36 -070092nlmsvc_remove_block(struct nlm_block *block)
93{
Olaf Kirch68a2d762006-10-04 02:15:57 -070094 if (!list_empty(&block->b_list)) {
95 list_del_init(&block->b_list);
96 nlmsvc_release_block(block);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070098}
99
100/*
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500101 * Find a block for a given lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 */
103static struct nlm_block *
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500104nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105{
Olaf Kirch68a2d762006-10-04 02:15:57 -0700106 struct nlm_block *block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 struct file_lock *fl;
108
109 dprintk("lockd: nlmsvc_lookup_block f=%p pd=%d %Ld-%Ld ty=%d\n",
110 file, lock->fl.fl_pid,
111 (long long)lock->fl.fl_start,
112 (long long)lock->fl.fl_end, lock->fl.fl_type);
Olaf Kirch68a2d762006-10-04 02:15:57 -0700113 list_for_each_entry(block, &nlm_blocked, b_list) {
Trond Myklebust92737232006-03-20 13:44:45 -0500114 fl = &block->b_call->a_args.lock.fl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%s\n",
116 block->b_file, fl->fl_pid,
117 (long long)fl->fl_start,
118 (long long)fl->fl_end, fl->fl_type,
Trond Myklebust92737232006-03-20 13:44:45 -0500119 nlmdbg_cookie2a(&block->b_call->a_args.cookie));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 if (block->b_file == file && nlm_compare_locks(fl, &lock->fl)) {
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500121 kref_get(&block->b_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 return block;
123 }
124 }
125
126 return NULL;
127}
128
129static inline int nlm_cookie_match(struct nlm_cookie *a, struct nlm_cookie *b)
130{
131 if(a->len != b->len)
132 return 0;
133 if(memcmp(a->data,b->data,a->len))
134 return 0;
135 return 1;
136}
137
138/*
139 * Find a block with a given NLM cookie.
140 */
141static inline struct nlm_block *
Olaf Kirch39be4502006-10-04 02:16:03 -0700142nlmsvc_find_block(struct nlm_cookie *cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143{
144 struct nlm_block *block;
145
Olaf Kirch68a2d762006-10-04 02:15:57 -0700146 list_for_each_entry(block, &nlm_blocked, b_list) {
Olaf Kirch39be4502006-10-04 02:16:03 -0700147 if (nlm_cookie_match(&block->b_call->a_args.cookie,cookie))
Olaf Kirch68a2d762006-10-04 02:15:57 -0700148 goto found;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 }
150
Olaf Kirch68a2d762006-10-04 02:15:57 -0700151 return NULL;
152
153found:
Olaf Kirch39be4502006-10-04 02:16:03 -0700154 dprintk("nlmsvc_find_block(%s): block=%p\n", nlmdbg_cookie2a(cookie), block);
Olaf Kirch68a2d762006-10-04 02:15:57 -0700155 kref_get(&block->b_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 return block;
157}
158
159/*
160 * Create a block and initialize it.
161 *
162 * Note: we explicitly set the cookie of the grant reply to that of
163 * the blocked lock request. The spec explicitly mentions that the client
164 * should _not_ rely on the callback containing the same cookie as the
165 * request, but (as I found out later) that's because some implementations
166 * do just this. Never mind the standards comittees, they support our
167 * logging industries.
Olaf Kirch39be4502006-10-04 02:16:03 -0700168 *
169 * 10 years later: I hope we can safely ignore these old and broken
170 * clients by now. Let's fix this so we can uniquely identify an incoming
171 * GRANTED_RES message by cookie, without having to rely on the client's IP
172 * address. --okir
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 */
Trond Myklebust255129d2007-09-25 15:55:03 -0400174static struct nlm_block *
175nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_host *host,
176 struct nlm_file *file, struct nlm_lock *lock,
177 struct nlm_cookie *cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178{
179 struct nlm_block *block;
Trond Myklebust92737232006-03-20 13:44:45 -0500180 struct nlm_rqst *call = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
Trond Myklebust92737232006-03-20 13:44:45 -0500182 call = nlm_alloc_call(host);
183 if (call == NULL)
184 return NULL;
185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 /* Allocate memory for block, and initialize arguments */
Trond Myklebust92737232006-03-20 13:44:45 -0500187 block = kzalloc(sizeof(*block), GFP_KERNEL);
188 if (block == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 goto failed;
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500190 kref_init(&block->b_count);
Olaf Kirch68a2d762006-10-04 02:15:57 -0700191 INIT_LIST_HEAD(&block->b_list);
192 INIT_LIST_HEAD(&block->b_flist);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
Trond Myklebust92737232006-03-20 13:44:45 -0500194 if (!nlmsvc_setgrantargs(call, lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 goto failed_free;
196
197 /* Set notifier function for VFS, and init args */
Trond Myklebust92737232006-03-20 13:44:45 -0500198 call->a_args.lock.fl.fl_flags |= FL_SLEEP;
199 call->a_args.lock.fl.fl_lmops = &nlmsvc_lock_operations;
Olaf Kirch39be4502006-10-04 02:16:03 -0700200 nlmclnt_next_cookie(&call->a_args.cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
202 dprintk("lockd: created block %p...\n", block);
203
204 /* Create and initialize the block */
205 block->b_daemon = rqstp->rq_server;
206 block->b_host = host;
207 block->b_file = file;
Marc Eshel5ea0d752006-11-28 16:27:06 -0500208 block->b_fl = NULL;
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500209 file->f_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
211 /* Add to file's list of blocks */
Olaf Kirch68a2d762006-10-04 02:15:57 -0700212 list_add(&block->b_flist, &file->f_blocks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
214 /* Set up RPC arguments for callback */
Trond Myklebust92737232006-03-20 13:44:45 -0500215 block->b_call = call;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 call->a_flags = RPC_TASK_ASYNC;
Trond Myklebust92737232006-03-20 13:44:45 -0500217 call->a_block = block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
219 return block;
220
221failed_free:
222 kfree(block);
223failed:
Trond Myklebust92737232006-03-20 13:44:45 -0500224 nlm_release_call(call);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 return NULL;
226}
227
228/*
229 * Delete a block. If the lock was cancelled or the grant callback
230 * failed, unlock is set to 1.
231 * It is the caller's responsibility to check whether the file
232 * can be closed hereafter.
233 */
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500234static int nlmsvc_unlink_block(struct nlm_block *block)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235{
Trond Myklebust09c79382006-03-20 13:44:38 -0500236 int status;
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500237 dprintk("lockd: unlinking block %p...\n", block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
239 /* Remove block from list */
Trond Myklebust92737232006-03-20 13:44:45 -0500240 status = posix_unblock_lock(block->b_file->f_file, &block->b_call->a_args.lock.fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 nlmsvc_remove_block(block);
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500242 return status;
243}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500245static void nlmsvc_free_block(struct kref *kref)
246{
247 struct nlm_block *block = container_of(kref, struct nlm_block, b_count);
248 struct nlm_file *file = block->b_file;
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500249
250 dprintk("lockd: freeing block %p...\n", block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
252 /* Remove block from file's list of blocks */
Neil Brown89e63ef2006-10-04 02:16:06 -0700253 mutex_lock(&file->f_mutex);
Olaf Kirch68a2d762006-10-04 02:15:57 -0700254 list_del_init(&block->b_flist);
Neil Brown89e63ef2006-10-04 02:16:06 -0700255 mutex_unlock(&file->f_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
Trond Myklebust92737232006-03-20 13:44:45 -0500257 nlmsvc_freegrantargs(block->b_call);
258 nlm_release_call(block->b_call);
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500259 nlm_release_file(block->b_file);
Marc Eshel0e4ac9d2006-11-28 16:26:51 -0500260 kfree(block->b_fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 kfree(block);
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500262}
263
264static void nlmsvc_release_block(struct nlm_block *block)
265{
266 if (block != NULL)
267 kref_put(&block->b_count, nlmsvc_free_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268}
269
Olaf Kirchf2af7932006-10-04 02:15:59 -0700270/*
271 * Loop over all blocks and delete blocks held by
272 * a matching host.
273 */
274void nlmsvc_traverse_blocks(struct nlm_host *host,
275 struct nlm_file *file,
276 nlm_host_match_fn_t match)
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500277{
Olaf Kirch68a2d762006-10-04 02:15:57 -0700278 struct nlm_block *block, *next;
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500279
280restart:
Neil Brown89e63ef2006-10-04 02:16:06 -0700281 mutex_lock(&file->f_mutex);
Olaf Kirch68a2d762006-10-04 02:15:57 -0700282 list_for_each_entry_safe(block, next, &file->f_blocks, b_flist) {
Olaf Kirchf2af7932006-10-04 02:15:59 -0700283 if (!match(block->b_host, host))
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500284 continue;
Olaf Kirch68a2d762006-10-04 02:15:57 -0700285 /* Do not destroy blocks that are not on
286 * the global retry list - why? */
287 if (list_empty(&block->b_list))
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500288 continue;
289 kref_get(&block->b_count);
Neil Brown89e63ef2006-10-04 02:16:06 -0700290 mutex_unlock(&file->f_mutex);
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500291 nlmsvc_unlink_block(block);
292 nlmsvc_release_block(block);
293 goto restart;
294 }
Neil Brown89e63ef2006-10-04 02:16:06 -0700295 mutex_unlock(&file->f_mutex);
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500296}
297
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298/*
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500299 * Initialize arguments for GRANTED call. The nlm_rqst structure
300 * has been cleared already.
301 */
302static int nlmsvc_setgrantargs(struct nlm_rqst *call, struct nlm_lock *lock)
303{
304 locks_copy_lock(&call->a_args.lock.fl, &lock->fl);
305 memcpy(&call->a_args.lock.fh, &lock->fh, sizeof(call->a_args.lock.fh));
Serge E. Hallyne9ff3992006-10-02 02:18:11 -0700306 call->a_args.lock.caller = utsname()->nodename;
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500307 call->a_args.lock.oh.len = lock->oh.len;
308
309 /* set default data area */
310 call->a_args.lock.oh.data = call->a_owner;
311 call->a_args.lock.svid = lock->fl.fl_pid;
312
313 if (lock->oh.len > NLMCLNT_OHSIZE) {
314 void *data = kmalloc(lock->oh.len, GFP_KERNEL);
Trond Myklebust92737232006-03-20 13:44:45 -0500315 if (!data)
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500316 return 0;
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500317 call->a_args.lock.oh.data = (u8 *) data;
318 }
319
320 memcpy(call->a_args.lock.oh.data, lock->oh.data, lock->oh.len);
321 return 1;
322}
323
324static void nlmsvc_freegrantargs(struct nlm_rqst *call)
325{
Trond Myklebust92737232006-03-20 13:44:45 -0500326 if (call->a_args.lock.oh.data != call->a_owner)
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500327 kfree(call->a_args.lock.oh.data);
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500328}
329
330/*
Marc Eshel2b36f412006-11-28 16:26:47 -0500331 * Deferred lock request handling for non-blocking lock
332 */
Al Viroca5c8cd2007-07-26 17:33:49 +0100333static __be32
Marc Eshel2b36f412006-11-28 16:26:47 -0500334nlmsvc_defer_lock_rqst(struct svc_rqst *rqstp, struct nlm_block *block)
335{
Al Viroca5c8cd2007-07-26 17:33:49 +0100336 __be32 status = nlm_lck_denied_nolocks;
Marc Eshel2b36f412006-11-28 16:26:47 -0500337
338 block->b_flags |= B_QUEUED;
339
340 nlmsvc_insert_block(block, NLM_TIMEOUT);
341
342 block->b_cache_req = &rqstp->rq_chandle;
343 if (rqstp->rq_chandle.defer) {
344 block->b_deferred_req =
345 rqstp->rq_chandle.defer(block->b_cache_req);
346 if (block->b_deferred_req != NULL)
347 status = nlm_drop_reply;
348 }
349 dprintk("lockd: nlmsvc_defer_lock_rqst block %p flags %d status %d\n",
Al Viroca5c8cd2007-07-26 17:33:49 +0100350 block, block->b_flags, ntohl(status));
Marc Eshel2b36f412006-11-28 16:26:47 -0500351
352 return status;
353}
354
355/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 * Attempt to establish a lock, and if it can't be granted, block it
357 * if required.
358 */
Al Viro52921e02006-10-19 23:28:46 -0700359__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
361 struct nlm_lock *lock, int wait, struct nlm_cookie *cookie)
362{
Marc Eshelf8120482006-12-05 23:48:10 -0500363 struct nlm_block *block = NULL;
Trond Myklebust255129d2007-09-25 15:55:03 -0400364 struct nlm_host *host;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 int error;
Al Viro52921e02006-10-19 23:28:46 -0700366 __be32 ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367
368 dprintk("lockd: nlmsvc_lock(%s/%ld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
Josef Sipek225a7192006-12-08 02:37:18 -0800369 file->f_file->f_path.dentry->d_inode->i_sb->s_id,
370 file->f_file->f_path.dentry->d_inode->i_ino,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 lock->fl.fl_type, lock->fl.fl_pid,
372 (long long)lock->fl.fl_start,
373 (long long)lock->fl.fl_end,
374 wait);
375
Trond Myklebust255129d2007-09-25 15:55:03 -0400376 /* Create host handle for callback */
377 host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len);
378 if (host == NULL)
379 return nlm_lck_denied_nolocks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 /* Lock file against concurrent access */
Neil Brown89e63ef2006-10-04 02:16:06 -0700382 mutex_lock(&file->f_mutex);
Marc Eshelf8120482006-12-05 23:48:10 -0500383 /* Get existing block (in case client is busy-waiting)
384 * or create new block
385 */
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500386 block = nlmsvc_lookup_block(file, lock);
Trond Myklebust09c79382006-03-20 13:44:38 -0500387 if (block == NULL) {
Trond Myklebust255129d2007-09-25 15:55:03 -0400388 block = nlmsvc_create_block(rqstp, nlm_get_host(host), file,
389 lock, cookie);
Marc Eshelf8120482006-12-05 23:48:10 -0500390 ret = nlm_lck_denied_nolocks;
391 if (block == NULL)
392 goto out;
Trond Myklebust92737232006-03-20 13:44:45 -0500393 lock = &block->b_call->a_args.lock;
Marc Eshelf8120482006-12-05 23:48:10 -0500394 } else
395 lock->fl.fl_flags &= ~FL_SLEEP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
Marc Eshel1a8322b2006-11-28 16:27:06 -0500397 if (block->b_flags & B_QUEUED) {
398 dprintk("lockd: nlmsvc_lock deferred block %p flags %d\n",
399 block, block->b_flags);
400 if (block->b_granted) {
401 nlmsvc_unlink_block(block);
402 ret = nlm_granted;
403 goto out;
404 }
405 if (block->b_flags & B_TIMED_OUT) {
406 nlmsvc_unlink_block(block);
407 ret = nlm_lck_denied;
408 goto out;
409 }
410 ret = nlm_drop_reply;
411 goto out;
412 }
413
414 if (!wait)
415 lock->fl.fl_flags &= ~FL_SLEEP;
416 error = vfs_lock_file(file->f_file, F_SETLK, &lock->fl, NULL);
Trond Myklebust09c79382006-03-20 13:44:38 -0500417 lock->fl.fl_flags &= ~FL_SLEEP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
Marc Eshel1a8322b2006-11-28 16:27:06 -0500419 dprintk("lockd: vfs_lock_file returned %d\n", error);
Trond Myklebust09c79382006-03-20 13:44:38 -0500420 switch(error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 case 0:
Andy Adamson15dadef2006-03-20 13:44:24 -0500422 ret = nlm_granted;
423 goto out;
Trond Myklebust09c79382006-03-20 13:44:38 -0500424 case -EAGAIN:
Marc Eshel1a8322b2006-11-28 16:27:06 -0500425 ret = nlm_lck_denied;
Trond Myklebust09c79382006-03-20 13:44:38 -0500426 break;
Marc Eshel1a8322b2006-11-28 16:27:06 -0500427 case -EINPROGRESS:
428 if (wait)
429 break;
430 /* Filesystem lock operation is in progress
431 Add it to the queue waiting for callback */
432 ret = nlmsvc_defer_lock_rqst(rqstp, block);
433 goto out;
Trond Myklebust09c79382006-03-20 13:44:38 -0500434 case -EDEADLK:
Andy Adamson15dadef2006-03-20 13:44:24 -0500435 ret = nlm_deadlock;
436 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 default: /* includes ENOLCK */
Andy Adamson15dadef2006-03-20 13:44:24 -0500438 ret = nlm_lck_denied_nolocks;
439 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 }
441
Trond Myklebust09c79382006-03-20 13:44:38 -0500442 ret = nlm_lck_denied;
443 if (!wait)
444 goto out;
445
446 ret = nlm_lck_blocked;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447
448 /* Append to list of blocked */
Marc Eshelf8120482006-12-05 23:48:10 -0500449 nlmsvc_insert_block(block, NLM_NEVER);
Andy Adamson15dadef2006-03-20 13:44:24 -0500450out:
Neil Brown89e63ef2006-10-04 02:16:06 -0700451 mutex_unlock(&file->f_mutex);
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500452 nlmsvc_release_block(block);
Trond Myklebust255129d2007-09-25 15:55:03 -0400453 nlm_release_host(host);
Andy Adamson15dadef2006-03-20 13:44:24 -0500454 dprintk("lockd: nlmsvc_lock returned %u\n", ret);
455 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456}
457
458/*
459 * Test for presence of a conflicting lock.
460 */
Al Viro52921e02006-10-19 23:28:46 -0700461__be32
Marc Eshel85f3f1b32006-11-28 16:27:06 -0500462nlmsvc_testlock(struct svc_rqst *rqstp, struct nlm_file *file,
463 struct nlm_lock *lock, struct nlm_lock *conflock,
464 struct nlm_cookie *cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465{
Marc Eshel5ea0d752006-11-28 16:27:06 -0500466 struct nlm_block *block = NULL;
467 int error;
468 __be32 ret;
469
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 dprintk("lockd: nlmsvc_testlock(%s/%ld, ty=%d, %Ld-%Ld)\n",
Josef Sipek225a7192006-12-08 02:37:18 -0800471 file->f_file->f_path.dentry->d_inode->i_sb->s_id,
472 file->f_file->f_path.dentry->d_inode->i_ino,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 lock->fl.fl_type,
474 (long long)lock->fl.fl_start,
475 (long long)lock->fl.fl_end);
476
Marc Eshel5ea0d752006-11-28 16:27:06 -0500477 /* Get existing block (in case client is busy-waiting) */
478 block = nlmsvc_lookup_block(file, lock);
479
480 if (block == NULL) {
481 struct file_lock *conf = kzalloc(sizeof(*conf), GFP_KERNEL);
Trond Myklebust255129d2007-09-25 15:55:03 -0400482 struct nlm_host *host;
Marc Eshel5ea0d752006-11-28 16:27:06 -0500483
484 if (conf == NULL)
485 return nlm_granted;
Trond Myklebust255129d2007-09-25 15:55:03 -0400486 /* Create host handle for callback */
487 host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len);
Trond Myklebusta6d85432007-10-09 11:04:57 -0400488 if (host == NULL) {
489 kfree(conf);
Trond Myklebust255129d2007-09-25 15:55:03 -0400490 return nlm_lck_denied_nolocks;
Trond Myklebusta6d85432007-10-09 11:04:57 -0400491 }
Trond Myklebust255129d2007-09-25 15:55:03 -0400492 block = nlmsvc_create_block(rqstp, host, file, lock, cookie);
Marc Eshel5ea0d752006-11-28 16:27:06 -0500493 if (block == NULL) {
494 kfree(conf);
495 return nlm_granted;
496 }
497 block->b_fl = conf;
498 }
499 if (block->b_flags & B_QUEUED) {
500 dprintk("lockd: nlmsvc_testlock deferred block %p flags %d fl %p\n",
501 block, block->b_flags, block->b_fl);
502 if (block->b_flags & B_TIMED_OUT) {
503 nlmsvc_unlink_block(block);
504 return nlm_lck_denied;
505 }
506 if (block->b_flags & B_GOT_CALLBACK) {
507 if (block->b_fl != NULL
508 && block->b_fl->fl_type != F_UNLCK) {
509 lock->fl = *block->b_fl;
510 goto conf_lock;
511 }
512 else {
513 nlmsvc_unlink_block(block);
514 return nlm_granted;
515 }
516 }
517 return nlm_drop_reply;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 }
519
Marc Eshel5ea0d752006-11-28 16:27:06 -0500520 error = vfs_test_lock(file->f_file, &lock->fl);
521 if (error == -EINPROGRESS)
522 return nlmsvc_defer_lock_rqst(rqstp, block);
523 if (error) {
524 ret = nlm_lck_denied_nolocks;
525 goto out;
526 }
527 if (lock->fl.fl_type == F_UNLCK) {
528 ret = nlm_granted;
529 goto out;
530 }
531
532conf_lock:
533 dprintk("lockd: conflicting lock(ty=%d, %Ld-%Ld)\n",
534 lock->fl.fl_type, (long long)lock->fl.fl_start,
535 (long long)lock->fl.fl_end);
536 conflock->caller = "somehost"; /* FIXME */
537 conflock->len = strlen(conflock->caller);
538 conflock->oh.len = 0; /* don't return OH info */
539 conflock->svid = lock->fl.fl_pid;
540 conflock->fl.fl_type = lock->fl.fl_type;
541 conflock->fl.fl_start = lock->fl.fl_start;
542 conflock->fl.fl_end = lock->fl.fl_end;
543 ret = nlm_lck_denied;
544out:
545 if (block)
546 nlmsvc_release_block(block);
547 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548}
549
550/*
551 * Remove a lock.
552 * This implies a CANCEL call: We send a GRANT_MSG, the client replies
553 * with a GRANT_RES call which gets lost, and calls UNLOCK immediately
554 * afterwards. In this case the block will still be there, and hence
555 * must be removed.
556 */
Al Viro52921e02006-10-19 23:28:46 -0700557__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558nlmsvc_unlock(struct nlm_file *file, struct nlm_lock *lock)
559{
560 int error;
561
562 dprintk("lockd: nlmsvc_unlock(%s/%ld, pi=%d, %Ld-%Ld)\n",
Josef Sipek225a7192006-12-08 02:37:18 -0800563 file->f_file->f_path.dentry->d_inode->i_sb->s_id,
564 file->f_file->f_path.dentry->d_inode->i_ino,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 lock->fl.fl_pid,
566 (long long)lock->fl.fl_start,
567 (long long)lock->fl.fl_end);
568
569 /* First, cancel any lock that might be there */
570 nlmsvc_cancel_blocked(file, lock);
571
572 lock->fl.fl_type = F_UNLCK;
Marc Eshel1a8322b2006-11-28 16:27:06 -0500573 error = vfs_lock_file(file->f_file, F_SETLK, &lock->fl, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
575 return (error < 0)? nlm_lck_denied_nolocks : nlm_granted;
576}
577
578/*
579 * Cancel a previously blocked request.
580 *
581 * A cancel request always overrides any grant that may currently
582 * be in progress.
583 * The calling procedure must check whether the file can be closed.
584 */
Al Viro52921e02006-10-19 23:28:46 -0700585__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586nlmsvc_cancel_blocked(struct nlm_file *file, struct nlm_lock *lock)
587{
588 struct nlm_block *block;
J. Bruce Fields64a318e2006-01-03 09:55:46 +0100589 int status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
591 dprintk("lockd: nlmsvc_cancel(%s/%ld, pi=%d, %Ld-%Ld)\n",
Josef Sipek225a7192006-12-08 02:37:18 -0800592 file->f_file->f_path.dentry->d_inode->i_sb->s_id,
593 file->f_file->f_path.dentry->d_inode->i_ino,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 lock->fl.fl_pid,
595 (long long)lock->fl.fl_start,
596 (long long)lock->fl.fl_end);
597
Neil Brown89e63ef2006-10-04 02:16:06 -0700598 mutex_lock(&file->f_mutex);
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500599 block = nlmsvc_lookup_block(file, lock);
Neil Brown89e63ef2006-10-04 02:16:06 -0700600 mutex_unlock(&file->f_mutex);
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500601 if (block != NULL) {
Marc Eshel1a8322b2006-11-28 16:27:06 -0500602 vfs_cancel_lock(block->b_file->f_file,
603 &block->b_call->a_args.lock.fl);
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500604 status = nlmsvc_unlink_block(block);
605 nlmsvc_release_block(block);
606 }
J. Bruce Fields64a318e2006-01-03 09:55:46 +0100607 return status ? nlm_lck_denied : nlm_granted;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608}
609
610/*
Marc Eshel0e4ac9d2006-11-28 16:26:51 -0500611 * This is a callback from the filesystem for VFS file lock requests.
612 * It will be used if fl_grant is defined and the filesystem can not
613 * respond to the request immediately.
614 * For GETLK request it will copy the reply to the nlm_block.
615 * For SETLK or SETLKW request it will get the local posix lock.
616 * In all cases it will move the block to the head of nlm_blocked q where
617 * nlmsvc_retry_blocked() can send back a reply for SETLKW or revisit the
618 * deferred rpc for GETLK and SETLK.
619 */
620static void
621nlmsvc_update_deferred_block(struct nlm_block *block, struct file_lock *conf,
622 int result)
623{
624 block->b_flags |= B_GOT_CALLBACK;
625 if (result == 0)
626 block->b_granted = 1;
627 else
628 block->b_flags |= B_TIMED_OUT;
629 if (conf) {
Marc Eshel0e4ac9d2006-11-28 16:26:51 -0500630 if (block->b_fl)
631 locks_copy_lock(block->b_fl, conf);
632 }
633}
634
635static int nlmsvc_grant_deferred(struct file_lock *fl, struct file_lock *conf,
636 int result)
637{
638 struct nlm_block *block;
639 int rc = -ENOENT;
640
641 lock_kernel();
642 list_for_each_entry(block, &nlm_blocked, b_list) {
643 if (nlm_compare_locks(&block->b_call->a_args.lock.fl, fl)) {
644 dprintk("lockd: nlmsvc_notify_blocked block %p flags %d\n",
645 block, block->b_flags);
646 if (block->b_flags & B_QUEUED) {
647 if (block->b_flags & B_TIMED_OUT) {
648 rc = -ENOLCK;
649 break;
650 }
651 nlmsvc_update_deferred_block(block, conf, result);
652 } else if (result == 0)
653 block->b_granted = 1;
654
655 nlmsvc_insert_block(block, 0);
656 svc_wake_up(block->b_daemon);
657 rc = 0;
658 break;
659 }
660 }
661 unlock_kernel();
662 if (rc == -ENOENT)
663 printk(KERN_WARNING "lockd: grant for unknown block\n");
664 return rc;
665}
666
667/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 * Unblock a blocked lock request. This is a callback invoked from the
669 * VFS layer when a lock on which we blocked is removed.
670 *
671 * This function doesn't grant the blocked lock instantly, but rather moves
672 * the block to the head of nlm_blocked where it can be picked up by lockd.
673 */
674static void
675nlmsvc_notify_blocked(struct file_lock *fl)
676{
Olaf Kirch68a2d762006-10-04 02:15:57 -0700677 struct nlm_block *block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
679 dprintk("lockd: VFS unblock notification for block %p\n", fl);
Olaf Kirch68a2d762006-10-04 02:15:57 -0700680 list_for_each_entry(block, &nlm_blocked, b_list) {
Trond Myklebust92737232006-03-20 13:44:45 -0500681 if (nlm_compare_locks(&block->b_call->a_args.lock.fl, fl)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 nlmsvc_insert_block(block, 0);
683 svc_wake_up(block->b_daemon);
684 return;
685 }
686 }
687
688 printk(KERN_WARNING "lockd: notification for unknown block!\n");
689}
690
691static int nlmsvc_same_owner(struct file_lock *fl1, struct file_lock *fl2)
692{
693 return fl1->fl_owner == fl2->fl_owner && fl1->fl_pid == fl2->fl_pid;
694}
695
696struct lock_manager_operations nlmsvc_lock_operations = {
697 .fl_compare_owner = nlmsvc_same_owner,
698 .fl_notify = nlmsvc_notify_blocked,
Marc Eshel0e4ac9d2006-11-28 16:26:51 -0500699 .fl_grant = nlmsvc_grant_deferred,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700};
701
702/*
703 * Try to claim a lock that was previously blocked.
704 *
705 * Note that we use both the RPC_GRANTED_MSG call _and_ an async
706 * RPC thread when notifying the client. This seems like overkill...
707 * Here's why:
708 * - we don't want to use a synchronous RPC thread, otherwise
709 * we might find ourselves hanging on a dead portmapper.
710 * - Some lockd implementations (e.g. HP) don't react to
711 * RPC_GRANTED calls; they seem to insist on RPC_GRANTED_MSG calls.
712 */
713static void
714nlmsvc_grant_blocked(struct nlm_block *block)
715{
716 struct nlm_file *file = block->b_file;
Trond Myklebust92737232006-03-20 13:44:45 -0500717 struct nlm_lock *lock = &block->b_call->a_args.lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 int error;
719
720 dprintk("lockd: grant blocked lock %p\n", block);
721
Marc Eshel0e4ac9d2006-11-28 16:26:51 -0500722 kref_get(&block->b_count);
723
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 /* Unlink block request from list */
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500725 nlmsvc_unlink_block(block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726
727 /* If b_granted is true this means we've been here before.
728 * Just retry the grant callback, possibly refreshing the RPC
729 * binding */
730 if (block->b_granted) {
731 nlm_rebind_host(block->b_host);
732 goto callback;
733 }
734
735 /* Try the lock operation again */
Trond Myklebust09c79382006-03-20 13:44:38 -0500736 lock->fl.fl_flags |= FL_SLEEP;
Marc Eshel1a8322b2006-11-28 16:27:06 -0500737 error = vfs_lock_file(file->f_file, F_SETLK, &lock->fl, NULL);
Trond Myklebust09c79382006-03-20 13:44:38 -0500738 lock->fl.fl_flags &= ~FL_SLEEP;
739
Andy Adamson5de0e502006-03-20 13:44:25 -0500740 switch (error) {
741 case 0:
742 break;
743 case -EAGAIN:
Marc Eshel1a8322b2006-11-28 16:27:06 -0500744 case -EINPROGRESS:
745 dprintk("lockd: lock still blocked error %d\n", error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 nlmsvc_insert_block(block, NLM_NEVER);
Marc Eshel0e4ac9d2006-11-28 16:26:51 -0500747 nlmsvc_release_block(block);
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500748 return;
Andy Adamson5de0e502006-03-20 13:44:25 -0500749 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 printk(KERN_WARNING "lockd: unexpected error %d in %s!\n",
751 -error, __FUNCTION__);
752 nlmsvc_insert_block(block, 10 * HZ);
Marc Eshel0e4ac9d2006-11-28 16:26:51 -0500753 nlmsvc_release_block(block);
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500754 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 }
756
757callback:
758 /* Lock was granted by VFS. */
759 dprintk("lockd: GRANTing blocked lock.\n");
760 block->b_granted = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
762 /* Schedule next grant callback in 30 seconds */
763 nlmsvc_insert_block(block, 30 * HZ);
764
765 /* Call the client */
Trond Myklebusta995e9e2007-02-02 15:37:43 -0800766 nlm_async_call(block->b_call, NLMPROC_GRANTED_MSG, &nlmsvc_grant_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767}
768
769/*
770 * This is the callback from the RPC layer when the NLM_GRANTED_MSG
771 * RPC call has succeeded or timed out.
772 * Like all RPC callbacks, it is invoked by the rpciod process, so it
773 * better not sleep. Therefore, we put the blocked lock on the nlm_blocked
774 * chain once more in order to have it removed by lockd itself (which can
775 * then sleep on the file semaphore without disrupting e.g. the nfs client).
776 */
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100777static void nlmsvc_grant_callback(struct rpc_task *task, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778{
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100779 struct nlm_rqst *call = data;
Trond Myklebust92737232006-03-20 13:44:45 -0500780 struct nlm_block *block = call->a_block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 unsigned long timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782
783 dprintk("lockd: GRANT_MSG RPC callback\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
785 /* Technically, we should down the file semaphore here. Since we
786 * move the block towards the head of the queue only, no harm
787 * can be done, though. */
788 if (task->tk_status < 0) {
789 /* RPC error: Re-insert for retransmission */
790 timeout = 10 * HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 } else {
792 /* Call was successful, now wait for client callback */
793 timeout = 60 * HZ;
794 }
795 nlmsvc_insert_block(block, timeout);
796 svc_wake_up(block->b_daemon);
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500797}
798
Adrian Bunkec535ce2006-04-18 13:21:50 -0400799static void nlmsvc_grant_release(void *data)
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500800{
Trond Myklebust6041b792006-03-20 13:44:45 -0500801 struct nlm_rqst *call = data;
802
803 nlmsvc_release_block(call->a_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804}
805
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100806static const struct rpc_call_ops nlmsvc_grant_ops = {
807 .rpc_call_done = nlmsvc_grant_callback,
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500808 .rpc_release = nlmsvc_grant_release,
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100809};
810
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811/*
812 * We received a GRANT_RES callback. Try to find the corresponding
813 * block.
814 */
815void
Al Viroe8c5c042006-12-13 00:35:03 -0800816nlmsvc_grant_reply(struct nlm_cookie *cookie, __be32 status)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817{
818 struct nlm_block *block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819
Olaf Kirch39be4502006-10-04 02:16:03 -0700820 dprintk("grant_reply: looking for cookie %x, s=%d \n",
821 *(unsigned int *)(cookie->data), status);
822 if (!(block = nlmsvc_find_block(cookie)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
J. Bruce Fieldsf2321422006-01-03 09:55:42 +0100825 if (block) {
Al Viroe8c5c042006-12-13 00:35:03 -0800826 if (status == nlm_lck_denied_grace_period) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 /* Try again in a couple of seconds */
828 nlmsvc_insert_block(block, 10 * HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 } else {
830 /* Lock is now held by client, or has been rejected.
831 * In both cases, the block should be removed. */
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500832 nlmsvc_unlink_block(block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 }
834 }
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500835 nlmsvc_release_block(block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836}
837
Marc Eshel0e4ac9d2006-11-28 16:26:51 -0500838/* Helper function to handle retry of a deferred block.
839 * If it is a blocking lock, call grant_blocked.
840 * For a non-blocking lock or test lock, revisit the request.
841 */
842static void
843retry_deferred_block(struct nlm_block *block)
844{
845 if (!(block->b_flags & B_GOT_CALLBACK))
846 block->b_flags |= B_TIMED_OUT;
847 nlmsvc_insert_block(block, NLM_TIMEOUT);
848 dprintk("revisit block %p flags %d\n", block, block->b_flags);
849 if (block->b_deferred_req) {
850 block->b_deferred_req->revisit(block->b_deferred_req, 0);
851 block->b_deferred_req = NULL;
852 }
853}
854
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855/*
856 * Retry all blocked locks that have been notified. This is where lockd
857 * picks up locks that can be granted, or grant notifications that must
858 * be retransmitted.
859 */
860unsigned long
861nlmsvc_retry_blocked(void)
862{
Olaf Kirch68a2d762006-10-04 02:15:57 -0700863 unsigned long timeout = MAX_SCHEDULE_TIMEOUT;
864 struct nlm_block *block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865
Olaf Kirch68a2d762006-10-04 02:15:57 -0700866 while (!list_empty(&nlm_blocked)) {
867 block = list_entry(nlm_blocked.next, struct nlm_block, b_list);
868
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 if (block->b_when == NLM_NEVER)
870 break;
Olaf Kirch68a2d762006-10-04 02:15:57 -0700871 if (time_after(block->b_when,jiffies)) {
872 timeout = block->b_when - jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 break;
Olaf Kirch68a2d762006-10-04 02:15:57 -0700874 }
875
J. Bruce Fieldsf3d43c72006-08-03 15:07:47 -0400876 dprintk("nlmsvc_retry_blocked(%p, when=%ld)\n",
877 block, block->b_when);
Marc Eshel0e4ac9d2006-11-28 16:26:51 -0500878 if (block->b_flags & B_QUEUED) {
879 dprintk("nlmsvc_retry_blocked delete block (%p, granted=%d, flags=%d)\n",
880 block, block->b_granted, block->b_flags);
881 retry_deferred_block(block);
882 } else
883 nlmsvc_grant_blocked(block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 }
885
Olaf Kirch68a2d762006-10-04 02:15:57 -0700886 return timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887}