[mirror_ubuntu-bionic-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 "afs_fs.h"
#include "internal.h"

static unsigned afs_server_gc_delay = 10;	/* Server record timeout in seconds */
static unsigned afs_server_update_delay = 30;	/* Time till VLDB recheck in secs */

static void afs_inc_servers_outstanding(struct afs_net *net)
{
	atomic_inc(&net->servers_outstanding);
}

static void afs_dec_servers_outstanding(struct afs_net *net)
{
	if (atomic_dec_and_test(&net->servers_outstanding))
		wake_up_atomic_t(&net->servers_outstanding);
}

/*
 * Find a server by one of its addresses.
 */
struct afs_server *afs_find_server(struct afs_net *net,
				   const struct sockaddr_rxrpc *srx)
{
	const struct sockaddr_in6 *a = &srx->transport.sin6, *b;
	const struct afs_addr_list *alist;
	struct afs_server *server = NULL;
	unsigned int i;
	bool ipv6 = true;
	int seq = 0, diff;

	if (srx->transport.sin6.sin6_addr.s6_addr32[0] == 0 ||
	    srx->transport.sin6.sin6_addr.s6_addr32[1] == 0 ||
	    srx->transport.sin6.sin6_addr.s6_addr32[2] == htonl(0xffff))
		ipv6 = false;

	rcu_read_lock();

	do {
		if (server)
			afs_put_server(net, server);
		server = NULL;
		read_seqbegin_or_lock(&net->fs_addr_lock, &seq);

		if (ipv6) {
			hlist_for_each_entry_rcu(server, &net->fs_addresses6, addr6_link) {
				alist = rcu_dereference(server->addresses);
				for (i = alist->nr_ipv4; i < alist->nr_addrs; i++) {
					b = &alist->addrs[i].transport.sin6;
					diff = (u16)a->sin6_port - (u16)b->sin6_port;
					if (diff == 0)
						diff = memcmp(&a->sin6_addr,
							      &b->sin6_addr,
							      sizeof(struct in6_addr));
					if (diff == 0)
						goto found;
					if (diff < 0) {
						// TODO: Sort the list
						//if (i == alist->nr_ipv4)
						//	goto not_found;
						break;
					}
				}
			}
		} else {
			hlist_for_each_entry_rcu(server, &net->fs_addresses4, addr4_link) {
				alist = rcu_dereference(server->addresses);
				for (i = 0; i < alist->nr_ipv4; i++) {
					b = &alist->addrs[i].transport.sin6;
					diff = (u16)a->sin6_port - (u16)b->sin6_port;
					if (diff == 0)
						diff = ((u32)a->sin6_addr.s6_addr32[3] -
							(u32)b->sin6_addr.s6_addr32[3]);
					if (diff == 0)
						goto found;
					if (diff < 0) {
						// TODO: Sort the list
						//if (i == 0)
						//	goto not_found;
						break;
					}
				}
			}
		}

	//not_found:
		server = NULL;
	found:
		if (server && !atomic_inc_not_zero(&server->usage))
			server = NULL;

	} while (need_seqretry(&net->fs_addr_lock, seq));

	done_seqretry(&net->fs_addr_lock, seq);

	rcu_read_unlock();
	return server;
}

/*
 * Look up a server by its UUID
 */
struct afs_server *afs_find_server_by_uuid(struct afs_net *net, const uuid_t *uuid)
{
	struct afs_server *server = NULL;
	struct rb_node *p;
	int diff, seq = 0;

	_enter("%pU", uuid);

	do {
		/* Unfortunately, rbtree walking doesn't give reliable results
		 * under just the RCU read lock, so we have to check for
		 * changes.
		 */
		if (server)
			afs_put_server(net, server);
		server = NULL;

		read_seqbegin_or_lock(&net->fs_lock, &seq);

		p = net->fs_servers.rb_node;
		while (p) {
			server = rb_entry(p, struct afs_server, uuid_rb);

			diff = memcmp(uuid, &server->uuid, sizeof(*uuid));
			if (diff < 0) {
				p = p->rb_left;
			} else if (diff > 0) {
				p = p->rb_right;
			} else {
				afs_get_server(server);
				break;
			}

			server = NULL;
		}
	} while (need_seqretry(&net->fs_lock, seq));

	done_seqretry(&net->fs_lock, seq);

	_leave(" = %p", server);
	return server;
}

/*
 * Install a server record in the namespace tree
 */
static struct afs_server *afs_install_server(struct afs_net *net,
					     struct afs_server *candidate)
{
	const struct afs_addr_list *alist;
	struct afs_server *server;
	struct rb_node **pp, *p;
	int ret = -EEXIST, diff;

	_enter("%p", candidate);

	write_seqlock(&net->fs_lock);

	/* Firstly install the server in the UUID lookup tree */
	pp = &net->fs_servers.rb_node;
	p = NULL;
	while (*pp) {
		p = *pp;
		_debug("- consider %p", p);
		server = rb_entry(p, struct afs_server, uuid_rb);
		diff = memcmp(&candidate->uuid, &server->uuid, sizeof(uuid_t));
		if (diff < 0)
			pp = &(*pp)->rb_left;
		else if (diff > 0)
			pp = &(*pp)->rb_right;
		else
			goto exists;
	}

	server = candidate;
	rb_link_node(&server->uuid_rb, p, pp);
	rb_insert_color(&server->uuid_rb, &net->fs_servers);
	hlist_add_head_rcu(&server->proc_link, &net->fs_proc);

	write_seqlock(&net->fs_addr_lock);
	alist = rcu_dereference_protected(server->addresses,
					  lockdep_is_held(&net->fs_addr_lock.lock));

	/* Secondly, if the server has any IPv4 and/or IPv6 addresses, install
	 * it in the IPv4 and/or IPv6 reverse-map lists.
	 *
	 * TODO: For speed we want to use something other than a flat list
	 * here; even sorting the list in terms of lowest address would help a
	 * bit, but anything we might want to do gets messy and memory
	 * intensive.
	 */
	if (alist->nr_ipv4 > 0)
		hlist_add_head_rcu(&server->addr4_link, &net->fs_addresses4);
	if (alist->nr_addrs > alist->nr_ipv4)
		hlist_add_head_rcu(&server->addr6_link, &net->fs_addresses6);

	write_sequnlock(&net->fs_addr_lock);
	ret = 0;

exists:
	afs_get_server(server);
	write_sequnlock(&net->fs_lock);
	return server;
}

/*
 * allocate a new server record
 */
static struct afs_server *afs_alloc_server(struct afs_net *net,
					   const uuid_t *uuid,
					   struct afs_addr_list *alist)
{
	struct afs_server *server;

	_enter("");

	server = kzalloc(sizeof(struct afs_server), GFP_KERNEL);
	if (!server)
		goto enomem;

	atomic_set(&server->usage, 1);
	RCU_INIT_POINTER(server->addresses, alist);
	server->addr_version = alist->version;
	server->uuid = *uuid;
	server->flags = (1UL << AFS_SERVER_FL_NEW);
	server->update_at = ktime_get_real_seconds() + afs_server_update_delay;
	rwlock_init(&server->fs_lock);
	INIT_LIST_HEAD(&server->cb_interests);
	rwlock_init(&server->cb_break_lock);

	afs_inc_servers_outstanding(net);
	_leave(" = %p", server);
	return server;

enomem:
	_leave(" = NULL [nomem]");
	return NULL;
}

/*
 * Look up an address record for a server
 */
static struct afs_addr_list *afs_vl_lookup_addrs(struct afs_cell *cell,
						 struct key *key, const uuid_t *uuid)
{
	struct afs_addr_cursor ac;
	struct afs_addr_list *alist;
	int ret;

	ret = afs_set_vl_cursor(&ac, cell);
	if (ret < 0)
		return ERR_PTR(ret);

	while (afs_iterate_addresses(&ac)) {
		if (test_bit(ac.index, &ac.alist->yfs))
			alist = afs_yfsvl_get_endpoints(cell->net, &ac, key, uuid);
		else
			alist = afs_vl_get_addrs_u(cell->net, &ac, key, uuid);
		switch (ac.error) {
		case 0:
			afs_end_cursor(&ac);
			return alist;
		case -ECONNABORTED:
			ac.error = afs_abort_to_error(ac.abort_code);
			goto error;
		case -ENOMEM:
		case -ENONET:
			goto error;
		case -ENETUNREACH:
		case -EHOSTUNREACH:
		case -ECONNREFUSED:
			break;
		default:
			ac.error = -EIO;
			goto error;
		}
	}

error:
	return ERR_PTR(afs_end_cursor(&ac));
}

/*
 * Get or create a fileserver record.
 */
struct afs_server *afs_lookup_server(struct afs_cell *cell, struct key *key,
				     const uuid_t *uuid)
{
	struct afs_addr_list *alist;
	struct afs_server *server, *candidate;

	_enter("%p,%pU", cell->net, uuid);

	server = afs_find_server_by_uuid(cell->net, uuid);
	if (server)
		return server;

	alist = afs_vl_lookup_addrs(cell, key, uuid);
	if (IS_ERR(alist))
		return ERR_CAST(alist);

	candidate = afs_alloc_server(cell->net, uuid, alist);
	if (!candidate) {
		afs_put_addrlist(alist);
		return ERR_PTR(-ENOMEM);
	}

	server = afs_install_server(cell->net, candidate);
	if (server != candidate) {
		afs_put_addrlist(alist);
		kfree(candidate);
	}

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

/*
 * Set the server timer to fire after a given delay, assuming it's not already
 * set for an earlier time.
 */
static void afs_set_server_timer(struct afs_net *net, time64_t delay)
{
	if (net->live) {
		afs_inc_servers_outstanding(net);
		if (timer_reduce(&net->fs_timer, jiffies + delay * HZ))
			afs_dec_servers_outstanding(net);
	}
}

/*
 * Server management timer.  We have an increment on fs_outstanding that we
 * need to pass along to the work item.
 */
void afs_servers_timer(struct timer_list *timer)
{
	struct afs_net *net = container_of(timer, struct afs_net, fs_timer);

	_enter("");
	if (!queue_work(afs_wq, &net->fs_manager))
		afs_dec_servers_outstanding(net);
}

/*
 * Release a reference on a server record.
 */
void afs_put_server(struct afs_net *net, struct afs_server *server)
{
	unsigned int usage;

	if (!server)
		return;

	server->put_time = ktime_get_real_seconds();

	usage = atomic_dec_return(&server->usage);

	_enter("{%u}", usage);

	if (likely(usage > 0))
		return;

	afs_set_server_timer(net, afs_server_gc_delay);
}

static void afs_server_rcu(struct rcu_head *rcu)
{
	struct afs_server *server = container_of(rcu, struct afs_server, rcu);

	afs_put_addrlist(server->addresses);
	kfree(server);
}

/*
 * destroy a dead server
 */
static void afs_destroy_server(struct afs_net *net, struct afs_server *server)
{
	struct afs_addr_list *alist = server->addresses;
	struct afs_addr_cursor ac = {
		.alist	= alist,
		.addr	= &alist->addrs[0],
		.start	= alist->index,
		.index	= alist->index,
		.error	= 0,
	};
	_enter("%p", server);

	afs_fs_give_up_all_callbacks(net, server, &ac, NULL);
	call_rcu(&server->rcu, afs_server_rcu);
	afs_dec_servers_outstanding(net);
}

/*
 * Garbage collect any expired servers.
 */
static void afs_gc_servers(struct afs_net *net, struct afs_server *gc_list)
{
	struct afs_server *server;
	bool deleted;
	int usage;

	while ((server = gc_list)) {
		gc_list = server->gc_next;

		write_seqlock(&net->fs_lock);
		usage = 1;
		deleted = atomic_try_cmpxchg(&server->usage, &usage, 0);
		if (deleted) {
			rb_erase(&server->uuid_rb, &net->fs_servers);
			hlist_del_rcu(&server->proc_link);
		}
		write_sequnlock(&net->fs_lock);

		if (deleted)
			afs_destroy_server(net, server);
	}
}

/*
 * Manage the records of servers known to be within a network namespace.  This
 * includes garbage collecting unused servers.
 *
 * Note also that we were given an increment on net->servers_outstanding by
 * whoever queued us that we need to deal with before returning.
 */
void afs_manage_servers(struct work_struct *work)
{
	struct afs_net *net = container_of(work, struct afs_net, fs_manager);
	struct afs_server *gc_list = NULL;
	struct rb_node *cursor;
	time64_t now = ktime_get_real_seconds(), next_manage = TIME64_MAX;
	bool purging = !net->live;

	_enter("");

	/* Trawl the server list looking for servers that have expired from
	 * lack of use.
	 */
	read_seqlock_excl(&net->fs_lock);

	for (cursor = rb_first(&net->fs_servers); cursor; cursor = rb_next(cursor)) {
		struct afs_server *server =
			rb_entry(cursor, struct afs_server, uuid_rb);
		int usage = atomic_read(&server->usage);

		_debug("manage %pU %u", &server->uuid, usage);

		ASSERTCMP(usage, >=, 1);
		ASSERTIFCMP(purging, usage, ==, 1);

		if (usage == 1) {
			time64_t expire_at = server->put_time;

			if (!test_bit(AFS_SERVER_FL_VL_FAIL, &server->flags) &&
			    !test_bit(AFS_SERVER_FL_NOT_FOUND, &server->flags))
				expire_at += afs_server_gc_delay;
			if (purging || expire_at <= now) {
				server->gc_next = gc_list;
				gc_list = server;
			} else if (expire_at < next_manage) {
				next_manage = expire_at;
			}
		}
	}

	read_sequnlock_excl(&net->fs_lock);

	/* Update the timer on the way out.  We have to pass an increment on
	 * servers_outstanding in the namespace that we are in to the timer or
	 * the work scheduler.
	 */
	if (!purging && next_manage < TIME64_MAX) {
		now = ktime_get_real_seconds();

		if (next_manage - now <= 0) {
			if (queue_work(afs_wq, &net->fs_manager))
				afs_inc_servers_outstanding(net);
		} else {
			afs_set_server_timer(net, next_manage - now);
		}
	}

	afs_gc_servers(net, gc_list);

	afs_dec_servers_outstanding(net);
	_leave(" [%d]", atomic_read(&net->servers_outstanding));
}

static void afs_queue_server_manager(struct afs_net *net)
{
	afs_inc_servers_outstanding(net);
	if (!queue_work(afs_wq, &net->fs_manager))
		afs_dec_servers_outstanding(net);
}

/*
 * Purge list of servers.
 */
void afs_purge_servers(struct afs_net *net)
{
	_enter("");

	if (del_timer_sync(&net->fs_timer))
		atomic_dec(&net->servers_outstanding);

	afs_queue_server_manager(net);

	_debug("wait");
	wait_on_atomic_t(&net->servers_outstanding, atomic_t_wait,
			 TASK_UNINTERRUPTIBLE);
	_leave("");
}

/*
 * Probe a fileserver to find its capabilities.
 *
 * TODO: Try service upgrade.
 */
static bool afs_do_probe_fileserver(struct afs_fs_cursor *fc)
{
	_enter("");

	fc->ac.addr = NULL;
	fc->ac.start = READ_ONCE(fc->ac.alist->index);
	fc->ac.index = fc->ac.start;
	fc->ac.error = 0;
	fc->ac.begun = false;

	while (afs_iterate_addresses(&fc->ac)) {
		afs_fs_get_capabilities(afs_v2net(fc->vnode), fc->cbi->server,
					&fc->ac, fc->key);
		switch (fc->ac.error) {
		case 0:
			afs_end_cursor(&fc->ac);
			set_bit(AFS_SERVER_FL_PROBED, &fc->cbi->server->flags);
			return true;
		case -ECONNABORTED:
			fc->ac.error = afs_abort_to_error(fc->ac.abort_code);
			goto error;
		case -ENOMEM:
		case -ENONET:
			goto error;
		case -ENETUNREACH:
		case -EHOSTUNREACH:
		case -ECONNREFUSED:
		case -ETIMEDOUT:
		case -ETIME:
			break;
		default:
			fc->ac.error = -EIO;
			goto error;
		}
	}

error:
	afs_end_cursor(&fc->ac);
	return false;
}

/*
 * If we haven't already, try probing the fileserver to get its capabilities.
 * We try not to instigate parallel probes, but it's possible that the parallel
 * probes will fail due to authentication failure when ours would succeed.
 *
 * TODO: Try sending an anonymous probe if an authenticated probe fails.
 */
bool afs_probe_fileserver(struct afs_fs_cursor *fc)
{
	bool success;
	int ret, retries = 0;

	_enter("");

retry:
	if (test_bit(AFS_SERVER_FL_PROBED, &fc->cbi->server->flags)) {
		_leave(" = t");
		return true;
	}

	if (!test_and_set_bit_lock(AFS_SERVER_FL_PROBING, &fc->cbi->server->flags)) {
		success = afs_do_probe_fileserver(fc);
		clear_bit_unlock(AFS_SERVER_FL_PROBING, &fc->cbi->server->flags);
		wake_up_bit(&fc->cbi->server->flags, AFS_SERVER_FL_PROBING);
		_leave(" = t");
		return success;
	}

	_debug("wait");
	ret = wait_on_bit(&fc->cbi->server->flags, AFS_SERVER_FL_PROBING,
			  TASK_INTERRUPTIBLE);
	if (ret == -ERESTARTSYS) {
		fc->ac.error = ret;
		_leave(" = f [%d]", ret);
		return false;
	}

	retries++;
	if (retries == 4) {
		fc->ac.error = -ESTALE;
		_leave(" = f [stale]");
		return false;
	}
	_debug("retry");
	goto retry;
}

/*
 * Get an update for a server's address list.
 */
static noinline bool afs_update_server_record(struct afs_fs_cursor *fc, struct afs_server *server)
{
	struct afs_addr_list *alist, *discard;

	_enter("");

	alist = afs_vl_lookup_addrs(fc->vnode->volume->cell, fc->key,
				    &server->uuid);
	if (IS_ERR(alist)) {
		fc->ac.error = PTR_ERR(alist);
		_leave(" = f [%d]", fc->ac.error);
		return false;
	}

	discard = alist;
	if (server->addr_version != alist->version) {
		write_lock(&server->fs_lock);
		discard = rcu_dereference_protected(server->addresses,
						    lockdep_is_held(&server->fs_lock));
		rcu_assign_pointer(server->addresses, alist);
		server->addr_version = alist->version;
		write_unlock(&server->fs_lock);
	}

	server->update_at = ktime_get_real_seconds() + afs_server_update_delay;
	afs_put_addrlist(discard);
	_leave(" = t");
	return true;
}

/*
 * See if a server's address list needs updating.
 */
bool afs_check_server_record(struct afs_fs_cursor *fc, struct afs_server *server)
{
	time64_t now = ktime_get_real_seconds();
	long diff;
	bool success;
	int ret, retries = 0;

	_enter("");

	ASSERT(server);

retry:
	diff = READ_ONCE(server->update_at) - now;
	if (diff > 0) {
		_leave(" = t [not now %ld]", diff);
		return true;
	}

	if (!test_and_set_bit_lock(AFS_SERVER_FL_UPDATING, &server->flags)) {
		success = afs_update_server_record(fc, server);
		clear_bit_unlock(AFS_SERVER_FL_UPDATING, &server->flags);
		wake_up_bit(&server->flags, AFS_SERVER_FL_UPDATING);
		_leave(" = %d", success);
		return success;
	}

	ret = wait_on_bit(&server->flags, AFS_SERVER_FL_UPDATING,
			  TASK_INTERRUPTIBLE);
	if (ret == -ERESTARTSYS) {
		fc->ac.error = ret;
		_leave(" = f [intr]");
		return false;
	}

	retries++;
	if (retries == 4) {
		_leave(" = f [stale]");
		ret = -ESTALE;
		return false;
	}
	goto retry;
}
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>
4d9df986	14	#include "afs_fs.h"
1da177e4 LT	15	#include "internal.h"
1da177e4 LT	16
d2ddc776 DH	17	static unsigned afs_server_gc_delay = 10; /* Server record timeout in seconds */
d2ddc776 DH	18	static unsigned afs_server_update_delay = 30; /* Time till VLDB recheck in secs */
1da177e4	19
59fa1c4a DH	20	static void afs_inc_servers_outstanding(struct afs_net *net)
	21	{
	22	atomic_inc(&net->servers_outstanding);
	23	}
	24
	25	static void afs_dec_servers_outstanding(struct afs_net *net)
	26	{
	27	if (atomic_dec_and_test(&net->servers_outstanding))
	28	wake_up_atomic_t(&net->servers_outstanding);
	29	}
	30
d2ddc776 DH	31	/*
	32	* Find a server by one of its addresses.
	33	*/
	34	struct afs_server afs_find_server(struct afs_net net,
	35	const struct sockaddr_rxrpc *srx)
59fa1c4a	36	{
d2ddc776 DH	37	const struct sockaddr_in6 a = &srx->transport.sin6, b;
	38	const struct afs_addr_list *alist;
	39	struct afs_server *server = NULL;
	40	unsigned int i;
	41	bool ipv6 = true;
	42	int seq = 0, diff;
	43
	44	if (srx->transport.sin6.sin6_addr.s6_addr32[0] == 0 \|\|
	45	srx->transport.sin6.sin6_addr.s6_addr32[1] == 0 \|\|
	46	srx->transport.sin6.sin6_addr.s6_addr32[2] == htonl(0xffff))
	47	ipv6 = false;
	48
	49	rcu_read_lock();
	50
	51	do {
	52	if (server)
	53	afs_put_server(net, server);
	54	server = NULL;
	55	read_seqbegin_or_lock(&net->fs_addr_lock, &seq);
	56
	57	if (ipv6) {
	58	hlist_for_each_entry_rcu(server, &net->fs_addresses6, addr6_link) {
	59	alist = rcu_dereference(server->addresses);
	60	for (i = alist->nr_ipv4; i < alist->nr_addrs; i++) {
	61	b = &alist->addrs[i].transport.sin6;
	62	diff = (u16)a->sin6_port - (u16)b->sin6_port;
	63	if (diff == 0)
	64	diff = memcmp(&a->sin6_addr,
	65	&b->sin6_addr,
	66	sizeof(struct in6_addr));
	67	if (diff == 0)
	68	goto found;
	69	if (diff < 0) {
	70	// TODO: Sort the list
	71	//if (i == alist->nr_ipv4)
	72	// goto not_found;
	73	break;
	74	}
	75	}
	76	}
	77	} else {
	78	hlist_for_each_entry_rcu(server, &net->fs_addresses4, addr4_link) {
	79	alist = rcu_dereference(server->addresses);
	80	for (i = 0; i < alist->nr_ipv4; i++) {
	81	b = &alist->addrs[i].transport.sin6;
	82	diff = (u16)a->sin6_port - (u16)b->sin6_port;
	83	if (diff == 0)
	84	diff = ((u32)a->sin6_addr.s6_addr32[3] -
	85	(u32)b->sin6_addr.s6_addr32[3]);
	86	if (diff == 0)
	87	goto found;
	88	if (diff < 0) {
	89	// TODO: Sort the list
	90	//if (i == 0)
	91	// goto not_found;
	92	break;
	93	}
	94	}
	95	}
	96	}
59fa1c4a	97
d2ddc776 DH	98	//not_found:
	99	server = NULL;
	100	found:
	101	if (server && !atomic_inc_not_zero(&server->usage))
	102	server = NULL;
	103
	104	} while (need_seqretry(&net->fs_addr_lock, seq));
	105
	106	done_seqretry(&net->fs_addr_lock, seq);
	107
	108	rcu_read_unlock();
	109	return server;
59fa1c4a DH	110	}
59fa1c4a DH	111
08e0e7c8	112	/*
d2ddc776	113	* Look up a server by its UUID
08e0e7c8	114	*/
d2ddc776	115	struct afs_server afs_find_server_by_uuid(struct afs_net net, const uuid_t *uuid)
1da177e4	116	{
d2ddc776 DH	117	struct afs_server *server = NULL;
	118	struct rb_node *p;
	119	int diff, seq = 0;
	120
	121	_enter("%pU", uuid);
	122
	123	do {
	124	/* Unfortunately, rbtree walking doesn't give reliable results
	125	* under just the RCU read lock, so we have to check for
	126	* changes.
	127	*/
	128	if (server)
	129	afs_put_server(net, server);
	130	server = NULL;
	131
	132	read_seqbegin_or_lock(&net->fs_lock, &seq);
	133
	134	p = net->fs_servers.rb_node;
	135	while (p) {
	136	server = rb_entry(p, struct afs_server, uuid_rb);
	137
	138	diff = memcmp(uuid, &server->uuid, sizeof(*uuid));
	139	if (diff < 0) {
	140	p = p->rb_left;
	141	} else if (diff > 0) {
	142	p = p->rb_right;
	143	} else {
	144	afs_get_server(server);
	145	break;
	146	}
	147
	148	server = NULL;
	149	}
	150	} while (need_seqretry(&net->fs_lock, seq));
	151
	152	done_seqretry(&net->fs_lock, seq);
	153
	154	_leave(" = %p", server);
	155	return server;
	156	}
	157
	158	/*
	159	* Install a server record in the namespace tree
	160	*/
	161	static struct afs_server afs_install_server(struct afs_net net,
	162	struct afs_server *candidate)
	163	{
	164	const struct afs_addr_list *alist;
	165	struct afs_server *server;
08e0e7c8	166	struct rb_node *pp, p;
d2ddc776	167	int ret = -EEXIST, diff;
08e0e7c8	168
d2ddc776	169	_enter("%p", candidate);
1da177e4	170
d2ddc776	171	write_seqlock(&net->fs_lock);
08e0e7c8	172
d2ddc776 DH	173	/* Firstly install the server in the UUID lookup tree */
d2ddc776 DH	174	pp = &net->fs_servers.rb_node;
08e0e7c8 DH	175	p = NULL;
	176	while (*pp) {
	177	p = *pp;
	178	_debug("- consider %p", p);
d2ddc776 DH	179	server = rb_entry(p, struct afs_server, uuid_rb);
d2ddc776 DH	180	diff = memcmp(&candidate->uuid, &server->uuid, sizeof(uuid_t));
4d9df986	181	if (diff < 0)
08e0e7c8	182	pp = &(*pp)->rb_left;
4d9df986	183	else if (diff > 0)
08e0e7c8 DH	184	pp = &(*pp)->rb_right;
08e0e7c8 DH	185	else
d2ddc776	186	goto exists;
08e0e7c8	187	}
1da177e4	188
d2ddc776 DH	189	server = candidate;
	190	rb_link_node(&server->uuid_rb, p, pp);
	191	rb_insert_color(&server->uuid_rb, &net->fs_servers);
	192	hlist_add_head_rcu(&server->proc_link, &net->fs_proc);
	193
	194	write_seqlock(&net->fs_addr_lock);
	195	alist = rcu_dereference_protected(server->addresses,
	196	lockdep_is_held(&net->fs_addr_lock.lock));
	197
	198	/* Secondly, if the server has any IPv4 and/or IPv6 addresses, install
	199	* it in the IPv4 and/or IPv6 reverse-map lists.
	200	*
	201	* TODO: For speed we want to use something other than a flat list
	202	* here; even sorting the list in terms of lowest address would help a
	203	* bit, but anything we might want to do gets messy and memory
	204	* intensive.
	205	*/
	206	if (alist->nr_ipv4 > 0)
	207	hlist_add_head_rcu(&server->addr4_link, &net->fs_addresses4);
	208	if (alist->nr_addrs > alist->nr_ipv4)
	209	hlist_add_head_rcu(&server->addr6_link, &net->fs_addresses6);
	210
	211	write_sequnlock(&net->fs_addr_lock);
08e0e7c8	212	ret = 0;
1da177e4	213
d2ddc776 DH	214	exists:
	215	afs_get_server(server);
	216	write_sequnlock(&net->fs_lock);
	217	return server;
08e0e7c8	218	}
1da177e4	219
1da177e4	220	/*
08e0e7c8	221	* allocate a new server record
1da177e4	222	*/
d2ddc776 DH	223	static struct afs_server afs_alloc_server(struct afs_net net,
	224	const uuid_t *uuid,
	225	struct afs_addr_list *alist)
1da177e4	226	{
08e0e7c8	227	struct afs_server *server;
1da177e4	228
08e0e7c8	229	_enter("");
1da177e4	230
b593e48d	231	server = kzalloc(sizeof(struct afs_server), GFP_KERNEL);
8b2a464c DH	232	if (!server)
8b2a464c DH	233	goto enomem;
8b2a464c DH	234
8b2a464c DH	235	atomic_set(&server->usage, 1);
d2ddc776 DH	236	RCU_INIT_POINTER(server->addresses, alist);
	237	server->addr_version = alist->version;
	238	server->uuid = *uuid;
	239	server->flags = (1UL << AFS_SERVER_FL_NEW);
	240	server->update_at = ktime_get_real_seconds() + afs_server_update_delay;
	241	rwlock_init(&server->fs_lock);
8b2a464c DH	242	INIT_LIST_HEAD(&server->cb_interests);
	243	rwlock_init(&server->cb_break_lock);
	244
d2ddc776 DH	245	afs_inc_servers_outstanding(net);
d2ddc776 DH	246	_leave(" = %p", server);
08e0e7c8	247	return server;
8b2a464c	248
8b2a464c DH	249	enomem:
	250	_leave(" = NULL [nomem]");
	251	return NULL;
08e0e7c8	252	}
1da177e4	253
08e0e7c8	254	/*
d2ddc776	255	* Look up an address record for a server
08e0e7c8	256	*/
d2ddc776 DH	257	static struct afs_addr_list afs_vl_lookup_addrs(struct afs_cell cell,
d2ddc776 DH	258	struct key key, const uuid_t uuid)
08e0e7c8	259	{
d2ddc776 DH	260	struct afs_addr_cursor ac;
	261	struct afs_addr_list *alist;
	262	int ret;
	263
	264	ret = afs_set_vl_cursor(&ac, cell);
	265	if (ret < 0)
	266	return ERR_PTR(ret);
	267
	268	while (afs_iterate_addresses(&ac)) {
bf99a53c DH	269	if (test_bit(ac.index, &ac.alist->yfs))
	270	alist = afs_yfsvl_get_endpoints(cell->net, &ac, key, uuid);
	271	else
	272	alist = afs_vl_get_addrs_u(cell->net, &ac, key, uuid);
d2ddc776 DH	273	switch (ac.error) {
	274	case 0:
	275	afs_end_cursor(&ac);
	276	return alist;
	277	case -ECONNABORTED:
	278	ac.error = afs_abort_to_error(ac.abort_code);
	279	goto error;
	280	case -ENOMEM:
	281	case -ENONET:
	282	goto error;
	283	case -ENETUNREACH:
	284	case -EHOSTUNREACH:
	285	case -ECONNREFUSED:
	286	break;
	287	default:
	288	ac.error = -EIO;
	289	goto error;
	290	}
08e0e7c8	291	}
08e0e7c8	292
d2ddc776 DH	293	error:
d2ddc776 DH	294	return ERR_PTR(afs_end_cursor(&ac));
08e0e7c8	295	}
1da177e4	296
08e0e7c8	297	/*
d2ddc776	298	* Get or create a fileserver record.
08e0e7c8	299	*/
d2ddc776 DH	300	struct afs_server afs_lookup_server(struct afs_cell cell, struct key *key,
d2ddc776 DH	301	const uuid_t *uuid)
08e0e7c8	302	{
d2ddc776 DH	303	struct afs_addr_list *alist;
d2ddc776 DH	304	struct afs_server server, candidate;
1da177e4	305
d2ddc776	306	_enter("%p,%pU", cell->net, uuid);
8324f0bc	307
d2ddc776 DH	308	server = afs_find_server_by_uuid(cell->net, uuid);
	309	if (server)
	310	return server;
1da177e4	311
d2ddc776 DH	312	alist = afs_vl_lookup_addrs(cell, key, uuid);
	313	if (IS_ERR(alist))
	314	return ERR_CAST(alist);
1da177e4	315
d2ddc776 DH	316	candidate = afs_alloc_server(cell->net, uuid, alist);
	317	if (!candidate) {
	318	afs_put_addrlist(alist);
	319	return ERR_PTR(-ENOMEM);
	320	}
1da177e4	321
d2ddc776 DH	322	server = afs_install_server(cell->net, candidate);
	323	if (server != candidate) {
	324	afs_put_addrlist(alist);
	325	kfree(candidate);
08e0e7c8	326	}
1da177e4	327
d2ddc776	328	_leave(" = %p{%d}", server, atomic_read(&server->usage));
08e0e7c8	329	return server;
ec26815a	330	}
1da177e4	331
d2ddc776 DH	332	/*
	333	* Set the server timer to fire after a given delay, assuming it's not already
	334	* set for an earlier time.
	335	*/
59fa1c4a DH	336	static void afs_set_server_timer(struct afs_net *net, time64_t delay)
59fa1c4a DH	337	{
59fa1c4a	338	if (net->live) {
d2ddc776 DH	339	afs_inc_servers_outstanding(net);
d2ddc776 DH	340	if (timer_reduce(&net->fs_timer, jiffies + delay * HZ))
59fa1c4a DH	341	afs_dec_servers_outstanding(net);
	342	}
	343	}
	344
1da177e4	345	/*
d2ddc776 DH	346	* Server management timer. We have an increment on fs_outstanding that we
	347	* need to pass along to the work item.
	348	*/
	349	void afs_servers_timer(struct timer_list *timer)
	350	{
	351	struct afs_net *net = container_of(timer, struct afs_net, fs_timer);
	352
	353	_enter("");
	354	if (!queue_work(afs_wq, &net->fs_manager))
	355	afs_dec_servers_outstanding(net);
	356	}
	357
	358	/*
	359	* Release a reference on a server record.
1da177e4	360	*/
9ed900b1	361	void afs_put_server(struct afs_net net, struct afs_server server)
1da177e4	362	{
d2ddc776 DH	363	unsigned int usage;
d2ddc776 DH	364
1da177e4 LT	365	if (!server)
	366	return;
	367
d2ddc776	368	server->put_time = ktime_get_real_seconds();
1da177e4	369
d2ddc776	370	usage = atomic_dec_return(&server->usage);
260a9803	371
d2ddc776	372	_enter("{%u}", usage);
1da177e4	373
d2ddc776	374	if (likely(usage > 0))
1da177e4	375	return;
1da177e4	376
d2ddc776 DH	377	afs_set_server_timer(net, afs_server_gc_delay);
	378	}
	379
	380	static void afs_server_rcu(struct rcu_head *rcu)
	381	{
	382	struct afs_server *server = container_of(rcu, struct afs_server, rcu);
	383
	384	afs_put_addrlist(server->addresses);
	385	kfree(server);
ec26815a	386	}
1da177e4	387
1da177e4	388	/*
08e0e7c8	389	* destroy a dead server
1da177e4	390	*/
59fa1c4a	391	static void afs_destroy_server(struct afs_net net, struct afs_server server)
1da177e4	392	{
d2ddc776	393	struct afs_addr_list *alist = server->addresses;
8b2a464c DH	394	struct afs_addr_cursor ac = {
	395	.alist = alist,
	396	.addr = &alist->addrs[0],
	397	.start = alist->index,
	398	.index = alist->index,
	399	.error = 0,
	400	};
1da177e4 LT	401	_enter("%p", server);
1da177e4 LT	402
d2ddc776 DH	403	afs_fs_give_up_all_callbacks(net, server, &ac, NULL);
d2ddc776 DH	404	call_rcu(&server->rcu, afs_server_rcu);
59fa1c4a	405	afs_dec_servers_outstanding(net);
ec26815a	406	}
1da177e4	407
1da177e4	408	/*
d2ddc776	409	* Garbage collect any expired servers.
1da177e4	410	*/
d2ddc776	411	static void afs_gc_servers(struct afs_net net, struct afs_server gc_list)
1da177e4	412	{
08e0e7c8	413	struct afs_server *server;
d2ddc776 DH	414	bool deleted;
	415	int usage;
	416
	417	while ((server = gc_list)) {
	418	gc_list = server->gc_next;
	419
	420	write_seqlock(&net->fs_lock);
	421	usage = 1;
	422	deleted = atomic_try_cmpxchg(&server->usage, &usage, 0);
	423	if (deleted) {
	424	rb_erase(&server->uuid_rb, &net->fs_servers);
	425	hlist_del_rcu(&server->proc_link);
1da177e4	426	}
d2ddc776	427	write_sequnlock(&net->fs_lock);
1da177e4	428
d2ddc776 DH	429	if (deleted)
	430	afs_destroy_server(net, server);
	431	}
	432	}
	433
	434	/*
	435	* Manage the records of servers known to be within a network namespace. This
	436	* includes garbage collecting unused servers.
	437	*
	438	* Note also that we were given an increment on net->servers_outstanding by
	439	* whoever queued us that we need to deal with before returning.
	440	*/
	441	void afs_manage_servers(struct work_struct *work)
	442	{
	443	struct afs_net *net = container_of(work, struct afs_net, fs_manager);
	444	struct afs_server *gc_list = NULL;
	445	struct rb_node *cursor;
	446	time64_t now = ktime_get_real_seconds(), next_manage = TIME64_MAX;
	447	bool purging = !net->live;
	448
	449	_enter("");
	450
	451	/* Trawl the server list looking for servers that have expired from
	452	* lack of use.
	453	*/
	454	read_seqlock_excl(&net->fs_lock);
	455
	456	for (cursor = rb_first(&net->fs_servers); cursor; cursor = rb_next(cursor)) {
	457	struct afs_server *server =
	458	rb_entry(cursor, struct afs_server, uuid_rb);
	459	int usage = atomic_read(&server->usage);
	460
	461	_debug("manage %pU %u", &server->uuid, usage);
	462
	463	ASSERTCMP(usage, >=, 1);
	464	ASSERTIFCMP(purging, usage, ==, 1);
	465
	466	if (usage == 1) {
	467	time64_t expire_at = server->put_time;
	468
	469	if (!test_bit(AFS_SERVER_FL_VL_FAIL, &server->flags) &&
	470	!test_bit(AFS_SERVER_FL_NOT_FOUND, &server->flags))
	471	expire_at += afs_server_gc_delay;
	472	if (purging \|\| expire_at <= now) {
	473	server->gc_next = gc_list;
	474	gc_list = server;
	475	} else if (expire_at < next_manage) {
	476	next_manage = expire_at;
	477	}
1da177e4 LT	478	}
	479	}
	480
d2ddc776	481	read_sequnlock_excl(&net->fs_lock);
1da177e4	482
d2ddc776 DH	483	/* Update the timer on the way out. We have to pass an increment on
	484	* servers_outstanding in the namespace that we are in to the timer or
	485	* the work scheduler.
	486	*/
	487	if (!purging && next_manage < TIME64_MAX) {
	488	now = ktime_get_real_seconds();
	489
	490	if (next_manage - now <= 0) {
	491	if (queue_work(afs_wq, &net->fs_manager))
	492	afs_inc_servers_outstanding(net);
	493	} else {
	494	afs_set_server_timer(net, next_manage - now);
	495	}
1da177e4	496	}
59fa1c4a	497
d2ddc776 DH	498	afs_gc_servers(net, gc_list);
d2ddc776 DH	499
59fa1c4a	500	afs_dec_servers_outstanding(net);
d2ddc776 DH	501	_leave(" [%d]", atomic_read(&net->servers_outstanding));
	502	}
	503
	504	static void afs_queue_server_manager(struct afs_net *net)
	505	{
	506	afs_inc_servers_outstanding(net);
	507	if (!queue_work(afs_wq, &net->fs_manager))
	508	afs_dec_servers_outstanding(net);
ec26815a	509	}
1da177e4	510
1da177e4	511	/*
d2ddc776	512	* Purge list of servers.
1da177e4	513	*/
d2ddc776	514	void afs_purge_servers(struct afs_net *net)
1da177e4	515	{
d2ddc776 DH	516	_enter("");
	517
	518	if (del_timer_sync(&net->fs_timer))
59fa1c4a DH	519	atomic_dec(&net->servers_outstanding);
59fa1c4a DH	520
d2ddc776	521	afs_queue_server_manager(net);
59fa1c4a	522
d2ddc776	523	_debug("wait");
59fa1c4a DH	524	wait_on_atomic_t(&net->servers_outstanding, atomic_t_wait,
59fa1c4a DH	525	TASK_UNINTERRUPTIBLE);
d2ddc776 DH	526	_leave("");
	527	}
	528
	529	/*
	530	* Probe a fileserver to find its capabilities.
	531	*
	532	* TODO: Try service upgrade.
	533	*/
	534	static bool afs_do_probe_fileserver(struct afs_fs_cursor *fc)
	535	{
	536	_enter("");
	537
	538	fc->ac.addr = NULL;
	539	fc->ac.start = READ_ONCE(fc->ac.alist->index);
	540	fc->ac.index = fc->ac.start;
	541	fc->ac.error = 0;
	542	fc->ac.begun = false;
	543
	544	while (afs_iterate_addresses(&fc->ac)) {
	545	afs_fs_get_capabilities(afs_v2net(fc->vnode), fc->cbi->server,
	546	&fc->ac, fc->key);
	547	switch (fc->ac.error) {
	548	case 0:
	549	afs_end_cursor(&fc->ac);
	550	set_bit(AFS_SERVER_FL_PROBED, &fc->cbi->server->flags);
	551	return true;
	552	case -ECONNABORTED:
	553	fc->ac.error = afs_abort_to_error(fc->ac.abort_code);
	554	goto error;
	555	case -ENOMEM:
	556	case -ENONET:
	557	goto error;
	558	case -ENETUNREACH:
	559	case -EHOSTUNREACH:
	560	case -ECONNREFUSED:
	561	case -ETIMEDOUT:
	562	case -ETIME:
	563	break;
	564	default:
	565	fc->ac.error = -EIO;
	566	goto error;
	567	}
	568	}
	569
	570	error:
	571	afs_end_cursor(&fc->ac);
	572	return false;
	573	}
	574
	575	/*
	576	* If we haven't already, try probing the fileserver to get its capabilities.
	577	* We try not to instigate parallel probes, but it's possible that the parallel
	578	* probes will fail due to authentication failure when ours would succeed.
	579	*
	580	* TODO: Try sending an anonymous probe if an authenticated probe fails.
	581	*/
	582	bool afs_probe_fileserver(struct afs_fs_cursor *fc)
	583	{
	584	bool success;
	585	int ret, retries = 0;
	586
	587	_enter("");
	588
	589	retry:
590	if (test_bit(AFS_SERVER_FL_PROBED, &fc->cbi->server->flags)) {
591	_leave(" = t");
592	return true;
593	}
594
595	if (!test_and_set_bit_lock(AFS_SERVER_FL_PROBING, &fc->cbi->server->flags)) {
596	success = afs_do_probe_fileserver(fc);
597	clear_bit_unlock(AFS_SERVER_FL_PROBING, &fc->cbi->server->flags);
598	wake_up_bit(&fc->cbi->server->flags, AFS_SERVER_FL_PROBING);
599	_leave(" = t");
600	return success;
601	}
602
603	_debug("wait");
604	ret = wait_on_bit(&fc->cbi->server->flags, AFS_SERVER_FL_PROBING,
605	TASK_INTERRUPTIBLE);
606	if (ret == -ERESTARTSYS) {
607	fc->ac.error = ret;
608	_leave(" = f [%d]", ret);
609	return false;
610	}
611
612	retries++;
613	if (retries == 4) {
614	fc->ac.error = -ESTALE;
615	_leave(" = f [stale]");
616	return false;
617	}
618	_debug("retry");
619	goto retry;
620	}
621
622	/*
623	* Get an update for a server's address list.
624	*/
625	static noinline bool afs_update_server_record(struct afs_fs_cursor fc, struct afs_server server)
626	{
627	struct afs_addr_list alist, discard;
628
629	_enter("");
630
631	alist = afs_vl_lookup_addrs(fc->vnode->volume->cell, fc->key,
632	&server->uuid);
633	if (IS_ERR(alist)) {
634	fc->ac.error = PTR_ERR(alist);
635	_leave(" = f [%d]", fc->ac.error);
636	return false;
637	}
638
639	discard = alist;
640	if (server->addr_version != alist->version) {
641	write_lock(&server->fs_lock);
642	discard = rcu_dereference_protected(server->addresses,
643	lockdep_is_held(&server->fs_lock));
644	rcu_assign_pointer(server->addresses, alist);
645	server->addr_version = alist->version;
646	write_unlock(&server->fs_lock);
647	}
648
649	server->update_at = ktime_get_real_seconds() + afs_server_update_delay;
650	afs_put_addrlist(discard);
651	_leave(" = t");
652	return true;
653	}
654
655	/*
656	* See if a server's address list needs updating.
657	*/
658	bool afs_check_server_record(struct afs_fs_cursor fc, struct afs_server server)
659	{
660	time64_t now = ktime_get_real_seconds();
661	long diff;
662	bool success;
663	int ret, retries = 0;
664
665	_enter("");
666
667	ASSERT(server);
668
669	retry:
670	diff = READ_ONCE(server->update_at) - now;
671	if (diff > 0) {
672	_leave(" = t [not now %ld]", diff);
673	return true;
674	}
675
676	if (!test_and_set_bit_lock(AFS_SERVER_FL_UPDATING, &server->flags)) {
677	success = afs_update_server_record(fc, server);
678	clear_bit_unlock(AFS_SERVER_FL_UPDATING, &server->flags);
679	wake_up_bit(&server->flags, AFS_SERVER_FL_UPDATING);
680	_leave(" = %d", success);
681	return success;
682	}
683
684	ret = wait_on_bit(&server->flags, AFS_SERVER_FL_UPDATING,
685	TASK_INTERRUPTIBLE);
686	if (ret == -ERESTARTSYS) {
687	fc->ac.error = ret;
688	_leave(" = f [intr]");
689	return false;
690	}
691
692	retries++;
693	if (retries == 4) {
694	_leave(" = f [stale]");
695	ret = -ESTALE;
696	return false;
697	}
698	goto retry;
ec26815a	699	}