1 // SPDX-License-Identifier: GPL-2.0
3 * linux/fs/lockd/host.c
5 * Management for NLM peer hosts. The nlm_host struct is shared
6 * between client and server implementation. The only reason to
7 * do so is to reduce code bloat.
9 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
12 #include <linux/types.h>
13 #include <linux/slab.h>
15 #include <linux/in6.h>
16 #include <linux/sunrpc/clnt.h>
17 #include <linux/sunrpc/addr.h>
18 #include <linux/sunrpc/svc.h>
19 #include <linux/lockd/lockd.h>
20 #include <linux/mutex.h>
22 #include <linux/sunrpc/svc_xprt.h>
28 #define NLMDBG_FACILITY NLMDBG_HOSTCACHE
29 #define NLM_HOST_NRHASH 32
30 #define NLM_HOST_REBIND (60 * HZ)
31 #define NLM_HOST_EXPIRE (300 * HZ)
32 #define NLM_HOST_COLLECT (120 * HZ)
34 static struct hlist_head nlm_server_hosts
[NLM_HOST_NRHASH
];
35 static struct hlist_head nlm_client_hosts
[NLM_HOST_NRHASH
];
37 #define for_each_host(host, chain, table) \
38 for ((chain) = (table); \
39 (chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
40 hlist_for_each_entry((host), (chain), h_hash)
42 #define for_each_host_safe(host, next, chain, table) \
43 for ((chain) = (table); \
44 (chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
45 hlist_for_each_entry_safe((host), (next), \
48 static unsigned long nrhosts
;
49 static DEFINE_MUTEX(nlm_host_mutex
);
51 static void nlm_gc_hosts(struct net
*net
);
53 struct nlm_lookup_host_info
{
54 const int server
; /* search for server|client */
55 const struct sockaddr
*sap
; /* address to search for */
56 const size_t salen
; /* it's length */
57 const unsigned short protocol
; /* transport to search for*/
58 const u32 version
; /* NLM version to search for */
59 const char *hostname
; /* remote's hostname */
60 const size_t hostname_len
; /* it's length */
61 const int noresvport
; /* use non-priv port */
62 struct net
*net
; /* network namespace to bind */
66 * Hash function must work well on big- and little-endian platforms
68 static unsigned int __nlm_hash32(const __be32 n
)
70 unsigned int hash
= (__force u32
)n
^ ((__force u32
)n
>> 16);
71 return hash
^ (hash
>> 8);
74 static unsigned int __nlm_hash_addr4(const struct sockaddr
*sap
)
76 const struct sockaddr_in
*sin
= (struct sockaddr_in
*)sap
;
77 return __nlm_hash32(sin
->sin_addr
.s_addr
);
80 static unsigned int __nlm_hash_addr6(const struct sockaddr
*sap
)
82 const struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)sap
;
83 const struct in6_addr addr
= sin6
->sin6_addr
;
84 return __nlm_hash32(addr
.s6_addr32
[0]) ^
85 __nlm_hash32(addr
.s6_addr32
[1]) ^
86 __nlm_hash32(addr
.s6_addr32
[2]) ^
87 __nlm_hash32(addr
.s6_addr32
[3]);
90 static unsigned int nlm_hash_address(const struct sockaddr
*sap
)
94 switch (sap
->sa_family
) {
96 hash
= __nlm_hash_addr4(sap
);
99 hash
= __nlm_hash_addr6(sap
);
104 return hash
& (NLM_HOST_NRHASH
- 1);
108 * Allocate and initialize an nlm_host. Common to both client and server.
110 static struct nlm_host
*nlm_alloc_host(struct nlm_lookup_host_info
*ni
,
111 struct nsm_handle
*nsm
)
113 struct nlm_host
*host
= NULL
;
114 unsigned long now
= jiffies
;
117 atomic_inc(&nsm
->sm_count
);
120 nsm
= nsm_get_handle(ni
->net
, ni
->sap
, ni
->salen
,
121 ni
->hostname
, ni
->hostname_len
);
122 if (unlikely(nsm
== NULL
)) {
123 dprintk("lockd: %s failed; no nsm handle\n",
129 host
= kmalloc(sizeof(*host
), GFP_KERNEL
);
130 if (unlikely(host
== NULL
)) {
131 dprintk("lockd: %s failed; no memory\n", __func__
);
136 memcpy(nlm_addr(host
), ni
->sap
, ni
->salen
);
137 host
->h_addrlen
= ni
->salen
;
138 rpc_set_port(nlm_addr(host
), 0);
139 host
->h_srcaddrlen
= 0;
141 host
->h_rpcclnt
= NULL
;
142 host
->h_name
= nsm
->sm_name
;
143 host
->h_version
= ni
->version
;
144 host
->h_proto
= ni
->protocol
;
145 host
->h_reclaiming
= 0;
146 host
->h_server
= ni
->server
;
147 host
->h_noresvport
= ni
->noresvport
;
149 init_waitqueue_head(&host
->h_gracewait
);
150 init_rwsem(&host
->h_rwsem
);
152 host
->h_nsmstate
= 0;
153 host
->h_pidcount
= 0;
154 atomic_set(&host
->h_count
, 1);
155 mutex_init(&host
->h_mutex
);
156 host
->h_nextrebind
= now
+ NLM_HOST_REBIND
;
157 host
->h_expires
= now
+ NLM_HOST_EXPIRE
;
158 INIT_LIST_HEAD(&host
->h_lockowners
);
159 spin_lock_init(&host
->h_lock
);
160 INIT_LIST_HEAD(&host
->h_granted
);
161 INIT_LIST_HEAD(&host
->h_reclaim
);
162 host
->h_nsmhandle
= nsm
;
163 host
->h_addrbuf
= nsm
->sm_addrbuf
;
165 strlcpy(host
->nodename
, utsname()->nodename
, sizeof(host
->nodename
));
172 * Destroy an nlm_host and free associated resources
174 * Caller must hold nlm_host_mutex.
176 static void nlm_destroy_host_locked(struct nlm_host
*host
)
178 struct rpc_clnt
*clnt
;
179 struct lockd_net
*ln
= net_generic(host
->net
, lockd_net_id
);
181 dprintk("lockd: destroy host %s\n", host
->h_name
);
183 hlist_del_init(&host
->h_hash
);
186 nsm_release(host
->h_nsmhandle
);
188 clnt
= host
->h_rpcclnt
;
190 rpc_shutdown_client(clnt
);
198 * nlmclnt_lookup_host - Find an NLM host handle matching a remote server
199 * @sap: network address of server
200 * @salen: length of server address
201 * @protocol: transport protocol to use
202 * @version: NLM protocol version
203 * @hostname: '\0'-terminated hostname of server
204 * @noresvport: 1 if non-privileged port should be used
206 * Returns an nlm_host structure that matches the passed-in
207 * [server address, transport protocol, NLM version, server hostname].
208 * If one doesn't already exist in the host cache, a new handle is
209 * created and returned.
211 struct nlm_host
*nlmclnt_lookup_host(const struct sockaddr
*sap
,
213 const unsigned short protocol
,
215 const char *hostname
,
219 struct nlm_lookup_host_info ni
= {
223 .protocol
= protocol
,
225 .hostname
= hostname
,
226 .hostname_len
= strlen(hostname
),
227 .noresvport
= noresvport
,
230 struct hlist_head
*chain
;
231 struct nlm_host
*host
;
232 struct nsm_handle
*nsm
= NULL
;
233 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
235 dprintk("lockd: %s(host='%s', vers=%u, proto=%s)\n", __func__
,
236 (hostname
? hostname
: "<none>"), version
,
237 (protocol
== IPPROTO_UDP
? "udp" : "tcp"));
239 mutex_lock(&nlm_host_mutex
);
241 chain
= &nlm_client_hosts
[nlm_hash_address(sap
)];
242 hlist_for_each_entry(host
, chain
, h_hash
) {
243 if (host
->net
!= net
)
245 if (!rpc_cmp_addr(nlm_addr(host
), sap
))
248 /* Same address. Share an NSM handle if we already have one */
250 nsm
= host
->h_nsmhandle
;
252 if (host
->h_proto
!= protocol
)
254 if (host
->h_version
!= version
)
258 dprintk("lockd: %s found host %s (%s)\n", __func__
,
259 host
->h_name
, host
->h_addrbuf
);
263 host
= nlm_alloc_host(&ni
, nsm
);
264 if (unlikely(host
== NULL
))
267 hlist_add_head(&host
->h_hash
, chain
);
271 dprintk("lockd: %s created host %s (%s)\n", __func__
,
272 host
->h_name
, host
->h_addrbuf
);
275 mutex_unlock(&nlm_host_mutex
);
280 * nlmclnt_release_host - release client nlm_host
281 * @host: nlm_host to release
284 void nlmclnt_release_host(struct nlm_host
*host
)
289 dprintk("lockd: release client host %s\n", host
->h_name
);
291 WARN_ON_ONCE(host
->h_server
);
293 if (atomic_dec_and_mutex_lock(&host
->h_count
, &nlm_host_mutex
)) {
294 WARN_ON_ONCE(!list_empty(&host
->h_lockowners
));
295 WARN_ON_ONCE(!list_empty(&host
->h_granted
));
296 WARN_ON_ONCE(!list_empty(&host
->h_reclaim
));
298 nlm_destroy_host_locked(host
);
299 mutex_unlock(&nlm_host_mutex
);
304 * nlmsvc_lookup_host - Find an NLM host handle matching a remote client
305 * @rqstp: incoming NLM request
306 * @hostname: name of client host
307 * @hostname_len: length of client hostname
309 * Returns an nlm_host structure that matches the [client address,
310 * transport protocol, NLM version, client hostname] of the passed-in
311 * NLM request. If one doesn't already exist in the host cache, a
312 * new handle is created and returned.
314 * Before possibly creating a new nlm_host, construct a sockaddr
315 * for a specific source address in case the local system has
316 * multiple network addresses. The family of the address in
317 * rq_daddr is guaranteed to be the same as the family of the
318 * address in rq_addr, so it's safe to use the same family for
319 * the source address.
321 struct nlm_host
*nlmsvc_lookup_host(const struct svc_rqst
*rqstp
,
322 const char *hostname
,
323 const size_t hostname_len
)
325 struct hlist_head
*chain
;
326 struct nlm_host
*host
= NULL
;
327 struct nsm_handle
*nsm
= NULL
;
328 struct sockaddr
*src_sap
= svc_daddr(rqstp
);
329 size_t src_len
= rqstp
->rq_daddrlen
;
330 struct net
*net
= SVC_NET(rqstp
);
331 struct nlm_lookup_host_info ni
= {
333 .sap
= svc_addr(rqstp
),
334 .salen
= rqstp
->rq_addrlen
,
335 .protocol
= rqstp
->rq_prot
,
336 .version
= rqstp
->rq_vers
,
337 .hostname
= hostname
,
338 .hostname_len
= hostname_len
,
341 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
343 dprintk("lockd: %s(host='%.*s', vers=%u, proto=%s)\n", __func__
,
344 (int)hostname_len
, hostname
, rqstp
->rq_vers
,
345 (rqstp
->rq_prot
== IPPROTO_UDP
? "udp" : "tcp"));
347 mutex_lock(&nlm_host_mutex
);
349 if (time_after_eq(jiffies
, ln
->next_gc
))
352 chain
= &nlm_server_hosts
[nlm_hash_address(ni
.sap
)];
353 hlist_for_each_entry(host
, chain
, h_hash
) {
354 if (host
->net
!= net
)
356 if (!rpc_cmp_addr(nlm_addr(host
), ni
.sap
))
359 /* Same address. Share an NSM handle if we already have one */
361 nsm
= host
->h_nsmhandle
;
363 if (host
->h_proto
!= ni
.protocol
)
365 if (host
->h_version
!= ni
.version
)
367 if (!rpc_cmp_addr(nlm_srcaddr(host
), src_sap
))
370 /* Move to head of hash chain. */
371 hlist_del(&host
->h_hash
);
372 hlist_add_head(&host
->h_hash
, chain
);
375 dprintk("lockd: %s found host %s (%s)\n",
376 __func__
, host
->h_name
, host
->h_addrbuf
);
380 host
= nlm_alloc_host(&ni
, nsm
);
381 if (unlikely(host
== NULL
))
384 memcpy(nlm_srcaddr(host
), src_sap
, src_len
);
385 host
->h_srcaddrlen
= src_len
;
386 hlist_add_head(&host
->h_hash
, chain
);
390 dprintk("lockd: %s created host %s (%s)\n",
391 __func__
, host
->h_name
, host
->h_addrbuf
);
394 mutex_unlock(&nlm_host_mutex
);
399 * nlmsvc_release_host - release server nlm_host
400 * @host: nlm_host to release
402 * Host is destroyed later in nlm_gc_host().
404 void nlmsvc_release_host(struct nlm_host
*host
)
409 dprintk("lockd: release server host %s\n", host
->h_name
);
411 WARN_ON_ONCE(!host
->h_server
);
412 atomic_dec(&host
->h_count
);
416 * Create the NLM RPC client for an NLM peer
419 nlm_bind_host(struct nlm_host
*host
)
421 struct rpc_clnt
*clnt
;
423 dprintk("lockd: nlm_bind_host %s (%s)\n",
424 host
->h_name
, host
->h_addrbuf
);
426 /* Lock host handle */
427 mutex_lock(&host
->h_mutex
);
429 /* If we've already created an RPC client, check whether
430 * RPC rebind is required
432 if ((clnt
= host
->h_rpcclnt
) != NULL
) {
433 if (time_after_eq(jiffies
, host
->h_nextrebind
)) {
434 rpc_force_rebind(clnt
);
435 host
->h_nextrebind
= jiffies
+ NLM_HOST_REBIND
;
436 dprintk("lockd: next rebind in %lu jiffies\n",
437 host
->h_nextrebind
- jiffies
);
440 unsigned long increment
= nlmsvc_timeout
;
441 struct rpc_timeout timeparms
= {
442 .to_initval
= increment
,
443 .to_increment
= increment
,
444 .to_maxval
= increment
* 6UL,
447 struct rpc_create_args args
= {
449 .protocol
= host
->h_proto
,
450 .address
= nlm_addr(host
),
451 .addrsize
= host
->h_addrlen
,
452 .timeout
= &timeparms
,
453 .servername
= host
->h_name
,
454 .program
= &nlm_program
,
455 .version
= host
->h_version
,
456 .authflavor
= RPC_AUTH_UNIX
,
457 .flags
= (RPC_CLNT_CREATE_NOPING
|
458 RPC_CLNT_CREATE_AUTOBIND
),
462 * lockd retries server side blocks automatically so we want
463 * those to be soft RPC calls. Client side calls need to be
467 args
.flags
|= RPC_CLNT_CREATE_HARDRTRY
;
468 if (host
->h_noresvport
)
469 args
.flags
|= RPC_CLNT_CREATE_NONPRIVPORT
;
470 if (host
->h_srcaddrlen
)
471 args
.saddress
= nlm_srcaddr(host
);
473 clnt
= rpc_create(&args
);
475 host
->h_rpcclnt
= clnt
;
477 printk("lockd: couldn't create RPC handle for %s\n", host
->h_name
);
482 mutex_unlock(&host
->h_mutex
);
487 * Force a portmap lookup of the remote lockd port
490 nlm_rebind_host(struct nlm_host
*host
)
492 dprintk("lockd: rebind host %s\n", host
->h_name
);
493 if (host
->h_rpcclnt
&& time_after_eq(jiffies
, host
->h_nextrebind
)) {
494 rpc_force_rebind(host
->h_rpcclnt
);
495 host
->h_nextrebind
= jiffies
+ NLM_HOST_REBIND
;
500 * Increment NLM host count
502 struct nlm_host
* nlm_get_host(struct nlm_host
*host
)
505 dprintk("lockd: get host %s\n", host
->h_name
);
506 atomic_inc(&host
->h_count
);
507 host
->h_expires
= jiffies
+ NLM_HOST_EXPIRE
;
512 static struct nlm_host
*next_host_state(struct hlist_head
*cache
,
513 struct nsm_handle
*nsm
,
514 const struct nlm_reboot
*info
)
516 struct nlm_host
*host
;
517 struct hlist_head
*chain
;
519 mutex_lock(&nlm_host_mutex
);
520 for_each_host(host
, chain
, cache
) {
521 if (host
->h_nsmhandle
== nsm
522 && host
->h_nsmstate
!= info
->state
) {
523 host
->h_nsmstate
= info
->state
;
527 mutex_unlock(&nlm_host_mutex
);
532 mutex_unlock(&nlm_host_mutex
);
537 * nlm_host_rebooted - Release all resources held by rebooted host
538 * @net: network namespace
539 * @info: pointer to decoded results of NLM_SM_NOTIFY call
541 * We were notified that the specified host has rebooted. Release
542 * all resources held by that peer.
544 void nlm_host_rebooted(const struct net
*net
, const struct nlm_reboot
*info
)
546 struct nsm_handle
*nsm
;
547 struct nlm_host
*host
;
549 nsm
= nsm_reboot_lookup(net
, info
);
550 if (unlikely(nsm
== NULL
))
553 /* Mark all hosts tied to this NSM state as having rebooted.
554 * We run the loop repeatedly, because we drop the host table
556 * To avoid processing a host several times, we match the nsmstate.
558 while ((host
= next_host_state(nlm_server_hosts
, nsm
, info
)) != NULL
) {
559 nlmsvc_free_host_resources(host
);
560 nlmsvc_release_host(host
);
562 while ((host
= next_host_state(nlm_client_hosts
, nsm
, info
)) != NULL
) {
563 nlmclnt_recovery(host
);
564 nlmclnt_release_host(host
);
570 static void nlm_complain_hosts(struct net
*net
)
572 struct hlist_head
*chain
;
573 struct nlm_host
*host
;
576 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
578 if (ln
->nrhosts
== 0)
580 pr_warn("lockd: couldn't shutdown host module for net %x!\n",
582 dprintk("lockd: %lu hosts left in net %x:\n", ln
->nrhosts
,
587 printk(KERN_WARNING
"lockd: couldn't shutdown host module!\n");
588 dprintk("lockd: %lu hosts left:\n", nrhosts
);
591 for_each_host(host
, chain
, nlm_server_hosts
) {
592 if (net
&& host
->net
!= net
)
594 dprintk(" %s (cnt %d use %d exp %ld net %x)\n",
595 host
->h_name
, atomic_read(&host
->h_count
),
596 host
->h_inuse
, host
->h_expires
, host
->net
->ns
.inum
);
601 nlm_shutdown_hosts_net(struct net
*net
)
603 struct hlist_head
*chain
;
604 struct nlm_host
*host
;
606 mutex_lock(&nlm_host_mutex
);
608 /* First, make all hosts eligible for gc */
609 dprintk("lockd: nuking all hosts in net %x...\n",
610 net
? net
->ns
.inum
: 0);
611 for_each_host(host
, chain
, nlm_server_hosts
) {
612 if (net
&& host
->net
!= net
)
614 host
->h_expires
= jiffies
- 1;
615 if (host
->h_rpcclnt
) {
616 rpc_shutdown_client(host
->h_rpcclnt
);
617 host
->h_rpcclnt
= NULL
;
621 /* Then, perform a garbage collection pass */
623 nlm_complain_hosts(net
);
624 mutex_unlock(&nlm_host_mutex
);
628 * Shut down the hosts module.
629 * Note that this routine is called only at server shutdown time.
632 nlm_shutdown_hosts(void)
634 dprintk("lockd: shutting down host module\n");
635 nlm_shutdown_hosts_net(NULL
);
639 * Garbage collect any unused NLM hosts.
640 * This GC combines reference counting for async operations with
641 * mark & sweep for resources held by remote clients.
644 nlm_gc_hosts(struct net
*net
)
646 struct hlist_head
*chain
;
647 struct hlist_node
*next
;
648 struct nlm_host
*host
;
650 dprintk("lockd: host garbage collection for net %x\n",
651 net
? net
->ns
.inum
: 0);
652 for_each_host(host
, chain
, nlm_server_hosts
) {
653 if (net
&& host
->net
!= net
)
658 /* Mark all hosts that hold locks, blocks or shares */
659 nlmsvc_mark_resources(net
);
661 for_each_host_safe(host
, next
, chain
, nlm_server_hosts
) {
662 if (net
&& host
->net
!= net
)
664 if (atomic_read(&host
->h_count
) || host
->h_inuse
665 || time_before(jiffies
, host
->h_expires
)) {
666 dprintk("nlm_gc_hosts skipping %s "
667 "(cnt %d use %d exp %ld net %x)\n",
668 host
->h_name
, atomic_read(&host
->h_count
),
669 host
->h_inuse
, host
->h_expires
,
673 nlm_destroy_host_locked(host
);
677 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
679 ln
->next_gc
= jiffies
+ NLM_HOST_COLLECT
;