[linux-2.6-block.git] / fs / lockd / host.c

// SPDX-License-Identifier: GPL-2.0
/*
 * linux/fs/lockd/host.c
 *
 * Management for NLM peer hosts. The nlm_host struct is shared
 * between client and server implementation. The only reason to
 * do so is to reduce code bloat.
 *
 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
 */

#include <linux/types.h>
#include <linux/slab.h>
#include <linux/in.h>
#include <linux/in6.h>
#include <linux/sunrpc/clnt.h>
#include <linux/sunrpc/addr.h>
#include <linux/sunrpc/svc.h>
#include <linux/lockd/lockd.h>
#include <linux/mutex.h>

#include <linux/sunrpc/svc_xprt.h>

#include <net/ipv6.h>

#include "netns.h"

#define NLMDBG_FACILITY		NLMDBG_HOSTCACHE
#define NLM_HOST_NRHASH		32
#define NLM_HOST_REBIND		(60 * HZ)
#define NLM_HOST_EXPIRE		(300 * HZ)
#define NLM_HOST_COLLECT	(120 * HZ)

static struct hlist_head	nlm_server_hosts[NLM_HOST_NRHASH];
static struct hlist_head	nlm_client_hosts[NLM_HOST_NRHASH];

#define for_each_host(host, chain, table) \
	for ((chain) = (table); \
	     (chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
		hlist_for_each_entry((host), (chain), h_hash)

#define for_each_host_safe(host, next, chain, table) \
	for ((chain) = (table); \
	     (chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
		hlist_for_each_entry_safe((host), (next), \
						(chain), h_hash)

static unsigned long		nrhosts;
static DEFINE_MUTEX(nlm_host_mutex);

static void			nlm_gc_hosts(struct net *net);

struct nlm_lookup_host_info {
	const int		server;		/* search for server|client */
	const struct sockaddr	*sap;		/* address to search for */
	const size_t		salen;		/* it's length */
	const unsigned short	protocol;	/* transport to search for*/
	const u32		version;	/* NLM version to search for */
	const char		*hostname;	/* remote's hostname */
	const size_t		hostname_len;	/* it's length */
	const int		noresvport;	/* use non-priv port */
	struct net		*net;		/* network namespace to bind */
	const struct cred	*cred;
};

/*
 * Hash function must work well on big- and little-endian platforms
 */
static unsigned int __nlm_hash32(const __be32 n)
{
	unsigned int hash = (__force u32)n ^ ((__force u32)n >> 16);
	return hash ^ (hash >> 8);
}

static unsigned int __nlm_hash_addr4(const struct sockaddr *sap)
{
	const struct sockaddr_in *sin = (struct sockaddr_in *)sap;
	return __nlm_hash32(sin->sin_addr.s_addr);
}

static unsigned int __nlm_hash_addr6(const struct sockaddr *sap)
{
	const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
	const struct in6_addr addr = sin6->sin6_addr;
	return __nlm_hash32(addr.s6_addr32[0]) ^
	       __nlm_hash32(addr.s6_addr32[1]) ^
	       __nlm_hash32(addr.s6_addr32[2]) ^
	       __nlm_hash32(addr.s6_addr32[3]);
}

static unsigned int nlm_hash_address(const struct sockaddr *sap)
{
	unsigned int hash;

	switch (sap->sa_family) {
	case AF_INET:
		hash = __nlm_hash_addr4(sap);
		break;
	case AF_INET6:
		hash = __nlm_hash_addr6(sap);
		break;
	default:
		hash = 0;
	}
	return hash & (NLM_HOST_NRHASH - 1);
}

/*
 * Allocate and initialize an nlm_host.  Common to both client and server.
 */
static struct nlm_host *nlm_alloc_host(struct nlm_lookup_host_info *ni,
				       struct nsm_handle *nsm)
{
	struct nlm_host *host = NULL;
	unsigned long now = jiffies;

	if (nsm != NULL)
		refcount_inc(&nsm->sm_count);
	else {
		nsm = nsm_get_handle(ni->net, ni->sap, ni->salen,
					ni->hostname, ni->hostname_len);
		if (unlikely(nsm == NULL)) {
			dprintk("lockd: %s failed; no nsm handle\n",
				__func__);
			goto out;
		}
	}

	host = kmalloc(sizeof(*host), GFP_KERNEL);
	if (unlikely(host == NULL)) {
		dprintk("lockd: %s failed; no memory\n", __func__);
		nsm_release(nsm);
		goto out;
	}

	memcpy(nlm_addr(host), ni->sap, ni->salen);
	host->h_addrlen    = ni->salen;
	rpc_set_port(nlm_addr(host), 0);
	host->h_srcaddrlen = 0;

	host->h_rpcclnt    = NULL;
	host->h_name	   = nsm->sm_name;
	host->h_version    = ni->version;
	host->h_proto      = ni->protocol;
	host->h_reclaiming = 0;
	host->h_server     = ni->server;
	host->h_noresvport = ni->noresvport;
	host->h_inuse      = 0;
	init_waitqueue_head(&host->h_gracewait);
	init_rwsem(&host->h_rwsem);
	host->h_state      = 0;
	host->h_nsmstate   = 0;
	host->h_pidcount   = 0;
	refcount_set(&host->h_count, 1);
	mutex_init(&host->h_mutex);
	host->h_nextrebind = now + NLM_HOST_REBIND;
	host->h_expires    = now + NLM_HOST_EXPIRE;
	INIT_LIST_HEAD(&host->h_lockowners);
	spin_lock_init(&host->h_lock);
	INIT_LIST_HEAD(&host->h_granted);
	INIT_LIST_HEAD(&host->h_reclaim);
	host->h_nsmhandle  = nsm;
	host->h_addrbuf    = nsm->sm_addrbuf;
	host->net	   = ni->net;
	host->h_cred	   = get_cred(ni->cred);
	strscpy(host->nodename, utsname()->nodename, sizeof(host->nodename));

out:
	return host;
}

/*
 * Destroy an nlm_host and free associated resources
 *
 * Caller must hold nlm_host_mutex.
 */
static void nlm_destroy_host_locked(struct nlm_host *host)
{
	struct rpc_clnt	*clnt;
	struct lockd_net *ln = net_generic(host->net, lockd_net_id);

	dprintk("lockd: destroy host %s\n", host->h_name);

	hlist_del_init(&host->h_hash);

	nsm_unmonitor(host);
	nsm_release(host->h_nsmhandle);

	clnt = host->h_rpcclnt;
	if (clnt != NULL)
		rpc_shutdown_client(clnt);
	put_cred(host->h_cred);
	kfree(host);

	ln->nrhosts--;
	nrhosts--;
}

/**
 * nlmclnt_lookup_host - Find an NLM host handle matching a remote server
 * @sap: network address of server
 * @salen: length of server address
 * @protocol: transport protocol to use
 * @version: NLM protocol version
 * @hostname: '\0'-terminated hostname of server
 * @noresvport: 1 if non-privileged port should be used
 * @net: pointer to net namespace
 * @cred: pointer to cred
 *
 * Returns an nlm_host structure that matches the passed-in
 * [server address, transport protocol, NLM version, server hostname].
 * If one doesn't already exist in the host cache, a new handle is
 * created and returned.
 */
struct nlm_host *nlmclnt_lookup_host(const struct sockaddr *sap,
				     const size_t salen,
				     const unsigned short protocol,
				     const u32 version,
				     const char *hostname,
				     int noresvport,
				     struct net *net,
				     const struct cred *cred)
{
	struct nlm_lookup_host_info ni = {
		.server		= 0,
		.sap		= sap,
		.salen		= salen,
		.protocol	= protocol,
		.version	= version,
		.hostname	= hostname,
		.hostname_len	= strlen(hostname),
		.noresvport	= noresvport,
		.net		= net,
		.cred		= cred,
	};
	struct hlist_head *chain;
	struct nlm_host	*host;
	struct nsm_handle *nsm = NULL;
	struct lockd_net *ln = net_generic(net, lockd_net_id);

	dprintk("lockd: %s(host='%s', vers=%u, proto=%s)\n", __func__,
			(hostname ? hostname : "<none>"), version,
			(protocol == IPPROTO_UDP ? "udp" : "tcp"));

	mutex_lock(&nlm_host_mutex);

	chain = &nlm_client_hosts[nlm_hash_address(sap)];
	hlist_for_each_entry(host, chain, h_hash) {
		if (host->net != net)
			continue;
		if (!rpc_cmp_addr(nlm_addr(host), sap))
			continue;

		/* Same address. Share an NSM handle if we already have one */
		if (nsm == NULL)
			nsm = host->h_nsmhandle;

		if (host->h_proto != protocol)
			continue;
		if (host->h_version != version)
			continue;

		nlm_get_host(host);
		dprintk("lockd: %s found host %s (%s)\n", __func__,
			host->h_name, host->h_addrbuf);
		goto out;
	}

	host = nlm_alloc_host(&ni, nsm);
	if (unlikely(host == NULL))
		goto out;

	hlist_add_head(&host->h_hash, chain);
	ln->nrhosts++;
	nrhosts++;

	dprintk("lockd: %s created host %s (%s)\n", __func__,
		host->h_name, host->h_addrbuf);

out:
	mutex_unlock(&nlm_host_mutex);
	return host;
}

/**
 * nlmclnt_release_host - release client nlm_host
 * @host: nlm_host to release
 *
 */
void nlmclnt_release_host(struct nlm_host *host)
{
	if (host == NULL)
		return;

	dprintk("lockd: release client host %s\n", host->h_name);

	WARN_ON_ONCE(host->h_server);

	if (refcount_dec_and_mutex_lock(&host->h_count, &nlm_host_mutex)) {
		WARN_ON_ONCE(!list_empty(&host->h_lockowners));
		WARN_ON_ONCE(!list_empty(&host->h_granted));
		WARN_ON_ONCE(!list_empty(&host->h_reclaim));

		nlm_destroy_host_locked(host);
		mutex_unlock(&nlm_host_mutex);
	}
}

/**
 * nlmsvc_lookup_host - Find an NLM host handle matching a remote client
 * @rqstp: incoming NLM request
 * @hostname: name of client host
 * @hostname_len: length of client hostname
 *
 * Returns an nlm_host structure that matches the [client address,
 * transport protocol, NLM version, client hostname] of the passed-in
 * NLM request.  If one doesn't already exist in the host cache, a
 * new handle is created and returned.
 *
 * Before possibly creating a new nlm_host, construct a sockaddr
 * for a specific source address in case the local system has
 * multiple network addresses.  The family of the address in
 * rq_daddr is guaranteed to be the same as the family of the
 * address in rq_addr, so it's safe to use the same family for
 * the source address.
 */
struct nlm_host *nlmsvc_lookup_host(const struct svc_rqst *rqstp,
				    const char *hostname,
				    const size_t hostname_len)
{
	struct hlist_head *chain;
	struct nlm_host	*host = NULL;
	struct nsm_handle *nsm = NULL;
	struct sockaddr *src_sap = svc_daddr(rqstp);
	size_t src_len = rqstp->rq_daddrlen;
	struct net *net = SVC_NET(rqstp);
	struct nlm_lookup_host_info ni = {
		.server		= 1,
		.sap		= svc_addr(rqstp),
		.salen		= rqstp->rq_addrlen,
		.protocol	= rqstp->rq_prot,
		.version	= rqstp->rq_vers,
		.hostname	= hostname,
		.hostname_len	= hostname_len,
		.net		= net,
	};
	struct lockd_net *ln = net_generic(net, lockd_net_id);

	dprintk("lockd: %s(host='%.*s', vers=%u, proto=%s)\n", __func__,
			(int)hostname_len, hostname, rqstp->rq_vers,
			(rqstp->rq_prot == IPPROTO_UDP ? "udp" : "tcp"));

	mutex_lock(&nlm_host_mutex);

	if (time_after_eq(jiffies, ln->next_gc))
		nlm_gc_hosts(net);

	chain = &nlm_server_hosts[nlm_hash_address(ni.sap)];
	hlist_for_each_entry(host, chain, h_hash) {
		if (host->net != net)
			continue;
		if (!rpc_cmp_addr(nlm_addr(host), ni.sap))
			continue;

		/* Same address. Share an NSM handle if we already have one */
		if (nsm == NULL)
			nsm = host->h_nsmhandle;

		if (host->h_proto != ni.protocol)
			continue;
		if (host->h_version != ni.version)
			continue;
		if (!rpc_cmp_addr(nlm_srcaddr(host), src_sap))
			continue;

		/* Move to head of hash chain. */
		hlist_del(&host->h_hash);
		hlist_add_head(&host->h_hash, chain);

		nlm_get_host(host);
		dprintk("lockd: %s found host %s (%s)\n",
			__func__, host->h_name, host->h_addrbuf);
		goto out;
	}

	host = nlm_alloc_host(&ni, nsm);
	if (unlikely(host == NULL))
		goto out;

	memcpy(nlm_srcaddr(host), src_sap, src_len);
	host->h_srcaddrlen = src_len;
	hlist_add_head(&host->h_hash, chain);
	ln->nrhosts++;
	nrhosts++;

	refcount_inc(&host->h_count);

	dprintk("lockd: %s created host %s (%s)\n",
		__func__, host->h_name, host->h_addrbuf);

out:
	mutex_unlock(&nlm_host_mutex);
	return host;
}

/**
 * nlmsvc_release_host - release server nlm_host
 * @host: nlm_host to release
 *
 * Host is destroyed later in nlm_gc_host().
 */
void nlmsvc_release_host(struct nlm_host *host)
{
	if (host == NULL)
		return;

	dprintk("lockd: release server host %s\n", host->h_name);

	WARN_ON_ONCE(!host->h_server);
	refcount_dec(&host->h_count);
}

/*
 * Create the NLM RPC client for an NLM peer
 */
struct rpc_clnt *
nlm_bind_host(struct nlm_host *host)
{
	struct rpc_clnt	*clnt;

	dprintk("lockd: nlm_bind_host %s (%s)\n",
			host->h_name, host->h_addrbuf);

	/* Lock host handle */
	mutex_lock(&host->h_mutex);

	/* If we've already created an RPC client, check whether
	 * RPC rebind is required
	 */
	if ((clnt = host->h_rpcclnt) != NULL) {
		nlm_rebind_host(host);
	} else {
		unsigned long increment = nlm_timeout * HZ;
		struct rpc_timeout timeparms = {
			.to_initval	= increment,
			.to_increment	= increment,
			.to_maxval	= increment * 6UL,
			.to_retries	= 5U,
		};
		struct rpc_create_args args = {
			.net		= host->net,
			.protocol	= host->h_proto,
			.address	= nlm_addr(host),
			.addrsize	= host->h_addrlen,
			.timeout	= &timeparms,
			.servername	= host->h_name,
			.program	= &nlm_program,
			.version	= host->h_version,
			.authflavor	= RPC_AUTH_UNIX,
			.flags		= (RPC_CLNT_CREATE_NOPING |
					   RPC_CLNT_CREATE_AUTOBIND |
					   RPC_CLNT_CREATE_REUSEPORT),
			.cred		= host->h_cred,
		};

		/*
		 * lockd retries server side blocks automatically so we want
		 * those to be soft RPC calls. Client side calls need to be
		 * hard RPC tasks.
		 */
		if (!host->h_server)
			args.flags |= RPC_CLNT_CREATE_HARDRTRY;
		if (host->h_noresvport)
			args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
		if (host->h_srcaddrlen)
			args.saddress = nlm_srcaddr(host);

		clnt = rpc_create(&args);
		if (!IS_ERR(clnt))
			host->h_rpcclnt = clnt;
		else {
			printk("lockd: couldn't create RPC handle for %s\n", host->h_name);
			clnt = NULL;
		}
	}

	mutex_unlock(&host->h_mutex);
	return clnt;
}

/**
 * nlm_rebind_host - If needed, force a portmap lookup of the peer's lockd port
 * @host: NLM host handle for peer
 *
 * This is not needed when using a connection-oriented protocol, such as TCP.
 * The existing autobind mechanism is sufficient to force a rebind when
 * required, e.g. on connection state transitions.
 */
void
nlm_rebind_host(struct nlm_host *host)
{
	if (host->h_proto != IPPROTO_UDP)
		return;

	if (host->h_rpcclnt && time_after_eq(jiffies, host->h_nextrebind)) {
		rpc_force_rebind(host->h_rpcclnt);
		host->h_nextrebind = jiffies + NLM_HOST_REBIND;
	}
}

/*
 * Increment NLM host count
 */
struct nlm_host * nlm_get_host(struct nlm_host *host)
{
	if (host) {
		dprintk("lockd: get host %s\n", host->h_name);
		refcount_inc(&host->h_count);
		host->h_expires = jiffies + NLM_HOST_EXPIRE;
	}
	return host;
}

static struct nlm_host *next_host_state(struct hlist_head *cache,
					struct nsm_handle *nsm,
					const struct nlm_reboot *info)
{
	struct nlm_host *host;
	struct hlist_head *chain;

	mutex_lock(&nlm_host_mutex);
	for_each_host(host, chain, cache) {
		if (host->h_nsmhandle == nsm
		    && host->h_nsmstate != info->state) {
			host->h_nsmstate = info->state;
			host->h_state++;

			nlm_get_host(host);
			mutex_unlock(&nlm_host_mutex);
			return host;
		}
	}

	mutex_unlock(&nlm_host_mutex);
	return NULL;
}

/**
 * nlm_host_rebooted - Release all resources held by rebooted host
 * @net:  network namespace
 * @info: pointer to decoded results of NLM_SM_NOTIFY call
 *
 * We were notified that the specified host has rebooted.  Release
 * all resources held by that peer.
 */
void nlm_host_rebooted(const struct net *net, const struct nlm_reboot *info)
{
	struct nsm_handle *nsm;
	struct nlm_host	*host;

	nsm = nsm_reboot_lookup(net, info);
	if (unlikely(nsm == NULL))
		return;

	/* Mark all hosts tied to this NSM state as having rebooted.
	 * We run the loop repeatedly, because we drop the host table
	 * lock for this.
	 * To avoid processing a host several times, we match the nsmstate.
	 */
	while ((host = next_host_state(nlm_server_hosts, nsm, info)) != NULL) {
		nlmsvc_free_host_resources(host);
		nlmsvc_release_host(host);
	}
	while ((host = next_host_state(nlm_client_hosts, nsm, info)) != NULL) {
		nlmclnt_recovery(host);
		nlmclnt_release_host(host);
	}

	nsm_release(nsm);
}

static void nlm_complain_hosts(struct net *net)
{
	struct hlist_head *chain;
	struct nlm_host	*host;

	if (net) {
		struct lockd_net *ln = net_generic(net, lockd_net_id);

		if (ln->nrhosts == 0)
			return;
		pr_warn("lockd: couldn't shutdown host module for net %x!\n",
			net->ns.inum);
		dprintk("lockd: %lu hosts left in net %x:\n", ln->nrhosts,
			net->ns.inum);
	} else {
		if (nrhosts == 0)
			return;
		printk(KERN_WARNING "lockd: couldn't shutdown host module!\n");
		dprintk("lockd: %lu hosts left:\n", nrhosts);
	}

	for_each_host(host, chain, nlm_server_hosts) {
		if (net && host->net != net)
			continue;
		dprintk("       %s (cnt %d use %d exp %ld net %x)\n",
			host->h_name, refcount_read(&host->h_count),
			host->h_inuse, host->h_expires, host->net->ns.inum);
	}
}

void
nlm_shutdown_hosts_net(struct net *net)
{
	struct hlist_head *chain;
	struct nlm_host	*host;

	mutex_lock(&nlm_host_mutex);

	/* First, make all hosts eligible for gc */
	dprintk("lockd: nuking all hosts in net %x...\n",
		net ? net->ns.inum : 0);
	for_each_host(host, chain, nlm_server_hosts) {
		if (net && host->net != net)
			continue;
		host->h_expires = jiffies - 1;
		if (host->h_rpcclnt) {
			rpc_shutdown_client(host->h_rpcclnt);
			host->h_rpcclnt = NULL;
		}
		nlmsvc_free_host_resources(host);
	}

	/* Then, perform a garbage collection pass */
	nlm_gc_hosts(net);
	nlm_complain_hosts(net);
	mutex_unlock(&nlm_host_mutex);
}

/*
 * Shut down the hosts module.
 * Note that this routine is called only at server shutdown time.
 */
void
nlm_shutdown_hosts(void)
{
	dprintk("lockd: shutting down host module\n");
	nlm_shutdown_hosts_net(NULL);
}

/*
 * Garbage collect any unused NLM hosts.
 * This GC combines reference counting for async operations with
 * mark & sweep for resources held by remote clients.
 */
static void
nlm_gc_hosts(struct net *net)
{
	struct hlist_head *chain;
	struct hlist_node *next;
	struct nlm_host	*host;

	dprintk("lockd: host garbage collection for net %x\n",
		net ? net->ns.inum : 0);
	for_each_host(host, chain, nlm_server_hosts) {
		if (net && host->net != net)
			continue;
		host->h_inuse = 0;
	}

	/* Mark all hosts that hold locks, blocks or shares */
	nlmsvc_mark_resources(net);

	for_each_host_safe(host, next, chain, nlm_server_hosts) {
		if (net && host->net != net)
			continue;
		if (host->h_inuse || time_before(jiffies, host->h_expires)) {
			dprintk("nlm_gc_hosts skipping %s "
				"(cnt %d use %d exp %ld net %x)\n",
				host->h_name, refcount_read(&host->h_count),
				host->h_inuse, host->h_expires,
				host->net->ns.inum);
			continue;
		}
		if (refcount_dec_if_one(&host->h_count))
			nlm_destroy_host_locked(host);
	}

	if (net) {
		struct lockd_net *ln = net_generic(net, lockd_net_id);

		ln->next_gc = jiffies + NLM_HOST_COLLECT;
	}
}
Commit	Line	Data
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* linux/fs/lockd/host.c
	4	*
	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.
	8	*
	9	* Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
	10	*/
	11
	12	#include <linux/types.h>
	13	#include <linux/slab.h>
	14	#include <linux/in.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>
	21
	22	#include <linux/sunrpc/svc_xprt.h>
	23
	24	#include <net/ipv6.h>
	25
	26	#include "netns.h"
	27
	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)
	33
	34	static struct hlist_head nlm_server_hosts[NLM_HOST_NRHASH];
	35	static struct hlist_head nlm_client_hosts[NLM_HOST_NRHASH];
	36
	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)
	41
	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), \
	46	(chain), h_hash)
	47
	48	static unsigned long nrhosts;
	49	static DEFINE_MUTEX(nlm_host_mutex);
	50
	51	static void nlm_gc_hosts(struct net *net);
	52
	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 */
	63	const struct cred *cred;
	64	};
	65
	66	/*
	67	* Hash function must work well on big- and little-endian platforms
	68	*/
	69	static unsigned int __nlm_hash32(const __be32 n)
	70	{
	71	unsigned int hash = (__force u32)n ^ ((__force u32)n >> 16);
	72	return hash ^ (hash >> 8);
	73	}
	74
	75	static unsigned int __nlm_hash_addr4(const struct sockaddr *sap)
	76	{
	77	const struct sockaddr_in sin = (struct sockaddr_in )sap;
	78	return __nlm_hash32(sin->sin_addr.s_addr);
	79	}
	80
	81	static unsigned int __nlm_hash_addr6(const struct sockaddr *sap)
	82	{
	83	const struct sockaddr_in6 sin6 = (struct sockaddr_in6 )sap;
	84	const struct in6_addr addr = sin6->sin6_addr;
	85	return __nlm_hash32(addr.s6_addr32[0]) ^
	86	__nlm_hash32(addr.s6_addr32[1]) ^
	87	__nlm_hash32(addr.s6_addr32[2]) ^
	88	__nlm_hash32(addr.s6_addr32[3]);
	89	}
	90
	91	static unsigned int nlm_hash_address(const struct sockaddr *sap)
	92	{
	93	unsigned int hash;
	94
	95	switch (sap->sa_family) {
	96	case AF_INET:
	97	hash = __nlm_hash_addr4(sap);
	98	break;
	99	case AF_INET6:
	100	hash = __nlm_hash_addr6(sap);
	101	break;
	102	default:
	103	hash = 0;
	104	}
	105	return hash & (NLM_HOST_NRHASH - 1);
	106	}
	107
	108	/*
	109	* Allocate and initialize an nlm_host. Common to both client and server.
	110	*/
	111	static struct nlm_host nlm_alloc_host(struct nlm_lookup_host_info ni,
	112	struct nsm_handle *nsm)
	113	{
	114	struct nlm_host *host = NULL;
	115	unsigned long now = jiffies;
	116
	117	if (nsm != NULL)
	118	refcount_inc(&nsm->sm_count);
	119	else {
	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",
	124	__func__);
	125	goto out;
	126	}
	127	}
	128
	129	host = kmalloc(sizeof(*host), GFP_KERNEL);
	130	if (unlikely(host == NULL)) {
	131	dprintk("lockd: %s failed; no memory\n", __func__);
	132	nsm_release(nsm);
	133	goto out;
	134	}
	135
	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;
	140
	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;
	148	host->h_inuse = 0;
	149	init_waitqueue_head(&host->h_gracewait);
	150	init_rwsem(&host->h_rwsem);
	151	host->h_state = 0;
	152	host->h_nsmstate = 0;
	153	host->h_pidcount = 0;
	154	refcount_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;
	164	host->net = ni->net;
	165	host->h_cred = get_cred(ni->cred);
	166	strscpy(host->nodename, utsname()->nodename, sizeof(host->nodename));
	167
	168	out:
	169	return host;
	170	}
	171
	172	/*
	173	* Destroy an nlm_host and free associated resources
	174	*
	175	* Caller must hold nlm_host_mutex.
	176	*/
	177	static void nlm_destroy_host_locked(struct nlm_host *host)
	178	{
	179	struct rpc_clnt *clnt;
	180	struct lockd_net *ln = net_generic(host->net, lockd_net_id);
	181
	182	dprintk("lockd: destroy host %s\n", host->h_name);
	183
	184	hlist_del_init(&host->h_hash);
	185
	186	nsm_unmonitor(host);
	187	nsm_release(host->h_nsmhandle);
	188
	189	clnt = host->h_rpcclnt;
	190	if (clnt != NULL)
	191	rpc_shutdown_client(clnt);
	192	put_cred(host->h_cred);
	193	kfree(host);
	194
	195	ln->nrhosts--;
	196	nrhosts--;
	197	}
	198
	199	/**
	200	* nlmclnt_lookup_host - Find an NLM host handle matching a remote server
	201	* @sap: network address of server
	202	* @salen: length of server address
	203	* @protocol: transport protocol to use
	204	* @version: NLM protocol version
	205	* @hostname: '\0'-terminated hostname of server
	206	* @noresvport: 1 if non-privileged port should be used
	207	* @net: pointer to net namespace
	208	* @cred: pointer to cred
	209	*
	210	* Returns an nlm_host structure that matches the passed-in
	211	* [server address, transport protocol, NLM version, server hostname].
	212	* If one doesn't already exist in the host cache, a new handle is
	213	* created and returned.
	214	*/
	215	struct nlm_host nlmclnt_lookup_host(const struct sockaddr sap,
	216	const size_t salen,
	217	const unsigned short protocol,
	218	const u32 version,
	219	const char *hostname,
	220	int noresvport,
	221	struct net *net,
	222	const struct cred *cred)
	223	{
	224	struct nlm_lookup_host_info ni = {
	225	.server = 0,
	226	.sap = sap,
	227	.salen = salen,
	228	.protocol = protocol,
	229	.version = version,
	230	.hostname = hostname,
	231	.hostname_len = strlen(hostname),
	232	.noresvport = noresvport,
	233	.net = net,
	234	.cred = cred,
	235	};
	236	struct hlist_head *chain;
	237	struct nlm_host *host;
	238	struct nsm_handle *nsm = NULL;
	239	struct lockd_net *ln = net_generic(net, lockd_net_id);
	240
	241	dprintk("lockd: %s(host='%s', vers=%u, proto=%s)\n", __func__,
	242	(hostname ? hostname : "<none>"), version,
	243	(protocol == IPPROTO_UDP ? "udp" : "tcp"));
	244
	245	mutex_lock(&nlm_host_mutex);
	246
	247	chain = &nlm_client_hosts[nlm_hash_address(sap)];
	248	hlist_for_each_entry(host, chain, h_hash) {
	249	if (host->net != net)
	250	continue;
	251	if (!rpc_cmp_addr(nlm_addr(host), sap))
	252	continue;
	253
	254	/* Same address. Share an NSM handle if we already have one */
	255	if (nsm == NULL)
	256	nsm = host->h_nsmhandle;
	257
	258	if (host->h_proto != protocol)
	259	continue;
	260	if (host->h_version != version)
	261	continue;
	262
	263	nlm_get_host(host);
	264	dprintk("lockd: %s found host %s (%s)\n", __func__,
	265	host->h_name, host->h_addrbuf);
	266	goto out;
	267	}
	268
	269	host = nlm_alloc_host(&ni, nsm);
	270	if (unlikely(host == NULL))
	271	goto out;
	272
	273	hlist_add_head(&host->h_hash, chain);
	274	ln->nrhosts++;
	275	nrhosts++;
	276
	277	dprintk("lockd: %s created host %s (%s)\n", __func__,
	278	host->h_name, host->h_addrbuf);
	279
	280	out:
	281	mutex_unlock(&nlm_host_mutex);
	282	return host;
	283	}
	284
	285	/**
	286	* nlmclnt_release_host - release client nlm_host
	287	* @host: nlm_host to release
	288	*
	289	*/
	290	void nlmclnt_release_host(struct nlm_host *host)
	291	{
	292	if (host == NULL)
	293	return;
	294
	295	dprintk("lockd: release client host %s\n", host->h_name);
	296
	297	WARN_ON_ONCE(host->h_server);
	298
	299	if (refcount_dec_and_mutex_lock(&host->h_count, &nlm_host_mutex)) {
	300	WARN_ON_ONCE(!list_empty(&host->h_lockowners));
	301	WARN_ON_ONCE(!list_empty(&host->h_granted));
	302	WARN_ON_ONCE(!list_empty(&host->h_reclaim));
	303
	304	nlm_destroy_host_locked(host);
	305	mutex_unlock(&nlm_host_mutex);
	306	}
	307	}
	308
	309	/**
	310	* nlmsvc_lookup_host - Find an NLM host handle matching a remote client
	311	* @rqstp: incoming NLM request
	312	* @hostname: name of client host
	313	* @hostname_len: length of client hostname
	314	*
	315	* Returns an nlm_host structure that matches the [client address,
	316	* transport protocol, NLM version, client hostname] of the passed-in
	317	* NLM request. If one doesn't already exist in the host cache, a
	318	* new handle is created and returned.
	319	*
	320	* Before possibly creating a new nlm_host, construct a sockaddr
	321	* for a specific source address in case the local system has
	322	* multiple network addresses. The family of the address in
	323	* rq_daddr is guaranteed to be the same as the family of the
	324	* address in rq_addr, so it's safe to use the same family for
	325	* the source address.
	326	*/
	327	struct nlm_host nlmsvc_lookup_host(const struct svc_rqst rqstp,
	328	const char *hostname,
	329	const size_t hostname_len)
	330	{
	331	struct hlist_head *chain;
	332	struct nlm_host *host = NULL;
	333	struct nsm_handle *nsm = NULL;
	334	struct sockaddr *src_sap = svc_daddr(rqstp);
	335	size_t src_len = rqstp->rq_daddrlen;
	336	struct net *net = SVC_NET(rqstp);
	337	struct nlm_lookup_host_info ni = {
	338	.server = 1,
	339	.sap = svc_addr(rqstp),
	340	.salen = rqstp->rq_addrlen,
	341	.protocol = rqstp->rq_prot,
	342	.version = rqstp->rq_vers,
	343	.hostname = hostname,
	344	.hostname_len = hostname_len,
	345	.net = net,
	346	};
	347	struct lockd_net *ln = net_generic(net, lockd_net_id);
	348
	349	dprintk("lockd: %s(host='%.*s', vers=%u, proto=%s)\n", __func__,
	350	(int)hostname_len, hostname, rqstp->rq_vers,
	351	(rqstp->rq_prot == IPPROTO_UDP ? "udp" : "tcp"));
	352
	353	mutex_lock(&nlm_host_mutex);
	354
	355	if (time_after_eq(jiffies, ln->next_gc))
	356	nlm_gc_hosts(net);
	357
	358	chain = &nlm_server_hosts[nlm_hash_address(ni.sap)];
	359	hlist_for_each_entry(host, chain, h_hash) {
	360	if (host->net != net)
	361	continue;
	362	if (!rpc_cmp_addr(nlm_addr(host), ni.sap))
	363	continue;
	364
	365	/* Same address. Share an NSM handle if we already have one */
	366	if (nsm == NULL)
	367	nsm = host->h_nsmhandle;
	368
	369	if (host->h_proto != ni.protocol)
	370	continue;
	371	if (host->h_version != ni.version)
	372	continue;
	373	if (!rpc_cmp_addr(nlm_srcaddr(host), src_sap))
	374	continue;
	375
	376	/* Move to head of hash chain. */
	377	hlist_del(&host->h_hash);
	378	hlist_add_head(&host->h_hash, chain);
	379
	380	nlm_get_host(host);
	381	dprintk("lockd: %s found host %s (%s)\n",
	382	__func__, host->h_name, host->h_addrbuf);
	383	goto out;
	384	}
	385
	386	host = nlm_alloc_host(&ni, nsm);
	387	if (unlikely(host == NULL))
	388	goto out;
	389
	390	memcpy(nlm_srcaddr(host), src_sap, src_len);
	391	host->h_srcaddrlen = src_len;
	392	hlist_add_head(&host->h_hash, chain);
	393	ln->nrhosts++;
	394	nrhosts++;
	395
	396	refcount_inc(&host->h_count);
	397
	398	dprintk("lockd: %s created host %s (%s)\n",
	399	__func__, host->h_name, host->h_addrbuf);
	400
	401	out:
	402	mutex_unlock(&nlm_host_mutex);
	403	return host;
	404	}
	405
	406	/**
	407	* nlmsvc_release_host - release server nlm_host
	408	* @host: nlm_host to release
	409	*
	410	* Host is destroyed later in nlm_gc_host().
	411	*/
	412	void nlmsvc_release_host(struct nlm_host *host)
	413	{
	414	if (host == NULL)
	415	return;
	416
	417	dprintk("lockd: release server host %s\n", host->h_name);
	418
	419	WARN_ON_ONCE(!host->h_server);
	420	refcount_dec(&host->h_count);
	421	}
	422
	423	/*
	424	* Create the NLM RPC client for an NLM peer
	425	*/
	426	struct rpc_clnt *
	427	nlm_bind_host(struct nlm_host *host)
	428	{
	429	struct rpc_clnt *clnt;
	430
	431	dprintk("lockd: nlm_bind_host %s (%s)\n",
	432	host->h_name, host->h_addrbuf);
	433
	434	/* Lock host handle */
	435	mutex_lock(&host->h_mutex);
	436
	437	/* If we've already created an RPC client, check whether
	438	* RPC rebind is required
	439	*/
	440	if ((clnt = host->h_rpcclnt) != NULL) {
	441	nlm_rebind_host(host);
	442	} else {
	443	unsigned long increment = nlm_timeout * HZ;
	444	struct rpc_timeout timeparms = {
	445	.to_initval = increment,
	446	.to_increment = increment,
	447	.to_maxval = increment * 6UL,
	448	.to_retries = 5U,
	449	};
	450	struct rpc_create_args args = {
	451	.net = host->net,
	452	.protocol = host->h_proto,
	453	.address = nlm_addr(host),
	454	.addrsize = host->h_addrlen,
	455	.timeout = &timeparms,
	456	.servername = host->h_name,
	457	.program = &nlm_program,
	458	.version = host->h_version,
	459	.authflavor = RPC_AUTH_UNIX,
	460	.flags = (RPC_CLNT_CREATE_NOPING \|
	461	RPC_CLNT_CREATE_AUTOBIND \|
	462	RPC_CLNT_CREATE_REUSEPORT),
	463	.cred = host->h_cred,
	464	};
	465
	466	/*
	467	* lockd retries server side blocks automatically so we want
	468	* those to be soft RPC calls. Client side calls need to be
	469	* hard RPC tasks.
	470	*/
	471	if (!host->h_server)
	472	args.flags \|= RPC_CLNT_CREATE_HARDRTRY;
	473	if (host->h_noresvport)
	474	args.flags \|= RPC_CLNT_CREATE_NONPRIVPORT;
	475	if (host->h_srcaddrlen)
	476	args.saddress = nlm_srcaddr(host);
	477
	478	clnt = rpc_create(&args);
	479	if (!IS_ERR(clnt))
	480	host->h_rpcclnt = clnt;
	481	else {
	482	printk("lockd: couldn't create RPC handle for %s\n", host->h_name);
	483	clnt = NULL;
	484	}
	485	}
	486
	487	mutex_unlock(&host->h_mutex);
	488	return clnt;
	489	}
	490
	491	/**
	492	* nlm_rebind_host - If needed, force a portmap lookup of the peer's lockd port
	493	* @host: NLM host handle for peer
	494	*
	495	* This is not needed when using a connection-oriented protocol, such as TCP.
	496	* The existing autobind mechanism is sufficient to force a rebind when
	497	* required, e.g. on connection state transitions.
	498	*/
	499	void
	500	nlm_rebind_host(struct nlm_host *host)
	501	{
	502	if (host->h_proto != IPPROTO_UDP)
	503	return;
	504
	505	if (host->h_rpcclnt && time_after_eq(jiffies, host->h_nextrebind)) {
	506	rpc_force_rebind(host->h_rpcclnt);
	507	host->h_nextrebind = jiffies + NLM_HOST_REBIND;
	508	}
	509	}
	510
	511	/*
	512	* Increment NLM host count
	513	*/
	514	struct nlm_host * nlm_get_host(struct nlm_host *host)
	515	{
	516	if (host) {
	517	dprintk("lockd: get host %s\n", host->h_name);
	518	refcount_inc(&host->h_count);
	519	host->h_expires = jiffies + NLM_HOST_EXPIRE;
	520	}
	521	return host;
	522	}
	523
	524	static struct nlm_host next_host_state(struct hlist_head cache,
	525	struct nsm_handle *nsm,
	526	const struct nlm_reboot *info)
	527	{
	528	struct nlm_host *host;
	529	struct hlist_head *chain;
	530
	531	mutex_lock(&nlm_host_mutex);
	532	for_each_host(host, chain, cache) {
	533	if (host->h_nsmhandle == nsm
	534	&& host->h_nsmstate != info->state) {
	535	host->h_nsmstate = info->state;
	536	host->h_state++;
	537
	538	nlm_get_host(host);
	539	mutex_unlock(&nlm_host_mutex);
	540	return host;
	541	}
	542	}
	543
	544	mutex_unlock(&nlm_host_mutex);
	545	return NULL;
	546	}
	547
	548	/**
	549	* nlm_host_rebooted - Release all resources held by rebooted host
	550	* @net: network namespace
	551	* @info: pointer to decoded results of NLM_SM_NOTIFY call
	552	*
	553	* We were notified that the specified host has rebooted. Release
	554	* all resources held by that peer.
	555	*/
	556	void nlm_host_rebooted(const struct net net, const struct nlm_reboot info)
	557	{
	558	struct nsm_handle *nsm;
	559	struct nlm_host *host;
	560
	561	nsm = nsm_reboot_lookup(net, info);
	562	if (unlikely(nsm == NULL))
	563	return;
	564
	565	/* Mark all hosts tied to this NSM state as having rebooted.
	566	* We run the loop repeatedly, because we drop the host table
	567	* lock for this.
	568	* To avoid processing a host several times, we match the nsmstate.
	569	*/
	570	while ((host = next_host_state(nlm_server_hosts, nsm, info)) != NULL) {
	571	nlmsvc_free_host_resources(host);
	572	nlmsvc_release_host(host);
	573	}
	574	while ((host = next_host_state(nlm_client_hosts, nsm, info)) != NULL) {
	575	nlmclnt_recovery(host);
	576	nlmclnt_release_host(host);
	577	}
	578
	579	nsm_release(nsm);
	580	}
	581
	582	static void nlm_complain_hosts(struct net *net)
	583	{
	584	struct hlist_head *chain;
	585	struct nlm_host *host;
	586
	587	if (net) {
	588	struct lockd_net *ln = net_generic(net, lockd_net_id);
	589
	590	if (ln->nrhosts == 0)
	591	return;
	592	pr_warn("lockd: couldn't shutdown host module for net %x!\n",
	593	net->ns.inum);
	594	dprintk("lockd: %lu hosts left in net %x:\n", ln->nrhosts,
	595	net->ns.inum);
	596	} else {
	597	if (nrhosts == 0)
	598	return;
	599	printk(KERN_WARNING "lockd: couldn't shutdown host module!\n");
	600	dprintk("lockd: %lu hosts left:\n", nrhosts);
	601	}
	602
	603	for_each_host(host, chain, nlm_server_hosts) {
	604	if (net && host->net != net)
	605	continue;
	606	dprintk(" %s (cnt %d use %d exp %ld net %x)\n",
	607	host->h_name, refcount_read(&host->h_count),
	608	host->h_inuse, host->h_expires, host->net->ns.inum);
	609	}
	610	}
	611
	612	void
	613	nlm_shutdown_hosts_net(struct net *net)
	614	{
	615	struct hlist_head *chain;
	616	struct nlm_host *host;
	617
	618	mutex_lock(&nlm_host_mutex);
	619
	620	/* First, make all hosts eligible for gc */
	621	dprintk("lockd: nuking all hosts in net %x...\n",
	622	net ? net->ns.inum : 0);
	623	for_each_host(host, chain, nlm_server_hosts) {
	624	if (net && host->net != net)
	625	continue;
	626	host->h_expires = jiffies - 1;
	627	if (host->h_rpcclnt) {
	628	rpc_shutdown_client(host->h_rpcclnt);
	629	host->h_rpcclnt = NULL;
	630	}
	631	nlmsvc_free_host_resources(host);
	632	}
	633
	634	/* Then, perform a garbage collection pass */
	635	nlm_gc_hosts(net);
	636	nlm_complain_hosts(net);
	637	mutex_unlock(&nlm_host_mutex);
	638	}
	639
	640	/*
	641	* Shut down the hosts module.
	642	* Note that this routine is called only at server shutdown time.
	643	*/
	644	void
	645	nlm_shutdown_hosts(void)
	646	{
	647	dprintk("lockd: shutting down host module\n");
	648	nlm_shutdown_hosts_net(NULL);
	649	}
	650
	651	/*
	652	* Garbage collect any unused NLM hosts.
	653	* This GC combines reference counting for async operations with
	654	* mark & sweep for resources held by remote clients.
	655	*/
	656	static void
	657	nlm_gc_hosts(struct net *net)
	658	{
	659	struct hlist_head *chain;
	660	struct hlist_node *next;
	661	struct nlm_host *host;
	662
	663	dprintk("lockd: host garbage collection for net %x\n",
	664	net ? net->ns.inum : 0);
	665	for_each_host(host, chain, nlm_server_hosts) {
	666	if (net && host->net != net)
	667	continue;
	668	host->h_inuse = 0;
	669	}
	670
	671	/* Mark all hosts that hold locks, blocks or shares */
	672	nlmsvc_mark_resources(net);
	673
	674	for_each_host_safe(host, next, chain, nlm_server_hosts) {
	675	if (net && host->net != net)
	676	continue;
	677	if (host->h_inuse \|\| time_before(jiffies, host->h_expires)) {
	678	dprintk("nlm_gc_hosts skipping %s "
	679	"(cnt %d use %d exp %ld net %x)\n",
	680	host->h_name, refcount_read(&host->h_count),
	681	host->h_inuse, host->h_expires,
	682	host->net->ns.inum);
	683	continue;
	684	}
	685	if (refcount_dec_if_one(&host->h_count))
	686	nlm_destroy_host_locked(host);
	687	}
	688
	689	if (net) {
	690	struct lockd_net *ln = net_generic(net, lockd_net_id);
	691
	692	ln->next_gc = jiffies + NLM_HOST_COLLECT;
	693	}
	694	}