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>
20 #include <linux/sunrpc/svc_xprt.h>
24 #define NLMDBG_FACILITY NLMDBG_HOSTCACHE
25 #define NLM_HOST_NRHASH 32
26 #define NLM_HOST_REBIND (60 * HZ)
27 #define NLM_HOST_EXPIRE (300 * HZ)
28 #define NLM_HOST_COLLECT (120 * HZ)
30 static struct hlist_head nlm_server_hosts
[NLM_HOST_NRHASH
];
31 static struct hlist_head nlm_client_hosts
[NLM_HOST_NRHASH
];
33 #define for_each_host(host, pos, chain, table) \
34 for ((chain) = (table); \
35 (chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
36 hlist_for_each_entry((host), (pos), (chain), h_hash)
38 #define for_each_host_safe(host, pos, next, chain, table) \
39 for ((chain) = (table); \
40 (chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
41 hlist_for_each_entry_safe((host), (pos), (next), \
44 static unsigned long next_gc
;
45 static unsigned long nrhosts
;
46 static DEFINE_MUTEX(nlm_host_mutex
);
48 static void nlm_gc_hosts(void);
50 struct nlm_lookup_host_info
{
51 const int server
; /* search for server|client */
52 const struct sockaddr
*sap
; /* address to search for */
53 const size_t salen
; /* it's length */
54 const unsigned short protocol
; /* transport to search for*/
55 const u32 version
; /* NLM version to search for */
56 const char *hostname
; /* remote's hostname */
57 const size_t hostname_len
; /* it's length */
58 const int noresvport
; /* use non-priv port */
59 struct net
*net
; /* network namespace to bind */
63 * Hash function must work well on big- and little-endian platforms
65 static unsigned int __nlm_hash32(const __be32 n
)
67 unsigned int hash
= (__force u32
)n
^ ((__force u32
)n
>> 16);
68 return hash
^ (hash
>> 8);
71 static unsigned int __nlm_hash_addr4(const struct sockaddr
*sap
)
73 const struct sockaddr_in
*sin
= (struct sockaddr_in
*)sap
;
74 return __nlm_hash32(sin
->sin_addr
.s_addr
);
77 static unsigned int __nlm_hash_addr6(const struct sockaddr
*sap
)
79 const struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)sap
;
80 const struct in6_addr addr
= sin6
->sin6_addr
;
81 return __nlm_hash32(addr
.s6_addr32
[0]) ^
82 __nlm_hash32(addr
.s6_addr32
[1]) ^
83 __nlm_hash32(addr
.s6_addr32
[2]) ^
84 __nlm_hash32(addr
.s6_addr32
[3]);
87 static unsigned int nlm_hash_address(const struct sockaddr
*sap
)
91 switch (sap
->sa_family
) {
93 hash
= __nlm_hash_addr4(sap
);
96 hash
= __nlm_hash_addr6(sap
);
101 return hash
& (NLM_HOST_NRHASH
- 1);
105 * Allocate and initialize an nlm_host. Common to both client and server.
107 static struct nlm_host
*nlm_alloc_host(struct nlm_lookup_host_info
*ni
,
108 struct nsm_handle
*nsm
)
110 struct nlm_host
*host
= NULL
;
111 unsigned long now
= jiffies
;
114 atomic_inc(&nsm
->sm_count
);
117 nsm
= nsm_get_handle(ni
->sap
, ni
->salen
,
118 ni
->hostname
, ni
->hostname_len
);
119 if (unlikely(nsm
== NULL
)) {
120 dprintk("lockd: %s failed; no nsm handle\n",
126 host
= kmalloc(sizeof(*host
), GFP_KERNEL
);
127 if (unlikely(host
== NULL
)) {
128 dprintk("lockd: %s failed; no memory\n", __func__
);
133 memcpy(nlm_addr(host
), ni
->sap
, ni
->salen
);
134 host
->h_addrlen
= ni
->salen
;
135 rpc_set_port(nlm_addr(host
), 0);
136 host
->h_srcaddrlen
= 0;
138 host
->h_rpcclnt
= NULL
;
139 host
->h_name
= nsm
->sm_name
;
140 host
->h_version
= ni
->version
;
141 host
->h_proto
= ni
->protocol
;
142 host
->h_reclaiming
= 0;
143 host
->h_server
= ni
->server
;
144 host
->h_noresvport
= ni
->noresvport
;
146 init_waitqueue_head(&host
->h_gracewait
);
147 init_rwsem(&host
->h_rwsem
);
149 host
->h_nsmstate
= 0;
150 host
->h_pidcount
= 0;
151 atomic_set(&host
->h_count
, 1);
152 mutex_init(&host
->h_mutex
);
153 host
->h_nextrebind
= now
+ NLM_HOST_REBIND
;
154 host
->h_expires
= now
+ NLM_HOST_EXPIRE
;
155 INIT_LIST_HEAD(&host
->h_lockowners
);
156 spin_lock_init(&host
->h_lock
);
157 INIT_LIST_HEAD(&host
->h_granted
);
158 INIT_LIST_HEAD(&host
->h_reclaim
);
159 host
->h_nsmhandle
= nsm
;
160 host
->h_addrbuf
= nsm
->sm_addrbuf
;
168 * Destroy an nlm_host and free associated resources
170 * Caller must hold nlm_host_mutex.
172 static void nlm_destroy_host_locked(struct nlm_host
*host
)
174 struct rpc_clnt
*clnt
;
176 dprintk("lockd: destroy host %s\n", host
->h_name
);
178 BUG_ON(!list_empty(&host
->h_lockowners
));
179 BUG_ON(atomic_read(&host
->h_count
));
181 hlist_del_init(&host
->h_hash
);
184 nsm_release(host
->h_nsmhandle
);
186 clnt
= host
->h_rpcclnt
;
188 rpc_shutdown_client(clnt
);
195 * nlmclnt_lookup_host - Find an NLM host handle matching a remote server
196 * @sap: network address of server
197 * @salen: length of server address
198 * @protocol: transport protocol to use
199 * @version: NLM protocol version
200 * @hostname: '\0'-terminated hostname of server
201 * @noresvport: 1 if non-privileged port should be used
203 * Returns an nlm_host structure that matches the passed-in
204 * [server address, transport protocol, NLM version, server hostname].
205 * If one doesn't already exist in the host cache, a new handle is
206 * created and returned.
208 struct nlm_host
*nlmclnt_lookup_host(const struct sockaddr
*sap
,
210 const unsigned short protocol
,
212 const char *hostname
,
216 struct nlm_lookup_host_info ni
= {
220 .protocol
= protocol
,
222 .hostname
= hostname
,
223 .hostname_len
= strlen(hostname
),
224 .noresvport
= noresvport
,
227 struct hlist_head
*chain
;
228 struct hlist_node
*pos
;
229 struct nlm_host
*host
;
230 struct nsm_handle
*nsm
= NULL
;
232 dprintk("lockd: %s(host='%s', vers=%u, proto=%s)\n", __func__
,
233 (hostname
? hostname
: "<none>"), version
,
234 (protocol
== IPPROTO_UDP
? "udp" : "tcp"));
236 mutex_lock(&nlm_host_mutex
);
238 chain
= &nlm_client_hosts
[nlm_hash_address(sap
)];
239 hlist_for_each_entry(host
, pos
, chain
, h_hash
) {
240 if (host
->net
!= net
)
242 if (!rpc_cmp_addr(nlm_addr(host
), sap
))
245 /* Same address. Share an NSM handle if we already have one */
247 nsm
= host
->h_nsmhandle
;
249 if (host
->h_proto
!= protocol
)
251 if (host
->h_version
!= version
)
255 dprintk("lockd: %s found host %s (%s)\n", __func__
,
256 host
->h_name
, host
->h_addrbuf
);
260 host
= nlm_alloc_host(&ni
, nsm
);
261 if (unlikely(host
== NULL
))
264 hlist_add_head(&host
->h_hash
, chain
);
267 dprintk("lockd: %s created host %s (%s)\n", __func__
,
268 host
->h_name
, host
->h_addrbuf
);
271 mutex_unlock(&nlm_host_mutex
);
276 * nlmclnt_release_host - release client nlm_host
277 * @host: nlm_host to release
280 void nlmclnt_release_host(struct nlm_host
*host
)
285 dprintk("lockd: release client host %s\n", host
->h_name
);
287 BUG_ON(atomic_read(&host
->h_count
) < 0);
288 BUG_ON(host
->h_server
);
290 if (atomic_dec_and_test(&host
->h_count
)) {
291 BUG_ON(!list_empty(&host
->h_lockowners
));
292 BUG_ON(!list_empty(&host
->h_granted
));
293 BUG_ON(!list_empty(&host
->h_reclaim
));
295 mutex_lock(&nlm_host_mutex
);
296 nlm_destroy_host_locked(host
);
297 mutex_unlock(&nlm_host_mutex
);
302 * nlmsvc_lookup_host - Find an NLM host handle matching a remote client
303 * @rqstp: incoming NLM request
304 * @hostname: name of client host
305 * @hostname_len: length of client hostname
307 * Returns an nlm_host structure that matches the [client address,
308 * transport protocol, NLM version, client hostname] of the passed-in
309 * NLM request. If one doesn't already exist in the host cache, a
310 * new handle is created and returned.
312 * Before possibly creating a new nlm_host, construct a sockaddr
313 * for a specific source address in case the local system has
314 * multiple network addresses. The family of the address in
315 * rq_daddr is guaranteed to be the same as the family of the
316 * address in rq_addr, so it's safe to use the same family for
317 * the source address.
319 struct nlm_host
*nlmsvc_lookup_host(const struct svc_rqst
*rqstp
,
320 const char *hostname
,
321 const size_t hostname_len
)
323 struct hlist_head
*chain
;
324 struct hlist_node
*pos
;
325 struct nlm_host
*host
= NULL
;
326 struct nsm_handle
*nsm
= NULL
;
327 struct sockaddr
*src_sap
= svc_daddr(rqstp
);
328 size_t src_len
= rqstp
->rq_daddrlen
;
329 struct net
*net
= rqstp
->rq_xprt
->xpt_net
;
330 struct nlm_lookup_host_info ni
= {
332 .sap
= svc_addr(rqstp
),
333 .salen
= rqstp
->rq_addrlen
,
334 .protocol
= rqstp
->rq_prot
,
335 .version
= rqstp
->rq_vers
,
336 .hostname
= hostname
,
337 .hostname_len
= hostname_len
,
341 dprintk("lockd: %s(host='%*s', vers=%u, proto=%s)\n", __func__
,
342 (int)hostname_len
, hostname
, rqstp
->rq_vers
,
343 (rqstp
->rq_prot
== IPPROTO_UDP
? "udp" : "tcp"));
345 mutex_lock(&nlm_host_mutex
);
347 if (time_after_eq(jiffies
, next_gc
))
350 chain
= &nlm_server_hosts
[nlm_hash_address(ni
.sap
)];
351 hlist_for_each_entry(host
, pos
, chain
, h_hash
) {
352 if (host
->net
!= net
)
354 if (!rpc_cmp_addr(nlm_addr(host
), ni
.sap
))
357 /* Same address. Share an NSM handle if we already have one */
359 nsm
= host
->h_nsmhandle
;
361 if (host
->h_proto
!= ni
.protocol
)
363 if (host
->h_version
!= ni
.version
)
365 if (!rpc_cmp_addr(nlm_srcaddr(host
), src_sap
))
368 /* Move to head of hash chain. */
369 hlist_del(&host
->h_hash
);
370 hlist_add_head(&host
->h_hash
, chain
);
373 dprintk("lockd: %s found host %s (%s)\n",
374 __func__
, host
->h_name
, host
->h_addrbuf
);
378 host
= nlm_alloc_host(&ni
, nsm
);
379 if (unlikely(host
== NULL
))
382 memcpy(nlm_srcaddr(host
), src_sap
, src_len
);
383 host
->h_srcaddrlen
= src_len
;
384 hlist_add_head(&host
->h_hash
, chain
);
387 dprintk("lockd: %s created host %s (%s)\n",
388 __func__
, host
->h_name
, host
->h_addrbuf
);
391 mutex_unlock(&nlm_host_mutex
);
396 * nlmsvc_release_host - release server nlm_host
397 * @host: nlm_host to release
399 * Host is destroyed later in nlm_gc_host().
401 void nlmsvc_release_host(struct nlm_host
*host
)
406 dprintk("lockd: release server host %s\n", host
->h_name
);
408 BUG_ON(atomic_read(&host
->h_count
) < 0);
409 BUG_ON(!host
->h_server
);
410 atomic_dec(&host
->h_count
);
414 * Create the NLM RPC client for an NLM peer
417 nlm_bind_host(struct nlm_host
*host
)
419 struct rpc_clnt
*clnt
;
421 dprintk("lockd: nlm_bind_host %s (%s)\n",
422 host
->h_name
, host
->h_addrbuf
);
424 /* Lock host handle */
425 mutex_lock(&host
->h_mutex
);
427 /* If we've already created an RPC client, check whether
428 * RPC rebind is required
430 if ((clnt
= host
->h_rpcclnt
) != NULL
) {
431 if (time_after_eq(jiffies
, host
->h_nextrebind
)) {
432 rpc_force_rebind(clnt
);
433 host
->h_nextrebind
= jiffies
+ NLM_HOST_REBIND
;
434 dprintk("lockd: next rebind in %lu jiffies\n",
435 host
->h_nextrebind
- jiffies
);
438 unsigned long increment
= nlmsvc_timeout
;
439 struct rpc_timeout timeparms
= {
440 .to_initval
= increment
,
441 .to_increment
= increment
,
442 .to_maxval
= increment
* 6UL,
445 struct rpc_create_args args
= {
447 .protocol
= host
->h_proto
,
448 .address
= nlm_addr(host
),
449 .addrsize
= host
->h_addrlen
,
450 .timeout
= &timeparms
,
451 .servername
= host
->h_name
,
452 .program
= &nlm_program
,
453 .version
= host
->h_version
,
454 .authflavor
= RPC_AUTH_UNIX
,
455 .flags
= (RPC_CLNT_CREATE_NOPING
|
456 RPC_CLNT_CREATE_AUTOBIND
),
460 * lockd retries server side blocks automatically so we want
461 * those to be soft RPC calls. Client side calls need to be
465 args
.flags
|= RPC_CLNT_CREATE_HARDRTRY
;
466 if (host
->h_noresvport
)
467 args
.flags
|= RPC_CLNT_CREATE_NONPRIVPORT
;
468 if (host
->h_srcaddrlen
)
469 args
.saddress
= nlm_srcaddr(host
);
471 clnt
= rpc_create(&args
);
473 host
->h_rpcclnt
= clnt
;
475 printk("lockd: couldn't create RPC handle for %s\n", host
->h_name
);
480 mutex_unlock(&host
->h_mutex
);
485 * Force a portmap lookup of the remote lockd port
488 nlm_rebind_host(struct nlm_host
*host
)
490 dprintk("lockd: rebind host %s\n", host
->h_name
);
491 if (host
->h_rpcclnt
&& time_after_eq(jiffies
, host
->h_nextrebind
)) {
492 rpc_force_rebind(host
->h_rpcclnt
);
493 host
->h_nextrebind
= jiffies
+ NLM_HOST_REBIND
;
498 * Increment NLM host count
500 struct nlm_host
* nlm_get_host(struct nlm_host
*host
)
503 dprintk("lockd: get host %s\n", host
->h_name
);
504 atomic_inc(&host
->h_count
);
505 host
->h_expires
= jiffies
+ NLM_HOST_EXPIRE
;
510 static struct nlm_host
*next_host_state(struct hlist_head
*cache
,
511 struct nsm_handle
*nsm
,
512 const struct nlm_reboot
*info
)
514 struct nlm_host
*host
;
515 struct hlist_head
*chain
;
516 struct hlist_node
*pos
;
518 mutex_lock(&nlm_host_mutex
);
519 for_each_host(host
, pos
, chain
, cache
) {
520 if (host
->h_nsmhandle
== nsm
521 && host
->h_nsmstate
!= info
->state
) {
522 host
->h_nsmstate
= info
->state
;
526 mutex_unlock(&nlm_host_mutex
);
531 mutex_unlock(&nlm_host_mutex
);
536 * nlm_host_rebooted - Release all resources held by rebooted host
537 * @info: pointer to decoded results of NLM_SM_NOTIFY call
539 * We were notified that the specified host has rebooted. Release
540 * all resources held by that peer.
542 void nlm_host_rebooted(const struct nlm_reboot
*info
)
544 struct nsm_handle
*nsm
;
545 struct nlm_host
*host
;
547 nsm
= nsm_reboot_lookup(info
);
548 if (unlikely(nsm
== NULL
))
551 /* Mark all hosts tied to this NSM state as having rebooted.
552 * We run the loop repeatedly, because we drop the host table
554 * To avoid processing a host several times, we match the nsmstate.
556 while ((host
= next_host_state(nlm_server_hosts
, nsm
, info
)) != NULL
) {
557 nlmsvc_free_host_resources(host
);
558 nlmsvc_release_host(host
);
560 while ((host
= next_host_state(nlm_client_hosts
, nsm
, info
)) != NULL
) {
561 nlmclnt_recovery(host
);
562 nlmclnt_release_host(host
);
569 nlm_shutdown_hosts_net(struct net
*net
)
571 struct hlist_head
*chain
;
572 struct hlist_node
*pos
;
573 struct nlm_host
*host
;
575 dprintk("lockd: shutting down host module\n");
576 mutex_lock(&nlm_host_mutex
);
578 /* First, make all hosts eligible for gc */
579 dprintk("lockd: nuking all hosts...\n");
580 for_each_host(host
, pos
, chain
, nlm_server_hosts
) {
581 if (net
&& host
->net
!= net
)
583 host
->h_expires
= jiffies
- 1;
584 if (host
->h_rpcclnt
) {
585 rpc_shutdown_client(host
->h_rpcclnt
);
586 host
->h_rpcclnt
= NULL
;
590 /* Then, perform a garbage collection pass */
592 mutex_unlock(&nlm_host_mutex
);
596 * Shut down the hosts module.
597 * Note that this routine is called only at server shutdown time.
600 nlm_shutdown_hosts(void)
602 struct hlist_head
*chain
;
603 struct hlist_node
*pos
;
604 struct nlm_host
*host
;
606 nlm_shutdown_hosts_net(NULL
);
608 /* complain if any hosts are left */
610 printk(KERN_WARNING
"lockd: couldn't shutdown host module!\n");
611 dprintk("lockd: %lu hosts left:\n", nrhosts
);
612 for_each_host(host
, pos
, chain
, nlm_server_hosts
) {
613 dprintk(" %s (cnt %d use %d exp %ld net %p)\n",
614 host
->h_name
, atomic_read(&host
->h_count
),
615 host
->h_inuse
, host
->h_expires
, host
->net
);
621 * Garbage collect any unused NLM hosts.
622 * This GC combines reference counting for async operations with
623 * mark & sweep for resources held by remote clients.
628 struct hlist_head
*chain
;
629 struct hlist_node
*pos
, *next
;
630 struct nlm_host
*host
;
632 dprintk("lockd: host garbage collection\n");
633 for_each_host(host
, pos
, chain
, nlm_server_hosts
)
636 /* Mark all hosts that hold locks, blocks or shares */
637 nlmsvc_mark_resources();
639 for_each_host_safe(host
, pos
, next
, chain
, nlm_server_hosts
) {
640 if (atomic_read(&host
->h_count
) || host
->h_inuse
641 || time_before(jiffies
, host
->h_expires
)) {
642 dprintk("nlm_gc_hosts skipping %s "
643 "(cnt %d use %d exp %ld)\n",
644 host
->h_name
, atomic_read(&host
->h_count
),
645 host
->h_inuse
, host
->h_expires
);
648 nlm_destroy_host_locked(host
);
651 next_gc
= jiffies
+ NLM_HOST_COLLECT
;