2 * linux/fs/lockd/host.c
4 * Management for NLM peer hosts. The nlm_host struct is shared
5 * between client and server implementation. The only reason to
6 * do so is to reduce code bloat.
8 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
11 #include <linux/types.h>
12 #include <linux/slab.h>
14 #include <linux/in6.h>
15 #include <linux/sunrpc/clnt.h>
16 #include <linux/sunrpc/svc.h>
17 #include <linux/lockd/lockd.h>
18 #include <linux/mutex.h>
22 #define NLMDBG_FACILITY NLMDBG_HOSTCACHE
23 #define NLM_HOST_NRHASH 32
24 #define NLM_HOST_REBIND (60 * HZ)
25 #define NLM_HOST_EXPIRE (300 * HZ)
26 #define NLM_HOST_COLLECT (120 * HZ)
28 static struct hlist_head nlm_hosts
[NLM_HOST_NRHASH
];
30 #define for_each_host(host, pos, chain, table) \
31 for ((chain) = (table); \
32 (chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
33 hlist_for_each_entry((host), (pos), (chain), h_hash)
35 #define for_each_host_safe(host, pos, next, chain, table) \
36 for ((chain) = (table); \
37 (chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
38 hlist_for_each_entry_safe((host), (pos), (next), \
41 static unsigned long next_gc
;
43 static DEFINE_MUTEX(nlm_host_mutex
);
45 static void nlm_gc_hosts(void);
47 struct nlm_lookup_host_info
{
48 const int server
; /* search for server|client */
49 const struct sockaddr
*sap
; /* address to search for */
50 const size_t salen
; /* it's length */
51 const unsigned short protocol
; /* transport to search for*/
52 const u32 version
; /* NLM version to search for */
53 const char *hostname
; /* remote's hostname */
54 const size_t hostname_len
; /* it's length */
55 const struct sockaddr
*src_sap
; /* our address (optional) */
56 const size_t src_len
; /* it's length */
57 const int noresvport
; /* use non-priv port */
61 * Hash function must work well on big- and little-endian platforms
63 static unsigned int __nlm_hash32(const __be32 n
)
65 unsigned int hash
= (__force u32
)n
^ ((__force u32
)n
>> 16);
66 return hash
^ (hash
>> 8);
69 static unsigned int __nlm_hash_addr4(const struct sockaddr
*sap
)
71 const struct sockaddr_in
*sin
= (struct sockaddr_in
*)sap
;
72 return __nlm_hash32(sin
->sin_addr
.s_addr
);
75 static unsigned int __nlm_hash_addr6(const struct sockaddr
*sap
)
77 const struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)sap
;
78 const struct in6_addr addr
= sin6
->sin6_addr
;
79 return __nlm_hash32(addr
.s6_addr32
[0]) ^
80 __nlm_hash32(addr
.s6_addr32
[1]) ^
81 __nlm_hash32(addr
.s6_addr32
[2]) ^
82 __nlm_hash32(addr
.s6_addr32
[3]);
85 static unsigned int nlm_hash_address(const struct sockaddr
*sap
)
89 switch (sap
->sa_family
) {
91 hash
= __nlm_hash_addr4(sap
);
94 hash
= __nlm_hash_addr6(sap
);
99 return hash
& (NLM_HOST_NRHASH
- 1);
103 * Common host lookup routine for server & client
105 static struct nlm_host
*nlm_lookup_host(struct nlm_lookup_host_info
*ni
)
107 struct hlist_head
*chain
;
108 struct hlist_node
*pos
;
109 struct nlm_host
*host
;
110 struct nsm_handle
*nsm
= NULL
;
112 mutex_lock(&nlm_host_mutex
);
114 if (time_after_eq(jiffies
, next_gc
))
117 /* We may keep several nlm_host objects for a peer, because each
118 * nlm_host is identified by
119 * (address, protocol, version, server/client)
120 * We could probably simplify this a little by putting all those
121 * different NLM rpc_clients into one single nlm_host object.
122 * This would allow us to have one nlm_host per address.
124 chain
= &nlm_hosts
[nlm_hash_address(ni
->sap
)];
125 hlist_for_each_entry(host
, pos
, chain
, h_hash
) {
126 if (!rpc_cmp_addr(nlm_addr(host
), ni
->sap
))
129 /* See if we have an NSM handle for this client */
131 nsm
= host
->h_nsmhandle
;
133 if (host
->h_proto
!= ni
->protocol
)
135 if (host
->h_version
!= ni
->version
)
137 if (host
->h_server
!= ni
->server
)
139 if (ni
->server
&& ni
->src_len
!= 0 &&
140 !rpc_cmp_addr(nlm_srcaddr(host
), ni
->src_sap
))
143 /* Move to head of hash chain. */
144 hlist_del(&host
->h_hash
);
145 hlist_add_head(&host
->h_hash
, chain
);
148 dprintk("lockd: nlm_lookup_host found host %s (%s)\n",
149 host
->h_name
, host
->h_addrbuf
);
154 * The host wasn't in our hash table. If we don't
155 * have an NSM handle for it yet, create one.
158 atomic_inc(&nsm
->sm_count
);
161 nsm
= nsm_get_handle(ni
->sap
, ni
->salen
,
162 ni
->hostname
, ni
->hostname_len
);
164 dprintk("lockd: nlm_lookup_host failed; "
170 host
= kzalloc(sizeof(*host
), GFP_KERNEL
);
173 dprintk("lockd: nlm_lookup_host failed; no memory\n");
176 host
->h_name
= nsm
->sm_name
;
177 host
->h_addrbuf
= nsm
->sm_addrbuf
;
178 memcpy(nlm_addr(host
), ni
->sap
, ni
->salen
);
179 host
->h_addrlen
= ni
->salen
;
180 rpc_set_port(nlm_addr(host
), 0);
181 memcpy(nlm_srcaddr(host
), ni
->src_sap
, ni
->src_len
);
182 host
->h_srcaddrlen
= ni
->src_len
;
183 host
->h_version
= ni
->version
;
184 host
->h_proto
= ni
->protocol
;
185 host
->h_rpcclnt
= NULL
;
186 mutex_init(&host
->h_mutex
);
187 host
->h_nextrebind
= jiffies
+ NLM_HOST_REBIND
;
188 host
->h_expires
= jiffies
+ NLM_HOST_EXPIRE
;
189 atomic_set(&host
->h_count
, 1);
190 init_waitqueue_head(&host
->h_gracewait
);
191 init_rwsem(&host
->h_rwsem
);
192 host
->h_state
= 0; /* pseudo NSM state */
193 host
->h_nsmstate
= 0; /* real NSM state */
194 host
->h_nsmhandle
= nsm
;
195 host
->h_server
= ni
->server
;
196 host
->h_noresvport
= ni
->noresvport
;
197 hlist_add_head(&host
->h_hash
, chain
);
198 INIT_LIST_HEAD(&host
->h_lockowners
);
199 spin_lock_init(&host
->h_lock
);
200 INIT_LIST_HEAD(&host
->h_granted
);
201 INIT_LIST_HEAD(&host
->h_reclaim
);
205 dprintk("lockd: nlm_lookup_host created host %s\n",
209 mutex_unlock(&nlm_host_mutex
);
217 nlm_destroy_host(struct nlm_host
*host
)
219 struct rpc_clnt
*clnt
;
221 BUG_ON(!list_empty(&host
->h_lockowners
));
222 BUG_ON(atomic_read(&host
->h_count
));
225 nsm_release(host
->h_nsmhandle
);
227 clnt
= host
->h_rpcclnt
;
229 rpc_shutdown_client(clnt
);
234 * nlmclnt_lookup_host - Find an NLM host handle matching a remote server
235 * @sap: network address of server
236 * @salen: length of server address
237 * @protocol: transport protocol to use
238 * @version: NLM protocol version
239 * @hostname: '\0'-terminated hostname of server
240 * @noresvport: 1 if non-privileged port should be used
242 * Returns an nlm_host structure that matches the passed-in
243 * [server address, transport protocol, NLM version, server hostname].
244 * If one doesn't already exist in the host cache, a new handle is
245 * created and returned.
247 struct nlm_host
*nlmclnt_lookup_host(const struct sockaddr
*sap
,
249 const unsigned short protocol
,
251 const char *hostname
,
254 struct nlm_lookup_host_info ni
= {
258 .protocol
= protocol
,
260 .hostname
= hostname
,
261 .hostname_len
= strlen(hostname
),
262 .noresvport
= noresvport
,
265 dprintk("lockd: %s(host='%s', vers=%u, proto=%s)\n", __func__
,
266 (hostname
? hostname
: "<none>"), version
,
267 (protocol
== IPPROTO_UDP
? "udp" : "tcp"));
269 return nlm_lookup_host(&ni
);
273 * nlmsvc_lookup_host - Find an NLM host handle matching a remote client
274 * @rqstp: incoming NLM request
275 * @hostname: name of client host
276 * @hostname_len: length of client hostname
278 * Returns an nlm_host structure that matches the [client address,
279 * transport protocol, NLM version, client hostname] of the passed-in
280 * NLM request. If one doesn't already exist in the host cache, a
281 * new handle is created and returned.
283 * Before possibly creating a new nlm_host, construct a sockaddr
284 * for a specific source address in case the local system has
285 * multiple network addresses. The family of the address in
286 * rq_daddr is guaranteed to be the same as the family of the
287 * address in rq_addr, so it's safe to use the same family for
288 * the source address.
290 struct nlm_host
*nlmsvc_lookup_host(const struct svc_rqst
*rqstp
,
291 const char *hostname
,
292 const size_t hostname_len
)
294 struct sockaddr_in sin
= {
295 .sin_family
= AF_INET
,
297 struct sockaddr_in6 sin6
= {
298 .sin6_family
= AF_INET6
,
300 struct nlm_lookup_host_info ni
= {
302 .sap
= svc_addr(rqstp
),
303 .salen
= rqstp
->rq_addrlen
,
304 .protocol
= rqstp
->rq_prot
,
305 .version
= rqstp
->rq_vers
,
306 .hostname
= hostname
,
307 .hostname_len
= hostname_len
,
308 .src_len
= rqstp
->rq_addrlen
,
311 dprintk("lockd: %s(host='%*s', vers=%u, proto=%s)\n", __func__
,
312 (int)hostname_len
, hostname
, rqstp
->rq_vers
,
313 (rqstp
->rq_prot
== IPPROTO_UDP
? "udp" : "tcp"));
315 switch (ni
.sap
->sa_family
) {
317 sin
.sin_addr
.s_addr
= rqstp
->rq_daddr
.addr
.s_addr
;
318 ni
.src_sap
= (struct sockaddr
*)&sin
;
321 ipv6_addr_copy(&sin6
.sin6_addr
, &rqstp
->rq_daddr
.addr6
);
322 ni
.src_sap
= (struct sockaddr
*)&sin6
;
328 return nlm_lookup_host(&ni
);
332 * Create the NLM RPC client for an NLM peer
335 nlm_bind_host(struct nlm_host
*host
)
337 struct rpc_clnt
*clnt
;
339 dprintk("lockd: nlm_bind_host %s (%s)\n",
340 host
->h_name
, host
->h_addrbuf
);
342 /* Lock host handle */
343 mutex_lock(&host
->h_mutex
);
345 /* If we've already created an RPC client, check whether
346 * RPC rebind is required
348 if ((clnt
= host
->h_rpcclnt
) != NULL
) {
349 if (time_after_eq(jiffies
, host
->h_nextrebind
)) {
350 rpc_force_rebind(clnt
);
351 host
->h_nextrebind
= jiffies
+ NLM_HOST_REBIND
;
352 dprintk("lockd: next rebind in %lu jiffies\n",
353 host
->h_nextrebind
- jiffies
);
356 unsigned long increment
= nlmsvc_timeout
;
357 struct rpc_timeout timeparms
= {
358 .to_initval
= increment
,
359 .to_increment
= increment
,
360 .to_maxval
= increment
* 6UL,
363 struct rpc_create_args args
= {
365 .protocol
= host
->h_proto
,
366 .address
= nlm_addr(host
),
367 .addrsize
= host
->h_addrlen
,
368 .timeout
= &timeparms
,
369 .servername
= host
->h_name
,
370 .program
= &nlm_program
,
371 .version
= host
->h_version
,
372 .authflavor
= RPC_AUTH_UNIX
,
373 .flags
= (RPC_CLNT_CREATE_NOPING
|
374 RPC_CLNT_CREATE_AUTOBIND
),
378 * lockd retries server side blocks automatically so we want
379 * those to be soft RPC calls. Client side calls need to be
383 args
.flags
|= RPC_CLNT_CREATE_HARDRTRY
;
384 if (host
->h_noresvport
)
385 args
.flags
|= RPC_CLNT_CREATE_NONPRIVPORT
;
386 if (host
->h_srcaddrlen
)
387 args
.saddress
= nlm_srcaddr(host
);
389 clnt
= rpc_create(&args
);
391 host
->h_rpcclnt
= clnt
;
393 printk("lockd: couldn't create RPC handle for %s\n", host
->h_name
);
398 mutex_unlock(&host
->h_mutex
);
403 * Force a portmap lookup of the remote lockd port
406 nlm_rebind_host(struct nlm_host
*host
)
408 dprintk("lockd: rebind host %s\n", host
->h_name
);
409 if (host
->h_rpcclnt
&& time_after_eq(jiffies
, host
->h_nextrebind
)) {
410 rpc_force_rebind(host
->h_rpcclnt
);
411 host
->h_nextrebind
= jiffies
+ NLM_HOST_REBIND
;
416 * Increment NLM host count
418 struct nlm_host
* nlm_get_host(struct nlm_host
*host
)
421 dprintk("lockd: get host %s\n", host
->h_name
);
422 atomic_inc(&host
->h_count
);
423 host
->h_expires
= jiffies
+ NLM_HOST_EXPIRE
;
429 * Release NLM host after use
431 void nlm_release_host(struct nlm_host
*host
)
434 dprintk("lockd: release host %s\n", host
->h_name
);
435 BUG_ON(atomic_read(&host
->h_count
) < 0);
436 if (atomic_dec_and_test(&host
->h_count
)) {
437 BUG_ON(!list_empty(&host
->h_lockowners
));
438 BUG_ON(!list_empty(&host
->h_granted
));
439 BUG_ON(!list_empty(&host
->h_reclaim
));
445 * nlm_host_rebooted - Release all resources held by rebooted host
446 * @info: pointer to decoded results of NLM_SM_NOTIFY call
448 * We were notified that the specified host has rebooted. Release
449 * all resources held by that peer.
451 void nlm_host_rebooted(const struct nlm_reboot
*info
)
453 struct hlist_head
*chain
;
454 struct hlist_node
*pos
;
455 struct nsm_handle
*nsm
;
456 struct nlm_host
*host
;
458 nsm
= nsm_reboot_lookup(info
);
459 if (unlikely(nsm
== NULL
))
462 /* Mark all hosts tied to this NSM state as having rebooted.
463 * We run the loop repeatedly, because we drop the host table
465 * To avoid processing a host several times, we match the nsmstate.
467 again
: mutex_lock(&nlm_host_mutex
);
468 for_each_host(host
, pos
, chain
, nlm_hosts
) {
469 if (host
->h_nsmhandle
== nsm
470 && host
->h_nsmstate
!= info
->state
) {
471 host
->h_nsmstate
= info
->state
;
475 mutex_unlock(&nlm_host_mutex
);
477 if (host
->h_server
) {
478 /* We're server for this guy, just ditch
479 * all the locks he held. */
480 nlmsvc_free_host_resources(host
);
482 /* He's the server, initiate lock recovery. */
483 nlmclnt_recovery(host
);
486 nlm_release_host(host
);
490 mutex_unlock(&nlm_host_mutex
);
495 * Shut down the hosts module.
496 * Note that this routine is called only at server shutdown time.
499 nlm_shutdown_hosts(void)
501 struct hlist_head
*chain
;
502 struct hlist_node
*pos
;
503 struct nlm_host
*host
;
505 dprintk("lockd: shutting down host module\n");
506 mutex_lock(&nlm_host_mutex
);
508 /* First, make all hosts eligible for gc */
509 dprintk("lockd: nuking all hosts...\n");
510 for_each_host(host
, pos
, chain
, nlm_hosts
) {
511 host
->h_expires
= jiffies
- 1;
512 if (host
->h_rpcclnt
) {
513 rpc_shutdown_client(host
->h_rpcclnt
);
514 host
->h_rpcclnt
= NULL
;
518 /* Then, perform a garbage collection pass */
520 mutex_unlock(&nlm_host_mutex
);
522 /* complain if any hosts are left */
524 printk(KERN_WARNING
"lockd: couldn't shutdown host module!\n");
525 dprintk("lockd: %d hosts left:\n", nrhosts
);
526 for_each_host(host
, pos
, chain
, nlm_hosts
) {
527 dprintk(" %s (cnt %d use %d exp %ld)\n",
528 host
->h_name
, atomic_read(&host
->h_count
),
529 host
->h_inuse
, host
->h_expires
);
535 * Garbage collect any unused NLM hosts.
536 * This GC combines reference counting for async operations with
537 * mark & sweep for resources held by remote clients.
542 struct hlist_head
*chain
;
543 struct hlist_node
*pos
, *next
;
544 struct nlm_host
*host
;
546 dprintk("lockd: host garbage collection\n");
547 for_each_host(host
, pos
, chain
, nlm_hosts
)
550 /* Mark all hosts that hold locks, blocks or shares */
551 nlmsvc_mark_resources();
553 for_each_host_safe(host
, pos
, next
, chain
, nlm_hosts
) {
554 if (atomic_read(&host
->h_count
) || host
->h_inuse
555 || time_before(jiffies
, host
->h_expires
)) {
556 dprintk("nlm_gc_hosts skipping %s "
557 "(cnt %d use %d exp %ld)\n",
558 host
->h_name
, atomic_read(&host
->h_count
),
559 host
->h_inuse
, host
->h_expires
);
562 dprintk("lockd: delete host %s\n", host
->h_name
);
563 hlist_del_init(&host
->h_hash
);
565 nlm_destroy_host(host
);
569 next_gc
= jiffies
+ NLM_HOST_COLLECT
;