blob: be8f19d53183cdb6a5c140a5d778608bae9118f3 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/lockd/host.c
3 *
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.
7 *
8 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
9 */
10
11#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/slab.h>
13#include <linux/in.h>
Chuck Lever1b333c52008-08-27 16:57:23 -040014#include <linux/in6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/sunrpc/clnt.h>
16#include <linux/sunrpc/svc.h>
17#include <linux/lockd/lockd.h>
18#include <linux/lockd/sm_inter.h>
Ingo Molnar353ab6e2006-03-26 01:37:12 -080019#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020
Chuck Lever1b333c52008-08-27 16:57:23 -040021#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
23#define NLMDBG_FACILITY NLMDBG_HOSTCACHE
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#define NLM_HOST_NRHASH 32
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#define NLM_HOST_REBIND (60 * HZ)
NeilBrown1447d252008-02-08 13:03:37 +110026#define NLM_HOST_EXPIRE (300 * HZ)
27#define NLM_HOST_COLLECT (120 * HZ)
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
Olaf Kirch0cea3272006-10-04 02:15:56 -070029static struct hlist_head nlm_hosts[NLM_HOST_NRHASH];
Linus Torvalds1da177e2005-04-16 15:20:36 -070030static unsigned long next_gc;
31static int nrhosts;
Ingo Molnar353ab6e2006-03-26 01:37:12 -080032static DEFINE_MUTEX(nlm_host_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
Linus Torvalds1da177e2005-04-16 15:20:36 -070034static void nlm_gc_hosts(void);
Chuck Levere0180402008-09-03 14:36:23 -040035static struct nsm_handle *nsm_find(const struct sockaddr *sap,
36 const size_t salen,
Chuck Leverbc48e4d2008-09-03 14:36:16 -040037 const char *hostname,
38 const size_t hostname_len,
39 const int create);
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
Chuck Leverede2fea2008-09-03 14:36:08 -040041/*
42 * Hash function must work well on big- and little-endian platforms
43 */
44static unsigned int __nlm_hash32(const __be32 n)
45{
46 unsigned int hash = (__force u32)n ^ ((__force u32)n >> 16);
47 return hash ^ (hash >> 8);
48}
49
50static unsigned int __nlm_hash_addr4(const struct sockaddr *sap)
51{
52 const struct sockaddr_in *sin = (struct sockaddr_in *)sap;
53 return __nlm_hash32(sin->sin_addr.s_addr);
54}
55
56static unsigned int __nlm_hash_addr6(const struct sockaddr *sap)
57{
58 const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
59 const struct in6_addr addr = sin6->sin6_addr;
60 return __nlm_hash32(addr.s6_addr32[0]) ^
61 __nlm_hash32(addr.s6_addr32[1]) ^
62 __nlm_hash32(addr.s6_addr32[2]) ^
63 __nlm_hash32(addr.s6_addr32[3]);
64}
65
66static unsigned int nlm_hash_address(const struct sockaddr *sap)
67{
68 unsigned int hash;
69
70 switch (sap->sa_family) {
71 case AF_INET:
72 hash = __nlm_hash_addr4(sap);
73 break;
74 case AF_INET6:
75 hash = __nlm_hash_addr6(sap);
76 break;
77 default:
78 hash = 0;
79 }
80 return hash & (NLM_HOST_NRHASH - 1);
81}
82
Chuck Lever396cb3d2008-08-27 16:57:38 -040083static void nlm_clear_port(struct sockaddr *sap)
84{
85 switch (sap->sa_family) {
86 case AF_INET:
87 ((struct sockaddr_in *)sap)->sin_port = 0;
88 break;
89 case AF_INET6:
90 ((struct sockaddr_in6 *)sap)->sin6_port = 0;
91 break;
92 }
93}
94
Chuck Lever1b333c52008-08-27 16:57:23 -040095static void nlm_display_address(const struct sockaddr *sap,
96 char *buf, const size_t len)
97{
98 const struct sockaddr_in *sin = (struct sockaddr_in *)sap;
99 const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
100
101 switch (sap->sa_family) {
102 case AF_UNSPEC:
103 snprintf(buf, len, "unspecified");
104 break;
105 case AF_INET:
106 snprintf(buf, len, NIPQUAD_FMT, NIPQUAD(sin->sin_addr.s_addr));
107 break;
108 case AF_INET6:
109 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
110 snprintf(buf, len, NIPQUAD_FMT,
111 NIPQUAD(sin6->sin6_addr.s6_addr32[3]));
112 else
113 snprintf(buf, len, NIP6_FMT, NIP6(sin6->sin6_addr));
114 break;
115 default:
116 snprintf(buf, len, "unsupported address family");
117 break;
118 }
119}
120
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121/*
122 * Common host lookup routine for server & client
123 */
Chuck Levereb188602008-03-14 14:18:37 -0400124static struct nlm_host *nlm_lookup_host(int server,
125 const struct sockaddr_in *sin,
126 int proto, u32 version,
127 const char *hostname,
128 unsigned int hostname_len,
129 const struct sockaddr_in *ssin)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130{
Olaf Kirch0cea3272006-10-04 02:15:56 -0700131 struct hlist_head *chain;
132 struct hlist_node *pos;
133 struct nlm_host *host;
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700134 struct nsm_handle *nsm = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135
Chuck Lever1b333c52008-08-27 16:57:23 -0400136 dprintk("lockd: nlm_lookup_host(proto=%d, vers=%u,"
137 " my role is %s, hostname=%.*s)\n",
138 proto, version, server ? "server" : "client",
139 hostname_len, hostname ? hostname : "<none>");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800141 mutex_lock(&nlm_host_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142
143 if (time_after_eq(jiffies, next_gc))
144 nlm_gc_hosts();
145
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700146 /* We may keep several nlm_host objects for a peer, because each
147 * nlm_host is identified by
148 * (address, protocol, version, server/client)
149 * We could probably simplify this a little by putting all those
150 * different NLM rpc_clients into one single nlm_host object.
151 * This would allow us to have one nlm_host per address.
152 */
Chuck Leverede2fea2008-09-03 14:36:08 -0400153 chain = &nlm_hosts[nlm_hash_address((struct sockaddr *)sin)];
Olaf Kirch0cea3272006-10-04 02:15:56 -0700154 hlist_for_each_entry(host, pos, chain, h_hash) {
Chuck Lever781b61a2008-09-03 14:36:01 -0400155 if (!nlm_cmp_addr(nlm_addr(host), (struct sockaddr *)sin))
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700156 continue;
157
158 /* See if we have an NSM handle for this client */
NeilBrown6b54dae2006-10-04 02:16:15 -0700159 if (!nsm)
160 nsm = host->h_nsmhandle;
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700161
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 if (host->h_proto != proto)
163 continue;
164 if (host->h_version != version)
165 continue;
166 if (host->h_server != server)
167 continue;
Chuck Lever781b61a2008-09-03 14:36:01 -0400168 if (!nlm_cmp_addr(nlm_srcaddr(host), (struct sockaddr *)ssin))
Frank van Maarseveenc98451b2007-07-09 22:25:29 +0200169 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Olaf Kirch0cea3272006-10-04 02:15:56 -0700171 /* Move to head of hash chain. */
172 hlist_del(&host->h_hash);
173 hlist_add_head(&host->h_hash, chain);
174
Olaf Kirchf0737a32006-10-04 02:15:54 -0700175 nlm_get_host(host);
Chuck Lever1b333c52008-08-27 16:57:23 -0400176 dprintk("lockd: nlm_lookup_host found host %s (%s)\n",
177 host->h_name, host->h_addrbuf);
Olaf Kirchf0737a32006-10-04 02:15:54 -0700178 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 }
Chuck Leverc2526f42008-08-27 16:57:15 -0400180
181 /*
182 * The host wasn't in our hash table. If we don't
183 * have an NSM handle for it yet, create one.
184 */
NeilBrown6b54dae2006-10-04 02:16:15 -0700185 if (nsm)
186 atomic_inc(&nsm->sm_count);
Chuck Leverc2526f42008-08-27 16:57:15 -0400187 else {
188 host = NULL;
Chuck Levere0180402008-09-03 14:36:23 -0400189 nsm = nsm_find((struct sockaddr *)sin, sizeof(*sin),
190 hostname, hostname_len, 1);
Chuck Lever1b333c52008-08-27 16:57:23 -0400191 if (!nsm) {
192 dprintk("lockd: nlm_lookup_host failed; "
193 "no nsm handle\n");
Chuck Leverc2526f42008-08-27 16:57:15 -0400194 goto out;
Chuck Lever1b333c52008-08-27 16:57:23 -0400195 }
Chuck Leverc2526f42008-08-27 16:57:15 -0400196 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
Panagiotis Issarisf8314dc2006-09-27 01:49:37 -0700198 host = kzalloc(sizeof(*host), GFP_KERNEL);
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700199 if (!host) {
200 nsm_release(nsm);
Chuck Lever1b333c52008-08-27 16:57:23 -0400201 dprintk("lockd: nlm_lookup_host failed; no memory\n");
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700202 goto out;
203 }
204 host->h_name = nsm->sm_name;
Chuck Leverb4ed58f2008-09-03 14:35:39 -0400205 memcpy(nlm_addr(host), sin, sizeof(*sin));
206 host->h_addrlen = sizeof(*sin);
207 nlm_clear_port(nlm_addr(host));
Chuck Lever90151e62008-09-03 14:35:46 -0400208 memcpy(nlm_srcaddr(host), ssin, sizeof(*ssin));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 host->h_version = version;
210 host->h_proto = proto;
211 host->h_rpcclnt = NULL;
Trond Myklebust50467912006-06-09 09:40:24 -0400212 mutex_init(&host->h_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 host->h_nextrebind = jiffies + NLM_HOST_REBIND;
214 host->h_expires = jiffies + NLM_HOST_EXPIRE;
215 atomic_set(&host->h_count, 1);
216 init_waitqueue_head(&host->h_gracewait);
Trond Myklebust28df9552006-06-09 09:40:27 -0400217 init_rwsem(&host->h_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 host->h_state = 0; /* pseudo NSM state */
219 host->h_nsmstate = 0; /* real NSM state */
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700220 host->h_nsmhandle = nsm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 host->h_server = server;
Olaf Kirch0cea3272006-10-04 02:15:56 -0700222 hlist_add_head(&host->h_hash, chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 INIT_LIST_HEAD(&host->h_lockowners);
224 spin_lock_init(&host->h_lock);
Christoph Hellwig26bcbf92006-03-20 13:44:40 -0500225 INIT_LIST_HEAD(&host->h_granted);
226 INIT_LIST_HEAD(&host->h_reclaim);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
NeilBrown1447d252008-02-08 13:03:37 +1100228 nrhosts++;
Chuck Lever1b333c52008-08-27 16:57:23 -0400229
230 nlm_display_address((struct sockaddr *)&host->h_addr,
231 host->h_addrbuf, sizeof(host->h_addrbuf));
Chuck Lever90151e62008-09-03 14:35:46 -0400232 nlm_display_address((struct sockaddr *)&host->h_srcaddr,
233 host->h_srcaddrbuf, sizeof(host->h_srcaddrbuf));
Chuck Lever1b333c52008-08-27 16:57:23 -0400234
235 dprintk("lockd: nlm_lookup_host created host %s\n",
236 host->h_name);
237
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700238out:
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800239 mutex_unlock(&nlm_host_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 return host;
241}
242
Olaf Kirchc53c1bb2006-10-04 02:16:00 -0700243/*
244 * Destroy a host
245 */
246static void
247nlm_destroy_host(struct nlm_host *host)
248{
249 struct rpc_clnt *clnt;
250
251 BUG_ON(!list_empty(&host->h_lockowners));
252 BUG_ON(atomic_read(&host->h_count));
253
254 /*
255 * Release NSM handle and unmonitor host.
256 */
257 nsm_unmonitor(host);
258
Trond Myklebust34f52e32007-06-14 16:40:31 -0400259 clnt = host->h_rpcclnt;
260 if (clnt != NULL)
261 rpc_shutdown_client(clnt);
Olaf Kirchc53c1bb2006-10-04 02:16:00 -0700262 kfree(host);
263}
264
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265/*
Adrian Bunkc5856462006-12-06 20:38:29 -0800266 * Find an NLM server handle in the cache. If there is none, create it.
267 */
Chuck Levereb188602008-03-14 14:18:37 -0400268struct nlm_host *nlmclnt_lookup_host(const struct sockaddr_in *sin,
269 int proto, u32 version,
270 const char *hostname,
271 unsigned int hostname_len)
Adrian Bunkc5856462006-12-06 20:38:29 -0800272{
Chuck Lever2860a022008-08-27 16:57:31 -0400273 const struct sockaddr_in source = {
274 .sin_family = AF_UNSPEC,
275 };
Frank van Maarseveenc98451b2007-07-09 22:25:29 +0200276
Adrian Bunkc5856462006-12-06 20:38:29 -0800277 return nlm_lookup_host(0, sin, proto, version,
Chuck Lever2860a022008-08-27 16:57:31 -0400278 hostname, hostname_len, &source);
Adrian Bunkc5856462006-12-06 20:38:29 -0800279}
280
281/*
282 * Find an NLM client handle in the cache. If there is none, create it.
283 */
284struct nlm_host *
285nlmsvc_lookup_host(struct svc_rqst *rqstp,
Chuck Lever48df0202007-11-01 16:56:53 -0400286 const char *hostname, unsigned int hostname_len)
Adrian Bunkc5856462006-12-06 20:38:29 -0800287{
Chuck Lever2860a022008-08-27 16:57:31 -0400288 const struct sockaddr_in source = {
289 .sin_family = AF_INET,
290 .sin_addr = rqstp->rq_daddr.addr,
291 };
Frank van Maarseveenc98451b2007-07-09 22:25:29 +0200292
Chuck Lever27459f02007-02-12 00:53:34 -0800293 return nlm_lookup_host(1, svc_addr_in(rqstp),
Adrian Bunkc5856462006-12-06 20:38:29 -0800294 rqstp->rq_prot, rqstp->rq_vers,
Chuck Lever2860a022008-08-27 16:57:31 -0400295 hostname, hostname_len, &source);
Adrian Bunkc5856462006-12-06 20:38:29 -0800296}
297
298/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 * Create the NLM RPC client for an NLM peer
300 */
301struct rpc_clnt *
302nlm_bind_host(struct nlm_host *host)
303{
304 struct rpc_clnt *clnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
Chuck Lever1b333c52008-08-27 16:57:23 -0400306 dprintk("lockd: nlm_bind_host %s (%s), my addr=%s\n",
Chuck Lever90151e62008-09-03 14:35:46 -0400307 host->h_name, host->h_addrbuf, host->h_srcaddrbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308
309 /* Lock host handle */
Trond Myklebust50467912006-06-09 09:40:24 -0400310 mutex_lock(&host->h_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311
312 /* If we've already created an RPC client, check whether
313 * RPC rebind is required
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 */
315 if ((clnt = host->h_rpcclnt) != NULL) {
Chuck Lever43118c22005-08-25 16:25:49 -0700316 if (time_after_eq(jiffies, host->h_nextrebind)) {
Chuck Lever35f5a422006-01-03 09:55:50 +0100317 rpc_force_rebind(clnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 host->h_nextrebind = jiffies + NLM_HOST_REBIND;
Chuck Lever1b333c52008-08-27 16:57:23 -0400319 dprintk("lockd: next rebind in %lu jiffies\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 host->h_nextrebind - jiffies);
321 }
322 } else {
Trond Myklebust21051ba2007-05-14 16:50:44 -0400323 unsigned long increment = nlmsvc_timeout;
Chuck Levere1ec7892006-08-22 20:06:20 -0400324 struct rpc_timeout timeparms = {
325 .to_initval = increment,
326 .to_increment = increment,
327 .to_maxval = increment * 6UL,
328 .to_retries = 5U,
329 };
330 struct rpc_create_args args = {
331 .protocol = host->h_proto,
Chuck Leverb4ed58f2008-09-03 14:35:39 -0400332 .address = nlm_addr(host),
333 .addrsize = host->h_addrlen,
Chuck Lever90151e62008-09-03 14:35:46 -0400334 .saddress = nlm_srcaddr(host),
Chuck Levere1ec7892006-08-22 20:06:20 -0400335 .timeout = &timeparms,
336 .servername = host->h_name,
337 .program = &nlm_program,
338 .version = host->h_version,
339 .authflavor = RPC_AUTH_UNIX,
Jeff Layton90bd17c2008-02-06 11:34:11 -0500340 .flags = (RPC_CLNT_CREATE_NOPING |
Chuck Levere1ec7892006-08-22 20:06:20 -0400341 RPC_CLNT_CREATE_AUTOBIND),
342 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
Jeff Layton90bd17c2008-02-06 11:34:11 -0500344 /*
345 * lockd retries server side blocks automatically so we want
346 * those to be soft RPC calls. Client side calls need to be
347 * hard RPC tasks.
348 */
349 if (!host->h_server)
350 args.flags |= RPC_CLNT_CREATE_HARDRTRY;
351
Chuck Levere1ec7892006-08-22 20:06:20 -0400352 clnt = rpc_create(&args);
353 if (!IS_ERR(clnt))
354 host->h_rpcclnt = clnt;
355 else {
356 printk("lockd: couldn't create RPC handle for %s\n", host->h_name);
357 clnt = NULL;
358 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 }
360
Trond Myklebust50467912006-06-09 09:40:24 -0400361 mutex_unlock(&host->h_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 return clnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363}
364
365/*
366 * Force a portmap lookup of the remote lockd port
367 */
368void
369nlm_rebind_host(struct nlm_host *host)
370{
371 dprintk("lockd: rebind host %s\n", host->h_name);
372 if (host->h_rpcclnt && time_after_eq(jiffies, host->h_nextrebind)) {
Chuck Lever35f5a422006-01-03 09:55:50 +0100373 rpc_force_rebind(host->h_rpcclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 host->h_nextrebind = jiffies + NLM_HOST_REBIND;
375 }
376}
377
378/*
379 * Increment NLM host count
380 */
381struct nlm_host * nlm_get_host(struct nlm_host *host)
382{
383 if (host) {
384 dprintk("lockd: get host %s\n", host->h_name);
385 atomic_inc(&host->h_count);
386 host->h_expires = jiffies + NLM_HOST_EXPIRE;
387 }
388 return host;
389}
390
391/*
392 * Release NLM host after use
393 */
394void nlm_release_host(struct nlm_host *host)
395{
396 if (host != NULL) {
397 dprintk("lockd: release host %s\n", host->h_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 BUG_ON(atomic_read(&host->h_count) < 0);
Trond Myklebust4c060b52006-03-20 13:44:41 -0500399 if (atomic_dec_and_test(&host->h_count)) {
400 BUG_ON(!list_empty(&host->h_lockowners));
401 BUG_ON(!list_empty(&host->h_granted));
402 BUG_ON(!list_empty(&host->h_reclaim));
403 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 }
405}
406
407/*
Olaf Kirchcf712c22006-10-04 02:15:52 -0700408 * We were notified that the host indicated by address &sin
409 * has rebooted.
410 * Release all resources held by that peer.
411 */
Olaf Kirch5c8dd292006-10-04 02:15:55 -0700412void nlm_host_rebooted(const struct sockaddr_in *sin,
Chuck Lever48df0202007-11-01 16:56:53 -0400413 const char *hostname,
414 unsigned int hostname_len,
Olaf Kirch5c8dd292006-10-04 02:15:55 -0700415 u32 new_state)
Olaf Kirchcf712c22006-10-04 02:15:52 -0700416{
Olaf Kirch0cea3272006-10-04 02:15:56 -0700417 struct hlist_head *chain;
418 struct hlist_node *pos;
Olaf Kirch5c8dd292006-10-04 02:15:55 -0700419 struct nsm_handle *nsm;
Olaf Kirch0cea3272006-10-04 02:15:56 -0700420 struct nlm_host *host;
Olaf Kirchcf712c22006-10-04 02:15:52 -0700421
Chuck Levere0180402008-09-03 14:36:23 -0400422 nsm = nsm_find((struct sockaddr *)sin, sizeof(*sin),
423 hostname, hostname_len, 0);
Chuck Lever1b333c52008-08-27 16:57:23 -0400424 if (nsm == NULL) {
425 dprintk("lockd: never saw rebooted peer '%.*s' before\n",
426 hostname_len, hostname);
Olaf Kirchdb4e4c92006-10-04 02:15:52 -0700427 return;
Chuck Lever1b333c52008-08-27 16:57:23 -0400428 }
429
430 dprintk("lockd: nlm_host_rebooted(%.*s, %s)\n",
431 hostname_len, hostname, nsm->sm_addrbuf);
Olaf Kirchdb4e4c92006-10-04 02:15:52 -0700432
Olaf Kirch5c8dd292006-10-04 02:15:55 -0700433 /* When reclaiming locks on this peer, make sure that
434 * we set up a new notification */
435 nsm->sm_monitored = 0;
436
437 /* Mark all hosts tied to this NSM state as having rebooted.
438 * We run the loop repeatedly, because we drop the host table
439 * lock for this.
440 * To avoid processing a host several times, we match the nsmstate.
441 */
442again: mutex_lock(&nlm_host_mutex);
Olaf Kirch0cea3272006-10-04 02:15:56 -0700443 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
444 hlist_for_each_entry(host, pos, chain, h_hash) {
Olaf Kirch5c8dd292006-10-04 02:15:55 -0700445 if (host->h_nsmhandle == nsm
446 && host->h_nsmstate != new_state) {
447 host->h_nsmstate = new_state;
448 host->h_state++;
449
450 nlm_get_host(host);
451 mutex_unlock(&nlm_host_mutex);
452
453 if (host->h_server) {
454 /* We're server for this guy, just ditch
455 * all the locks he held. */
456 nlmsvc_free_host_resources(host);
457 } else {
458 /* He's the server, initiate lock recovery. */
459 nlmclnt_recovery(host);
460 }
461
462 nlm_release_host(host);
463 goto again;
464 }
465 }
Olaf Kirchcf712c22006-10-04 02:15:52 -0700466 }
Olaf Kirch5c8dd292006-10-04 02:15:55 -0700467
468 mutex_unlock(&nlm_host_mutex);
Olaf Kirchcf712c22006-10-04 02:15:52 -0700469}
470
471/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 * Shut down the hosts module.
473 * Note that this routine is called only at server shutdown time.
474 */
475void
476nlm_shutdown_hosts(void)
477{
Olaf Kirch0cea3272006-10-04 02:15:56 -0700478 struct hlist_head *chain;
479 struct hlist_node *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 struct nlm_host *host;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
482 dprintk("lockd: shutting down host module\n");
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800483 mutex_lock(&nlm_host_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
485 /* First, make all hosts eligible for gc */
486 dprintk("lockd: nuking all hosts...\n");
Olaf Kirch0cea3272006-10-04 02:15:56 -0700487 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
Jeff Laytond801b862008-01-29 10:30:55 -0500488 hlist_for_each_entry(host, pos, chain, h_hash) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 host->h_expires = jiffies - 1;
Jeff Laytond801b862008-01-29 10:30:55 -0500490 if (host->h_rpcclnt) {
491 rpc_shutdown_client(host->h_rpcclnt);
492 host->h_rpcclnt = NULL;
493 }
494 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 }
496
497 /* Then, perform a garbage collection pass */
498 nlm_gc_hosts();
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800499 mutex_unlock(&nlm_host_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
501 /* complain if any hosts are left */
502 if (nrhosts) {
503 printk(KERN_WARNING "lockd: couldn't shutdown host module!\n");
504 dprintk("lockd: %d hosts left:\n", nrhosts);
Olaf Kirch0cea3272006-10-04 02:15:56 -0700505 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
506 hlist_for_each_entry(host, pos, chain, h_hash) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 dprintk(" %s (cnt %d use %d exp %ld)\n",
508 host->h_name, atomic_read(&host->h_count),
509 host->h_inuse, host->h_expires);
510 }
511 }
512 }
513}
514
515/*
516 * Garbage collect any unused NLM hosts.
517 * This GC combines reference counting for async operations with
518 * mark & sweep for resources held by remote clients.
519 */
520static void
521nlm_gc_hosts(void)
522{
Olaf Kirch0cea3272006-10-04 02:15:56 -0700523 struct hlist_head *chain;
524 struct hlist_node *pos, *next;
525 struct nlm_host *host;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526
527 dprintk("lockd: host garbage collection\n");
Olaf Kirch0cea3272006-10-04 02:15:56 -0700528 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
529 hlist_for_each_entry(host, pos, chain, h_hash)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 host->h_inuse = 0;
531 }
532
533 /* Mark all hosts that hold locks, blocks or shares */
534 nlmsvc_mark_resources();
535
Olaf Kirch0cea3272006-10-04 02:15:56 -0700536 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
537 hlist_for_each_entry_safe(host, pos, next, chain, h_hash) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 if (atomic_read(&host->h_count) || host->h_inuse
539 || time_before(jiffies, host->h_expires)) {
540 dprintk("nlm_gc_hosts skipping %s (cnt %d use %d exp %ld)\n",
541 host->h_name, atomic_read(&host->h_count),
542 host->h_inuse, host->h_expires);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 continue;
544 }
545 dprintk("lockd: delete host %s\n", host->h_name);
Olaf Kirch0cea3272006-10-04 02:15:56 -0700546 hlist_del_init(&host->h_hash);
Olaf Kirch977faf32006-10-04 02:15:51 -0700547
Olaf Kirchc53c1bb2006-10-04 02:16:00 -0700548 nlm_destroy_host(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 nrhosts--;
550 }
551 }
552
553 next_gc = jiffies + NLM_HOST_COLLECT;
554}
555
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700556
557/*
558 * Manage NSM handles
559 */
560static LIST_HEAD(nsm_handles);
J. Bruce Fieldsd8421202008-02-20 15:40:15 -0500561static DEFINE_SPINLOCK(nsm_lock);
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700562
Chuck Levere0180402008-09-03 14:36:23 -0400563static struct nsm_handle *nsm_find(const struct sockaddr *sap,
564 const size_t salen,
Chuck Leverbc48e4d2008-09-03 14:36:16 -0400565 const char *hostname,
566 const size_t hostname_len,
567 const int create)
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700568{
569 struct nsm_handle *nsm = NULL;
J. Bruce Fieldsa95e56e2008-02-20 15:27:31 -0500570 struct nsm_handle *pos;
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700571
Chuck Levere0180402008-09-03 14:36:23 -0400572 if (!sap)
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700573 return NULL;
574
575 if (hostname && memchr(hostname, '/', hostname_len) != NULL) {
576 if (printk_ratelimit()) {
577 printk(KERN_WARNING "Invalid hostname \"%.*s\" "
578 "in NFS lock request\n",
Chuck Leverbc48e4d2008-09-03 14:36:16 -0400579 (int)hostname_len, hostname);
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700580 }
581 return NULL;
582 }
583
J. Bruce Fieldsd8421202008-02-20 15:40:15 -0500584retry:
585 spin_lock(&nsm_lock);
J. Bruce Fieldsa95e56e2008-02-20 15:27:31 -0500586 list_for_each_entry(pos, &nsm_handles, sm_link) {
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700587
Olaf Kirchabd1f502006-10-04 02:16:01 -0700588 if (hostname && nsm_use_hostnames) {
J. Bruce Fieldsa95e56e2008-02-20 15:27:31 -0500589 if (strlen(pos->sm_name) != hostname_len
590 || memcmp(pos->sm_name, hostname, hostname_len))
Olaf Kirchabd1f502006-10-04 02:16:01 -0700591 continue;
Chuck Levere0180402008-09-03 14:36:23 -0400592 } else if (!nlm_cmp_addr(nsm_addr(pos), sap))
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700593 continue;
J. Bruce Fieldsa95e56e2008-02-20 15:27:31 -0500594 atomic_inc(&pos->sm_count);
J. Bruce Fieldsd8421202008-02-20 15:40:15 -0500595 kfree(nsm);
J. Bruce Fieldsa95e56e2008-02-20 15:27:31 -0500596 nsm = pos;
J. Bruce Fieldsd8421202008-02-20 15:40:15 -0500597 goto found;
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700598 }
J. Bruce Fieldsd8421202008-02-20 15:40:15 -0500599 if (nsm) {
600 list_add(&nsm->sm_link, &nsm_handles);
601 goto found;
602 }
603 spin_unlock(&nsm_lock);
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700604
J. Bruce Fieldsd8421202008-02-20 15:40:15 -0500605 if (!create)
606 return NULL;
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700607
608 nsm = kzalloc(sizeof(*nsm) + hostname_len + 1, GFP_KERNEL);
J. Bruce Fieldsa95e56e2008-02-20 15:27:31 -0500609 if (nsm == NULL)
J. Bruce Fieldsd8421202008-02-20 15:40:15 -0500610 return NULL;
611
Chuck Levere0180402008-09-03 14:36:23 -0400612 memcpy(nsm_addr(nsm), sap, salen);
613 nsm->sm_addrlen = salen;
J. Bruce Fieldsa95e56e2008-02-20 15:27:31 -0500614 nsm->sm_name = (char *) (nsm + 1);
615 memcpy(nsm->sm_name, hostname, hostname_len);
616 nsm->sm_name[hostname_len] = '\0';
Chuck Lever1b333c52008-08-27 16:57:23 -0400617 nlm_display_address((struct sockaddr *)&nsm->sm_addr,
618 nsm->sm_addrbuf, sizeof(nsm->sm_addrbuf));
J. Bruce Fieldsa95e56e2008-02-20 15:27:31 -0500619 atomic_set(&nsm->sm_count, 1);
J. Bruce Fieldsd8421202008-02-20 15:40:15 -0500620 goto retry;
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700621
J. Bruce Fieldsd8421202008-02-20 15:40:15 -0500622found:
623 spin_unlock(&nsm_lock);
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700624 return nsm;
625}
626
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700627/*
628 * Release an NSM handle
629 */
630void
631nsm_release(struct nsm_handle *nsm)
632{
633 if (!nsm)
634 return;
J. Bruce Fieldsd8421202008-02-20 15:40:15 -0500635 if (atomic_dec_and_lock(&nsm->sm_count, &nsm_lock)) {
J. Bruce Fields164f98a2008-02-20 14:02:47 -0500636 list_del(&nsm->sm_link);
J. Bruce Fieldsd8421202008-02-20 15:40:15 -0500637 spin_unlock(&nsm_lock);
J. Bruce Fields164f98a2008-02-20 14:02:47 -0500638 kfree(nsm);
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700639 }
640}