mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-23 04:34:11 +08:00
d5c32c89b2
Currently, once configured, AFS cells are looked up in the DNS at regular
intervals - which is a waste of resources if those cells aren't being
used. It also leads to a problem where cells preloaded, but not
configured, before the network is brought up end up effectively statically
configured with no VL servers and are unable to get any.
Fix this by not doing the DNS lookup until the first time a cell is
touched. It is waited for if we don't have any cached records yet,
otherwise the DNS lookup to maintain the record is done in the background.
This has the downside that the first time you touch a cell, you now have to
wait for the upcall to do the required DNS lookups rather than them already
being cached.
Further, the record is not replaced if the old record has at least one
server in it and the new record doesn't have any.
Fixes: 0a5143f2f8
("afs: Implement VL server rotation")
Signed-off-by: David Howells <dhowells@redhat.com>
344 lines
8.5 KiB
C
344 lines
8.5 KiB
C
/* Handle vlserver selection and rotation.
|
|
*
|
|
* Copyright (C) 2018 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 Licence
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the Licence, or (at your option) any later version.
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/sched/signal.h>
|
|
#include "internal.h"
|
|
#include "afs_vl.h"
|
|
|
|
/*
|
|
* Begin an operation on a volume location server.
|
|
*/
|
|
bool afs_begin_vlserver_operation(struct afs_vl_cursor *vc, struct afs_cell *cell,
|
|
struct key *key)
|
|
{
|
|
memset(vc, 0, sizeof(*vc));
|
|
vc->cell = cell;
|
|
vc->key = key;
|
|
vc->error = -EDESTADDRREQ;
|
|
vc->ac.error = SHRT_MAX;
|
|
|
|
if (signal_pending(current)) {
|
|
vc->error = -EINTR;
|
|
vc->flags |= AFS_VL_CURSOR_STOP;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* Begin iteration through a server list, starting with the last used server if
|
|
* possible, or the last recorded good server if not.
|
|
*/
|
|
static bool afs_start_vl_iteration(struct afs_vl_cursor *vc)
|
|
{
|
|
struct afs_cell *cell = vc->cell;
|
|
unsigned int dns_lookup_count;
|
|
|
|
if (cell->dns_source == DNS_RECORD_UNAVAILABLE ||
|
|
cell->dns_expiry <= ktime_get_real_seconds()) {
|
|
dns_lookup_count = smp_load_acquire(&cell->dns_lookup_count);
|
|
set_bit(AFS_CELL_FL_DO_LOOKUP, &cell->flags);
|
|
queue_work(afs_wq, &cell->manager);
|
|
|
|
if (cell->dns_source == DNS_RECORD_UNAVAILABLE) {
|
|
if (wait_var_event_interruptible(
|
|
&cell->dns_lookup_count,
|
|
smp_load_acquire(&cell->dns_lookup_count)
|
|
!= dns_lookup_count) < 0) {
|
|
vc->error = -ERESTARTSYS;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/* Status load is ordered after lookup counter load */
|
|
if (cell->dns_source == DNS_RECORD_UNAVAILABLE) {
|
|
vc->error = -EDESTADDRREQ;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
read_lock(&cell->vl_servers_lock);
|
|
vc->server_list = afs_get_vlserverlist(
|
|
rcu_dereference_protected(cell->vl_servers,
|
|
lockdep_is_held(&cell->vl_servers_lock)));
|
|
read_unlock(&cell->vl_servers_lock);
|
|
if (!vc->server_list->nr_servers)
|
|
return false;
|
|
|
|
vc->untried = (1UL << vc->server_list->nr_servers) - 1;
|
|
vc->index = -1;
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* Select the vlserver to use. May be called multiple times to rotate
|
|
* through the vlservers.
|
|
*/
|
|
bool afs_select_vlserver(struct afs_vl_cursor *vc)
|
|
{
|
|
struct afs_addr_list *alist;
|
|
struct afs_vlserver *vlserver;
|
|
struct afs_error e;
|
|
u32 rtt;
|
|
int error = vc->ac.error, i;
|
|
|
|
_enter("%lx[%d],%lx[%d],%d,%d",
|
|
vc->untried, vc->index,
|
|
vc->ac.tried, vc->ac.index,
|
|
error, vc->ac.abort_code);
|
|
|
|
if (vc->flags & AFS_VL_CURSOR_STOP) {
|
|
_leave(" = f [stopped]");
|
|
return false;
|
|
}
|
|
|
|
vc->nr_iterations++;
|
|
|
|
/* Evaluate the result of the previous operation, if there was one. */
|
|
switch (error) {
|
|
case SHRT_MAX:
|
|
goto start;
|
|
|
|
default:
|
|
case 0:
|
|
/* Success or local failure. Stop. */
|
|
vc->error = error;
|
|
vc->flags |= AFS_VL_CURSOR_STOP;
|
|
_leave(" = f [okay/local %d]", vc->ac.error);
|
|
return false;
|
|
|
|
case -ECONNABORTED:
|
|
/* The far side rejected the operation on some grounds. This
|
|
* might involve the server being busy or the volume having been moved.
|
|
*/
|
|
switch (vc->ac.abort_code) {
|
|
case AFSVL_IO:
|
|
case AFSVL_BADVOLOPER:
|
|
case AFSVL_NOMEM:
|
|
/* The server went weird. */
|
|
vc->error = -EREMOTEIO;
|
|
//write_lock(&vc->cell->vl_servers_lock);
|
|
//vc->server_list->weird_mask |= 1 << vc->index;
|
|
//write_unlock(&vc->cell->vl_servers_lock);
|
|
goto next_server;
|
|
|
|
default:
|
|
vc->error = afs_abort_to_error(vc->ac.abort_code);
|
|
goto failed;
|
|
}
|
|
|
|
case -ERFKILL:
|
|
case -EADDRNOTAVAIL:
|
|
case -ENETUNREACH:
|
|
case -EHOSTUNREACH:
|
|
case -EHOSTDOWN:
|
|
case -ECONNREFUSED:
|
|
case -ETIMEDOUT:
|
|
case -ETIME:
|
|
_debug("no conn %d", error);
|
|
vc->error = error;
|
|
goto iterate_address;
|
|
|
|
case -ECONNRESET:
|
|
_debug("call reset");
|
|
vc->error = error;
|
|
vc->flags |= AFS_VL_CURSOR_RETRY;
|
|
goto next_server;
|
|
}
|
|
|
|
restart_from_beginning:
|
|
_debug("restart");
|
|
afs_end_cursor(&vc->ac);
|
|
afs_put_vlserverlist(vc->cell->net, vc->server_list);
|
|
vc->server_list = NULL;
|
|
if (vc->flags & AFS_VL_CURSOR_RETRIED)
|
|
goto failed;
|
|
vc->flags |= AFS_VL_CURSOR_RETRIED;
|
|
start:
|
|
_debug("start");
|
|
|
|
if (!afs_start_vl_iteration(vc))
|
|
goto failed;
|
|
|
|
error = afs_send_vl_probes(vc->cell->net, vc->key, vc->server_list);
|
|
if (error < 0)
|
|
goto failed_set_error;
|
|
|
|
pick_server:
|
|
_debug("pick [%lx]", vc->untried);
|
|
|
|
error = afs_wait_for_vl_probes(vc->server_list, vc->untried);
|
|
if (error < 0)
|
|
goto failed_set_error;
|
|
|
|
/* Pick the untried server with the lowest RTT. */
|
|
vc->index = vc->server_list->preferred;
|
|
if (test_bit(vc->index, &vc->untried))
|
|
goto selected_server;
|
|
|
|
vc->index = -1;
|
|
rtt = U32_MAX;
|
|
for (i = 0; i < vc->server_list->nr_servers; i++) {
|
|
struct afs_vlserver *s = vc->server_list->servers[i].server;
|
|
|
|
if (!test_bit(i, &vc->untried) || !s->probe.responded)
|
|
continue;
|
|
if (s->probe.rtt < rtt) {
|
|
vc->index = i;
|
|
rtt = s->probe.rtt;
|
|
}
|
|
}
|
|
|
|
if (vc->index == -1)
|
|
goto no_more_servers;
|
|
|
|
selected_server:
|
|
_debug("use %d", vc->index);
|
|
__clear_bit(vc->index, &vc->untried);
|
|
|
|
/* We're starting on a different vlserver from the list. We need to
|
|
* check it, find its address list and probe its capabilities before we
|
|
* use it.
|
|
*/
|
|
ASSERTCMP(vc->ac.alist, ==, NULL);
|
|
vlserver = vc->server_list->servers[vc->index].server;
|
|
vc->server = vlserver;
|
|
|
|
_debug("USING VLSERVER: %s", vlserver->name);
|
|
|
|
read_lock(&vlserver->lock);
|
|
alist = rcu_dereference_protected(vlserver->addresses,
|
|
lockdep_is_held(&vlserver->lock));
|
|
afs_get_addrlist(alist);
|
|
read_unlock(&vlserver->lock);
|
|
|
|
memset(&vc->ac, 0, sizeof(vc->ac));
|
|
|
|
if (!vc->ac.alist)
|
|
vc->ac.alist = alist;
|
|
else
|
|
afs_put_addrlist(alist);
|
|
|
|
vc->ac.index = -1;
|
|
|
|
iterate_address:
|
|
ASSERT(vc->ac.alist);
|
|
/* Iterate over the current server's address list to try and find an
|
|
* address on which it will respond to us.
|
|
*/
|
|
if (!afs_iterate_addresses(&vc->ac))
|
|
goto next_server;
|
|
|
|
_debug("VL address %d/%d", vc->ac.index, vc->ac.alist->nr_addrs);
|
|
|
|
_leave(" = t %pISpc", &vc->ac.alist->addrs[vc->ac.index].transport);
|
|
return true;
|
|
|
|
next_server:
|
|
_debug("next");
|
|
afs_end_cursor(&vc->ac);
|
|
goto pick_server;
|
|
|
|
no_more_servers:
|
|
/* That's all the servers poked to no good effect. Try again if some
|
|
* of them were busy.
|
|
*/
|
|
if (vc->flags & AFS_VL_CURSOR_RETRY)
|
|
goto restart_from_beginning;
|
|
|
|
e.error = -EDESTADDRREQ;
|
|
e.responded = false;
|
|
for (i = 0; i < vc->server_list->nr_servers; i++) {
|
|
struct afs_vlserver *s = vc->server_list->servers[i].server;
|
|
|
|
afs_prioritise_error(&e, READ_ONCE(s->probe.error),
|
|
s->probe.abort_code);
|
|
}
|
|
|
|
failed_set_error:
|
|
vc->error = error;
|
|
failed:
|
|
vc->flags |= AFS_VL_CURSOR_STOP;
|
|
afs_end_cursor(&vc->ac);
|
|
_leave(" = f [failed %d]", vc->error);
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* Dump cursor state in the case of the error being EDESTADDRREQ.
|
|
*/
|
|
static void afs_vl_dump_edestaddrreq(const struct afs_vl_cursor *vc)
|
|
{
|
|
static int count;
|
|
int i;
|
|
|
|
if (!IS_ENABLED(CONFIG_AFS_DEBUG_CURSOR) || count > 3)
|
|
return;
|
|
count++;
|
|
|
|
rcu_read_lock();
|
|
pr_notice("EDESTADDR occurred\n");
|
|
pr_notice("VC: ut=%lx ix=%u ni=%hu fl=%hx err=%hd\n",
|
|
vc->untried, vc->index, vc->nr_iterations, vc->flags, vc->error);
|
|
|
|
if (vc->server_list) {
|
|
const struct afs_vlserver_list *sl = vc->server_list;
|
|
pr_notice("VC: SL nr=%u ix=%u\n",
|
|
sl->nr_servers, sl->index);
|
|
for (i = 0; i < sl->nr_servers; i++) {
|
|
const struct afs_vlserver *s = sl->servers[i].server;
|
|
pr_notice("VC: server %s+%hu fl=%lx E=%hd\n",
|
|
s->name, s->port, s->flags, s->probe.error);
|
|
if (s->addresses) {
|
|
const struct afs_addr_list *a =
|
|
rcu_dereference(s->addresses);
|
|
pr_notice("VC: - nr=%u/%u/%u pf=%u\n",
|
|
a->nr_ipv4, a->nr_addrs, a->max_addrs,
|
|
a->preferred);
|
|
pr_notice("VC: - pr=%lx R=%lx F=%lx\n",
|
|
a->probed, a->responded, a->failed);
|
|
if (a == vc->ac.alist)
|
|
pr_notice("VC: - current\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
pr_notice("AC: t=%lx ax=%u ac=%d er=%d r=%u ni=%u\n",
|
|
vc->ac.tried, vc->ac.index, vc->ac.abort_code, vc->ac.error,
|
|
vc->ac.responded, vc->ac.nr_iterations);
|
|
rcu_read_unlock();
|
|
}
|
|
|
|
/*
|
|
* Tidy up a volume location server cursor and unlock the vnode.
|
|
*/
|
|
int afs_end_vlserver_operation(struct afs_vl_cursor *vc)
|
|
{
|
|
struct afs_net *net = vc->cell->net;
|
|
|
|
if (vc->error == -EDESTADDRREQ ||
|
|
vc->error == -EADDRNOTAVAIL ||
|
|
vc->error == -ENETUNREACH ||
|
|
vc->error == -EHOSTUNREACH)
|
|
afs_vl_dump_edestaddrreq(vc);
|
|
|
|
afs_end_cursor(&vc->ac);
|
|
afs_put_vlserverlist(net, vc->server_list);
|
|
|
|
if (vc->error == -ECONNABORTED)
|
|
vc->error = afs_abort_to_error(vc->ac.abort_code);
|
|
|
|
return vc->error;
|
|
}
|