[mirror_ubuntu-artful-kernel.git] / fs / afs / server.c

/* AFS server record management
 *
 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/sched.h>
#include <linux/slab.h>
#include "internal.h"

static unsigned afs_server_timeout = 10;	/* server timeout in seconds */

static void afs_reap_server(struct work_struct *);

/* tree of all the servers, indexed by IP address */
static struct rb_root afs_servers = RB_ROOT;
static DEFINE_RWLOCK(afs_servers_lock);

/* LRU list of all the servers not currently in use */
static LIST_HEAD(afs_server_graveyard);
static DEFINE_SPINLOCK(afs_server_graveyard_lock);
static DECLARE_DELAYED_WORK(afs_server_reaper, afs_reap_server);

/*
 * install a server record in the master tree
 */
static int afs_install_server(struct afs_server *server)
{
	struct afs_server *xserver;
	struct rb_node **pp, *p;
	int ret;

	_enter("%p", server);

	write_lock(&afs_servers_lock);

	ret = -EEXIST;
	pp = &afs_servers.rb_node;
	p = NULL;
	while (*pp) {
		p = *pp;
		_debug("- consider %p", p);
		xserver = rb_entry(p, struct afs_server, master_rb);
		if (server->addr.s_addr < xserver->addr.s_addr)
			pp = &(*pp)->rb_left;
		else if (server->addr.s_addr > xserver->addr.s_addr)
			pp = &(*pp)->rb_right;
		else
			goto error;
	}

	rb_link_node(&server->master_rb, p, pp);
	rb_insert_color(&server->master_rb, &afs_servers);
	ret = 0;

error:
	write_unlock(&afs_servers_lock);
	return ret;
}

/*
 * allocate a new server record
 */
static struct afs_server *afs_alloc_server(struct afs_cell *cell,
					   const struct in_addr *addr)
{
	struct afs_server *server;

	_enter("");

	server = kzalloc(sizeof(struct afs_server), GFP_KERNEL);
	if (server) {
		atomic_set(&server->usage, 1);
		server->cell = cell;

		INIT_LIST_HEAD(&server->link);
		INIT_LIST_HEAD(&server->grave);
		init_rwsem(&server->sem);
		spin_lock_init(&server->fs_lock);
		server->fs_vnodes = RB_ROOT;
		server->cb_promises = RB_ROOT;
		spin_lock_init(&server->cb_lock);
		init_waitqueue_head(&server->cb_break_waitq);
		INIT_DELAYED_WORK(&server->cb_break_work,
				  afs_dispatch_give_up_callbacks);

		memcpy(&server->addr, addr, sizeof(struct in_addr));
		server->addr.s_addr = addr->s_addr;
		_leave(" = %p{%d}", server, atomic_read(&server->usage));
	} else {
		_leave(" = NULL [nomem]");
	}
	return server;
}

/*
 * get an FS-server record for a cell
 */
struct afs_server *afs_lookup_server(struct afs_cell *cell,
				     const struct in_addr *addr)
{
	struct afs_server *server, *candidate;

	_enter("%p,%pI4", cell, &addr->s_addr);

	/* quick scan of the list to see if we already have the server */
	read_lock(&cell->servers_lock);

	list_for_each_entry(server, &cell->servers, link) {
		if (server->addr.s_addr == addr->s_addr)
			goto found_server_quickly;
	}
	read_unlock(&cell->servers_lock);

	candidate = afs_alloc_server(cell, addr);
	if (!candidate) {
		_leave(" = -ENOMEM");
		return ERR_PTR(-ENOMEM);
	}

	write_lock(&cell->servers_lock);

	/* check the cell's server list again */
	list_for_each_entry(server, &cell->servers, link) {
		if (server->addr.s_addr == addr->s_addr)
			goto found_server;
	}

	_debug("new");
	server = candidate;
	if (afs_install_server(server) < 0)
		goto server_in_two_cells;

	afs_get_cell(cell);
	list_add_tail(&server->link, &cell->servers);

	write_unlock(&cell->servers_lock);
	_leave(" = %p{%d}", server, atomic_read(&server->usage));
	return server;

	/* found a matching server quickly */
found_server_quickly:
	_debug("found quickly");
	afs_get_server(server);
	read_unlock(&cell->servers_lock);
no_longer_unused:
	if (!list_empty(&server->grave)) {
		spin_lock(&afs_server_graveyard_lock);
		list_del_init(&server->grave);
		spin_unlock(&afs_server_graveyard_lock);
	}
	_leave(" = %p{%d}", server, atomic_read(&server->usage));
	return server;

	/* found a matching server on the second pass */
found_server:
	_debug("found");
	afs_get_server(server);
	write_unlock(&cell->servers_lock);
	kfree(candidate);
	goto no_longer_unused;

	/* found a server that seems to be in two cells */
server_in_two_cells:
	write_unlock(&cell->servers_lock);
	kfree(candidate);
	printk(KERN_NOTICE "kAFS: Server %pI4 appears to be in two cells\n",
	       addr);
	_leave(" = -EEXIST");
	return ERR_PTR(-EEXIST);
}

/*
 * look up a server by its IP address
 */
struct afs_server *afs_find_server(const struct sockaddr_rxrpc *srx)
{
	struct afs_server *server = NULL;
	struct rb_node *p;
	struct in_addr addr = srx->transport.sin.sin_addr;

	_enter("{%d,%pI4}", srx->transport.family, &addr.s_addr);

	if (srx->transport.family != AF_INET) {
		WARN(true, "AFS does not yes support non-IPv4 addresses\n");
		return NULL;
	}

	read_lock(&afs_servers_lock);

	p = afs_servers.rb_node;
	while (p) {
		server = rb_entry(p, struct afs_server, master_rb);

		_debug("- consider %p", p);

		if (addr.s_addr < server->addr.s_addr) {
			p = p->rb_left;
		} else if (addr.s_addr > server->addr.s_addr) {
			p = p->rb_right;
		} else {
			afs_get_server(server);
			goto found;
		}
	}

	server = NULL;
found:
	read_unlock(&afs_servers_lock);
	ASSERTIFCMP(server, server->addr.s_addr, ==, addr.s_addr);
	_leave(" = %p", server);
	return server;
}

/*
 * destroy a server record
 * - removes from the cell list
 */
void afs_put_server(struct afs_server *server)
{
	if (!server)
		return;

	_enter("%p{%d}", server, atomic_read(&server->usage));

	_debug("PUT SERVER %d", atomic_read(&server->usage));

	ASSERTCMP(atomic_read(&server->usage), >, 0);

	if (likely(!atomic_dec_and_test(&server->usage))) {
		_leave("");
		return;
	}

	afs_flush_callback_breaks(server);

	spin_lock(&afs_server_graveyard_lock);
	if (atomic_read(&server->usage) == 0) {
		list_move_tail(&server->grave, &afs_server_graveyard);
		server->time_of_death = ktime_get_real_seconds();
		queue_delayed_work(afs_wq, &afs_server_reaper,
				   afs_server_timeout * HZ);
	}
	spin_unlock(&afs_server_graveyard_lock);
	_leave(" [dead]");
}

/*
 * destroy a dead server
 */
static void afs_destroy_server(struct afs_server *server)
{
	_enter("%p", server);

	ASSERTIF(server->cb_break_head != server->cb_break_tail,
		 delayed_work_pending(&server->cb_break_work));

	ASSERTCMP(server->fs_vnodes.rb_node, ==, NULL);
	ASSERTCMP(server->cb_promises.rb_node, ==, NULL);
	ASSERTCMP(server->cb_break_head, ==, server->cb_break_tail);
	ASSERTCMP(atomic_read(&server->cb_break_n), ==, 0);

	afs_put_cell(server->cell);
	kfree(server);
}

/*
 * reap dead server records
 */
static void afs_reap_server(struct work_struct *work)
{
	LIST_HEAD(corpses);
	struct afs_server *server;
	unsigned long delay, expiry;
	time64_t now;

	now = ktime_get_real_seconds();
	spin_lock(&afs_server_graveyard_lock);

	while (!list_empty(&afs_server_graveyard)) {
		server = list_entry(afs_server_graveyard.next,
				    struct afs_server, grave);

		/* the queue is ordered most dead first */
		expiry = server->time_of_death + afs_server_timeout;
		if (expiry > now) {
			delay = (expiry - now) * HZ;
			mod_delayed_work(afs_wq, &afs_server_reaper, delay);
			break;
		}

		write_lock(&server->cell->servers_lock);
		write_lock(&afs_servers_lock);
		if (atomic_read(&server->usage) > 0) {
			list_del_init(&server->grave);
		} else {
			list_move_tail(&server->grave, &corpses);
			list_del_init(&server->link);
			rb_erase(&server->master_rb, &afs_servers);
		}
		write_unlock(&afs_servers_lock);
		write_unlock(&server->cell->servers_lock);
	}

	spin_unlock(&afs_server_graveyard_lock);

	/* now reap the corpses we've extracted */
	while (!list_empty(&corpses)) {
		server = list_entry(corpses.next, struct afs_server, grave);
		list_del(&server->grave);
		afs_destroy_server(server);
	}
}

/*
 * discard all the server records for rmmod
 */
void __exit afs_purge_servers(void)
{
	afs_server_timeout = 0;
	mod_delayed_work(afs_wq, &afs_server_reaper, 0);
}
Commit	Line	Data
ec26815a	1	/* AFS server record management
1da177e4	2	*
08e0e7c8	3	* Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
1da177e4 LT	4	* Written by David Howells (dhowells@redhat.com)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
	12	#include <linux/sched.h>
	13	#include <linux/slab.h>
1da177e4 LT	14	#include "internal.h"
1da177e4 LT	15
c1206a2c	16	static unsigned afs_server_timeout = 10; /* server timeout in seconds */
1da177e4	17
08e0e7c8	18	static void afs_reap_server(struct work_struct *);
1da177e4	19
08e0e7c8 DH	20	/* tree of all the servers, indexed by IP address */
	21	static struct rb_root afs_servers = RB_ROOT;
	22	static DEFINE_RWLOCK(afs_servers_lock);
	23
	24	/* LRU list of all the servers not currently in use */
	25	static LIST_HEAD(afs_server_graveyard);
	26	static DEFINE_SPINLOCK(afs_server_graveyard_lock);
	27	static DECLARE_DELAYED_WORK(afs_server_reaper, afs_reap_server);
	28
	29	/*
	30	* install a server record in the master tree
	31	*/
	32	static int afs_install_server(struct afs_server *server)
1da177e4	33	{
08e0e7c8 DH	34	struct afs_server *xserver;
	35	struct rb_node *pp, p;
	36	int ret;
	37
	38	_enter("%p", server);
1da177e4	39
08e0e7c8 DH	40	write_lock(&afs_servers_lock);
	41
	42	ret = -EEXIST;
	43	pp = &afs_servers.rb_node;
	44	p = NULL;
	45	while (*pp) {
	46	p = *pp;
	47	_debug("- consider %p", p);
	48	xserver = rb_entry(p, struct afs_server, master_rb);
	49	if (server->addr.s_addr < xserver->addr.s_addr)
	50	pp = &(*pp)->rb_left;
	51	else if (server->addr.s_addr > xserver->addr.s_addr)
	52	pp = &(*pp)->rb_right;
	53	else
	54	goto error;
	55	}
1da177e4	56
08e0e7c8 DH	57	rb_link_node(&server->master_rb, p, pp);
	58	rb_insert_color(&server->master_rb, &afs_servers);
	59	ret = 0;
1da177e4	60
08e0e7c8 DH	61	error:
	62	write_unlock(&afs_servers_lock);
	63	return ret;
	64	}
1da177e4	65
1da177e4	66	/*
08e0e7c8	67	* allocate a new server record
1da177e4	68	*/
08e0e7c8 DH	69	static struct afs_server afs_alloc_server(struct afs_cell cell,
08e0e7c8 DH	70	const struct in_addr *addr)
1da177e4	71	{
08e0e7c8	72	struct afs_server *server;
1da177e4	73
08e0e7c8	74	_enter("");
1da177e4	75
b593e48d	76	server = kzalloc(sizeof(struct afs_server), GFP_KERNEL);
08e0e7c8 DH	77	if (server) {
	78	atomic_set(&server->usage, 1);
	79	server->cell = cell;
	80
	81	INIT_LIST_HEAD(&server->link);
	82	INIT_LIST_HEAD(&server->grave);
	83	init_rwsem(&server->sem);
	84	spin_lock_init(&server->fs_lock);
	85	server->fs_vnodes = RB_ROOT;
	86	server->cb_promises = RB_ROOT;
	87	spin_lock_init(&server->cb_lock);
	88	init_waitqueue_head(&server->cb_break_waitq);
	89	INIT_DELAYED_WORK(&server->cb_break_work,
	90	afs_dispatch_give_up_callbacks);
	91
	92	memcpy(&server->addr, addr, sizeof(struct in_addr));
	93	server->addr.s_addr = addr->s_addr;
037776fc DK	94	_leave(" = %p{%d}", server, atomic_read(&server->usage));
	95	} else {
	96	_leave(" = NULL [nomem]");
1da177e4	97	}
08e0e7c8 DH	98	return server;
08e0e7c8 DH	99	}
1da177e4	100
08e0e7c8 DH	101	/*
	102	* get an FS-server record for a cell
	103	*/
	104	struct afs_server afs_lookup_server(struct afs_cell cell,
	105	const struct in_addr *addr)
	106	{
	107	struct afs_server server, candidate;
1da177e4	108
be859405	109	_enter("%p,%pI4", cell, &addr->s_addr);
1da177e4	110
08e0e7c8 DH	111	/* quick scan of the list to see if we already have the server */
08e0e7c8 DH	112	read_lock(&cell->servers_lock);
1da177e4	113
08e0e7c8 DH	114	list_for_each_entry(server, &cell->servers, link) {
	115	if (server->addr.s_addr == addr->s_addr)
	116	goto found_server_quickly;
1da177e4	117	}
08e0e7c8	118	read_unlock(&cell->servers_lock);
1da177e4	119
08e0e7c8 DH	120	candidate = afs_alloc_server(cell, addr);
	121	if (!candidate) {
	122	_leave(" = -ENOMEM");
	123	return ERR_PTR(-ENOMEM);
1da177e4	124	}
1da177e4	125
08e0e7c8	126	write_lock(&cell->servers_lock);
1da177e4	127
08e0e7c8 DH	128	/* check the cell's server list again */
	129	list_for_each_entry(server, &cell->servers, link) {
	130	if (server->addr.s_addr == addr->s_addr)
	131	goto found_server;
	132	}
	133
	134	_debug("new");
	135	server = candidate;
	136	if (afs_install_server(server) < 0)
	137	goto server_in_two_cells;
1da177e4	138
08e0e7c8 DH	139	afs_get_cell(cell);
	140	list_add_tail(&server->link, &cell->servers);
	141
	142	write_unlock(&cell->servers_lock);
	143	_leave(" = %p{%d}", server, atomic_read(&server->usage));
	144	return server;
	145
	146	/* found a matching server quickly */
	147	found_server_quickly:
	148	_debug("found quickly");
	149	afs_get_server(server);
	150	read_unlock(&cell->servers_lock);
	151	no_longer_unused:
	152	if (!list_empty(&server->grave)) {
	153	spin_lock(&afs_server_graveyard_lock);
	154	list_del_init(&server->grave);
	155	spin_unlock(&afs_server_graveyard_lock);
	156	}
	157	_leave(" = %p{%d}", server, atomic_read(&server->usage));
	158	return server;
	159
	160	/* found a matching server on the second pass */
	161	found_server:
	162	_debug("found");
	163	afs_get_server(server);
	164	write_unlock(&cell->servers_lock);
	165	kfree(candidate);
	166	goto no_longer_unused;
	167
	168	/* found a server that seems to be in two cells */
	169	server_in_two_cells:
	170	write_unlock(&cell->servers_lock);
	171	kfree(candidate);
be859405 HH	172	printk(KERN_NOTICE "kAFS: Server %pI4 appears to be in two cells\n",
be859405 HH	173	addr);
08e0e7c8 DH	174	_leave(" = -EEXIST");
	175	return ERR_PTR(-EEXIST);
	176	}
1da177e4	177
08e0e7c8 DH	178	/*
	179	* look up a server by its IP address
	180	*/
8324f0bc	181	struct afs_server afs_find_server(const struct sockaddr_rxrpc srx)
08e0e7c8 DH	182	{
	183	struct afs_server *server = NULL;
	184	struct rb_node *p;
8324f0bc	185	struct in_addr addr = srx->transport.sin.sin_addr;
1da177e4	186
8324f0bc DH	187	_enter("{%d,%pI4}", srx->transport.family, &addr.s_addr);
	188
	189	if (srx->transport.family != AF_INET) {
	190	WARN(true, "AFS does not yes support non-IPv4 addresses\n");
	191	return NULL;
	192	}
1da177e4	193
08e0e7c8	194	read_lock(&afs_servers_lock);
1da177e4	195
08e0e7c8 DH	196	p = afs_servers.rb_node;
	197	while (p) {
	198	server = rb_entry(p, struct afs_server, master_rb);
1da177e4	199
08e0e7c8	200	_debug("- consider %p", p);
1da177e4	201
08e0e7c8 DH	202	if (addr.s_addr < server->addr.s_addr) {
	203	p = p->rb_left;
	204	} else if (addr.s_addr > server->addr.s_addr) {
	205	p = p->rb_right;
	206	} else {
	207	afs_get_server(server);
	208	goto found;
	209	}
	210	}
1da177e4	211
08e0e7c8 DH	212	server = NULL;
	213	found:
	214	read_unlock(&afs_servers_lock);
	215	ASSERTIFCMP(server, server->addr.s_addr, ==, addr.s_addr);
	216	_leave(" = %p", server);
	217	return server;
ec26815a	218	}
1da177e4	219
1da177e4 LT	220	/*
	221	* destroy a server record
	222	* - removes from the cell list
	223	*/
	224	void afs_put_server(struct afs_server *server)
	225	{
1da177e4 LT	226	if (!server)
	227	return;
	228
08e0e7c8	229	_enter("%p{%d}", server, atomic_read(&server->usage));
1da177e4	230
260a9803 DH	231	_debug("PUT SERVER %d", atomic_read(&server->usage));
260a9803 DH	232
08e0e7c8	233	ASSERTCMP(atomic_read(&server->usage), >, 0);
1da177e4 LT	234
1da177e4 LT	235	if (likely(!atomic_dec_and_test(&server->usage))) {
1da177e4 LT	236	_leave("");
	237	return;
	238	}
	239
08e0e7c8	240	afs_flush_callback_breaks(server);
1da177e4	241
08e0e7c8 DH	242	spin_lock(&afs_server_graveyard_lock);
	243	if (atomic_read(&server->usage) == 0) {
	244	list_move_tail(&server->grave, &afs_server_graveyard);
8a79790b	245	server->time_of_death = ktime_get_real_seconds();
0ad53eee TH	246	queue_delayed_work(afs_wq, &afs_server_reaper,
0ad53eee TH	247	afs_server_timeout * HZ);
08e0e7c8 DH	248	}
	249	spin_unlock(&afs_server_graveyard_lock);
	250	_leave(" [dead]");
ec26815a	251	}
1da177e4	252
1da177e4	253	/*
08e0e7c8	254	* destroy a dead server
1da177e4	255	*/
08e0e7c8	256	static void afs_destroy_server(struct afs_server *server)
1da177e4	257	{
1da177e4 LT	258	_enter("%p", server);
1da177e4 LT	259
416351f2 DH	260	ASSERTIF(server->cb_break_head != server->cb_break_tail,
	261	delayed_work_pending(&server->cb_break_work));
	262
08e0e7c8 DH	263	ASSERTCMP(server->fs_vnodes.rb_node, ==, NULL);
	264	ASSERTCMP(server->cb_promises.rb_node, ==, NULL);
	265	ASSERTCMP(server->cb_break_head, ==, server->cb_break_tail);
	266	ASSERTCMP(atomic_read(&server->cb_break_n), ==, 0);
1da177e4	267
08e0e7c8	268	afs_put_cell(server->cell);
1da177e4	269	kfree(server);
ec26815a	270	}
1da177e4	271
1da177e4	272	/*
08e0e7c8	273	* reap dead server records
1da177e4	274	*/
08e0e7c8	275	static void afs_reap_server(struct work_struct *work)
1da177e4	276	{
08e0e7c8 DH	277	LIST_HEAD(corpses);
	278	struct afs_server *server;
	279	unsigned long delay, expiry;
8a79790b	280	time64_t now;
08e0e7c8	281
8a79790b	282	now = ktime_get_real_seconds();
08e0e7c8 DH	283	spin_lock(&afs_server_graveyard_lock);
	284
	285	while (!list_empty(&afs_server_graveyard)) {
	286	server = list_entry(afs_server_graveyard.next,
	287	struct afs_server, grave);
	288
	289	/* the queue is ordered most dead first */
	290	expiry = server->time_of_death + afs_server_timeout;
	291	if (expiry > now) {
	292	delay = (expiry - now) * HZ;
41f63c53	293	mod_delayed_work(afs_wq, &afs_server_reaper, delay);
08e0e7c8	294	break;
1da177e4 LT	295	}
1da177e4 LT	296
08e0e7c8 DH	297	write_lock(&server->cell->servers_lock);
	298	write_lock(&afs_servers_lock);
	299	if (atomic_read(&server->usage) > 0) {
	300	list_del_init(&server->grave);
	301	} else {
	302	list_move_tail(&server->grave, &corpses);
	303	list_del_init(&server->link);
	304	rb_erase(&server->master_rb, &afs_servers);
1da177e4	305	}
08e0e7c8 DH	306	write_unlock(&afs_servers_lock);
08e0e7c8 DH	307	write_unlock(&server->cell->servers_lock);
1da177e4 LT	308	}
1da177e4 LT	309
08e0e7c8	310	spin_unlock(&afs_server_graveyard_lock);
1da177e4	311
08e0e7c8 DH	312	/* now reap the corpses we've extracted */
	313	while (!list_empty(&corpses)) {
	314	server = list_entry(corpses.next, struct afs_server, grave);
	315	list_del(&server->grave);
	316	afs_destroy_server(server);
1da177e4	317	}
ec26815a	318	}
1da177e4	319
1da177e4	320	/*
08e0e7c8	321	* discard all the server records for rmmod
1da177e4	322	*/
08e0e7c8	323	void __exit afs_purge_servers(void)
1da177e4	324	{
08e0e7c8	325	afs_server_timeout = 0;
41f63c53	326	mod_delayed_work(afs_wq, &afs_server_reaper, 0);
ec26815a	327	}