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/mutex.h>
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)
28 static struct hlist_head nlm_hosts
[NLM_HOST_NRHASH
];
29 static unsigned long next_gc
;
31 static DEFINE_MUTEX(nlm_host_mutex
);
33 static void nlm_gc_hosts(void);
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 */
49 * Hash function must work well on big- and little-endian platforms
51 static unsigned int __nlm_hash32(const __be32 n
)
53 unsigned int hash
= (__force u32
)n
^ ((__force u32
)n
>> 16);
54 return hash
^ (hash
>> 8);
57 static unsigned int __nlm_hash_addr4(const struct sockaddr
*sap
)
59 const struct sockaddr_in
*sin
= (struct sockaddr_in
*)sap
;
60 return __nlm_hash32(sin
->sin_addr
.s_addr
);
63 static unsigned int __nlm_hash_addr6(const struct sockaddr
*sap
)
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]);
73 static unsigned int nlm_hash_address(const struct sockaddr
*sap
)
77 switch (sap
->sa_family
) {
79 hash
= __nlm_hash_addr4(sap
);
82 hash
= __nlm_hash_addr6(sap
);
87 return hash
& (NLM_HOST_NRHASH
- 1);
91 * Common host lookup routine for server & client
93 static struct nlm_host
*nlm_lookup_host(struct nlm_lookup_host_info
*ni
)
95 struct hlist_head
*chain
;
96 struct hlist_node
*pos
;
97 struct nlm_host
*host
;
98 struct nsm_handle
*nsm
= NULL
;
100 mutex_lock(&nlm_host_mutex
);
102 if (time_after_eq(jiffies
, next_gc
))
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.
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
))
117 /* See if we have an NSM handle for this client */
119 nsm
= host
->h_nsmhandle
;
121 if (host
->h_proto
!= ni
->protocol
)
123 if (host
->h_version
!= ni
->version
)
125 if (host
->h_server
!= ni
->server
)
127 if (ni
->server
&& ni
->src_len
!= 0 &&
128 !rpc_cmp_addr(nlm_srcaddr(host
), ni
->src_sap
))
131 /* Move to head of hash chain. */
132 hlist_del(&host
->h_hash
);
133 hlist_add_head(&host
->h_hash
, chain
);
136 dprintk("lockd: nlm_lookup_host found host %s (%s)\n",
137 host
->h_name
, host
->h_addrbuf
);
142 * The host wasn't in our hash table. If we don't
143 * have an NSM handle for it yet, create one.
146 atomic_inc(&nsm
->sm_count
);
149 nsm
= nsm_get_handle(ni
->sap
, ni
->salen
,
150 ni
->hostname
, ni
->hostname_len
);
152 dprintk("lockd: nlm_lookup_host failed; "
158 host
= kzalloc(sizeof(*host
), GFP_KERNEL
);
161 dprintk("lockd: nlm_lookup_host failed; no memory\n");
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_srcaddrlen
= ni
->src_len
;
171 host
->h_version
= ni
->version
;
172 host
->h_proto
= ni
->protocol
;
173 host
->h_rpcclnt
= NULL
;
174 mutex_init(&host
->h_mutex
);
175 host
->h_nextrebind
= jiffies
+ NLM_HOST_REBIND
;
176 host
->h_expires
= jiffies
+ NLM_HOST_EXPIRE
;
177 atomic_set(&host
->h_count
, 1);
178 init_waitqueue_head(&host
->h_gracewait
);
179 init_rwsem(&host
->h_rwsem
);
180 host
->h_state
= 0; /* pseudo NSM state */
181 host
->h_nsmstate
= 0; /* real NSM state */
182 host
->h_nsmhandle
= nsm
;
183 host
->h_server
= ni
->server
;
184 host
->h_noresvport
= ni
->noresvport
;
185 hlist_add_head(&host
->h_hash
, chain
);
186 INIT_LIST_HEAD(&host
->h_lockowners
);
187 spin_lock_init(&host
->h_lock
);
188 INIT_LIST_HEAD(&host
->h_granted
);
189 INIT_LIST_HEAD(&host
->h_reclaim
);
193 dprintk("lockd: nlm_lookup_host created host %s\n",
197 mutex_unlock(&nlm_host_mutex
);
205 nlm_destroy_host(struct nlm_host
*host
)
207 struct rpc_clnt
*clnt
;
209 BUG_ON(!list_empty(&host
->h_lockowners
));
210 BUG_ON(atomic_read(&host
->h_count
));
213 nsm_release(host
->h_nsmhandle
);
215 clnt
= host
->h_rpcclnt
;
217 rpc_shutdown_client(clnt
);
222 * nlmclnt_lookup_host - Find an NLM host handle matching a remote server
223 * @sap: network address of server
224 * @salen: length of server address
225 * @protocol: transport protocol to use
226 * @version: NLM protocol version
227 * @hostname: '\0'-terminated hostname of server
228 * @noresvport: 1 if non-privileged port should be used
230 * Returns an nlm_host structure that matches the passed-in
231 * [server address, transport protocol, NLM version, server hostname].
232 * If one doesn't already exist in the host cache, a new handle is
233 * created and returned.
235 struct nlm_host
*nlmclnt_lookup_host(const struct sockaddr
*sap
,
237 const unsigned short protocol
,
239 const char *hostname
,
242 struct nlm_lookup_host_info ni
= {
246 .protocol
= protocol
,
248 .hostname
= hostname
,
249 .hostname_len
= strlen(hostname
),
250 .noresvport
= noresvport
,
253 dprintk("lockd: %s(host='%s', vers=%u, proto=%s)\n", __func__
,
254 (hostname
? hostname
: "<none>"), version
,
255 (protocol
== IPPROTO_UDP
? "udp" : "tcp"));
257 return nlm_lookup_host(&ni
);
261 * nlmsvc_lookup_host - Find an NLM host handle matching a remote client
262 * @rqstp: incoming NLM request
263 * @hostname: name of client host
264 * @hostname_len: length of client hostname
266 * Returns an nlm_host structure that matches the [client address,
267 * transport protocol, NLM version, client hostname] of the passed-in
268 * NLM request. If one doesn't already exist in the host cache, a
269 * new handle is created and returned.
271 * Before possibly creating a new nlm_host, construct a sockaddr
272 * for a specific source address in case the local system has
273 * multiple network addresses. The family of the address in
274 * rq_daddr is guaranteed to be the same as the family of the
275 * address in rq_addr, so it's safe to use the same family for
276 * the source address.
278 struct nlm_host
*nlmsvc_lookup_host(const struct svc_rqst
*rqstp
,
279 const char *hostname
,
280 const size_t hostname_len
)
282 struct sockaddr_in sin
= {
283 .sin_family
= AF_INET
,
285 struct sockaddr_in6 sin6
= {
286 .sin6_family
= AF_INET6
,
288 struct nlm_lookup_host_info ni
= {
290 .sap
= svc_addr(rqstp
),
291 .salen
= rqstp
->rq_addrlen
,
292 .protocol
= rqstp
->rq_prot
,
293 .version
= rqstp
->rq_vers
,
294 .hostname
= hostname
,
295 .hostname_len
= hostname_len
,
296 .src_len
= rqstp
->rq_addrlen
,
299 dprintk("lockd: %s(host='%*s', vers=%u, proto=%s)\n", __func__
,
300 (int)hostname_len
, hostname
, rqstp
->rq_vers
,
301 (rqstp
->rq_prot
== IPPROTO_UDP
? "udp" : "tcp"));
303 switch (ni
.sap
->sa_family
) {
305 sin
.sin_addr
.s_addr
= rqstp
->rq_daddr
.addr
.s_addr
;
306 ni
.src_sap
= (struct sockaddr
*)&sin
;
309 ipv6_addr_copy(&sin6
.sin6_addr
, &rqstp
->rq_daddr
.addr6
);
310 ni
.src_sap
= (struct sockaddr
*)&sin6
;
316 return nlm_lookup_host(&ni
);
320 * Create the NLM RPC client for an NLM peer
323 nlm_bind_host(struct nlm_host
*host
)
325 struct rpc_clnt
*clnt
;
327 dprintk("lockd: nlm_bind_host %s (%s)\n",
328 host
->h_name
, host
->h_addrbuf
);
330 /* Lock host handle */
331 mutex_lock(&host
->h_mutex
);
333 /* If we've already created an RPC client, check whether
334 * RPC rebind is required
336 if ((clnt
= host
->h_rpcclnt
) != NULL
) {
337 if (time_after_eq(jiffies
, host
->h_nextrebind
)) {
338 rpc_force_rebind(clnt
);
339 host
->h_nextrebind
= jiffies
+ NLM_HOST_REBIND
;
340 dprintk("lockd: next rebind in %lu jiffies\n",
341 host
->h_nextrebind
- jiffies
);
344 unsigned long increment
= nlmsvc_timeout
;
345 struct rpc_timeout timeparms
= {
346 .to_initval
= increment
,
347 .to_increment
= increment
,
348 .to_maxval
= increment
* 6UL,
351 struct rpc_create_args args
= {
353 .protocol
= host
->h_proto
,
354 .address
= nlm_addr(host
),
355 .addrsize
= host
->h_addrlen
,
356 .timeout
= &timeparms
,
357 .servername
= host
->h_name
,
358 .program
= &nlm_program
,
359 .version
= host
->h_version
,
360 .authflavor
= RPC_AUTH_UNIX
,
361 .flags
= (RPC_CLNT_CREATE_NOPING
|
362 RPC_CLNT_CREATE_AUTOBIND
),
366 * lockd retries server side blocks automatically so we want
367 * those to be soft RPC calls. Client side calls need to be
371 args
.flags
|= RPC_CLNT_CREATE_HARDRTRY
;
372 if (host
->h_noresvport
)
373 args
.flags
|= RPC_CLNT_CREATE_NONPRIVPORT
;
374 if (host
->h_srcaddrlen
)
375 args
.saddress
= nlm_srcaddr(host
);
377 clnt
= rpc_create(&args
);
379 host
->h_rpcclnt
= clnt
;
381 printk("lockd: couldn't create RPC handle for %s\n", host
->h_name
);
386 mutex_unlock(&host
->h_mutex
);
391 * Force a portmap lookup of the remote lockd port
394 nlm_rebind_host(struct nlm_host
*host
)
396 dprintk("lockd: rebind host %s\n", host
->h_name
);
397 if (host
->h_rpcclnt
&& time_after_eq(jiffies
, host
->h_nextrebind
)) {
398 rpc_force_rebind(host
->h_rpcclnt
);
399 host
->h_nextrebind
= jiffies
+ NLM_HOST_REBIND
;
404 * Increment NLM host count
406 struct nlm_host
* nlm_get_host(struct nlm_host
*host
)
409 dprintk("lockd: get host %s\n", host
->h_name
);
410 atomic_inc(&host
->h_count
);
411 host
->h_expires
= jiffies
+ NLM_HOST_EXPIRE
;
417 * Release NLM host after use
419 void nlm_release_host(struct nlm_host
*host
)
422 dprintk("lockd: release host %s\n", host
->h_name
);
423 BUG_ON(atomic_read(&host
->h_count
) < 0);
424 if (atomic_dec_and_test(&host
->h_count
)) {
425 BUG_ON(!list_empty(&host
->h_lockowners
));
426 BUG_ON(!list_empty(&host
->h_granted
));
427 BUG_ON(!list_empty(&host
->h_reclaim
));
433 * nlm_host_rebooted - Release all resources held by rebooted host
434 * @info: pointer to decoded results of NLM_SM_NOTIFY call
436 * We were notified that the specified host has rebooted. Release
437 * all resources held by that peer.
439 void nlm_host_rebooted(const struct nlm_reboot
*info
)
441 struct hlist_head
*chain
;
442 struct hlist_node
*pos
;
443 struct nsm_handle
*nsm
;
444 struct nlm_host
*host
;
446 nsm
= nsm_reboot_lookup(info
);
447 if (unlikely(nsm
== NULL
))
450 /* Mark all hosts tied to this NSM state as having rebooted.
451 * We run the loop repeatedly, because we drop the host table
453 * To avoid processing a host several times, we match the nsmstate.
455 again
: mutex_lock(&nlm_host_mutex
);
456 for (chain
= nlm_hosts
; chain
< nlm_hosts
+ NLM_HOST_NRHASH
; ++chain
) {
457 hlist_for_each_entry(host
, pos
, chain
, h_hash
) {
458 if (host
->h_nsmhandle
== nsm
459 && host
->h_nsmstate
!= info
->state
) {
460 host
->h_nsmstate
= info
->state
;
464 mutex_unlock(&nlm_host_mutex
);
466 if (host
->h_server
) {
467 /* We're server for this guy, just ditch
468 * all the locks he held. */
469 nlmsvc_free_host_resources(host
);
471 /* He's the server, initiate lock recovery. */
472 nlmclnt_recovery(host
);
475 nlm_release_host(host
);
480 mutex_unlock(&nlm_host_mutex
);
485 * Shut down the hosts module.
486 * Note that this routine is called only at server shutdown time.
489 nlm_shutdown_hosts(void)
491 struct hlist_head
*chain
;
492 struct hlist_node
*pos
;
493 struct nlm_host
*host
;
495 dprintk("lockd: shutting down host module\n");
496 mutex_lock(&nlm_host_mutex
);
498 /* First, make all hosts eligible for gc */
499 dprintk("lockd: nuking all hosts...\n");
500 for (chain
= nlm_hosts
; chain
< nlm_hosts
+ NLM_HOST_NRHASH
; ++chain
) {
501 hlist_for_each_entry(host
, pos
, chain
, h_hash
) {
502 host
->h_expires
= jiffies
- 1;
503 if (host
->h_rpcclnt
) {
504 rpc_shutdown_client(host
->h_rpcclnt
);
505 host
->h_rpcclnt
= NULL
;
510 /* Then, perform a garbage collection pass */
512 mutex_unlock(&nlm_host_mutex
);
514 /* complain if any hosts are left */
516 printk(KERN_WARNING
"lockd: couldn't shutdown host module!\n");
517 dprintk("lockd: %d hosts left:\n", nrhosts
);
518 for (chain
= nlm_hosts
; chain
< nlm_hosts
+ NLM_HOST_NRHASH
; ++chain
) {
519 hlist_for_each_entry(host
, pos
, chain
, h_hash
) {
520 dprintk(" %s (cnt %d use %d exp %ld)\n",
521 host
->h_name
, atomic_read(&host
->h_count
),
522 host
->h_inuse
, host
->h_expires
);
529 * Garbage collect any unused NLM hosts.
530 * This GC combines reference counting for async operations with
531 * mark & sweep for resources held by remote clients.
536 struct hlist_head
*chain
;
537 struct hlist_node
*pos
, *next
;
538 struct nlm_host
*host
;
540 dprintk("lockd: host garbage collection\n");
541 for (chain
= nlm_hosts
; chain
< nlm_hosts
+ NLM_HOST_NRHASH
; ++chain
) {
542 hlist_for_each_entry(host
, pos
, chain
, h_hash
)
546 /* Mark all hosts that hold locks, blocks or shares */
547 nlmsvc_mark_resources();
549 for (chain
= nlm_hosts
; chain
< nlm_hosts
+ NLM_HOST_NRHASH
; ++chain
) {
550 hlist_for_each_entry_safe(host
, pos
, next
, chain
, h_hash
) {
551 if (atomic_read(&host
->h_count
) || host
->h_inuse
552 || time_before(jiffies
, host
->h_expires
)) {
553 dprintk("nlm_gc_hosts skipping %s (cnt %d use %d exp %ld)\n",
554 host
->h_name
, atomic_read(&host
->h_count
),
555 host
->h_inuse
, host
->h_expires
);
558 dprintk("lockd: delete host %s\n", host
->h_name
);
559 hlist_del_init(&host
->h_hash
);
561 nlm_destroy_host(host
);
566 next_gc
= jiffies
+ NLM_HOST_COLLECT
;