forked from luck/tmp_suning_uos_patched
031fd3aa20
It's currently possible for an unresponsive NLM client to completely lock up a server's lockd. The scenario is something like this: 1) client1 (or a process on the server) takes a lock on a file 2) client2 tries to take a blocking lock on the same file and awaits the callback 3) client2 goes unresponsive (plug pulled, network partition, etc) 4) client1 releases the lock ...at that point the server's lockd will try to queue up a GRANT_MSG callback for client2, but first it requeues the block with a timeout of 30s. nlm_async_call will attempt to bind the RPC client to client2 and will call rpc_ping. rpc_ping entails a sync RPC call and if client2 is unresponsive it will take around 60s for that to time out. Once it times out, it's already time to retry the block and the whole process repeats. Once in this situation, nlmsvc_retry_blocked will never return until the host starts responding again. lockd won't service new calls. Fix this by skipping the RPC ping on NLM RPC clients. This makes nlm_async_call return quickly when called. Signed-off-by: Jeff Layton <jlayton@redhat.com> Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
537 lines
13 KiB
C
537 lines
13 KiB
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/sunrpc/clnt.h>
|
|
#include <linux/sunrpc/svc.h>
|
|
#include <linux/lockd/lockd.h>
|
|
#include <linux/lockd/sm_inter.h>
|
|
#include <linux/mutex.h>
|
|
|
|
|
|
#define NLMDBG_FACILITY NLMDBG_HOSTCACHE
|
|
#define NLM_HOST_MAX 64
|
|
#define NLM_HOST_NRHASH 32
|
|
#define NLM_ADDRHASH(addr) (ntohl(addr) & (NLM_HOST_NRHASH-1))
|
|
#define NLM_HOST_REBIND (60 * HZ)
|
|
#define NLM_HOST_EXPIRE ((nrhosts > NLM_HOST_MAX)? 300 * HZ : 120 * HZ)
|
|
#define NLM_HOST_COLLECT ((nrhosts > NLM_HOST_MAX)? 120 * HZ : 60 * HZ)
|
|
|
|
static struct hlist_head nlm_hosts[NLM_HOST_NRHASH];
|
|
static unsigned long next_gc;
|
|
static int nrhosts;
|
|
static DEFINE_MUTEX(nlm_host_mutex);
|
|
|
|
|
|
static void nlm_gc_hosts(void);
|
|
static struct nsm_handle * __nsm_find(const struct sockaddr_in *,
|
|
const char *, unsigned int, int);
|
|
static struct nsm_handle * nsm_find(const struct sockaddr_in *sin,
|
|
const char *hostname,
|
|
unsigned int hostname_len);
|
|
|
|
/*
|
|
* Common host lookup routine for server & client
|
|
*/
|
|
static struct nlm_host *
|
|
nlm_lookup_host(int server, const struct sockaddr_in *sin,
|
|
int proto, int version, const char *hostname,
|
|
unsigned int hostname_len,
|
|
const struct sockaddr_in *ssin)
|
|
{
|
|
struct hlist_head *chain;
|
|
struct hlist_node *pos;
|
|
struct nlm_host *host;
|
|
struct nsm_handle *nsm = NULL;
|
|
int hash;
|
|
|
|
dprintk("lockd: nlm_lookup_host("NIPQUAD_FMT"->"NIPQUAD_FMT
|
|
", p=%d, v=%d, my role=%s, name=%.*s)\n",
|
|
NIPQUAD(ssin->sin_addr.s_addr),
|
|
NIPQUAD(sin->sin_addr.s_addr), proto, version,
|
|
server? "server" : "client",
|
|
hostname_len,
|
|
hostname? hostname : "<none>");
|
|
|
|
|
|
hash = NLM_ADDRHASH(sin->sin_addr.s_addr);
|
|
|
|
/* Lock hash table */
|
|
mutex_lock(&nlm_host_mutex);
|
|
|
|
if (time_after_eq(jiffies, next_gc))
|
|
nlm_gc_hosts();
|
|
|
|
/* We may keep several nlm_host objects for a peer, because each
|
|
* nlm_host is identified by
|
|
* (address, protocol, version, server/client)
|
|
* We could probably simplify this a little by putting all those
|
|
* different NLM rpc_clients into one single nlm_host object.
|
|
* This would allow us to have one nlm_host per address.
|
|
*/
|
|
chain = &nlm_hosts[hash];
|
|
hlist_for_each_entry(host, pos, chain, h_hash) {
|
|
if (!nlm_cmp_addr(&host->h_addr, sin))
|
|
continue;
|
|
|
|
/* See if we have an NSM handle for this client */
|
|
if (!nsm)
|
|
nsm = host->h_nsmhandle;
|
|
|
|
if (host->h_proto != proto)
|
|
continue;
|
|
if (host->h_version != version)
|
|
continue;
|
|
if (host->h_server != server)
|
|
continue;
|
|
if (!nlm_cmp_addr(&host->h_saddr, ssin))
|
|
continue;
|
|
|
|
/* Move to head of hash chain. */
|
|
hlist_del(&host->h_hash);
|
|
hlist_add_head(&host->h_hash, chain);
|
|
|
|
nlm_get_host(host);
|
|
goto out;
|
|
}
|
|
if (nsm)
|
|
atomic_inc(&nsm->sm_count);
|
|
|
|
host = NULL;
|
|
|
|
/* Sadly, the host isn't in our hash table yet. See if
|
|
* we have an NSM handle for it. If not, create one.
|
|
*/
|
|
if (!nsm && !(nsm = nsm_find(sin, hostname, hostname_len)))
|
|
goto out;
|
|
|
|
host = kzalloc(sizeof(*host), GFP_KERNEL);
|
|
if (!host) {
|
|
nsm_release(nsm);
|
|
goto out;
|
|
}
|
|
host->h_name = nsm->sm_name;
|
|
host->h_addr = *sin;
|
|
host->h_addr.sin_port = 0; /* ouch! */
|
|
host->h_saddr = *ssin;
|
|
host->h_version = version;
|
|
host->h_proto = proto;
|
|
host->h_rpcclnt = NULL;
|
|
mutex_init(&host->h_mutex);
|
|
host->h_nextrebind = jiffies + NLM_HOST_REBIND;
|
|
host->h_expires = jiffies + NLM_HOST_EXPIRE;
|
|
atomic_set(&host->h_count, 1);
|
|
init_waitqueue_head(&host->h_gracewait);
|
|
init_rwsem(&host->h_rwsem);
|
|
host->h_state = 0; /* pseudo NSM state */
|
|
host->h_nsmstate = 0; /* real NSM state */
|
|
host->h_nsmhandle = nsm;
|
|
host->h_server = server;
|
|
hlist_add_head(&host->h_hash, chain);
|
|
INIT_LIST_HEAD(&host->h_lockowners);
|
|
spin_lock_init(&host->h_lock);
|
|
INIT_LIST_HEAD(&host->h_granted);
|
|
INIT_LIST_HEAD(&host->h_reclaim);
|
|
|
|
if (++nrhosts > NLM_HOST_MAX)
|
|
next_gc = 0;
|
|
|
|
out:
|
|
mutex_unlock(&nlm_host_mutex);
|
|
return host;
|
|
}
|
|
|
|
/*
|
|
* Destroy a host
|
|
*/
|
|
static void
|
|
nlm_destroy_host(struct nlm_host *host)
|
|
{
|
|
struct rpc_clnt *clnt;
|
|
|
|
BUG_ON(!list_empty(&host->h_lockowners));
|
|
BUG_ON(atomic_read(&host->h_count));
|
|
|
|
/*
|
|
* Release NSM handle and unmonitor host.
|
|
*/
|
|
nsm_unmonitor(host);
|
|
|
|
clnt = host->h_rpcclnt;
|
|
if (clnt != NULL)
|
|
rpc_shutdown_client(clnt);
|
|
kfree(host);
|
|
}
|
|
|
|
/*
|
|
* Find an NLM server handle in the cache. If there is none, create it.
|
|
*/
|
|
struct nlm_host *
|
|
nlmclnt_lookup_host(const struct sockaddr_in *sin, int proto, int version,
|
|
const char *hostname, unsigned int hostname_len)
|
|
{
|
|
struct sockaddr_in ssin = {0};
|
|
|
|
return nlm_lookup_host(0, sin, proto, version,
|
|
hostname, hostname_len, &ssin);
|
|
}
|
|
|
|
/*
|
|
* Find an NLM client handle in the cache. If there is none, create it.
|
|
*/
|
|
struct nlm_host *
|
|
nlmsvc_lookup_host(struct svc_rqst *rqstp,
|
|
const char *hostname, unsigned int hostname_len)
|
|
{
|
|
struct sockaddr_in ssin = {0};
|
|
|
|
ssin.sin_addr = rqstp->rq_daddr.addr;
|
|
return nlm_lookup_host(1, svc_addr_in(rqstp),
|
|
rqstp->rq_prot, rqstp->rq_vers,
|
|
hostname, hostname_len, &ssin);
|
|
}
|
|
|
|
/*
|
|
* 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("NIPQUAD_FMT"->"NIPQUAD_FMT")\n",
|
|
NIPQUAD(host->h_saddr.sin_addr),
|
|
NIPQUAD(host->h_addr.sin_addr));
|
|
|
|
/* 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 %ld 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 = {
|
|
.protocol = host->h_proto,
|
|
.address = (struct sockaddr *)&host->h_addr,
|
|
.addrsize = sizeof(host->h_addr),
|
|
.saddress = (struct sockaddr *)&host->h_saddr,
|
|
.timeout = &timeparms,
|
|
.servername = host->h_name,
|
|
.program = &nlm_program,
|
|
.version = host->h_version,
|
|
.authflavor = RPC_AUTH_UNIX,
|
|
.flags = (RPC_CLNT_CREATE_HARDRTRY |
|
|
RPC_CLNT_CREATE_NOPING |
|
|
RPC_CLNT_CREATE_AUTOBIND),
|
|
};
|
|
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* Release NLM host after use
|
|
*/
|
|
void nlm_release_host(struct nlm_host *host)
|
|
{
|
|
if (host != NULL) {
|
|
dprintk("lockd: release host %s\n", host->h_name);
|
|
BUG_ON(atomic_read(&host->h_count) < 0);
|
|
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));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* We were notified that the host indicated by address &sin
|
|
* has rebooted.
|
|
* Release all resources held by that peer.
|
|
*/
|
|
void nlm_host_rebooted(const struct sockaddr_in *sin,
|
|
const char *hostname,
|
|
unsigned int hostname_len,
|
|
u32 new_state)
|
|
{
|
|
struct hlist_head *chain;
|
|
struct hlist_node *pos;
|
|
struct nsm_handle *nsm;
|
|
struct nlm_host *host;
|
|
|
|
dprintk("lockd: nlm_host_rebooted(%s, %u.%u.%u.%u)\n",
|
|
hostname, NIPQUAD(sin->sin_addr));
|
|
|
|
/* Find the NSM handle for this peer */
|
|
if (!(nsm = __nsm_find(sin, hostname, hostname_len, 0)))
|
|
return;
|
|
|
|
/* When reclaiming locks on this peer, make sure that
|
|
* we set up a new notification */
|
|
nsm->sm_monitored = 0;
|
|
|
|
/* 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.
|
|
*/
|
|
again: mutex_lock(&nlm_host_mutex);
|
|
for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
|
|
hlist_for_each_entry(host, pos, chain, h_hash) {
|
|
if (host->h_nsmhandle == nsm
|
|
&& host->h_nsmstate != new_state) {
|
|
host->h_nsmstate = new_state;
|
|
host->h_state++;
|
|
|
|
nlm_get_host(host);
|
|
mutex_unlock(&nlm_host_mutex);
|
|
|
|
if (host->h_server) {
|
|
/* We're server for this guy, just ditch
|
|
* all the locks he held. */
|
|
nlmsvc_free_host_resources(host);
|
|
} else {
|
|
/* He's the server, initiate lock recovery. */
|
|
nlmclnt_recovery(host);
|
|
}
|
|
|
|
nlm_release_host(host);
|
|
goto again;
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
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 (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
|
|
hlist_for_each_entry(host, pos, chain, h_hash) {
|
|
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);
|
|
|
|
/* complain if any hosts are left */
|
|
if (nrhosts) {
|
|
printk(KERN_WARNING "lockd: couldn't shutdown host module!\n");
|
|
dprintk("lockd: %d hosts left:\n", nrhosts);
|
|
for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
|
|
hlist_for_each_entry(host, pos, chain, h_hash) {
|
|
dprintk(" %s (cnt %d use %d exp %ld)\n",
|
|
host->h_name, atomic_read(&host->h_count),
|
|
host->h_inuse, host->h_expires);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* 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 (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
|
|
hlist_for_each_entry(host, pos, chain, h_hash)
|
|
host->h_inuse = 0;
|
|
}
|
|
|
|
/* Mark all hosts that hold locks, blocks or shares */
|
|
nlmsvc_mark_resources();
|
|
|
|
for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
|
|
hlist_for_each_entry_safe(host, pos, next, chain, h_hash) {
|
|
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;
|
|
}
|
|
dprintk("lockd: delete host %s\n", host->h_name);
|
|
hlist_del_init(&host->h_hash);
|
|
|
|
nlm_destroy_host(host);
|
|
nrhosts--;
|
|
}
|
|
}
|
|
|
|
next_gc = jiffies + NLM_HOST_COLLECT;
|
|
}
|
|
|
|
|
|
/*
|
|
* Manage NSM handles
|
|
*/
|
|
static LIST_HEAD(nsm_handles);
|
|
static DEFINE_MUTEX(nsm_mutex);
|
|
|
|
static struct nsm_handle *
|
|
__nsm_find(const struct sockaddr_in *sin,
|
|
const char *hostname, unsigned int hostname_len,
|
|
int create)
|
|
{
|
|
struct nsm_handle *nsm = NULL;
|
|
struct list_head *pos;
|
|
|
|
if (!sin)
|
|
return NULL;
|
|
|
|
if (hostname && memchr(hostname, '/', hostname_len) != NULL) {
|
|
if (printk_ratelimit()) {
|
|
printk(KERN_WARNING "Invalid hostname \"%.*s\" "
|
|
"in NFS lock request\n",
|
|
hostname_len, hostname);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
mutex_lock(&nsm_mutex);
|
|
list_for_each(pos, &nsm_handles) {
|
|
nsm = list_entry(pos, struct nsm_handle, sm_link);
|
|
|
|
if (hostname && nsm_use_hostnames) {
|
|
if (strlen(nsm->sm_name) != hostname_len
|
|
|| memcmp(nsm->sm_name, hostname, hostname_len))
|
|
continue;
|
|
} else if (!nlm_cmp_addr(&nsm->sm_addr, sin))
|
|
continue;
|
|
atomic_inc(&nsm->sm_count);
|
|
goto out;
|
|
}
|
|
|
|
if (!create) {
|
|
nsm = NULL;
|
|
goto out;
|
|
}
|
|
|
|
nsm = kzalloc(sizeof(*nsm) + hostname_len + 1, GFP_KERNEL);
|
|
if (nsm != NULL) {
|
|
nsm->sm_addr = *sin;
|
|
nsm->sm_name = (char *) (nsm + 1);
|
|
memcpy(nsm->sm_name, hostname, hostname_len);
|
|
nsm->sm_name[hostname_len] = '\0';
|
|
atomic_set(&nsm->sm_count, 1);
|
|
|
|
list_add(&nsm->sm_link, &nsm_handles);
|
|
}
|
|
|
|
out:
|
|
mutex_unlock(&nsm_mutex);
|
|
return nsm;
|
|
}
|
|
|
|
static struct nsm_handle *
|
|
nsm_find(const struct sockaddr_in *sin, const char *hostname,
|
|
unsigned int hostname_len)
|
|
{
|
|
return __nsm_find(sin, hostname, hostname_len, 1);
|
|
}
|
|
|
|
/*
|
|
* Release an NSM handle
|
|
*/
|
|
void
|
|
nsm_release(struct nsm_handle *nsm)
|
|
{
|
|
if (!nsm)
|
|
return;
|
|
if (atomic_dec_and_test(&nsm->sm_count)) {
|
|
mutex_lock(&nsm_mutex);
|
|
if (atomic_read(&nsm->sm_count) == 0) {
|
|
list_del(&nsm->sm_link);
|
|
kfree(nsm);
|
|
}
|
|
mutex_unlock(&nsm_mutex);
|
|
}
|
|
}
|