2 * linux/fs/lockd/clntlock.c
4 * Lock handling for the client side NLM implementation
6 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
9 #include <linux/module.h>
10 #include <linux/types.h>
11 #include <linux/time.h>
12 #include <linux/nfs_fs.h>
13 #include <linux/sunrpc/clnt.h>
14 #include <linux/sunrpc/svc.h>
15 #include <linux/lockd/lockd.h>
16 #include <linux/smp_lock.h>
17 #include <linux/kthread.h>
19 #define NLMDBG_FACILITY NLMDBG_CLIENT
22 * Local function prototypes
24 static int reclaimer(void *ptr
);
27 * The following functions handle blocking and granting from the
32 * This is the representation of a blocked client lock.
35 struct list_head b_list
; /* linked list */
36 wait_queue_head_t b_wait
; /* where to wait on */
37 struct nlm_host
* b_host
;
38 struct file_lock
* b_lock
; /* local file lock */
39 unsigned short b_reclaim
; /* got to reclaim lock */
40 __be32 b_status
; /* grant callback status */
43 static LIST_HEAD(nlm_blocked
);
46 * nlmclnt_init - Set up per-NFS mount point lockd data structures
47 * @nlm_init: pointer to arguments structure
49 * Returns pointer to an appropriate nlm_host struct,
50 * or an ERR_PTR value.
52 struct nlm_host
*nlmclnt_init(const struct nlmclnt_initdata
*nlm_init
)
54 struct nlm_host
*host
;
55 u32 nlm_version
= (nlm_init
->nfs_version
== 2) ? 1 : 4;
60 return ERR_PTR(status
);
62 host
= nlmclnt_lookup_host(nlm_init
->address
, nlm_init
->addrlen
,
63 nlm_init
->protocol
, nlm_version
,
64 nlm_init
->hostname
, nlm_init
->noresvport
);
67 return ERR_PTR(-ENOLCK
);
72 EXPORT_SYMBOL_GPL(nlmclnt_init
);
75 * nlmclnt_done - Release resources allocated by nlmclnt_init()
76 * @host: nlm_host structure reserved by nlmclnt_init()
79 void nlmclnt_done(struct nlm_host
*host
)
81 nlm_release_host(host
);
84 EXPORT_SYMBOL_GPL(nlmclnt_done
);
87 * Queue up a lock for blocking so that the GRANTED request can see it
89 struct nlm_wait
*nlmclnt_prepare_block(struct nlm_host
*host
, struct file_lock
*fl
)
91 struct nlm_wait
*block
;
93 block
= kmalloc(sizeof(*block
), GFP_KERNEL
);
97 init_waitqueue_head(&block
->b_wait
);
98 block
->b_status
= nlm_lck_blocked
;
99 list_add(&block
->b_list
, &nlm_blocked
);
104 void nlmclnt_finish_block(struct nlm_wait
*block
)
108 list_del(&block
->b_list
);
115 int nlmclnt_block(struct nlm_wait
*block
, struct nlm_rqst
*req
, long timeout
)
119 /* A borken server might ask us to block even if we didn't
120 * request it. Just say no!
125 /* Go to sleep waiting for GRANT callback. Some servers seem
126 * to lose callbacks, however, so we're going to poll from
127 * time to time just to make sure.
129 * For now, the retry frequency is pretty high; normally
130 * a 1 minute timeout would do. See the comment before
131 * nlmclnt_lock for an explanation.
133 ret
= wait_event_interruptible_timeout(block
->b_wait
,
134 block
->b_status
!= nlm_lck_blocked
,
138 req
->a_res
.status
= block
->b_status
;
142 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
143 static const struct in6_addr
*nlmclnt_map_v4addr(const struct sockaddr
*sap
,
144 struct in6_addr
*addr_mapped
)
146 const struct sockaddr_in
*sin
= (const struct sockaddr_in
*)sap
;
148 switch (sap
->sa_family
) {
150 return &((const struct sockaddr_in6
*)sap
)->sin6_addr
;
152 ipv6_addr_set_v4mapped(sin
->sin_addr
.s_addr
, addr_mapped
);
160 * If lockd is using a PF_INET6 listener, all incoming requests appear
161 * to come from AF_INET6 remotes. The address of AF_INET remotes are
162 * mapped to AF_INET6 automatically by the network layer. In case the
163 * user passed an AF_INET server address at mount time, ensure both
164 * addresses are AF_INET6 before comparing them.
166 static int nlmclnt_cmp_addr(const struct nlm_host
*host
,
167 const struct sockaddr
*sap
)
169 const struct in6_addr
*addr1
;
170 const struct in6_addr
*addr2
;
171 struct in6_addr addr1_mapped
;
172 struct in6_addr addr2_mapped
;
174 addr1
= nlmclnt_map_v4addr(nlm_addr(host
), &addr1_mapped
);
175 if (likely(addr1
!= NULL
)) {
176 addr2
= nlmclnt_map_v4addr(sap
, &addr2_mapped
);
177 if (likely(addr2
!= NULL
))
178 return ipv6_addr_equal(addr1
, addr2
);
183 #else /* !(CONFIG_IPV6 || CONFIG_IPV6_MODULE) */
184 static int nlmclnt_cmp_addr(const struct nlm_host
*host
,
185 const struct sockaddr
*sap
)
187 return nlm_cmp_addr(nlm_addr(host
), sap
);
189 #endif /* !(CONFIG_IPV6 || CONFIG_IPV6_MODULE) */
192 * The server lockd has called us back to tell us the lock was granted
194 __be32
nlmclnt_grant(const struct sockaddr
*addr
, const struct nlm_lock
*lock
)
196 const struct file_lock
*fl
= &lock
->fl
;
197 const struct nfs_fh
*fh
= &lock
->fh
;
198 struct nlm_wait
*block
;
199 __be32 res
= nlm_lck_denied
;
202 * Look up blocked request based on arguments.
203 * Warning: must not use cookie to match it!
205 list_for_each_entry(block
, &nlm_blocked
, b_list
) {
206 struct file_lock
*fl_blocked
= block
->b_lock
;
208 if (fl_blocked
->fl_start
!= fl
->fl_start
)
210 if (fl_blocked
->fl_end
!= fl
->fl_end
)
213 * Careful! The NLM server will return the 32-bit "pid" that
214 * we put on the wire: in this case the lockowner "pid".
216 if (fl_blocked
->fl_u
.nfs_fl
.owner
->pid
!= lock
->svid
)
218 if (!nlmclnt_cmp_addr(block
->b_host
, addr
))
220 if (nfs_compare_fh(NFS_FH(fl_blocked
->fl_file
->f_path
.dentry
->d_inode
) ,fh
) != 0)
222 /* Alright, we found a lock. Set the return status
223 * and wake up the caller
225 block
->b_status
= nlm_granted
;
226 wake_up(&block
->b_wait
);
233 * The following procedures deal with the recovery of locks after a
238 * Reclaim all locks on server host. We do this by spawning a separate
242 nlmclnt_recovery(struct nlm_host
*host
)
244 struct task_struct
*task
;
246 if (!host
->h_reclaiming
++) {
248 task
= kthread_run(reclaimer
, host
, "%s-reclaim", host
->h_name
);
250 printk(KERN_ERR
"lockd: unable to spawn reclaimer "
251 "thread. Locks for %s won't be reclaimed! "
252 "(%ld)\n", host
->h_name
, PTR_ERR(task
));
259 struct nlm_host
*host
= (struct nlm_host
*) ptr
;
260 struct nlm_wait
*block
;
261 struct file_lock
*fl
, *next
;
264 allow_signal(SIGKILL
);
266 down_write(&host
->h_rwsem
);
268 /* This one ensures that our parent doesn't terminate while the
269 * reclaim is in progress */
271 lockd_up(); /* note: this cannot fail as lockd is already running */
273 dprintk("lockd: reclaiming locks for host %s\n", host
->h_name
);
276 nsmstate
= host
->h_nsmstate
;
278 /* Force a portmap getport - the peer's lockd will
279 * most likely end up on a different port.
281 host
->h_nextrebind
= jiffies
;
282 nlm_rebind_host(host
);
284 /* First, reclaim all locks that have been granted. */
285 list_splice_init(&host
->h_granted
, &host
->h_reclaim
);
286 list_for_each_entry_safe(fl
, next
, &host
->h_reclaim
, fl_u
.nfs_fl
.list
) {
287 list_del_init(&fl
->fl_u
.nfs_fl
.list
);
290 * sending this thread a SIGKILL will result in any unreclaimed
291 * locks being removed from the h_granted list. This means that
292 * the kernel will not attempt to reclaim them again if a new
293 * reclaimer thread is spawned for this host.
297 if (nlmclnt_reclaim(host
, fl
) != 0)
299 list_add_tail(&fl
->fl_u
.nfs_fl
.list
, &host
->h_granted
);
300 if (host
->h_nsmstate
!= nsmstate
) {
301 /* Argh! The server rebooted again! */
306 host
->h_reclaiming
= 0;
307 up_write(&host
->h_rwsem
);
308 dprintk("NLM: done reclaiming locks for host %s\n", host
->h_name
);
310 /* Now, wake up all processes that sleep on a blocked lock */
311 list_for_each_entry(block
, &nlm_blocked
, b_list
) {
312 if (block
->b_host
== host
) {
313 block
->b_status
= nlm_lck_denied_grace_period
;
314 wake_up(&block
->b_wait
);
318 /* Release host handle after use */
319 nlm_release_host(host
);