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);
35 static struct nsm_handle
*nsm_find(const struct sockaddr
*sap
,
38 const size_t hostname_len
,
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 */
54 * Hash function must work well on big- and little-endian platforms
56 static unsigned int __nlm_hash32(const __be32 n
)
58 unsigned int hash
= (__force u32
)n
^ ((__force u32
)n
>> 16);
59 return hash
^ (hash
>> 8);
62 static unsigned int __nlm_hash_addr4(const struct sockaddr
*sap
)
64 const struct sockaddr_in
*sin
= (struct sockaddr_in
*)sap
;
65 return __nlm_hash32(sin
->sin_addr
.s_addr
);
68 static unsigned int __nlm_hash_addr6(const struct sockaddr
*sap
)
70 const struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)sap
;
71 const struct in6_addr addr
= sin6
->sin6_addr
;
72 return __nlm_hash32(addr
.s6_addr32
[0]) ^
73 __nlm_hash32(addr
.s6_addr32
[1]) ^
74 __nlm_hash32(addr
.s6_addr32
[2]) ^
75 __nlm_hash32(addr
.s6_addr32
[3]);
78 static unsigned int nlm_hash_address(const struct sockaddr
*sap
)
82 switch (sap
->sa_family
) {
84 hash
= __nlm_hash_addr4(sap
);
87 hash
= __nlm_hash_addr6(sap
);
92 return hash
& (NLM_HOST_NRHASH
- 1);
95 static void nlm_clear_port(struct sockaddr
*sap
)
97 switch (sap
->sa_family
) {
99 ((struct sockaddr_in
*)sap
)->sin_port
= 0;
102 ((struct sockaddr_in6
*)sap
)->sin6_port
= 0;
107 static void nlm_display_address(const struct sockaddr
*sap
,
108 char *buf
, const size_t len
)
110 const struct sockaddr_in
*sin
= (struct sockaddr_in
*)sap
;
111 const struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)sap
;
113 switch (sap
->sa_family
) {
115 snprintf(buf
, len
, "unspecified");
118 snprintf(buf
, len
, NIPQUAD_FMT
, NIPQUAD(sin
->sin_addr
.s_addr
));
121 if (ipv6_addr_v4mapped(&sin6
->sin6_addr
))
122 snprintf(buf
, len
, NIPQUAD_FMT
,
123 NIPQUAD(sin6
->sin6_addr
.s6_addr32
[3]));
125 snprintf(buf
, len
, NIP6_FMT
, NIP6(sin6
->sin6_addr
));
128 snprintf(buf
, len
, "unsupported address family");
134 * Common host lookup routine for server & client
136 static struct nlm_host
*nlm_lookup_host(struct nlm_lookup_host_info
*ni
)
138 struct hlist_head
*chain
;
139 struct hlist_node
*pos
;
140 struct nlm_host
*host
;
141 struct nsm_handle
*nsm
= NULL
;
143 mutex_lock(&nlm_host_mutex
);
145 if (time_after_eq(jiffies
, next_gc
))
148 /* We may keep several nlm_host objects for a peer, because each
149 * nlm_host is identified by
150 * (address, protocol, version, server/client)
151 * We could probably simplify this a little by putting all those
152 * different NLM rpc_clients into one single nlm_host object.
153 * This would allow us to have one nlm_host per address.
155 chain
= &nlm_hosts
[nlm_hash_address(ni
->sap
)];
156 hlist_for_each_entry(host
, pos
, chain
, h_hash
) {
157 if (!nlm_cmp_addr(nlm_addr(host
), ni
->sap
))
160 /* See if we have an NSM handle for this client */
162 nsm
= host
->h_nsmhandle
;
164 if (host
->h_proto
!= ni
->protocol
)
166 if (host
->h_version
!= ni
->version
)
168 if (host
->h_server
!= ni
->server
)
170 if (!nlm_cmp_addr(nlm_srcaddr(host
), ni
->src_sap
))
173 /* Move to head of hash chain. */
174 hlist_del(&host
->h_hash
);
175 hlist_add_head(&host
->h_hash
, chain
);
178 dprintk("lockd: nlm_lookup_host found host %s (%s)\n",
179 host
->h_name
, host
->h_addrbuf
);
184 * The host wasn't in our hash table. If we don't
185 * have an NSM handle for it yet, create one.
188 atomic_inc(&nsm
->sm_count
);
191 nsm
= nsm_find(ni
->sap
, ni
->salen
,
192 ni
->hostname
, ni
->hostname_len
, 1);
194 dprintk("lockd: nlm_lookup_host failed; "
200 host
= kzalloc(sizeof(*host
), GFP_KERNEL
);
203 dprintk("lockd: nlm_lookup_host failed; no memory\n");
206 host
->h_name
= nsm
->sm_name
;
207 memcpy(nlm_addr(host
), ni
->sap
, ni
->salen
);
208 host
->h_addrlen
= ni
->salen
;
209 nlm_clear_port(nlm_addr(host
));
210 memcpy(nlm_srcaddr(host
), ni
->src_sap
, ni
->src_len
);
211 host
->h_version
= ni
->version
;
212 host
->h_proto
= ni
->protocol
;
213 host
->h_rpcclnt
= NULL
;
214 mutex_init(&host
->h_mutex
);
215 host
->h_nextrebind
= jiffies
+ NLM_HOST_REBIND
;
216 host
->h_expires
= jiffies
+ NLM_HOST_EXPIRE
;
217 atomic_set(&host
->h_count
, 1);
218 init_waitqueue_head(&host
->h_gracewait
);
219 init_rwsem(&host
->h_rwsem
);
220 host
->h_state
= 0; /* pseudo NSM state */
221 host
->h_nsmstate
= 0; /* real NSM state */
222 host
->h_nsmhandle
= nsm
;
223 host
->h_server
= ni
->server
;
224 hlist_add_head(&host
->h_hash
, chain
);
225 INIT_LIST_HEAD(&host
->h_lockowners
);
226 spin_lock_init(&host
->h_lock
);
227 INIT_LIST_HEAD(&host
->h_granted
);
228 INIT_LIST_HEAD(&host
->h_reclaim
);
232 nlm_display_address((struct sockaddr
*)&host
->h_addr
,
233 host
->h_addrbuf
, sizeof(host
->h_addrbuf
));
234 nlm_display_address((struct sockaddr
*)&host
->h_srcaddr
,
235 host
->h_srcaddrbuf
, sizeof(host
->h_srcaddrbuf
));
237 dprintk("lockd: nlm_lookup_host created host %s\n",
241 mutex_unlock(&nlm_host_mutex
);
249 nlm_destroy_host(struct nlm_host
*host
)
251 struct rpc_clnt
*clnt
;
253 BUG_ON(!list_empty(&host
->h_lockowners
));
254 BUG_ON(atomic_read(&host
->h_count
));
257 * Release NSM handle and unmonitor host.
261 clnt
= host
->h_rpcclnt
;
263 rpc_shutdown_client(clnt
);
268 * nlmclnt_lookup_host - Find an NLM host handle matching a remote server
269 * @sap: network address of server
270 * @salen: length of server address
271 * @protocol: transport protocol to use
272 * @version: NLM protocol version
273 * @hostname: '\0'-terminated hostname of server
275 * Returns an nlm_host structure that matches the passed-in
276 * [server address, transport protocol, NLM version, server hostname].
277 * If one doesn't already exist in the host cache, a new handle is
278 * created and returned.
280 struct nlm_host
*nlmclnt_lookup_host(const struct sockaddr
*sap
,
282 const unsigned short protocol
,
283 const u32 version
, const char *hostname
)
285 const struct sockaddr source
= {
286 .sa_family
= AF_UNSPEC
,
288 struct nlm_lookup_host_info ni
= {
292 .protocol
= protocol
,
294 .hostname
= hostname
,
295 .hostname_len
= strlen(hostname
),
297 .src_len
= sizeof(source
),
300 dprintk("lockd: %s(host='%s', vers=%u, proto=%s)\n", __func__
,
301 (hostname
? hostname
: "<none>"), version
,
302 (protocol
== IPPROTO_UDP
? "udp" : "tcp"));
304 return nlm_lookup_host(&ni
);
308 * Find an NLM client handle in the cache. If there is none, create it.
311 nlmsvc_lookup_host(struct svc_rqst
*rqstp
,
312 const char *hostname
, unsigned int hostname_len
)
314 const struct sockaddr_in source
= {
315 .sin_family
= AF_INET
,
316 .sin_addr
= rqstp
->rq_daddr
.addr
,
318 struct nlm_lookup_host_info ni
= {
320 .sap
= svc_addr(rqstp
),
321 .salen
= rqstp
->rq_addrlen
,
322 .protocol
= rqstp
->rq_prot
,
323 .version
= rqstp
->rq_vers
,
324 .hostname
= hostname
,
325 .hostname_len
= hostname_len
,
326 .src_sap
= (struct sockaddr
*)&source
,
327 .src_len
= sizeof(source
),
330 dprintk("lockd: %s(host='%*s', vers=%u, proto=%s)\n", __func__
,
331 (int)hostname_len
, hostname
, rqstp
->rq_vers
,
332 (rqstp
->rq_prot
== IPPROTO_UDP
? "udp" : "tcp"));
334 return nlm_lookup_host(&ni
);
338 * Create the NLM RPC client for an NLM peer
341 nlm_bind_host(struct nlm_host
*host
)
343 struct rpc_clnt
*clnt
;
345 dprintk("lockd: nlm_bind_host %s (%s), my addr=%s\n",
346 host
->h_name
, host
->h_addrbuf
, host
->h_srcaddrbuf
);
348 /* Lock host handle */
349 mutex_lock(&host
->h_mutex
);
351 /* If we've already created an RPC client, check whether
352 * RPC rebind is required
354 if ((clnt
= host
->h_rpcclnt
) != NULL
) {
355 if (time_after_eq(jiffies
, host
->h_nextrebind
)) {
356 rpc_force_rebind(clnt
);
357 host
->h_nextrebind
= jiffies
+ NLM_HOST_REBIND
;
358 dprintk("lockd: next rebind in %lu jiffies\n",
359 host
->h_nextrebind
- jiffies
);
362 unsigned long increment
= nlmsvc_timeout
;
363 struct rpc_timeout timeparms
= {
364 .to_initval
= increment
,
365 .to_increment
= increment
,
366 .to_maxval
= increment
* 6UL,
369 struct rpc_create_args args
= {
370 .protocol
= host
->h_proto
,
371 .address
= nlm_addr(host
),
372 .addrsize
= host
->h_addrlen
,
373 .saddress
= nlm_srcaddr(host
),
374 .timeout
= &timeparms
,
375 .servername
= host
->h_name
,
376 .program
= &nlm_program
,
377 .version
= host
->h_version
,
378 .authflavor
= RPC_AUTH_UNIX
,
379 .flags
= (RPC_CLNT_CREATE_NOPING
|
380 RPC_CLNT_CREATE_AUTOBIND
),
384 * lockd retries server side blocks automatically so we want
385 * those to be soft RPC calls. Client side calls need to be
389 args
.flags
|= RPC_CLNT_CREATE_HARDRTRY
;
391 clnt
= rpc_create(&args
);
393 host
->h_rpcclnt
= clnt
;
395 printk("lockd: couldn't create RPC handle for %s\n", host
->h_name
);
400 mutex_unlock(&host
->h_mutex
);
405 * Force a portmap lookup of the remote lockd port
408 nlm_rebind_host(struct nlm_host
*host
)
410 dprintk("lockd: rebind host %s\n", host
->h_name
);
411 if (host
->h_rpcclnt
&& time_after_eq(jiffies
, host
->h_nextrebind
)) {
412 rpc_force_rebind(host
->h_rpcclnt
);
413 host
->h_nextrebind
= jiffies
+ NLM_HOST_REBIND
;
418 * Increment NLM host count
420 struct nlm_host
* nlm_get_host(struct nlm_host
*host
)
423 dprintk("lockd: get host %s\n", host
->h_name
);
424 atomic_inc(&host
->h_count
);
425 host
->h_expires
= jiffies
+ NLM_HOST_EXPIRE
;
431 * Release NLM host after use
433 void nlm_release_host(struct nlm_host
*host
)
436 dprintk("lockd: release host %s\n", host
->h_name
);
437 BUG_ON(atomic_read(&host
->h_count
) < 0);
438 if (atomic_dec_and_test(&host
->h_count
)) {
439 BUG_ON(!list_empty(&host
->h_lockowners
));
440 BUG_ON(!list_empty(&host
->h_granted
));
441 BUG_ON(!list_empty(&host
->h_reclaim
));
447 * We were notified that the host indicated by address &sin
449 * Release all resources held by that peer.
451 void nlm_host_rebooted(const struct sockaddr_in
*sin
,
452 const char *hostname
,
453 unsigned int hostname_len
,
456 struct hlist_head
*chain
;
457 struct hlist_node
*pos
;
458 struct nsm_handle
*nsm
;
459 struct nlm_host
*host
;
461 nsm
= nsm_find((struct sockaddr
*)sin
, sizeof(*sin
),
462 hostname
, hostname_len
, 0);
464 dprintk("lockd: never saw rebooted peer '%.*s' before\n",
465 hostname_len
, hostname
);
469 dprintk("lockd: nlm_host_rebooted(%.*s, %s)\n",
470 hostname_len
, hostname
, nsm
->sm_addrbuf
);
472 /* When reclaiming locks on this peer, make sure that
473 * we set up a new notification */
474 nsm
->sm_monitored
= 0;
476 /* Mark all hosts tied to this NSM state as having rebooted.
477 * We run the loop repeatedly, because we drop the host table
479 * To avoid processing a host several times, we match the nsmstate.
481 again
: mutex_lock(&nlm_host_mutex
);
482 for (chain
= nlm_hosts
; chain
< nlm_hosts
+ NLM_HOST_NRHASH
; ++chain
) {
483 hlist_for_each_entry(host
, pos
, chain
, h_hash
) {
484 if (host
->h_nsmhandle
== nsm
485 && host
->h_nsmstate
!= new_state
) {
486 host
->h_nsmstate
= new_state
;
490 mutex_unlock(&nlm_host_mutex
);
492 if (host
->h_server
) {
493 /* We're server for this guy, just ditch
494 * all the locks he held. */
495 nlmsvc_free_host_resources(host
);
497 /* He's the server, initiate lock recovery. */
498 nlmclnt_recovery(host
);
501 nlm_release_host(host
);
507 mutex_unlock(&nlm_host_mutex
);
511 * Shut down the hosts module.
512 * Note that this routine is called only at server shutdown time.
515 nlm_shutdown_hosts(void)
517 struct hlist_head
*chain
;
518 struct hlist_node
*pos
;
519 struct nlm_host
*host
;
521 dprintk("lockd: shutting down host module\n");
522 mutex_lock(&nlm_host_mutex
);
524 /* First, make all hosts eligible for gc */
525 dprintk("lockd: nuking all hosts...\n");
526 for (chain
= nlm_hosts
; chain
< nlm_hosts
+ NLM_HOST_NRHASH
; ++chain
) {
527 hlist_for_each_entry(host
, pos
, chain
, h_hash
) {
528 host
->h_expires
= jiffies
- 1;
529 if (host
->h_rpcclnt
) {
530 rpc_shutdown_client(host
->h_rpcclnt
);
531 host
->h_rpcclnt
= NULL
;
536 /* Then, perform a garbage collection pass */
538 mutex_unlock(&nlm_host_mutex
);
540 /* complain if any hosts are left */
542 printk(KERN_WARNING
"lockd: couldn't shutdown host module!\n");
543 dprintk("lockd: %d hosts left:\n", nrhosts
);
544 for (chain
= nlm_hosts
; chain
< nlm_hosts
+ NLM_HOST_NRHASH
; ++chain
) {
545 hlist_for_each_entry(host
, pos
, chain
, h_hash
) {
546 dprintk(" %s (cnt %d use %d exp %ld)\n",
547 host
->h_name
, atomic_read(&host
->h_count
),
548 host
->h_inuse
, host
->h_expires
);
555 * Garbage collect any unused NLM hosts.
556 * This GC combines reference counting for async operations with
557 * mark & sweep for resources held by remote clients.
562 struct hlist_head
*chain
;
563 struct hlist_node
*pos
, *next
;
564 struct nlm_host
*host
;
566 dprintk("lockd: host garbage collection\n");
567 for (chain
= nlm_hosts
; chain
< nlm_hosts
+ NLM_HOST_NRHASH
; ++chain
) {
568 hlist_for_each_entry(host
, pos
, chain
, h_hash
)
572 /* Mark all hosts that hold locks, blocks or shares */
573 nlmsvc_mark_resources();
575 for (chain
= nlm_hosts
; chain
< nlm_hosts
+ NLM_HOST_NRHASH
; ++chain
) {
576 hlist_for_each_entry_safe(host
, pos
, next
, chain
, h_hash
) {
577 if (atomic_read(&host
->h_count
) || host
->h_inuse
578 || time_before(jiffies
, host
->h_expires
)) {
579 dprintk("nlm_gc_hosts skipping %s (cnt %d use %d exp %ld)\n",
580 host
->h_name
, atomic_read(&host
->h_count
),
581 host
->h_inuse
, host
->h_expires
);
584 dprintk("lockd: delete host %s\n", host
->h_name
);
585 hlist_del_init(&host
->h_hash
);
587 nlm_destroy_host(host
);
592 next_gc
= jiffies
+ NLM_HOST_COLLECT
;
599 static LIST_HEAD(nsm_handles
);
600 static DEFINE_SPINLOCK(nsm_lock
);
602 static struct nsm_handle
*nsm_find(const struct sockaddr
*sap
,
604 const char *hostname
,
605 const size_t hostname_len
,
608 struct nsm_handle
*nsm
= NULL
;
609 struct nsm_handle
*pos
;
614 if (hostname
&& memchr(hostname
, '/', hostname_len
) != NULL
) {
615 if (printk_ratelimit()) {
616 printk(KERN_WARNING
"Invalid hostname \"%.*s\" "
617 "in NFS lock request\n",
618 (int)hostname_len
, hostname
);
624 spin_lock(&nsm_lock
);
625 list_for_each_entry(pos
, &nsm_handles
, sm_link
) {
627 if (hostname
&& nsm_use_hostnames
) {
628 if (strlen(pos
->sm_name
) != hostname_len
629 || memcmp(pos
->sm_name
, hostname
, hostname_len
))
631 } else if (!nlm_cmp_addr(nsm_addr(pos
), sap
))
633 atomic_inc(&pos
->sm_count
);
639 list_add(&nsm
->sm_link
, &nsm_handles
);
642 spin_unlock(&nsm_lock
);
647 nsm
= kzalloc(sizeof(*nsm
) + hostname_len
+ 1, GFP_KERNEL
);
651 memcpy(nsm_addr(nsm
), sap
, salen
);
652 nsm
->sm_addrlen
= salen
;
653 nsm
->sm_name
= (char *) (nsm
+ 1);
654 memcpy(nsm
->sm_name
, hostname
, hostname_len
);
655 nsm
->sm_name
[hostname_len
] = '\0';
656 nlm_display_address((struct sockaddr
*)&nsm
->sm_addr
,
657 nsm
->sm_addrbuf
, sizeof(nsm
->sm_addrbuf
));
658 atomic_set(&nsm
->sm_count
, 1);
662 spin_unlock(&nsm_lock
);
667 * Release an NSM handle
670 nsm_release(struct nsm_handle
*nsm
)
674 if (atomic_dec_and_lock(&nsm
->sm_count
, &nsm_lock
)) {
675 list_del(&nsm
->sm_link
);
676 spin_unlock(&nsm_lock
);