mirror of
https://github.com/torvalds/linux.git
synced 2024-12-14 15:13:52 +00:00
22650f1481
The generic/464 xfstest causes kAFS to emit occasional warnings of the
form:
kAFS: vnode modified {100055:8a} 30->31 YFS.StoreData64 (c=6015)
This indicates that the data version received back from the server did not
match the expected value (the DV should be incremented monotonically for
each individual modification op committed to a vnode).
What is happening is that a lookup call is doing a bulk status fetch
speculatively on a bunch of vnodes in a directory besides getting the
status of the vnode it's actually interested in. This is racing with a
StoreData operation (though it could also occur with, say, a MakeDir op).
On the client, a modification operation locks the vnode, but the bulk
status fetch only locks the parent directory, so no ordering is imposed
there (thereby avoiding an avenue to deadlock).
On the server, the StoreData op handler doesn't lock the vnode until it's
received all the request data, and downgrades the lock after committing the
data until it has finished sending change notifications to other clients -
which allows the status fetch to occur before it has finished.
This means that:
- a status fetch can access the target vnode either side of the exclusive
section of the modification
- the status fetch could start before the modification, yet finish after,
and vice-versa.
- the status fetch and the modification RPCs can complete in either order.
- the status fetch can return either the before or the after DV from the
modification.
- the status fetch might regress the locally cached DV.
Some of these are handled by the previous fix[1], but that's not sufficient
because it checks the DV it received against the DV it cached at the start
of the op, but the DV might've been updated in the meantime by a locally
generated modification op.
Fix this by the following means:
(1) Keep track of when we're performing a modification operation on a
vnode. This is done by marking vnode parameters with a 'modification'
note that causes the AFS_VNODE_MODIFYING flag to be set on the vnode
for the duration.
(2) Alter the speculation race detection to ignore speculative status
fetches if either the vnode is marked as being modified or the data
version number is not what we expected.
Note that whilst the "vnode modified" warning does get recovered from as it
causes the client to refetch the status at the next opportunity, it will
also invalidate the pagecache, so changes might get lost.
Fixes: a9e5c87ca7
("afs: Fix speculative status fetch going out of order wrt to modifications")
Reported-by: Marc Dionne <marc.dionne@auristor.com>
Signed-off-by: David Howells <dhowells@redhat.com>
Tested-and-reviewed-by: Marc Dionne <marc.dionne@auristor.com>
cc: linux-afs@lists.infradead.org
Link: https://lore.kernel.org/r/160605082531.252452.14708077925602709042.stgit@warthog.procyon.org.uk/ [1]
Link: https://lore.kernel.org/linux-fsdevel/161961335926.39335.2552653972195467566.stgit@warthog.procyon.org.uk/ # v1
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
260 lines
5.8 KiB
C
260 lines
5.8 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/* Fileserver-directed operation handling.
|
|
*
|
|
* Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
|
|
* Written by David Howells (dhowells@redhat.com)
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/fs.h>
|
|
#include "internal.h"
|
|
|
|
static atomic_t afs_operation_debug_counter;
|
|
|
|
/*
|
|
* Create an operation against a volume.
|
|
*/
|
|
struct afs_operation *afs_alloc_operation(struct key *key, struct afs_volume *volume)
|
|
{
|
|
struct afs_operation *op;
|
|
|
|
_enter("");
|
|
|
|
op = kzalloc(sizeof(*op), GFP_KERNEL);
|
|
if (!op)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
if (!key) {
|
|
key = afs_request_key(volume->cell);
|
|
if (IS_ERR(key)) {
|
|
kfree(op);
|
|
return ERR_CAST(key);
|
|
}
|
|
} else {
|
|
key_get(key);
|
|
}
|
|
|
|
op->key = key;
|
|
op->volume = afs_get_volume(volume, afs_volume_trace_get_new_op);
|
|
op->net = volume->cell->net;
|
|
op->cb_v_break = volume->cb_v_break;
|
|
op->debug_id = atomic_inc_return(&afs_operation_debug_counter);
|
|
op->error = -EDESTADDRREQ;
|
|
op->ac.error = SHRT_MAX;
|
|
|
|
_leave(" = [op=%08x]", op->debug_id);
|
|
return op;
|
|
}
|
|
|
|
/*
|
|
* Lock the vnode(s) being operated upon.
|
|
*/
|
|
static bool afs_get_io_locks(struct afs_operation *op)
|
|
{
|
|
struct afs_vnode *vnode = op->file[0].vnode;
|
|
struct afs_vnode *vnode2 = op->file[1].vnode;
|
|
|
|
_enter("");
|
|
|
|
if (op->flags & AFS_OPERATION_UNINTR) {
|
|
mutex_lock(&vnode->io_lock);
|
|
op->flags |= AFS_OPERATION_LOCK_0;
|
|
_leave(" = t [1]");
|
|
return true;
|
|
}
|
|
|
|
if (!vnode2 || !op->file[1].need_io_lock || vnode == vnode2)
|
|
vnode2 = NULL;
|
|
|
|
if (vnode2 > vnode)
|
|
swap(vnode, vnode2);
|
|
|
|
if (mutex_lock_interruptible(&vnode->io_lock) < 0) {
|
|
op->error = -ERESTARTSYS;
|
|
op->flags |= AFS_OPERATION_STOP;
|
|
_leave(" = f [I 0]");
|
|
return false;
|
|
}
|
|
op->flags |= AFS_OPERATION_LOCK_0;
|
|
|
|
if (vnode2) {
|
|
if (mutex_lock_interruptible_nested(&vnode2->io_lock, 1) < 0) {
|
|
op->error = -ERESTARTSYS;
|
|
op->flags |= AFS_OPERATION_STOP;
|
|
mutex_unlock(&vnode->io_lock);
|
|
op->flags &= ~AFS_OPERATION_LOCK_0;
|
|
_leave(" = f [I 1]");
|
|
return false;
|
|
}
|
|
op->flags |= AFS_OPERATION_LOCK_1;
|
|
}
|
|
|
|
_leave(" = t [2]");
|
|
return true;
|
|
}
|
|
|
|
static void afs_drop_io_locks(struct afs_operation *op)
|
|
{
|
|
struct afs_vnode *vnode = op->file[0].vnode;
|
|
struct afs_vnode *vnode2 = op->file[1].vnode;
|
|
|
|
_enter("");
|
|
|
|
if (op->flags & AFS_OPERATION_LOCK_1)
|
|
mutex_unlock(&vnode2->io_lock);
|
|
if (op->flags & AFS_OPERATION_LOCK_0)
|
|
mutex_unlock(&vnode->io_lock);
|
|
}
|
|
|
|
static void afs_prepare_vnode(struct afs_operation *op, struct afs_vnode_param *vp,
|
|
unsigned int index)
|
|
{
|
|
struct afs_vnode *vnode = vp->vnode;
|
|
|
|
if (vnode) {
|
|
vp->fid = vnode->fid;
|
|
vp->dv_before = vnode->status.data_version;
|
|
vp->cb_break_before = afs_calc_vnode_cb_break(vnode);
|
|
if (vnode->lock_state != AFS_VNODE_LOCK_NONE)
|
|
op->flags |= AFS_OPERATION_CUR_ONLY;
|
|
if (vp->modification)
|
|
set_bit(AFS_VNODE_MODIFYING, &vnode->flags);
|
|
}
|
|
|
|
if (vp->fid.vnode)
|
|
_debug("PREP[%u] {%llx:%llu.%u}",
|
|
index, vp->fid.vid, vp->fid.vnode, vp->fid.unique);
|
|
}
|
|
|
|
/*
|
|
* Begin an operation on the fileserver.
|
|
*
|
|
* Fileserver operations are serialised on the server by vnode, so we serialise
|
|
* them here also using the io_lock.
|
|
*/
|
|
bool afs_begin_vnode_operation(struct afs_operation *op)
|
|
{
|
|
struct afs_vnode *vnode = op->file[0].vnode;
|
|
|
|
ASSERT(vnode);
|
|
|
|
_enter("");
|
|
|
|
if (op->file[0].need_io_lock)
|
|
if (!afs_get_io_locks(op))
|
|
return false;
|
|
|
|
afs_prepare_vnode(op, &op->file[0], 0);
|
|
afs_prepare_vnode(op, &op->file[1], 1);
|
|
op->cb_v_break = op->volume->cb_v_break;
|
|
_leave(" = true");
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* Tidy up a filesystem cursor and unlock the vnode.
|
|
*/
|
|
static void afs_end_vnode_operation(struct afs_operation *op)
|
|
{
|
|
_enter("");
|
|
|
|
if (op->error == -EDESTADDRREQ ||
|
|
op->error == -EADDRNOTAVAIL ||
|
|
op->error == -ENETUNREACH ||
|
|
op->error == -EHOSTUNREACH)
|
|
afs_dump_edestaddrreq(op);
|
|
|
|
afs_drop_io_locks(op);
|
|
|
|
if (op->error == -ECONNABORTED)
|
|
op->error = afs_abort_to_error(op->ac.abort_code);
|
|
}
|
|
|
|
/*
|
|
* Wait for an in-progress operation to complete.
|
|
*/
|
|
void afs_wait_for_operation(struct afs_operation *op)
|
|
{
|
|
_enter("");
|
|
|
|
while (afs_select_fileserver(op)) {
|
|
op->cb_s_break = op->server->cb_s_break;
|
|
if (test_bit(AFS_SERVER_FL_IS_YFS, &op->server->flags) &&
|
|
op->ops->issue_yfs_rpc)
|
|
op->ops->issue_yfs_rpc(op);
|
|
else if (op->ops->issue_afs_rpc)
|
|
op->ops->issue_afs_rpc(op);
|
|
else
|
|
op->ac.error = -ENOTSUPP;
|
|
|
|
if (op->call)
|
|
op->error = afs_wait_for_call_to_complete(op->call, &op->ac);
|
|
}
|
|
|
|
switch (op->error) {
|
|
case 0:
|
|
_debug("success");
|
|
op->ops->success(op);
|
|
break;
|
|
case -ECONNABORTED:
|
|
if (op->ops->aborted)
|
|
op->ops->aborted(op);
|
|
fallthrough;
|
|
default:
|
|
if (op->ops->failed)
|
|
op->ops->failed(op);
|
|
break;
|
|
}
|
|
|
|
afs_end_vnode_operation(op);
|
|
|
|
if (op->error == 0 && op->ops->edit_dir) {
|
|
_debug("edit_dir");
|
|
op->ops->edit_dir(op);
|
|
}
|
|
_leave("");
|
|
}
|
|
|
|
/*
|
|
* Dispose of an operation.
|
|
*/
|
|
int afs_put_operation(struct afs_operation *op)
|
|
{
|
|
int i, ret = op->error;
|
|
|
|
_enter("op=%08x,%d", op->debug_id, ret);
|
|
|
|
if (op->ops && op->ops->put)
|
|
op->ops->put(op);
|
|
if (op->file[0].modification)
|
|
clear_bit(AFS_VNODE_MODIFYING, &op->file[0].vnode->flags);
|
|
if (op->file[1].modification && op->file[1].vnode != op->file[0].vnode)
|
|
clear_bit(AFS_VNODE_MODIFYING, &op->file[1].vnode->flags);
|
|
if (op->file[0].put_vnode)
|
|
iput(&op->file[0].vnode->vfs_inode);
|
|
if (op->file[1].put_vnode)
|
|
iput(&op->file[1].vnode->vfs_inode);
|
|
|
|
if (op->more_files) {
|
|
for (i = 0; i < op->nr_files - 2; i++)
|
|
if (op->more_files[i].put_vnode)
|
|
iput(&op->more_files[i].vnode->vfs_inode);
|
|
kfree(op->more_files);
|
|
}
|
|
|
|
afs_end_cursor(&op->ac);
|
|
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);
|
|
kfree(op);
|
|
return ret;
|
|
}
|
|
|
|
int afs_do_sync_operation(struct afs_operation *op)
|
|
{
|
|
afs_begin_vnode_operation(op);
|
|
afs_wait_for_operation(op);
|
|
return afs_put_operation(op);
|
|
}
|