2 * linux/fs/lockd/host.c
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.
8 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
11 #include <linux/types.h>
12 #include <linux/slab.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>
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)
29 static struct hlist_head nlm_hosts
[NLM_HOST_NRHASH
];
30 static unsigned long next_gc
;
32 static DEFINE_MUTEX(nlm_host_mutex
);
34 static void nlm_gc_hosts(void);
36 struct nlm_lookup_host_info
{
37 const int server
; /* search for server|client */
38 const struct sockaddr
*sap
; /* address to search for */
39 const size_t salen
; /* it's length */
40 const unsigned short protocol
; /* transport to search for*/
41 const u32 version
; /* NLM version to search for */
42 const char *hostname
; /* remote's hostname */
43 const size_t hostname_len
; /* it's length */
44 const struct sockaddr
*src_sap
; /* our address (optional) */
45 const size_t src_len
; /* it's length */
46 const int noresvport
; /* use non-priv port */
50 * Hash function must work well on big- and little-endian platforms
52 static unsigned int __nlm_hash32(const __be32 n
)
54 unsigned int hash
= (__force u32
)n
^ ((__force u32
)n
>> 16);
55 return hash
^ (hash
>> 8);
58 static unsigned int __nlm_hash_addr4(const struct sockaddr
*sap
)
60 const struct sockaddr_in
*sin
= (struct sockaddr_in
*)sap
;
61 return __nlm_hash32(sin
->sin_addr
.s_addr
);
64 static unsigned int __nlm_hash_addr6(const struct sockaddr
*sap
)
66 const struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)sap
;
67 const struct in6_addr addr
= sin6
->sin6_addr
;
68 return __nlm_hash32(addr
.s6_addr32
[0]) ^
69 __nlm_hash32(addr
.s6_addr32
[1]) ^
70 __nlm_hash32(addr
.s6_addr32
[2]) ^
71 __nlm_hash32(addr
.s6_addr32
[3]);
74 static unsigned int nlm_hash_address(const struct sockaddr
*sap
)
78 switch (sap
->sa_family
) {
80 hash
= __nlm_hash_addr4(sap
);
83 hash
= __nlm_hash_addr6(sap
);
88 return hash
& (NLM_HOST_NRHASH
- 1);
91 static void nlm_clear_port(struct sockaddr
*sap
)
93 switch (sap
->sa_family
) {
95 ((struct sockaddr_in
*)sap
)->sin_port
= 0;
98 ((struct sockaddr_in6
*)sap
)->sin6_port
= 0;
104 * Common host lookup routine for server & client
106 static struct nlm_host
*nlm_lookup_host(struct nlm_lookup_host_info
*ni
)
108 struct hlist_head
*chain
;
109 struct hlist_node
*pos
;
110 struct nlm_host
*host
;
111 struct nsm_handle
*nsm
= NULL
;
113 mutex_lock(&nlm_host_mutex
);
115 if (time_after_eq(jiffies
, next_gc
))
118 /* We may keep several nlm_host objects for a peer, because each
119 * nlm_host is identified by
120 * (address, protocol, version, server/client)
121 * We could probably simplify this a little by putting all those
122 * different NLM rpc_clients into one single nlm_host object.
123 * This would allow us to have one nlm_host per address.
125 chain
= &nlm_hosts
[nlm_hash_address(ni
->sap
)];
126 hlist_for_each_entry(host
, pos
, chain
, h_hash
) {
127 if (!nlm_cmp_addr(nlm_addr(host
), ni
->sap
))
130 /* See if we have an NSM handle for this client */
132 nsm
= host
->h_nsmhandle
;
134 if (host
->h_proto
!= ni
->protocol
)
136 if (host
->h_version
!= ni
->version
)
138 if (host
->h_server
!= ni
->server
)
141 !nlm_cmp_addr(nlm_srcaddr(host
), ni
->src_sap
))
144 /* Move to head of hash chain. */
145 hlist_del(&host
->h_hash
);
146 hlist_add_head(&host
->h_hash
, chain
);
149 dprintk("lockd: nlm_lookup_host found host %s (%s)\n",
150 host
->h_name
, host
->h_addrbuf
);
155 * The host wasn't in our hash table. If we don't
156 * have an NSM handle for it yet, create one.
159 atomic_inc(&nsm
->sm_count
);
162 nsm
= nsm_find(ni
->sap
, ni
->salen
,
163 ni
->hostname
, ni
->hostname_len
, 1);
165 dprintk("lockd: nlm_lookup_host failed; "
171 host
= kzalloc(sizeof(*host
), GFP_KERNEL
);
174 dprintk("lockd: nlm_lookup_host failed; no memory\n");
177 host
->h_name
= nsm
->sm_name
;
178 host
->h_addrbuf
= nsm
->sm_addrbuf
;
179 memcpy(nlm_addr(host
), ni
->sap
, ni
->salen
);
180 host
->h_addrlen
= ni
->salen
;
181 nlm_clear_port(nlm_addr(host
));
182 memcpy(nlm_srcaddr(host
), ni
->src_sap
, ni
->src_len
);
183 host
->h_version
= ni
->version
;
184 host
->h_proto
= ni
->protocol
;
185 host
->h_rpcclnt
= NULL
;
186 mutex_init(&host
->h_mutex
);
187 host
->h_nextrebind
= jiffies
+ NLM_HOST_REBIND
;
188 host
->h_expires
= jiffies
+ NLM_HOST_EXPIRE
;
189 atomic_set(&host
->h_count
, 1);
190 init_waitqueue_head(&host
->h_gracewait
);
191 init_rwsem(&host
->h_rwsem
);
192 host
->h_state
= 0; /* pseudo NSM state */
193 host
->h_nsmstate
= 0; /* real NSM state */
194 host
->h_nsmhandle
= nsm
;
195 host
->h_server
= ni
->server
;
196 host
->h_noresvport
= ni
->noresvport
;
197 hlist_add_head(&host
->h_hash
, chain
);
198 INIT_LIST_HEAD(&host
->h_lockowners
);
199 spin_lock_init(&host
->h_lock
);
200 INIT_LIST_HEAD(&host
->h_granted
);
201 INIT_LIST_HEAD(&host
->h_reclaim
);
205 dprintk("lockd: nlm_lookup_host created host %s\n",
209 mutex_unlock(&nlm_host_mutex
);
217 nlm_destroy_host(struct nlm_host
*host
)
219 struct rpc_clnt
*clnt
;
221 BUG_ON(!list_empty(&host
->h_lockowners
));
222 BUG_ON(atomic_read(&host
->h_count
));
225 nsm_release(host
->h_nsmhandle
);
227 clnt
= host
->h_rpcclnt
;
229 rpc_shutdown_client(clnt
);
234 * nlmclnt_lookup_host - Find an NLM host handle matching a remote server
235 * @sap: network address of server
236 * @salen: length of server address
237 * @protocol: transport protocol to use
238 * @version: NLM protocol version
239 * @hostname: '\0'-terminated hostname of server
240 * @noresvport: 1 if non-privileged port should be used
242 * Returns an nlm_host structure that matches the passed-in
243 * [server address, transport protocol, NLM version, server hostname].
244 * If one doesn't already exist in the host cache, a new handle is
245 * created and returned.
247 struct nlm_host
*nlmclnt_lookup_host(const struct sockaddr
*sap
,
249 const unsigned short protocol
,
251 const char *hostname
,
254 const struct sockaddr source
= {
255 .sa_family
= AF_UNSPEC
,
257 struct nlm_lookup_host_info ni
= {
261 .protocol
= protocol
,
263 .hostname
= hostname
,
264 .hostname_len
= strlen(hostname
),
266 .src_len
= sizeof(source
),
267 .noresvport
= noresvport
,
270 dprintk("lockd: %s(host='%s', vers=%u, proto=%s)\n", __func__
,
271 (hostname
? hostname
: "<none>"), version
,
272 (protocol
== IPPROTO_UDP
? "udp" : "tcp"));
274 return nlm_lookup_host(&ni
);
278 * nlmsvc_lookup_host - Find an NLM host handle matching a remote client
279 * @rqstp: incoming NLM request
280 * @hostname: name of client host
281 * @hostname_len: length of client hostname
283 * Returns an nlm_host structure that matches the [client address,
284 * transport protocol, NLM version, client hostname] of the passed-in
285 * NLM request. If one doesn't already exist in the host cache, a
286 * new handle is created and returned.
288 * Before possibly creating a new nlm_host, construct a sockaddr
289 * for a specific source address in case the local system has
290 * multiple network addresses. The family of the address in
291 * rq_daddr is guaranteed to be the same as the family of the
292 * address in rq_addr, so it's safe to use the same family for
293 * the source address.
295 struct nlm_host
*nlmsvc_lookup_host(const struct svc_rqst
*rqstp
,
296 const char *hostname
,
297 const size_t hostname_len
)
299 struct sockaddr_in sin
= {
300 .sin_family
= AF_INET
,
302 struct sockaddr_in6 sin6
= {
303 .sin6_family
= AF_INET6
,
305 struct nlm_lookup_host_info ni
= {
307 .sap
= svc_addr(rqstp
),
308 .salen
= rqstp
->rq_addrlen
,
309 .protocol
= rqstp
->rq_prot
,
310 .version
= rqstp
->rq_vers
,
311 .hostname
= hostname
,
312 .hostname_len
= hostname_len
,
313 .src_len
= rqstp
->rq_addrlen
,
316 dprintk("lockd: %s(host='%*s', vers=%u, proto=%s)\n", __func__
,
317 (int)hostname_len
, hostname
, rqstp
->rq_vers
,
318 (rqstp
->rq_prot
== IPPROTO_UDP
? "udp" : "tcp"));
320 switch (ni
.sap
->sa_family
) {
322 sin
.sin_addr
.s_addr
= rqstp
->rq_daddr
.addr
.s_addr
;
323 ni
.src_sap
= (struct sockaddr
*)&sin
;
326 ipv6_addr_copy(&sin6
.sin6_addr
, &rqstp
->rq_daddr
.addr6
);
327 ni
.src_sap
= (struct sockaddr
*)&sin6
;
333 return nlm_lookup_host(&ni
);
337 * Create the NLM RPC client for an NLM peer
340 nlm_bind_host(struct nlm_host
*host
)
342 struct rpc_clnt
*clnt
;
344 dprintk("lockd: nlm_bind_host %s (%s)\n",
345 host
->h_name
, host
->h_addrbuf
);
347 /* Lock host handle */
348 mutex_lock(&host
->h_mutex
);
350 /* If we've already created an RPC client, check whether
351 * RPC rebind is required
353 if ((clnt
= host
->h_rpcclnt
) != NULL
) {
354 if (time_after_eq(jiffies
, host
->h_nextrebind
)) {
355 rpc_force_rebind(clnt
);
356 host
->h_nextrebind
= jiffies
+ NLM_HOST_REBIND
;
357 dprintk("lockd: next rebind in %lu jiffies\n",
358 host
->h_nextrebind
- jiffies
);
361 unsigned long increment
= nlmsvc_timeout
;
362 struct rpc_timeout timeparms
= {
363 .to_initval
= increment
,
364 .to_increment
= increment
,
365 .to_maxval
= increment
* 6UL,
368 struct rpc_create_args args
= {
369 .protocol
= host
->h_proto
,
370 .address
= nlm_addr(host
),
371 .addrsize
= host
->h_addrlen
,
372 .saddress
= nlm_srcaddr(host
),
373 .timeout
= &timeparms
,
374 .servername
= host
->h_name
,
375 .program
= &nlm_program
,
376 .version
= host
->h_version
,
377 .authflavor
= RPC_AUTH_UNIX
,
378 .flags
= (RPC_CLNT_CREATE_NOPING
|
379 RPC_CLNT_CREATE_AUTOBIND
),
383 * lockd retries server side blocks automatically so we want
384 * those to be soft RPC calls. Client side calls need to be
388 args
.flags
|= RPC_CLNT_CREATE_HARDRTRY
;
389 if (host
->h_noresvport
)
390 args
.flags
|= RPC_CLNT_CREATE_NONPRIVPORT
;
392 clnt
= rpc_create(&args
);
394 host
->h_rpcclnt
= clnt
;
396 printk("lockd: couldn't create RPC handle for %s\n", host
->h_name
);
401 mutex_unlock(&host
->h_mutex
);
406 * Force a portmap lookup of the remote lockd port
409 nlm_rebind_host(struct nlm_host
*host
)
411 dprintk("lockd: rebind host %s\n", host
->h_name
);
412 if (host
->h_rpcclnt
&& time_after_eq(jiffies
, host
->h_nextrebind
)) {
413 rpc_force_rebind(host
->h_rpcclnt
);
414 host
->h_nextrebind
= jiffies
+ NLM_HOST_REBIND
;
419 * Increment NLM host count
421 struct nlm_host
* nlm_get_host(struct nlm_host
*host
)
424 dprintk("lockd: get host %s\n", host
->h_name
);
425 atomic_inc(&host
->h_count
);
426 host
->h_expires
= jiffies
+ NLM_HOST_EXPIRE
;
432 * Release NLM host after use
434 void nlm_release_host(struct nlm_host
*host
)
437 dprintk("lockd: release host %s\n", host
->h_name
);
438 BUG_ON(atomic_read(&host
->h_count
) < 0);
439 if (atomic_dec_and_test(&host
->h_count
)) {
440 BUG_ON(!list_empty(&host
->h_lockowners
));
441 BUG_ON(!list_empty(&host
->h_granted
));
442 BUG_ON(!list_empty(&host
->h_reclaim
));
448 * We were notified that the host indicated by address &sin
450 * Release all resources held by that peer.
452 void nlm_host_rebooted(const struct sockaddr_in
*sin
,
453 const char *hostname
,
454 unsigned int hostname_len
,
457 struct hlist_head
*chain
;
458 struct hlist_node
*pos
;
459 struct nsm_handle
*nsm
;
460 struct nlm_host
*host
;
462 nsm
= nsm_find((struct sockaddr
*)sin
, sizeof(*sin
),
463 hostname
, hostname_len
, 0);
465 dprintk("lockd: never saw rebooted peer '%.*s' before\n",
466 hostname_len
, hostname
);
470 dprintk("lockd: nlm_host_rebooted(%.*s, %s)\n",
471 hostname_len
, hostname
, nsm
->sm_addrbuf
);
473 /* When reclaiming locks on this peer, make sure that
474 * we set up a new notification */
475 nsm
->sm_monitored
= 0;
477 /* Mark all hosts tied to this NSM state as having rebooted.
478 * We run the loop repeatedly, because we drop the host table
480 * To avoid processing a host several times, we match the nsmstate.
482 again
: mutex_lock(&nlm_host_mutex
);
483 for (chain
= nlm_hosts
; chain
< nlm_hosts
+ NLM_HOST_NRHASH
; ++chain
) {
484 hlist_for_each_entry(host
, pos
, chain
, h_hash
) {
485 if (host
->h_nsmhandle
== nsm
486 && host
->h_nsmstate
!= new_state
) {
487 host
->h_nsmstate
= new_state
;
491 mutex_unlock(&nlm_host_mutex
);
493 if (host
->h_server
) {
494 /* We're server for this guy, just ditch
495 * all the locks he held. */
496 nlmsvc_free_host_resources(host
);
498 /* He's the server, initiate lock recovery. */
499 nlmclnt_recovery(host
);
502 nlm_release_host(host
);
508 mutex_unlock(&nlm_host_mutex
);
512 * Shut down the hosts module.
513 * Note that this routine is called only at server shutdown time.
516 nlm_shutdown_hosts(void)
518 struct hlist_head
*chain
;
519 struct hlist_node
*pos
;
520 struct nlm_host
*host
;
522 dprintk("lockd: shutting down host module\n");
523 mutex_lock(&nlm_host_mutex
);
525 /* First, make all hosts eligible for gc */
526 dprintk("lockd: nuking all hosts...\n");
527 for (chain
= nlm_hosts
; chain
< nlm_hosts
+ NLM_HOST_NRHASH
; ++chain
) {
528 hlist_for_each_entry(host
, pos
, chain
, h_hash
) {
529 host
->h_expires
= jiffies
- 1;
530 if (host
->h_rpcclnt
) {
531 rpc_shutdown_client(host
->h_rpcclnt
);
532 host
->h_rpcclnt
= NULL
;
537 /* Then, perform a garbage collection pass */
539 mutex_unlock(&nlm_host_mutex
);
541 /* complain if any hosts are left */
543 printk(KERN_WARNING
"lockd: couldn't shutdown host module!\n");
544 dprintk("lockd: %d hosts left:\n", nrhosts
);
545 for (chain
= nlm_hosts
; chain
< nlm_hosts
+ NLM_HOST_NRHASH
; ++chain
) {
546 hlist_for_each_entry(host
, pos
, chain
, h_hash
) {
547 dprintk(" %s (cnt %d use %d exp %ld)\n",
548 host
->h_name
, atomic_read(&host
->h_count
),
549 host
->h_inuse
, host
->h_expires
);
556 * Garbage collect any unused NLM hosts.
557 * This GC combines reference counting for async operations with
558 * mark & sweep for resources held by remote clients.
563 struct hlist_head
*chain
;
564 struct hlist_node
*pos
, *next
;
565 struct nlm_host
*host
;
567 dprintk("lockd: host garbage collection\n");
568 for (chain
= nlm_hosts
; chain
< nlm_hosts
+ NLM_HOST_NRHASH
; ++chain
) {
569 hlist_for_each_entry(host
, pos
, chain
, h_hash
)
573 /* Mark all hosts that hold locks, blocks or shares */
574 nlmsvc_mark_resources();
576 for (chain
= nlm_hosts
; chain
< nlm_hosts
+ NLM_HOST_NRHASH
; ++chain
) {
577 hlist_for_each_entry_safe(host
, pos
, next
, chain
, h_hash
) {
578 if (atomic_read(&host
->h_count
) || host
->h_inuse
579 || time_before(jiffies
, host
->h_expires
)) {
580 dprintk("nlm_gc_hosts skipping %s (cnt %d use %d exp %ld)\n",
581 host
->h_name
, atomic_read(&host
->h_count
),
582 host
->h_inuse
, host
->h_expires
);
585 dprintk("lockd: delete host %s\n", host
->h_name
);
586 hlist_del_init(&host
->h_hash
);
588 nlm_destroy_host(host
);
593 next_gc
= jiffies
+ NLM_HOST_COLLECT
;