mirror of
https://github.com/torvalds/linux.git
synced 2024-11-22 04:02:20 +00:00
afs: Fold the afs_addr_cursor struct in
Fold the afs_addr_cursor struct into the afs_operation struct and the afs_vl_cursor struct and fold its operations into their callers also. Signed-off-by: David Howells <dhowells@redhat.com> cc: Marc Dionne <marc.dionne@auristor.com> cc: linux-afs@lists.infradead.org
This commit is contained in:
David Howells
parent
e38f299ece
commit
98f9fda205
@ -375,56 +375,3 @@ int afs_merge_fs_addr6(struct afs_net *net, struct afs_addr_list *alist,
|
||||
alist->nr_addrs++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Get an address to try.
|
||||
*/
|
||||
bool afs_iterate_addresses(struct afs_addr_cursor *ac)
|
||||
{
|
||||
unsigned long set, failed;
|
||||
int index;
|
||||
|
||||
if (!ac->alist)
|
||||
return false;
|
||||
|
||||
set = ac->alist->responded;
|
||||
failed = ac->alist->probe_failed;
|
||||
_enter("%lx-%lx-%lx,%d", set, failed, ac->tried, ac->index);
|
||||
|
||||
ac->nr_iterations++;
|
||||
|
||||
set &= ~(failed | ac->tried);
|
||||
|
||||
if (!set)
|
||||
return false;
|
||||
|
||||
index = READ_ONCE(ac->alist->preferred);
|
||||
if (test_bit(index, &set))
|
||||
goto selected;
|
||||
|
||||
index = __ffs(set);
|
||||
|
||||
selected:
|
||||
ac->index = index;
|
||||
set_bit(index, &ac->tried);
|
||||
ac->call_responded = false;
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
* Release an address list cursor.
|
||||
*/
|
||||
void afs_end_cursor(struct afs_addr_cursor *ac)
|
||||
{
|
||||
struct afs_addr_list *alist;
|
||||
|
||||
alist = ac->alist;
|
||||
if (alist) {
|
||||
if (ac->call_responded &&
|
||||
ac->index != alist->preferred &&
|
||||
test_bit(ac->alist->preferred, &ac->tried))
|
||||
WRITE_ONCE(alist->preferred, ac->index);
|
||||
afs_put_addrlist(alist, afs_alist_trace_put_end_cursor);
|
||||
ac->alist = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
@ -179,6 +179,7 @@ void afs_wait_for_operation(struct afs_operation *op)
|
||||
_enter("");
|
||||
|
||||
while (afs_select_fileserver(op)) {
|
||||
op->call_responded = false;
|
||||
op->call_error = 0;
|
||||
op->call_abort_code = 0;
|
||||
op->cb_s_break = op->server->cb_s_break;
|
||||
@ -191,17 +192,19 @@ void afs_wait_for_operation(struct afs_operation *op)
|
||||
op->call_error = -ENOTSUPP;
|
||||
|
||||
if (op->call) {
|
||||
afs_wait_for_call_to_complete(op->call, &op->ac);
|
||||
afs_wait_for_call_to_complete(op->call);
|
||||
op->call_abort_code = op->call->abort_code;
|
||||
op->call_error = op->call->error;
|
||||
op->call_responded = op->call->responded;
|
||||
op->ac.call_responded = true;
|
||||
WRITE_ONCE(op->ac.alist->addrs[op->ac.index].last_error,
|
||||
WRITE_ONCE(op->alist->addrs[op->addr_index].last_error,
|
||||
op->call_error);
|
||||
afs_put_call(op->call);
|
||||
}
|
||||
}
|
||||
|
||||
if (op->call_responded)
|
||||
set_bit(AFS_SERVER_FL_RESPONDING, &op->server->flags);
|
||||
|
||||
if (!afs_op_error(op)) {
|
||||
_debug("success");
|
||||
op->ops->success(op);
|
||||
@ -227,6 +230,7 @@ void afs_wait_for_operation(struct afs_operation *op)
|
||||
*/
|
||||
int afs_put_operation(struct afs_operation *op)
|
||||
{
|
||||
struct afs_addr_list *alist;
|
||||
int i, ret = afs_op_error(op);
|
||||
|
||||
_enter("op=%08x,%d", op->debug_id, ret);
|
||||
@ -249,7 +253,16 @@ int afs_put_operation(struct afs_operation *op)
|
||||
kfree(op->more_files);
|
||||
}
|
||||
|
||||
afs_end_cursor(&op->ac);
|
||||
alist = op->alist;
|
||||
if (alist) {
|
||||
if (op->call_responded &&
|
||||
op->addr_index != alist->preferred &&
|
||||
test_bit(alist->preferred, &op->addr_tried))
|
||||
WRITE_ONCE(alist->preferred, op->addr_index);
|
||||
afs_put_addrlist(alist, afs_alist_trace_put_operation);
|
||||
op->alist = NULL;
|
||||
}
|
||||
|
||||
afs_put_serverlist(op->net, op->server_list);
|
||||
afs_put_volume(op->net, op->volume, afs_volume_trace_put_put_op);
|
||||
key_put(op->key);
|
||||
|
||||
@ -74,11 +74,9 @@ static void afs_done_one_fs_probe(struct afs_net *net, struct afs_server *server
|
||||
*/
|
||||
static void afs_fs_probe_not_done(struct afs_net *net,
|
||||
struct afs_server *server,
|
||||
struct afs_addr_cursor *ac)
|
||||
struct afs_addr_list *alist,
|
||||
int index)
|
||||
{
|
||||
struct afs_addr_list *alist = ac->alist;
|
||||
unsigned int index = ac->index;
|
||||
|
||||
_enter("");
|
||||
|
||||
trace_afs_io_error(0, -ENOMEM, afs_io_error_fs_probe_fail);
|
||||
@ -100,10 +98,10 @@ static void afs_fs_probe_not_done(struct afs_net *net,
|
||||
*/
|
||||
void afs_fileserver_probe_result(struct afs_call *call)
|
||||
{
|
||||
struct afs_addr_list *alist = call->alist;
|
||||
struct afs_address *addr = &alist->addrs[call->addr_ix];
|
||||
struct afs_addr_list *alist = call->probe_alist;
|
||||
struct afs_address *addr = &alist->addrs[call->probe_index];
|
||||
struct afs_server *server = call->server;
|
||||
unsigned int index = call->addr_ix;
|
||||
unsigned int index = call->probe_index;
|
||||
unsigned int rtt_us = 0, cap0;
|
||||
int ret = call->error;
|
||||
|
||||
@ -196,37 +194,36 @@ out:
|
||||
void afs_fs_probe_fileserver(struct afs_net *net, struct afs_server *server,
|
||||
struct key *key, bool all)
|
||||
{
|
||||
struct afs_addr_cursor ac = {
|
||||
.index = 0,
|
||||
};
|
||||
struct afs_addr_list *alist;
|
||||
unsigned int index;
|
||||
|
||||
_enter("%pU", &server->uuid);
|
||||
|
||||
read_lock(&server->fs_lock);
|
||||
ac.alist = rcu_dereference_protected(server->addresses,
|
||||
lockdep_is_held(&server->fs_lock));
|
||||
afs_get_addrlist(ac.alist, afs_alist_trace_get_probe);
|
||||
alist = rcu_dereference_protected(server->addresses,
|
||||
lockdep_is_held(&server->fs_lock));
|
||||
afs_get_addrlist(alist, afs_alist_trace_get_probe);
|
||||
read_unlock(&server->fs_lock);
|
||||
|
||||
server->probed_at = jiffies;
|
||||
atomic_set(&server->probe_outstanding, all ? ac.alist->nr_addrs : 1);
|
||||
atomic_set(&server->probe_outstanding, all ? alist->nr_addrs : 1);
|
||||
memset(&server->probe, 0, sizeof(server->probe));
|
||||
server->probe.rtt = UINT_MAX;
|
||||
|
||||
ac.index = ac.alist->preferred;
|
||||
if (ac.index < 0 || ac.index >= ac.alist->nr_addrs)
|
||||
index = alist->preferred;
|
||||
if (index < 0 || index >= alist->nr_addrs)
|
||||
all = true;
|
||||
|
||||
if (all) {
|
||||
for (ac.index = 0; ac.index < ac.alist->nr_addrs; ac.index++)
|
||||
if (!afs_fs_get_capabilities(net, server, &ac, key))
|
||||
afs_fs_probe_not_done(net, server, &ac);
|
||||
for (index = 0; index < alist->nr_addrs; index++)
|
||||
if (!afs_fs_get_capabilities(net, server, alist, index, key))
|
||||
afs_fs_probe_not_done(net, server, alist, index);
|
||||
} else {
|
||||
if (!afs_fs_get_capabilities(net, server, &ac, key))
|
||||
afs_fs_probe_not_done(net, server, &ac);
|
||||
if (!afs_fs_get_capabilities(net, server, alist, index, key))
|
||||
afs_fs_probe_not_done(net, server, alist, index);
|
||||
}
|
||||
|
||||
afs_put_addrlist(ac.alist, afs_alist_trace_put_probe);
|
||||
afs_put_addrlist(alist, afs_alist_trace_put_probe);
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -1605,10 +1605,8 @@ static const struct afs_call_type afs_RXFSGiveUpAllCallBacks = {
|
||||
/*
|
||||
* Flush all the callbacks we have on a server.
|
||||
*/
|
||||
int afs_fs_give_up_all_callbacks(struct afs_net *net,
|
||||
struct afs_server *server,
|
||||
struct afs_addr_cursor *ac,
|
||||
struct key *key)
|
||||
int afs_fs_give_up_all_callbacks(struct afs_net *net, struct afs_server *server,
|
||||
struct afs_address *addr, struct key *key)
|
||||
{
|
||||
struct afs_call *call;
|
||||
__be32 *bp;
|
||||
@ -1621,7 +1619,7 @@ int afs_fs_give_up_all_callbacks(struct afs_net *net,
|
||||
return -ENOMEM;
|
||||
|
||||
call->key = key;
|
||||
call->peer = rxrpc_kernel_get_peer(ac->alist->addrs[ac->index].peer);
|
||||
call->peer = rxrpc_kernel_get_peer(addr->peer);
|
||||
call->service_id = server->service_id;
|
||||
|
||||
/* marshall the parameters */
|
||||
@ -1629,9 +1627,11 @@ int afs_fs_give_up_all_callbacks(struct afs_net *net,
|
||||
*bp++ = htonl(FSGIVEUPALLCALLBACKS);
|
||||
|
||||
call->server = afs_use_server(server, afs_server_trace_give_up_cb);
|
||||
afs_make_call(ac, call, GFP_NOFS);
|
||||
afs_wait_for_call_to_complete(call, ac);
|
||||
afs_make_call(call, GFP_NOFS);
|
||||
afs_wait_for_call_to_complete(call);
|
||||
ret = call->error;
|
||||
if (call->responded)
|
||||
set_bit(AFS_SERVER_FL_RESPONDING, &server->flags);
|
||||
afs_put_call(call);
|
||||
return ret;
|
||||
}
|
||||
@ -1695,6 +1695,12 @@ static int afs_deliver_fs_get_capabilities(struct afs_call *call)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void afs_fs_get_capabilities_destructor(struct afs_call *call)
|
||||
{
|
||||
afs_put_addrlist(call->probe_alist, afs_alist_trace_put_getcaps);
|
||||
afs_flat_call_destructor(call);
|
||||
}
|
||||
|
||||
/*
|
||||
* FS.GetCapabilities operation type
|
||||
*/
|
||||
@ -1703,7 +1709,7 @@ static const struct afs_call_type afs_RXFSGetCapabilities = {
|
||||
.op = afs_FS_GetCapabilities,
|
||||
.deliver = afs_deliver_fs_get_capabilities,
|
||||
.done = afs_fileserver_probe_result,
|
||||
.destructor = afs_flat_call_destructor,
|
||||
.destructor = afs_fs_get_capabilities_destructor,
|
||||
};
|
||||
|
||||
/*
|
||||
@ -1713,7 +1719,8 @@ static const struct afs_call_type afs_RXFSGetCapabilities = {
|
||||
* ->done() - otherwise we return false to indicate we didn't even try.
|
||||
*/
|
||||
bool afs_fs_get_capabilities(struct afs_net *net, struct afs_server *server,
|
||||
struct afs_addr_cursor *ac, struct key *key)
|
||||
struct afs_addr_list *alist, unsigned int addr_index,
|
||||
struct key *key)
|
||||
{
|
||||
struct afs_call *call;
|
||||
__be32 *bp;
|
||||
@ -1726,7 +1733,9 @@ bool afs_fs_get_capabilities(struct afs_net *net, struct afs_server *server,
|
||||
|
||||
call->key = key;
|
||||
call->server = afs_use_server(server, afs_server_trace_get_caps);
|
||||
call->peer = rxrpc_kernel_get_peer(ac->alist->addrs[ac->index].peer);
|
||||
call->peer = rxrpc_kernel_get_peer(alist->addrs[addr_index].peer);
|
||||
call->probe_alist = afs_get_addrlist(alist, afs_alist_trace_get_getcaps);
|
||||
call->probe_index = addr_index;
|
||||
call->service_id = server->service_id;
|
||||
call->upgrade = true;
|
||||
call->async = true;
|
||||
@ -1737,7 +1746,7 @@ bool afs_fs_get_capabilities(struct afs_net *net, struct afs_server *server,
|
||||
*bp++ = htonl(FSGETCAPABILITIES);
|
||||
|
||||
trace_afs_make_fs_call(call, NULL);
|
||||
afs_make_call(ac, call, GFP_NOFS);
|
||||
afs_make_call(call, GFP_NOFS);
|
||||
afs_put_call(call);
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -102,7 +102,6 @@ struct afs_addr_list {
|
||||
*/
|
||||
struct afs_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 */
|
||||
struct work_struct async_work; /* async I/O processor */
|
||||
struct work_struct work; /* actual work processor */
|
||||
@ -123,6 +122,10 @@ struct afs_call {
|
||||
};
|
||||
void *buffer; /* reply receive buffer */
|
||||
union {
|
||||
struct {
|
||||
struct afs_addr_list *probe_alist;
|
||||
unsigned char probe_index; /* Address in ->probe_alist */
|
||||
};
|
||||
struct afs_addr_list *ret_alist;
|
||||
struct afs_vldb_entry *ret_vldb;
|
||||
char *ret_str;
|
||||
@ -139,7 +142,6 @@ struct afs_call {
|
||||
unsigned reply_max; /* maximum size of reply */
|
||||
unsigned count2; /* count used in unmarshalling */
|
||||
unsigned char unmarshall; /* unmarshalling phase */
|
||||
unsigned char addr_ix; /* Address in ->alist */
|
||||
bool drop_ref; /* T if need to drop ref for incoming call */
|
||||
bool need_attention; /* T if RxRPC poked us */
|
||||
bool async; /* T if asynchronous */
|
||||
@ -729,31 +731,23 @@ struct afs_error {
|
||||
bool aborted; /* T if ->error is from an abort */
|
||||
};
|
||||
|
||||
/*
|
||||
* Cursor for iterating over a server's address list.
|
||||
*/
|
||||
struct afs_addr_cursor {
|
||||
struct afs_addr_list *alist; /* Current address list (pins ref) */
|
||||
unsigned long tried; /* Tried addresses */
|
||||
signed char index; /* Current address */
|
||||
unsigned short nr_iterations; /* Number of address iterations */
|
||||
bool call_responded;
|
||||
};
|
||||
|
||||
/*
|
||||
* Cursor for iterating over a set of volume location servers.
|
||||
*/
|
||||
struct afs_vl_cursor {
|
||||
struct afs_addr_cursor ac;
|
||||
struct afs_cell *cell; /* The cell we're querying */
|
||||
struct afs_vlserver_list *server_list; /* Current server list (pins ref) */
|
||||
struct afs_vlserver *server; /* Server on which this resides */
|
||||
struct afs_addr_list *alist; /* Current address list (pins ref) */
|
||||
struct key *key; /* Key for the server */
|
||||
unsigned long untried_servers; /* Bitmask of untried servers */
|
||||
unsigned long addr_tried; /* Tried addresses */
|
||||
struct afs_error cumul_error; /* Cumulative error */
|
||||
unsigned int debug_id;
|
||||
s32 call_abort_code;
|
||||
short call_error; /* Error from single call */
|
||||
short server_index; /* Current server */
|
||||
signed char addr_index; /* Current address */
|
||||
unsigned short flags;
|
||||
#define AFS_VL_CURSOR_STOP 0x0001 /* Set to cease iteration */
|
||||
#define AFS_VL_CURSOR_RETRY 0x0002 /* Set to do a retry */
|
||||
@ -812,8 +806,6 @@ struct afs_operation {
|
||||
struct timespec64 ctime; /* Change time to set */
|
||||
struct afs_error cumul_error; /* Cumulative error */
|
||||
short nr_files; /* Number of entries in file[], more_files */
|
||||
short call_error; /* Error from single call */
|
||||
s32 call_abort_code; /* Abort code from single call */
|
||||
unsigned int debug_id;
|
||||
|
||||
unsigned int cb_v_break; /* Volume break counter before op */
|
||||
@ -862,16 +854,19 @@ struct afs_operation {
|
||||
};
|
||||
|
||||
/* Fileserver iteration state */
|
||||
struct afs_addr_cursor ac;
|
||||
struct afs_server_list *server_list; /* Current server list (pins ref) */
|
||||
struct afs_server *server; /* Server we're using (ref pinned by server_list) */
|
||||
struct afs_addr_list *alist; /* Current address list (pins ref) */
|
||||
struct afs_call *call;
|
||||
unsigned long untried_servers; /* Bitmask of untried servers */
|
||||
unsigned long addr_tried; /* Tried addresses */
|
||||
s32 call_abort_code; /* Abort code from single call */
|
||||
short call_error; /* Error from single call */
|
||||
short server_index; /* Current server */
|
||||
short nr_iterations; /* Number of server iterations */
|
||||
signed char addr_index; /* Current address */
|
||||
bool call_responded; /* T if the current address responded */
|
||||
|
||||
|
||||
unsigned int flags;
|
||||
#define AFS_OPERATION_STOP 0x0001 /* Set to cease iteration */
|
||||
#define AFS_OPERATION_VBUSY 0x0002 /* Set if seen VBUSY */
|
||||
@ -981,8 +976,6 @@ extern struct afs_vlserver_list *afs_parse_text_addrs(struct afs_net *,
|
||||
bool afs_addr_list_same(const struct afs_addr_list *a,
|
||||
const struct afs_addr_list *b);
|
||||
extern struct afs_vlserver_list *afs_dns_query(struct afs_cell *, time64_t *);
|
||||
extern bool afs_iterate_addresses(struct afs_addr_cursor *);
|
||||
extern void afs_end_cursor(struct afs_addr_cursor *ac);
|
||||
|
||||
extern int afs_merge_fs_addr4(struct afs_net *net, struct afs_addr_list *addr,
|
||||
__be32 xdr, u16 port);
|
||||
@ -1123,10 +1116,11 @@ extern void afs_fs_get_volume_status(struct afs_operation *);
|
||||
extern void afs_fs_set_lock(struct afs_operation *);
|
||||
extern void afs_fs_extend_lock(struct afs_operation *);
|
||||
extern void afs_fs_release_lock(struct afs_operation *);
|
||||
extern int afs_fs_give_up_all_callbacks(struct afs_net *, struct afs_server *,
|
||||
struct afs_addr_cursor *, struct key *);
|
||||
extern bool afs_fs_get_capabilities(struct afs_net *, struct afs_server *,
|
||||
struct afs_addr_cursor *, struct key *);
|
||||
int afs_fs_give_up_all_callbacks(struct afs_net *net, struct afs_server *server,
|
||||
struct afs_address *addr, struct key *key);
|
||||
bool afs_fs_get_capabilities(struct afs_net *net, struct afs_server *server,
|
||||
struct afs_addr_list *alist, unsigned int addr_index,
|
||||
struct key *key);
|
||||
extern void afs_fs_inline_bulk_status(struct afs_operation *);
|
||||
|
||||
struct afs_acl {
|
||||
@ -1306,8 +1300,8 @@ extern int __net_init afs_open_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_put_call(struct afs_call *);
|
||||
extern void afs_make_call(struct afs_addr_cursor *, struct afs_call *, gfp_t);
|
||||
void afs_wait_for_call_to_complete(struct afs_call *call, struct afs_addr_cursor *ac);
|
||||
void afs_make_call(struct afs_call *call, gfp_t gfp);
|
||||
void afs_wait_for_call_to_complete(struct afs_call *call);
|
||||
extern struct afs_call *afs_alloc_flat_call(struct afs_net *,
|
||||
const struct afs_call_type *,
|
||||
size_t, size_t);
|
||||
@ -1325,9 +1319,9 @@ static inline void afs_make_op_call(struct afs_operation *op, struct afs_call *c
|
||||
call->op = op;
|
||||
call->key = op->key;
|
||||
call->intr = !(op->flags & AFS_OPERATION_UNINTR);
|
||||
call->peer = rxrpc_kernel_get_peer(op->ac.alist->addrs[op->ac.index].peer);
|
||||
call->peer = rxrpc_kernel_get_peer(op->alist->addrs[op->addr_index].peer);
|
||||
call->service_id = op->server->service_id;
|
||||
afs_make_call(&op->ac, call, gfp);
|
||||
afs_make_call(call, gfp);
|
||||
}
|
||||
|
||||
static inline void afs_extract_begin(struct afs_call *call, void *buf, size_t size)
|
||||
@ -1493,8 +1487,12 @@ extern void afs_fs_exit(void);
|
||||
extern struct afs_vldb_entry *afs_vl_get_entry_by_name_u(struct afs_vl_cursor *,
|
||||
const char *, int);
|
||||
extern struct afs_addr_list *afs_vl_get_addrs_u(struct afs_vl_cursor *, const uuid_t *);
|
||||
extern struct afs_call *afs_vl_get_capabilities(struct afs_net *, struct afs_addr_cursor *,
|
||||
struct key *, struct afs_vlserver *, unsigned int);
|
||||
struct afs_call *afs_vl_get_capabilities(struct afs_net *net,
|
||||
struct afs_addr_list *alist,
|
||||
unsigned int addr_index,
|
||||
struct key *key,
|
||||
struct afs_vlserver *server,
|
||||
unsigned int server_index);
|
||||
extern struct afs_addr_list *afs_yfsvl_get_endpoints(struct afs_vl_cursor *, const uuid_t *);
|
||||
extern char *afs_yfsvl_get_cell_name(struct afs_vl_cursor *);
|
||||
|
||||
|
||||
@ -109,19 +109,20 @@ static bool afs_sleep_and_retry(struct afs_operation *op)
|
||||
*/
|
||||
bool afs_select_fileserver(struct afs_operation *op)
|
||||
{
|
||||
struct afs_addr_list *alist;
|
||||
struct afs_addr_list *alist = op->alist;
|
||||
struct afs_server *server;
|
||||
struct afs_vnode *vnode = op->file[0].vnode;
|
||||
unsigned long set;
|
||||
unsigned int rtt;
|
||||
s32 abort_code = op->call_abort_code;
|
||||
int error = op->call_error, i;
|
||||
int error = op->call_error, addr_index, i;
|
||||
|
||||
op->nr_iterations++;
|
||||
|
||||
_enter("OP=%x+%x,%llx,%lx[%d],%lx[%d],%d,%d",
|
||||
_enter("OP=%x+%x,%llx,%u{%lx},%u{%lx},%d,%d",
|
||||
op->debug_id, op->nr_iterations, op->volume->vid,
|
||||
op->untried_servers, op->server_index,
|
||||
op->ac.tried, op->ac.index,
|
||||
op->server_index, op->untried_servers,
|
||||
op->addr_index, op->addr_tried,
|
||||
error, abort_code);
|
||||
|
||||
if (op->flags & AFS_OPERATION_STOP) {
|
||||
@ -398,12 +399,14 @@ bool afs_select_fileserver(struct afs_operation *op)
|
||||
|
||||
restart_from_beginning:
|
||||
_debug("restart");
|
||||
afs_end_cursor(&op->ac);
|
||||
afs_put_addrlist(alist, afs_alist_trace_put_restart_rotate);
|
||||
alist = op->alist = NULL;
|
||||
op->server = NULL;
|
||||
afs_put_serverlist(op->net, op->server_list);
|
||||
op->server_list = NULL;
|
||||
start:
|
||||
_debug("start");
|
||||
ASSERTCMP(alist, ==, NULL);
|
||||
/* See if we need to do an update of the volume record. Note that the
|
||||
* volume may have moved or even have been deleted.
|
||||
*/
|
||||
@ -420,6 +423,7 @@ start:
|
||||
|
||||
pick_server:
|
||||
_debug("pick [%lx]", op->untried_servers);
|
||||
ASSERTCMP(alist, ==, NULL);
|
||||
|
||||
error = afs_wait_for_fs_probes(op->server_list, op->untried_servers);
|
||||
if (error < 0) {
|
||||
@ -463,7 +467,7 @@ selected_server:
|
||||
* check it, create a callback intercept, find its address list and
|
||||
* probe its capabilities before we use it.
|
||||
*/
|
||||
ASSERTCMP(op->ac.alist, ==, NULL);
|
||||
ASSERTCMP(alist, ==, NULL);
|
||||
server = op->server_list->servers[op->server_index].server;
|
||||
|
||||
if (!afs_check_server_record(op, server))
|
||||
@ -484,32 +488,34 @@ selected_server:
|
||||
read_lock(&server->fs_lock);
|
||||
alist = rcu_dereference_protected(server->addresses,
|
||||
lockdep_is_held(&server->fs_lock));
|
||||
afs_get_addrlist(alist, afs_alist_trace_get_fsrotate_set);
|
||||
op->alist = afs_get_addrlist(alist, afs_alist_trace_get_fsrotate_set);
|
||||
read_unlock(&server->fs_lock);
|
||||
|
||||
retry_server:
|
||||
memset(&op->ac, 0, sizeof(op->ac));
|
||||
|
||||
if (!op->ac.alist)
|
||||
op->ac.alist = alist;
|
||||
else
|
||||
afs_put_addrlist(alist, afs_alist_trace_put_retry_server);
|
||||
|
||||
op->ac.index = -1;
|
||||
op->addr_tried = 0;
|
||||
op->addr_index = -1;
|
||||
|
||||
iterate_address:
|
||||
ASSERT(op->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(&op->ac))
|
||||
set = READ_ONCE(alist->responded);
|
||||
set &= ~(READ_ONCE(alist->probe_failed) | op->addr_tried);
|
||||
if (!set)
|
||||
goto out_of_addresses;
|
||||
|
||||
_debug("address [%u] %u/%u %pISp",
|
||||
op->server_index, op->ac.index, op->ac.alist->nr_addrs,
|
||||
rxrpc_kernel_remote_addr(op->ac.alist->addrs[op->ac.index].peer));
|
||||
addr_index = READ_ONCE(alist->preferred);
|
||||
if (!test_bit(addr_index, &set))
|
||||
addr_index = __ffs(set);
|
||||
|
||||
op->addr_index = addr_index;
|
||||
set_bit(addr_index, &op->addr_tried);
|
||||
op->alist = alist;
|
||||
|
||||
op->call_responded = false;
|
||||
_debug("address [%u] %u/%u %pISp",
|
||||
op->server_index, addr_index, alist->nr_addrs,
|
||||
rxrpc_kernel_remote_addr(alist->addrs[op->addr_index].peer));
|
||||
_leave(" = t");
|
||||
return true;
|
||||
|
||||
@ -519,7 +525,6 @@ out_of_addresses:
|
||||
*/
|
||||
afs_probe_fileserver(op->net, op->server);
|
||||
if (op->flags & AFS_OPERATION_RETRY_SERVER) {
|
||||
alist = op->ac.alist;
|
||||
error = afs_wait_for_one_fs_probe(
|
||||
op->server, !(op->flags & AFS_OPERATION_UNINTR));
|
||||
switch (error) {
|
||||
@ -537,7 +542,13 @@ out_of_addresses:
|
||||
|
||||
next_server:
|
||||
_debug("next");
|
||||
afs_end_cursor(&op->ac);
|
||||
ASSERT(alist);
|
||||
if (op->call_responded &&
|
||||
op->addr_index != READ_ONCE(alist->preferred) &&
|
||||
test_bit(alist->preferred, &op->addr_tried))
|
||||
WRITE_ONCE(alist->preferred, op->addr_index);
|
||||
afs_put_addrlist(alist, afs_alist_trace_put_next_server);
|
||||
alist = op->alist = NULL;
|
||||
goto pick_server;
|
||||
|
||||
no_more_servers:
|
||||
@ -557,7 +568,14 @@ no_more_servers:
|
||||
|
||||
failed:
|
||||
op->flags |= AFS_OPERATION_STOP;
|
||||
afs_end_cursor(&op->ac);
|
||||
if (alist) {
|
||||
if (op->call_responded &&
|
||||
op->addr_index != READ_ONCE(alist->preferred) &&
|
||||
test_bit(alist->preferred, &op->addr_tried))
|
||||
WRITE_ONCE(alist->preferred, op->addr_index);
|
||||
afs_put_addrlist(alist, afs_alist_trace_put_op_failed);
|
||||
op->alist = NULL;
|
||||
}
|
||||
_leave(" = f [failed %d]", afs_op_error(op));
|
||||
return false;
|
||||
}
|
||||
@ -602,13 +620,12 @@ void afs_dump_edestaddrreq(const struct afs_operation *op)
|
||||
a->preferred);
|
||||
pr_notice("FC: - R=%lx F=%lx\n",
|
||||
a->responded, a->probe_failed);
|
||||
if (a == op->ac.alist)
|
||||
if (a == op->alist)
|
||||
pr_notice("FC: - current\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pr_notice("AC: t=%lx ax=%u ni=%u\n",
|
||||
op->ac.tried, op->ac.index, op->ac.nr_iterations);
|
||||
pr_notice("AC: t=%lx ax=%u\n", op->addr_tried, op->addr_index);
|
||||
rcu_read_unlock();
|
||||
}
|
||||
|
||||
@ -189,7 +189,6 @@ void afs_put_call(struct afs_call *call)
|
||||
call->type->destructor(call);
|
||||
|
||||
afs_unuse_server_notime(call->net, call->server, afs_server_trace_put_call);
|
||||
afs_put_addrlist(call->alist, afs_alist_trace_put_call);
|
||||
kfree(call->request);
|
||||
|
||||
trace_afs_call(call->debug_id, afs_call_trace_free, 0, o,
|
||||
@ -296,7 +295,7 @@ static void afs_notify_end_request_tx(struct sock *sock,
|
||||
* Initiate a call and synchronously queue up the parameters for dispatch. Any
|
||||
* error is stored into the call struct, which the caller must check for.
|
||||
*/
|
||||
void afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call, gfp_t gfp)
|
||||
void afs_make_call(struct afs_call *call, gfp_t gfp)
|
||||
{
|
||||
struct rxrpc_call *rxcall;
|
||||
struct msghdr msg;
|
||||
@ -314,9 +313,6 @@ void afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call, gfp_t gfp)
|
||||
call, call->type->name, key_serial(call->key),
|
||||
atomic_read(&call->net->nr_outstanding_calls));
|
||||
|
||||
call->addr_ix = ac->index;
|
||||
call->alist = afs_get_addrlist(ac->alist, afs_alist_trace_get_make_call);
|
||||
|
||||
/* 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
|
||||
* after the initial fixed part.
|
||||
@ -392,7 +388,7 @@ void afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call, gfp_t gfp)
|
||||
/* Note that at this point, we may have received the reply or an abort
|
||||
* - and an asynchronous call may already have completed.
|
||||
*
|
||||
* afs_wait_for_call_to_complete(call, ac)
|
||||
* afs_wait_for_call_to_complete(call)
|
||||
* must be called to synchronously clean up.
|
||||
*/
|
||||
return;
|
||||
@ -577,7 +573,7 @@ call_complete:
|
||||
/*
|
||||
* Wait synchronously for a call to complete.
|
||||
*/
|
||||
void afs_wait_for_call_to_complete(struct afs_call *call, struct afs_addr_cursor *ac)
|
||||
void afs_wait_for_call_to_complete(struct afs_call *call)
|
||||
{
|
||||
bool rxrpc_complete = false;
|
||||
|
||||
@ -627,9 +623,6 @@ void afs_wait_for_call_to_complete(struct afs_call *call, struct afs_addr_cursor
|
||||
afs_set_call_complete(call, -EINTR, 0);
|
||||
}
|
||||
}
|
||||
|
||||
if (call->error == 0 || call->error == -ECONNABORTED)
|
||||
call->responded = true;
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -436,12 +436,8 @@ static void __afs_put_server(struct afs_net *net, struct afs_server *server)
|
||||
static void afs_give_up_callbacks(struct afs_net *net, struct afs_server *server)
|
||||
{
|
||||
struct afs_addr_list *alist = rcu_access_pointer(server->addresses);
|
||||
struct afs_addr_cursor ac = {
|
||||
.alist = alist,
|
||||
.index = alist->preferred,
|
||||
};
|
||||
|
||||
afs_fs_give_up_all_callbacks(net, server, &ac, NULL);
|
||||
afs_fs_give_up_all_callbacks(net, server, &alist->addrs[alist->preferred], NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -46,12 +46,12 @@ static void afs_done_one_vl_probe(struct afs_vlserver *server, bool wake_up)
|
||||
*/
|
||||
void afs_vlserver_probe_result(struct afs_call *call)
|
||||
{
|
||||
struct afs_addr_list *alist = call->alist;
|
||||
struct afs_addr_list *alist = call->probe_alist;
|
||||
struct afs_vlserver *server = call->vlserver;
|
||||
struct afs_address *addr = &alist->addrs[call->addr_ix];
|
||||
struct afs_address *addr = &alist->addrs[call->probe_index];
|
||||
unsigned int server_index = call->server_index;
|
||||
unsigned int rtt_us = 0;
|
||||
unsigned int index = call->addr_ix;
|
||||
unsigned int index = call->probe_index;
|
||||
bool have_result = false;
|
||||
int ret = call->error;
|
||||
|
||||
@ -148,25 +148,25 @@ static bool afs_do_probe_vlserver(struct afs_net *net,
|
||||
unsigned int server_index,
|
||||
struct afs_error *_e)
|
||||
{
|
||||
struct afs_addr_cursor ac = {
|
||||
.index = 0,
|
||||
};
|
||||
struct afs_addr_list *alist;
|
||||
struct afs_call *call;
|
||||
unsigned int index;
|
||||
bool in_progress = false;
|
||||
|
||||
_enter("%s", server->name);
|
||||
|
||||
read_lock(&server->lock);
|
||||
ac.alist = rcu_dereference_protected(server->addresses,
|
||||
lockdep_is_held(&server->lock));
|
||||
alist = rcu_dereference_protected(server->addresses,
|
||||
lockdep_is_held(&server->lock));
|
||||
afs_get_addrlist(alist, afs_alist_trace_get_vlprobe);
|
||||
read_unlock(&server->lock);
|
||||
|
||||
atomic_set(&server->probe_outstanding, ac.alist->nr_addrs);
|
||||
atomic_set(&server->probe_outstanding, 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++) {
|
||||
call = afs_vl_get_capabilities(net, &ac, key, server,
|
||||
for (index = 0; index < alist->nr_addrs; index++) {
|
||||
call = afs_vl_get_capabilities(net, alist, index, key, server,
|
||||
server_index);
|
||||
if (!IS_ERR(call)) {
|
||||
afs_prioritise_error(_e, call->error, call->abort_code);
|
||||
@ -178,6 +178,7 @@ static bool afs_do_probe_vlserver(struct afs_net *net,
|
||||
}
|
||||
}
|
||||
|
||||
afs_put_addrlist(alist, afs_alist_trace_put_vlprobe);
|
||||
return in_progress;
|
||||
}
|
||||
|
||||
|
||||
@ -17,6 +17,8 @@
|
||||
bool afs_begin_vlserver_operation(struct afs_vl_cursor *vc, struct afs_cell *cell,
|
||||
struct key *key)
|
||||
{
|
||||
static atomic_t debug_ids;
|
||||
|
||||
memset(vc, 0, sizeof(*vc));
|
||||
vc->cell = cell;
|
||||
vc->key = key;
|
||||
@ -29,6 +31,7 @@ bool afs_begin_vlserver_operation(struct afs_vl_cursor *vc, struct afs_cell *cel
|
||||
return false;
|
||||
}
|
||||
|
||||
vc->debug_id = atomic_inc_return(&debug_ids);
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -89,17 +92,18 @@ static bool afs_start_vl_iteration(struct afs_vl_cursor *vc)
|
||||
*/
|
||||
bool afs_select_vlserver(struct afs_vl_cursor *vc)
|
||||
{
|
||||
struct afs_addr_list *alist;
|
||||
struct afs_addr_list *alist = vc->alist;
|
||||
struct afs_vlserver *vlserver;
|
||||
unsigned long set, failed;
|
||||
unsigned int rtt;
|
||||
s32 abort_code = vc->call_abort_code;
|
||||
int error = vc->call_error, i;
|
||||
|
||||
vc->nr_iterations++;
|
||||
|
||||
_enter("%lx[%d],%lx[%d],%d,%d",
|
||||
vc->untried_servers, vc->server_index,
|
||||
vc->ac.tried, vc->ac.index,
|
||||
_enter("VC=%x+%x,%d{%lx},%d{%lx},%d,%d",
|
||||
vc->debug_id, vc->nr_iterations, vc->server_index, vc->untried_servers,
|
||||
vc->addr_index, vc->addr_tried,
|
||||
error, abort_code);
|
||||
|
||||
if (vc->flags & AFS_VL_CURSOR_STOP) {
|
||||
@ -165,7 +169,13 @@ bool afs_select_vlserver(struct afs_vl_cursor *vc)
|
||||
|
||||
restart_from_beginning:
|
||||
_debug("restart");
|
||||
afs_end_cursor(&vc->ac);
|
||||
if (vc->call_responded &&
|
||||
vc->addr_index != vc->alist->preferred &&
|
||||
test_bit(alist->preferred, &vc->addr_tried))
|
||||
WRITE_ONCE(alist->preferred, vc->addr_index);
|
||||
afs_put_addrlist(alist, afs_alist_trace_put_vlrotate_restart);
|
||||
alist = vc->alist = NULL;
|
||||
|
||||
afs_put_vlserverlist(vc->cell->net, vc->server_list);
|
||||
vc->server_list = NULL;
|
||||
if (vc->flags & AFS_VL_CURSOR_RETRIED)
|
||||
@ -173,6 +183,7 @@ restart_from_beginning:
|
||||
vc->flags |= AFS_VL_CURSOR_RETRIED;
|
||||
start:
|
||||
_debug("start");
|
||||
ASSERTCMP(alist, ==, NULL);
|
||||
|
||||
if (!afs_start_vl_iteration(vc))
|
||||
goto failed;
|
||||
@ -185,6 +196,7 @@ start:
|
||||
|
||||
pick_server:
|
||||
_debug("pick [%lx]", vc->untried_servers);
|
||||
ASSERTCMP(alist, ==, NULL);
|
||||
|
||||
error = afs_wait_for_vl_probes(vc->server_list, vc->untried_servers);
|
||||
if (error < 0) {
|
||||
@ -222,7 +234,6 @@ selected_server:
|
||||
* 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->server_index].server;
|
||||
vc->server = vlserver;
|
||||
|
||||
@ -231,30 +242,48 @@ selected_server:
|
||||
read_lock(&vlserver->lock);
|
||||
alist = rcu_dereference_protected(vlserver->addresses,
|
||||
lockdep_is_held(&vlserver->lock));
|
||||
afs_get_addrlist(alist, afs_alist_trace_get_vlrotate_set);
|
||||
vc->alist = afs_get_addrlist(alist, afs_alist_trace_get_vlrotate_set);
|
||||
read_unlock(&vlserver->lock);
|
||||
|
||||
memset(&vc->ac, 0, sizeof(vc->ac));
|
||||
vc->ac.alist = alist;
|
||||
vc->ac.index = -1;
|
||||
vc->addr_tried = 0;
|
||||
vc->addr_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))
|
||||
set = READ_ONCE(alist->responded);
|
||||
failed = READ_ONCE(alist->probe_failed);
|
||||
vc->addr_index = READ_ONCE(alist->preferred);
|
||||
|
||||
_debug("%lx-%lx-%lx,%d", set, failed, vc->addr_tried, vc->addr_index);
|
||||
|
||||
set &= ~(failed | vc->addr_tried);
|
||||
|
||||
if (!set)
|
||||
goto next_server;
|
||||
|
||||
_debug("VL address %d/%d", vc->ac.index, vc->ac.alist->nr_addrs);
|
||||
if (!test_bit(vc->addr_index, &set))
|
||||
vc->addr_index = __ffs(set);
|
||||
|
||||
set_bit(vc->addr_index, &vc->addr_tried);
|
||||
vc->alist = alist;
|
||||
|
||||
_debug("VL address %d/%d", vc->addr_index, alist->nr_addrs);
|
||||
|
||||
vc->call_responded = false;
|
||||
_leave(" = t %pISpc", rxrpc_kernel_remote_addr(vc->ac.alist->addrs[vc->ac.index].peer));
|
||||
_leave(" = t %pISpc", rxrpc_kernel_remote_addr(alist->addrs[vc->addr_index].peer));
|
||||
return true;
|
||||
|
||||
next_server:
|
||||
_debug("next");
|
||||
afs_end_cursor(&vc->ac);
|
||||
ASSERT(alist);
|
||||
if (vc->call_responded &&
|
||||
vc->addr_index != alist->preferred &&
|
||||
test_bit(alist->preferred, &vc->addr_tried))
|
||||
WRITE_ONCE(alist->preferred, vc->addr_index);
|
||||
afs_put_addrlist(alist, afs_alist_trace_put_vlrotate_next);
|
||||
alist = vc->alist = NULL;
|
||||
goto pick_server;
|
||||
|
||||
no_more_servers:
|
||||
@ -274,8 +303,15 @@ no_more_servers:
|
||||
}
|
||||
|
||||
failed:
|
||||
if (alist) {
|
||||
if (vc->call_responded &&
|
||||
vc->addr_index != alist->preferred &&
|
||||
test_bit(alist->preferred, &vc->addr_tried))
|
||||
WRITE_ONCE(alist->preferred, vc->addr_index);
|
||||
afs_put_addrlist(alist, afs_alist_trace_put_vlrotate_fail);
|
||||
alist = vc->alist = NULL;
|
||||
}
|
||||
vc->flags |= AFS_VL_CURSOR_STOP;
|
||||
afs_end_cursor(&vc->ac);
|
||||
_leave(" = f [failed %d]", vc->cumul_error.error);
|
||||
return false;
|
||||
}
|
||||
@ -299,8 +335,8 @@ static void afs_vl_dump_edestaddrreq(const struct afs_vl_cursor *vc)
|
||||
pr_notice("DNS: src=%u st=%u lc=%x\n",
|
||||
cell->dns_source, cell->dns_status, cell->dns_lookup_count);
|
||||
pr_notice("VC: ut=%lx ix=%u ni=%hu fl=%hx err=%hd\n",
|
||||
vc->untried_servers, vc->server_index, vc->nr_iterations, vc->flags,
|
||||
vc->cumul_error.error);
|
||||
vc->untried_servers, vc->server_index, vc->nr_iterations,
|
||||
vc->flags, vc->cumul_error.error);
|
||||
pr_notice("VC: call er=%d ac=%d r=%u\n",
|
||||
vc->call_error, vc->call_abort_code, vc->call_responded);
|
||||
|
||||
@ -320,14 +356,13 @@ static void afs_vl_dump_edestaddrreq(const struct afs_vl_cursor *vc)
|
||||
a->preferred);
|
||||
pr_notice("VC: - R=%lx F=%lx\n",
|
||||
a->responded, a->probe_failed);
|
||||
if (a == vc->ac.alist)
|
||||
if (a == vc->alist)
|
||||
pr_notice("VC: - current\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pr_notice("AC: t=%lx ax=%u ni=%u\n",
|
||||
vc->ac.tried, vc->ac.index, vc->ac.nr_iterations);
|
||||
pr_notice("AC: t=%lx ax=%u\n", vc->addr_tried, vc->addr_index);
|
||||
rcu_read_unlock();
|
||||
}
|
||||
|
||||
@ -338,6 +373,8 @@ int afs_end_vlserver_operation(struct afs_vl_cursor *vc)
|
||||
{
|
||||
struct afs_net *net = vc->cell->net;
|
||||
|
||||
_enter("VC=%x+%x", vc->debug_id, vc->nr_iterations);
|
||||
|
||||
switch (vc->cumul_error.error) {
|
||||
case -EDESTADDRREQ:
|
||||
case -EADDRNOTAVAIL:
|
||||
@ -347,7 +384,14 @@ int afs_end_vlserver_operation(struct afs_vl_cursor *vc)
|
||||
break;
|
||||
}
|
||||
|
||||
afs_end_cursor(&vc->ac);
|
||||
if (vc->alist) {
|
||||
if (vc->call_responded &&
|
||||
vc->addr_index != vc->alist->preferred &&
|
||||
test_bit(vc->alist->preferred, &vc->addr_tried))
|
||||
WRITE_ONCE(vc->alist->preferred, vc->addr_index);
|
||||
afs_put_addrlist(vc->alist, afs_alist_trace_put_vlrotate_end);
|
||||
vc->alist = NULL;
|
||||
}
|
||||
afs_put_vlserverlist(net, vc->server_list);
|
||||
return vc->cumul_error.error;
|
||||
}
|
||||
|
||||
@ -149,7 +149,7 @@ struct afs_vldb_entry *afs_vl_get_entry_by_name_u(struct afs_vl_cursor *vc,
|
||||
call->key = vc->key;
|
||||
call->ret_vldb = entry;
|
||||
call->max_lifespan = AFS_VL_MAX_LIFESPAN;
|
||||
call->peer = rxrpc_kernel_get_peer(vc->ac.alist->addrs[vc->ac.index].peer);
|
||||
call->peer = rxrpc_kernel_get_peer(vc->alist->addrs[vc->addr_index].peer);
|
||||
call->service_id = vc->server->service_id;
|
||||
|
||||
/* Marshall the parameters */
|
||||
@ -161,8 +161,8 @@ struct afs_vldb_entry *afs_vl_get_entry_by_name_u(struct afs_vl_cursor *vc,
|
||||
memset((void *)bp + volnamesz, 0, padsz);
|
||||
|
||||
trace_afs_make_vl_call(call);
|
||||
afs_make_call(&vc->ac, call, GFP_KERNEL);
|
||||
afs_wait_for_call_to_complete(call, &vc->ac);
|
||||
afs_make_call(call, GFP_KERNEL);
|
||||
afs_wait_for_call_to_complete(call);
|
||||
vc->call_abort_code = call->abort_code;
|
||||
vc->call_error = call->error;
|
||||
vc->call_responded = call->responded;
|
||||
@ -290,7 +290,7 @@ struct afs_addr_list *afs_vl_get_addrs_u(struct afs_vl_cursor *vc,
|
||||
call->key = vc->key;
|
||||
call->ret_alist = NULL;
|
||||
call->max_lifespan = AFS_VL_MAX_LIFESPAN;
|
||||
call->peer = rxrpc_kernel_get_peer(vc->ac.alist->addrs[vc->ac.index].peer);
|
||||
call->peer = rxrpc_kernel_get_peer(vc->alist->addrs[vc->addr_index].peer);
|
||||
call->service_id = vc->server->service_id;
|
||||
|
||||
/* Marshall the parameters */
|
||||
@ -310,8 +310,8 @@ struct afs_addr_list *afs_vl_get_addrs_u(struct afs_vl_cursor *vc,
|
||||
r->uuid.node[i] = htonl(u->node[i]);
|
||||
|
||||
trace_afs_make_vl_call(call);
|
||||
afs_make_call(&vc->ac, call, GFP_KERNEL);
|
||||
afs_wait_for_call_to_complete(call, &vc->ac);
|
||||
afs_make_call(call, GFP_KERNEL);
|
||||
afs_wait_for_call_to_complete(call);
|
||||
vc->call_abort_code = call->abort_code;
|
||||
vc->call_error = call->error;
|
||||
vc->call_responded = call->responded;
|
||||
@ -371,6 +371,7 @@ static int afs_deliver_vl_get_capabilities(struct afs_call *call)
|
||||
|
||||
static void afs_destroy_vl_get_capabilities(struct afs_call *call)
|
||||
{
|
||||
afs_put_addrlist(call->probe_alist, afs_alist_trace_put_vlgetcaps);
|
||||
afs_put_vlserver(call->net, call->vlserver);
|
||||
afs_flat_call_destructor(call);
|
||||
}
|
||||
@ -394,7 +395,8 @@ static const struct afs_call_type afs_RXVLGetCapabilities = {
|
||||
* other end supports.
|
||||
*/
|
||||
struct afs_call *afs_vl_get_capabilities(struct afs_net *net,
|
||||
struct afs_addr_cursor *ac,
|
||||
struct afs_addr_list *alist,
|
||||
unsigned int addr_index,
|
||||
struct key *key,
|
||||
struct afs_vlserver *server,
|
||||
unsigned int server_index)
|
||||
@ -411,7 +413,9 @@ struct afs_call *afs_vl_get_capabilities(struct afs_net *net,
|
||||
call->key = key;
|
||||
call->vlserver = afs_get_vlserver(server);
|
||||
call->server_index = server_index;
|
||||
call->peer = rxrpc_kernel_get_peer(ac->alist->addrs[ac->index].peer);
|
||||
call->peer = rxrpc_kernel_get_peer(alist->addrs[addr_index].peer);
|
||||
call->probe_alist = afs_get_addrlist(alist, afs_alist_trace_get_vlgetcaps);
|
||||
call->probe_index = addr_index;
|
||||
call->service_id = server->service_id;
|
||||
call->upgrade = true;
|
||||
call->async = true;
|
||||
@ -423,7 +427,7 @@ struct afs_call *afs_vl_get_capabilities(struct afs_net *net,
|
||||
|
||||
/* Can't take a ref on server */
|
||||
trace_afs_make_vl_call(call);
|
||||
afs_make_call(ac, call, GFP_KERNEL);
|
||||
afs_make_call(call, GFP_KERNEL);
|
||||
return call;
|
||||
}
|
||||
|
||||
@ -658,7 +662,7 @@ struct afs_addr_list *afs_yfsvl_get_endpoints(struct afs_vl_cursor *vc,
|
||||
call->key = vc->key;
|
||||
call->ret_alist = NULL;
|
||||
call->max_lifespan = AFS_VL_MAX_LIFESPAN;
|
||||
call->peer = rxrpc_kernel_get_peer(vc->ac.alist->addrs[vc->ac.index].peer);
|
||||
call->peer = rxrpc_kernel_get_peer(vc->alist->addrs[vc->addr_index].peer);
|
||||
call->service_id = vc->server->service_id;
|
||||
|
||||
/* Marshall the parameters */
|
||||
@ -668,8 +672,8 @@ struct afs_addr_list *afs_yfsvl_get_endpoints(struct afs_vl_cursor *vc,
|
||||
memcpy(bp, uuid, sizeof(*uuid)); /* Type opr_uuid */
|
||||
|
||||
trace_afs_make_vl_call(call);
|
||||
afs_make_call(&vc->ac, call, GFP_KERNEL);
|
||||
afs_wait_for_call_to_complete(call, &vc->ac);
|
||||
afs_make_call(call, GFP_KERNEL);
|
||||
afs_wait_for_call_to_complete(call);
|
||||
vc->call_abort_code = call->abort_code;
|
||||
vc->call_error = call->error;
|
||||
vc->call_responded = call->responded;
|
||||
@ -777,7 +781,7 @@ char *afs_yfsvl_get_cell_name(struct afs_vl_cursor *vc)
|
||||
call->key = vc->key;
|
||||
call->ret_str = NULL;
|
||||
call->max_lifespan = AFS_VL_MAX_LIFESPAN;
|
||||
call->peer = rxrpc_kernel_get_peer(vc->ac.alist->addrs[vc->ac.index].peer);
|
||||
call->peer = rxrpc_kernel_get_peer(vc->alist->addrs[vc->addr_index].peer);
|
||||
call->service_id = vc->server->service_id;
|
||||
|
||||
/* marshall the parameters */
|
||||
@ -786,8 +790,8 @@ char *afs_yfsvl_get_cell_name(struct afs_vl_cursor *vc)
|
||||
|
||||
/* Can't take a ref on server */
|
||||
trace_afs_make_vl_call(call);
|
||||
afs_make_call(&vc->ac, call, GFP_KERNEL);
|
||||
afs_wait_for_call_to_complete(call, &vc->ac);
|
||||
afs_make_call(call, GFP_KERNEL);
|
||||
afs_wait_for_call_to_complete(call);
|
||||
vc->call_abort_code = call->abort_code;
|
||||
vc->call_error = call->error;
|
||||
vc->call_responded = call->responded;
|
||||
|
||||
@ -204,21 +204,31 @@ enum yfs_cm_operation {
|
||||
|
||||
#define afs_alist_traces \
|
||||
EM(afs_alist_trace_alloc, "ALLOC ") \
|
||||
EM(afs_alist_trace_get_getcaps, "GET getcap") \
|
||||
EM(afs_alist_trace_get_fsrotate_set, "GET fs-rot") \
|
||||
EM(afs_alist_trace_get_make_call, "GET mkcall") \
|
||||
EM(afs_alist_trace_get_probe, "GET probe ") \
|
||||
EM(afs_alist_trace_get_vlgetcaps, "GET vgtcap") \
|
||||
EM(afs_alist_trace_get_vlprobe, "GET vprobe") \
|
||||
EM(afs_alist_trace_get_vlrotate_set, "GET vl-rot") \
|
||||
EM(afs_alist_trace_put_call, "PUT call ") \
|
||||
EM(afs_alist_trace_put_end_cursor, "PUT endcur") \
|
||||
EM(afs_alist_trace_put_getaddru, "PUT GtAdrU") \
|
||||
EM(afs_alist_trace_put_getcaps, "PUT getcap") \
|
||||
EM(afs_alist_trace_put_next_server, "PUT nx-srv") \
|
||||
EM(afs_alist_trace_put_op_failed, "PUT op-fai") \
|
||||
EM(afs_alist_trace_put_operation, "PUT op ") \
|
||||
EM(afs_alist_trace_put_parse_empty, "PUT p-empt") \
|
||||
EM(afs_alist_trace_put_parse_error, "PUT p-err ") \
|
||||
EM(afs_alist_trace_put_probe, "PUT probe ") \
|
||||
EM(afs_alist_trace_put_retry_server, "PUT retry ") \
|
||||
EM(afs_alist_trace_put_restart_rotate, "PUT rstrot") \
|
||||
EM(afs_alist_trace_put_server, "PUT server") \
|
||||
EM(afs_alist_trace_put_server_dup, "PUT sv-dup") \
|
||||
EM(afs_alist_trace_put_server_oom, "PUT sv-oom") \
|
||||
EM(afs_alist_trace_put_server_update, "PUT sv-upd") \
|
||||
EM(afs_alist_trace_put_vlgetcaps, "PUT vgtcap") \
|
||||
EM(afs_alist_trace_put_vlprobe, "PUT vprobe") \
|
||||
EM(afs_alist_trace_put_vlrotate_end, "PUT vr-end") \
|
||||
EM(afs_alist_trace_put_vlrotate_fail, "PUT vr-fai") \
|
||||
EM(afs_alist_trace_put_vlrotate_next, "PUT vr-nxt") \
|
||||
EM(afs_alist_trace_put_vlrotate_restart,"PUT vr-rst") \
|
||||
EM(afs_alist_trace_put_vlserver, "PUT vlsrvr") \
|
||||
EM(afs_alist_trace_put_vlserver_old, "PUT vs-old") \
|
||||
E_(afs_alist_trace_free, "FREE ")
|
||||
|
||||
Loading…
Reference in New Issue
Block a user