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);
36 struct nlm_lookup_host_info {
37 const int server; /* search for server|client */
38 const struct sockaddr *sap; /* address to search for */
39 const size_t salen; /* it's length */
40 const unsigned short protocol; /* transport to search for*/
41 const u32 version; /* NLM version to search for */
42 const char *hostname; /* remote's hostname */
43 const size_t hostname_len; /* it's length */
44 const struct sockaddr *src_sap; /* our address (optional) */
45 const size_t src_len; /* it's length */
46 const int noresvport; /* use non-priv port */
50 * Hash function must work well on big- and little-endian platforms
52 static unsigned int __nlm_hash32(const __be32 n)
54 unsigned int hash = (__force u32)n ^ ((__force u32)n >> 16);
55 return hash ^ (hash >> 8);
58 static unsigned int __nlm_hash_addr4(const struct sockaddr *sap)
60 const struct sockaddr_in *sin = (struct sockaddr_in *)sap;
61 return __nlm_hash32(sin->sin_addr.s_addr);
64 static unsigned int __nlm_hash_addr6(const struct sockaddr *sap)
66 const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
67 const struct in6_addr addr = sin6->sin6_addr;
68 return __nlm_hash32(addr.s6_addr32[0]) ^
69 __nlm_hash32(addr.s6_addr32[1]) ^
70 __nlm_hash32(addr.s6_addr32[2]) ^
71 __nlm_hash32(addr.s6_addr32[3]);
74 static unsigned int nlm_hash_address(const struct sockaddr *sap)
78 switch (sap->sa_family) {
80 hash = __nlm_hash_addr4(sap);
83 hash = __nlm_hash_addr6(sap);
88 return hash & (NLM_HOST_NRHASH - 1);
91 static void nlm_clear_port(struct sockaddr *sap)
93 switch (sap->sa_family) {
95 ((struct sockaddr_in *)sap)->sin_port = 0;
98 ((struct sockaddr_in6 *)sap)->sin6_port = 0;
104 * Common host lookup routine for server & client
106 static struct nlm_host *nlm_lookup_host(struct nlm_lookup_host_info *ni)
108 struct hlist_head *chain;
109 struct hlist_node *pos;
110 struct nlm_host *host;
111 struct nsm_handle *nsm = NULL;
113 mutex_lock(&nlm_host_mutex);
115 if (time_after_eq(jiffies, next_gc))
118 /* We may keep several nlm_host objects for a peer, because each
119 * nlm_host is identified by
120 * (address, protocol, version, server/client)
121 * We could probably simplify this a little by putting all those
122 * different NLM rpc_clients into one single nlm_host object.
123 * This would allow us to have one nlm_host per address.
125 chain = &nlm_hosts[nlm_hash_address(ni->sap)];
126 hlist_for_each_entry(host, pos, chain, h_hash) {
127 if (!nlm_cmp_addr(nlm_addr(host), ni->sap))
130 /* See if we have an NSM handle for this client */
132 nsm = host->h_nsmhandle;
134 if (host->h_proto != ni->protocol)
136 if (host->h_version != ni->version)
138 if (host->h_server != ni->server)
141 !nlm_cmp_addr(nlm_srcaddr(host), ni->src_sap))
144 /* Move to head of hash chain. */
145 hlist_del(&host->h_hash);
146 hlist_add_head(&host->h_hash, chain);
149 dprintk("lockd: nlm_lookup_host found host %s (%s)\n",
150 host->h_name, host->h_addrbuf);
155 * The host wasn't in our hash table. If we don't
156 * have an NSM handle for it yet, create one.
159 atomic_inc(&nsm->sm_count);
162 nsm = nsm_find(ni->sap, ni->salen,
163 ni->hostname, ni->hostname_len, 1);
165 dprintk("lockd: nlm_lookup_host failed; "
171 host = kzalloc(sizeof(*host), GFP_KERNEL);
174 dprintk("lockd: nlm_lookup_host failed; no memory\n");
177 host->h_name = nsm->sm_name;
178 host->h_addrbuf = nsm->sm_addrbuf;
179 memcpy(nlm_addr(host), ni->sap, ni->salen);
180 host->h_addrlen = ni->salen;
181 nlm_clear_port(nlm_addr(host));
182 memcpy(nlm_srcaddr(host), ni->src_sap, 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 const struct sockaddr source = {
255 .sa_family = AF_UNSPEC,
257 struct nlm_lookup_host_info ni = {
261 .protocol = protocol,
263 .hostname = hostname,
264 .hostname_len = strlen(hostname),
266 .src_len = sizeof(source),
267 .noresvport = noresvport,
270 dprintk("lockd: %s(host='%s', vers=%u, proto=%s)\n", __func__,
271 (hostname ? hostname : "<none>"), version,
272 (protocol == IPPROTO_UDP ? "udp" : "tcp"));
274 return nlm_lookup_host(&ni);
278 * nlmsvc_lookup_host - Find an NLM host handle matching a remote client
279 * @rqstp: incoming NLM request
280 * @hostname: name of client host
281 * @hostname_len: length of client hostname
283 * Returns an nlm_host structure that matches the [client address,
284 * transport protocol, NLM version, client hostname] of the passed-in
285 * NLM request. If one doesn't already exist in the host cache, a
286 * new handle is created and returned.
288 * Before possibly creating a new nlm_host, construct a sockaddr
289 * for a specific source address in case the local system has
290 * multiple network addresses. The family of the address in
291 * rq_daddr is guaranteed to be the same as the family of the
292 * address in rq_addr, so it's safe to use the same family for
293 * the source address.
295 struct nlm_host *nlmsvc_lookup_host(const struct svc_rqst *rqstp,
296 const char *hostname,
297 const size_t hostname_len)
299 struct sockaddr_in sin = {
300 .sin_family = AF_INET,
302 struct sockaddr_in6 sin6 = {
303 .sin6_family = AF_INET6,
305 struct nlm_lookup_host_info ni = {
307 .sap = svc_addr(rqstp),
308 .salen = rqstp->rq_addrlen,
309 .protocol = rqstp->rq_prot,
310 .version = rqstp->rq_vers,
311 .hostname = hostname,
312 .hostname_len = hostname_len,
313 .src_len = rqstp->rq_addrlen,
316 dprintk("lockd: %s(host='%*s', vers=%u, proto=%s)\n", __func__,
317 (int)hostname_len, hostname, rqstp->rq_vers,
318 (rqstp->rq_prot == IPPROTO_UDP ? "udp" : "tcp"));
320 switch (ni.sap->sa_family) {
322 sin.sin_addr.s_addr = rqstp->rq_daddr.addr.s_addr;
323 ni.src_sap = (struct sockaddr *)&sin;
326 ipv6_addr_copy(&sin6.sin6_addr, &rqstp->rq_daddr.addr6);
327 ni.src_sap = (struct sockaddr *)&sin6;
333 return nlm_lookup_host(&ni);
337 * Create the NLM RPC client for an NLM peer
340 nlm_bind_host(struct nlm_host *host)
342 struct rpc_clnt *clnt;
344 dprintk("lockd: nlm_bind_host %s (%s)\n",
345 host->h_name, host->h_addrbuf);
347 /* Lock host handle */
348 mutex_lock(&host->h_mutex);
350 /* If we've already created an RPC client, check whether
351 * RPC rebind is required
353 if ((clnt = host->h_rpcclnt) != NULL) {
354 if (time_after_eq(jiffies, host->h_nextrebind)) {
355 rpc_force_rebind(clnt);
356 host->h_nextrebind = jiffies + NLM_HOST_REBIND;
357 dprintk("lockd: next rebind in %lu jiffies\n",
358 host->h_nextrebind - jiffies);
361 unsigned long increment = nlmsvc_timeout;
362 struct rpc_timeout timeparms = {
363 .to_initval = increment,
364 .to_increment = increment,
365 .to_maxval = increment * 6UL,
368 struct rpc_create_args args = {
369 .protocol = host->h_proto,
370 .address = nlm_addr(host),
371 .addrsize = host->h_addrlen,
372 .saddress = nlm_srcaddr(host),
373 .timeout = &timeparms,
374 .servername = host->h_name,
375 .program = &nlm_program,
376 .version = host->h_version,
377 .authflavor = RPC_AUTH_UNIX,
378 .flags = (RPC_CLNT_CREATE_NOPING |
379 RPC_CLNT_CREATE_AUTOBIND),
383 * lockd retries server side blocks automatically so we want
384 * those to be soft RPC calls. Client side calls need to be
388 args.flags |= RPC_CLNT_CREATE_HARDRTRY;
389 if (host->h_noresvport)
390 args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
392 clnt = rpc_create(&args);
394 host->h_rpcclnt = clnt;
396 printk("lockd: couldn't create RPC handle for %s\n", host->h_name);
401 mutex_unlock(&host->h_mutex);
406 * Force a portmap lookup of the remote lockd port
409 nlm_rebind_host(struct nlm_host *host)
411 dprintk("lockd: rebind host %s\n", host->h_name);
412 if (host->h_rpcclnt && time_after_eq(jiffies, host->h_nextrebind)) {
413 rpc_force_rebind(host->h_rpcclnt);
414 host->h_nextrebind = jiffies + NLM_HOST_REBIND;
419 * Increment NLM host count
421 struct nlm_host * nlm_get_host(struct nlm_host *host)
424 dprintk("lockd: get host %s\n", host->h_name);
425 atomic_inc(&host->h_count);
426 host->h_expires = jiffies + NLM_HOST_EXPIRE;
432 * Release NLM host after use
434 void nlm_release_host(struct nlm_host *host)
437 dprintk("lockd: release host %s\n", host->h_name);
438 BUG_ON(atomic_read(&host->h_count) < 0);
439 if (atomic_dec_and_test(&host->h_count)) {
440 BUG_ON(!list_empty(&host->h_lockowners));
441 BUG_ON(!list_empty(&host->h_granted));
442 BUG_ON(!list_empty(&host->h_reclaim));
448 * nlm_host_rebooted - Release all resources held by rebooted host
449 * @info: pointer to decoded results of NLM_SM_NOTIFY call
451 * We were notified that the specified host has rebooted. Release
452 * all resources held by that peer.
454 void nlm_host_rebooted(const struct nlm_reboot *info)
456 struct hlist_head *chain;
457 struct hlist_node *pos;
458 struct nsm_handle *nsm;
459 struct nlm_host *host;
461 nsm = nsm_reboot_lookup(info);
462 if (unlikely(nsm == NULL))
465 /* Mark all hosts tied to this NSM state as having rebooted.
466 * We run the loop repeatedly, because we drop the host table
468 * To avoid processing a host several times, we match the nsmstate.
470 again: mutex_lock(&nlm_host_mutex);
471 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
472 hlist_for_each_entry(host, pos, chain, h_hash) {
473 if (host->h_nsmhandle == nsm
474 && host->h_nsmstate != info->state) {
475 host->h_nsmstate = info->state;
479 mutex_unlock(&nlm_host_mutex);
481 if (host->h_server) {
482 /* We're server for this guy, just ditch
483 * all the locks he held. */
484 nlmsvc_free_host_resources(host);
486 /* He's the server, initiate lock recovery. */
487 nlmclnt_recovery(host);
490 nlm_release_host(host);
496 mutex_unlock(&nlm_host_mutex);
500 * Shut down the hosts module.
501 * Note that this routine is called only at server shutdown time.
504 nlm_shutdown_hosts(void)
506 struct hlist_head *chain;
507 struct hlist_node *pos;
508 struct nlm_host *host;
510 dprintk("lockd: shutting down host module\n");
511 mutex_lock(&nlm_host_mutex);
513 /* First, make all hosts eligible for gc */
514 dprintk("lockd: nuking all hosts...\n");
515 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
516 hlist_for_each_entry(host, pos, chain, h_hash) {
517 host->h_expires = jiffies - 1;
518 if (host->h_rpcclnt) {
519 rpc_shutdown_client(host->h_rpcclnt);
520 host->h_rpcclnt = NULL;
525 /* Then, perform a garbage collection pass */
527 mutex_unlock(&nlm_host_mutex);
529 /* complain if any hosts are left */
531 printk(KERN_WARNING "lockd: couldn't shutdown host module!\n");
532 dprintk("lockd: %d hosts left:\n", nrhosts);
533 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
534 hlist_for_each_entry(host, pos, chain, h_hash) {
535 dprintk(" %s (cnt %d use %d exp %ld)\n",
536 host->h_name, atomic_read(&host->h_count),
537 host->h_inuse, host->h_expires);
544 * Garbage collect any unused NLM hosts.
545 * This GC combines reference counting for async operations with
546 * mark & sweep for resources held by remote clients.
551 struct hlist_head *chain;
552 struct hlist_node *pos, *next;
553 struct nlm_host *host;
555 dprintk("lockd: host garbage collection\n");
556 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
557 hlist_for_each_entry(host, pos, chain, h_hash)
561 /* Mark all hosts that hold locks, blocks or shares */
562 nlmsvc_mark_resources();
564 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
565 hlist_for_each_entry_safe(host, pos, next, chain, h_hash) {
566 if (atomic_read(&host->h_count) || host->h_inuse
567 || time_before(jiffies, host->h_expires)) {
568 dprintk("nlm_gc_hosts skipping %s (cnt %d use %d exp %ld)\n",
569 host->h_name, atomic_read(&host->h_count),
570 host->h_inuse, host->h_expires);
573 dprintk("lockd: delete host %s\n", host->h_name);
574 hlist_del_init(&host->h_hash);
576 nlm_destroy_host(host);
581 next_gc = jiffies + NLM_HOST_COLLECT;