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/addr.h>
17 #include <linux/sunrpc/svc.h>
18 #include <linux/lockd/lockd.h>
19 #include <linux/mutex.h>
21 #include <linux/sunrpc/svc_xprt.h>
27 #define NLMDBG_FACILITY NLMDBG_HOSTCACHE
28 #define NLM_HOST_NRHASH 32
29 #define NLM_HOST_REBIND (60 * HZ)
30 #define NLM_HOST_EXPIRE (300 * HZ)
31 #define NLM_HOST_COLLECT (120 * HZ)
33 static struct hlist_head nlm_server_hosts[NLM_HOST_NRHASH];
34 static struct hlist_head nlm_client_hosts[NLM_HOST_NRHASH];
36 #define for_each_host(host, pos, chain, table) \
37 for ((chain) = (table); \
38 (chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
39 hlist_for_each_entry((host), (pos), (chain), h_hash)
41 #define for_each_host_safe(host, pos, next, chain, table) \
42 for ((chain) = (table); \
43 (chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
44 hlist_for_each_entry_safe((host), (pos), (next), \
47 static unsigned long nrhosts;
48 static DEFINE_MUTEX(nlm_host_mutex);
50 static void nlm_gc_hosts(struct net *net);
52 struct nlm_lookup_host_info {
53 const int server; /* search for server|client */
54 const struct sockaddr *sap; /* address to search for */
55 const size_t salen; /* it's length */
56 const unsigned short protocol; /* transport to search for*/
57 const u32 version; /* NLM version to search for */
58 const char *hostname; /* remote's hostname */
59 const size_t hostname_len; /* it's length */
60 const int noresvport; /* use non-priv port */
61 struct net *net; /* network namespace to bind */
65 * Hash function must work well on big- and little-endian platforms
67 static unsigned int __nlm_hash32(const __be32 n)
69 unsigned int hash = (__force u32)n ^ ((__force u32)n >> 16);
70 return hash ^ (hash >> 8);
73 static unsigned int __nlm_hash_addr4(const struct sockaddr *sap)
75 const struct sockaddr_in *sin = (struct sockaddr_in *)sap;
76 return __nlm_hash32(sin->sin_addr.s_addr);
79 static unsigned int __nlm_hash_addr6(const struct sockaddr *sap)
81 const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
82 const struct in6_addr addr = sin6->sin6_addr;
83 return __nlm_hash32(addr.s6_addr32[0]) ^
84 __nlm_hash32(addr.s6_addr32[1]) ^
85 __nlm_hash32(addr.s6_addr32[2]) ^
86 __nlm_hash32(addr.s6_addr32[3]);
89 static unsigned int nlm_hash_address(const struct sockaddr *sap)
93 switch (sap->sa_family) {
95 hash = __nlm_hash_addr4(sap);
98 hash = __nlm_hash_addr6(sap);
103 return hash & (NLM_HOST_NRHASH - 1);
107 * Allocate and initialize an nlm_host. Common to both client and server.
109 static struct nlm_host *nlm_alloc_host(struct nlm_lookup_host_info *ni,
110 struct nsm_handle *nsm)
112 struct nlm_host *host = NULL;
113 unsigned long now = jiffies;
116 atomic_inc(&nsm->sm_count);
119 nsm = nsm_get_handle(ni->sap, ni->salen,
120 ni->hostname, ni->hostname_len);
121 if (unlikely(nsm == NULL)) {
122 dprintk("lockd: %s failed; no nsm handle\n",
128 host = kmalloc(sizeof(*host), GFP_KERNEL);
129 if (unlikely(host == NULL)) {
130 dprintk("lockd: %s failed; no memory\n", __func__);
135 memcpy(nlm_addr(host), ni->sap, ni->salen);
136 host->h_addrlen = ni->salen;
137 rpc_set_port(nlm_addr(host), 0);
138 host->h_srcaddrlen = 0;
140 host->h_rpcclnt = NULL;
141 host->h_name = nsm->sm_name;
142 host->h_version = ni->version;
143 host->h_proto = ni->protocol;
144 host->h_reclaiming = 0;
145 host->h_server = ni->server;
146 host->h_noresvport = ni->noresvport;
148 init_waitqueue_head(&host->h_gracewait);
149 init_rwsem(&host->h_rwsem);
151 host->h_nsmstate = 0;
152 host->h_pidcount = 0;
153 atomic_set(&host->h_count, 1);
154 mutex_init(&host->h_mutex);
155 host->h_nextrebind = now + NLM_HOST_REBIND;
156 host->h_expires = now + NLM_HOST_EXPIRE;
157 INIT_LIST_HEAD(&host->h_lockowners);
158 spin_lock_init(&host->h_lock);
159 INIT_LIST_HEAD(&host->h_granted);
160 INIT_LIST_HEAD(&host->h_reclaim);
161 host->h_nsmhandle = nsm;
162 host->h_addrbuf = nsm->sm_addrbuf;
170 * Destroy an nlm_host and free associated resources
172 * Caller must hold nlm_host_mutex.
174 static void nlm_destroy_host_locked(struct nlm_host *host)
176 struct rpc_clnt *clnt;
177 struct lockd_net *ln = net_generic(host->net, lockd_net_id);
179 dprintk("lockd: destroy host %s\n", host->h_name);
181 hlist_del_init(&host->h_hash);
184 nsm_release(host->h_nsmhandle);
186 clnt = host->h_rpcclnt;
188 rpc_shutdown_client(clnt);
196 * nlmclnt_lookup_host - Find an NLM host handle matching a remote server
197 * @sap: network address of server
198 * @salen: length of server address
199 * @protocol: transport protocol to use
200 * @version: NLM protocol version
201 * @hostname: '\0'-terminated hostname of server
202 * @noresvport: 1 if non-privileged port should be used
204 * Returns an nlm_host structure that matches the passed-in
205 * [server address, transport protocol, NLM version, server hostname].
206 * If one doesn't already exist in the host cache, a new handle is
207 * created and returned.
209 struct nlm_host *nlmclnt_lookup_host(const struct sockaddr *sap,
211 const unsigned short protocol,
213 const char *hostname,
217 struct nlm_lookup_host_info ni = {
221 .protocol = protocol,
223 .hostname = hostname,
224 .hostname_len = strlen(hostname),
225 .noresvport = noresvport,
228 struct hlist_head *chain;
229 struct hlist_node *pos;
230 struct nlm_host *host;
231 struct nsm_handle *nsm = NULL;
232 struct lockd_net *ln = net_generic(net, lockd_net_id);
234 dprintk("lockd: %s(host='%s', vers=%u, proto=%s)\n", __func__,
235 (hostname ? hostname : "<none>"), version,
236 (protocol == IPPROTO_UDP ? "udp" : "tcp"));
238 mutex_lock(&nlm_host_mutex);
240 chain = &nlm_client_hosts[nlm_hash_address(sap)];
241 hlist_for_each_entry(host, pos, chain, h_hash) {
242 if (host->net != net)
244 if (!rpc_cmp_addr(nlm_addr(host), sap))
247 /* Same address. Share an NSM handle if we already have one */
249 nsm = host->h_nsmhandle;
251 if (host->h_proto != protocol)
253 if (host->h_version != version)
257 dprintk("lockd: %s found host %s (%s)\n", __func__,
258 host->h_name, host->h_addrbuf);
262 host = nlm_alloc_host(&ni, nsm);
263 if (unlikely(host == NULL))
266 hlist_add_head(&host->h_hash, chain);
270 dprintk("lockd: %s created host %s (%s)\n", __func__,
271 host->h_name, host->h_addrbuf);
274 mutex_unlock(&nlm_host_mutex);
279 * nlmclnt_release_host - release client nlm_host
280 * @host: nlm_host to release
283 void nlmclnt_release_host(struct nlm_host *host)
288 dprintk("lockd: release client host %s\n", host->h_name);
290 WARN_ON_ONCE(host->h_server);
292 if (atomic_dec_and_test(&host->h_count)) {
293 WARN_ON_ONCE(!list_empty(&host->h_lockowners));
294 WARN_ON_ONCE(!list_empty(&host->h_granted));
295 WARN_ON_ONCE(!list_empty(&host->h_reclaim));
297 mutex_lock(&nlm_host_mutex);
298 nlm_destroy_host_locked(host);
299 mutex_unlock(&nlm_host_mutex);
304 * nlmsvc_lookup_host - Find an NLM host handle matching a remote client
305 * @rqstp: incoming NLM request
306 * @hostname: name of client host
307 * @hostname_len: length of client hostname
309 * Returns an nlm_host structure that matches the [client address,
310 * transport protocol, NLM version, client hostname] of the passed-in
311 * NLM request. If one doesn't already exist in the host cache, a
312 * new handle is created and returned.
314 * Before possibly creating a new nlm_host, construct a sockaddr
315 * for a specific source address in case the local system has
316 * multiple network addresses. The family of the address in
317 * rq_daddr is guaranteed to be the same as the family of the
318 * address in rq_addr, so it's safe to use the same family for
319 * the source address.
321 struct nlm_host *nlmsvc_lookup_host(const struct svc_rqst *rqstp,
322 const char *hostname,
323 const size_t hostname_len)
325 struct hlist_head *chain;
326 struct hlist_node *pos;
327 struct nlm_host *host = NULL;
328 struct nsm_handle *nsm = NULL;
329 struct sockaddr *src_sap = svc_daddr(rqstp);
330 size_t src_len = rqstp->rq_daddrlen;
331 struct net *net = SVC_NET(rqstp);
332 struct nlm_lookup_host_info ni = {
334 .sap = svc_addr(rqstp),
335 .salen = rqstp->rq_addrlen,
336 .protocol = rqstp->rq_prot,
337 .version = rqstp->rq_vers,
338 .hostname = hostname,
339 .hostname_len = hostname_len,
342 struct lockd_net *ln = net_generic(net, lockd_net_id);
344 dprintk("lockd: %s(host='%*s', vers=%u, proto=%s)\n", __func__,
345 (int)hostname_len, hostname, rqstp->rq_vers,
346 (rqstp->rq_prot == IPPROTO_UDP ? "udp" : "tcp"));
348 mutex_lock(&nlm_host_mutex);
350 if (time_after_eq(jiffies, ln->next_gc))
353 chain = &nlm_server_hosts[nlm_hash_address(ni.sap)];
354 hlist_for_each_entry(host, pos, chain, h_hash) {
355 if (host->net != net)
357 if (!rpc_cmp_addr(nlm_addr(host), ni.sap))
360 /* Same address. Share an NSM handle if we already have one */
362 nsm = host->h_nsmhandle;
364 if (host->h_proto != ni.protocol)
366 if (host->h_version != ni.version)
368 if (!rpc_cmp_addr(nlm_srcaddr(host), src_sap))
371 /* Move to head of hash chain. */
372 hlist_del(&host->h_hash);
373 hlist_add_head(&host->h_hash, chain);
376 dprintk("lockd: %s found host %s (%s)\n",
377 __func__, host->h_name, host->h_addrbuf);
381 host = nlm_alloc_host(&ni, nsm);
382 if (unlikely(host == NULL))
385 memcpy(nlm_srcaddr(host), src_sap, src_len);
386 host->h_srcaddrlen = src_len;
387 hlist_add_head(&host->h_hash, chain);
391 dprintk("lockd: %s created host %s (%s)\n",
392 __func__, host->h_name, host->h_addrbuf);
395 mutex_unlock(&nlm_host_mutex);
400 * nlmsvc_release_host - release server nlm_host
401 * @host: nlm_host to release
403 * Host is destroyed later in nlm_gc_host().
405 void nlmsvc_release_host(struct nlm_host *host)
410 dprintk("lockd: release server host %s\n", host->h_name);
412 WARN_ON_ONCE(!host->h_server);
413 atomic_dec(&host->h_count);
417 * Create the NLM RPC client for an NLM peer
420 nlm_bind_host(struct nlm_host *host)
422 struct rpc_clnt *clnt;
424 dprintk("lockd: nlm_bind_host %s (%s)\n",
425 host->h_name, host->h_addrbuf);
427 /* Lock host handle */
428 mutex_lock(&host->h_mutex);
430 /* If we've already created an RPC client, check whether
431 * RPC rebind is required
433 if ((clnt = host->h_rpcclnt) != NULL) {
434 if (time_after_eq(jiffies, host->h_nextrebind)) {
435 rpc_force_rebind(clnt);
436 host->h_nextrebind = jiffies + NLM_HOST_REBIND;
437 dprintk("lockd: next rebind in %lu jiffies\n",
438 host->h_nextrebind - jiffies);
441 unsigned long increment = nlmsvc_timeout;
442 struct rpc_timeout timeparms = {
443 .to_initval = increment,
444 .to_increment = increment,
445 .to_maxval = increment * 6UL,
448 struct rpc_create_args args = {
450 .protocol = host->h_proto,
451 .address = nlm_addr(host),
452 .addrsize = host->h_addrlen,
453 .timeout = &timeparms,
454 .servername = host->h_name,
455 .program = &nlm_program,
456 .version = host->h_version,
457 .authflavor = RPC_AUTH_UNIX,
458 .flags = (RPC_CLNT_CREATE_NOPING |
459 RPC_CLNT_CREATE_AUTOBIND),
463 * lockd retries server side blocks automatically so we want
464 * those to be soft RPC calls. Client side calls need to be
468 args.flags |= RPC_CLNT_CREATE_HARDRTRY;
469 if (host->h_noresvport)
470 args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
471 if (host->h_srcaddrlen)
472 args.saddress = nlm_srcaddr(host);
474 clnt = rpc_create(&args);
476 host->h_rpcclnt = clnt;
478 printk("lockd: couldn't create RPC handle for %s\n", host->h_name);
483 mutex_unlock(&host->h_mutex);
488 * Force a portmap lookup of the remote lockd port
491 nlm_rebind_host(struct nlm_host *host)
493 dprintk("lockd: rebind host %s\n", host->h_name);
494 if (host->h_rpcclnt && time_after_eq(jiffies, host->h_nextrebind)) {
495 rpc_force_rebind(host->h_rpcclnt);
496 host->h_nextrebind = jiffies + NLM_HOST_REBIND;
501 * Increment NLM host count
503 struct nlm_host * nlm_get_host(struct nlm_host *host)
506 dprintk("lockd: get host %s\n", host->h_name);
507 atomic_inc(&host->h_count);
508 host->h_expires = jiffies + NLM_HOST_EXPIRE;
513 static struct nlm_host *next_host_state(struct hlist_head *cache,
514 struct nsm_handle *nsm,
515 const struct nlm_reboot *info)
517 struct nlm_host *host;
518 struct hlist_head *chain;
519 struct hlist_node *pos;
521 mutex_lock(&nlm_host_mutex);
522 for_each_host(host, pos, chain, cache) {
523 if (host->h_nsmhandle == nsm
524 && host->h_nsmstate != info->state) {
525 host->h_nsmstate = info->state;
529 mutex_unlock(&nlm_host_mutex);
534 mutex_unlock(&nlm_host_mutex);
539 * nlm_host_rebooted - Release all resources held by rebooted host
540 * @info: pointer to decoded results of NLM_SM_NOTIFY call
542 * We were notified that the specified host has rebooted. Release
543 * all resources held by that peer.
545 void nlm_host_rebooted(const struct nlm_reboot *info)
547 struct nsm_handle *nsm;
548 struct nlm_host *host;
550 nsm = nsm_reboot_lookup(info);
551 if (unlikely(nsm == NULL))
554 /* Mark all hosts tied to this NSM state as having rebooted.
555 * We run the loop repeatedly, because we drop the host table
557 * To avoid processing a host several times, we match the nsmstate.
559 while ((host = next_host_state(nlm_server_hosts, nsm, info)) != NULL) {
560 nlmsvc_free_host_resources(host);
561 nlmsvc_release_host(host);
563 while ((host = next_host_state(nlm_client_hosts, nsm, info)) != NULL) {
564 nlmclnt_recovery(host);
565 nlmclnt_release_host(host);
571 static void nlm_complain_hosts(struct net *net)
573 struct hlist_head *chain;
574 struct hlist_node *pos;
575 struct nlm_host *host;
578 struct lockd_net *ln = net_generic(net, lockd_net_id);
580 if (ln->nrhosts == 0)
582 printk(KERN_WARNING "lockd: couldn't shutdown host module for net %p!\n", net);
583 dprintk("lockd: %lu hosts left in net %p:\n", ln->nrhosts, net);
587 printk(KERN_WARNING "lockd: couldn't shutdown host module!\n");
588 dprintk("lockd: %lu hosts left:\n", nrhosts);
591 for_each_host(host, pos, chain, nlm_server_hosts) {
592 if (net && host->net != net)
594 dprintk(" %s (cnt %d use %d exp %ld net %p)\n",
595 host->h_name, atomic_read(&host->h_count),
596 host->h_inuse, host->h_expires, host->net);
601 nlm_shutdown_hosts_net(struct net *net)
603 struct hlist_head *chain;
604 struct hlist_node *pos;
605 struct nlm_host *host;
607 mutex_lock(&nlm_host_mutex);
609 /* First, make all hosts eligible for gc */
610 dprintk("lockd: nuking all hosts in net %p...\n", net);
611 for_each_host(host, pos, chain, nlm_server_hosts) {
612 if (net && host->net != net)
614 host->h_expires = jiffies - 1;
615 if (host->h_rpcclnt) {
616 rpc_shutdown_client(host->h_rpcclnt);
617 host->h_rpcclnt = NULL;
621 /* Then, perform a garbage collection pass */
623 mutex_unlock(&nlm_host_mutex);
625 nlm_complain_hosts(net);
629 * Shut down the hosts module.
630 * Note that this routine is called only at server shutdown time.
633 nlm_shutdown_hosts(void)
635 dprintk("lockd: shutting down host module\n");
636 nlm_shutdown_hosts_net(NULL);
640 * Garbage collect any unused NLM hosts.
641 * This GC combines reference counting for async operations with
642 * mark & sweep for resources held by remote clients.
645 nlm_gc_hosts(struct net *net)
647 struct hlist_head *chain;
648 struct hlist_node *pos, *next;
649 struct nlm_host *host;
651 dprintk("lockd: host garbage collection for net %p\n", net);
652 for_each_host(host, pos, chain, nlm_server_hosts) {
653 if (net && host->net != net)
658 /* Mark all hosts that hold locks, blocks or shares */
659 nlmsvc_mark_resources(net);
661 for_each_host_safe(host, pos, next, chain, nlm_server_hosts) {
662 if (net && host->net != net)
664 if (atomic_read(&host->h_count) || host->h_inuse
665 || time_before(jiffies, host->h_expires)) {
666 dprintk("nlm_gc_hosts skipping %s "
667 "(cnt %d use %d exp %ld net %p)\n",
668 host->h_name, atomic_read(&host->h_count),
669 host->h_inuse, host->h_expires, host->net);
672 nlm_destroy_host_locked(host);
676 struct lockd_net *ln = net_generic(net, lockd_net_id);
678 ln->next_gc = jiffies + NLM_HOST_COLLECT;