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

/*
 * 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/svc.h>
#include <linux/lockd/lockd.h>
#include <linux/mutex.h>

#include <linux/sunrpc/svc_xprt.h>

#include <net/ipv6.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, pos, chain, table) \
	for ((chain) = (table); \
	     (chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
		hlist_for_each_entry((host), (pos), (chain), h_hash)

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

static unsigned long		next_gc;
static unsigned long		nrhosts;
static DEFINE_MUTEX(nlm_host_mutex);

static void			nlm_gc_hosts(void);

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 */
};

/*
 * 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)
		atomic_inc(&nsm->sm_count);
	else {
		host = NULL;
		nsm = nsm_get_handle(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;
	atomic_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;

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;

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

	BUG_ON(!list_empty(&host->h_lockowners));
	BUG_ON(atomic_read(&host->h_count));

	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);
	kfree(host);

	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
 *
 * 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)
{
	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,
	};
	struct hlist_head *chain;
	struct hlist_node *pos;
	struct nlm_host	*host;
	struct nsm_handle *nsm = NULL;

	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, pos, 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);
	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);

	BUG_ON(atomic_read(&host->h_count) < 0);
	BUG_ON(host->h_server);

	if (atomic_dec_and_test(&host->h_count)) {
		BUG_ON(!list_empty(&host->h_lockowners));
		BUG_ON(!list_empty(&host->h_granted));
		BUG_ON(!list_empty(&host->h_reclaim));

		mutex_lock(&nlm_host_mutex);
		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 hlist_node *pos;
	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 = rqstp->rq_xprt->xpt_net;
	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,
	};

	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, next_gc))
		nlm_gc_hosts();

	chain = &nlm_server_hosts[nlm_hash_address(ni.sap)];
	hlist_for_each_entry(host, pos, 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);
	nrhosts++;

	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);

	BUG_ON(atomic_read(&host->h_count) < 0);
	BUG_ON(!host->h_server);
	atomic_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) {
		if (time_after_eq(jiffies, host->h_nextrebind)) {
			rpc_force_rebind(clnt);
			host->h_nextrebind = jiffies + NLM_HOST_REBIND;
			dprintk("lockd: next rebind in %lu jiffies\n",
					host->h_nextrebind - jiffies);
		}
	} else {
		unsigned long increment = nlmsvc_timeout;
		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),
		};

		/*
		 * 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;
}

/*
 * Force a portmap lookup of the remote lockd port
 */
void
nlm_rebind_host(struct nlm_host *host)
{
	dprintk("lockd: rebind host %s\n", host->h_name);
	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);
		atomic_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;
	struct hlist_node *pos;

	mutex_lock(&nlm_host_mutex);
	for_each_host(host, pos, 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
 * @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 nlm_reboot *info)
{
	struct nsm_handle *nsm;
	struct nlm_host	*host;

	nsm = nsm_reboot_lookup(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);
}

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

	dprintk("lockd: shutting down host module\n");
	mutex_lock(&nlm_host_mutex);

	/* First, make all hosts eligible for gc */
	dprintk("lockd: nuking all hosts...\n");
	for_each_host(host, pos, 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;
		}
	}

	/* Then, perform a garbage collection pass */
	nlm_gc_hosts();
	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)
{
	struct hlist_head *chain;
	struct hlist_node *pos;
	struct nlm_host	*host;

	nlm_shutdown_hosts_net(NULL);

	/* complain if any hosts are left */
	if (nrhosts != 0) {
		printk(KERN_WARNING "lockd: couldn't shutdown host module!\n");
		dprintk("lockd: %lu hosts left:\n", nrhosts);
		for_each_host(host, pos, chain, nlm_server_hosts) {
			dprintk("       %s (cnt %d use %d exp %ld net %p)\n",
				host->h_name, atomic_read(&host->h_count),
				host->h_inuse, host->h_expires, host->net);
		}
	}
}

/*
 * 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(void)
{
	struct hlist_head *chain;
	struct hlist_node *pos, *next;
	struct nlm_host	*host;

	dprintk("lockd: host garbage collection\n");
	for_each_host(host, pos, chain, nlm_server_hosts)
		host->h_inuse = 0;

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

	for_each_host_safe(host, pos, next, chain, nlm_server_hosts) {
		if (atomic_read(&host->h_count) || host->h_inuse
		 || time_before(jiffies, host->h_expires)) {
			dprintk("nlm_gc_hosts skipping %s "
				"(cnt %d use %d exp %ld)\n",
				host->h_name, atomic_read(&host->h_count),
				host->h_inuse, host->h_expires);
			continue;
		}
		nlm_destroy_host_locked(host);
	}

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