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
);
242 posix_unblock_lock(file
->f_file
, fl
);
244 fl
->fl_type
= F_UNLCK
;
245 posix_lock_file(file
->f_file
, fl
);
246 block
->b_granted
= 0;
249 /* If the block is in the middle of a GRANT callback,
250 * don't kill it yet. */
251 if (block
->b_incall
) {
252 nlmsvc_insert_block(block
, NLM_NEVER
);
257 /* Remove block from file's list of blocks */
258 for (bp
= &file
->f_blocks
; *bp
; bp
= &(*bp
)->b_fnext
) {
260 *bp
= block
->b_fnext
;
266 nlm_release_host(block
->b_host
);
267 nlmclnt_freegrantargs(&block
->b_call
);
272 * Loop over all blocks and perform the action specified.
273 * (NLM_ACT_CHECK handled by nlmsvc_inspect_file).
276 nlmsvc_traverse_blocks(struct nlm_host
*host
, struct nlm_file
*file
, int action
)
278 struct nlm_block
*block
, *next
;
281 for (block
= file
->f_blocks
; block
; block
= next
) {
282 next
= block
->b_fnext
;
283 if (action
== NLM_ACT_MARK
)
284 block
->b_host
->h_inuse
= 1;
285 else if (action
== NLM_ACT_UNLOCK
) {
286 if (host
== NULL
|| host
== block
->b_host
)
287 nlmsvc_delete_block(block
, 1);
295 * Attempt to establish a lock, and if it can't be granted, block it
299 nlmsvc_lock(struct svc_rqst
*rqstp
, struct nlm_file
*file
,
300 struct nlm_lock
*lock
, int wait
, struct nlm_cookie
*cookie
)
302 struct file_lock
*conflock
;
303 struct nlm_block
*block
;
306 dprintk("lockd: nlmsvc_lock(%s/%ld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
307 file
->f_file
->f_dentry
->d_inode
->i_sb
->s_id
,
308 file
->f_file
->f_dentry
->d_inode
->i_ino
,
309 lock
->fl
.fl_type
, lock
->fl
.fl_pid
,
310 (long long)lock
->fl
.fl_start
,
311 (long long)lock
->fl
.fl_end
,
315 /* Get existing block (in case client is busy-waiting) */
316 block
= nlmsvc_lookup_block(file
, lock
, 0);
318 lock
->fl
.fl_flags
|= FL_LOCKD
;
321 /* Lock file against concurrent access */
324 if (!(conflock
= posix_test_lock(file
->f_file
, &lock
->fl
))) {
325 error
= posix_lock_file(file
->f_file
, &lock
->fl
);
328 nlmsvc_delete_block(block
, 0);
331 dprintk("lockd: posix_lock_file returned %d\n", -error
);
338 return nlm_lck_denied
;
339 default: /* includes ENOLCK */
340 return nlm_lck_denied_nolocks
;
346 return nlm_lck_denied
;
349 if (posix_locks_deadlock(&lock
->fl
, conflock
)) {
354 /* If we don't have a block, create and initialize it. Then
355 * retry because we may have slept in kmalloc. */
356 /* We have to release f_sema as nlmsvc_create_block may try to
357 * to claim it while doing host garbage collection */
360 dprintk("lockd: blocking on this lock (allocating).\n");
361 if (!(block
= nlmsvc_create_block(rqstp
, file
, lock
, cookie
)))
362 return nlm_lck_denied_nolocks
;
366 /* Append to list of blocked */
367 nlmsvc_insert_block(block
, NLM_NEVER
);
369 if (list_empty(&block
->b_call
.a_args
.lock
.fl
.fl_block
)) {
370 /* Now add block to block list of the conflicting lock
371 if we haven't done so. */
372 dprintk("lockd: blocking on this lock.\n");
373 posix_block_lock(conflock
, &block
->b_call
.a_args
.lock
.fl
);
377 return nlm_lck_blocked
;
381 * Test for presence of a conflicting lock.
384 nlmsvc_testlock(struct nlm_file
*file
, struct nlm_lock
*lock
,
385 struct nlm_lock
*conflock
)
387 struct file_lock
*fl
;
389 dprintk("lockd: nlmsvc_testlock(%s/%ld, ty=%d, %Ld-%Ld)\n",
390 file
->f_file
->f_dentry
->d_inode
->i_sb
->s_id
,
391 file
->f_file
->f_dentry
->d_inode
->i_ino
,
393 (long long)lock
->fl
.fl_start
,
394 (long long)lock
->fl
.fl_end
);
396 if ((fl
= posix_test_lock(file
->f_file
, &lock
->fl
)) != NULL
) {
397 dprintk("lockd: conflicting lock(ty=%d, %Ld-%Ld)\n",
398 fl
->fl_type
, (long long)fl
->fl_start
,
399 (long long)fl
->fl_end
);
400 conflock
->caller
= "somehost"; /* FIXME */
401 conflock
->oh
.len
= 0; /* don't return OH info */
403 return nlm_lck_denied
;
411 * This implies a CANCEL call: We send a GRANT_MSG, the client replies
412 * with a GRANT_RES call which gets lost, and calls UNLOCK immediately
413 * afterwards. In this case the block will still be there, and hence
417 nlmsvc_unlock(struct nlm_file
*file
, struct nlm_lock
*lock
)
421 dprintk("lockd: nlmsvc_unlock(%s/%ld, pi=%d, %Ld-%Ld)\n",
422 file
->f_file
->f_dentry
->d_inode
->i_sb
->s_id
,
423 file
->f_file
->f_dentry
->d_inode
->i_ino
,
425 (long long)lock
->fl
.fl_start
,
426 (long long)lock
->fl
.fl_end
);
428 /* First, cancel any lock that might be there */
429 nlmsvc_cancel_blocked(file
, lock
);
431 lock
->fl
.fl_type
= F_UNLCK
;
432 error
= posix_lock_file(file
->f_file
, &lock
->fl
);
434 return (error
< 0)? nlm_lck_denied_nolocks
: nlm_granted
;
438 * Cancel a previously blocked request.
440 * A cancel request always overrides any grant that may currently
442 * The calling procedure must check whether the file can be closed.
445 nlmsvc_cancel_blocked(struct nlm_file
*file
, struct nlm_lock
*lock
)
447 struct nlm_block
*block
;
449 dprintk("lockd: nlmsvc_cancel(%s/%ld, pi=%d, %Ld-%Ld)\n",
450 file
->f_file
->f_dentry
->d_inode
->i_sb
->s_id
,
451 file
->f_file
->f_dentry
->d_inode
->i_ino
,
453 (long long)lock
->fl
.fl_start
,
454 (long long)lock
->fl
.fl_end
);
457 if ((block
= nlmsvc_lookup_block(file
, lock
, 1)) != NULL
)
458 nlmsvc_delete_block(block
, 1);
464 * Unblock a blocked lock request. This is a callback invoked from the
465 * VFS layer when a lock on which we blocked is removed.
467 * This function doesn't grant the blocked lock instantly, but rather moves
468 * the block to the head of nlm_blocked where it can be picked up by lockd.
471 nlmsvc_notify_blocked(struct file_lock
*fl
)
473 struct nlm_block
**bp
, *block
;
475 dprintk("lockd: VFS unblock notification for block %p\n", fl
);
476 for (bp
= &nlm_blocked
; (block
= *bp
) != 0; bp
= &block
->b_next
) {
477 if (nlm_compare_locks(&block
->b_call
.a_args
.lock
.fl
, fl
)) {
478 nlmsvc_insert_block(block
, 0);
479 svc_wake_up(block
->b_daemon
);
484 printk(KERN_WARNING
"lockd: notification for unknown block!\n");
487 static int nlmsvc_same_owner(struct file_lock
*fl1
, struct file_lock
*fl2
)
489 return fl1
->fl_owner
== fl2
->fl_owner
&& fl1
->fl_pid
== fl2
->fl_pid
;
492 struct lock_manager_operations nlmsvc_lock_operations
= {
493 .fl_compare_owner
= nlmsvc_same_owner
,
494 .fl_notify
= nlmsvc_notify_blocked
,
498 * Try to claim a lock that was previously blocked.
500 * Note that we use both the RPC_GRANTED_MSG call _and_ an async
501 * RPC thread when notifying the client. This seems like overkill...
503 * - we don't want to use a synchronous RPC thread, otherwise
504 * we might find ourselves hanging on a dead portmapper.
505 * - Some lockd implementations (e.g. HP) don't react to
506 * RPC_GRANTED calls; they seem to insist on RPC_GRANTED_MSG calls.
509 nlmsvc_grant_blocked(struct nlm_block
*block
)
511 struct nlm_file
*file
= block
->b_file
;
512 struct nlm_lock
*lock
= &block
->b_call
.a_args
.lock
;
513 struct file_lock
*conflock
;
516 dprintk("lockd: grant blocked lock %p\n", block
);
518 /* First thing is lock the file */
521 /* Unlink block request from list */
522 nlmsvc_remove_block(block
);
524 /* If b_granted is true this means we've been here before.
525 * Just retry the grant callback, possibly refreshing the RPC
527 if (block
->b_granted
) {
528 nlm_rebind_host(block
->b_host
);
532 /* Try the lock operation again */
533 if ((conflock
= posix_test_lock(file
->f_file
, &lock
->fl
)) != NULL
) {
534 /* Bummer, we blocked again */
535 dprintk("lockd: lock still blocked\n");
536 nlmsvc_insert_block(block
, NLM_NEVER
);
537 posix_block_lock(conflock
, &lock
->fl
);
542 /* Alright, no conflicting lock. Now lock it for real. If the
543 * following yields an error, this is most probably due to low
544 * memory. Retry the lock in a few seconds.
546 if ((error
= posix_lock_file(file
->f_file
, &lock
->fl
)) < 0) {
547 printk(KERN_WARNING
"lockd: unexpected error %d in %s!\n",
548 -error
, __FUNCTION__
);
549 nlmsvc_insert_block(block
, 10 * HZ
);
555 /* Lock was granted by VFS. */
556 dprintk("lockd: GRANTing blocked lock.\n");
557 block
->b_granted
= 1;
560 /* Schedule next grant callback in 30 seconds */
561 nlmsvc_insert_block(block
, 30 * HZ
);
563 /* Call the client */
564 nlm_get_host(block
->b_call
.a_host
);
565 if (nlmsvc_async_call(&block
->b_call
, NLMPROC_GRANTED_MSG
,
566 &nlmsvc_grant_ops
) < 0)
567 nlm_release_host(block
->b_call
.a_host
);
572 * This is the callback from the RPC layer when the NLM_GRANTED_MSG
573 * RPC call has succeeded or timed out.
574 * Like all RPC callbacks, it is invoked by the rpciod process, so it
575 * better not sleep. Therefore, we put the blocked lock on the nlm_blocked
576 * chain once more in order to have it removed by lockd itself (which can
577 * then sleep on the file semaphore without disrupting e.g. the nfs client).
579 static void nlmsvc_grant_callback(struct rpc_task
*task
, void *data
)
581 struct nlm_rqst
*call
= data
;
582 struct nlm_block
*block
;
583 unsigned long timeout
;
584 struct sockaddr_in
*peer_addr
= RPC_PEERADDR(task
->tk_client
);
586 dprintk("lockd: GRANT_MSG RPC callback\n");
587 dprintk("callback: looking for cookie %s, host (%u.%u.%u.%u)\n",
588 nlmdbg_cookie2a(&call
->a_args
.cookie
),
589 NIPQUAD(peer_addr
->sin_addr
.s_addr
));
590 if (!(block
= nlmsvc_find_block(&call
->a_args
.cookie
, peer_addr
))) {
591 dprintk("lockd: no block for cookie %s, host (%u.%u.%u.%u)\n",
592 nlmdbg_cookie2a(&call
->a_args
.cookie
),
593 NIPQUAD(peer_addr
->sin_addr
.s_addr
));
597 /* Technically, we should down the file semaphore here. Since we
598 * move the block towards the head of the queue only, no harm
599 * can be done, though. */
600 if (task
->tk_status
< 0) {
601 /* RPC error: Re-insert for retransmission */
603 } else if (block
->b_done
) {
604 /* Block already removed, kill it for real */
607 /* Call was successful, now wait for client callback */
610 nlmsvc_insert_block(block
, timeout
);
611 svc_wake_up(block
->b_daemon
);
614 nlm_release_host(call
->a_host
);
617 static const struct rpc_call_ops nlmsvc_grant_ops
= {
618 .rpc_call_done
= nlmsvc_grant_callback
,
622 * We received a GRANT_RES callback. Try to find the corresponding
626 nlmsvc_grant_reply(struct svc_rqst
*rqstp
, struct nlm_cookie
*cookie
, u32 status
)
628 struct nlm_block
*block
;
629 struct nlm_file
*file
;
631 dprintk("grant_reply: looking for cookie %x, host (%08x), s=%d \n",
632 *(unsigned int *)(cookie
->data
),
633 ntohl(rqstp
->rq_addr
.sin_addr
.s_addr
), status
);
634 if (!(block
= nlmsvc_find_block(cookie
, &rqstp
->rq_addr
)))
636 file
= block
->b_file
;
640 if ((block
= nlmsvc_find_block(cookie
,&rqstp
->rq_addr
)) != NULL
) {
641 if (status
== NLM_LCK_DENIED_GRACE_PERIOD
) {
642 /* Try again in a couple of seconds */
643 nlmsvc_insert_block(block
, 10 * HZ
);
646 /* Lock is now held by client, or has been rejected.
647 * In both cases, the block should be removed. */
649 if (status
== NLM_LCK_GRANTED
)
650 nlmsvc_delete_block(block
, 0);
652 nlmsvc_delete_block(block
, 1);
657 nlm_release_file(file
);
661 * Retry all blocked locks that have been notified. This is where lockd
662 * picks up locks that can be granted, or grant notifications that must
666 nlmsvc_retry_blocked(void)
668 struct nlm_block
*block
;
670 dprintk("nlmsvc_retry_blocked(%p, when=%ld)\n",
672 nlm_blocked
? nlm_blocked
->b_when
: 0);
673 while ((block
= nlm_blocked
) != 0) {
674 if (block
->b_when
== NLM_NEVER
)
676 if (time_after(block
->b_when
,jiffies
))
678 dprintk("nlmsvc_retry_blocked(%p, when=%ld, done=%d)\n",
679 block
, block
->b_when
, block
->b_done
);
681 nlmsvc_delete_block(block
, 0);
683 nlmsvc_grant_blocked(block
);
686 if ((block
= nlm_blocked
) && block
->b_when
!= NLM_NEVER
)
687 return (block
->b_when
- jiffies
);
689 return MAX_SCHEDULE_TIMEOUT
;