Pull remove-hotkey into release branch
[linux-2.6] / 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/sunrpc/clnt.h>
15 #include <linux/sunrpc/svc.h>
16 #include <linux/lockd/lockd.h>
17 #include <linux/lockd/sm_inter.h>
18 #include <linux/mutex.h>
19
20
21 #define NLMDBG_FACILITY         NLMDBG_HOSTCACHE
22 #define NLM_HOST_MAX            64
23 #define NLM_HOST_NRHASH         32
24 #define NLM_ADDRHASH(addr)      (ntohl(addr) & (NLM_HOST_NRHASH-1))
25 #define NLM_HOST_REBIND         (60 * HZ)
26 #define NLM_HOST_EXPIRE         ((nrhosts > NLM_HOST_MAX)? 300 * HZ : 120 * HZ)
27 #define NLM_HOST_COLLECT        ((nrhosts > NLM_HOST_MAX)? 120 * HZ :  60 * 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
35 static void                     nlm_gc_hosts(void);
36 static struct nsm_handle *      __nsm_find(const struct sockaddr_in *,
37                                         const char *, int, int);
38 static struct nsm_handle *      nsm_find(const struct sockaddr_in *sin,
39                                          const char *hostname,
40                                          int hostname_len);
41
42 /*
43  * Common host lookup routine for server & client
44  */
45 static struct nlm_host *
46 nlm_lookup_host(int server, const struct sockaddr_in *sin,
47                                         int proto, int version,
48                                         const char *hostname,
49                                         int hostname_len)
50 {
51         struct hlist_head *chain;
52         struct hlist_node *pos;
53         struct nlm_host *host;
54         struct nsm_handle *nsm = NULL;
55         int             hash;
56
57         dprintk("lockd: nlm_lookup_host(%u.%u.%u.%u, p=%d, v=%d, my role=%s, name=%.*s)\n",
58                         NIPQUAD(sin->sin_addr.s_addr), proto, version,
59                         server? "server" : "client",
60                         hostname_len,
61                         hostname? hostname : "<none>");
62
63
64         hash = NLM_ADDRHASH(sin->sin_addr.s_addr);
65
66         /* Lock hash table */
67         mutex_lock(&nlm_host_mutex);
68
69         if (time_after_eq(jiffies, next_gc))
70                 nlm_gc_hosts();
71
72         /* We may keep several nlm_host objects for a peer, because each
73          * nlm_host is identified by
74          * (address, protocol, version, server/client)
75          * We could probably simplify this a little by putting all those
76          * different NLM rpc_clients into one single nlm_host object.
77          * This would allow us to have one nlm_host per address.
78          */
79         chain = &nlm_hosts[hash];
80         hlist_for_each_entry(host, pos, chain, h_hash) {
81                 if (!nlm_cmp_addr(&host->h_addr, sin))
82                         continue;
83
84                 /* See if we have an NSM handle for this client */
85                 if (!nsm)
86                         nsm = host->h_nsmhandle;
87
88                 if (host->h_proto != proto)
89                         continue;
90                 if (host->h_version != version)
91                         continue;
92                 if (host->h_server != server)
93                         continue;
94
95                 /* Move to head of hash chain. */
96                 hlist_del(&host->h_hash);
97                 hlist_add_head(&host->h_hash, chain);
98
99                 nlm_get_host(host);
100                 goto out;
101         }
102         if (nsm)
103                 atomic_inc(&nsm->sm_count);
104
105         host = NULL;
106
107         /* Sadly, the host isn't in our hash table yet. See if
108          * we have an NSM handle for it. If not, create one.
109          */
110         if (!nsm && !(nsm = nsm_find(sin, hostname, hostname_len)))
111                 goto out;
112
113         host = kzalloc(sizeof(*host), GFP_KERNEL);
114         if (!host) {
115                 nsm_release(nsm);
116                 goto out;
117         }
118         host->h_name       = nsm->sm_name;
119         host->h_addr       = *sin;
120         host->h_addr.sin_port = 0;      /* ouch! */
121         host->h_version    = version;
122         host->h_proto      = proto;
123         host->h_rpcclnt    = NULL;
124         mutex_init(&host->h_mutex);
125         host->h_nextrebind = jiffies + NLM_HOST_REBIND;
126         host->h_expires    = jiffies + NLM_HOST_EXPIRE;
127         atomic_set(&host->h_count, 1);
128         init_waitqueue_head(&host->h_gracewait);
129         init_rwsem(&host->h_rwsem);
130         host->h_state      = 0;                 /* pseudo NSM state */
131         host->h_nsmstate   = 0;                 /* real NSM state */
132         host->h_nsmhandle  = nsm;
133         host->h_server     = server;
134         hlist_add_head(&host->h_hash, chain);
135         INIT_LIST_HEAD(&host->h_lockowners);
136         spin_lock_init(&host->h_lock);
137         INIT_LIST_HEAD(&host->h_granted);
138         INIT_LIST_HEAD(&host->h_reclaim);
139
140         if (++nrhosts > NLM_HOST_MAX)
141                 next_gc = 0;
142
143 out:
144         mutex_unlock(&nlm_host_mutex);
145         return host;
146 }
147
148 /*
149  * Destroy a host
150  */
151 static void
152 nlm_destroy_host(struct nlm_host *host)
153 {
154         struct rpc_clnt *clnt;
155
156         BUG_ON(!list_empty(&host->h_lockowners));
157         BUG_ON(atomic_read(&host->h_count));
158
159         /*
160          * Release NSM handle and unmonitor host.
161          */
162         nsm_unmonitor(host);
163
164         if ((clnt = host->h_rpcclnt) != NULL) {
165                 if (atomic_read(&clnt->cl_users)) {
166                         printk(KERN_WARNING
167                                 "lockd: active RPC handle\n");
168                         clnt->cl_dead = 1;
169                 } else {
170                         rpc_destroy_client(host->h_rpcclnt);
171                 }
172         }
173         kfree(host);
174 }
175
176 /*
177  * Find an NLM server handle in the cache. If there is none, create it.
178  */
179 struct nlm_host *
180 nlmclnt_lookup_host(const struct sockaddr_in *sin, int proto, int version,
181                         const char *hostname, int hostname_len)
182 {
183         return nlm_lookup_host(0, sin, proto, version,
184                                hostname, hostname_len);
185 }
186
187 /*
188  * Find an NLM client handle in the cache. If there is none, create it.
189  */
190 struct nlm_host *
191 nlmsvc_lookup_host(struct svc_rqst *rqstp,
192                         const char *hostname, int hostname_len)
193 {
194         return nlm_lookup_host(1, svc_addr_in(rqstp),
195                                rqstp->rq_prot, rqstp->rq_vers,
196                                hostname, hostname_len);
197 }
198
199 /*
200  * Create the NLM RPC client for an NLM peer
201  */
202 struct rpc_clnt *
203 nlm_bind_host(struct nlm_host *host)
204 {
205         struct rpc_clnt *clnt;
206
207         dprintk("lockd: nlm_bind_host(%08x)\n",
208                         (unsigned)ntohl(host->h_addr.sin_addr.s_addr));
209
210         /* Lock host handle */
211         mutex_lock(&host->h_mutex);
212
213         /* If we've already created an RPC client, check whether
214          * RPC rebind is required
215          */
216         if ((clnt = host->h_rpcclnt) != NULL) {
217                 if (time_after_eq(jiffies, host->h_nextrebind)) {
218                         rpc_force_rebind(clnt);
219                         host->h_nextrebind = jiffies + NLM_HOST_REBIND;
220                         dprintk("lockd: next rebind in %ld jiffies\n",
221                                         host->h_nextrebind - jiffies);
222                 }
223         } else {
224                 unsigned long increment = nlmsvc_timeout * HZ;
225                 struct rpc_timeout timeparms = {
226                         .to_initval     = increment,
227                         .to_increment   = increment,
228                         .to_maxval      = increment * 6UL,
229                         .to_retries     = 5U,
230                 };
231                 struct rpc_create_args args = {
232                         .protocol       = host->h_proto,
233                         .address        = (struct sockaddr *)&host->h_addr,
234                         .addrsize       = sizeof(host->h_addr),
235                         .timeout        = &timeparms,
236                         .servername     = host->h_name,
237                         .program        = &nlm_program,
238                         .version        = host->h_version,
239                         .authflavor     = RPC_AUTH_UNIX,
240                         .flags          = (RPC_CLNT_CREATE_HARDRTRY |
241                                            RPC_CLNT_CREATE_AUTOBIND),
242                 };
243
244                 clnt = rpc_create(&args);
245                 if (!IS_ERR(clnt))
246                         host->h_rpcclnt = clnt;
247                 else {
248                         printk("lockd: couldn't create RPC handle for %s\n", host->h_name);
249                         clnt = NULL;
250                 }
251         }
252
253         mutex_unlock(&host->h_mutex);
254         return clnt;
255 }
256
257 /*
258  * Force a portmap lookup of the remote lockd port
259  */
260 void
261 nlm_rebind_host(struct nlm_host *host)
262 {
263         dprintk("lockd: rebind host %s\n", host->h_name);
264         if (host->h_rpcclnt && time_after_eq(jiffies, host->h_nextrebind)) {
265                 rpc_force_rebind(host->h_rpcclnt);
266                 host->h_nextrebind = jiffies + NLM_HOST_REBIND;
267         }
268 }
269
270 /*
271  * Increment NLM host count
272  */
273 struct nlm_host * nlm_get_host(struct nlm_host *host)
274 {
275         if (host) {
276                 dprintk("lockd: get host %s\n", host->h_name);
277                 atomic_inc(&host->h_count);
278                 host->h_expires = jiffies + NLM_HOST_EXPIRE;
279         }
280         return host;
281 }
282
283 /*
284  * Release NLM host after use
285  */
286 void nlm_release_host(struct nlm_host *host)
287 {
288         if (host != NULL) {
289                 dprintk("lockd: release host %s\n", host->h_name);
290                 BUG_ON(atomic_read(&host->h_count) < 0);
291                 if (atomic_dec_and_test(&host->h_count)) {
292                         BUG_ON(!list_empty(&host->h_lockowners));
293                         BUG_ON(!list_empty(&host->h_granted));
294                         BUG_ON(!list_empty(&host->h_reclaim));
295                 }
296         }
297 }
298
299 /*
300  * We were notified that the host indicated by address &sin
301  * has rebooted.
302  * Release all resources held by that peer.
303  */
304 void nlm_host_rebooted(const struct sockaddr_in *sin,
305                                 const char *hostname, int hostname_len,
306                                 u32 new_state)
307 {
308         struct hlist_head *chain;
309         struct hlist_node *pos;
310         struct nsm_handle *nsm;
311         struct nlm_host *host;
312
313         dprintk("lockd: nlm_host_rebooted(%s, %u.%u.%u.%u)\n",
314                         hostname, NIPQUAD(sin->sin_addr));
315
316         /* Find the NSM handle for this peer */
317         if (!(nsm = __nsm_find(sin, hostname, hostname_len, 0)))
318                 return;
319
320         /* When reclaiming locks on this peer, make sure that
321          * we set up a new notification */
322         nsm->sm_monitored = 0;
323
324         /* Mark all hosts tied to this NSM state as having rebooted.
325          * We run the loop repeatedly, because we drop the host table
326          * lock for this.
327          * To avoid processing a host several times, we match the nsmstate.
328          */
329 again:  mutex_lock(&nlm_host_mutex);
330         for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
331                 hlist_for_each_entry(host, pos, chain, h_hash) {
332                         if (host->h_nsmhandle == nsm
333                          && host->h_nsmstate != new_state) {
334                                 host->h_nsmstate = new_state;
335                                 host->h_state++;
336
337                                 nlm_get_host(host);
338                                 mutex_unlock(&nlm_host_mutex);
339
340                                 if (host->h_server) {
341                                         /* We're server for this guy, just ditch
342                                          * all the locks he held. */
343                                         nlmsvc_free_host_resources(host);
344                                 } else {
345                                         /* He's the server, initiate lock recovery. */
346                                         nlmclnt_recovery(host);
347                                 }
348
349                                 nlm_release_host(host);
350                                 goto again;
351                         }
352                 }
353         }
354
355         mutex_unlock(&nlm_host_mutex);
356 }
357
358 /*
359  * Shut down the hosts module.
360  * Note that this routine is called only at server shutdown time.
361  */
362 void
363 nlm_shutdown_hosts(void)
364 {
365         struct hlist_head *chain;
366         struct hlist_node *pos;
367         struct nlm_host *host;
368
369         dprintk("lockd: shutting down host module\n");
370         mutex_lock(&nlm_host_mutex);
371
372         /* First, make all hosts eligible for gc */
373         dprintk("lockd: nuking all hosts...\n");
374         for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
375                 hlist_for_each_entry(host, pos, chain, h_hash)
376                         host->h_expires = jiffies - 1;
377         }
378
379         /* Then, perform a garbage collection pass */
380         nlm_gc_hosts();
381         mutex_unlock(&nlm_host_mutex);
382
383         /* complain if any hosts are left */
384         if (nrhosts) {
385                 printk(KERN_WARNING "lockd: couldn't shutdown host module!\n");
386                 dprintk("lockd: %d hosts left:\n", nrhosts);
387                 for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
388                         hlist_for_each_entry(host, pos, chain, h_hash) {
389                                 dprintk("       %s (cnt %d use %d exp %ld)\n",
390                                         host->h_name, atomic_read(&host->h_count),
391                                         host->h_inuse, host->h_expires);
392                         }
393                 }
394         }
395 }
396
397 /*
398  * Garbage collect any unused NLM hosts.
399  * This GC combines reference counting for async operations with
400  * mark & sweep for resources held by remote clients.
401  */
402 static void
403 nlm_gc_hosts(void)
404 {
405         struct hlist_head *chain;
406         struct hlist_node *pos, *next;
407         struct nlm_host *host;
408
409         dprintk("lockd: host garbage collection\n");
410         for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
411                 hlist_for_each_entry(host, pos, chain, h_hash)
412                         host->h_inuse = 0;
413         }
414
415         /* Mark all hosts that hold locks, blocks or shares */
416         nlmsvc_mark_resources();
417
418         for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
419                 hlist_for_each_entry_safe(host, pos, next, chain, h_hash) {
420                         if (atomic_read(&host->h_count) || host->h_inuse
421                          || time_before(jiffies, host->h_expires)) {
422                                 dprintk("nlm_gc_hosts skipping %s (cnt %d use %d exp %ld)\n",
423                                         host->h_name, atomic_read(&host->h_count),
424                                         host->h_inuse, host->h_expires);
425                                 continue;
426                         }
427                         dprintk("lockd: delete host %s\n", host->h_name);
428                         hlist_del_init(&host->h_hash);
429
430                         nlm_destroy_host(host);
431                         nrhosts--;
432                 }
433         }
434
435         next_gc = jiffies + NLM_HOST_COLLECT;
436 }
437
438
439 /*
440  * Manage NSM handles
441  */
442 static LIST_HEAD(nsm_handles);
443 static DEFINE_MUTEX(nsm_mutex);
444
445 static struct nsm_handle *
446 __nsm_find(const struct sockaddr_in *sin,
447                 const char *hostname, int hostname_len,
448                 int create)
449 {
450         struct nsm_handle *nsm = NULL;
451         struct list_head *pos;
452
453         if (!sin)
454                 return NULL;
455
456         if (hostname && memchr(hostname, '/', hostname_len) != NULL) {
457                 if (printk_ratelimit()) {
458                         printk(KERN_WARNING "Invalid hostname \"%.*s\" "
459                                             "in NFS lock request\n",
460                                 hostname_len, hostname);
461                 }
462                 return NULL;
463         }
464
465         mutex_lock(&nsm_mutex);
466         list_for_each(pos, &nsm_handles) {
467                 nsm = list_entry(pos, struct nsm_handle, sm_link);
468
469                 if (hostname && nsm_use_hostnames) {
470                         if (strlen(nsm->sm_name) != hostname_len
471                          || memcmp(nsm->sm_name, hostname, hostname_len))
472                                 continue;
473                 } else if (!nlm_cmp_addr(&nsm->sm_addr, sin))
474                         continue;
475                 atomic_inc(&nsm->sm_count);
476                 goto out;
477         }
478
479         if (!create) {
480                 nsm = NULL;
481                 goto out;
482         }
483
484         nsm = kzalloc(sizeof(*nsm) + hostname_len + 1, GFP_KERNEL);
485         if (nsm != NULL) {
486                 nsm->sm_addr = *sin;
487                 nsm->sm_name = (char *) (nsm + 1);
488                 memcpy(nsm->sm_name, hostname, hostname_len);
489                 nsm->sm_name[hostname_len] = '\0';
490                 atomic_set(&nsm->sm_count, 1);
491
492                 list_add(&nsm->sm_link, &nsm_handles);
493         }
494
495 out:
496         mutex_unlock(&nsm_mutex);
497         return nsm;
498 }
499
500 static struct nsm_handle *
501 nsm_find(const struct sockaddr_in *sin, const char *hostname, int hostname_len)
502 {
503         return __nsm_find(sin, hostname, hostname_len, 1);
504 }
505
506 /*
507  * Release an NSM handle
508  */
509 void
510 nsm_release(struct nsm_handle *nsm)
511 {
512         if (!nsm)
513                 return;
514         if (atomic_dec_and_test(&nsm->sm_count)) {
515                 mutex_lock(&nsm_mutex);
516                 if (atomic_read(&nsm->sm_count) == 0) {
517                         list_del(&nsm->sm_link);
518                         kfree(nsm);
519                 }
520                 mutex_unlock(&nsm_mutex);
521         }
522 }