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/lockd/sm_inter.h>
19 #include <linux/mutex.h>
23 #define NLMDBG_FACILITY NLMDBG_HOSTCACHE
24 #define NLM_HOST_NRHASH 32
25 #define NLM_HOST_REBIND (60 * HZ)
26 #define NLM_HOST_EXPIRE (300 * HZ)
27 #define NLM_HOST_COLLECT (120 * HZ)
29 static struct hlist_head nlm_hosts[NLM_HOST_NRHASH];
30 static unsigned long next_gc;
32 static DEFINE_MUTEX(nlm_host_mutex);
34 static void nlm_gc_hosts(void);
35 static struct nsm_handle *nsm_find(const struct sockaddr *sap,
38 const size_t hostname_len,
40 static void nsm_release(struct nsm_handle *nsm);
42 struct nlm_lookup_host_info {
43 const int server; /* search for server|client */
44 const struct sockaddr *sap; /* address to search for */
45 const size_t salen; /* it's length */
46 const unsigned short protocol; /* transport to search for*/
47 const u32 version; /* NLM version to search for */
48 const char *hostname; /* remote's hostname */
49 const size_t hostname_len; /* it's length */
50 const struct sockaddr *src_sap; /* our address (optional) */
51 const size_t src_len; /* it's length */
52 const int noresvport; /* use non-priv port */
56 * Hash function must work well on big- and little-endian platforms
58 static unsigned int __nlm_hash32(const __be32 n)
60 unsigned int hash = (__force u32)n ^ ((__force u32)n >> 16);
61 return hash ^ (hash >> 8);
64 static unsigned int __nlm_hash_addr4(const struct sockaddr *sap)
66 const struct sockaddr_in *sin = (struct sockaddr_in *)sap;
67 return __nlm_hash32(sin->sin_addr.s_addr);
70 static unsigned int __nlm_hash_addr6(const struct sockaddr *sap)
72 const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
73 const struct in6_addr addr = sin6->sin6_addr;
74 return __nlm_hash32(addr.s6_addr32[0]) ^
75 __nlm_hash32(addr.s6_addr32[1]) ^
76 __nlm_hash32(addr.s6_addr32[2]) ^
77 __nlm_hash32(addr.s6_addr32[3]);
80 static unsigned int nlm_hash_address(const struct sockaddr *sap)
84 switch (sap->sa_family) {
86 hash = __nlm_hash_addr4(sap);
89 hash = __nlm_hash_addr6(sap);
94 return hash & (NLM_HOST_NRHASH - 1);
97 static void nlm_clear_port(struct sockaddr *sap)
99 switch (sap->sa_family) {
101 ((struct sockaddr_in *)sap)->sin_port = 0;
104 ((struct sockaddr_in6 *)sap)->sin6_port = 0;
109 static void nlm_display_ipv4_address(const struct sockaddr *sap, char *buf,
112 const struct sockaddr_in *sin = (struct sockaddr_in *)sap;
113 snprintf(buf, len, "%pI4", &sin->sin_addr.s_addr);
116 static void nlm_display_ipv6_address(const struct sockaddr *sap, char *buf,
119 const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
121 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
122 snprintf(buf, len, "%pI4", &sin6->sin6_addr.s6_addr32[3]);
123 else if (sin6->sin6_scope_id != 0)
124 snprintf(buf, len, "%pI6%%%u", &sin6->sin6_addr,
125 sin6->sin6_scope_id);
127 snprintf(buf, len, "%pI6", &sin6->sin6_addr);
130 static void nlm_display_address(const struct sockaddr *sap,
131 char *buf, const size_t len)
133 switch (sap->sa_family) {
135 nlm_display_ipv4_address(sap, buf, len);
138 nlm_display_ipv6_address(sap, buf, len);
141 snprintf(buf, len, "unsupported address family");
147 * Common host lookup routine for server & client
149 static struct nlm_host *nlm_lookup_host(struct nlm_lookup_host_info *ni)
151 struct hlist_head *chain;
152 struct hlist_node *pos;
153 struct nlm_host *host;
154 struct nsm_handle *nsm = NULL;
156 mutex_lock(&nlm_host_mutex);
158 if (time_after_eq(jiffies, next_gc))
161 /* We may keep several nlm_host objects for a peer, because each
162 * nlm_host is identified by
163 * (address, protocol, version, server/client)
164 * We could probably simplify this a little by putting all those
165 * different NLM rpc_clients into one single nlm_host object.
166 * This would allow us to have one nlm_host per address.
168 chain = &nlm_hosts[nlm_hash_address(ni->sap)];
169 hlist_for_each_entry(host, pos, chain, h_hash) {
170 if (!nlm_cmp_addr(nlm_addr(host), ni->sap))
173 /* See if we have an NSM handle for this client */
175 nsm = host->h_nsmhandle;
177 if (host->h_proto != ni->protocol)
179 if (host->h_version != ni->version)
181 if (host->h_server != ni->server)
184 !nlm_cmp_addr(nlm_srcaddr(host), ni->src_sap))
187 /* Move to head of hash chain. */
188 hlist_del(&host->h_hash);
189 hlist_add_head(&host->h_hash, chain);
192 dprintk("lockd: nlm_lookup_host found host %s (%s)\n",
193 host->h_name, host->h_addrbuf);
198 * The host wasn't in our hash table. If we don't
199 * have an NSM handle for it yet, create one.
202 atomic_inc(&nsm->sm_count);
205 nsm = nsm_find(ni->sap, ni->salen,
206 ni->hostname, ni->hostname_len, 1);
208 dprintk("lockd: nlm_lookup_host failed; "
214 host = kzalloc(sizeof(*host), GFP_KERNEL);
217 dprintk("lockd: nlm_lookup_host failed; no memory\n");
220 host->h_name = nsm->sm_name;
221 host->h_addrbuf = nsm->sm_addrbuf;
222 memcpy(nlm_addr(host), ni->sap, ni->salen);
223 host->h_addrlen = ni->salen;
224 nlm_clear_port(nlm_addr(host));
225 memcpy(nlm_srcaddr(host), ni->src_sap, ni->src_len);
226 host->h_version = ni->version;
227 host->h_proto = ni->protocol;
228 host->h_rpcclnt = NULL;
229 mutex_init(&host->h_mutex);
230 host->h_nextrebind = jiffies + NLM_HOST_REBIND;
231 host->h_expires = jiffies + NLM_HOST_EXPIRE;
232 atomic_set(&host->h_count, 1);
233 init_waitqueue_head(&host->h_gracewait);
234 init_rwsem(&host->h_rwsem);
235 host->h_state = 0; /* pseudo NSM state */
236 host->h_nsmstate = 0; /* real NSM state */
237 host->h_nsmhandle = nsm;
238 host->h_server = ni->server;
239 host->h_noresvport = ni->noresvport;
240 hlist_add_head(&host->h_hash, chain);
241 INIT_LIST_HEAD(&host->h_lockowners);
242 spin_lock_init(&host->h_lock);
243 INIT_LIST_HEAD(&host->h_granted);
244 INIT_LIST_HEAD(&host->h_reclaim);
248 dprintk("lockd: nlm_lookup_host created host %s\n",
252 mutex_unlock(&nlm_host_mutex);
260 nlm_destroy_host(struct nlm_host *host)
262 struct rpc_clnt *clnt;
264 BUG_ON(!list_empty(&host->h_lockowners));
265 BUG_ON(atomic_read(&host->h_count));
268 nsm_release(host->h_nsmhandle);
270 clnt = host->h_rpcclnt;
272 rpc_shutdown_client(clnt);
277 * nlmclnt_lookup_host - Find an NLM host handle matching a remote server
278 * @sap: network address of server
279 * @salen: length of server address
280 * @protocol: transport protocol to use
281 * @version: NLM protocol version
282 * @hostname: '\0'-terminated hostname of server
283 * @noresvport: 1 if non-privileged port should be used
285 * Returns an nlm_host structure that matches the passed-in
286 * [server address, transport protocol, NLM version, server hostname].
287 * If one doesn't already exist in the host cache, a new handle is
288 * created and returned.
290 struct nlm_host *nlmclnt_lookup_host(const struct sockaddr *sap,
292 const unsigned short protocol,
294 const char *hostname,
297 const struct sockaddr source = {
298 .sa_family = AF_UNSPEC,
300 struct nlm_lookup_host_info ni = {
304 .protocol = protocol,
306 .hostname = hostname,
307 .hostname_len = strlen(hostname),
309 .src_len = sizeof(source),
310 .noresvport = noresvport,
313 dprintk("lockd: %s(host='%s', vers=%u, proto=%s)\n", __func__,
314 (hostname ? hostname : "<none>"), version,
315 (protocol == IPPROTO_UDP ? "udp" : "tcp"));
317 return nlm_lookup_host(&ni);
321 * nlmsvc_lookup_host - Find an NLM host handle matching a remote client
322 * @rqstp: incoming NLM request
323 * @hostname: name of client host
324 * @hostname_len: length of client hostname
326 * Returns an nlm_host structure that matches the [client address,
327 * transport protocol, NLM version, client hostname] of the passed-in
328 * NLM request. If one doesn't already exist in the host cache, a
329 * new handle is created and returned.
331 * Before possibly creating a new nlm_host, construct a sockaddr
332 * for a specific source address in case the local system has
333 * multiple network addresses. The family of the address in
334 * rq_daddr is guaranteed to be the same as the family of the
335 * address in rq_addr, so it's safe to use the same family for
336 * the source address.
338 struct nlm_host *nlmsvc_lookup_host(const struct svc_rqst *rqstp,
339 const char *hostname,
340 const size_t hostname_len)
342 struct sockaddr_in sin = {
343 .sin_family = AF_INET,
345 struct sockaddr_in6 sin6 = {
346 .sin6_family = AF_INET6,
348 struct nlm_lookup_host_info ni = {
350 .sap = svc_addr(rqstp),
351 .salen = rqstp->rq_addrlen,
352 .protocol = rqstp->rq_prot,
353 .version = rqstp->rq_vers,
354 .hostname = hostname,
355 .hostname_len = hostname_len,
356 .src_len = rqstp->rq_addrlen,
359 dprintk("lockd: %s(host='%*s', vers=%u, proto=%s)\n", __func__,
360 (int)hostname_len, hostname, rqstp->rq_vers,
361 (rqstp->rq_prot == IPPROTO_UDP ? "udp" : "tcp"));
363 switch (ni.sap->sa_family) {
365 sin.sin_addr.s_addr = rqstp->rq_daddr.addr.s_addr;
366 ni.src_sap = (struct sockaddr *)&sin;
369 ipv6_addr_copy(&sin6.sin6_addr, &rqstp->rq_daddr.addr6);
370 ni.src_sap = (struct sockaddr *)&sin6;
376 return nlm_lookup_host(&ni);
380 * Create the NLM RPC client for an NLM peer
383 nlm_bind_host(struct nlm_host *host)
385 struct rpc_clnt *clnt;
387 dprintk("lockd: nlm_bind_host %s (%s)\n",
388 host->h_name, host->h_addrbuf);
390 /* Lock host handle */
391 mutex_lock(&host->h_mutex);
393 /* If we've already created an RPC client, check whether
394 * RPC rebind is required
396 if ((clnt = host->h_rpcclnt) != NULL) {
397 if (time_after_eq(jiffies, host->h_nextrebind)) {
398 rpc_force_rebind(clnt);
399 host->h_nextrebind = jiffies + NLM_HOST_REBIND;
400 dprintk("lockd: next rebind in %lu jiffies\n",
401 host->h_nextrebind - jiffies);
404 unsigned long increment = nlmsvc_timeout;
405 struct rpc_timeout timeparms = {
406 .to_initval = increment,
407 .to_increment = increment,
408 .to_maxval = increment * 6UL,
411 struct rpc_create_args args = {
412 .protocol = host->h_proto,
413 .address = nlm_addr(host),
414 .addrsize = host->h_addrlen,
415 .saddress = nlm_srcaddr(host),
416 .timeout = &timeparms,
417 .servername = host->h_name,
418 .program = &nlm_program,
419 .version = host->h_version,
420 .authflavor = RPC_AUTH_UNIX,
421 .flags = (RPC_CLNT_CREATE_NOPING |
422 RPC_CLNT_CREATE_AUTOBIND),
426 * lockd retries server side blocks automatically so we want
427 * those to be soft RPC calls. Client side calls need to be
431 args.flags |= RPC_CLNT_CREATE_HARDRTRY;
432 if (host->h_noresvport)
433 args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
435 clnt = rpc_create(&args);
437 host->h_rpcclnt = clnt;
439 printk("lockd: couldn't create RPC handle for %s\n", host->h_name);
444 mutex_unlock(&host->h_mutex);
449 * Force a portmap lookup of the remote lockd port
452 nlm_rebind_host(struct nlm_host *host)
454 dprintk("lockd: rebind host %s\n", host->h_name);
455 if (host->h_rpcclnt && time_after_eq(jiffies, host->h_nextrebind)) {
456 rpc_force_rebind(host->h_rpcclnt);
457 host->h_nextrebind = jiffies + NLM_HOST_REBIND;
462 * Increment NLM host count
464 struct nlm_host * nlm_get_host(struct nlm_host *host)
467 dprintk("lockd: get host %s\n", host->h_name);
468 atomic_inc(&host->h_count);
469 host->h_expires = jiffies + NLM_HOST_EXPIRE;
475 * Release NLM host after use
477 void nlm_release_host(struct nlm_host *host)
480 dprintk("lockd: release host %s\n", host->h_name);
481 BUG_ON(atomic_read(&host->h_count) < 0);
482 if (atomic_dec_and_test(&host->h_count)) {
483 BUG_ON(!list_empty(&host->h_lockowners));
484 BUG_ON(!list_empty(&host->h_granted));
485 BUG_ON(!list_empty(&host->h_reclaim));
491 * We were notified that the host indicated by address &sin
493 * Release all resources held by that peer.
495 void nlm_host_rebooted(const struct sockaddr_in *sin,
496 const char *hostname,
497 unsigned int hostname_len,
500 struct hlist_head *chain;
501 struct hlist_node *pos;
502 struct nsm_handle *nsm;
503 struct nlm_host *host;
505 nsm = nsm_find((struct sockaddr *)sin, sizeof(*sin),
506 hostname, hostname_len, 0);
508 dprintk("lockd: never saw rebooted peer '%.*s' before\n",
509 hostname_len, hostname);
513 dprintk("lockd: nlm_host_rebooted(%.*s, %s)\n",
514 hostname_len, hostname, nsm->sm_addrbuf);
516 /* When reclaiming locks on this peer, make sure that
517 * we set up a new notification */
518 nsm->sm_monitored = 0;
520 /* Mark all hosts tied to this NSM state as having rebooted.
521 * We run the loop repeatedly, because we drop the host table
523 * To avoid processing a host several times, we match the nsmstate.
525 again: mutex_lock(&nlm_host_mutex);
526 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
527 hlist_for_each_entry(host, pos, chain, h_hash) {
528 if (host->h_nsmhandle == nsm
529 && host->h_nsmstate != new_state) {
530 host->h_nsmstate = new_state;
534 mutex_unlock(&nlm_host_mutex);
536 if (host->h_server) {
537 /* We're server for this guy, just ditch
538 * all the locks he held. */
539 nlmsvc_free_host_resources(host);
541 /* He's the server, initiate lock recovery. */
542 nlmclnt_recovery(host);
545 nlm_release_host(host);
551 mutex_unlock(&nlm_host_mutex);
555 * Shut down the hosts module.
556 * Note that this routine is called only at server shutdown time.
559 nlm_shutdown_hosts(void)
561 struct hlist_head *chain;
562 struct hlist_node *pos;
563 struct nlm_host *host;
565 dprintk("lockd: shutting down host module\n");
566 mutex_lock(&nlm_host_mutex);
568 /* First, make all hosts eligible for gc */
569 dprintk("lockd: nuking all hosts...\n");
570 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
571 hlist_for_each_entry(host, pos, chain, h_hash) {
572 host->h_expires = jiffies - 1;
573 if (host->h_rpcclnt) {
574 rpc_shutdown_client(host->h_rpcclnt);
575 host->h_rpcclnt = NULL;
580 /* Then, perform a garbage collection pass */
582 mutex_unlock(&nlm_host_mutex);
584 /* complain if any hosts are left */
586 printk(KERN_WARNING "lockd: couldn't shutdown host module!\n");
587 dprintk("lockd: %d hosts left:\n", nrhosts);
588 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
589 hlist_for_each_entry(host, pos, chain, h_hash) {
590 dprintk(" %s (cnt %d use %d exp %ld)\n",
591 host->h_name, atomic_read(&host->h_count),
592 host->h_inuse, host->h_expires);
599 * Garbage collect any unused NLM hosts.
600 * This GC combines reference counting for async operations with
601 * mark & sweep for resources held by remote clients.
606 struct hlist_head *chain;
607 struct hlist_node *pos, *next;
608 struct nlm_host *host;
610 dprintk("lockd: host garbage collection\n");
611 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
612 hlist_for_each_entry(host, pos, chain, h_hash)
616 /* Mark all hosts that hold locks, blocks or shares */
617 nlmsvc_mark_resources();
619 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
620 hlist_for_each_entry_safe(host, pos, next, chain, h_hash) {
621 if (atomic_read(&host->h_count) || host->h_inuse
622 || time_before(jiffies, host->h_expires)) {
623 dprintk("nlm_gc_hosts skipping %s (cnt %d use %d exp %ld)\n",
624 host->h_name, atomic_read(&host->h_count),
625 host->h_inuse, host->h_expires);
628 dprintk("lockd: delete host %s\n", host->h_name);
629 hlist_del_init(&host->h_hash);
631 nlm_destroy_host(host);
636 next_gc = jiffies + NLM_HOST_COLLECT;
643 static LIST_HEAD(nsm_handles);
644 static DEFINE_SPINLOCK(nsm_lock);
646 static struct nsm_handle *nsm_find(const struct sockaddr *sap,
648 const char *hostname,
649 const size_t hostname_len,
652 struct nsm_handle *nsm = NULL;
653 struct nsm_handle *pos;
658 if (hostname && memchr(hostname, '/', hostname_len) != NULL) {
659 if (printk_ratelimit()) {
660 printk(KERN_WARNING "Invalid hostname \"%.*s\" "
661 "in NFS lock request\n",
662 (int)hostname_len, hostname);
668 spin_lock(&nsm_lock);
669 list_for_each_entry(pos, &nsm_handles, sm_link) {
671 if (hostname && nsm_use_hostnames) {
672 if (strlen(pos->sm_name) != hostname_len
673 || memcmp(pos->sm_name, hostname, hostname_len))
675 } else if (!nlm_cmp_addr(nsm_addr(pos), sap))
677 atomic_inc(&pos->sm_count);
683 list_add(&nsm->sm_link, &nsm_handles);
686 spin_unlock(&nsm_lock);
691 nsm = kzalloc(sizeof(*nsm) + hostname_len + 1, GFP_KERNEL);
695 memcpy(nsm_addr(nsm), sap, salen);
696 nsm->sm_addrlen = salen;
697 nsm->sm_name = (char *) (nsm + 1);
698 memcpy(nsm->sm_name, hostname, hostname_len);
699 nsm->sm_name[hostname_len] = '\0';
700 nlm_display_address((struct sockaddr *)&nsm->sm_addr,
701 nsm->sm_addrbuf, sizeof(nsm->sm_addrbuf));
702 atomic_set(&nsm->sm_count, 1);
706 spin_unlock(&nsm_lock);
711 * Release an NSM handle
713 static void nsm_release(struct nsm_handle *nsm)
717 if (atomic_dec_and_lock(&nsm->sm_count, &nsm_lock)) {
718 list_del(&nsm->sm_link);
719 spin_unlock(&nsm_lock);