~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/lockd/host.c

Version: ~ [ linux-5.10-rc1 ] ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp