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