blob: 814c6064c9e0514fef4a712a2f1be156afb7fb25 [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 */
174static inline struct nlm_block *
175nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_file *file,
176 struct nlm_lock *lock, struct nlm_cookie *cookie)
177{
178 struct nlm_block *block;
179 struct nlm_host *host;
Trond Myklebust92737232006-03-20 13:44:45 -0500180 struct nlm_rqst *call = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
182 /* Create host handle for callback */
Olaf Kirchdb4e4c92006-10-04 02:15:52 -0700183 host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 if (host == NULL)
185 return NULL;
186
Trond Myklebust92737232006-03-20 13:44:45 -0500187 call = nlm_alloc_call(host);
188 if (call == NULL)
189 return NULL;
190
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 /* Allocate memory for block, and initialize arguments */
Trond Myklebust92737232006-03-20 13:44:45 -0500192 block = kzalloc(sizeof(*block), GFP_KERNEL);
193 if (block == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 goto failed;
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500195 kref_init(&block->b_count);
Olaf Kirch68a2d762006-10-04 02:15:57 -0700196 INIT_LIST_HEAD(&block->b_list);
197 INIT_LIST_HEAD(&block->b_flist);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
Trond Myklebust92737232006-03-20 13:44:45 -0500199 if (!nlmsvc_setgrantargs(call, lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 goto failed_free;
201
202 /* Set notifier function for VFS, and init args */
Trond Myklebust92737232006-03-20 13:44:45 -0500203 call->a_args.lock.fl.fl_flags |= FL_SLEEP;
204 call->a_args.lock.fl.fl_lmops = &nlmsvc_lock_operations;
Olaf Kirch39be4502006-10-04 02:16:03 -0700205 nlmclnt_next_cookie(&call->a_args.cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
207 dprintk("lockd: created block %p...\n", block);
208
209 /* Create and initialize the block */
210 block->b_daemon = rqstp->rq_server;
211 block->b_host = host;
212 block->b_file = file;
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500213 file->f_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
215 /* Add to file's list of blocks */
Olaf Kirch68a2d762006-10-04 02:15:57 -0700216 list_add(&block->b_flist, &file->f_blocks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
218 /* Set up RPC arguments for callback */
Trond Myklebust92737232006-03-20 13:44:45 -0500219 block->b_call = call;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 call->a_flags = RPC_TASK_ASYNC;
Trond Myklebust92737232006-03-20 13:44:45 -0500221 call->a_block = block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
223 return block;
224
225failed_free:
226 kfree(block);
227failed:
Trond Myklebust92737232006-03-20 13:44:45 -0500228 nlm_release_call(call);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 return NULL;
230}
231
232/*
233 * Delete a block. If the lock was cancelled or the grant callback
234 * failed, unlock is set to 1.
235 * It is the caller's responsibility to check whether the file
236 * can be closed hereafter.
237 */
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500238static int nlmsvc_unlink_block(struct nlm_block *block)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239{
Trond Myklebust09c79382006-03-20 13:44:38 -0500240 int status;
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500241 dprintk("lockd: unlinking block %p...\n", block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
243 /* Remove block from list */
Trond Myklebust92737232006-03-20 13:44:45 -0500244 status = posix_unblock_lock(block->b_file->f_file, &block->b_call->a_args.lock.fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 nlmsvc_remove_block(block);
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500246 return status;
247}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500249static void nlmsvc_free_block(struct kref *kref)
250{
251 struct nlm_block *block = container_of(kref, struct nlm_block, b_count);
252 struct nlm_file *file = block->b_file;
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500253
254 dprintk("lockd: freeing block %p...\n", block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
256 /* Remove block from file's list of blocks */
Neil Brown89e63ef2006-10-04 02:16:06 -0700257 mutex_lock(&file->f_mutex);
Olaf Kirch68a2d762006-10-04 02:15:57 -0700258 list_del_init(&block->b_flist);
Neil Brown89e63ef2006-10-04 02:16:06 -0700259 mutex_unlock(&file->f_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
Trond Myklebust92737232006-03-20 13:44:45 -0500261 nlmsvc_freegrantargs(block->b_call);
262 nlm_release_call(block->b_call);
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500263 nlm_release_file(block->b_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 kfree(block);
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500265}
266
267static void nlmsvc_release_block(struct nlm_block *block)
268{
269 if (block != NULL)
270 kref_put(&block->b_count, nlmsvc_free_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271}
272
Olaf Kirchf2af7932006-10-04 02:15:59 -0700273/*
274 * Loop over all blocks and delete blocks held by
275 * a matching host.
276 */
277void nlmsvc_traverse_blocks(struct nlm_host *host,
278 struct nlm_file *file,
279 nlm_host_match_fn_t match)
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500280{
Olaf Kirch68a2d762006-10-04 02:15:57 -0700281 struct nlm_block *block, *next;
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500282
283restart:
Neil Brown89e63ef2006-10-04 02:16:06 -0700284 mutex_lock(&file->f_mutex);
Olaf Kirch68a2d762006-10-04 02:15:57 -0700285 list_for_each_entry_safe(block, next, &file->f_blocks, b_flist) {
Olaf Kirchf2af7932006-10-04 02:15:59 -0700286 if (!match(block->b_host, host))
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500287 continue;
Olaf Kirch68a2d762006-10-04 02:15:57 -0700288 /* Do not destroy blocks that are not on
289 * the global retry list - why? */
290 if (list_empty(&block->b_list))
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500291 continue;
292 kref_get(&block->b_count);
Neil Brown89e63ef2006-10-04 02:16:06 -0700293 mutex_unlock(&file->f_mutex);
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500294 nlmsvc_unlink_block(block);
295 nlmsvc_release_block(block);
296 goto restart;
297 }
Neil Brown89e63ef2006-10-04 02:16:06 -0700298 mutex_unlock(&file->f_mutex);
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500299}
300
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301/*
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500302 * Initialize arguments for GRANTED call. The nlm_rqst structure
303 * has been cleared already.
304 */
305static int nlmsvc_setgrantargs(struct nlm_rqst *call, struct nlm_lock *lock)
306{
307 locks_copy_lock(&call->a_args.lock.fl, &lock->fl);
308 memcpy(&call->a_args.lock.fh, &lock->fh, sizeof(call->a_args.lock.fh));
Serge E. Hallyne9ff3992006-10-02 02:18:11 -0700309 call->a_args.lock.caller = utsname()->nodename;
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500310 call->a_args.lock.oh.len = lock->oh.len;
311
312 /* set default data area */
313 call->a_args.lock.oh.data = call->a_owner;
314 call->a_args.lock.svid = lock->fl.fl_pid;
315
316 if (lock->oh.len > NLMCLNT_OHSIZE) {
317 void *data = kmalloc(lock->oh.len, GFP_KERNEL);
Trond Myklebust92737232006-03-20 13:44:45 -0500318 if (!data)
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500319 return 0;
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500320 call->a_args.lock.oh.data = (u8 *) data;
321 }
322
323 memcpy(call->a_args.lock.oh.data, lock->oh.data, lock->oh.len);
324 return 1;
325}
326
327static void nlmsvc_freegrantargs(struct nlm_rqst *call)
328{
Trond Myklebust92737232006-03-20 13:44:45 -0500329 if (call->a_args.lock.oh.data != call->a_owner)
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500330 kfree(call->a_args.lock.oh.data);
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500331}
332
333/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 * Attempt to establish a lock, and if it can't be granted, block it
335 * if required.
336 */
337u32
338nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
339 struct nlm_lock *lock, int wait, struct nlm_cookie *cookie)
340{
Trond Myklebust09c79382006-03-20 13:44:38 -0500341 struct nlm_block *block, *newblock = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 int error;
Andy Adamson15dadef2006-03-20 13:44:24 -0500343 u32 ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
345 dprintk("lockd: nlmsvc_lock(%s/%ld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
346 file->f_file->f_dentry->d_inode->i_sb->s_id,
347 file->f_file->f_dentry->d_inode->i_ino,
348 lock->fl.fl_type, lock->fl.fl_pid,
349 (long long)lock->fl.fl_start,
350 (long long)lock->fl.fl_end,
351 wait);
352
353
Trond Myklebust09c79382006-03-20 13:44:38 -0500354 lock->fl.fl_flags &= ~FL_SLEEP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355again:
356 /* Lock file against concurrent access */
Neil Brown89e63ef2006-10-04 02:16:06 -0700357 mutex_lock(&file->f_mutex);
Trond Myklebust09c79382006-03-20 13:44:38 -0500358 /* Get existing block (in case client is busy-waiting) */
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500359 block = nlmsvc_lookup_block(file, lock);
Trond Myklebust09c79382006-03-20 13:44:38 -0500360 if (block == NULL) {
361 if (newblock != NULL)
Trond Myklebust92737232006-03-20 13:44:45 -0500362 lock = &newblock->b_call->a_args.lock;
Trond Myklebust09c79382006-03-20 13:44:38 -0500363 } else
Trond Myklebust92737232006-03-20 13:44:45 -0500364 lock = &block->b_call->a_args.lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
Andy Adamsona85f1932006-03-20 13:44:25 -0500366 error = posix_lock_file(file->f_file, &lock->fl);
Trond Myklebust09c79382006-03-20 13:44:38 -0500367 lock->fl.fl_flags &= ~FL_SLEEP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
Andy Adamsona85f1932006-03-20 13:44:25 -0500369 dprintk("lockd: posix_lock_file returned %d\n", error);
370
Trond Myklebust09c79382006-03-20 13:44:38 -0500371 switch(error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 case 0:
Andy Adamson15dadef2006-03-20 13:44:24 -0500373 ret = nlm_granted;
374 goto out;
Trond Myklebust09c79382006-03-20 13:44:38 -0500375 case -EAGAIN:
376 break;
377 case -EDEADLK:
Andy Adamson15dadef2006-03-20 13:44:24 -0500378 ret = nlm_deadlock;
379 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 default: /* includes ENOLCK */
Andy Adamson15dadef2006-03-20 13:44:24 -0500381 ret = nlm_lck_denied_nolocks;
382 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 }
384
Trond Myklebust09c79382006-03-20 13:44:38 -0500385 ret = nlm_lck_denied;
386 if (!wait)
387 goto out;
388
389 ret = nlm_lck_blocked;
390 if (block != NULL)
391 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 /* If we don't have a block, create and initialize it. Then
394 * retry because we may have slept in kmalloc. */
Neil Brown89e63ef2006-10-04 02:16:06 -0700395 /* We have to release f_mutex as nlmsvc_create_block may try to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 * to claim it while doing host garbage collection */
Trond Myklebust09c79382006-03-20 13:44:38 -0500397 if (newblock == NULL) {
Neil Brown89e63ef2006-10-04 02:16:06 -0700398 mutex_unlock(&file->f_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 dprintk("lockd: blocking on this lock (allocating).\n");
Trond Myklebust09c79382006-03-20 13:44:38 -0500400 if (!(newblock = nlmsvc_create_block(rqstp, file, lock, cookie)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 return nlm_lck_denied_nolocks;
402 goto again;
403 }
404
405 /* Append to list of blocked */
Trond Myklebust09c79382006-03-20 13:44:38 -0500406 nlmsvc_insert_block(newblock, NLM_NEVER);
Andy Adamson15dadef2006-03-20 13:44:24 -0500407out:
Neil Brown89e63ef2006-10-04 02:16:06 -0700408 mutex_unlock(&file->f_mutex);
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500409 nlmsvc_release_block(newblock);
410 nlmsvc_release_block(block);
Andy Adamson15dadef2006-03-20 13:44:24 -0500411 dprintk("lockd: nlmsvc_lock returned %u\n", ret);
412 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413}
414
415/*
416 * Test for presence of a conflicting lock.
417 */
418u32
419nlmsvc_testlock(struct nlm_file *file, struct nlm_lock *lock,
420 struct nlm_lock *conflock)
421{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 dprintk("lockd: nlmsvc_testlock(%s/%ld, ty=%d, %Ld-%Ld)\n",
423 file->f_file->f_dentry->d_inode->i_sb->s_id,
424 file->f_file->f_dentry->d_inode->i_ino,
425 lock->fl.fl_type,
426 (long long)lock->fl.fl_start,
427 (long long)lock->fl.fl_end);
428
Andy Adamson8dc7c312006-03-20 13:44:26 -0500429 if (posix_test_lock(file->f_file, &lock->fl, &conflock->fl)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 dprintk("lockd: conflicting lock(ty=%d, %Ld-%Ld)\n",
Andy Adamson8dc7c312006-03-20 13:44:26 -0500431 conflock->fl.fl_type,
432 (long long)conflock->fl.fl_start,
433 (long long)conflock->fl.fl_end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 conflock->caller = "somehost"; /* FIXME */
Olaf Kirchdb4e4c92006-10-04 02:15:52 -0700435 conflock->len = strlen(conflock->caller);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 conflock->oh.len = 0; /* don't return OH info */
Andy Adamson8dc7c312006-03-20 13:44:26 -0500437 conflock->svid = conflock->fl.fl_pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 return nlm_lck_denied;
439 }
440
441 return nlm_granted;
442}
443
444/*
445 * Remove a lock.
446 * This implies a CANCEL call: We send a GRANT_MSG, the client replies
447 * with a GRANT_RES call which gets lost, and calls UNLOCK immediately
448 * afterwards. In this case the block will still be there, and hence
449 * must be removed.
450 */
451u32
452nlmsvc_unlock(struct nlm_file *file, struct nlm_lock *lock)
453{
454 int error;
455
456 dprintk("lockd: nlmsvc_unlock(%s/%ld, pi=%d, %Ld-%Ld)\n",
457 file->f_file->f_dentry->d_inode->i_sb->s_id,
458 file->f_file->f_dentry->d_inode->i_ino,
459 lock->fl.fl_pid,
460 (long long)lock->fl.fl_start,
461 (long long)lock->fl.fl_end);
462
463 /* First, cancel any lock that might be there */
464 nlmsvc_cancel_blocked(file, lock);
465
466 lock->fl.fl_type = F_UNLCK;
467 error = posix_lock_file(file->f_file, &lock->fl);
468
469 return (error < 0)? nlm_lck_denied_nolocks : nlm_granted;
470}
471
472/*
473 * Cancel a previously blocked request.
474 *
475 * A cancel request always overrides any grant that may currently
476 * be in progress.
477 * The calling procedure must check whether the file can be closed.
478 */
479u32
480nlmsvc_cancel_blocked(struct nlm_file *file, struct nlm_lock *lock)
481{
482 struct nlm_block *block;
J. Bruce Fields64a318e2006-01-03 09:55:46 +0100483 int status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
485 dprintk("lockd: nlmsvc_cancel(%s/%ld, pi=%d, %Ld-%Ld)\n",
486 file->f_file->f_dentry->d_inode->i_sb->s_id,
487 file->f_file->f_dentry->d_inode->i_ino,
488 lock->fl.fl_pid,
489 (long long)lock->fl.fl_start,
490 (long long)lock->fl.fl_end);
491
Neil Brown89e63ef2006-10-04 02:16:06 -0700492 mutex_lock(&file->f_mutex);
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500493 block = nlmsvc_lookup_block(file, lock);
Neil Brown89e63ef2006-10-04 02:16:06 -0700494 mutex_unlock(&file->f_mutex);
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500495 if (block != NULL) {
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500496 status = nlmsvc_unlink_block(block);
497 nlmsvc_release_block(block);
498 }
J. Bruce Fields64a318e2006-01-03 09:55:46 +0100499 return status ? nlm_lck_denied : nlm_granted;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500}
501
502/*
503 * Unblock a blocked lock request. This is a callback invoked from the
504 * VFS layer when a lock on which we blocked is removed.
505 *
506 * This function doesn't grant the blocked lock instantly, but rather moves
507 * the block to the head of nlm_blocked where it can be picked up by lockd.
508 */
509static void
510nlmsvc_notify_blocked(struct file_lock *fl)
511{
Olaf Kirch68a2d762006-10-04 02:15:57 -0700512 struct nlm_block *block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513
514 dprintk("lockd: VFS unblock notification for block %p\n", fl);
Olaf Kirch68a2d762006-10-04 02:15:57 -0700515 list_for_each_entry(block, &nlm_blocked, b_list) {
Trond Myklebust92737232006-03-20 13:44:45 -0500516 if (nlm_compare_locks(&block->b_call->a_args.lock.fl, fl)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 nlmsvc_insert_block(block, 0);
518 svc_wake_up(block->b_daemon);
519 return;
520 }
521 }
522
523 printk(KERN_WARNING "lockd: notification for unknown block!\n");
524}
525
526static int nlmsvc_same_owner(struct file_lock *fl1, struct file_lock *fl2)
527{
528 return fl1->fl_owner == fl2->fl_owner && fl1->fl_pid == fl2->fl_pid;
529}
530
531struct lock_manager_operations nlmsvc_lock_operations = {
532 .fl_compare_owner = nlmsvc_same_owner,
533 .fl_notify = nlmsvc_notify_blocked,
534};
535
536/*
537 * Try to claim a lock that was previously blocked.
538 *
539 * Note that we use both the RPC_GRANTED_MSG call _and_ an async
540 * RPC thread when notifying the client. This seems like overkill...
541 * Here's why:
542 * - we don't want to use a synchronous RPC thread, otherwise
543 * we might find ourselves hanging on a dead portmapper.
544 * - Some lockd implementations (e.g. HP) don't react to
545 * RPC_GRANTED calls; they seem to insist on RPC_GRANTED_MSG calls.
546 */
547static void
548nlmsvc_grant_blocked(struct nlm_block *block)
549{
550 struct nlm_file *file = block->b_file;
Trond Myklebust92737232006-03-20 13:44:45 -0500551 struct nlm_lock *lock = &block->b_call->a_args.lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 int error;
553
554 dprintk("lockd: grant blocked lock %p\n", block);
555
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 /* Unlink block request from list */
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500557 nlmsvc_unlink_block(block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558
559 /* If b_granted is true this means we've been here before.
560 * Just retry the grant callback, possibly refreshing the RPC
561 * binding */
562 if (block->b_granted) {
563 nlm_rebind_host(block->b_host);
564 goto callback;
565 }
566
567 /* Try the lock operation again */
Trond Myklebust09c79382006-03-20 13:44:38 -0500568 lock->fl.fl_flags |= FL_SLEEP;
Andy Adamson5de0e502006-03-20 13:44:25 -0500569 error = posix_lock_file(file->f_file, &lock->fl);
Trond Myklebust09c79382006-03-20 13:44:38 -0500570 lock->fl.fl_flags &= ~FL_SLEEP;
571
Andy Adamson5de0e502006-03-20 13:44:25 -0500572 switch (error) {
573 case 0:
574 break;
575 case -EAGAIN:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 dprintk("lockd: lock still blocked\n");
577 nlmsvc_insert_block(block, NLM_NEVER);
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500578 return;
Andy Adamson5de0e502006-03-20 13:44:25 -0500579 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 printk(KERN_WARNING "lockd: unexpected error %d in %s!\n",
581 -error, __FUNCTION__);
582 nlmsvc_insert_block(block, 10 * HZ);
Trond Myklebustd9f6eb72006-03-20 13:44:47 -0500583 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 }
585
586callback:
587 /* Lock was granted by VFS. */
588 dprintk("lockd: GRANTing blocked lock.\n");
589 block->b_granted = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
591 /* Schedule next grant callback in 30 seconds */
592 nlmsvc_insert_block(block, 30 * HZ);
593
594 /* Call the client */
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500595 kref_get(&block->b_count);
Trond Myklebust92737232006-03-20 13:44:45 -0500596 if (nlm_async_call(block->b_call, NLMPROC_GRANTED_MSG,
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100597 &nlmsvc_grant_ops) < 0)
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500598 nlmsvc_release_block(block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599}
600
601/*
602 * This is the callback from the RPC layer when the NLM_GRANTED_MSG
603 * RPC call has succeeded or timed out.
604 * Like all RPC callbacks, it is invoked by the rpciod process, so it
605 * better not sleep. Therefore, we put the blocked lock on the nlm_blocked
606 * chain once more in order to have it removed by lockd itself (which can
607 * then sleep on the file semaphore without disrupting e.g. the nfs client).
608 */
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100609static void nlmsvc_grant_callback(struct rpc_task *task, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610{
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100611 struct nlm_rqst *call = data;
Trond Myklebust92737232006-03-20 13:44:45 -0500612 struct nlm_block *block = call->a_block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 unsigned long timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
615 dprintk("lockd: GRANT_MSG RPC callback\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617 /* Technically, we should down the file semaphore here. Since we
618 * move the block towards the head of the queue only, no harm
619 * can be done, though. */
620 if (task->tk_status < 0) {
621 /* RPC error: Re-insert for retransmission */
622 timeout = 10 * HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 } else {
624 /* Call was successful, now wait for client callback */
625 timeout = 60 * HZ;
626 }
627 nlmsvc_insert_block(block, timeout);
628 svc_wake_up(block->b_daemon);
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500629}
630
Adrian Bunkec535ce2006-04-18 13:21:50 -0400631static void nlmsvc_grant_release(void *data)
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500632{
Trond Myklebust6041b792006-03-20 13:44:45 -0500633 struct nlm_rqst *call = data;
634
635 nlmsvc_release_block(call->a_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636}
637
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100638static const struct rpc_call_ops nlmsvc_grant_ops = {
639 .rpc_call_done = nlmsvc_grant_callback,
Trond Myklebust5e1abf82006-03-20 13:44:39 -0500640 .rpc_release = nlmsvc_grant_release,
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100641};
642
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643/*
644 * We received a GRANT_RES callback. Try to find the corresponding
645 * block.
646 */
647void
Olaf Kirch39be4502006-10-04 02:16:03 -0700648nlmsvc_grant_reply(struct nlm_cookie *cookie, u32 status)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649{
650 struct nlm_block *block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651
Olaf Kirch39be4502006-10-04 02:16:03 -0700652 dprintk("grant_reply: looking for cookie %x, s=%d \n",
653 *(unsigned int *)(cookie->data), status);
654 if (!(block = nlmsvc_find_block(cookie)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
J. Bruce Fieldsf2321422006-01-03 09:55:42 +0100657 if (block) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 if (status == NLM_LCK_DENIED_GRACE_PERIOD) {
659 /* Try again in a couple of seconds */
660 nlmsvc_insert_block(block, 10 * HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 } else {
662 /* Lock is now held by client, or has been rejected.
663 * In both cases, the block should be removed. */
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500664 nlmsvc_unlink_block(block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 }
666 }
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500667 nlmsvc_release_block(block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668}
669
670/*
671 * Retry all blocked locks that have been notified. This is where lockd
672 * picks up locks that can be granted, or grant notifications that must
673 * be retransmitted.
674 */
675unsigned long
676nlmsvc_retry_blocked(void)
677{
Olaf Kirch68a2d762006-10-04 02:15:57 -0700678 unsigned long timeout = MAX_SCHEDULE_TIMEOUT;
679 struct nlm_block *block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680
Olaf Kirch68a2d762006-10-04 02:15:57 -0700681 while (!list_empty(&nlm_blocked)) {
682 block = list_entry(nlm_blocked.next, struct nlm_block, b_list);
683
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 if (block->b_when == NLM_NEVER)
685 break;
Olaf Kirch68a2d762006-10-04 02:15:57 -0700686 if (time_after(block->b_when,jiffies)) {
687 timeout = block->b_when - jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 break;
Olaf Kirch68a2d762006-10-04 02:15:57 -0700689 }
690
J. Bruce Fieldsf3d43c72006-08-03 15:07:47 -0400691 dprintk("nlmsvc_retry_blocked(%p, when=%ld)\n",
692 block, block->b_when);
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500693 kref_get(&block->b_count);
J. Bruce Fieldsf3d43c72006-08-03 15:07:47 -0400694 nlmsvc_grant_blocked(block);
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500695 nlmsvc_release_block(block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 }
697
Olaf Kirch68a2d762006-10-04 02:15:57 -0700698 return timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699}