2 * linux/fs/lockd/svclock.c
4 * Handling of server-side locks, mostly of the blocked variety.
5 * This is the ugliest part of lockd because we tread on very thin ice.
6 * GRANT and CANCEL calls may get stuck, meet in mid-flight, etc.
7 * IMNSHO introducing the grant callback into the NLM protocol was one
8 * of the worst ideas Sun ever had. Except maybe for the idea of doing
9 * NFS file locking at all.
11 * I'm trying hard to avoid race conditions by protecting most accesses
12 * to a file's list of blocked locks through a semaphore. The global
13 * list of blocked locks is not protected in this fashion however.
14 * Therefore, some functions (such as the RPC callback for the async grant
15 * call) move blocked locks towards the head of the list *while some other
16 * process might be traversing it*. This should not be a problem in
17 * practice, because this will only cause functions traversing the list
18 * to visit some blocks twice.
20 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
23 #include <linux/config.h>
24 #include <linux/types.h>
25 #include <linux/errno.h>
26 #include <linux/kernel.h>
27 #include <linux/sched.h>
28 #include <linux/smp_lock.h>
29 #include <linux/sunrpc/clnt.h>
30 #include <linux/sunrpc/svc.h>
31 #include <linux/lockd/nlm.h>
32 #include <linux/lockd/lockd.h>
34 #define NLMDBG_FACILITY NLMDBG_SVCLOCK
36 #ifdef CONFIG_LOCKD_V4
37 #define nlm_deadlock nlm4_deadlock
39 #define nlm_deadlock nlm_lck_denied
42 static void nlmsvc_insert_block(struct nlm_block
*block
, unsigned long);
43 static int nlmsvc_remove_block(struct nlm_block
*block
);
45 static const struct rpc_call_ops nlmsvc_grant_ops
;
48 * The list of blocked locks to retry
50 static struct nlm_block
* nlm_blocked
;
53 * Insert a blocked lock into the global list
56 nlmsvc_insert_block(struct nlm_block
*block
, unsigned long when
)
58 struct nlm_block
**bp
, *b
;
60 dprintk("lockd: nlmsvc_insert_block(%p, %ld)\n", block
, when
);
62 nlmsvc_remove_block(block
);
64 if (when
!= NLM_NEVER
) {
65 if ((when
+= jiffies
) == NLM_NEVER
)
67 while ((b
= *bp
) && time_before_eq(b
->b_when
,when
) && b
->b_when
!= NLM_NEVER
)
70 while ((b
= *bp
) != 0)
80 * Remove a block from the global list
83 nlmsvc_remove_block(struct nlm_block
*block
)
85 struct nlm_block
**bp
, *b
;
89 for (bp
= &nlm_blocked
; (b
= *bp
) != 0; bp
= &b
->b_next
) {
101 * Find a block for a given lock and optionally remove it from
104 static struct nlm_block
*
105 nlmsvc_lookup_block(struct nlm_file
*file
, struct nlm_lock
*lock
, int remove
)
107 struct nlm_block
**head
, *block
;
108 struct file_lock
*fl
;
110 dprintk("lockd: nlmsvc_lookup_block f=%p pd=%d %Ld-%Ld ty=%d\n",
111 file
, lock
->fl
.fl_pid
,
112 (long long)lock
->fl
.fl_start
,
113 (long long)lock
->fl
.fl_end
, lock
->fl
.fl_type
);
114 for (head
= &nlm_blocked
; (block
= *head
) != 0; head
= &block
->b_next
) {
115 fl
= &block
->b_call
.a_args
.lock
.fl
;
116 dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%s\n",
117 block
->b_file
, fl
->fl_pid
,
118 (long long)fl
->fl_start
,
119 (long long)fl
->fl_end
, fl
->fl_type
,
120 nlmdbg_cookie2a(&block
->b_call
.a_args
.cookie
));
121 if (block
->b_file
== file
&& nlm_compare_locks(fl
, &lock
->fl
)) {
123 *head
= block
->b_next
;
133 static inline int nlm_cookie_match(struct nlm_cookie
*a
, struct nlm_cookie
*b
)
137 if(memcmp(a
->data
,b
->data
,a
->len
))
143 * Find a block with a given NLM cookie.
145 static inline struct nlm_block
*
146 nlmsvc_find_block(struct nlm_cookie
*cookie
, struct sockaddr_in
*sin
)
148 struct nlm_block
*block
;
150 for (block
= nlm_blocked
; block
; block
= block
->b_next
) {
151 dprintk("cookie: head of blocked queue %p, block %p\n",
153 if (nlm_cookie_match(&block
->b_call
.a_args
.cookie
,cookie
)
154 && nlm_cmp_addr(sin
, &block
->b_host
->h_addr
))
162 * Create a block and initialize it.
164 * Note: we explicitly set the cookie of the grant reply to that of
165 * the blocked lock request. The spec explicitly mentions that the client
166 * should _not_ rely on the callback containing the same cookie as the
167 * request, but (as I found out later) that's because some implementations
168 * do just this. Never mind the standards comittees, they support our
169 * logging industries.
171 static inline struct nlm_block
*
172 nlmsvc_create_block(struct svc_rqst
*rqstp
, struct nlm_file
*file
,
173 struct nlm_lock
*lock
, struct nlm_cookie
*cookie
)
175 struct nlm_block
*block
;
176 struct nlm_host
*host
;
177 struct nlm_rqst
*call
;
179 /* Create host handle for callback */
180 host
= nlmclnt_lookup_host(&rqstp
->rq_addr
,
181 rqstp
->rq_prot
, rqstp
->rq_vers
);
185 /* Allocate memory for block, and initialize arguments */
186 if (!(block
= (struct nlm_block
*) kmalloc(sizeof(*block
), GFP_KERNEL
)))
188 memset(block
, 0, sizeof(*block
));
189 locks_init_lock(&block
->b_call
.a_args
.lock
.fl
);
190 locks_init_lock(&block
->b_call
.a_res
.lock
.fl
);
192 if (!nlmclnt_setgrantargs(&block
->b_call
, lock
))
195 /* Set notifier function for VFS, and init args */
196 block
->b_call
.a_args
.lock
.fl
.fl_lmops
= &nlmsvc_lock_operations
;
197 block
->b_call
.a_args
.cookie
= *cookie
; /* see above */
199 dprintk("lockd: created block %p...\n", block
);
201 /* Create and initialize the block */
202 block
->b_daemon
= rqstp
->rq_server
;
203 block
->b_host
= host
;
204 block
->b_file
= file
;
206 /* Add to file's list of blocks */
207 block
->b_fnext
= file
->f_blocks
;
208 file
->f_blocks
= block
;
210 /* Set up RPC arguments for callback */
211 call
= &block
->b_call
;
213 call
->a_flags
= RPC_TASK_ASYNC
;
220 nlm_release_host(host
);
225 * Delete a block. If the lock was cancelled or the grant callback
226 * failed, unlock is set to 1.
227 * It is the caller's responsibility to check whether the file
228 * can be closed hereafter.
231 nlmsvc_delete_block(struct nlm_block
*block
, int unlock
)
233 struct file_lock
*fl
= &block
->b_call
.a_args
.lock
.fl
;
234 struct nlm_file
*file
= block
->b_file
;
235 struct nlm_block
**bp
;
237 dprintk("lockd: deleting block %p...\n", block
);
239 /* Remove block from list */
240 nlmsvc_remove_block(block
);
241 posix_unblock_lock(file
->f_file
, fl
);
243 /* If the block is in the middle of a GRANT callback,
244 * don't kill it yet. */
245 if (block
->b_incall
) {
246 nlmsvc_insert_block(block
, NLM_NEVER
);
251 /* Remove block from file's list of blocks */
252 for (bp
= &file
->f_blocks
; *bp
; bp
= &(*bp
)->b_fnext
) {
254 *bp
= block
->b_fnext
;
260 nlm_release_host(block
->b_host
);
261 nlmclnt_freegrantargs(&block
->b_call
);
266 * Loop over all blocks and perform the action specified.
267 * (NLM_ACT_CHECK handled by nlmsvc_inspect_file).
270 nlmsvc_traverse_blocks(struct nlm_host
*host
, struct nlm_file
*file
, int action
)
272 struct nlm_block
*block
, *next
;
275 for (block
= file
->f_blocks
; block
; block
= next
) {
276 next
= block
->b_fnext
;
277 if (action
== NLM_ACT_MARK
)
278 block
->b_host
->h_inuse
= 1;
279 else if (action
== NLM_ACT_UNLOCK
) {
280 if (host
== NULL
|| host
== block
->b_host
)
281 nlmsvc_delete_block(block
, 1);
289 * Attempt to establish a lock, and if it can't be granted, block it
293 nlmsvc_lock(struct svc_rqst
*rqstp
, struct nlm_file
*file
,
294 struct nlm_lock
*lock
, int wait
, struct nlm_cookie
*cookie
)
296 struct file_lock
*conflock
;
297 struct nlm_block
*block
;
300 dprintk("lockd: nlmsvc_lock(%s/%ld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
301 file
->f_file
->f_dentry
->d_inode
->i_sb
->s_id
,
302 file
->f_file
->f_dentry
->d_inode
->i_ino
,
303 lock
->fl
.fl_type
, lock
->fl
.fl_pid
,
304 (long long)lock
->fl
.fl_start
,
305 (long long)lock
->fl
.fl_end
,
309 /* Get existing block (in case client is busy-waiting) */
310 block
= nlmsvc_lookup_block(file
, lock
, 0);
312 lock
->fl
.fl_flags
|= FL_LOCKD
;
315 /* Lock file against concurrent access */
318 if (!(conflock
= posix_test_lock(file
->f_file
, &lock
->fl
))) {
319 error
= posix_lock_file(file
->f_file
, &lock
->fl
);
322 nlmsvc_delete_block(block
, 0);
325 dprintk("lockd: posix_lock_file returned %d\n", -error
);
332 return nlm_lck_denied
;
333 default: /* includes ENOLCK */
334 return nlm_lck_denied_nolocks
;
340 return nlm_lck_denied
;
343 if (posix_locks_deadlock(&lock
->fl
, conflock
)) {
348 /* If we don't have a block, create and initialize it. Then
349 * retry because we may have slept in kmalloc. */
350 /* We have to release f_sema as nlmsvc_create_block may try to
351 * to claim it while doing host garbage collection */
354 dprintk("lockd: blocking on this lock (allocating).\n");
355 if (!(block
= nlmsvc_create_block(rqstp
, file
, lock
, cookie
)))
356 return nlm_lck_denied_nolocks
;
360 /* Append to list of blocked */
361 nlmsvc_insert_block(block
, NLM_NEVER
);
363 if (list_empty(&block
->b_call
.a_args
.lock
.fl
.fl_block
)) {
364 /* Now add block to block list of the conflicting lock
365 if we haven't done so. */
366 dprintk("lockd: blocking on this lock.\n");
367 posix_block_lock(conflock
, &block
->b_call
.a_args
.lock
.fl
);
371 return nlm_lck_blocked
;
375 * Test for presence of a conflicting lock.
378 nlmsvc_testlock(struct nlm_file
*file
, struct nlm_lock
*lock
,
379 struct nlm_lock
*conflock
)
381 struct file_lock
*fl
;
383 dprintk("lockd: nlmsvc_testlock(%s/%ld, ty=%d, %Ld-%Ld)\n",
384 file
->f_file
->f_dentry
->d_inode
->i_sb
->s_id
,
385 file
->f_file
->f_dentry
->d_inode
->i_ino
,
387 (long long)lock
->fl
.fl_start
,
388 (long long)lock
->fl
.fl_end
);
390 if ((fl
= posix_test_lock(file
->f_file
, &lock
->fl
)) != NULL
) {
391 dprintk("lockd: conflicting lock(ty=%d, %Ld-%Ld)\n",
392 fl
->fl_type
, (long long)fl
->fl_start
,
393 (long long)fl
->fl_end
);
394 conflock
->caller
= "somehost"; /* FIXME */
395 conflock
->oh
.len
= 0; /* don't return OH info */
397 return nlm_lck_denied
;
405 * This implies a CANCEL call: We send a GRANT_MSG, the client replies
406 * with a GRANT_RES call which gets lost, and calls UNLOCK immediately
407 * afterwards. In this case the block will still be there, and hence
411 nlmsvc_unlock(struct nlm_file
*file
, struct nlm_lock
*lock
)
415 dprintk("lockd: nlmsvc_unlock(%s/%ld, pi=%d, %Ld-%Ld)\n",
416 file
->f_file
->f_dentry
->d_inode
->i_sb
->s_id
,
417 file
->f_file
->f_dentry
->d_inode
->i_ino
,
419 (long long)lock
->fl
.fl_start
,
420 (long long)lock
->fl
.fl_end
);
422 /* First, cancel any lock that might be there */
423 nlmsvc_cancel_blocked(file
, lock
);
425 lock
->fl
.fl_type
= F_UNLCK
;
426 error
= posix_lock_file(file
->f_file
, &lock
->fl
);
428 return (error
< 0)? nlm_lck_denied_nolocks
: nlm_granted
;
432 * Cancel a previously blocked request.
434 * A cancel request always overrides any grant that may currently
436 * The calling procedure must check whether the file can be closed.
439 nlmsvc_cancel_blocked(struct nlm_file
*file
, struct nlm_lock
*lock
)
441 struct nlm_block
*block
;
443 dprintk("lockd: nlmsvc_cancel(%s/%ld, pi=%d, %Ld-%Ld)\n",
444 file
->f_file
->f_dentry
->d_inode
->i_sb
->s_id
,
445 file
->f_file
->f_dentry
->d_inode
->i_ino
,
447 (long long)lock
->fl
.fl_start
,
448 (long long)lock
->fl
.fl_end
);
451 if ((block
= nlmsvc_lookup_block(file
, lock
, 1)) != NULL
)
452 nlmsvc_delete_block(block
, 1);
458 * Unblock a blocked lock request. This is a callback invoked from the
459 * VFS layer when a lock on which we blocked is removed.
461 * This function doesn't grant the blocked lock instantly, but rather moves
462 * the block to the head of nlm_blocked where it can be picked up by lockd.
465 nlmsvc_notify_blocked(struct file_lock
*fl
)
467 struct nlm_block
**bp
, *block
;
469 dprintk("lockd: VFS unblock notification for block %p\n", fl
);
470 for (bp
= &nlm_blocked
; (block
= *bp
) != 0; bp
= &block
->b_next
) {
471 if (nlm_compare_locks(&block
->b_call
.a_args
.lock
.fl
, fl
)) {
472 nlmsvc_insert_block(block
, 0);
473 svc_wake_up(block
->b_daemon
);
478 printk(KERN_WARNING
"lockd: notification for unknown block!\n");
481 static int nlmsvc_same_owner(struct file_lock
*fl1
, struct file_lock
*fl2
)
483 return fl1
->fl_owner
== fl2
->fl_owner
&& fl1
->fl_pid
== fl2
->fl_pid
;
486 struct lock_manager_operations nlmsvc_lock_operations
= {
487 .fl_compare_owner
= nlmsvc_same_owner
,
488 .fl_notify
= nlmsvc_notify_blocked
,
492 * Try to claim a lock that was previously blocked.
494 * Note that we use both the RPC_GRANTED_MSG call _and_ an async
495 * RPC thread when notifying the client. This seems like overkill...
497 * - we don't want to use a synchronous RPC thread, otherwise
498 * we might find ourselves hanging on a dead portmapper.
499 * - Some lockd implementations (e.g. HP) don't react to
500 * RPC_GRANTED calls; they seem to insist on RPC_GRANTED_MSG calls.
503 nlmsvc_grant_blocked(struct nlm_block
*block
)
505 struct nlm_file
*file
= block
->b_file
;
506 struct nlm_lock
*lock
= &block
->b_call
.a_args
.lock
;
507 struct file_lock
*conflock
;
510 dprintk("lockd: grant blocked lock %p\n", block
);
512 /* First thing is lock the file */
515 /* Unlink block request from list */
516 nlmsvc_remove_block(block
);
518 /* If b_granted is true this means we've been here before.
519 * Just retry the grant callback, possibly refreshing the RPC
521 if (block
->b_granted
) {
522 nlm_rebind_host(block
->b_host
);
526 /* Try the lock operation again */
527 if ((conflock
= posix_test_lock(file
->f_file
, &lock
->fl
)) != NULL
) {
528 /* Bummer, we blocked again */
529 dprintk("lockd: lock still blocked\n");
530 nlmsvc_insert_block(block
, NLM_NEVER
);
531 posix_block_lock(conflock
, &lock
->fl
);
536 /* Alright, no conflicting lock. Now lock it for real. If the
537 * following yields an error, this is most probably due to low
538 * memory. Retry the lock in a few seconds.
540 if ((error
= posix_lock_file(file
->f_file
, &lock
->fl
)) < 0) {
541 printk(KERN_WARNING
"lockd: unexpected error %d in %s!\n",
542 -error
, __FUNCTION__
);
543 nlmsvc_insert_block(block
, 10 * HZ
);
549 /* Lock was granted by VFS. */
550 dprintk("lockd: GRANTing blocked lock.\n");
551 block
->b_granted
= 1;
554 /* Schedule next grant callback in 30 seconds */
555 nlmsvc_insert_block(block
, 30 * HZ
);
557 /* Call the client */
558 nlm_get_host(block
->b_call
.a_host
);
559 if (nlmsvc_async_call(&block
->b_call
, NLMPROC_GRANTED_MSG
,
560 &nlmsvc_grant_ops
) < 0)
561 nlm_release_host(block
->b_call
.a_host
);
566 * This is the callback from the RPC layer when the NLM_GRANTED_MSG
567 * RPC call has succeeded or timed out.
568 * Like all RPC callbacks, it is invoked by the rpciod process, so it
569 * better not sleep. Therefore, we put the blocked lock on the nlm_blocked
570 * chain once more in order to have it removed by lockd itself (which can
571 * then sleep on the file semaphore without disrupting e.g. the nfs client).
573 static void nlmsvc_grant_callback(struct rpc_task
*task
, void *data
)
575 struct nlm_rqst
*call
= data
;
576 struct nlm_block
*block
;
577 unsigned long timeout
;
578 struct sockaddr_in
*peer_addr
= RPC_PEERADDR(task
->tk_client
);
580 dprintk("lockd: GRANT_MSG RPC callback\n");
581 dprintk("callback: looking for cookie %s, host (%u.%u.%u.%u)\n",
582 nlmdbg_cookie2a(&call
->a_args
.cookie
),
583 NIPQUAD(peer_addr
->sin_addr
.s_addr
));
584 if (!(block
= nlmsvc_find_block(&call
->a_args
.cookie
, peer_addr
))) {
585 dprintk("lockd: no block for cookie %s, host (%u.%u.%u.%u)\n",
586 nlmdbg_cookie2a(&call
->a_args
.cookie
),
587 NIPQUAD(peer_addr
->sin_addr
.s_addr
));
591 /* Technically, we should down the file semaphore here. Since we
592 * move the block towards the head of the queue only, no harm
593 * can be done, though. */
594 if (task
->tk_status
< 0) {
595 /* RPC error: Re-insert for retransmission */
597 } else if (block
->b_done
) {
598 /* Block already removed, kill it for real */
601 /* Call was successful, now wait for client callback */
604 nlmsvc_insert_block(block
, timeout
);
605 svc_wake_up(block
->b_daemon
);
608 nlm_release_host(call
->a_host
);
611 static const struct rpc_call_ops nlmsvc_grant_ops
= {
612 .rpc_call_done
= nlmsvc_grant_callback
,
616 * We received a GRANT_RES callback. Try to find the corresponding
620 nlmsvc_grant_reply(struct svc_rqst
*rqstp
, struct nlm_cookie
*cookie
, u32 status
)
622 struct nlm_block
*block
;
623 struct nlm_file
*file
;
625 dprintk("grant_reply: looking for cookie %x, host (%08x), s=%d \n",
626 *(unsigned int *)(cookie
->data
),
627 ntohl(rqstp
->rq_addr
.sin_addr
.s_addr
), status
);
628 if (!(block
= nlmsvc_find_block(cookie
, &rqstp
->rq_addr
)))
630 file
= block
->b_file
;
634 block
= nlmsvc_find_block(cookie
, &rqstp
->rq_addr
);
636 if (status
== NLM_LCK_DENIED_GRACE_PERIOD
) {
637 /* Try again in a couple of seconds */
638 nlmsvc_insert_block(block
, 10 * HZ
);
641 /* Lock is now held by client, or has been rejected.
642 * In both cases, the block should be removed. */
644 if (status
== NLM_LCK_GRANTED
)
645 nlmsvc_delete_block(block
, 0);
647 nlmsvc_delete_block(block
, 1);
650 nlm_release_file(file
);
654 * Retry all blocked locks that have been notified. This is where lockd
655 * picks up locks that can be granted, or grant notifications that must
659 nlmsvc_retry_blocked(void)
661 struct nlm_block
*block
;
663 dprintk("nlmsvc_retry_blocked(%p, when=%ld)\n",
665 nlm_blocked
? nlm_blocked
->b_when
: 0);
666 while ((block
= nlm_blocked
) != 0) {
667 if (block
->b_when
== NLM_NEVER
)
669 if (time_after(block
->b_when
,jiffies
))
671 dprintk("nlmsvc_retry_blocked(%p, when=%ld, done=%d)\n",
672 block
, block
->b_when
, block
->b_done
);
674 nlmsvc_delete_block(block
, 0);
676 nlmsvc_grant_blocked(block
);
679 if ((block
= nlm_blocked
) && block
->b_when
!= NLM_NEVER
)
680 return (block
->b_when
- jiffies
);
682 return MAX_SCHEDULE_TIMEOUT
;