Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * linux/fs/lockd/host.c
4 : : *
5 : : * Management for NLM peer hosts. The nlm_host struct is shared
6 : : * between client and server implementation. The only reason to
7 : : * do so is to reduce code bloat.
8 : : *
9 : : * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
10 : : */
11 : :
12 : : #include <linux/types.h>
13 : : #include <linux/slab.h>
14 : : #include <linux/in.h>
15 : : #include <linux/in6.h>
16 : : #include <linux/sunrpc/clnt.h>
17 : : #include <linux/sunrpc/addr.h>
18 : : #include <linux/sunrpc/svc.h>
19 : : #include <linux/lockd/lockd.h>
20 : : #include <linux/mutex.h>
21 : :
22 : : #include <linux/sunrpc/svc_xprt.h>
23 : :
24 : : #include <net/ipv6.h>
25 : :
26 : : #include "netns.h"
27 : :
28 : : #define NLMDBG_FACILITY NLMDBG_HOSTCACHE
29 : : #define NLM_HOST_NRHASH 32
30 : : #define NLM_HOST_REBIND (60 * HZ)
31 : : #define NLM_HOST_EXPIRE (300 * HZ)
32 : : #define NLM_HOST_COLLECT (120 * HZ)
33 : :
34 : : static struct hlist_head nlm_server_hosts[NLM_HOST_NRHASH];
35 : : static struct hlist_head nlm_client_hosts[NLM_HOST_NRHASH];
36 : :
37 : : #define for_each_host(host, chain, table) \
38 : : for ((chain) = (table); \
39 : : (chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
40 : : hlist_for_each_entry((host), (chain), h_hash)
41 : :
42 : : #define for_each_host_safe(host, next, chain, table) \
43 : : for ((chain) = (table); \
44 : : (chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
45 : : hlist_for_each_entry_safe((host), (next), \
46 : : (chain), h_hash)
47 : :
48 : : static unsigned long nrhosts;
49 : : static DEFINE_MUTEX(nlm_host_mutex);
50 : :
51 : : static void nlm_gc_hosts(struct net *net);
52 : :
53 : : struct nlm_lookup_host_info {
54 : : const int server; /* search for server|client */
55 : : const struct sockaddr *sap; /* address to search for */
56 : : const size_t salen; /* it's length */
57 : : const unsigned short protocol; /* transport to search for*/
58 : : const u32 version; /* NLM version to search for */
59 : : const char *hostname; /* remote's hostname */
60 : : const size_t hostname_len; /* it's length */
61 : : const int noresvport; /* use non-priv port */
62 : : struct net *net; /* network namespace to bind */
63 : : const struct cred *cred;
64 : : };
65 : :
66 : : /*
67 : : * Hash function must work well on big- and little-endian platforms
68 : : */
69 : : static unsigned int __nlm_hash32(const __be32 n)
70 : : {
71 : 0 : unsigned int hash = (__force u32)n ^ ((__force u32)n >> 16);
72 : 0 : return hash ^ (hash >> 8);
73 : : }
74 : :
75 : : static unsigned int __nlm_hash_addr4(const struct sockaddr *sap)
76 : : {
77 : : const struct sockaddr_in *sin = (struct sockaddr_in *)sap;
78 : 0 : return __nlm_hash32(sin->sin_addr.s_addr);
79 : : }
80 : :
81 : 0 : static unsigned int __nlm_hash_addr6(const struct sockaddr *sap)
82 : : {
83 : : const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
84 : 0 : const struct in6_addr addr = sin6->sin6_addr;
85 : 0 : return __nlm_hash32(addr.s6_addr32[0]) ^
86 : 0 : __nlm_hash32(addr.s6_addr32[1]) ^
87 : : __nlm_hash32(addr.s6_addr32[2]) ^
88 : : __nlm_hash32(addr.s6_addr32[3]);
89 : : }
90 : :
91 : 0 : static unsigned int nlm_hash_address(const struct sockaddr *sap)
92 : : {
93 : : unsigned int hash;
94 : :
95 : 0 : switch (sap->sa_family) {
96 : : case AF_INET:
97 : : hash = __nlm_hash_addr4(sap);
98 : 0 : break;
99 : : case AF_INET6:
100 : 0 : hash = __nlm_hash_addr6(sap);
101 : 0 : break;
102 : : default:
103 : : hash = 0;
104 : : }
105 : 0 : return hash & (NLM_HOST_NRHASH - 1);
106 : : }
107 : :
108 : : /*
109 : : * Allocate and initialize an nlm_host. Common to both client and server.
110 : : */
111 : 0 : static struct nlm_host *nlm_alloc_host(struct nlm_lookup_host_info *ni,
112 : : struct nsm_handle *nsm)
113 : : {
114 : : struct nlm_host *host = NULL;
115 : 0 : unsigned long now = jiffies;
116 : :
117 : 0 : if (nsm != NULL)
118 : 0 : refcount_inc(&nsm->sm_count);
119 : : else {
120 : : host = NULL;
121 : 0 : nsm = nsm_get_handle(ni->net, ni->sap, ni->salen,
122 : : ni->hostname, ni->hostname_len);
123 : 0 : if (unlikely(nsm == NULL)) {
124 : : dprintk("lockd: %s failed; no nsm handle\n",
125 : : __func__);
126 : : goto out;
127 : : }
128 : : }
129 : :
130 : : host = kmalloc(sizeof(*host), GFP_KERNEL);
131 : 0 : if (unlikely(host == NULL)) {
132 : : dprintk("lockd: %s failed; no memory\n", __func__);
133 : 0 : nsm_release(nsm);
134 : 0 : goto out;
135 : : }
136 : :
137 : 0 : memcpy(nlm_addr(host), ni->sap, ni->salen);
138 : 0 : host->h_addrlen = ni->salen;
139 : : rpc_set_port(nlm_addr(host), 0);
140 : 0 : host->h_srcaddrlen = 0;
141 : :
142 : 0 : host->h_rpcclnt = NULL;
143 : 0 : host->h_name = nsm->sm_name;
144 : 0 : host->h_version = ni->version;
145 : 0 : host->h_proto = ni->protocol;
146 : 0 : host->h_reclaiming = 0;
147 : 0 : host->h_server = ni->server;
148 : 0 : host->h_noresvport = ni->noresvport;
149 : 0 : host->h_inuse = 0;
150 : 0 : init_waitqueue_head(&host->h_gracewait);
151 : 0 : init_rwsem(&host->h_rwsem);
152 : 0 : host->h_state = 0;
153 : 0 : host->h_nsmstate = 0;
154 : 0 : host->h_pidcount = 0;
155 : : refcount_set(&host->h_count, 1);
156 : 0 : mutex_init(&host->h_mutex);
157 : 0 : host->h_nextrebind = now + NLM_HOST_REBIND;
158 : 0 : host->h_expires = now + NLM_HOST_EXPIRE;
159 : 0 : INIT_LIST_HEAD(&host->h_lockowners);
160 : 0 : spin_lock_init(&host->h_lock);
161 : 0 : INIT_LIST_HEAD(&host->h_granted);
162 : 0 : INIT_LIST_HEAD(&host->h_reclaim);
163 : 0 : host->h_nsmhandle = nsm;
164 : 0 : host->h_addrbuf = nsm->sm_addrbuf;
165 : 0 : host->net = ni->net;
166 : 0 : host->h_cred = get_cred(ni->cred),
167 : 0 : strlcpy(host->nodename, utsname()->nodename, sizeof(host->nodename));
168 : :
169 : : out:
170 : 0 : return host;
171 : : }
172 : :
173 : : /*
174 : : * Destroy an nlm_host and free associated resources
175 : : *
176 : : * Caller must hold nlm_host_mutex.
177 : : */
178 : 0 : static void nlm_destroy_host_locked(struct nlm_host *host)
179 : : {
180 : : struct rpc_clnt *clnt;
181 : 0 : struct lockd_net *ln = net_generic(host->net, lockd_net_id);
182 : :
183 : : dprintk("lockd: destroy host %s\n", host->h_name);
184 : :
185 : : hlist_del_init(&host->h_hash);
186 : :
187 : 0 : nsm_unmonitor(host);
188 : 0 : nsm_release(host->h_nsmhandle);
189 : :
190 : 0 : clnt = host->h_rpcclnt;
191 : 0 : if (clnt != NULL)
192 : 0 : rpc_shutdown_client(clnt);
193 : 0 : put_cred(host->h_cred);
194 : 0 : kfree(host);
195 : :
196 : 0 : ln->nrhosts--;
197 : 0 : nrhosts--;
198 : 0 : }
199 : :
200 : : /**
201 : : * nlmclnt_lookup_host - Find an NLM host handle matching a remote server
202 : : * @sap: network address of server
203 : : * @salen: length of server address
204 : : * @protocol: transport protocol to use
205 : : * @version: NLM protocol version
206 : : * @hostname: '\0'-terminated hostname of server
207 : : * @noresvport: 1 if non-privileged port should be used
208 : : * @net: pointer to net namespace
209 : : * @cred: pointer to cred
210 : : *
211 : : * Returns an nlm_host structure that matches the passed-in
212 : : * [server address, transport protocol, NLM version, server hostname].
213 : : * If one doesn't already exist in the host cache, a new handle is
214 : : * created and returned.
215 : : */
216 : 0 : struct nlm_host *nlmclnt_lookup_host(const struct sockaddr *sap,
217 : : const size_t salen,
218 : : const unsigned short protocol,
219 : : const u32 version,
220 : : const char *hostname,
221 : : int noresvport,
222 : : struct net *net,
223 : : const struct cred *cred)
224 : : {
225 : 0 : struct nlm_lookup_host_info ni = {
226 : : .server = 0,
227 : : .sap = sap,
228 : : .salen = salen,
229 : : .protocol = protocol,
230 : : .version = version,
231 : : .hostname = hostname,
232 : 0 : .hostname_len = strlen(hostname),
233 : : .noresvport = noresvport,
234 : : .net = net,
235 : : .cred = cred,
236 : : };
237 : : struct hlist_head *chain;
238 : : struct nlm_host *host;
239 : : struct nsm_handle *nsm = NULL;
240 : 0 : struct lockd_net *ln = net_generic(net, lockd_net_id);
241 : :
242 : : dprintk("lockd: %s(host='%s', vers=%u, proto=%s)\n", __func__,
243 : : (hostname ? hostname : "<none>"), version,
244 : : (protocol == IPPROTO_UDP ? "udp" : "tcp"));
245 : :
246 : 0 : mutex_lock(&nlm_host_mutex);
247 : :
248 : 0 : chain = &nlm_client_hosts[nlm_hash_address(sap)];
249 : 0 : hlist_for_each_entry(host, chain, h_hash) {
250 : 0 : if (host->net != net)
251 : 0 : continue;
252 : 0 : if (!rpc_cmp_addr(nlm_addr(host), sap))
253 : 0 : continue;
254 : :
255 : : /* Same address. Share an NSM handle if we already have one */
256 : 0 : if (nsm == NULL)
257 : 0 : nsm = host->h_nsmhandle;
258 : :
259 : 0 : if (host->h_proto != protocol)
260 : 0 : continue;
261 : 0 : if (host->h_version != version)
262 : 0 : continue;
263 : :
264 : : nlm_get_host(host);
265 : : dprintk("lockd: %s found host %s (%s)\n", __func__,
266 : : host->h_name, host->h_addrbuf);
267 : : goto out;
268 : : }
269 : :
270 : 0 : host = nlm_alloc_host(&ni, nsm);
271 : 0 : if (unlikely(host == NULL))
272 : : goto out;
273 : :
274 : 0 : hlist_add_head(&host->h_hash, chain);
275 : 0 : ln->nrhosts++;
276 : 0 : nrhosts++;
277 : :
278 : : dprintk("lockd: %s created host %s (%s)\n", __func__,
279 : : host->h_name, host->h_addrbuf);
280 : :
281 : : out:
282 : 0 : mutex_unlock(&nlm_host_mutex);
283 : 0 : return host;
284 : : }
285 : :
286 : : /**
287 : : * nlmclnt_release_host - release client nlm_host
288 : : * @host: nlm_host to release
289 : : *
290 : : */
291 : 0 : void nlmclnt_release_host(struct nlm_host *host)
292 : : {
293 : 0 : if (host == NULL)
294 : 0 : return;
295 : :
296 : : dprintk("lockd: release client host %s\n", host->h_name);
297 : :
298 : 0 : WARN_ON_ONCE(host->h_server);
299 : :
300 : 0 : if (refcount_dec_and_mutex_lock(&host->h_count, &nlm_host_mutex)) {
301 : 0 : WARN_ON_ONCE(!list_empty(&host->h_lockowners));
302 : 0 : WARN_ON_ONCE(!list_empty(&host->h_granted));
303 : 0 : WARN_ON_ONCE(!list_empty(&host->h_reclaim));
304 : :
305 : 0 : nlm_destroy_host_locked(host);
306 : 0 : mutex_unlock(&nlm_host_mutex);
307 : : }
308 : : }
309 : :
310 : : /**
311 : : * nlmsvc_lookup_host - Find an NLM host handle matching a remote client
312 : : * @rqstp: incoming NLM request
313 : : * @hostname: name of client host
314 : : * @hostname_len: length of client hostname
315 : : *
316 : : * Returns an nlm_host structure that matches the [client address,
317 : : * transport protocol, NLM version, client hostname] of the passed-in
318 : : * NLM request. If one doesn't already exist in the host cache, a
319 : : * new handle is created and returned.
320 : : *
321 : : * Before possibly creating a new nlm_host, construct a sockaddr
322 : : * for a specific source address in case the local system has
323 : : * multiple network addresses. The family of the address in
324 : : * rq_daddr is guaranteed to be the same as the family of the
325 : : * address in rq_addr, so it's safe to use the same family for
326 : : * the source address.
327 : : */
328 : 0 : struct nlm_host *nlmsvc_lookup_host(const struct svc_rqst *rqstp,
329 : : const char *hostname,
330 : : const size_t hostname_len)
331 : : {
332 : : struct hlist_head *chain;
333 : : struct nlm_host *host = NULL;
334 : : struct nsm_handle *nsm = NULL;
335 : : struct sockaddr *src_sap = svc_daddr(rqstp);
336 : : size_t src_len = rqstp->rq_daddrlen;
337 : 0 : struct net *net = SVC_NET(rqstp);
338 : 0 : struct nlm_lookup_host_info ni = {
339 : : .server = 1,
340 : : .sap = svc_addr(rqstp),
341 : 0 : .salen = rqstp->rq_addrlen,
342 : 0 : .protocol = rqstp->rq_prot,
343 : 0 : .version = rqstp->rq_vers,
344 : : .hostname = hostname,
345 : : .hostname_len = hostname_len,
346 : : .net = net,
347 : : };
348 : 0 : struct lockd_net *ln = net_generic(net, lockd_net_id);
349 : :
350 : : dprintk("lockd: %s(host='%.*s', vers=%u, proto=%s)\n", __func__,
351 : : (int)hostname_len, hostname, rqstp->rq_vers,
352 : : (rqstp->rq_prot == IPPROTO_UDP ? "udp" : "tcp"));
353 : :
354 : 0 : mutex_lock(&nlm_host_mutex);
355 : :
356 : 0 : if (time_after_eq(jiffies, ln->next_gc))
357 : 0 : nlm_gc_hosts(net);
358 : :
359 : 0 : chain = &nlm_server_hosts[nlm_hash_address(ni.sap)];
360 : 0 : hlist_for_each_entry(host, chain, h_hash) {
361 : 0 : if (host->net != net)
362 : 0 : continue;
363 : 0 : if (!rpc_cmp_addr(nlm_addr(host), ni.sap))
364 : 0 : continue;
365 : :
366 : : /* Same address. Share an NSM handle if we already have one */
367 : 0 : if (nsm == NULL)
368 : 0 : nsm = host->h_nsmhandle;
369 : :
370 : 0 : if (host->h_proto != ni.protocol)
371 : 0 : continue;
372 : 0 : if (host->h_version != ni.version)
373 : 0 : continue;
374 : 0 : if (!rpc_cmp_addr(nlm_srcaddr(host), src_sap))
375 : 0 : continue;
376 : :
377 : : /* Move to head of hash chain. */
378 : : hlist_del(&host->h_hash);
379 : 0 : hlist_add_head(&host->h_hash, chain);
380 : :
381 : : nlm_get_host(host);
382 : : dprintk("lockd: %s found host %s (%s)\n",
383 : : __func__, host->h_name, host->h_addrbuf);
384 : : goto out;
385 : : }
386 : :
387 : 0 : host = nlm_alloc_host(&ni, nsm);
388 : 0 : if (unlikely(host == NULL))
389 : : goto out;
390 : :
391 : 0 : memcpy(nlm_srcaddr(host), src_sap, src_len);
392 : 0 : host->h_srcaddrlen = src_len;
393 : 0 : hlist_add_head(&host->h_hash, chain);
394 : 0 : ln->nrhosts++;
395 : 0 : nrhosts++;
396 : :
397 : 0 : refcount_inc(&host->h_count);
398 : :
399 : : dprintk("lockd: %s created host %s (%s)\n",
400 : : __func__, host->h_name, host->h_addrbuf);
401 : :
402 : : out:
403 : 0 : mutex_unlock(&nlm_host_mutex);
404 : 0 : return host;
405 : : }
406 : :
407 : : /**
408 : : * nlmsvc_release_host - release server nlm_host
409 : : * @host: nlm_host to release
410 : : *
411 : : * Host is destroyed later in nlm_gc_host().
412 : : */
413 : 0 : void nlmsvc_release_host(struct nlm_host *host)
414 : : {
415 : 0 : if (host == NULL)
416 : 0 : return;
417 : :
418 : : dprintk("lockd: release server host %s\n", host->h_name);
419 : :
420 : 0 : WARN_ON_ONCE(!host->h_server);
421 : 0 : refcount_dec(&host->h_count);
422 : : }
423 : :
424 : : /*
425 : : * Create the NLM RPC client for an NLM peer
426 : : */
427 : : struct rpc_clnt *
428 : 0 : nlm_bind_host(struct nlm_host *host)
429 : : {
430 : : struct rpc_clnt *clnt;
431 : :
432 : : dprintk("lockd: nlm_bind_host %s (%s)\n",
433 : : host->h_name, host->h_addrbuf);
434 : :
435 : : /* Lock host handle */
436 : 0 : mutex_lock(&host->h_mutex);
437 : :
438 : : /* If we've already created an RPC client, check whether
439 : : * RPC rebind is required
440 : : */
441 : 0 : if ((clnt = host->h_rpcclnt) != NULL) {
442 : 0 : if (time_after_eq(jiffies, host->h_nextrebind)) {
443 : 0 : rpc_force_rebind(clnt);
444 : 0 : host->h_nextrebind = jiffies + NLM_HOST_REBIND;
445 : : dprintk("lockd: next rebind in %lu jiffies\n",
446 : : host->h_nextrebind - jiffies);
447 : : }
448 : : } else {
449 : 0 : unsigned long increment = nlmsvc_timeout;
450 : 0 : struct rpc_timeout timeparms = {
451 : : .to_initval = increment,
452 : : .to_increment = increment,
453 : 0 : .to_maxval = increment * 6UL,
454 : : .to_retries = 5U,
455 : : };
456 : 0 : struct rpc_create_args args = {
457 : 0 : .net = host->net,
458 : 0 : .protocol = host->h_proto,
459 : : .address = nlm_addr(host),
460 : 0 : .addrsize = host->h_addrlen,
461 : : .timeout = &timeparms,
462 : 0 : .servername = host->h_name,
463 : : .program = &nlm_program,
464 : 0 : .version = host->h_version,
465 : : .authflavor = RPC_AUTH_UNIX,
466 : : .flags = (RPC_CLNT_CREATE_NOPING |
467 : : RPC_CLNT_CREATE_AUTOBIND),
468 : 0 : .cred = host->h_cred,
469 : : };
470 : :
471 : : /*
472 : : * lockd retries server side blocks automatically so we want
473 : : * those to be soft RPC calls. Client side calls need to be
474 : : * hard RPC tasks.
475 : : */
476 : 0 : if (!host->h_server)
477 : 0 : args.flags |= RPC_CLNT_CREATE_HARDRTRY;
478 : 0 : if (host->h_noresvport)
479 : 0 : args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
480 : 0 : if (host->h_srcaddrlen)
481 : 0 : args.saddress = nlm_srcaddr(host);
482 : :
483 : 0 : clnt = rpc_create(&args);
484 : 0 : if (!IS_ERR(clnt))
485 : 0 : host->h_rpcclnt = clnt;
486 : : else {
487 : 0 : printk("lockd: couldn't create RPC handle for %s\n", host->h_name);
488 : : clnt = NULL;
489 : : }
490 : : }
491 : :
492 : 0 : mutex_unlock(&host->h_mutex);
493 : 0 : return clnt;
494 : : }
495 : :
496 : : /*
497 : : * Force a portmap lookup of the remote lockd port
498 : : */
499 : : void
500 : 0 : nlm_rebind_host(struct nlm_host *host)
501 : : {
502 : : dprintk("lockd: rebind host %s\n", host->h_name);
503 : 0 : if (host->h_rpcclnt && time_after_eq(jiffies, host->h_nextrebind)) {
504 : 0 : rpc_force_rebind(host->h_rpcclnt);
505 : 0 : host->h_nextrebind = jiffies + NLM_HOST_REBIND;
506 : : }
507 : 0 : }
508 : :
509 : : /*
510 : : * Increment NLM host count
511 : : */
512 : 0 : struct nlm_host * nlm_get_host(struct nlm_host *host)
513 : : {
514 : 0 : if (host) {
515 : : dprintk("lockd: get host %s\n", host->h_name);
516 : 0 : refcount_inc(&host->h_count);
517 : 0 : host->h_expires = jiffies + NLM_HOST_EXPIRE;
518 : : }
519 : 0 : return host;
520 : : }
521 : :
522 : 0 : static struct nlm_host *next_host_state(struct hlist_head *cache,
523 : : struct nsm_handle *nsm,
524 : : const struct nlm_reboot *info)
525 : : {
526 : : struct nlm_host *host;
527 : : struct hlist_head *chain;
528 : :
529 : 0 : mutex_lock(&nlm_host_mutex);
530 : 0 : for_each_host(host, chain, cache) {
531 : 0 : if (host->h_nsmhandle == nsm
532 : 0 : && host->h_nsmstate != info->state) {
533 : 0 : host->h_nsmstate = info->state;
534 : 0 : host->h_state++;
535 : :
536 : : nlm_get_host(host);
537 : 0 : mutex_unlock(&nlm_host_mutex);
538 : 0 : return host;
539 : : }
540 : : }
541 : :
542 : 0 : mutex_unlock(&nlm_host_mutex);
543 : 0 : return NULL;
544 : : }
545 : :
546 : : /**
547 : : * nlm_host_rebooted - Release all resources held by rebooted host
548 : : * @net: network namespace
549 : : * @info: pointer to decoded results of NLM_SM_NOTIFY call
550 : : *
551 : : * We were notified that the specified host has rebooted. Release
552 : : * all resources held by that peer.
553 : : */
554 : 0 : void nlm_host_rebooted(const struct net *net, const struct nlm_reboot *info)
555 : : {
556 : : struct nsm_handle *nsm;
557 : : struct nlm_host *host;
558 : :
559 : 0 : nsm = nsm_reboot_lookup(net, info);
560 : 0 : if (unlikely(nsm == NULL))
561 : 0 : return;
562 : :
563 : : /* Mark all hosts tied to this NSM state as having rebooted.
564 : : * We run the loop repeatedly, because we drop the host table
565 : : * lock for this.
566 : : * To avoid processing a host several times, we match the nsmstate.
567 : : */
568 : 0 : while ((host = next_host_state(nlm_server_hosts, nsm, info)) != NULL) {
569 : 0 : nlmsvc_free_host_resources(host);
570 : 0 : nlmsvc_release_host(host);
571 : : }
572 : 0 : while ((host = next_host_state(nlm_client_hosts, nsm, info)) != NULL) {
573 : 0 : nlmclnt_recovery(host);
574 : 0 : nlmclnt_release_host(host);
575 : : }
576 : :
577 : 0 : nsm_release(nsm);
578 : : }
579 : :
580 : 0 : static void nlm_complain_hosts(struct net *net)
581 : : {
582 : : struct hlist_head *chain;
583 : : struct nlm_host *host;
584 : :
585 : 0 : if (net) {
586 : 0 : struct lockd_net *ln = net_generic(net, lockd_net_id);
587 : :
588 : 0 : if (ln->nrhosts == 0)
589 : : return;
590 : 0 : pr_warn("lockd: couldn't shutdown host module for net %x!\n",
591 : : net->ns.inum);
592 : : dprintk("lockd: %lu hosts left in net %x:\n", ln->nrhosts,
593 : : net->ns.inum);
594 : : } else {
595 : 0 : if (nrhosts == 0)
596 : : return;
597 : 0 : printk(KERN_WARNING "lockd: couldn't shutdown host module!\n");
598 : : dprintk("lockd: %lu hosts left:\n", nrhosts);
599 : : }
600 : :
601 : 0 : for_each_host(host, chain, nlm_server_hosts) {
602 : : if (net && host->net != net)
603 : : continue;
604 : : dprintk(" %s (cnt %d use %d exp %ld net %x)\n",
605 : : host->h_name, refcount_read(&host->h_count),
606 : : host->h_inuse, host->h_expires, host->net->ns.inum);
607 : : }
608 : : }
609 : :
610 : : void
611 : 0 : nlm_shutdown_hosts_net(struct net *net)
612 : : {
613 : : struct hlist_head *chain;
614 : : struct nlm_host *host;
615 : :
616 : 0 : mutex_lock(&nlm_host_mutex);
617 : :
618 : : /* First, make all hosts eligible for gc */
619 : : dprintk("lockd: nuking all hosts in net %x...\n",
620 : : net ? net->ns.inum : 0);
621 : 0 : for_each_host(host, chain, nlm_server_hosts) {
622 : 0 : if (net && host->net != net)
623 : 0 : continue;
624 : 0 : host->h_expires = jiffies - 1;
625 : 0 : if (host->h_rpcclnt) {
626 : 0 : rpc_shutdown_client(host->h_rpcclnt);
627 : 0 : host->h_rpcclnt = NULL;
628 : : }
629 : : }
630 : :
631 : : /* Then, perform a garbage collection pass */
632 : 0 : nlm_gc_hosts(net);
633 : 0 : nlm_complain_hosts(net);
634 : 0 : mutex_unlock(&nlm_host_mutex);
635 : 0 : }
636 : :
637 : : /*
638 : : * Shut down the hosts module.
639 : : * Note that this routine is called only at server shutdown time.
640 : : */
641 : : void
642 : 0 : nlm_shutdown_hosts(void)
643 : : {
644 : : dprintk("lockd: shutting down host module\n");
645 : 0 : nlm_shutdown_hosts_net(NULL);
646 : 0 : }
647 : :
648 : : /*
649 : : * Garbage collect any unused NLM hosts.
650 : : * This GC combines reference counting for async operations with
651 : : * mark & sweep for resources held by remote clients.
652 : : */
653 : : static void
654 : 0 : nlm_gc_hosts(struct net *net)
655 : : {
656 : : struct hlist_head *chain;
657 : : struct hlist_node *next;
658 : : struct nlm_host *host;
659 : :
660 : : dprintk("lockd: host garbage collection for net %x\n",
661 : : net ? net->ns.inum : 0);
662 : 0 : for_each_host(host, chain, nlm_server_hosts) {
663 : 0 : if (net && host->net != net)
664 : 0 : continue;
665 : 0 : host->h_inuse = 0;
666 : : }
667 : :
668 : : /* Mark all hosts that hold locks, blocks or shares */
669 : 0 : nlmsvc_mark_resources(net);
670 : :
671 : 0 : for_each_host_safe(host, next, chain, nlm_server_hosts) {
672 : 0 : if (net && host->net != net)
673 : 0 : continue;
674 : 0 : if (host->h_inuse || time_before(jiffies, host->h_expires)) {
675 : : dprintk("nlm_gc_hosts skipping %s "
676 : : "(cnt %d use %d exp %ld net %x)\n",
677 : : host->h_name, refcount_read(&host->h_count),
678 : : host->h_inuse, host->h_expires,
679 : : host->net->ns.inum);
680 : 0 : continue;
681 : : }
682 : 0 : if (refcount_dec_if_one(&host->h_count))
683 : 0 : nlm_destroy_host_locked(host);
684 : : }
685 : :
686 : 0 : if (net) {
687 : 0 : struct lockd_net *ln = net_generic(net, lockd_net_id);
688 : :
689 : 0 : ln->next_gc = jiffies + NLM_HOST_COLLECT;
690 : : }
691 : 0 : }
|
