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_release_block(struct nlm_block
*block
);
43 static void nlmsvc_insert_block(struct nlm_block
*block
, unsigned long);
44 static int nlmsvc_remove_block(struct nlm_block
*block
);
46 static int nlmsvc_setgrantargs(struct nlm_rqst
*call
, struct nlm_lock
*lock
);
47 static void nlmsvc_freegrantargs(struct nlm_rqst
*call
);
48 static const struct rpc_call_ops nlmsvc_grant_ops
;
51 * The list of blocked locks to retry
53 static struct nlm_block
* nlm_blocked
;
56 * Insert a blocked lock into the global list
59 nlmsvc_insert_block(struct nlm_block
*block
, unsigned long when
)
61 struct nlm_block
**bp
, *b
;
63 dprintk("lockd: nlmsvc_insert_block(%p, %ld)\n", block
, when
);
64 kref_get(&block
->b_count
);
66 nlmsvc_remove_block(block
);
68 if (when
!= NLM_NEVER
) {
69 if ((when
+= jiffies
) == NLM_NEVER
)
71 while ((b
= *bp
) && time_before_eq(b
->b_when
,when
) && b
->b_when
!= NLM_NEVER
)
74 while ((b
= *bp
) != 0)
84 * Remove a block from the global list
87 nlmsvc_remove_block(struct nlm_block
*block
)
89 struct nlm_block
**bp
, *b
;
93 for (bp
= &nlm_blocked
; (b
= *bp
) != 0; bp
= &b
->b_next
) {
97 nlmsvc_release_block(block
);
106 * Find a block for a given lock and optionally remove it from
109 static struct nlm_block
*
110 nlmsvc_lookup_block(struct nlm_file
*file
, struct nlm_lock
*lock
, int remove
)
112 struct nlm_block
**head
, *block
;
113 struct file_lock
*fl
;
115 dprintk("lockd: nlmsvc_lookup_block f=%p pd=%d %Ld-%Ld ty=%d\n",
116 file
, lock
->fl
.fl_pid
,
117 (long long)lock
->fl
.fl_start
,
118 (long long)lock
->fl
.fl_end
, lock
->fl
.fl_type
);
119 for (head
= &nlm_blocked
; (block
= *head
) != 0; head
= &block
->b_next
) {
120 fl
= &block
->b_call
.a_args
.lock
.fl
;
121 dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%s\n",
122 block
->b_file
, fl
->fl_pid
,
123 (long long)fl
->fl_start
,
124 (long long)fl
->fl_end
, fl
->fl_type
,
125 nlmdbg_cookie2a(&block
->b_call
.a_args
.cookie
));
126 if (block
->b_file
== file
&& nlm_compare_locks(fl
, &lock
->fl
)) {
128 *head
= block
->b_next
;
131 kref_get(&block
->b_count
);
139 static inline int nlm_cookie_match(struct nlm_cookie
*a
, struct nlm_cookie
*b
)
143 if(memcmp(a
->data
,b
->data
,a
->len
))
149 * Find a block with a given NLM cookie.
151 static inline struct nlm_block
*
152 nlmsvc_find_block(struct nlm_cookie
*cookie
, struct sockaddr_in
*sin
)
154 struct nlm_block
*block
;
156 for (block
= nlm_blocked
; block
; block
= block
->b_next
) {
157 dprintk("cookie: head of blocked queue %p, block %p\n",
159 if (nlm_cookie_match(&block
->b_call
.a_args
.cookie
,cookie
)
160 && nlm_cmp_addr(sin
, &block
->b_host
->h_addr
))
165 kref_get(&block
->b_count
);
170 * Create a block and initialize it.
172 * Note: we explicitly set the cookie of the grant reply to that of
173 * the blocked lock request. The spec explicitly mentions that the client
174 * should _not_ rely on the callback containing the same cookie as the
175 * request, but (as I found out later) that's because some implementations
176 * do just this. Never mind the standards comittees, they support our
177 * logging industries.
179 static inline struct nlm_block
*
180 nlmsvc_create_block(struct svc_rqst
*rqstp
, struct nlm_file
*file
,
181 struct nlm_lock
*lock
, struct nlm_cookie
*cookie
)
183 struct nlm_block
*block
;
184 struct nlm_host
*host
;
185 struct nlm_rqst
*call
;
187 /* Create host handle for callback */
188 host
= nlmclnt_lookup_host(&rqstp
->rq_addr
,
189 rqstp
->rq_prot
, rqstp
->rq_vers
);
193 /* Allocate memory for block, and initialize arguments */
194 if (!(block
= (struct nlm_block
*) kmalloc(sizeof(*block
), GFP_KERNEL
)))
196 memset(block
, 0, sizeof(*block
));
197 locks_init_lock(&block
->b_call
.a_args
.lock
.fl
);
198 locks_init_lock(&block
->b_call
.a_res
.lock
.fl
);
199 kref_init(&block
->b_count
);
201 if (!nlmsvc_setgrantargs(&block
->b_call
, lock
))
204 /* Set notifier function for VFS, and init args */
205 block
->b_call
.a_args
.lock
.fl
.fl_flags
|= FL_SLEEP
;
206 block
->b_call
.a_args
.lock
.fl
.fl_lmops
= &nlmsvc_lock_operations
;
207 block
->b_call
.a_args
.cookie
= *cookie
; /* see above */
209 dprintk("lockd: created block %p...\n", block
);
211 /* Create and initialize the block */
212 block
->b_daemon
= rqstp
->rq_server
;
213 block
->b_host
= host
;
214 block
->b_file
= file
;
216 /* Add to file's list of blocks */
217 block
->b_fnext
= file
->f_blocks
;
218 file
->f_blocks
= block
;
220 /* Set up RPC arguments for callback */
221 call
= &block
->b_call
;
223 call
->a_flags
= RPC_TASK_ASYNC
;
230 nlm_release_host(host
);
235 * Delete a block. If the lock was cancelled or the grant callback
236 * failed, unlock is set to 1.
237 * It is the caller's responsibility to check whether the file
238 * can be closed hereafter.
240 static int nlmsvc_unlink_block(struct nlm_block
*block
)
243 dprintk("lockd: unlinking block %p...\n", block
);
245 /* Remove block from list */
246 status
= posix_unblock_lock(block
->b_file
->f_file
, &block
->b_call
.a_args
.lock
.fl
);
247 nlmsvc_remove_block(block
);
251 static void nlmsvc_free_block(struct kref
*kref
)
253 struct nlm_block
*block
= container_of(kref
, struct nlm_block
, b_count
);
254 struct nlm_file
*file
= block
->b_file
;
255 struct nlm_block
**bp
;
257 dprintk("lockd: freeing block %p...\n", block
);
259 /* Remove block from file's list of blocks */
260 for (bp
= &file
->f_blocks
; *bp
; bp
= &(*bp
)->b_fnext
) {
262 *bp
= block
->b_fnext
;
268 nlm_release_host(block
->b_host
);
269 nlmsvc_freegrantargs(&block
->b_call
);
273 static void nlmsvc_release_block(struct nlm_block
*block
)
276 kref_put(&block
->b_count
, nlmsvc_free_block
);
280 * Loop over all blocks and perform the action specified.
281 * (NLM_ACT_CHECK handled by nlmsvc_inspect_file).
284 nlmsvc_traverse_blocks(struct nlm_host
*host
, struct nlm_file
*file
, int action
)
286 struct nlm_block
*block
, *next
;
287 /* XXX: Will everything get cleaned up if we don't unlock here? */
290 for (block
= file
->f_blocks
; block
; block
= next
) {
291 next
= block
->b_fnext
;
292 if (action
== NLM_ACT_MARK
)
293 block
->b_host
->h_inuse
= 1;
294 else if (action
== NLM_ACT_UNLOCK
) {
295 if (host
== NULL
|| host
== block
->b_host
)
296 nlmsvc_unlink_block(block
);
304 * Initialize arguments for GRANTED call. The nlm_rqst structure
305 * has been cleared already.
307 static int nlmsvc_setgrantargs(struct nlm_rqst
*call
, struct nlm_lock
*lock
)
309 locks_copy_lock(&call
->a_args
.lock
.fl
, &lock
->fl
);
310 memcpy(&call
->a_args
.lock
.fh
, &lock
->fh
, sizeof(call
->a_args
.lock
.fh
));
311 call
->a_args
.lock
.caller
= system_utsname
.nodename
;
312 call
->a_args
.lock
.oh
.len
= lock
->oh
.len
;
314 /* set default data area */
315 call
->a_args
.lock
.oh
.data
= call
->a_owner
;
316 call
->a_args
.lock
.svid
= lock
->fl
.fl_pid
;
318 if (lock
->oh
.len
> NLMCLNT_OHSIZE
) {
319 void *data
= kmalloc(lock
->oh
.len
, GFP_KERNEL
);
321 nlmsvc_freegrantargs(call
);
324 call
->a_args
.lock
.oh
.data
= (u8
*) data
;
327 memcpy(call
->a_args
.lock
.oh
.data
, lock
->oh
.data
, lock
->oh
.len
);
331 static void nlmsvc_freegrantargs(struct nlm_rqst
*call
)
333 struct file_lock
*fl
= &call
->a_args
.lock
.fl
;
335 * Check whether we allocated memory for the owner.
337 if (call
->a_args
.lock
.oh
.data
!= (u8
*) call
->a_owner
) {
338 kfree(call
->a_args
.lock
.oh
.data
);
340 if (fl
->fl_ops
&& fl
->fl_ops
->fl_release_private
)
341 fl
->fl_ops
->fl_release_private(fl
);
342 if (fl
->fl_lmops
&& fl
->fl_lmops
->fl_release_private
)
343 fl
->fl_lmops
->fl_release_private(fl
);
347 * Attempt to establish a lock, and if it can't be granted, block it
351 nlmsvc_lock(struct svc_rqst
*rqstp
, struct nlm_file
*file
,
352 struct nlm_lock
*lock
, int wait
, struct nlm_cookie
*cookie
)
354 struct nlm_block
*block
, *newblock
= NULL
;
358 dprintk("lockd: nlmsvc_lock(%s/%ld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
359 file
->f_file
->f_dentry
->d_inode
->i_sb
->s_id
,
360 file
->f_file
->f_dentry
->d_inode
->i_ino
,
361 lock
->fl
.fl_type
, lock
->fl
.fl_pid
,
362 (long long)lock
->fl
.fl_start
,
363 (long long)lock
->fl
.fl_end
,
367 lock
->fl
.fl_flags
&= ~FL_SLEEP
;
369 /* Lock file against concurrent access */
371 /* Get existing block (in case client is busy-waiting) */
372 block
= nlmsvc_lookup_block(file
, lock
, 0);
374 if (newblock
!= NULL
)
375 lock
= &newblock
->b_call
.a_args
.lock
;
377 lock
= &block
->b_call
.a_args
.lock
;
379 error
= posix_lock_file(file
->f_file
, &lock
->fl
);
380 lock
->fl
.fl_flags
&= ~FL_SLEEP
;
382 dprintk("lockd: posix_lock_file returned %d\n", error
);
393 default: /* includes ENOLCK */
394 ret
= nlm_lck_denied_nolocks
;
398 ret
= nlm_lck_denied
;
402 ret
= nlm_lck_blocked
;
406 /* If we don't have a block, create and initialize it. Then
407 * retry because we may have slept in kmalloc. */
408 /* We have to release f_sema as nlmsvc_create_block may try to
409 * to claim it while doing host garbage collection */
410 if (newblock
== NULL
) {
412 dprintk("lockd: blocking on this lock (allocating).\n");
413 if (!(newblock
= nlmsvc_create_block(rqstp
, file
, lock
, cookie
)))
414 return nlm_lck_denied_nolocks
;
418 /* Append to list of blocked */
419 nlmsvc_insert_block(newblock
, NLM_NEVER
);
422 nlmsvc_release_block(newblock
);
423 nlmsvc_release_block(block
);
424 dprintk("lockd: nlmsvc_lock returned %u\n", ret
);
429 * Test for presence of a conflicting lock.
432 nlmsvc_testlock(struct nlm_file
*file
, struct nlm_lock
*lock
,
433 struct nlm_lock
*conflock
)
435 dprintk("lockd: nlmsvc_testlock(%s/%ld, ty=%d, %Ld-%Ld)\n",
436 file
->f_file
->f_dentry
->d_inode
->i_sb
->s_id
,
437 file
->f_file
->f_dentry
->d_inode
->i_ino
,
439 (long long)lock
->fl
.fl_start
,
440 (long long)lock
->fl
.fl_end
);
442 if (posix_test_lock(file
->f_file
, &lock
->fl
, &conflock
->fl
)) {
443 dprintk("lockd: conflicting lock(ty=%d, %Ld-%Ld)\n",
444 conflock
->fl
.fl_type
,
445 (long long)conflock
->fl
.fl_start
,
446 (long long)conflock
->fl
.fl_end
);
447 conflock
->caller
= "somehost"; /* FIXME */
448 conflock
->oh
.len
= 0; /* don't return OH info */
449 conflock
->svid
= conflock
->fl
.fl_pid
;
450 return nlm_lck_denied
;
458 * This implies a CANCEL call: We send a GRANT_MSG, the client replies
459 * with a GRANT_RES call which gets lost, and calls UNLOCK immediately
460 * afterwards. In this case the block will still be there, and hence
464 nlmsvc_unlock(struct nlm_file
*file
, struct nlm_lock
*lock
)
468 dprintk("lockd: nlmsvc_unlock(%s/%ld, pi=%d, %Ld-%Ld)\n",
469 file
->f_file
->f_dentry
->d_inode
->i_sb
->s_id
,
470 file
->f_file
->f_dentry
->d_inode
->i_ino
,
472 (long long)lock
->fl
.fl_start
,
473 (long long)lock
->fl
.fl_end
);
475 /* First, cancel any lock that might be there */
476 nlmsvc_cancel_blocked(file
, lock
);
478 lock
->fl
.fl_type
= F_UNLCK
;
479 error
= posix_lock_file(file
->f_file
, &lock
->fl
);
481 return (error
< 0)? nlm_lck_denied_nolocks
: nlm_granted
;
485 * Cancel a previously blocked request.
487 * A cancel request always overrides any grant that may currently
489 * The calling procedure must check whether the file can be closed.
492 nlmsvc_cancel_blocked(struct nlm_file
*file
, struct nlm_lock
*lock
)
494 struct nlm_block
*block
;
497 dprintk("lockd: nlmsvc_cancel(%s/%ld, pi=%d, %Ld-%Ld)\n",
498 file
->f_file
->f_dentry
->d_inode
->i_sb
->s_id
,
499 file
->f_file
->f_dentry
->d_inode
->i_ino
,
501 (long long)lock
->fl
.fl_start
,
502 (long long)lock
->fl
.fl_end
);
505 if ((block
= nlmsvc_lookup_block(file
, lock
, 1)) != NULL
) {
506 status
= nlmsvc_unlink_block(block
);
507 nlmsvc_release_block(block
);
510 return status
? nlm_lck_denied
: nlm_granted
;
514 * Unblock a blocked lock request. This is a callback invoked from the
515 * VFS layer when a lock on which we blocked is removed.
517 * This function doesn't grant the blocked lock instantly, but rather moves
518 * the block to the head of nlm_blocked where it can be picked up by lockd.
521 nlmsvc_notify_blocked(struct file_lock
*fl
)
523 struct nlm_block
**bp
, *block
;
525 dprintk("lockd: VFS unblock notification for block %p\n", fl
);
526 for (bp
= &nlm_blocked
; (block
= *bp
) != 0; bp
= &block
->b_next
) {
527 if (nlm_compare_locks(&block
->b_call
.a_args
.lock
.fl
, fl
)) {
528 nlmsvc_insert_block(block
, 0);
529 svc_wake_up(block
->b_daemon
);
534 printk(KERN_WARNING
"lockd: notification for unknown block!\n");
537 static int nlmsvc_same_owner(struct file_lock
*fl1
, struct file_lock
*fl2
)
539 return fl1
->fl_owner
== fl2
->fl_owner
&& fl1
->fl_pid
== fl2
->fl_pid
;
542 struct lock_manager_operations nlmsvc_lock_operations
= {
543 .fl_compare_owner
= nlmsvc_same_owner
,
544 .fl_notify
= nlmsvc_notify_blocked
,
548 * Try to claim a lock that was previously blocked.
550 * Note that we use both the RPC_GRANTED_MSG call _and_ an async
551 * RPC thread when notifying the client. This seems like overkill...
553 * - we don't want to use a synchronous RPC thread, otherwise
554 * we might find ourselves hanging on a dead portmapper.
555 * - Some lockd implementations (e.g. HP) don't react to
556 * RPC_GRANTED calls; they seem to insist on RPC_GRANTED_MSG calls.
559 nlmsvc_grant_blocked(struct nlm_block
*block
)
561 struct nlm_file
*file
= block
->b_file
;
562 struct nlm_lock
*lock
= &block
->b_call
.a_args
.lock
;
565 dprintk("lockd: grant blocked lock %p\n", block
);
567 /* First thing is lock the file */
570 /* Unlink block request from list */
571 nlmsvc_unlink_block(block
);
573 /* If b_granted is true this means we've been here before.
574 * Just retry the grant callback, possibly refreshing the RPC
576 if (block
->b_granted
) {
577 nlm_rebind_host(block
->b_host
);
581 /* Try the lock operation again */
582 lock
->fl
.fl_flags
|= FL_SLEEP
;
583 error
= posix_lock_file(file
->f_file
, &lock
->fl
);
584 lock
->fl
.fl_flags
&= ~FL_SLEEP
;
590 dprintk("lockd: lock still blocked\n");
591 nlmsvc_insert_block(block
, NLM_NEVER
);
594 printk(KERN_WARNING
"lockd: unexpected error %d in %s!\n",
595 -error
, __FUNCTION__
);
596 nlmsvc_insert_block(block
, 10 * HZ
);
601 /* Lock was granted by VFS. */
602 dprintk("lockd: GRANTing blocked lock.\n");
603 block
->b_granted
= 1;
605 /* Schedule next grant callback in 30 seconds */
606 nlmsvc_insert_block(block
, 30 * HZ
);
608 /* Call the client */
609 kref_get(&block
->b_count
);
610 if (nlmsvc_async_call(&block
->b_call
, NLMPROC_GRANTED_MSG
,
611 &nlmsvc_grant_ops
) < 0)
612 nlmsvc_release_block(block
);
618 * This is the callback from the RPC layer when the NLM_GRANTED_MSG
619 * RPC call has succeeded or timed out.
620 * Like all RPC callbacks, it is invoked by the rpciod process, so it
621 * better not sleep. Therefore, we put the blocked lock on the nlm_blocked
622 * chain once more in order to have it removed by lockd itself (which can
623 * then sleep on the file semaphore without disrupting e.g. the nfs client).
625 static void nlmsvc_grant_callback(struct rpc_task
*task
, void *data
)
627 struct nlm_rqst
*call
= data
;
628 struct nlm_block
*block
= container_of(call
, struct nlm_block
, b_call
);
629 unsigned long timeout
;
631 dprintk("lockd: GRANT_MSG RPC callback\n");
633 /* Technically, we should down the file semaphore here. Since we
634 * move the block towards the head of the queue only, no harm
635 * can be done, though. */
636 if (task
->tk_status
< 0) {
637 /* RPC error: Re-insert for retransmission */
639 } else if (block
->b_done
) {
640 /* Block already removed, kill it for real */
643 /* Call was successful, now wait for client callback */
646 nlmsvc_insert_block(block
, timeout
);
647 svc_wake_up(block
->b_daemon
);
650 void nlmsvc_grant_release(void *data
)
652 nlmsvc_release_block(data
);
655 static const struct rpc_call_ops nlmsvc_grant_ops
= {
656 .rpc_call_done
= nlmsvc_grant_callback
,
657 .rpc_release
= nlmsvc_grant_release
,
661 * We received a GRANT_RES callback. Try to find the corresponding
665 nlmsvc_grant_reply(struct svc_rqst
*rqstp
, struct nlm_cookie
*cookie
, u32 status
)
667 struct nlm_block
*block
;
668 struct nlm_file
*file
;
670 dprintk("grant_reply: looking for cookie %x, host (%08x), s=%d \n",
671 *(unsigned int *)(cookie
->data
),
672 ntohl(rqstp
->rq_addr
.sin_addr
.s_addr
), status
);
673 if (!(block
= nlmsvc_find_block(cookie
, &rqstp
->rq_addr
)))
675 file
= block
->b_file
;
680 if (status
== NLM_LCK_DENIED_GRACE_PERIOD
) {
681 /* Try again in a couple of seconds */
682 nlmsvc_insert_block(block
, 10 * HZ
);
684 /* Lock is now held by client, or has been rejected.
685 * In both cases, the block should be removed. */
686 nlmsvc_unlink_block(block
);
690 nlm_release_file(file
);
691 nlmsvc_release_block(block
);
695 * Retry all blocked locks that have been notified. This is where lockd
696 * picks up locks that can be granted, or grant notifications that must
700 nlmsvc_retry_blocked(void)
702 struct nlm_block
*block
;
704 dprintk("nlmsvc_retry_blocked(%p, when=%ld)\n",
706 nlm_blocked
? nlm_blocked
->b_when
: 0);
707 while ((block
= nlm_blocked
) != 0) {
708 if (block
->b_when
== NLM_NEVER
)
710 if (time_after(block
->b_when
,jiffies
))
712 dprintk("nlmsvc_retry_blocked(%p, when=%ld, done=%d)\n",
713 block
, block
->b_when
, block
->b_done
);
714 kref_get(&block
->b_count
);
716 nlmsvc_unlink_block(block
);
718 nlmsvc_grant_blocked(block
);
719 nlmsvc_release_block(block
);
722 if ((block
= nlm_blocked
) && block
->b_when
!= NLM_NEVER
)
723 return (block
->b_when
- jiffies
);
725 return MAX_SCHEDULE_TIMEOUT
;