Commit 3bf0fb6f authored by David Howells's avatar David Howells

afs: Probe multiple fileservers simultaneously

Send probes to all the unprobed fileservers in a fileserver list on all
addresses simultaneously in an attempt to find out the fastest route whilst
not getting stuck for 20s on any server or address that we don't get a
reply from.

This alleviates the problem whereby attempting to access a new server can
take a long time because the rotation algorithm ends up rotating through
all servers and addresses until it finds one that responds.
Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
parent 18ac6185
...@@ -17,6 +17,7 @@ kafs-y := \ ...@@ -17,6 +17,7 @@ kafs-y := \
file.o \ file.o \
flock.o \ flock.o \
fsclient.o \ fsclient.o \
fs_probe.o \
inode.o \ inode.o \
main.o \ main.o \
misc.o \ misc.o \
...@@ -29,8 +30,9 @@ kafs-y := \ ...@@ -29,8 +30,9 @@ kafs-y := \
super.o \ super.o \
netdevices.o \ netdevices.o \
vlclient.o \ vlclient.o \
vl_rotate.o \
vl_list.o \ vl_list.o \
vl_probe.o \
vl_rotate.o \
volume.o \ volume.o \
write.o \ write.o \
xattr.o \ xattr.o \
......
...@@ -303,6 +303,8 @@ void afs_merge_fs_addr4(struct afs_addr_list *alist, __be32 xdr, u16 port) ...@@ -303,6 +303,8 @@ void afs_merge_fs_addr4(struct afs_addr_list *alist, __be32 xdr, u16 port)
sizeof(alist->addrs[0]) * (alist->nr_addrs - i)); sizeof(alist->addrs[0]) * (alist->nr_addrs - i));
srx = &alist->addrs[i]; srx = &alist->addrs[i];
srx->srx_family = AF_RXRPC;
srx->transport_type = SOCK_DGRAM;
srx->transport_len = sizeof(srx->transport.sin); srx->transport_len = sizeof(srx->transport.sin);
srx->transport.sin.sin_family = AF_INET; srx->transport.sin.sin_family = AF_INET;
srx->transport.sin.sin_port = htons(port); srx->transport.sin.sin_port = htons(port);
...@@ -341,6 +343,8 @@ void afs_merge_fs_addr6(struct afs_addr_list *alist, __be32 *xdr, u16 port) ...@@ -341,6 +343,8 @@ void afs_merge_fs_addr6(struct afs_addr_list *alist, __be32 *xdr, u16 port)
sizeof(alist->addrs[0]) * (alist->nr_addrs - i)); sizeof(alist->addrs[0]) * (alist->nr_addrs - i));
srx = &alist->addrs[i]; srx = &alist->addrs[i];
srx->srx_family = AF_RXRPC;
srx->transport_type = SOCK_DGRAM;
srx->transport_len = sizeof(srx->transport.sin6); srx->transport_len = sizeof(srx->transport.sin6);
srx->transport.sin6.sin6_family = AF_INET6; srx->transport.sin6.sin6_family = AF_INET6;
srx->transport.sin6.sin6_port = htons(port); srx->transport.sin6.sin6_port = htons(port);
...@@ -353,23 +357,32 @@ void afs_merge_fs_addr6(struct afs_addr_list *alist, __be32 *xdr, u16 port) ...@@ -353,23 +357,32 @@ void afs_merge_fs_addr6(struct afs_addr_list *alist, __be32 *xdr, u16 port)
*/ */
bool afs_iterate_addresses(struct afs_addr_cursor *ac) bool afs_iterate_addresses(struct afs_addr_cursor *ac)
{ {
_enter("%hu+%hd", ac->start, (short)ac->index); unsigned long set, failed;
int index;
if (!ac->alist) if (!ac->alist)
return false; return false;
set = ac->alist->responded;
failed = ac->alist->failed;
_enter("%lx-%lx-%lx,%d", set, failed, ac->tried, ac->index);
ac->nr_iterations++; ac->nr_iterations++;
if (ac->begun) { set &= ~(failed | ac->tried);
ac->index++;
if (ac->index == ac->alist->nr_addrs)
ac->index = 0;
if (ac->index == ac->start) if (!set)
return false; return false;
}
index = READ_ONCE(ac->alist->preferred);
if (test_bit(index, &set))
goto selected;
index = __ffs(set);
ac->begun = true; selected:
ac->index = index;
set_bit(index, &ac->tried);
ac->responded = false; ac->responded = false;
return true; return true;
} }
...@@ -383,12 +396,13 @@ int afs_end_cursor(struct afs_addr_cursor *ac) ...@@ -383,12 +396,13 @@ int afs_end_cursor(struct afs_addr_cursor *ac)
alist = ac->alist; alist = ac->alist;
if (alist) { if (alist) {
if (ac->responded && ac->index != ac->start) if (ac->responded &&
WRITE_ONCE(alist->index, ac->index); ac->index != alist->preferred &&
test_bit(ac->alist->preferred, &ac->tried))
WRITE_ONCE(alist->preferred, ac->index);
afs_put_addrlist(alist); afs_put_addrlist(alist);
ac->alist = NULL;
} }
ac->alist = NULL;
ac->begun = false;
return ac->error; return ac->error;
} }
...@@ -122,6 +122,8 @@ bool afs_cm_incoming_call(struct afs_call *call) ...@@ -122,6 +122,8 @@ bool afs_cm_incoming_call(struct afs_call *call)
{ {
_enter("{%u, CB.OP %u}", call->service_id, call->operation_ID); _enter("{%u, CB.OP %u}", call->service_id, call->operation_ID);
call->epoch = rxrpc_kernel_get_epoch(call->net->socket, call->rxcall);
switch (call->operation_ID) { switch (call->operation_ID) {
case CBCallBack: case CBCallBack:
call->type = &afs_SRXCBCallBack; call->type = &afs_SRXCBCallBack;
...@@ -151,6 +153,91 @@ bool afs_cm_incoming_call(struct afs_call *call) ...@@ -151,6 +153,91 @@ bool afs_cm_incoming_call(struct afs_call *call)
} }
} }
/*
* Record a probe to the cache manager from a server.
*/
static int afs_record_cm_probe(struct afs_call *call, struct afs_server *server)
{
_enter("");
if (test_bit(AFS_SERVER_FL_HAVE_EPOCH, &server->flags) &&
!test_bit(AFS_SERVER_FL_PROBING, &server->flags)) {
if (server->cm_epoch == call->epoch)
return 0;
if (!server->probe.said_rebooted) {
pr_notice("kAFS: FS rebooted %pU\n", &server->uuid);
server->probe.said_rebooted = true;
}
}
spin_lock(&server->probe_lock);
if (!test_bit(AFS_SERVER_FL_HAVE_EPOCH, &server->flags)) {
server->cm_epoch = call->epoch;
server->probe.cm_epoch = call->epoch;
goto out;
}
if (server->probe.cm_probed &&
call->epoch != server->probe.cm_epoch &&
!server->probe.said_inconsistent) {
pr_notice("kAFS: FS endpoints inconsistent %pU\n",
&server->uuid);
server->probe.said_inconsistent = true;
}
if (!server->probe.cm_probed || call->epoch == server->cm_epoch)
server->probe.cm_epoch = server->cm_epoch;
out:
server->probe.cm_probed = true;
spin_unlock(&server->probe_lock);
return 0;
}
/*
* Find the server record by peer address and record a probe to the cache
* manager from a server.
*/
static int afs_find_cm_server_by_peer(struct afs_call *call)
{
struct sockaddr_rxrpc srx;
struct afs_server *server;
rxrpc_kernel_get_peer(call->net->socket, call->rxcall, &srx);
server = afs_find_server(call->net, &srx);
if (!server) {
trace_afs_cm_no_server(call, &srx);
return 0;
}
call->cm_server = server;
return afs_record_cm_probe(call, server);
}
/*
* Find the server record by server UUID and record a probe to the cache
* manager from a server.
*/
static int afs_find_cm_server_by_uuid(struct afs_call *call,
struct afs_uuid *uuid)
{
struct afs_server *server;
rcu_read_lock();
server = afs_find_server_by_uuid(call->net, call->request);
rcu_read_unlock();
if (!server) {
trace_afs_cm_no_server_u(call, call->request);
return 0;
}
call->cm_server = server;
return afs_record_cm_probe(call, server);
}
/* /*
* Clean up a cache manager call. * Clean up a cache manager call.
*/ */
...@@ -187,7 +274,6 @@ static void SRXAFSCB_CallBack(struct work_struct *work) ...@@ -187,7 +274,6 @@ static void SRXAFSCB_CallBack(struct work_struct *work)
static int afs_deliver_cb_callback(struct afs_call *call) static int afs_deliver_cb_callback(struct afs_call *call)
{ {
struct afs_callback_break *cb; struct afs_callback_break *cb;
struct sockaddr_rxrpc srx;
__be32 *bp; __be32 *bp;
int ret, loop; int ret, loop;
...@@ -276,12 +362,7 @@ static int afs_deliver_cb_callback(struct afs_call *call) ...@@ -276,12 +362,7 @@ static int afs_deliver_cb_callback(struct afs_call *call)
/* we'll need the file server record as that tells us which set of /* we'll need the file server record as that tells us which set of
* vnodes to operate upon */ * vnodes to operate upon */
rxrpc_kernel_get_peer(call->net->socket, call->rxcall, &srx); return afs_find_cm_server_by_peer(call);
call->cm_server = afs_find_server(call->net, &srx);
if (!call->cm_server)
trace_afs_cm_no_server(call, &srx);
return afs_queue_call_work(call);
} }
/* /*
...@@ -305,13 +386,10 @@ static void SRXAFSCB_InitCallBackState(struct work_struct *work) ...@@ -305,13 +386,10 @@ static void SRXAFSCB_InitCallBackState(struct work_struct *work)
*/ */
static int afs_deliver_cb_init_call_back_state(struct afs_call *call) static int afs_deliver_cb_init_call_back_state(struct afs_call *call)
{ {
struct sockaddr_rxrpc srx;
int ret; int ret;
_enter(""); _enter("");
rxrpc_kernel_get_peer(call->net->socket, call->rxcall, &srx);
afs_extract_discard(call, 0); afs_extract_discard(call, 0);
ret = afs_extract_data(call, false); ret = afs_extract_data(call, false);
if (ret < 0) if (ret < 0)
...@@ -319,11 +397,7 @@ static int afs_deliver_cb_init_call_back_state(struct afs_call *call) ...@@ -319,11 +397,7 @@ static int afs_deliver_cb_init_call_back_state(struct afs_call *call)
/* we'll need the file server record as that tells us which set of /* we'll need the file server record as that tells us which set of
* vnodes to operate upon */ * vnodes to operate upon */
call->cm_server = afs_find_server(call->net, &srx); return afs_find_cm_server_by_peer(call);
if (!call->cm_server)
trace_afs_cm_no_server(call, &srx);
return afs_queue_call_work(call);
} }
/* /*
...@@ -384,13 +458,7 @@ static int afs_deliver_cb_init_call_back_state3(struct afs_call *call) ...@@ -384,13 +458,7 @@ static int afs_deliver_cb_init_call_back_state3(struct afs_call *call)
/* we'll need the file server record as that tells us which set of /* we'll need the file server record as that tells us which set of
* vnodes to operate upon */ * vnodes to operate upon */
rcu_read_lock(); return afs_find_cm_server_by_uuid(call, call->request);
call->cm_server = afs_find_server_by_uuid(call->net, call->request);
rcu_read_unlock();
if (!call->cm_server)
trace_afs_cm_no_server_u(call, call->request);
return afs_queue_call_work(call);
} }
/* /*
...@@ -422,8 +490,7 @@ static int afs_deliver_cb_probe(struct afs_call *call) ...@@ -422,8 +490,7 @@ static int afs_deliver_cb_probe(struct afs_call *call)
if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING)) if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
return afs_io_error(call, afs_io_error_cm_reply); return afs_io_error(call, afs_io_error_cm_reply);
return afs_find_cm_server_by_peer(call);
return afs_queue_call_work(call);
} }
/* /*
...@@ -503,8 +570,7 @@ static int afs_deliver_cb_probe_uuid(struct afs_call *call) ...@@ -503,8 +570,7 @@ static int afs_deliver_cb_probe_uuid(struct afs_call *call)
if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING)) if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
return afs_io_error(call, afs_io_error_cm_reply); return afs_io_error(call, afs_io_error_cm_reply);
return afs_find_cm_server_by_uuid(call, call->request);
return afs_queue_call_work(call);
} }
/* /*
...@@ -586,8 +652,7 @@ static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call) ...@@ -586,8 +652,7 @@ static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call)
if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING)) if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
return afs_io_error(call, afs_io_error_cm_reply); return afs_io_error(call, afs_io_error_cm_reply);
return afs_find_cm_server_by_peer(call);
return afs_queue_call_work(call);
} }
/* /*
...@@ -596,7 +661,6 @@ static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call) ...@@ -596,7 +661,6 @@ static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call)
static int afs_deliver_yfs_cb_callback(struct afs_call *call) static int afs_deliver_yfs_cb_callback(struct afs_call *call)
{ {
struct afs_callback_break *cb; struct afs_callback_break *cb;
struct sockaddr_rxrpc srx;
struct yfs_xdr_YFSFid *bp; struct yfs_xdr_YFSFid *bp;
size_t size; size_t size;
int ret, loop; int ret, loop;
...@@ -664,10 +728,5 @@ static int afs_deliver_yfs_cb_callback(struct afs_call *call) ...@@ -664,10 +728,5 @@ static int afs_deliver_yfs_cb_callback(struct afs_call *call)
/* We'll need the file server record as that tells us which set of /* We'll need the file server record as that tells us which set of
* vnodes to operate upon. * vnodes to operate upon.
*/ */
rxrpc_kernel_get_peer(call->net->socket, call->rxcall, &srx); return afs_find_cm_server_by_peer(call);
call->cm_server = afs_find_server(call->net, &srx);
if (!call->cm_server)
trace_afs_cm_no_server(call, &srx);
return afs_queue_call_work(call);
} }
/* AFS fileserver probing
*
* 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/sched.h>
#include <linux/slab.h>
#include "afs_fs.h"
#include "internal.h"
#include "protocol_yfs.h"
static bool afs_fs_probe_done(struct afs_server *server)
{
if (!atomic_dec_and_test(&server->probe_outstanding))
return false;
wake_up_var(&server->probe_outstanding);
clear_bit_unlock(AFS_SERVER_FL_PROBING, &server->flags);
wake_up_bit(&server->flags, AFS_SERVER_FL_PROBING);
return true;
}
/*
* Process the result of probing a fileserver. This is called after successful
* or failed delivery of an FS.GetCapabilities operation.
*/
void afs_fileserver_probe_result(struct afs_call *call)
{
struct afs_addr_list *alist = call->alist;
struct afs_server *server = call->reply[0];
unsigned int server_index = (long)call->reply[1];
unsigned int index = call->addr_ix;
unsigned int rtt = UINT_MAX;
bool have_result = false;
u64 _rtt;
int ret = call->error;
_enter("%pU,%u", &server->uuid, index);
spin_lock(&server->probe_lock);
switch (ret) {
case 0:
server->probe.error = 0;
goto responded;
case -ECONNABORTED:
if (!server->probe.responded) {
server->probe.abort_code = call->abort_code;
server->probe.error = ret;
}
goto responded;
case -ENOMEM:
case -ENONET:
server->probe.local_failure = true;
afs_io_error(call, afs_io_error_fs_probe_fail);
goto out;
case -ECONNRESET: /* Responded, but call expired. */
case -ENETUNREACH:
case -EHOSTUNREACH:
case -ECONNREFUSED:
case -ETIMEDOUT:
case -ETIME:
default:
clear_bit(index, &alist->responded);
set_bit(index, &alist->failed);
if (!server->probe.responded &&
(server->probe.error == 0 ||
server->probe.error == -ETIMEDOUT ||
server->probe.error == -ETIME))
server->probe.error = ret;
afs_io_error(call, afs_io_error_fs_probe_fail);
goto out;
}
responded:
set_bit(index, &alist->responded);
clear_bit(index, &alist->failed);
if (call->service_id == YFS_FS_SERVICE) {
server->probe.is_yfs = true;
set_bit(AFS_SERVER_FL_IS_YFS, &server->flags);
alist->addrs[index].srx_service = call->service_id;
} else {
server->probe.not_yfs = true;
if (!server->probe.is_yfs) {
clear_bit(AFS_SERVER_FL_IS_YFS, &server->flags);
alist->addrs[index].srx_service = call->service_id;
}
}
/* Get the RTT and scale it to fit into a 32-bit value that represents
* over a minute of time so that we can access it with one instruction
* on a 32-bit system.
*/
_rtt = rxrpc_kernel_get_rtt(call->net->socket, call->rxcall);
_rtt /= 64;
rtt = (_rtt > UINT_MAX) ? UINT_MAX : _rtt;
if (rtt < server->probe.rtt) {
server->probe.rtt = rtt;
alist->preferred = index;
have_result = true;
}
smp_wmb(); /* Set rtt before responded. */
server->probe.responded = true;
set_bit(AFS_SERVER_FL_PROBED, &server->flags);
out:
spin_unlock(&server->probe_lock);
_debug("probe [%u][%u] %pISpc rtt=%u ret=%d",
server_index, index, &alist->addrs[index].transport,
(unsigned int)rtt, ret);
have_result |= afs_fs_probe_done(server);
if (have_result) {
server->probe.have_result = true;
wake_up_var(&server->probe.have_result);
wake_up_all(&server->probe_wq);
}
}
/*
* Probe all of a fileserver's addresses to find out the best route and to
* query its capabilities.
*/
static int afs_do_probe_fileserver(struct afs_net *net,
struct afs_server *server,
struct key *key,
unsigned int server_index)
{
struct afs_addr_cursor ac = {
.index = 0,
};
int ret;
_enter("%pU", &server->uuid);
read_lock(&server->fs_lock);
ac.alist = rcu_dereference_protected(server->addresses,
lockdep_is_held(&server->fs_lock));
read_unlock(&server->fs_lock);
atomic_set(&server->probe_outstanding, ac.alist->nr_addrs);
memset(&server->probe, 0, sizeof(server->probe));
server->probe.rtt = UINT_MAX;
for (ac.index = 0; ac.index < ac.alist->nr_addrs; ac.index++) {
ret = afs_fs_get_capabilities(net, server, &ac, key, server_index,
true);
if (ret != -EINPROGRESS) {
afs_fs_probe_done(server);
return ret;
}
}
return 0;
}
/*
* Send off probes to all unprobed servers.
*/
int afs_probe_fileservers(struct afs_net *net, struct key *key,
struct afs_server_list *list)
{
struct afs_server *server;
int i, ret;
for (i = 0; i < list->nr_servers; i++) {
server = list->servers[i].server;
if (test_bit(AFS_SERVER_FL_PROBED, &server->flags))
continue;
if (!test_and_set_bit_lock(AFS_SERVER_FL_PROBING, &server->flags)) {
ret = afs_do_probe_fileserver(net, server, key, i);
if (ret)
return ret;
}
}
return 0;
}
/*
* Wait for the first as-yet untried fileserver to respond.
*/
int afs_wait_for_fs_probes(struct afs_server_list *slist, unsigned long untried)
{
struct wait_queue_entry *waits;
struct afs_server *server;
unsigned int rtt = UINT_MAX;
bool have_responders = false;
int pref = -1, i;
_enter("%u,%lx", slist->nr_servers, untried);
/* Only wait for servers that have a probe outstanding. */
for (i = 0; i < slist->nr_servers; i++) {
if (test_bit(i, &untried)) {
server = slist->servers[i].server;
if (!test_bit(AFS_SERVER_FL_PROBING, &server->flags))
__clear_bit(i, &untried);
if (server->probe.responded)
have_responders = true;
}
}
if (have_responders || !untried)
return 0;
waits = kmalloc(array_size(slist->nr_servers, sizeof(*waits)), GFP_KERNEL);
if (!waits)
return -ENOMEM;
for (i = 0; i < slist->nr_servers; i++) {
if (test_bit(i, &untried)) {
server = slist->servers[i].server;
init_waitqueue_entry(&waits[i], current);
add_wait_queue(&server->probe_wq, &waits[i]);
}
}
for (;;) {
bool still_probing = false;
set_current_state(TASK_INTERRUPTIBLE);
for (i = 0; i < slist->nr_servers; i++) {
if (test_bit(i, &untried)) {
server = slist->servers[i].server;
if (server->probe.responded)
goto stop;
if (test_bit(AFS_SERVER_FL_PROBING, &server->flags))
still_probing = true;
}
}
if (!still_probing || unlikely(signal_pending(current)))
goto stop;
schedule();
}
stop:
set_current_state(TASK_RUNNING);
for (i = 0; i < slist->nr_servers; i++) {
if (test_bit(i, &untried)) {
server = slist->servers[i].server;
if (server->probe.responded &&
server->probe.rtt < rtt) {
pref = i;
rtt = server->probe.rtt;
}
remove_wait_queue(&server->probe_wq, &waits[i]);
}
}
kfree(waits);
if (pref == -1 && signal_pending(current))
return -ERESTARTSYS;
if (pref >= 0)
slist->preferred = pref;
return 0;
}
...@@ -2006,7 +2006,6 @@ int afs_fs_give_up_all_callbacks(struct afs_net *net, ...@@ -2006,7 +2006,6 @@ int afs_fs_give_up_all_callbacks(struct afs_net *net,
*/ */
static int afs_deliver_fs_get_capabilities(struct afs_call *call) static int afs_deliver_fs_get_capabilities(struct afs_call *call)
{ {
struct afs_server *server = call->reply[0];
u32 count; u32 count;
int ret; int ret;
...@@ -2042,15 +2041,18 @@ static int afs_deliver_fs_get_capabilities(struct afs_call *call) ...@@ -2042,15 +2041,18 @@ static int afs_deliver_fs_get_capabilities(struct afs_call *call)
break; break;
} }
if (call->service_id == YFS_FS_SERVICE)
set_bit(AFS_SERVER_FL_IS_YFS, &server->flags);
else
clear_bit(AFS_SERVER_FL_IS_YFS, &server->flags);
_leave(" = 0 [done]"); _leave(" = 0 [done]");
return 0; return 0;
} }
static void afs_destroy_fs_get_capabilities(struct afs_call *call)
{
struct afs_server *server = call->reply[0];
afs_put_server(call->net, server);
afs_flat_call_destructor(call);
}
/* /*
* FS.GetCapabilities operation type * FS.GetCapabilities operation type
*/ */
...@@ -2058,7 +2060,8 @@ static const struct afs_call_type afs_RXFSGetCapabilities = { ...@@ -2058,7 +2060,8 @@ static const struct afs_call_type afs_RXFSGetCapabilities = {
.name = "FS.GetCapabilities", .name = "FS.GetCapabilities",
.op = afs_FS_GetCapabilities, .op = afs_FS_GetCapabilities,
.deliver = afs_deliver_fs_get_capabilities, .deliver = afs_deliver_fs_get_capabilities,
.destructor = afs_flat_call_destructor, .done = afs_fileserver_probe_result,
.destructor = afs_destroy_fs_get_capabilities,
}; };
/* /*
...@@ -2068,7 +2071,9 @@ static const struct afs_call_type afs_RXFSGetCapabilities = { ...@@ -2068,7 +2071,9 @@ static const struct afs_call_type afs_RXFSGetCapabilities = {
int afs_fs_get_capabilities(struct afs_net *net, int afs_fs_get_capabilities(struct afs_net *net,
struct afs_server *server, struct afs_server *server,
struct afs_addr_cursor *ac, struct afs_addr_cursor *ac,
struct key *key) struct key *key,
unsigned int server_index,
bool async)
{ {
struct afs_call *call; struct afs_call *call;
__be32 *bp; __be32 *bp;
...@@ -2080,8 +2085,10 @@ int afs_fs_get_capabilities(struct afs_net *net, ...@@ -2080,8 +2085,10 @@ int afs_fs_get_capabilities(struct afs_net *net,
return -ENOMEM; return -ENOMEM;
call->key = key; call->key = key;
call->reply[0] = server; call->reply[0] = afs_get_server(server);
call->reply[1] = (void *)(long)server_index;
call->upgrade = true; call->upgrade = true;
call->want_reply_time = true;
/* marshall the parameters */ /* marshall the parameters */
bp = call->request; bp = call->request;
...@@ -2089,7 +2096,7 @@ int afs_fs_get_capabilities(struct afs_net *net, ...@@ -2089,7 +2096,7 @@ int afs_fs_get_capabilities(struct afs_net *net,
/* Can't take a ref on server */ /* Can't take a ref on server */
trace_afs_make_fs_call(call, NULL); trace_afs_make_fs_call(call, NULL);
return afs_make_call(ac, call, GFP_NOFS, false); return afs_make_call(ac, call, GFP_NOFS, async);
} }
/* /*
......
...@@ -76,12 +76,13 @@ struct afs_addr_list { ...@@ -76,12 +76,13 @@ struct afs_addr_list {
u32 version; /* Version */ u32 version; /* Version */
unsigned char max_addrs; unsigned char max_addrs;
unsigned char nr_addrs; unsigned char nr_addrs;
unsigned char index; /* Address currently in use */ unsigned char preferred; /* Preferred address */
unsigned char nr_ipv4; /* Number of IPv4 addresses */ unsigned char nr_ipv4; /* Number of IPv4 addresses */
enum dns_record_source source:8; enum dns_record_source source:8;
enum dns_lookup_status status:8; enum dns_lookup_status status:8;
unsigned long probed; /* Mask of servers that have been probed */ unsigned long probed; /* Mask of servers that have been probed */
unsigned long yfs; /* Mask of servers that are YFS */ unsigned long failed; /* Mask of addrs that failed locally/ICMP */
unsigned long responded; /* Mask of addrs that responded */
struct sockaddr_rxrpc addrs[]; struct sockaddr_rxrpc addrs[];
#define AFS_MAX_ADDRESSES ((unsigned int)(sizeof(unsigned long) * 8)) #define AFS_MAX_ADDRESSES ((unsigned int)(sizeof(unsigned long) * 8))
}; };
...@@ -91,6 +92,7 @@ struct afs_addr_list { ...@@ -91,6 +92,7 @@ struct afs_addr_list {
*/ */
struct afs_call { struct afs_call {
const struct afs_call_type *type; /* type of call */ const struct afs_call_type *type; /* type of call */
struct afs_addr_list *alist; /* Address is alist[addr_ix] */
wait_queue_head_t waitq; /* processes awaiting completion */ wait_queue_head_t waitq; /* processes awaiting completion */
struct work_struct async_work; /* async I/O processor */ struct work_struct async_work; /* async I/O processor */
struct work_struct work; /* actual work processor */ struct work_struct work; /* actual work processor */
...@@ -116,6 +118,7 @@ struct afs_call { ...@@ -116,6 +118,7 @@ struct afs_call {
spinlock_t state_lock; spinlock_t state_lock;
int error; /* error code */ int error; /* error code */
u32 abort_code; /* Remote abort ID or 0 */ u32 abort_code; /* Remote abort ID or 0 */
u32 epoch;
unsigned request_size; /* size of request data */ unsigned request_size; /* size of request data */
unsigned reply_max; /* maximum size of reply */ unsigned reply_max; /* maximum size of reply */
unsigned first_offset; /* offset into mapping[first] */ unsigned first_offset; /* offset into mapping[first] */
...@@ -125,13 +128,14 @@ struct afs_call { ...@@ -125,13 +128,14 @@ struct afs_call {
unsigned count2; /* count used in unmarshalling */ unsigned count2; /* count used in unmarshalling */
}; };
unsigned char unmarshall; /* unmarshalling phase */ unsigned char unmarshall; /* unmarshalling phase */
unsigned char addr_ix; /* Address in ->alist */
bool incoming; /* T if incoming call */ bool incoming; /* T if incoming call */
bool send_pages; /* T if data from mapping should be sent */ bool send_pages; /* T if data from mapping should be sent */
bool need_attention; /* T if RxRPC poked us */ bool need_attention; /* T if RxRPC poked us */
bool async; /* T if asynchronous */ bool async; /* T if asynchronous */
bool ret_reply0; /* T if should return reply[0] on success */ bool ret_reply0; /* T if should return reply[0] on success */
bool upgrade; /* T to request service upgrade */ bool upgrade; /* T to request service upgrade */
bool want_reply_time; /* T if want reply_time */ bool want_reply_time; /* T if want reply_time */
u16 service_id; /* Actual service ID (after upgrade) */ u16 service_id; /* Actual service ID (after upgrade) */
unsigned int debug_id; /* Trace ID */ unsigned int debug_id; /* Trace ID */
u32 operation_ID; /* operation ID for an incoming call */ u32 operation_ID; /* operation ID for an incoming call */
...@@ -162,6 +166,9 @@ struct afs_call_type { ...@@ -162,6 +166,9 @@ struct afs_call_type {
/* Work function */ /* Work function */
void (*work)(struct work_struct *work); void (*work)(struct work_struct *work);
/* Call done function (gets called immediately on success or failure) */
void (*done)(struct afs_call *call);
}; };
/* /*
...@@ -376,10 +383,27 @@ struct afs_vlserver { ...@@ -376,10 +383,27 @@ struct afs_vlserver {
unsigned long flags; unsigned long flags;
#define AFS_VLSERVER_FL_PROBED 0 /* The VL server has been probed */ #define AFS_VLSERVER_FL_PROBED 0 /* The VL server has been probed */
#define AFS_VLSERVER_FL_PROBING 1 /* VL server is being probed */ #define AFS_VLSERVER_FL_PROBING 1 /* VL server is being probed */
#define AFS_VLSERVER_FL_IS_YFS 2 /* Server is YFS not AFS */
rwlock_t lock; /* Lock on addresses */ rwlock_t lock; /* Lock on addresses */
atomic_t usage; atomic_t usage;
u16 name_len; /* Length of name */
/* Probe state */
wait_queue_head_t probe_wq;
atomic_t probe_outstanding;
spinlock_t probe_lock;
struct {
unsigned int rtt; /* RTT as ktime/64 */
u32 abort_code;
short error;
bool have_result;
bool responded:1;
bool is_yfs:1;
bool not_yfs:1;
bool local_failure:1;
} probe;
u16 port; u16 port;
u16 name_len; /* Length of name */
char name[]; /* Server name, case-flattened */ char name[]; /* Server name, case-flattened */
}; };
...@@ -399,6 +423,7 @@ struct afs_vlserver_list { ...@@ -399,6 +423,7 @@ struct afs_vlserver_list {
atomic_t usage; atomic_t usage;
u8 nr_servers; u8 nr_servers;
u8 index; /* Server currently in use */ u8 index; /* Server currently in use */
u8 preferred; /* Preferred server */
enum dns_record_source source:8; enum dns_record_source source:8;
enum dns_lookup_status status:8; enum dns_lookup_status status:8;
rwlock_t lock; rwlock_t lock;
...@@ -461,8 +486,10 @@ struct afs_server { ...@@ -461,8 +486,10 @@ struct afs_server {
#define AFS_SERVER_FL_MAY_HAVE_CB 8 /* May have callbacks on this fileserver */ #define AFS_SERVER_FL_MAY_HAVE_CB 8 /* May have callbacks on this fileserver */
#define AFS_SERVER_FL_IS_YFS 9 /* Server is YFS not AFS */ #define AFS_SERVER_FL_IS_YFS 9 /* Server is YFS not AFS */
#define AFS_SERVER_FL_NO_RM2 10 /* Fileserver doesn't support YFS.RemoveFile2 */ #define AFS_SERVER_FL_NO_RM2 10 /* Fileserver doesn't support YFS.RemoveFile2 */
#define AFS_SERVER_FL_HAVE_EPOCH 11 /* ->epoch is valid */
atomic_t usage; atomic_t usage;
u32 addr_version; /* Address list version */ u32 addr_version; /* Address list version */
u32 cm_epoch; /* Server RxRPC epoch */
/* file service access */ /* file service access */
rwlock_t fs_lock; /* access lock */ rwlock_t fs_lock; /* access lock */
...@@ -471,6 +498,26 @@ struct afs_server { ...@@ -471,6 +498,26 @@ struct afs_server {
struct hlist_head cb_volumes; /* List of volume interests on this server */ struct hlist_head cb_volumes; /* List of volume interests on this server */
unsigned cb_s_break; /* Break-everything counter. */ unsigned cb_s_break; /* Break-everything counter. */
rwlock_t cb_break_lock; /* Volume finding lock */ rwlock_t cb_break_lock; /* Volume finding lock */
/* Probe state */
wait_queue_head_t probe_wq;
atomic_t probe_outstanding;
spinlock_t probe_lock;
struct {
unsigned int rtt; /* RTT as ktime/64 */
u32 abort_code;
u32 cm_epoch;
short error;
bool have_result;
bool responded:1;
bool is_yfs:1;
bool not_yfs:1;
bool local_failure:1;
bool no_epoch:1;
bool cm_probed:1;
bool said_rebooted:1;
bool said_inconsistent:1;
} probe;
}; };
/* /*
...@@ -505,8 +552,8 @@ struct afs_server_entry { ...@@ -505,8 +552,8 @@ struct afs_server_entry {
struct afs_server_list { struct afs_server_list {
refcount_t usage; refcount_t usage;
unsigned short nr_servers; unsigned char nr_servers;
unsigned short index; /* Server currently in use */ unsigned char preferred; /* Preferred server */
unsigned short vnovol_mask; /* Servers to be skipped due to VNOVOL */ unsigned short vnovol_mask; /* Servers to be skipped due to VNOVOL */
unsigned int seq; /* Set to ->servers_seq when installed */ unsigned int seq; /* Set to ->servers_seq when installed */
rwlock_t lock; rwlock_t lock;
...@@ -653,13 +700,12 @@ struct afs_interface { ...@@ -653,13 +700,12 @@ struct afs_interface {
*/ */
struct afs_addr_cursor { struct afs_addr_cursor {
struct afs_addr_list *alist; /* Current address list (pins ref) */ struct afs_addr_list *alist; /* Current address list (pins ref) */
u32 abort_code; unsigned long tried; /* Tried addresses */
unsigned short start; /* Starting point in alist->addrs[] */ signed char index; /* Current address */
unsigned short index; /* Wrapping offset from start to current addr */
short error;
bool begun; /* T if we've begun iteration */
bool responded; /* T if the current address responded */ bool responded; /* T if the current address responded */
unsigned short nr_iterations; /* Number of address iterations */ unsigned short nr_iterations; /* Number of address iterations */
short error;
u32 abort_code;
}; };
/* /*
...@@ -669,9 +715,10 @@ struct afs_vl_cursor { ...@@ -669,9 +715,10 @@ struct afs_vl_cursor {
struct afs_addr_cursor ac; struct afs_addr_cursor ac;
struct afs_cell *cell; /* The cell we're querying */ struct afs_cell *cell; /* The cell we're querying */
struct afs_vlserver_list *server_list; /* Current server list (pins ref) */ struct afs_vlserver_list *server_list; /* Current server list (pins ref) */
struct afs_vlserver *server; /* Server on which this resides */
struct key *key; /* Key for the server */ struct key *key; /* Key for the server */
unsigned char start; /* Initial index in server list */ unsigned long untried; /* Bitmask of untried servers */
unsigned char index; /* Number of servers tried beyond start */ short index; /* Current server */
short error; short error;
unsigned short flags; unsigned short flags;
#define AFS_VL_CURSOR_STOP 0x0001 /* Set to cease iteration */ #define AFS_VL_CURSOR_STOP 0x0001 /* Set to cease iteration */
...@@ -689,10 +736,10 @@ struct afs_fs_cursor { ...@@ -689,10 +736,10 @@ struct afs_fs_cursor {
struct afs_server_list *server_list; /* Current server list (pins ref) */ struct afs_server_list *server_list; /* Current server list (pins ref) */
struct afs_cb_interest *cbi; /* Server on which this resides (pins ref) */ struct afs_cb_interest *cbi; /* Server on which this resides (pins ref) */
struct key *key; /* Key for the server */ struct key *key; /* Key for the server */
unsigned long untried; /* Bitmask of untried servers */
unsigned int cb_break; /* cb_break + cb_s_break before the call */ unsigned int cb_break; /* cb_break + cb_s_break before the call */
unsigned int cb_break_2; /* cb_break + cb_s_break (2nd vnode) */ unsigned int cb_break_2; /* cb_break + cb_s_break (2nd vnode) */
unsigned char start; /* Initial index in server list */ short index; /* Current server */
unsigned char index; /* Number of servers tried beyond start */
short error; short error;
unsigned short flags; unsigned short flags;
#define AFS_FS_CURSOR_STOP 0x0001 /* Set to cease iteration */ #define AFS_FS_CURSOR_STOP 0x0001 /* Set to cease iteration */
...@@ -888,7 +935,7 @@ extern int afs_fs_release_lock(struct afs_fs_cursor *); ...@@ -888,7 +935,7 @@ extern int afs_fs_release_lock(struct afs_fs_cursor *);
extern int afs_fs_give_up_all_callbacks(struct afs_net *, struct afs_server *, extern int afs_fs_give_up_all_callbacks(struct afs_net *, struct afs_server *,
struct afs_addr_cursor *, struct key *); struct afs_addr_cursor *, struct key *);
extern int afs_fs_get_capabilities(struct afs_net *, struct afs_server *, extern int afs_fs_get_capabilities(struct afs_net *, struct afs_server *,
struct afs_addr_cursor *, struct key *); struct afs_addr_cursor *, struct key *, unsigned int, bool);
extern int afs_fs_inline_bulk_status(struct afs_fs_cursor *, struct afs_net *, extern int afs_fs_inline_bulk_status(struct afs_fs_cursor *, struct afs_net *,
struct afs_fid *, struct afs_file_status *, struct afs_fid *, struct afs_file_status *,
struct afs_callback *, unsigned int, struct afs_callback *, unsigned int,
...@@ -897,6 +944,13 @@ extern int afs_fs_fetch_status(struct afs_fs_cursor *, struct afs_net *, ...@@ -897,6 +944,13 @@ extern int afs_fs_fetch_status(struct afs_fs_cursor *, struct afs_net *,
struct afs_fid *, struct afs_file_status *, struct afs_fid *, struct afs_file_status *,
struct afs_callback *, struct afs_volsync *); struct afs_callback *, struct afs_volsync *);
/*
* fs_probe.c
*/
extern void afs_fileserver_probe_result(struct afs_call *);
extern int afs_probe_fileservers(struct afs_net *, struct key *, struct afs_server_list *);
extern int afs_wait_for_fs_probes(struct afs_server_list *, unsigned long);
/* /*
* inode.c * inode.c
*/ */
...@@ -1013,7 +1067,6 @@ extern int __net_init afs_open_socket(struct afs_net *); ...@@ -1013,7 +1067,6 @@ extern int __net_init afs_open_socket(struct afs_net *);
extern void __net_exit afs_close_socket(struct afs_net *); extern void __net_exit afs_close_socket(struct afs_net *);
extern void afs_charge_preallocation(struct work_struct *); extern void afs_charge_preallocation(struct work_struct *);
extern void afs_put_call(struct afs_call *); extern void afs_put_call(struct afs_call *);
extern int afs_queue_call_work(struct afs_call *);
extern long afs_make_call(struct afs_addr_cursor *, struct afs_call *, gfp_t, bool); extern long afs_make_call(struct afs_addr_cursor *, struct afs_call *, gfp_t, bool);
extern struct afs_call *afs_alloc_flat_call(struct afs_net *, extern struct afs_call *afs_alloc_flat_call(struct afs_net *,
const struct afs_call_type *, const struct afs_call_type *,
...@@ -1130,7 +1183,6 @@ extern void afs_put_server(struct afs_net *, struct afs_server *); ...@@ -1130,7 +1183,6 @@ extern void afs_put_server(struct afs_net *, struct afs_server *);
extern void afs_manage_servers(struct work_struct *); extern void afs_manage_servers(struct work_struct *);
extern void afs_servers_timer(struct timer_list *); extern void afs_servers_timer(struct timer_list *);
extern void __net_exit afs_purge_servers(struct afs_net *); extern void __net_exit afs_purge_servers(struct afs_net *);
extern bool afs_probe_fileserver(struct afs_fs_cursor *);
extern bool afs_check_server_record(struct afs_fs_cursor *, struct afs_server *); extern bool afs_check_server_record(struct afs_fs_cursor *, struct afs_server *);
/* /*
...@@ -1160,9 +1212,17 @@ extern void afs_fs_exit(void); ...@@ -1160,9 +1212,17 @@ extern void afs_fs_exit(void);
extern struct afs_vldb_entry *afs_vl_get_entry_by_name_u(struct afs_vl_cursor *, extern struct afs_vldb_entry *afs_vl_get_entry_by_name_u(struct afs_vl_cursor *,
const char *, int); const char *, int);
extern struct afs_addr_list *afs_vl_get_addrs_u(struct afs_vl_cursor *, const uuid_t *); extern struct afs_addr_list *afs_vl_get_addrs_u(struct afs_vl_cursor *, const uuid_t *);
extern int afs_vl_get_capabilities(struct afs_net *, struct afs_addr_cursor *, struct key *); extern int afs_vl_get_capabilities(struct afs_net *, struct afs_addr_cursor *, struct key *,
struct afs_vlserver *, unsigned int, bool);
extern struct afs_addr_list *afs_yfsvl_get_endpoints(struct afs_vl_cursor *, const uuid_t *); extern struct afs_addr_list *afs_yfsvl_get_endpoints(struct afs_vl_cursor *, const uuid_t *);
/*
* vl_probe.c
*/
extern void afs_vlserver_probe_result(struct afs_call *);
extern int afs_send_vl_probes(struct afs_net *, struct key *, struct afs_vlserver_list *);
extern int afs_wait_for_vl_probes(struct afs_vlserver_list *, unsigned long);
/* /*
* vl_rotate.c * vl_rotate.c
*/ */
......
...@@ -312,7 +312,7 @@ static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v) ...@@ -312,7 +312,7 @@ static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v)
if (alist) { if (alist) {
for (i = 0; i < alist->nr_addrs; i++) for (i = 0; i < alist->nr_addrs; i++)
seq_printf(m, " %c %pISpc\n", seq_printf(m, " %c %pISpc\n",
alist->index == i ? '>' : '-', alist->preferred == i ? '>' : '-',
&alist->addrs[i].transport); &alist->addrs[i].transport);
} }
return 0; return 0;
...@@ -391,11 +391,11 @@ static int afs_proc_servers_show(struct seq_file *m, void *v) ...@@ -391,11 +391,11 @@ static int afs_proc_servers_show(struct seq_file *m, void *v)
&server->uuid, &server->uuid,
atomic_read(&server->usage), atomic_read(&server->usage),
&alist->addrs[0].transport, &alist->addrs[0].transport,
alist->index == 0 ? "*" : ""); alist->preferred == 0 ? "*" : "");
for (i = 1; i < alist->nr_addrs; i++) for (i = 1; i < alist->nr_addrs; i++)
seq_printf(m, " %pISpc%s\n", seq_printf(m, " %pISpc%s\n",
&alist->addrs[i].transport, &alist->addrs[i].transport,
alist->index == i ? "*" : ""); alist->preferred == i ? "*" : "");
return 0; return 0;
} }
......
...@@ -18,14 +18,6 @@ ...@@ -18,14 +18,6 @@
#include "internal.h" #include "internal.h"
#include "afs_fs.h" #include "afs_fs.h"
/*
* Initialise a filesystem server cursor for iterating over FS servers.
*/
static void afs_init_fs_cursor(struct afs_fs_cursor *fc, struct afs_vnode *vnode)
{
memset(fc, 0, sizeof(*fc));
}
/* /*
* Begin an operation on the fileserver. * Begin an operation on the fileserver.
* *
...@@ -35,7 +27,7 @@ static void afs_init_fs_cursor(struct afs_fs_cursor *fc, struct afs_vnode *vnode ...@@ -35,7 +27,7 @@ static void afs_init_fs_cursor(struct afs_fs_cursor *fc, struct afs_vnode *vnode
bool afs_begin_vnode_operation(struct afs_fs_cursor *fc, struct afs_vnode *vnode, bool afs_begin_vnode_operation(struct afs_fs_cursor *fc, struct afs_vnode *vnode,
struct key *key) struct key *key)
{ {
afs_init_fs_cursor(fc, vnode); memset(fc, 0, sizeof(*fc));
fc->vnode = vnode; fc->vnode = vnode;
fc->key = key; fc->key = key;
fc->ac.error = SHRT_MAX; fc->ac.error = SHRT_MAX;
...@@ -66,12 +58,15 @@ static bool afs_start_fs_iteration(struct afs_fs_cursor *fc, ...@@ -66,12 +58,15 @@ static bool afs_start_fs_iteration(struct afs_fs_cursor *fc,
fc->server_list = afs_get_serverlist(vnode->volume->servers); fc->server_list = afs_get_serverlist(vnode->volume->servers);
read_unlock(&vnode->volume->servers_lock); read_unlock(&vnode->volume->servers_lock);
fc->untried = (1UL << fc->server_list->nr_servers) - 1;
fc->index = READ_ONCE(fc->server_list->preferred);
cbi = vnode->cb_interest; cbi = vnode->cb_interest;
if (cbi) { if (cbi) {
/* See if the vnode's preferred record is still available */ /* See if the vnode's preferred record is still available */
for (i = 0; i < fc->server_list->nr_servers; i++) { for (i = 0; i < fc->server_list->nr_servers; i++) {
if (fc->server_list->servers[i].cb_interest == cbi) { if (fc->server_list->servers[i].cb_interest == cbi) {
fc->start = i; fc->index = i;
goto found_interest; goto found_interest;
} }
} }
...@@ -95,12 +90,9 @@ static bool afs_start_fs_iteration(struct afs_fs_cursor *fc, ...@@ -95,12 +90,9 @@ static bool afs_start_fs_iteration(struct afs_fs_cursor *fc,
afs_put_cb_interest(afs_v2net(vnode), cbi); afs_put_cb_interest(afs_v2net(vnode), cbi);
cbi = NULL; cbi = NULL;
} else {
fc->start = READ_ONCE(fc->server_list->index);
} }
found_interest: found_interest:
fc->index = fc->start;
return true; return true;
} }
...@@ -144,11 +136,12 @@ bool afs_select_fileserver(struct afs_fs_cursor *fc) ...@@ -144,11 +136,12 @@ bool afs_select_fileserver(struct afs_fs_cursor *fc)
struct afs_addr_list *alist; struct afs_addr_list *alist;
struct afs_server *server; struct afs_server *server;
struct afs_vnode *vnode = fc->vnode; struct afs_vnode *vnode = fc->vnode;
int error = fc->ac.error; u32 rtt, abort_code;
int error = fc->ac.error, i;
_enter("%u/%u,%u/%u,%d,%d", _enter("%lx[%d],%lx[%d],%d,%d",
fc->index, fc->start, fc->untried, fc->index,
fc->ac.index, fc->ac.start, fc->ac.tried, fc->ac.index,
error, fc->ac.abort_code); error, fc->ac.abort_code);
if (fc->flags & AFS_FS_CURSOR_STOP) { if (fc->flags & AFS_FS_CURSOR_STOP) {
...@@ -345,8 +338,50 @@ bool afs_select_fileserver(struct afs_fs_cursor *fc) ...@@ -345,8 +338,50 @@ bool afs_select_fileserver(struct afs_fs_cursor *fc)
if (!afs_start_fs_iteration(fc, vnode)) if (!afs_start_fs_iteration(fc, vnode))
goto failed; goto failed;
use_server: _debug("__ VOL %llx __", vnode->volume->vid);
_debug("use"); error = afs_probe_fileservers(afs_v2net(vnode), fc->key, fc->server_list);
if (error < 0)
goto failed_set_error;
pick_server:
_debug("pick [%lx]", fc->untried);
error = afs_wait_for_fs_probes(fc->server_list, fc->untried);
if (error < 0)
goto failed_set_error;
/* Pick the untried server with the lowest RTT. If we have outstanding
* callbacks, we stick with the server we're already using if we can.
*/
if (fc->cbi) {
_debug("cbi %u", fc->index);
if (test_bit(fc->index, &fc->untried))
goto selected_server;
afs_put_cb_interest(afs_v2net(vnode), fc->cbi);
fc->cbi = NULL;
_debug("nocbi");
}
fc->index = -1;
rtt = U32_MAX;
for (i = 0; i < fc->server_list->nr_servers; i++) {
struct afs_server *s = fc->server_list->servers[i].server;
if (!test_bit(i, &fc->untried) || !s->probe.responded)
continue;
if (s->probe.rtt < rtt) {
fc->index = i;
rtt = s->probe.rtt;
}
}
if (fc->index == -1)
goto no_more_servers;
selected_server:
_debug("use %d", fc->index);
__clear_bit(fc->index, &fc->untried);
/* We're starting on a different fileserver from the list. We need to /* We're starting on a different fileserver from the list. We need to
* check it, create a callback intercept, find its address list and * check it, create a callback intercept, find its address list and
* probe its capabilities before we use it. * probe its capabilities before we use it.
...@@ -379,60 +414,81 @@ bool afs_select_fileserver(struct afs_fs_cursor *fc) ...@@ -379,60 +414,81 @@ bool afs_select_fileserver(struct afs_fs_cursor *fc)
memset(&fc->ac, 0, sizeof(fc->ac)); memset(&fc->ac, 0, sizeof(fc->ac));
/* Probe the current fileserver if we haven't done so yet. */
if (!test_bit(AFS_SERVER_FL_PROBED, &server->flags)) {
fc->ac.alist = afs_get_addrlist(alist);
if (!afs_probe_fileserver(fc)) {
switch (fc->ac.error) {
case -ENOMEM:
case -ERESTARTSYS:
case -EINTR:
goto failed;
default:
goto next_server;
}
}
}
if (!fc->ac.alist) if (!fc->ac.alist)
fc->ac.alist = alist; fc->ac.alist = alist;
else else
afs_put_addrlist(alist); afs_put_addrlist(alist);
fc->ac.start = READ_ONCE(alist->index); fc->ac.index = -1;
fc->ac.index = fc->ac.start;
iterate_address: iterate_address:
ASSERT(fc->ac.alist); ASSERT(fc->ac.alist);
_debug("iterate %d/%d", fc->ac.index, fc->ac.alist->nr_addrs);
/* Iterate over the current server's address list to try and find an /* Iterate over the current server's address list to try and find an
* address on which it will respond to us. * address on which it will respond to us.
*/ */
if (!afs_iterate_addresses(&fc->ac)) if (!afs_iterate_addresses(&fc->ac))
goto next_server; goto next_server;
_debug("address [%u] %u/%u", fc->index, fc->ac.index, fc->ac.alist->nr_addrs);
_leave(" = t"); _leave(" = t");
return true; return true;
next_server: next_server:
_debug("next"); _debug("next");
afs_end_cursor(&fc->ac); afs_end_cursor(&fc->ac);
afs_put_cb_interest(afs_v2net(vnode), fc->cbi); goto pick_server;
fc->cbi = NULL;
fc->index++;
if (fc->index >= fc->server_list->nr_servers)
fc->index = 0;
if (fc->index != fc->start)
goto use_server;
no_more_servers:
/* That's all the servers poked to no good effect. Try again if some /* That's all the servers poked to no good effect. Try again if some
* of them were busy. * of them were busy.
*/ */
if (fc->flags & AFS_FS_CURSOR_VBUSY) if (fc->flags & AFS_FS_CURSOR_VBUSY)
goto restart_from_beginning; goto restart_from_beginning;
goto failed; abort_code = 0;
error = -EDESTADDRREQ;
for (i = 0; i < fc->server_list->nr_servers; i++) {
struct afs_server *s = fc->server_list->servers[i].server;
int probe_error = READ_ONCE(s->probe.error);
switch (probe_error) {
case 0:
continue;
default:
if (error == -ETIMEDOUT ||
error == -ETIME)
continue;
case -ETIMEDOUT:
case -ETIME:
if (error == -ENOMEM ||
error == -ENONET)
continue;
case -ENOMEM:
case -ENONET:
if (error == -ENETUNREACH)
continue;
case -ENETUNREACH:
if (error == -EHOSTUNREACH)
continue;
case -EHOSTUNREACH:
if (error == -ECONNREFUSED)
continue;
case -ECONNREFUSED:
if (error == -ECONNRESET)
continue;
case -ECONNRESET: /* Responded, but call expired. */
if (error == -ECONNABORTED)
continue;
case -ECONNABORTED:
abort_code = s->probe.abort_code;
error = probe_error;
continue;
}
}
if (error == -ECONNABORTED)
error = afs_abort_to_error(abort_code);
failed_set_error: failed_set_error:
fc->error = error; fc->error = error;
...@@ -480,8 +536,7 @@ bool afs_select_current_fileserver(struct afs_fs_cursor *fc) ...@@ -480,8 +536,7 @@ bool afs_select_current_fileserver(struct afs_fs_cursor *fc)
memset(&fc->ac, 0, sizeof(fc->ac)); memset(&fc->ac, 0, sizeof(fc->ac));
fc->ac.alist = alist; fc->ac.alist = alist;
fc->ac.start = READ_ONCE(alist->index); fc->ac.index = -1;
fc->ac.index = fc->ac.start;
goto iterate_address; goto iterate_address;
case 0: case 0:
...@@ -538,13 +593,13 @@ static void afs_dump_edestaddrreq(const struct afs_fs_cursor *fc) ...@@ -538,13 +593,13 @@ static void afs_dump_edestaddrreq(const struct afs_fs_cursor *fc)
pr_notice("EDESTADDR occurred\n"); pr_notice("EDESTADDR occurred\n");
pr_notice("FC: cbb=%x cbb2=%x fl=%hx err=%hd\n", pr_notice("FC: cbb=%x cbb2=%x fl=%hx err=%hd\n",
fc->cb_break, fc->cb_break_2, fc->flags, fc->error); fc->cb_break, fc->cb_break_2, fc->flags, fc->error);
pr_notice("FC: st=%u ix=%u ni=%u\n", pr_notice("FC: ut=%lx ix=%d ni=%u\n",
fc->start, fc->index, fc->nr_iterations); fc->untried, fc->index, fc->nr_iterations);
if (fc->server_list) { if (fc->server_list) {
const struct afs_server_list *sl = fc->server_list; const struct afs_server_list *sl = fc->server_list;
pr_notice("FC: SL nr=%u ix=%u vnov=%hx\n", pr_notice("FC: SL nr=%u pr=%u vnov=%hx\n",
sl->nr_servers, sl->index, sl->vnovol_mask); sl->nr_servers, sl->preferred, sl->vnovol_mask);
for (i = 0; i < sl->nr_servers; i++) { for (i = 0; i < sl->nr_servers; i++) {
const struct afs_server *s = sl->servers[i].server; const struct afs_server *s = sl->servers[i].server;
pr_notice("FC: server fl=%lx av=%u %pU\n", pr_notice("FC: server fl=%lx av=%u %pU\n",
...@@ -552,22 +607,21 @@ static void afs_dump_edestaddrreq(const struct afs_fs_cursor *fc) ...@@ -552,22 +607,21 @@ static void afs_dump_edestaddrreq(const struct afs_fs_cursor *fc)
if (s->addresses) { if (s->addresses) {
const struct afs_addr_list *a = const struct afs_addr_list *a =
rcu_dereference(s->addresses); rcu_dereference(s->addresses);
pr_notice("FC: - av=%u nr=%u/%u/%u ax=%u\n", pr_notice("FC: - av=%u nr=%u/%u/%u pr=%u\n",
a->version, a->version,
a->nr_ipv4, a->nr_addrs, a->max_addrs, a->nr_ipv4, a->nr_addrs, a->max_addrs,
a->index); a->preferred);
pr_notice("FC: - pr=%lx yf=%lx\n", pr_notice("FC: - pr=%lx R=%lx F=%lx\n",
a->probed, a->yfs); a->probed, a->responded, a->failed);
if (a == fc->ac.alist) if (a == fc->ac.alist)
pr_notice("FC: - current\n"); pr_notice("FC: - current\n");
} }
} }
} }
pr_notice("AC: as=%u ax=%u ac=%d er=%d b=%u r=%u ni=%u\n", pr_notice("AC: t=%lx ax=%u ac=%d er=%d r=%u ni=%u\n",
fc->ac.start, fc->ac.index, fc->ac.abort_code, fc->ac.error, fc->ac.tried, fc->ac.index, fc->ac.abort_code, fc->ac.error,
fc->ac.begun, fc->ac.responded, fc->ac.nr_iterations); fc->ac.responded, fc->ac.nr_iterations);
rcu_read_unlock(); rcu_read_unlock();
} }
......
...@@ -43,7 +43,6 @@ int afs_open_socket(struct afs_net *net) ...@@ -43,7 +43,6 @@ int afs_open_socket(struct afs_net *net)
struct sockaddr_rxrpc srx; struct sockaddr_rxrpc srx;
struct socket *socket; struct socket *socket;
unsigned int min_level; unsigned int min_level;
u16 service_upgrade[2];
int ret; int ret;
_enter(""); _enter("");
...@@ -82,13 +81,12 @@ int afs_open_socket(struct afs_net *net) ...@@ -82,13 +81,12 @@ int afs_open_socket(struct afs_net *net)
if (ret < 0) if (ret < 0)
goto error_2; goto error_2;
service_upgrade[0] = CM_SERVICE; /* Ideally, we'd turn on service upgrade here, but we can't because
service_upgrade[1] = YFS_CM_SERVICE; * OpenAFS is buggy and leaks the userStatus field from packet to
ret = kernel_setsockopt(socket, SOL_RXRPC, RXRPC_UPGRADEABLE_SERVICE, * packet and between FS packets and CB packets - so if we try to do an
(void *)service_upgrade, sizeof(service_upgrade)); * upgrade on an FS packet, OpenAFS will leak that into the CB packet
if (ret < 0) * it sends back to us.
goto error_2; */
rxrpc_kernel_new_call_notification(socket, afs_rx_new_call, rxrpc_kernel_new_call_notification(socket, afs_rx_new_call,
afs_rx_discard_new_call); afs_rx_discard_new_call);
...@@ -192,6 +190,7 @@ void afs_put_call(struct afs_call *call) ...@@ -192,6 +190,7 @@ void afs_put_call(struct afs_call *call)
afs_put_server(call->net, call->cm_server); afs_put_server(call->net, call->cm_server);
afs_put_cb_interest(call->net, call->cbi); afs_put_cb_interest(call->net, call->cbi);
afs_put_addrlist(call->alist);
kfree(call->request); kfree(call->request);
trace_afs_call(call, afs_call_trace_free, 0, o, trace_afs_call(call, afs_call_trace_free, 0, o,
...@@ -205,21 +204,22 @@ void afs_put_call(struct afs_call *call) ...@@ -205,21 +204,22 @@ void afs_put_call(struct afs_call *call)
} }
/* /*
* Queue the call for actual work. Returns 0 unconditionally for convenience. * Queue the call for actual work.
*/ */
int afs_queue_call_work(struct afs_call *call) static void afs_queue_call_work(struct afs_call *call)
{ {
int u = atomic_inc_return(&call->usage); if (call->type->work) {
int u = atomic_inc_return(&call->usage);
trace_afs_call(call, afs_call_trace_work, u, trace_afs_call(call, afs_call_trace_work, u,
atomic_read(&call->net->nr_outstanding_calls), atomic_read(&call->net->nr_outstanding_calls),
__builtin_return_address(0)); __builtin_return_address(0));
INIT_WORK(&call->work, call->type->work); INIT_WORK(&call->work, call->type->work);
if (!queue_work(afs_wq, &call->work)) if (!queue_work(afs_wq, &call->work))
afs_put_call(call); afs_put_call(call);
return 0; }
} }
/* /*
...@@ -376,6 +376,8 @@ long afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call, ...@@ -376,6 +376,8 @@ long afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call,
atomic_read(&call->net->nr_outstanding_calls)); atomic_read(&call->net->nr_outstanding_calls));
call->async = async; call->async = async;
call->addr_ix = ac->index;
call->alist = afs_get_addrlist(ac->alist);
/* Work out the length we're going to transmit. This is awkward for /* Work out the length we're going to transmit. This is awkward for
* calls such as FS.StoreData where there's an extra injection of data * calls such as FS.StoreData where there's an extra injection of data
...@@ -407,6 +409,7 @@ long afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call, ...@@ -407,6 +409,7 @@ long afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call,
call->debug_id); call->debug_id);
if (IS_ERR(rxcall)) { if (IS_ERR(rxcall)) {
ret = PTR_ERR(rxcall); ret = PTR_ERR(rxcall);
call->error = ret;
goto error_kill_call; goto error_kill_call;
} }
...@@ -458,6 +461,8 @@ long afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call, ...@@ -458,6 +461,8 @@ long afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call,
call->error = ret; call->error = ret;
trace_afs_call_done(call); trace_afs_call_done(call);
error_kill_call: error_kill_call:
if (call->type->done)
call->type->done(call);
afs_put_call(call); afs_put_call(call);
ac->error = ret; ac->error = ret;
_leave(" = %d", ret); _leave(" = %d", ret);
...@@ -509,6 +514,7 @@ static void afs_deliver_to_call(struct afs_call *call) ...@@ -509,6 +514,7 @@ static void afs_deliver_to_call(struct afs_call *call)
state = READ_ONCE(call->state); state = READ_ONCE(call->state);
switch (ret) { switch (ret) {
case 0: case 0:
afs_queue_call_work(call);
if (state == AFS_CALL_CL_PROC_REPLY) { if (state == AFS_CALL_CL_PROC_REPLY) {
if (call->cbi) if (call->cbi)
set_bit(AFS_SERVER_FL_MAY_HAVE_CB, set_bit(AFS_SERVER_FL_MAY_HAVE_CB,
...@@ -546,6 +552,8 @@ static void afs_deliver_to_call(struct afs_call *call) ...@@ -546,6 +552,8 @@ static void afs_deliver_to_call(struct afs_call *call)
} }
done: done:
if (call->type->done)
call->type->done(call);
if (state == AFS_CALL_COMPLETE && call->incoming) if (state == AFS_CALL_COMPLETE && call->incoming)
afs_put_call(call); afs_put_call(call);
out: out:
......
...@@ -231,6 +231,8 @@ static struct afs_server *afs_alloc_server(struct afs_net *net, ...@@ -231,6 +231,8 @@ static struct afs_server *afs_alloc_server(struct afs_net *net,
rwlock_init(&server->fs_lock); rwlock_init(&server->fs_lock);
INIT_HLIST_HEAD(&server->cb_volumes); INIT_HLIST_HEAD(&server->cb_volumes);
rwlock_init(&server->cb_break_lock); rwlock_init(&server->cb_break_lock);
init_waitqueue_head(&server->probe_wq);
spin_lock_init(&server->probe_lock);
afs_inc_servers_outstanding(net); afs_inc_servers_outstanding(net);
_leave(" = %p", server); _leave(" = %p", server);
...@@ -254,7 +256,7 @@ static struct afs_addr_list *afs_vl_lookup_addrs(struct afs_cell *cell, ...@@ -254,7 +256,7 @@ static struct afs_addr_list *afs_vl_lookup_addrs(struct afs_cell *cell,
ret = -ERESTARTSYS; ret = -ERESTARTSYS;
if (afs_begin_vlserver_operation(&vc, cell, key)) { if (afs_begin_vlserver_operation(&vc, cell, key)) {
while (afs_select_vlserver(&vc)) { while (afs_select_vlserver(&vc)) {
if (test_bit(vc.ac.index, &vc.ac.alist->yfs)) if (test_bit(AFS_VLSERVER_FL_IS_YFS, &vc.server->flags))
alist = afs_yfsvl_get_endpoints(&vc, uuid); alist = afs_yfsvl_get_endpoints(&vc, uuid);
else else
alist = afs_vl_get_addrs_u(&vc, uuid); alist = afs_vl_get_addrs_u(&vc, uuid);
...@@ -365,8 +367,7 @@ static void afs_destroy_server(struct afs_net *net, struct afs_server *server) ...@@ -365,8 +367,7 @@ static void afs_destroy_server(struct afs_net *net, struct afs_server *server)
struct afs_addr_list *alist = rcu_access_pointer(server->addresses); struct afs_addr_list *alist = rcu_access_pointer(server->addresses);
struct afs_addr_cursor ac = { struct afs_addr_cursor ac = {
.alist = alist, .alist = alist,
.start = alist->index, .index = alist->preferred,
.index = 0,
.error = 0, .error = 0,
}; };
_enter("%p", server); _enter("%p", server);
...@@ -374,6 +375,9 @@ static void afs_destroy_server(struct afs_net *net, struct afs_server *server) ...@@ -374,6 +375,9 @@ static void afs_destroy_server(struct afs_net *net, struct afs_server *server)
if (test_bit(AFS_SERVER_FL_MAY_HAVE_CB, &server->flags)) if (test_bit(AFS_SERVER_FL_MAY_HAVE_CB, &server->flags))
afs_fs_give_up_all_callbacks(net, server, &ac, NULL); afs_fs_give_up_all_callbacks(net, server, &ac, NULL);
wait_var_event(&server->probe_outstanding,
atomic_read(&server->probe_outstanding) == 0);
call_rcu(&server->rcu, afs_server_rcu); call_rcu(&server->rcu, afs_server_rcu);
afs_dec_servers_outstanding(net); afs_dec_servers_outstanding(net);
} }
...@@ -506,105 +510,6 @@ void afs_purge_servers(struct afs_net *net) ...@@ -506,105 +510,6 @@ void afs_purge_servers(struct afs_net *net)
_leave(""); _leave("");
} }
/*
* Probe a fileserver to find its capabilities.
*
* TODO: Try service upgrade.
*/
static bool afs_do_probe_fileserver(struct afs_fs_cursor *fc)
{
int i;
_enter("");
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:
if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags)) {
for (i = 0; i < fc->ac.alist->nr_addrs; i++)
fc->ac.alist->addrs[i].srx_service =
YFS_FS_SERVICE;
}
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 = afs_io_error(NULL, afs_io_error_fs_probe_fail);
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. * Get an update for a server's address list.
*/ */
......
...@@ -118,11 +118,11 @@ bool afs_annotate_server_list(struct afs_server_list *new, ...@@ -118,11 +118,11 @@ bool afs_annotate_server_list(struct afs_server_list *new,
return false; return false;
changed: changed:
/* Maintain the same current server as before if possible. */ /* Maintain the same preferred server as before if possible. */
cur = old->servers[old->index].server; cur = old->servers[old->preferred].server;
for (j = 0; j < new->nr_servers; j++) { for (j = 0; j < new->nr_servers; j++) {
if (new->servers[j].server == cur) { if (new->servers[j].server == cur) {
new->index = j; new->preferred = j;
break; break;
} }
} }
......
...@@ -23,6 +23,8 @@ struct afs_vlserver *afs_alloc_vlserver(const char *name, size_t name_len, ...@@ -23,6 +23,8 @@ struct afs_vlserver *afs_alloc_vlserver(const char *name, size_t name_len,
if (vlserver) { if (vlserver) {
atomic_set(&vlserver->usage, 1); atomic_set(&vlserver->usage, 1);
rwlock_init(&vlserver->lock); rwlock_init(&vlserver->lock);
init_waitqueue_head(&vlserver->probe_wq);
spin_lock_init(&vlserver->probe_lock);
vlserver->name_len = name_len; vlserver->name_len = name_len;
vlserver->port = port; vlserver->port = port;
memcpy(vlserver->name, name, name_len); memcpy(vlserver->name, name, name_len);
...@@ -141,7 +143,7 @@ static struct afs_addr_list *afs_extract_vl_addrs(const u8 **_b, const u8 *end, ...@@ -141,7 +143,7 @@ static struct afs_addr_list *afs_extract_vl_addrs(const u8 **_b, const u8 *end,
/* Start with IPv6 if available. */ /* Start with IPv6 if available. */
if (alist->nr_ipv4 < alist->nr_addrs) if (alist->nr_ipv4 < alist->nr_addrs)
alist->index = alist->nr_ipv4; alist->preferred = alist->nr_ipv4;
*_b = b; *_b = b;
return alist; return alist;
...@@ -307,6 +309,8 @@ struct afs_vlserver_list *afs_extract_vlserver_list(struct afs_cell *cell, ...@@ -307,6 +309,8 @@ struct afs_vlserver_list *afs_extract_vlserver_list(struct afs_cell *cell,
(vllist->nr_servers - j) * sizeof(struct afs_vlserver_entry)); (vllist->nr_servers - j) * sizeof(struct afs_vlserver_entry));
} }
clear_bit(AFS_VLSERVER_FL_PROBED, &server->flags);
vllist->servers[j].priority = bs.priority; vllist->servers[j].priority = bs.priority;
vllist->servers[j].weight = bs.weight; vllist->servers[j].weight = bs.weight;
vllist->servers[j].server = server; vllist->servers[j].server = server;
......
/* AFS vlserver probing
*
* 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/sched.h>
#include <linux/slab.h>
#include "afs_fs.h"
#include "internal.h"
#include "protocol_yfs.h"
static bool afs_vl_probe_done(struct afs_vlserver *server)
{
if (!atomic_dec_and_test(&server->probe_outstanding))
return false;
wake_up_var(&server->probe_outstanding);
clear_bit_unlock(AFS_VLSERVER_FL_PROBING, &server->flags);
wake_up_bit(&server->flags, AFS_VLSERVER_FL_PROBING);
return true;
}
/*
* Process the result of probing a vlserver. This is called after successful
* or failed delivery of an VL.GetCapabilities operation.
*/
void afs_vlserver_probe_result(struct afs_call *call)
{
struct afs_addr_list *alist = call->alist;
struct afs_vlserver *server = call->reply[0];
unsigned int server_index = (long)call->reply[1];
unsigned int index = call->addr_ix;
unsigned int rtt = UINT_MAX;
bool have_result = false;
u64 _rtt;
int ret = call->error;
_enter("%s,%u,%u,%d,%d", server->name, server_index, index, ret, call->abort_code);
spin_lock(&server->probe_lock);
switch (ret) {
case 0:
server->probe.error = 0;
goto responded;
case -ECONNABORTED:
if (!server->probe.responded) {
server->probe.abort_code = call->abort_code;
server->probe.error = ret;
}
goto responded;
case -ENOMEM:
case -ENONET:
server->probe.local_failure = true;
afs_io_error(call, afs_io_error_vl_probe_fail);
goto out;
case -ECONNRESET: /* Responded, but call expired. */
case -ENETUNREACH:
case -EHOSTUNREACH:
case -ECONNREFUSED:
case -ETIMEDOUT:
case -ETIME:
default:
clear_bit(index, &alist->responded);
set_bit(index, &alist->failed);
if (!server->probe.responded &&
(server->probe.error == 0 ||
server->probe.error == -ETIMEDOUT ||
server->probe.error == -ETIME))
server->probe.error = ret;
afs_io_error(call, afs_io_error_vl_probe_fail);
goto out;
}
responded:
set_bit(index, &alist->responded);
clear_bit(index, &alist->failed);
if (call->service_id == YFS_VL_SERVICE) {
server->probe.is_yfs = true;
set_bit(AFS_VLSERVER_FL_IS_YFS, &server->flags);
alist->addrs[index].srx_service = call->service_id;
} else {
server->probe.not_yfs = true;
if (!server->probe.is_yfs) {
clear_bit(AFS_VLSERVER_FL_IS_YFS, &server->flags);
alist->addrs[index].srx_service = call->service_id;
}
}
/* Get the RTT and scale it to fit into a 32-bit value that represents
* over a minute of time so that we can access it with one instruction
* on a 32-bit system.
*/
_rtt = rxrpc_kernel_get_rtt(call->net->socket, call->rxcall);
_rtt /= 64;
rtt = (_rtt > UINT_MAX) ? UINT_MAX : _rtt;
if (rtt < server->probe.rtt) {
server->probe.rtt = rtt;
alist->preferred = index;
have_result = true;
}
smp_wmb(); /* Set rtt before responded. */
server->probe.responded = true;
set_bit(AFS_VLSERVER_FL_PROBED, &server->flags);
out:
spin_unlock(&server->probe_lock);
_debug("probe [%u][%u] %pISpc rtt=%u ret=%d",
server_index, index, &alist->addrs[index].transport,
(unsigned int)rtt, ret);
have_result |= afs_vl_probe_done(server);
if (have_result) {
server->probe.have_result = true;
wake_up_var(&server->probe.have_result);
wake_up_all(&server->probe_wq);
}
}
/*
* Probe all of a vlserver's addresses to find out the best route and to
* query its capabilities.
*/
static int afs_do_probe_vlserver(struct afs_net *net,
struct afs_vlserver *server,
struct key *key,
unsigned int server_index)
{
struct afs_addr_cursor ac = {
.index = 0,
};
int ret;
_enter("%s", server->name);
read_lock(&server->lock);
ac.alist = rcu_dereference_protected(server->addresses,
lockdep_is_held(&server->lock));
read_unlock(&server->lock);
atomic_set(&server->probe_outstanding, ac.alist->nr_addrs);
memset(&server->probe, 0, sizeof(server->probe));
server->probe.rtt = UINT_MAX;
for (ac.index = 0; ac.index < ac.alist->nr_addrs; ac.index++) {
ret = afs_vl_get_capabilities(net, &ac, key, server,
server_index, true);
if (ret != -EINPROGRESS) {
afs_vl_probe_done(server);
return ret;
}
}
return 0;
}
/*
* Send off probes to all unprobed servers.
*/
int afs_send_vl_probes(struct afs_net *net, struct key *key,
struct afs_vlserver_list *vllist)
{
struct afs_vlserver *server;
int i, ret;
for (i = 0; i < vllist->nr_servers; i++) {
server = vllist->servers[i].server;
if (test_bit(AFS_VLSERVER_FL_PROBED, &server->flags))
continue;
if (!test_and_set_bit_lock(AFS_VLSERVER_FL_PROBING, &server->flags)) {
ret = afs_do_probe_vlserver(net, server, key, i);
if (ret)
return ret;
}
}
return 0;
}
/*
* Wait for the first as-yet untried server to respond.
*/
int afs_wait_for_vl_probes(struct afs_vlserver_list *vllist,
unsigned long untried)
{
struct wait_queue_entry *waits;
struct afs_vlserver *server;
unsigned int rtt = UINT_MAX;
bool have_responders = false;
int pref = -1, i;
_enter("%u,%lx", vllist->nr_servers, untried);
/* Only wait for servers that have a probe outstanding. */
for (i = 0; i < vllist->nr_servers; i++) {
if (test_bit(i, &untried)) {
server = vllist->servers[i].server;
if (!test_bit(AFS_VLSERVER_FL_PROBING, &server->flags))
__clear_bit(i, &untried);
if (server->probe.responded)
have_responders = true;
}
}
if (have_responders || !untried)
return 0;
waits = kmalloc(array_size(vllist->nr_servers, sizeof(*waits)), GFP_KERNEL);
if (!waits)
return -ENOMEM;
for (i = 0; i < vllist->nr_servers; i++) {
if (test_bit(i, &untried)) {
server = vllist->servers[i].server;
init_waitqueue_entry(&waits[i], current);
add_wait_queue(&server->probe_wq, &waits[i]);
}
}
for (;;) {
bool still_probing = false;
set_current_state(TASK_INTERRUPTIBLE);
for (i = 0; i < vllist->nr_servers; i++) {
if (test_bit(i, &untried)) {
server = vllist->servers[i].server;
if (server->probe.responded)
goto stop;
if (test_bit(AFS_VLSERVER_FL_PROBING, &server->flags))
still_probing = true;
}
}
if (!still_probing || unlikely(signal_pending(current)))
goto stop;
schedule();
}
stop:
set_current_state(TASK_RUNNING);
for (i = 0; i < vllist->nr_servers; i++) {
if (test_bit(i, &untried)) {
server = vllist->servers[i].server;
if (server->probe.responded &&
server->probe.rtt < rtt) {
pref = i;
rtt = server->probe.rtt;
}
remove_wait_queue(&server->probe_wq, &waits[i]);
}
}
kfree(waits);
if (pref == -1 && signal_pending(current))
return -ERESTARTSYS;
if (pref >= 0)
vllist->preferred = pref;
_leave(" = 0 [%u]", pref);
return 0;
}
...@@ -58,8 +58,8 @@ static bool afs_start_vl_iteration(struct afs_vl_cursor *vc) ...@@ -58,8 +58,8 @@ static bool afs_start_vl_iteration(struct afs_vl_cursor *vc)
if (!vc->server_list || !vc->server_list->nr_servers) if (!vc->server_list || !vc->server_list->nr_servers)
return false; return false;
vc->start = READ_ONCE(vc->server_list->index); vc->untried = (1UL << vc->server_list->nr_servers) - 1;
vc->index = vc->start; vc->index = -1;
return true; return true;
} }
...@@ -71,11 +71,12 @@ bool afs_select_vlserver(struct afs_vl_cursor *vc) ...@@ -71,11 +71,12 @@ bool afs_select_vlserver(struct afs_vl_cursor *vc)
{ {
struct afs_addr_list *alist; struct afs_addr_list *alist;
struct afs_vlserver *vlserver; struct afs_vlserver *vlserver;
int error = vc->ac.error; u32 rtt;
int error = vc->ac.error, abort_code, i;
_enter("%u/%u,%u/%u,%d,%d", _enter("%lx[%d],%lx[%d],%d,%d",
vc->index, vc->start, vc->untried, vc->index,
vc->ac.index, vc->ac.start, vc->ac.tried, vc->ac.index,
error, vc->ac.abort_code); error, vc->ac.abort_code);
if (vc->flags & AFS_VL_CURSOR_STOP) { if (vc->flags & AFS_VL_CURSOR_STOP) {
...@@ -145,23 +146,52 @@ bool afs_select_vlserver(struct afs_vl_cursor *vc) ...@@ -145,23 +146,52 @@ bool afs_select_vlserver(struct afs_vl_cursor *vc)
start: start:
_debug("start"); _debug("start");
/* TODO: Consider checking the VL server list */
if (!afs_start_vl_iteration(vc)) if (!afs_start_vl_iteration(vc))
goto failed; goto failed;
use_server: error = afs_send_vl_probes(vc->cell->net, vc->key, vc->server_list);
_debug("use"); 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 /* 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 * check it, find its address list and probe its capabilities before we
* use it. * use it.
*/ */
ASSERTCMP(vc->ac.alist, ==, NULL); ASSERTCMP(vc->ac.alist, ==, NULL);
vlserver = vc->server_list->servers[vc->index].server; vlserver = vc->server_list->servers[vc->index].server;
vc->server = vlserver;
// TODO: Check the vlserver occasionally
//if (!afs_check_vlserver_record(vc, vlserver))
// goto failed;
_debug("USING VLSERVER: %s", vlserver->name); _debug("USING VLSERVER: %s", vlserver->name);
...@@ -173,62 +203,84 @@ bool afs_select_vlserver(struct afs_vl_cursor *vc) ...@@ -173,62 +203,84 @@ bool afs_select_vlserver(struct afs_vl_cursor *vc)
memset(&vc->ac, 0, sizeof(vc->ac)); memset(&vc->ac, 0, sizeof(vc->ac));
/* Probe the current vlserver if we haven't done so yet. */
#if 0 // TODO
if (!test_bit(AFS_VLSERVER_FL_PROBED, &vlserver->flags)) {
vc->ac.alist = afs_get_addrlist(alist);
if (!afs_probe_vlserver(vc)) {
error = vc->ac.error;
switch (error) {
case -ENOMEM:
case -ERESTARTSYS:
case -EINTR:
goto failed_set_error;
default:
goto next_server;
}
}
}
#endif
if (!vc->ac.alist) if (!vc->ac.alist)
vc->ac.alist = alist; vc->ac.alist = alist;
else else
afs_put_addrlist(alist); afs_put_addrlist(alist);
vc->ac.start = READ_ONCE(alist->index); vc->ac.index = -1;
vc->ac.index = vc->ac.start;
iterate_address: iterate_address:
ASSERT(vc->ac.alist); ASSERT(vc->ac.alist);
_debug("iterate %d/%d", vc->ac.index, vc->ac.alist->nr_addrs);
/* Iterate over the current server's address list to try and find an /* Iterate over the current server's address list to try and find an
* address on which it will respond to us. * address on which it will respond to us.
*/ */
if (!afs_iterate_addresses(&vc->ac)) if (!afs_iterate_addresses(&vc->ac))
goto next_server; 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); _leave(" = t %pISpc", &vc->ac.alist->addrs[vc->ac.index].transport);
return true; return true;
next_server: next_server:
_debug("next"); _debug("next");
afs_end_cursor(&vc->ac); afs_end_cursor(&vc->ac);
vc->index++; goto pick_server;
if (vc->index >= vc->server_list->nr_servers)
vc->index = 0;
if (vc->index != vc->start)
goto use_server;
no_more_servers:
/* That's all the servers poked to no good effect. Try again if some /* That's all the servers poked to no good effect. Try again if some
* of them were busy. * of them were busy.
*/ */
if (vc->flags & AFS_VL_CURSOR_RETRY) if (vc->flags & AFS_VL_CURSOR_RETRY)
goto restart_from_beginning; goto restart_from_beginning;
goto failed; abort_code = 0;
error = -EDESTADDRREQ;
for (i = 0; i < vc->server_list->nr_servers; i++) {
struct afs_vlserver *s = vc->server_list->servers[i].server;
int probe_error = READ_ONCE(s->probe.error);
switch (probe_error) {
case 0:
continue;
default:
if (error == -ETIMEDOUT ||
error == -ETIME)
continue;
case -ETIMEDOUT:
case -ETIME:
if (error == -ENOMEM ||
error == -ENONET)
continue;
case -ENOMEM:
case -ENONET:
if (error == -ENETUNREACH)
continue;
case -ENETUNREACH:
if (error == -EHOSTUNREACH)
continue;
case -EHOSTUNREACH:
if (error == -ECONNREFUSED)
continue;
case -ECONNREFUSED:
if (error == -ECONNRESET)
continue;
case -ECONNRESET: /* Responded, but call expired. */
if (error == -ECONNABORTED)
continue;
case -ECONNABORTED:
abort_code = s->probe.abort_code;
error = probe_error;
continue;
}
}
if (error == -ECONNABORTED)
error = afs_abort_to_error(abort_code);
failed_set_error:
vc->error = error;
failed: failed:
vc->flags |= AFS_VL_CURSOR_STOP; vc->flags |= AFS_VL_CURSOR_STOP;
afs_end_cursor(&vc->ac); afs_end_cursor(&vc->ac);
...@@ -250,8 +302,8 @@ static void afs_vl_dump_edestaddrreq(const struct afs_vl_cursor *vc) ...@@ -250,8 +302,8 @@ static void afs_vl_dump_edestaddrreq(const struct afs_vl_cursor *vc)
rcu_read_lock(); rcu_read_lock();
pr_notice("EDESTADDR occurred\n"); pr_notice("EDESTADDR occurred\n");
pr_notice("VC: st=%u ix=%u ni=%hu fl=%hx err=%hd\n", pr_notice("VC: ut=%lx ix=%u ni=%hu fl=%hx err=%hd\n",
vc->start, vc->index, vc->nr_iterations, vc->flags, vc->error); vc->untried, vc->index, vc->nr_iterations, vc->flags, vc->error);
if (vc->server_list) { if (vc->server_list) {
const struct afs_vlserver_list *sl = vc->server_list; const struct afs_vlserver_list *sl = vc->server_list;
...@@ -259,26 +311,25 @@ static void afs_vl_dump_edestaddrreq(const struct afs_vl_cursor *vc) ...@@ -259,26 +311,25 @@ static void afs_vl_dump_edestaddrreq(const struct afs_vl_cursor *vc)
sl->nr_servers, sl->index); sl->nr_servers, sl->index);
for (i = 0; i < sl->nr_servers; i++) { for (i = 0; i < sl->nr_servers; i++) {
const struct afs_vlserver *s = sl->servers[i].server; const struct afs_vlserver *s = sl->servers[i].server;
pr_notice("VC: server fl=%lx %s+%hu\n", pr_notice("VC: server %s+%hu fl=%lx E=%hd\n",
s->flags, s->name, s->port); s->name, s->port, s->flags, s->probe.error);
if (s->addresses) { if (s->addresses) {
const struct afs_addr_list *a = const struct afs_addr_list *a =
rcu_dereference(s->addresses); rcu_dereference(s->addresses);
pr_notice("VC: - av=%u nr=%u/%u/%u ax=%u\n", pr_notice("VC: - nr=%u/%u/%u pf=%u\n",
a->version,
a->nr_ipv4, a->nr_addrs, a->max_addrs, a->nr_ipv4, a->nr_addrs, a->max_addrs,
a->index); a->preferred);
pr_notice("VC: - pr=%lx yf=%lx\n", pr_notice("VC: - pr=%lx R=%lx F=%lx\n",
a->probed, a->yfs); a->probed, a->responded, a->failed);
if (a == vc->ac.alist) if (a == vc->ac.alist)
pr_notice("VC: - current\n"); pr_notice("VC: - current\n");
} }
} }
} }
pr_notice("AC: as=%u ax=%u ac=%d er=%d b=%u r=%u ni=%hu\n", pr_notice("AC: t=%lx ax=%u ac=%d er=%d r=%u ni=%u\n",
vc->ac.start, vc->ac.index, vc->ac.abort_code, vc->ac.error, vc->ac.tried, vc->ac.index, vc->ac.abort_code, vc->ac.error,
vc->ac.begun, vc->ac.responded, vc->ac.nr_iterations); vc->ac.responded, vc->ac.nr_iterations);
rcu_read_unlock(); rcu_read_unlock();
} }
......
...@@ -348,12 +348,18 @@ static int afs_deliver_vl_get_capabilities(struct afs_call *call) ...@@ -348,12 +348,18 @@ static int afs_deliver_vl_get_capabilities(struct afs_call *call)
break; break;
} }
call->reply[0] = (void *)(unsigned long)call->service_id;
_leave(" = 0 [done]"); _leave(" = 0 [done]");
return 0; return 0;
} }
static void afs_destroy_vl_get_capabilities(struct afs_call *call)
{
struct afs_vlserver *server = call->reply[0];
afs_put_vlserver(call->net, server);
afs_flat_call_destructor(call);
}
/* /*
* VL.GetCapabilities operation type * VL.GetCapabilities operation type
*/ */
...@@ -361,7 +367,8 @@ static const struct afs_call_type afs_RXVLGetCapabilities = { ...@@ -361,7 +367,8 @@ static const struct afs_call_type afs_RXVLGetCapabilities = {
.name = "VL.GetCapabilities", .name = "VL.GetCapabilities",
.op = afs_VL_GetCapabilities, .op = afs_VL_GetCapabilities,
.deliver = afs_deliver_vl_get_capabilities, .deliver = afs_deliver_vl_get_capabilities,
.destructor = afs_flat_call_destructor, .done = afs_vlserver_probe_result,
.destructor = afs_destroy_vl_get_capabilities,
}; };
/* /*
...@@ -371,8 +378,12 @@ static const struct afs_call_type afs_RXVLGetCapabilities = { ...@@ -371,8 +378,12 @@ static const struct afs_call_type afs_RXVLGetCapabilities = {
* We use this to probe for service upgrade to determine what the server at the * We use this to probe for service upgrade to determine what the server at the
* other end supports. * other end supports.
*/ */
int afs_vl_get_capabilities(struct afs_net *net, struct afs_addr_cursor *ac, int afs_vl_get_capabilities(struct afs_net *net,
struct key *key) struct afs_addr_cursor *ac,
struct key *key,
struct afs_vlserver *server,
unsigned int server_index,
bool async)
{ {
struct afs_call *call; struct afs_call *call;
__be32 *bp; __be32 *bp;
...@@ -384,9 +395,10 @@ int afs_vl_get_capabilities(struct afs_net *net, struct afs_addr_cursor *ac, ...@@ -384,9 +395,10 @@ int afs_vl_get_capabilities(struct afs_net *net, struct afs_addr_cursor *ac,
return -ENOMEM; return -ENOMEM;
call->key = key; call->key = key;
call->upgrade = true; /* Let's see if this is a YFS server */ call->reply[0] = afs_get_vlserver(server);
call->reply[0] = (void *)VLGETCAPABILITIES; call->reply[1] = (void *)(long)server_index;
call->ret_reply0 = true; call->upgrade = true;
call->want_reply_time = true;
/* marshall the parameters */ /* marshall the parameters */
bp = call->request; bp = call->request;
...@@ -394,7 +406,7 @@ int afs_vl_get_capabilities(struct afs_net *net, struct afs_addr_cursor *ac, ...@@ -394,7 +406,7 @@ int afs_vl_get_capabilities(struct afs_net *net, struct afs_addr_cursor *ac,
/* Can't take a ref on server */ /* Can't take a ref on server */
trace_afs_make_vl_call(call); trace_afs_make_vl_call(call);
return afs_make_call(ac, call, GFP_KERNEL, false); return afs_make_call(ac, call, GFP_KERNEL, async);
} }
/* /*
...@@ -591,11 +603,6 @@ static int afs_deliver_yfsvl_get_endpoints(struct afs_call *call) ...@@ -591,11 +603,6 @@ static int afs_deliver_yfsvl_get_endpoints(struct afs_call *call)
} }
alist = call->reply[0]; alist = call->reply[0];
/* Start with IPv6 if available. */
if (alist->nr_ipv4 < alist->nr_addrs)
alist->index = alist->nr_ipv4;
_leave(" = 0 [done]"); _leave(" = 0 [done]");
return 0; return 0;
} }
......
...@@ -82,22 +82,6 @@ static struct afs_vldb_entry *afs_vl_lookup_vldb(struct afs_cell *cell, ...@@ -82,22 +82,6 @@ static struct afs_vldb_entry *afs_vl_lookup_vldb(struct afs_cell *cell,
return ERR_PTR(-ERESTARTSYS); return ERR_PTR(-ERESTARTSYS);
while (afs_select_vlserver(&vc)) { while (afs_select_vlserver(&vc)) {
if (!test_bit(vc.ac.index, &vc.ac.alist->probed)) {
ret = afs_vl_get_capabilities(cell->net, &vc.ac, key);
switch (ret) {
case VL_SERVICE:
clear_bit(vc.ac.index, &vc.ac.alist->yfs);
set_bit(vc.ac.index, &vc.ac.alist->probed);
vc.ac.alist->addrs[vc.ac.index].srx_service = ret;
break;
case YFS_VL_SERVICE:
set_bit(vc.ac.index, &vc.ac.alist->yfs);
set_bit(vc.ac.index, &vc.ac.alist->probed);
vc.ac.alist->addrs[vc.ac.index].srx_service = ret;
break;
}
}
vldb = afs_vl_get_entry_by_name_u(&vc, volname, volnamesz); vldb = afs_vl_get_entry_by_name_u(&vc, volname, volnamesz);
} }
......
...@@ -137,6 +137,7 @@ enum afs_io_error { ...@@ -137,6 +137,7 @@ enum afs_io_error {
afs_io_error_extract, afs_io_error_extract,
afs_io_error_fs_probe_fail, afs_io_error_fs_probe_fail,
afs_io_error_vl_lookup_fail, afs_io_error_vl_lookup_fail,
afs_io_error_vl_probe_fail,
}; };
enum afs_file_error { enum afs_file_error {
...@@ -261,7 +262,8 @@ enum afs_file_error { ...@@ -261,7 +262,8 @@ enum afs_file_error {
EM(afs_io_error_cm_reply, "CM_REPLY") \ EM(afs_io_error_cm_reply, "CM_REPLY") \
EM(afs_io_error_extract, "EXTRACT") \ EM(afs_io_error_extract, "EXTRACT") \
EM(afs_io_error_fs_probe_fail, "FS_PROBE_FAIL") \ EM(afs_io_error_fs_probe_fail, "FS_PROBE_FAIL") \
E_(afs_io_error_vl_lookup_fail, "VL_LOOKUP_FAIL") EM(afs_io_error_vl_lookup_fail, "VL_LOOKUP_FAIL") \
E_(afs_io_error_vl_probe_fail, "VL_PROBE_FAIL")
#define afs_file_errors \ #define afs_file_errors \
EM(afs_file_error_dir_bad_magic, "DIR_BAD_MAGIC") \ EM(afs_file_error_dir_bad_magic, "DIR_BAD_MAGIC") \
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment