host.c 12.6 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * 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/sched.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>
Ingo Molnar's avatar
Ingo Molnar committed
19
#include <linux/mutex.h>
Linus Torvalds's avatar
Linus Torvalds committed
20 21 22 23 24 25 26 27 28 29


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

30
static struct hlist_head	nlm_hosts[NLM_HOST_NRHASH];
Linus Torvalds's avatar
Linus Torvalds committed
31 32
static unsigned long		next_gc;
static int			nrhosts;
Ingo Molnar's avatar
Ingo Molnar committed
33
static DEFINE_MUTEX(nlm_host_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
34 35 36


static void			nlm_gc_hosts(void);
37 38
static struct nsm_handle *	__nsm_find(const struct sockaddr_in *,
					const char *, int, int);
Linus Torvalds's avatar
Linus Torvalds committed
39 40 41 42 43

/*
 * Find an NLM server handle in the cache. If there is none, create it.
 */
struct nlm_host *
44 45
nlmclnt_lookup_host(const struct sockaddr_in *sin, int proto, int version,
			const char *hostname, int hostname_len)
Linus Torvalds's avatar
Linus Torvalds committed
46
{
47 48
	return nlm_lookup_host(0, sin, proto, version,
			       hostname, hostname_len);
Linus Torvalds's avatar
Linus Torvalds committed
49 50 51 52 53 54
}

/*
 * Find an NLM client handle in the cache. If there is none, create it.
 */
struct nlm_host *
55 56
nlmsvc_lookup_host(struct svc_rqst *rqstp,
			const char *hostname, int hostname_len)
Linus Torvalds's avatar
Linus Torvalds committed
57 58
{
	return nlm_lookup_host(1, &rqstp->rq_addr,
59 60
			       rqstp->rq_prot, rqstp->rq_vers,
			       hostname, hostname_len);
Linus Torvalds's avatar
Linus Torvalds committed
61 62 63 64 65 66
}

/*
 * Common host lookup routine for server & client
 */
struct nlm_host *
67
nlm_lookup_host(int server, const struct sockaddr_in *sin,
68 69 70
					int proto, int version,
					const char *hostname,
					int hostname_len)
Linus Torvalds's avatar
Linus Torvalds committed
71
{
72 73 74
	struct hlist_head *chain;
	struct hlist_node *pos;
	struct nlm_host	*host;
75
	struct nsm_handle *nsm = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
76 77
	int		hash;

78 79 80 81 82 83
	dprintk("lockd: nlm_lookup_host(%u.%u.%u.%u, p=%d, v=%d, my role=%s, name=%.*s)\n",
			NIPQUAD(sin->sin_addr.s_addr), proto, version,
			server? "server" : "client",
			hostname_len,
			hostname? hostname : "<none>");

Linus Torvalds's avatar
Linus Torvalds committed
84 85 86 87

	hash = NLM_ADDRHASH(sin->sin_addr.s_addr);

	/* Lock hash table */
Ingo Molnar's avatar
Ingo Molnar committed
88
	mutex_lock(&nlm_host_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
89 90 91 92

	if (time_after_eq(jiffies, next_gc))
		nlm_gc_hosts();

93 94 95 96 97 98 99
	/* 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.
	 */
100 101
	chain = &nlm_hosts[hash];
	hlist_for_each_entry(host, pos, chain, h_hash) {
102 103 104 105
		if (!nlm_cmp_addr(&host->h_addr, sin))
			continue;

		/* See if we have an NSM handle for this client */
106 107
		if (!nsm)
			nsm = host->h_nsmhandle;
108

Linus Torvalds's avatar
Linus Torvalds committed
109 110 111 112 113 114 115
		if (host->h_proto != proto)
			continue;
		if (host->h_version != version)
			continue;
		if (host->h_server != server)
			continue;

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

120 121
		nlm_get_host(host);
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
122
	}
123 124
	if (nsm)
		atomic_inc(&nsm->sm_count);
Linus Torvalds's avatar
Linus Torvalds committed
125

126 127
	host = NULL;

128 129 130 131 132
	/* 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;
Linus Torvalds's avatar
Linus Torvalds committed
133

134
	host = kzalloc(sizeof(*host), GFP_KERNEL);
135 136 137 138 139
	if (!host) {
		nsm_release(nsm);
		goto out;
	}
	host->h_name	   = nsm->sm_name;
Linus Torvalds's avatar
Linus Torvalds committed
140 141 142 143 144
	host->h_addr       = *sin;
	host->h_addr.sin_port = 0;	/* ouch! */
	host->h_version    = version;
	host->h_proto      = proto;
	host->h_rpcclnt    = NULL;
145
	mutex_init(&host->h_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
146 147 148 149
	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);
Trond Myklebust's avatar
Trond Myklebust committed
150
	init_rwsem(&host->h_rwsem);
Linus Torvalds's avatar
Linus Torvalds committed
151 152
	host->h_state      = 0;			/* pseudo NSM state */
	host->h_nsmstate   = 0;			/* real NSM state */
153
	host->h_nsmhandle  = nsm;
Linus Torvalds's avatar
Linus Torvalds committed
154
	host->h_server	   = server;
155
	hlist_add_head(&host->h_hash, chain);
Linus Torvalds's avatar
Linus Torvalds committed
156 157
	INIT_LIST_HEAD(&host->h_lockowners);
	spin_lock_init(&host->h_lock);
158 159
	INIT_LIST_HEAD(&host->h_granted);
	INIT_LIST_HEAD(&host->h_reclaim);
Linus Torvalds's avatar
Linus Torvalds committed
160 161 162 163

	if (++nrhosts > NLM_HOST_MAX)
		next_gc = 0;

164
out:
Ingo Molnar's avatar
Ingo Molnar committed
165
	mutex_unlock(&nlm_host_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
166 167 168
	return host;
}

169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196
/*
 * 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);

	if ((clnt = host->h_rpcclnt) != NULL) {
		if (atomic_read(&clnt->cl_users)) {
			printk(KERN_WARNING
				"lockd: active RPC handle\n");
			clnt->cl_dead = 1;
		} else {
			rpc_destroy_client(host->h_rpcclnt);
		}
	}
	kfree(host);
}

Linus Torvalds's avatar
Linus Torvalds committed
197 198 199 200 201 202 203 204 205 206 207 208
/*
 * 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(%08x)\n",
			(unsigned)ntohl(host->h_addr.sin_addr.s_addr));

	/* Lock host handle */
209
	mutex_lock(&host->h_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
210 211 212 213 214

	/* If we've already created an RPC client, check whether
	 * RPC rebind is required
	 */
	if ((clnt = host->h_rpcclnt) != NULL) {
215
		if (time_after_eq(jiffies, host->h_nextrebind)) {
216
			rpc_force_rebind(clnt);
Linus Torvalds's avatar
Linus Torvalds committed
217 218 219 220 221
			host->h_nextrebind = jiffies + NLM_HOST_REBIND;
			dprintk("lockd: next rebind in %ld jiffies\n",
					host->h_nextrebind - jiffies);
		}
	} else {
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
		unsigned long increment = nlmsvc_timeout * HZ;
		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),
			.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_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;
		}
Linus Torvalds's avatar
Linus Torvalds committed
249 250
	}

251
	mutex_unlock(&host->h_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
252 253 254 255 256 257 258 259 260 261 262
	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)) {
263
		rpc_force_rebind(host->h_rpcclnt);
Linus Torvalds's avatar
Linus Torvalds committed
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
		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);
289 290 291 292 293
		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));
		}
Linus Torvalds's avatar
Linus Torvalds committed
294 295 296
	}
}

297 298 299 300 301
/*
 * We were notified that the host indicated by address &sin
 * has rebooted.
 * Release all resources held by that peer.
 */
302 303 304
void nlm_host_rebooted(const struct sockaddr_in *sin,
				const char *hostname, int hostname_len,
				u32 new_state)
305
{
306 307
	struct hlist_head *chain;
	struct hlist_node *pos;
308
	struct nsm_handle *nsm;
309
	struct nlm_host	*host;
310

311 312 313 314 315
	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)))
316 317
		return;

318 319 320 321 322 323 324 325 326 327
	/* 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);
328 329
	for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
		hlist_for_each_entry(host, pos, chain, h_hash) {
330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
			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;
			}
		}
351
	}
352 353

	mutex_unlock(&nlm_host_mutex);
354 355
}

Linus Torvalds's avatar
Linus Torvalds committed
356 357 358 359 360 361 362
/*
 * Shut down the hosts module.
 * Note that this routine is called only at server shutdown time.
 */
void
nlm_shutdown_hosts(void)
{
363 364
	struct hlist_head *chain;
	struct hlist_node *pos;
Linus Torvalds's avatar
Linus Torvalds committed
365 366 367
	struct nlm_host	*host;

	dprintk("lockd: shutting down host module\n");
Ingo Molnar's avatar
Ingo Molnar committed
368
	mutex_lock(&nlm_host_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
369 370 371

	/* First, make all hosts eligible for gc */
	dprintk("lockd: nuking all hosts...\n");
372 373
	for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
		hlist_for_each_entry(host, pos, chain, h_hash)
Linus Torvalds's avatar
Linus Torvalds committed
374 375 376 377 378
			host->h_expires = jiffies - 1;
	}

	/* Then, perform a garbage collection pass */
	nlm_gc_hosts();
Ingo Molnar's avatar
Ingo Molnar committed
379
	mutex_unlock(&nlm_host_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
380 381 382 383 384

	/* 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);
385 386
		for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
			hlist_for_each_entry(host, pos, chain, h_hash) {
Linus Torvalds's avatar
Linus Torvalds committed
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
				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)
{
403 404 405
	struct hlist_head *chain;
	struct hlist_node *pos, *next;
	struct nlm_host	*host;
Linus Torvalds's avatar
Linus Torvalds committed
406 407

	dprintk("lockd: host garbage collection\n");
408 409
	for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
		hlist_for_each_entry(host, pos, chain, h_hash)
Linus Torvalds's avatar
Linus Torvalds committed
410 411 412 413 414 415
			host->h_inuse = 0;
	}

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

416 417
	for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) {
		hlist_for_each_entry_safe(host, pos, next, chain, h_hash) {
Linus Torvalds's avatar
Linus Torvalds committed
418 419 420 421 422 423 424 425
			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);
426
			hlist_del_init(&host->h_hash);
427

428
			nlm_destroy_host(host);
Linus Torvalds's avatar
Linus Torvalds committed
429 430 431 432 433 434 435
			nrhosts--;
		}
	}

	next_gc = jiffies + NLM_HOST_COLLECT;
}

436 437 438 439 440

/*
 * Manage NSM handles
 */
static LIST_HEAD(nsm_handles);
441
static DEFINE_MUTEX(nsm_mutex);
442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462

static struct nsm_handle *
__nsm_find(const struct sockaddr_in *sin,
		const char *hostname, 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;
	}

463
	mutex_lock(&nsm_mutex);
464 465 466
	list_for_each(pos, &nsm_handles) {
		nsm = list_entry(pos, struct nsm_handle, sm_link);

467 468 469 470 471
		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))
472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492
			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);
	}

493 494
out:
	mutex_unlock(&nsm_mutex);
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512
	return nsm;
}

struct nsm_handle *
nsm_find(const struct sockaddr_in *sin, const char *hostname, 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)) {
513
		mutex_lock(&nsm_mutex);
514 515 516 517
		if (atomic_read(&nsm->sm_count) == 0) {
			list_del(&nsm->sm_link);
			kfree(nsm);
		}
518
		mutex_unlock(&nsm_mutex);
519 520
	}
}