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