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

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

Version: ~ [ linux-5.10-rc5 ] ~ [ linux-5.9.10 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.79 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.159 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.208 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.245 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.245 ] ~ [ 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 /*
  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>
 12 #include <linux/slab.h>
 13 #include <linux/in.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/mutex.h>
 19 
 20 #include <net/ipv6.h>
 21 
 22 #define NLMDBG_FACILITY         NLMDBG_HOSTCACHE
 23 #define NLM_HOST_NRHASH         32
 24 #define NLM_HOST_REBIND         (60 * HZ)
 25 #define NLM_HOST_EXPIRE         (300 * HZ)
 26 #define NLM_HOST_COLLECT        (120 * HZ)
 27 
 28 static struct hlist_head        nlm_hosts[NLM_HOST_NRHASH];
 29 static unsigned long            next_gc;
 30 static int                      nrhosts;
 31 static DEFINE_MUTEX(nlm_host_mutex);
 32 
 33 static void                     nlm_gc_hosts(void);
 34 
 35 struct nlm_lookup_host_info {
 36         const int               server;         /* search for server|client */
 37         const struct sockaddr   *sap;           /* address to search for */
 38         const size_t            salen;          /* it's length */
 39         const unsigned short    protocol;       /* transport to search for*/
 40         const u32               version;        /* NLM version to search for */
 41         const char              *hostname;      /* remote's hostname */
 42         const size_t            hostname_len;   /* it's length */
 43         const struct sockaddr   *src_sap;       /* our address (optional) */
 44         const size_t            src_len;        /* it's length */
 45         const int               noresvport;     /* use non-priv port */
 46 };
 47 
 48 /*
 49  * Hash function must work well on big- and little-endian platforms
 50  */
 51 static unsigned int __nlm_hash32(const __be32 n)
 52 {
 53         unsigned int hash = (__force u32)n ^ ((__force u32)n >> 16);
 54         return hash ^ (hash >> 8);
 55 }
 56 
 57 static unsigned int __nlm_hash_addr4(const struct sockaddr *sap)
 58 {
 59         const struct sockaddr_in *sin = (struct sockaddr_in *)sap;
 60         return __nlm_hash32(sin->sin_addr.s_addr);
 61 }
 62 
 63 static unsigned int __nlm_hash_addr6(const struct sockaddr *sap)
 64 {
 65         const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
 66         const struct in6_addr addr = sin6->sin6_addr;
 67         return __nlm_hash32(addr.s6_addr32[0]) ^
 68                __nlm_hash32(addr.s6_addr32[1]) ^
 69                __nlm_hash32(addr.s6_addr32[2]) ^
 70                __nlm_hash32(addr.s6_addr32[3]);
 71 }
 72 
 73 static unsigned int nlm_hash_address(const struct sockaddr *sap)
 74 {
 75         unsigned int hash;
 76 
 77         switch (sap->sa_family) {
 78         case AF_INET:
 79                 hash = __nlm_hash_addr4(sap);
 80                 break;
 81         case AF_INET6:
 82                 hash = __nlm_hash_addr6(sap);
 83                 break;
 84         default:
 85                 hash = 0;
 86         }
 87         return hash & (NLM_HOST_NRHASH - 1);
 88 }
 89 
 90 /*
 91  * Common host lookup routine for server & client
 92  */
 93 static struct nlm_host *nlm_lookup_host(struct nlm_lookup_host_info *ni)
 94 {
 95         struct hlist_head *chain;
 96         struct hlist_node *pos;
 97         struct nlm_host *host;
 98         struct nsm_handle *nsm = NULL;
 99 
100         mutex_lock(&nlm_host_mutex);
101 
102         if (time_after_eq(jiffies, next_gc))
103                 nlm_gc_hosts();
104 
105         /* We may keep several nlm_host objects for a peer, because each
106          * nlm_host is identified by
107          * (address, protocol, version, server/client)
108          * We could probably simplify this a little by putting all those
109          * different NLM rpc_clients into one single nlm_host object.
110          * This would allow us to have one nlm_host per address.
111          */
112         chain = &nlm_hosts[nlm_hash_address(ni->sap)];
113         hlist_for_each_entry(host, pos, chain, h_hash) {
114                 if (!rpc_cmp_addr(nlm_addr(host), ni->sap))
115                         continue;
116 
117                 /* See if we have an NSM handle for this client */
118                 if (!nsm)
119                         nsm = host->h_nsmhandle;
120 
121                 if (host->h_proto != ni->protocol)
122                         continue;
123                 if (host->h_version != ni->version)
124                         continue;
125                 if (host->h_server != ni->server)
126                         continue;
127                 if (ni->server &&
128                     !rpc_cmp_addr(nlm_srcaddr(host), ni->src_sap))
129                         continue;
130 
131                 /* Move to head of hash chain. */
132                 hlist_del(&host->h_hash);
133                 hlist_add_head(&host->h_hash, chain);
134 
135                 nlm_get_host(host);
136                 dprintk("lockd: nlm_lookup_host found host %s (%s)\n",
137                                 host->h_name, host->h_addrbuf);
138                 goto out;
139         }
140 
141         /*
142          * The host wasn't in our hash table.  If we don't
143          * have an NSM handle for it yet, create one.
144          */
145         if (nsm)
146                 atomic_inc(&nsm->sm_count);
147         else {
148                 host = NULL;
149                 nsm = nsm_get_handle(ni->sap, ni->salen,
150                                         ni->hostname, ni->hostname_len);
151                 if (!nsm) {
152                         dprintk("lockd: nlm_lookup_host failed; "
153                                 "no nsm handle\n");
154                         goto out;
155                 }
156         }
157 
158         host = kzalloc(sizeof(*host), GFP_KERNEL);
159         if (!host) {
160                 nsm_release(nsm);
161                 dprintk("lockd: nlm_lookup_host failed; no memory\n");
162                 goto out;
163         }
164         host->h_name       = nsm->sm_name;
165         host->h_addrbuf    = nsm->sm_addrbuf;
166         memcpy(nlm_addr(host), ni->sap, ni->salen);
167         host->h_addrlen = ni->salen;
168         rpc_set_port(nlm_addr(host), 0);
169         memcpy(nlm_srcaddr(host), ni->src_sap, ni->src_len);
170         host->h_version    = ni->version;
171         host->h_proto      = ni->protocol;
172         host->h_rpcclnt    = NULL;
173         mutex_init(&host->h_mutex);
174         host->h_nextrebind = jiffies + NLM_HOST_REBIND;
175         host->h_expires    = jiffies + NLM_HOST_EXPIRE;
176         atomic_set(&host->h_count, 1);
177         init_waitqueue_head(&host->h_gracewait);
178         init_rwsem(&host->h_rwsem);
179         host->h_state      = 0;                 /* pseudo NSM state */
180         host->h_nsmstate   = 0;                 /* real NSM state */
181         host->h_nsmhandle  = nsm;
182         host->h_server     = ni->server;
183         host->h_noresvport = ni->noresvport;
184         hlist_add_head(&host->h_hash, chain);
185         INIT_LIST_HEAD(&host->h_lockowners);
186         spin_lock_init(&host->h_lock);
187         INIT_LIST_HEAD(&host->h_granted);
188         INIT_LIST_HEAD(&host->h_reclaim);
189 
190         nrhosts++;
191 
192         dprintk("lockd: nlm_lookup_host created host %s\n",
193                         host->h_name);
194 
195 out:
196         mutex_unlock(&nlm_host_mutex);
197         return host;
198 }
199 
200 /*
201  * Destroy a host
202  */
203 static void
204 nlm_destroy_host(struct nlm_host *host)
205 {
206         struct rpc_clnt *clnt;
207 
208         BUG_ON(!list_empty(&host->h_lockowners));
209         BUG_ON(atomic_read(&host->h_count));
210 
211         nsm_unmonitor(host);
212         nsm_release(host->h_nsmhandle);
213 
214         clnt = host->h_rpcclnt;
215         if (clnt != NULL)
216                 rpc_shutdown_client(clnt);
217         kfree(host);
218 }
219 
220 /**
221  * nlmclnt_lookup_host - Find an NLM host handle matching a remote server
222  * @sap: network address of server
223  * @salen: length of server address
224  * @protocol: transport protocol to use
225  * @version: NLM protocol version
226  * @hostname: '\0'-terminated hostname of server
227  * @noresvport: 1 if non-privileged port should be used
228  *
229  * Returns an nlm_host structure that matches the passed-in
230  * [server address, transport protocol, NLM version, server hostname].
231  * If one doesn't already exist in the host cache, a new handle is
232  * created and returned.
233  */
234 struct nlm_host *nlmclnt_lookup_host(const struct sockaddr *sap,
235                                      const size_t salen,
236                                      const unsigned short protocol,
237                                      const u32 version,
238                                      const char *hostname,
239                                      int noresvport)
240 {
241         const struct sockaddr source = {
242                 .sa_family      = AF_UNSPEC,
243         };
244         struct nlm_lookup_host_info ni = {
245                 .server         = 0,
246                 .sap            = sap,
247                 .salen          = salen,
248                 .protocol       = protocol,
249                 .version        = version,
250                 .hostname       = hostname,
251                 .hostname_len   = strlen(hostname),
252                 .src_sap        = &source,
253                 .src_len        = sizeof(source),
254                 .noresvport     = noresvport,
255         };
256 
257         dprintk("lockd: %s(host='%s', vers=%u, proto=%s)\n", __func__,
258                         (hostname ? hostname : "<none>"), version,
259                         (protocol == IPPROTO_UDP ? "udp" : "tcp"));
260 
261         return nlm_lookup_host(&ni);
262 }
263 
264 /**
265  * nlmsvc_lookup_host - Find an NLM host handle matching a remote client
266  * @rqstp: incoming NLM request
267  * @hostname: name of client host
268  * @hostname_len: length of client hostname
269  *
270  * Returns an nlm_host structure that matches the [client address,
271  * transport protocol, NLM version, client hostname] of the passed-in
272  * NLM request.  If one doesn't already exist in the host cache, a
273  * new handle is created and returned.
274  *
275  * Before possibly creating a new nlm_host, construct a sockaddr
276  * for a specific source address in case the local system has
277  * multiple network addresses.  The family of the address in
278  * rq_daddr is guaranteed to be the same as the family of the
279  * address in rq_addr, so it's safe to use the same family for
280  * the source address.
281  */
282 struct nlm_host *nlmsvc_lookup_host(const struct svc_rqst *rqstp,
283                                     const char *hostname,
284                                     const size_t hostname_len)
285 {
286         struct sockaddr_in sin = {
287                 .sin_family     = AF_INET,
288         };
289         struct sockaddr_in6 sin6 = {
290                 .sin6_family    = AF_INET6,
291         };
292         struct nlm_lookup_host_info ni = {
293                 .server         = 1,
294                 .sap            = svc_addr(rqstp),
295                 .salen          = rqstp->rq_addrlen,
296                 .protocol       = rqstp->rq_prot,
297                 .version        = rqstp->rq_vers,
298                 .hostname       = hostname,
299                 .hostname_len   = hostname_len,
300                 .src_len        = rqstp->rq_addrlen,
301         };
302 
303         dprintk("lockd: %s(host='%*s', vers=%u, proto=%s)\n", __func__,
304                         (int)hostname_len, hostname, rqstp->rq_vers,
305                         (rqstp->rq_prot == IPPROTO_UDP ? "udp" : "tcp"));
306 
307         switch (ni.sap->sa_family) {
308         case AF_INET:
309                 sin.sin_addr.s_addr = rqstp->rq_daddr.addr.s_addr;
310                 ni.src_sap = (struct sockaddr *)&sin;
311                 break;
312         case AF_INET6:
313                 ipv6_addr_copy(&sin6.sin6_addr, &rqstp->rq_daddr.addr6);
314                 ni.src_sap = (struct sockaddr *)&sin6;
315                 break;
316         default:
317                 return NULL;
318         }
319 
320         return nlm_lookup_host(&ni);
321 }
322 
323 /*
324  * Create the NLM RPC client for an NLM peer
325  */
326 struct rpc_clnt *
327 nlm_bind_host(struct nlm_host *host)
328 {
329         struct rpc_clnt *clnt;
330 
331         dprintk("lockd: nlm_bind_host %s (%s)\n",
332                         host->h_name, host->h_addrbuf);
333 
334         /* Lock host handle */
335         mutex_lock(&host->h_mutex);
336 
337         /* If we've already created an RPC client, check whether
338          * RPC rebind is required
339          */
340         if ((clnt = host->h_rpcclnt) != NULL) {
341                 if (time_after_eq(jiffies, host->h_nextrebind)) {
342                         rpc_force_rebind(clnt);
343                         host->h_nextrebind = jiffies + NLM_HOST_REBIND;
344                         dprintk("lockd: next rebind in %lu jiffies\n",
345                                         host->h_nextrebind - jiffies);
346                 }
347         } else {
348                 unsigned long increment = nlmsvc_timeout;
349                 struct rpc_timeout timeparms = {
350                         .to_initval     = increment,
351                         .to_increment   = increment,
352                         .to_maxval      = increment * 6UL,
353                         .to_retries     = 5U,
354                 };
355                 struct rpc_create_args args = {
356                         .protocol       = host->h_proto,
357                         .address        = nlm_addr(host),
358                         .addrsize       = host->h_addrlen,
359                         .saddress       = nlm_srcaddr(host),
360                         .timeout        = &timeparms,
361                         .servername     = host->h_name,
362                         .program        = &nlm_program,
363                         .version        = host->h_version,
364                         .authflavor     = RPC_AUTH_UNIX,
365                         .flags          = (RPC_CLNT_CREATE_NOPING |
366                                            RPC_CLNT_CREATE_AUTOBIND),
367                 };
368 
369                 /*
370                  * lockd retries server side blocks automatically so we want
371                  * those to be soft RPC calls. Client side calls need to be
372                  * hard RPC tasks.
373                  */
374                 if (!host->h_server)
375                         args.flags |= RPC_CLNT_CREATE_HARDRTRY;
376                 if (host->h_noresvport)
377                         args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
378 
379                 clnt = rpc_create(&args);
380                 if (!IS_ERR(clnt))
381                         host->h_rpcclnt = clnt;
382                 else {
383                         printk("lockd: couldn't create RPC handle for %s\n", host->h_name);
384                         clnt = NULL;
385                 }
386         }
387 
388         mutex_unlock(&host->h_mutex);
389         return clnt;
390 }
391 
392 /*
393  * Force a portmap lookup of the remote lockd port
394  */
395 void
396 nlm_rebind_host(struct nlm_host *host)
397 {
398         dprintk("lockd: rebind host %s\n", host->h_name);
399         if (host->h_rpcclnt && time_after_eq(jiffies, host->h_nextrebind)) {
400                 rpc_force_rebind(host->h_rpcclnt);
401                 host->h_nextrebind = jiffies + NLM_HOST_REBIND;
402         }
403 }
404 
405 /*
406  * Increment NLM host count
407  */
408 struct nlm_host * nlm_get_host(struct nlm_host *host)
409 {
410         if (host) {
411                 dprintk("lockd: get host %s\n", host->h_name);
412                 atomic_inc(&host->h_count);
413                 host->h_expires = jiffies + NLM_HOST_EXPIRE;
414         }
415         return host;
416 }
417 
418 /*
419  * Release NLM host after use
420  */
421 void nlm_release_host(struct nlm_host *host)
422 {
423         if (host != NULL) {
424                 dprintk("lockd: release host %s\n", host->h_name);
425                 BUG_ON(atomic_read(&host->h_count) < 0);
426                 if (atomic_dec_and_test(&host->h_count)) {
427                         BUG_ON(!list_empty(&host->h_lockowners));
428                         BUG_ON(!list_empty(&host->h_granted));
429                         BUG_ON(!list_empty(&host->h_reclaim));
430                 }
431         }
432 }
433 
434 /**
435  * nlm_host_rebooted - Release all resources held by rebooted host
436  * @info: pointer to decoded results of NLM_SM_NOTIFY call
437  *
438  * We were notified that the specified host has rebooted.  Release
439  * all resources held by that peer.
440  */
441 void nlm_host_rebooted(const struct nlm_reboot *info)
442 {
443         struct hlist_head *chain;
444         struct hlist_node *pos;
445         struct nsm_handle *nsm;
446         struct nlm_host *host;
447 
448         nsm = nsm_reboot_lookup(info);
449         if (unlikely(nsm == NULL))
450                 return;
451 
452         /* Mark all hosts tied to this NSM state as having rebooted.
453          * We run the loop repeatedly, because we drop the host table
454          * lock for this.
455          * To avoid processing a host several times, we match the nsmstate.
456          */
457 again:  mutex_lock(&nlm_host_mutex);
458         for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
459                 hlist_for_each_entry(host, pos, chain, h_hash) {
460                         if (host->h_nsmhandle == nsm
461                          && host->h_nsmstate != info->state) {
462                                 host->h_nsmstate = info->state;
463                                 host->h_state++;
464 
465                                 nlm_get_host(host);
466                                 mutex_unlock(&nlm_host_mutex);
467 
468                                 if (host->h_server) {
469                                         /* We're server for this guy, just ditch
470                                          * all the locks he held. */
471                                         nlmsvc_free_host_resources(host);
472                                 } else {
473                                         /* He's the server, initiate lock recovery. */
474                                         nlmclnt_recovery(host);
475                                 }
476 
477                                 nlm_release_host(host);
478                                 goto again;
479                         }
480                 }
481         }
482 
483         mutex_unlock(&nlm_host_mutex);
484 }
485 
486 /*
487  * Shut down the hosts module.
488  * Note that this routine is called only at server shutdown time.
489  */
490 void
491 nlm_shutdown_hosts(void)
492 {
493         struct hlist_head *chain;
494         struct hlist_node *pos;
495         struct nlm_host *host;
496 
497         dprintk("lockd: shutting down host module\n");
498         mutex_lock(&nlm_host_mutex);
499 
500         /* First, make all hosts eligible for gc */
501         dprintk("lockd: nuking all hosts...\n");
502         for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
503                 hlist_for_each_entry(host, pos, chain, h_hash) {
504                         host->h_expires = jiffies - 1;
505                         if (host->h_rpcclnt) {
506                                 rpc_shutdown_client(host->h_rpcclnt);
507                                 host->h_rpcclnt = NULL;
508                         }
509                 }
510         }
511 
512         /* Then, perform a garbage collection pass */
513         nlm_gc_hosts();
514         mutex_unlock(&nlm_host_mutex);
515 
516         /* complain if any hosts are left */
517         if (nrhosts) {
518                 printk(KERN_WARNING "lockd: couldn't shutdown host module!\n");
519                 dprintk("lockd: %d hosts left:\n", nrhosts);
520                 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
521                         hlist_for_each_entry(host, pos, chain, h_hash) {
522                                 dprintk("       %s (cnt %d use %d exp %ld)\n",
523                                         host->h_name, atomic_read(&host->h_count),
524                                         host->h_inuse, host->h_expires);
525                         }
526                 }
527         }
528 }
529 
530 /*
531  * Garbage collect any unused NLM hosts.
532  * This GC combines reference counting for async operations with
533  * mark & sweep for resources held by remote clients.
534  */
535 static void
536 nlm_gc_hosts(void)
537 {
538         struct hlist_head *chain;
539         struct hlist_node *pos, *next;
540         struct nlm_host *host;
541 
542         dprintk("lockd: host garbage collection\n");
543         for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
544                 hlist_for_each_entry(host, pos, chain, h_hash)
545                         host->h_inuse = 0;
546         }
547 
548         /* Mark all hosts that hold locks, blocks or shares */
549         nlmsvc_mark_resources();
550 
551         for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
552                 hlist_for_each_entry_safe(host, pos, next, chain, h_hash) {
553                         if (atomic_read(&host->h_count) || host->h_inuse
554                          || time_before(jiffies, host->h_expires)) {
555                                 dprintk("nlm_gc_hosts skipping %s (cnt %d use %d exp %ld)\n",
556                                         host->h_name, atomic_read(&host->h_count),
557                                         host->h_inuse, host->h_expires);
558                                 continue;
559                         }
560                         dprintk("lockd: delete host %s\n", host->h_name);
561                         hlist_del_init(&host->h_hash);
562 
563                         nlm_destroy_host(host);
564                         nrhosts--;
565                 }
566         }
567 
568         next_gc = jiffies + NLM_HOST_COLLECT;
569 }
570 

~ [ 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