Commit e49c7b2f authored by David Howells's avatar David Howells

afs: Build an abstraction around an "operation" concept

Turn the afs_operation struct into the main way that most fileserver
operations are managed.  Various things are added to the struct, including
the following:

 (1) All the parameters and results of the relevant operations are moved
     into it, removing corresponding fields from the afs_call struct.
     afs_call gets a pointer to the op.

 (2) The target volume is made the main focus of the operation, rather than
     the target vnode(s), and a bunch of op->vnode->volume are made
     op->volume instead.

 (3) Two vnode records are defined (op->file[]) for the vnode(s) involved
     in most operations.  The vnode record (struct afs_vnode_param)
     contains:

	- The vnode pointer.

	- The fid of the vnode to be included in the parameters or that was
          returned in the reply (eg. FS.MakeDir).

	- The status and callback information that may be returned in the
     	  reply about the vnode.

	- Callback break and data version tracking for detecting
          simultaneous third-parth changes.

 (4) Pointers to dentries to be updated with new inodes.

 (5) An operations table pointer.  The table includes pointers to functions
     for issuing AFS and YFS-variant RPCs, handling the success and abort
     of an operation and handling post-I/O-lock local editing of a
     directory.

To make this work, the following function restructuring is made:

 (A) The rotation loop that issues calls to fileservers that can be found
     in each function that wants to issue an RPC (such as afs_mkdir()) is
     extracted out into common code, in a new file called fs_operation.c.

 (B) The rotation loops, such as the one in afs_mkdir(), are replaced with
     a much smaller piece of code that allocates an operation, sets the
     parameters and then calls out to the common code to do the actual
     work.

 (C) The code for handling the success and failure of an operation are
     moved into operation functions (as (5) above) and these are called
     from the core code at appropriate times.

 (D) The pseudo inode getting stuff used by the dynamic root code is moved
     over into dynroot.c.

 (E) struct afs_iget_data is absorbed into the operation struct and
     afs_iget() expects to be given an op pointer and a vnode record.

 (F) Point (E) doesn't work for the root dir of a volume, but we know the
     FID in advance (it's always vnode 1, unique 1), so a separate inode
     getter, afs_root_iget(), is provided to special-case that.

 (G) The inode status init/update functions now also take an op and a vnode
     record.

 (H) The RPC marshalling functions now, for the most part, just take an
     afs_operation struct as their only argument.  All the data they need
     is held there.  The result delivery functions write their answers
     there as well.

 (I) The call is attached to the operation and then the operation core does
     the waiting.

And then the new operation code is, for the moment, made to just initialise
the operation, get the appropriate vnode I/O locks and do the same rotation
loop as before.

This lays the foundation for the following changes in the future:

 (*) Overhauling the rotation (again).

 (*) Support for asynchronous I/O, where the fileserver rotation must be
     done asynchronously also.
Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
parent a310082f
...@@ -18,6 +18,7 @@ kafs-y := \ ...@@ -18,6 +18,7 @@ kafs-y := \
file.o \ file.o \
flock.o \ flock.o \
fsclient.o \ fsclient.o \
fs_operation.o \
fs_probe.o \ fs_probe.o \
inode.o \ inode.o \
main.o \ main.o \
......
...@@ -146,7 +146,6 @@ struct afs_file_status { ...@@ -146,7 +146,6 @@ struct afs_file_status {
struct afs_status_cb { struct afs_status_cb {
struct afs_file_status status; struct afs_file_status status;
struct afs_callback callback; struct afs_callback callback;
unsigned int cb_break; /* Pre-op callback break counter */
bool have_status; /* True if status record was retrieved */ bool have_status; /* True if status record was retrieved */
bool have_cb; /* True if cb record was retrieved */ bool have_cb; /* True if cb record was retrieved */
bool have_error; /* True if status.abort_code indicates an error */ bool have_error; /* True if status.abort_code indicates an error */
......
...@@ -46,7 +46,6 @@ static struct afs_cb_interest *afs_create_interest(struct afs_server *server, ...@@ -46,7 +46,6 @@ static struct afs_cb_interest *afs_create_interest(struct afs_server *server,
refcount_set(&new->usage, 1); refcount_set(&new->usage, 1);
new->sb = vnode->vfs_inode.i_sb; new->sb = vnode->vfs_inode.i_sb;
new->vid = vnode->volume->vid;
new->server = afs_get_server(server, afs_server_trace_get_new_cbi); new->server = afs_get_server(server, afs_server_trace_get_new_cbi);
INIT_HLIST_NODE(&new->cb_vlink); INIT_HLIST_NODE(&new->cb_vlink);
...@@ -286,7 +285,6 @@ static void afs_break_one_callback(struct afs_server *server, ...@@ -286,7 +285,6 @@ static void afs_break_one_callback(struct afs_server *server,
struct afs_vol_interest *vi) struct afs_vol_interest *vi)
{ {
struct afs_cb_interest *cbi; struct afs_cb_interest *cbi;
struct afs_iget_data data;
struct afs_vnode *vnode; struct afs_vnode *vnode;
struct inode *inode; struct inode *inode;
...@@ -305,15 +303,12 @@ static void afs_break_one_callback(struct afs_server *server, ...@@ -305,15 +303,12 @@ static void afs_break_one_callback(struct afs_server *server,
afs_cb_break_for_volume_callback, false); afs_cb_break_for_volume_callback, false);
write_unlock(&volume->cb_v_break_lock); write_unlock(&volume->cb_v_break_lock);
} else { } else {
data.volume = NULL;
data.fid = *fid;
/* See if we can find a matching inode - even an I_NEW /* See if we can find a matching inode - even an I_NEW
* inode needs to be marked as it can have its callback * inode needs to be marked as it can have its callback
* broken before we finish setting up the local inode. * broken before we finish setting up the local inode.
*/ */
inode = find_inode_rcu(cbi->sb, fid->vnode, inode = find_inode_rcu(cbi->sb, fid->vnode,
afs_iget5_test, &data); afs_ilookup5_test_by_fid, fid);
if (inode) { if (inode) {
vnode = AFS_FS_I(inode); vnode = AFS_FS_I(inode);
afs_break_callback(vnode, afs_cb_break_for_callback); afs_break_callback(vnode, afs_cb_break_for_callback);
......
This diff is collapsed.
...@@ -12,6 +12,47 @@ ...@@ -12,6 +12,47 @@
#include <linux/fsnotify.h> #include <linux/fsnotify.h>
#include "internal.h" #include "internal.h"
static void afs_silly_rename_success(struct afs_operation *op)
{
_enter("op=%08x", op->debug_id);
afs_vnode_commit_status(op, &op->file[0]);
}
static void afs_silly_rename_edit_dir(struct afs_operation *op)
{
struct afs_vnode_param *dvp = &op->file[0];
struct afs_vnode *dvnode = dvp->vnode;
struct afs_vnode *vnode = AFS_FS_I(d_inode(op->dentry));
struct dentry *old = op->dentry;
struct dentry *new = op->dentry_2;
spin_lock(&old->d_lock);
old->d_flags |= DCACHE_NFSFS_RENAMED;
spin_unlock(&old->d_lock);
if (dvnode->silly_key != op->key) {
key_put(dvnode->silly_key);
dvnode->silly_key = key_get(op->key);
}
down_write(&dvnode->validate_lock);
if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) &&
dvnode->status.data_version == dvp->dv_before + dvp->dv_delta) {
afs_edit_dir_remove(dvnode, &old->d_name,
afs_edit_dir_for_silly_0);
afs_edit_dir_add(dvnode, &new->d_name,
&vnode->fid, afs_edit_dir_for_silly_1);
}
up_write(&dvnode->validate_lock);
}
static const struct afs_operation_ops afs_silly_rename_operation = {
.issue_afs_rpc = afs_fs_rename,
.issue_yfs_rpc = yfs_fs_rename,
.success = afs_silly_rename_success,
.edit_dir = afs_silly_rename_edit_dir,
};
/* /*
* Actually perform the silly rename step. * Actually perform the silly rename step.
*/ */
...@@ -19,56 +60,22 @@ static int afs_do_silly_rename(struct afs_vnode *dvnode, struct afs_vnode *vnode ...@@ -19,56 +60,22 @@ static int afs_do_silly_rename(struct afs_vnode *dvnode, struct afs_vnode *vnode
struct dentry *old, struct dentry *new, struct dentry *old, struct dentry *new,
struct key *key) struct key *key)
{ {
struct afs_operation fc; struct afs_operation *op;
struct afs_status_cb *scb;
afs_dataversion_t dir_data_version;
int ret = -ERESTARTSYS;
_enter("%pd,%pd", old, new); _enter("%pd,%pd", old, new);
scb = kzalloc(sizeof(struct afs_status_cb), GFP_KERNEL); op = afs_alloc_operation(key, dvnode->volume);
if (!scb) if (IS_ERR(op))
return -ENOMEM; return PTR_ERR(op);
trace_afs_silly_rename(vnode, false); afs_op_set_vnode(op, 0, dvnode);
if (afs_begin_vnode_operation(&fc, dvnode, key, true)) {
dir_data_version = dvnode->status.data_version + 1;
while (afs_select_fileserver(&fc)) {
fc.cb_break = afs_calc_vnode_cb_break(dvnode);
afs_fs_rename(&fc, old->d_name.name,
dvnode, new->d_name.name,
scb, scb);
}
afs_vnode_commit_status(&fc, dvnode, fc.cb_break,
&dir_data_version, scb);
ret = afs_end_vnode_operation(&fc);
}
if (ret == 0) { op->dentry = old;
spin_lock(&old->d_lock); op->dentry_2 = new;
old->d_flags |= DCACHE_NFSFS_RENAMED; op->ops = &afs_silly_rename_operation;
spin_unlock(&old->d_lock);
if (dvnode->silly_key != key) {
key_put(dvnode->silly_key);
dvnode->silly_key = key_get(key);
}
down_write(&dvnode->validate_lock);
if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) &&
dvnode->status.data_version == dir_data_version) {
afs_edit_dir_remove(dvnode, &old->d_name,
afs_edit_dir_for_silly_0);
afs_edit_dir_add(dvnode, &new->d_name,
&vnode->fid, afs_edit_dir_for_silly_1);
}
up_write(&dvnode->validate_lock);
}
kfree(scb); trace_afs_silly_rename(vnode, false);
_leave(" = %d", ret); return afs_do_sync_operation(op);
return ret;
} }
/** /**
...@@ -139,65 +146,66 @@ int afs_sillyrename(struct afs_vnode *dvnode, struct afs_vnode *vnode, ...@@ -139,65 +146,66 @@ int afs_sillyrename(struct afs_vnode *dvnode, struct afs_vnode *vnode,
return ret; return ret;
} }
static void afs_silly_unlink_success(struct afs_operation *op)
{
struct afs_vnode *vnode = op->file[1].vnode;
_enter("op=%08x", op->debug_id);
afs_check_for_remote_deletion(op, op->file[0].vnode);
afs_vnode_commit_status(op, &op->file[0]);
afs_vnode_commit_status(op, &op->file[1]);
afs_update_dentry_version(op, &op->file[0], op->dentry);
drop_nlink(&vnode->vfs_inode);
if (vnode->vfs_inode.i_nlink == 0) {
set_bit(AFS_VNODE_DELETED, &vnode->flags);
clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags);
}
}
static void afs_silly_unlink_edit_dir(struct afs_operation *op)
{
struct afs_vnode_param *dvp = &op->file[0];
struct afs_vnode *dvnode = dvp->vnode;
_enter("op=%08x", op->debug_id);
down_write(&dvnode->validate_lock);
if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) &&
dvnode->status.data_version == dvp->dv_before + dvp->dv_delta)
afs_edit_dir_remove(dvnode, &op->dentry->d_name,
afs_edit_dir_for_unlink);
up_write(&dvnode->validate_lock);
}
static const struct afs_operation_ops afs_silly_unlink_operation = {
.issue_afs_rpc = afs_fs_remove_file,
.issue_yfs_rpc = yfs_fs_remove_file,
.success = afs_silly_unlink_success,
.edit_dir = afs_silly_unlink_edit_dir,
};
/* /*
* Tell the server to remove a sillyrename file. * Tell the server to remove a sillyrename file.
*/ */
static int afs_do_silly_unlink(struct afs_vnode *dvnode, struct afs_vnode *vnode, static int afs_do_silly_unlink(struct afs_vnode *dvnode, struct afs_vnode *vnode,
struct dentry *dentry, struct key *key) struct dentry *dentry, struct key *key)
{ {
struct afs_operation fc; struct afs_operation *op;
struct afs_status_cb *scb;
int ret = -ERESTARTSYS;
_enter(""); _enter("");
scb = kcalloc(2, sizeof(struct afs_status_cb), GFP_KERNEL); op = afs_alloc_operation(NULL, dvnode->volume);
if (!scb) if (IS_ERR(op))
return -ENOMEM; return PTR_ERR(op);
trace_afs_silly_rename(vnode, true); afs_op_set_vnode(op, 0, dvnode);
if (afs_begin_vnode_operation(&fc, dvnode, key, false)) { afs_op_set_vnode(op, 1, vnode);
afs_dataversion_t dir_data_version = dvnode->status.data_version + 1;
while (afs_select_fileserver(&fc)) {
fc.cb_break = afs_calc_vnode_cb_break(dvnode);
if (test_bit(AFS_SERVER_FL_IS_YFS, &fc.cbi->server->flags) &&
!test_bit(AFS_SERVER_FL_NO_RM2, &fc.cbi->server->flags)) {
yfs_fs_remove_file2(&fc, vnode, dentry->d_name.name,
&scb[0], &scb[1]);
if (fc.ac.error != -ECONNABORTED ||
fc.ac.abort_code != RXGEN_OPCODE)
continue;
set_bit(AFS_SERVER_FL_NO_RM2, &fc.cbi->server->flags);
}
afs_fs_remove(&fc, vnode, dentry->d_name.name, false, &scb[0]);
}
afs_vnode_commit_status(&fc, dvnode, fc.cb_break, op->dentry = dentry;
&dir_data_version, &scb[0]); op->ops = &afs_silly_unlink_operation;
ret = afs_end_vnode_operation(&fc);
if (ret == 0) {
drop_nlink(&vnode->vfs_inode);
if (vnode->vfs_inode.i_nlink == 0) {
set_bit(AFS_VNODE_DELETED, &vnode->flags);
clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags);
}
}
if (ret == 0) {
down_write(&dvnode->validate_lock);
if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) &&
dvnode->status.data_version == dir_data_version)
afs_edit_dir_remove(dvnode, &dentry->d_name,
afs_edit_dir_for_unlink);
up_write(&dvnode->validate_lock);
}
}
kfree(scb); trace_afs_silly_rename(vnode, true);
_leave(" = %d", ret); return afs_do_sync_operation(op);
return ret;
} }
/* /*
......
...@@ -10,6 +10,99 @@ ...@@ -10,6 +10,99 @@
#include <linux/dns_resolver.h> #include <linux/dns_resolver.h>
#include "internal.h" #include "internal.h"
static atomic_t afs_autocell_ino;
/*
* iget5() comparator for inode created by autocell operations
*
* These pseudo inodes don't match anything.
*/
static int afs_iget5_pseudo_test(struct inode *inode, void *opaque)
{
return 0;
}
/*
* iget5() inode initialiser
*/
static int afs_iget5_pseudo_set(struct inode *inode, void *opaque)
{
struct afs_super_info *as = AFS_FS_S(inode->i_sb);
struct afs_vnode *vnode = AFS_FS_I(inode);
struct afs_fid *fid = opaque;
vnode->volume = as->volume;
vnode->fid = *fid;
inode->i_ino = fid->vnode;
inode->i_generation = fid->unique;
return 0;
}
/*
* Create an inode for a dynamic root directory or an autocell dynamic
* automount dir.
*/
struct inode *afs_iget_pseudo_dir(struct super_block *sb, bool root)
{
struct afs_super_info *as = AFS_FS_S(sb);
struct afs_vnode *vnode;
struct inode *inode;
struct afs_fid fid = {};
_enter("");
if (as->volume)
fid.vid = as->volume->vid;
if (root) {
fid.vnode = 1;
fid.unique = 1;
} else {
fid.vnode = atomic_inc_return(&afs_autocell_ino);
fid.unique = 0;
}
inode = iget5_locked(sb, fid.vnode,
afs_iget5_pseudo_test, afs_iget5_pseudo_set, &fid);
if (!inode) {
_leave(" = -ENOMEM");
return ERR_PTR(-ENOMEM);
}
_debug("GOT INODE %p { ino=%lu, vl=%llx, vn=%llx, u=%x }",
inode, inode->i_ino, fid.vid, fid.vnode, fid.unique);
vnode = AFS_FS_I(inode);
/* there shouldn't be an existing inode */
BUG_ON(!(inode->i_state & I_NEW));
inode->i_size = 0;
inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
if (root) {
inode->i_op = &afs_dynroot_inode_operations;
inode->i_fop = &simple_dir_operations;
} else {
inode->i_op = &afs_autocell_inode_operations;
}
set_nlink(inode, 2);
inode->i_uid = GLOBAL_ROOT_UID;
inode->i_gid = GLOBAL_ROOT_GID;
inode->i_ctime = inode->i_atime = inode->i_mtime = current_time(inode);
inode->i_blocks = 0;
inode->i_generation = 0;
set_bit(AFS_VNODE_PSEUDODIR, &vnode->flags);
if (!root) {
set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags);
inode->i_flags |= S_AUTOMOUNT;
}
inode->i_flags |= S_NOATIME;
unlock_new_inode(inode);
_leave(" = %p", inode);
return inode;
}
/* /*
* Probe to see if a cell may exist. This prevents positive dentries from * Probe to see if a cell may exist. This prevents positive dentries from
* being created unnecessarily. * being created unnecessarily.
......
...@@ -69,7 +69,7 @@ static const struct vm_operations_struct afs_vm_ops = { ...@@ -69,7 +69,7 @@ static const struct vm_operations_struct afs_vm_ops = {
*/ */
void afs_put_wb_key(struct afs_wb_key *wbk) void afs_put_wb_key(struct afs_wb_key *wbk)
{ {
if (refcount_dec_and_test(&wbk->usage)) { if (wbk && refcount_dec_and_test(&wbk->usage)) {
key_put(wbk->key); key_put(wbk->key);
kfree(wbk); kfree(wbk);
} }
...@@ -220,14 +220,35 @@ static void afs_file_readpage_read_complete(struct page *page, ...@@ -220,14 +220,35 @@ static void afs_file_readpage_read_complete(struct page *page,
} }
#endif #endif
static void afs_fetch_data_success(struct afs_operation *op)
{
struct afs_vnode *vnode = op->file[0].vnode;
_enter("op=%08x", op->debug_id);
afs_check_for_remote_deletion(op, vnode);
afs_vnode_commit_status(op, &op->file[0]);
afs_stat_v(vnode, n_fetches);
atomic_long_add(op->fetch.req->actual_len, &op->net->n_fetch_bytes);
}
static void afs_fetch_data_put(struct afs_operation *op)
{
afs_put_read(op->fetch.req);
}
static const struct afs_operation_ops afs_fetch_data_operation = {
.issue_afs_rpc = afs_fs_fetch_data,
.issue_yfs_rpc = yfs_fs_fetch_data,
.success = afs_fetch_data_success,
.put = afs_fetch_data_put,
};
/* /*
* Fetch file data from the volume. * Fetch file data from the volume.
*/ */
int afs_fetch_data(struct afs_vnode *vnode, struct key *key, struct afs_read *req) int afs_fetch_data(struct afs_vnode *vnode, struct key *key, struct afs_read *req)
{ {
struct afs_operation fc; struct afs_operation *op;
struct afs_status_cb *scb;
int ret;
_enter("%s{%llx:%llu.%u},%x,,,", _enter("%s{%llx:%llu.%u},%x,,,",
vnode->volume->name, vnode->volume->name,
...@@ -236,34 +257,15 @@ int afs_fetch_data(struct afs_vnode *vnode, struct key *key, struct afs_read *re ...@@ -236,34 +257,15 @@ int afs_fetch_data(struct afs_vnode *vnode, struct key *key, struct afs_read *re
vnode->fid.unique, vnode->fid.unique,
key_serial(key)); key_serial(key));
scb = kzalloc(sizeof(struct afs_status_cb), GFP_KERNEL); op = afs_alloc_operation(key, vnode->volume);
if (!scb) if (IS_ERR(op))
return -ENOMEM; return PTR_ERR(op);
ret = -ERESTARTSYS;
if (afs_begin_vnode_operation(&fc, vnode, key, true)) {
afs_dataversion_t data_version = vnode->status.data_version;
while (afs_select_fileserver(&fc)) { afs_op_set_vnode(op, 0, vnode);
fc.cb_break = afs_calc_vnode_cb_break(vnode);
afs_fs_fetch_data(&fc, scb, req);
}
afs_check_for_remote_deletion(&fc, vnode);
afs_vnode_commit_status(&fc, vnode, fc.cb_break,
&data_version, scb);
ret = afs_end_vnode_operation(&fc);
}
if (ret == 0) { op->fetch.req = afs_get_read(req);
afs_stat_v(vnode, n_fetches); op->ops = &afs_fetch_data_operation;
atomic_long_add(req->actual_len, return afs_do_sync_operation(op);
&afs_v2net(vnode)->n_fetch_bytes);
}
kfree(scb);
_leave(" = %d", ret);
return ret;
} }
/* /*
......
...@@ -70,7 +70,8 @@ static void afs_schedule_lock_extension(struct afs_vnode *vnode) ...@@ -70,7 +70,8 @@ static void afs_schedule_lock_extension(struct afs_vnode *vnode)
*/ */
void afs_lock_op_done(struct afs_call *call) void afs_lock_op_done(struct afs_call *call)
{ {
struct afs_vnode *vnode = call->lvnode; struct afs_operation *op = call->op;
struct afs_vnode *vnode = op->lock.lvnode;
if (call->error == 0) { if (call->error == 0) {
spin_lock(&vnode->lock); spin_lock(&vnode->lock);
...@@ -172,15 +173,28 @@ static void afs_kill_lockers_enoent(struct afs_vnode *vnode) ...@@ -172,15 +173,28 @@ static void afs_kill_lockers_enoent(struct afs_vnode *vnode)
vnode->lock_key = NULL; vnode->lock_key = NULL;
} }
static void afs_lock_success(struct afs_operation *op)
{
struct afs_vnode *vnode = op->file[0].vnode;
_enter("op=%08x", op->debug_id);
afs_check_for_remote_deletion(op, vnode);
afs_vnode_commit_status(op, &op->file[0]);
}
static const struct afs_operation_ops afs_set_lock_operation = {
.issue_afs_rpc = afs_fs_set_lock,
.issue_yfs_rpc = yfs_fs_set_lock,
.success = afs_lock_success,
};
/* /*
* Get a lock on a file * Get a lock on a file
*/ */
static int afs_set_lock(struct afs_vnode *vnode, struct key *key, static int afs_set_lock(struct afs_vnode *vnode, struct key *key,
afs_lock_type_t type) afs_lock_type_t type)
{ {
struct afs_status_cb *scb; struct afs_operation *op;
struct afs_operation fc;
int ret;
_enter("%s{%llx:%llu.%u},%x,%u", _enter("%s{%llx:%llu.%u},%x,%u",
vnode->volume->name, vnode->volume->name,
...@@ -189,35 +203,29 @@ static int afs_set_lock(struct afs_vnode *vnode, struct key *key, ...@@ -189,35 +203,29 @@ static int afs_set_lock(struct afs_vnode *vnode, struct key *key,
vnode->fid.unique, vnode->fid.unique,
key_serial(key), type); key_serial(key), type);
scb = kzalloc(sizeof(struct afs_status_cb), GFP_KERNEL); op = afs_alloc_operation(key, vnode->volume);
if (!scb) if (IS_ERR(op))
return -ENOMEM; return PTR_ERR(op);
ret = -ERESTARTSYS; afs_op_set_vnode(op, 0, vnode);
if (afs_begin_vnode_operation(&fc, vnode, key, true)) {
while (afs_select_fileserver(&fc)) {
fc.cb_break = afs_calc_vnode_cb_break(vnode);
afs_fs_set_lock(&fc, type, scb);
}
afs_check_for_remote_deletion(&fc, vnode);
afs_vnode_commit_status(&fc, vnode, fc.cb_break, NULL, scb);
ret = afs_end_vnode_operation(&fc);
}
kfree(scb); op->lock.type = type;
_leave(" = %d", ret); op->ops = &afs_set_lock_operation;
return ret; return afs_do_sync_operation(op);
} }
static const struct afs_operation_ops afs_extend_lock_operation = {
.issue_afs_rpc = afs_fs_extend_lock,
.issue_yfs_rpc = yfs_fs_extend_lock,
.success = afs_lock_success,
};
/* /*
* Extend a lock on a file * Extend a lock on a file
*/ */
static int afs_extend_lock(struct afs_vnode *vnode, struct key *key) static int afs_extend_lock(struct afs_vnode *vnode, struct key *key)
{ {
struct afs_status_cb *scb; struct afs_operation *op;
struct afs_operation fc;
int ret;
_enter("%s{%llx:%llu.%u},%x", _enter("%s{%llx:%llu.%u},%x",
vnode->volume->name, vnode->volume->name,
...@@ -226,35 +234,29 @@ static int afs_extend_lock(struct afs_vnode *vnode, struct key *key) ...@@ -226,35 +234,29 @@ static int afs_extend_lock(struct afs_vnode *vnode, struct key *key)
vnode->fid.unique, vnode->fid.unique,
key_serial(key)); key_serial(key));
scb = kzalloc(sizeof(struct afs_status_cb), GFP_KERNEL); op = afs_alloc_operation(key, vnode->volume);
if (!scb) if (IS_ERR(op))
return -ENOMEM; return PTR_ERR(op);
ret = -ERESTARTSYS;
if (afs_begin_vnode_operation(&fc, vnode, key, false)) {
while (afs_select_current_fileserver(&fc)) {
fc.cb_break = afs_calc_vnode_cb_break(vnode);
afs_fs_extend_lock(&fc, scb);
}
afs_check_for_remote_deletion(&fc, vnode); afs_op_set_vnode(op, 0, vnode);
afs_vnode_commit_status(&fc, vnode, fc.cb_break, NULL, scb);
ret = afs_end_vnode_operation(&fc);
}
kfree(scb); op->flags |= AFS_OPERATION_UNINTR;
_leave(" = %d", ret); op->ops = &afs_extend_lock_operation;
return ret; return afs_do_sync_operation(op);
} }
static const struct afs_operation_ops afs_release_lock_operation = {
.issue_afs_rpc = afs_fs_release_lock,
.issue_yfs_rpc = yfs_fs_release_lock,
.success = afs_lock_success,
};
/* /*
* Release a lock on a file * Release a lock on a file
*/ */
static int afs_release_lock(struct afs_vnode *vnode, struct key *key) static int afs_release_lock(struct afs_vnode *vnode, struct key *key)
{ {
struct afs_status_cb *scb; struct afs_operation *op;
struct afs_operation fc;
int ret;
_enter("%s{%llx:%llu.%u},%x", _enter("%s{%llx:%llu.%u},%x",
vnode->volume->name, vnode->volume->name,
...@@ -263,25 +265,15 @@ static int afs_release_lock(struct afs_vnode *vnode, struct key *key) ...@@ -263,25 +265,15 @@ static int afs_release_lock(struct afs_vnode *vnode, struct key *key)
vnode->fid.unique, vnode->fid.unique,
key_serial(key)); key_serial(key));
scb = kzalloc(sizeof(struct afs_status_cb), GFP_KERNEL); op = afs_alloc_operation(key, vnode->volume);
if (!scb) if (IS_ERR(op))
return -ENOMEM; return PTR_ERR(op);
ret = -ERESTARTSYS; afs_op_set_vnode(op, 0, vnode);
if (afs_begin_vnode_operation(&fc, vnode, key, false)) {
while (afs_select_current_fileserver(&fc)) {
fc.cb_break = afs_calc_vnode_cb_break(vnode);
afs_fs_release_lock(&fc, scb);
}
afs_check_for_remote_deletion(&fc, vnode); op->flags |= AFS_OPERATION_UNINTR;
afs_vnode_commit_status(&fc, vnode, fc.cb_break, NULL, scb); op->ops = &afs_release_lock_operation;
ret = afs_end_vnode_operation(&fc); return afs_do_sync_operation(op);
}
kfree(scb);
_leave(" = %d", ret);
return ret;
} }
/* /*
......
// 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);
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 = -EINTR;
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 = -EINTR;
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->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;
read_seqlock_excl(&vnode->cb_lock);
op->cbi = afs_get_cb_interest(
rcu_dereference_protected(vnode->cb_interest,
lockdep_is_held(&vnode->cb_lock.lock)));
read_sequnlock_excl(&vnode->cb_lock);
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->cbi->server->cb_s_break;
if (test_bit(AFS_SERVER_FL_IS_YFS, &op->cbi->server->flags) &&
op->ops->issue_yfs_rpc)
op->ops->issue_yfs_rpc(op);
else
op->ops->issue_afs_rpc(op);
op->error = afs_wait_for_call_to_complete(op->call, &op->ac);
}
if (op->error == 0) {
_debug("success");
op->ops->success(op);
}
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].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_cb_interest(op->net, op->cbi);
afs_put_serverlist(op->net, op->server_list);
afs_put_volume(op->net, op->volume);
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);
}
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
...@@ -283,18 +283,19 @@ static void afs_load_bvec(struct afs_call *call, struct msghdr *msg, ...@@ -283,18 +283,19 @@ static void afs_load_bvec(struct afs_call *call, struct msghdr *msg,
struct bio_vec *bv, pgoff_t first, pgoff_t last, struct bio_vec *bv, pgoff_t first, pgoff_t last,
unsigned offset) unsigned offset)
{ {
struct afs_operation *op = call->op;
struct page *pages[AFS_BVEC_MAX]; struct page *pages[AFS_BVEC_MAX];
unsigned int nr, n, i, to, bytes = 0; unsigned int nr, n, i, to, bytes = 0;
nr = min_t(pgoff_t, last - first + 1, AFS_BVEC_MAX); nr = min_t(pgoff_t, last - first + 1, AFS_BVEC_MAX);
n = find_get_pages_contig(call->mapping, first, nr, pages); n = find_get_pages_contig(op->store.mapping, first, nr, pages);
ASSERTCMP(n, ==, nr); ASSERTCMP(n, ==, nr);
msg->msg_flags |= MSG_MORE; msg->msg_flags |= MSG_MORE;
for (i = 0; i < nr; i++) { for (i = 0; i < nr; i++) {
to = PAGE_SIZE; to = PAGE_SIZE;
if (first + i >= last) { if (first + i >= last) {
to = call->last_to; to = op->store.last_to;
msg->msg_flags &= ~MSG_MORE; msg->msg_flags &= ~MSG_MORE;
} }
bv[i].bv_page = pages[i]; bv[i].bv_page = pages[i];
...@@ -324,13 +325,14 @@ static void afs_notify_end_request_tx(struct sock *sock, ...@@ -324,13 +325,14 @@ static void afs_notify_end_request_tx(struct sock *sock,
*/ */
static int afs_send_pages(struct afs_call *call, struct msghdr *msg) static int afs_send_pages(struct afs_call *call, struct msghdr *msg)
{ {
struct afs_operation *op = call->op;
struct bio_vec bv[AFS_BVEC_MAX]; struct bio_vec bv[AFS_BVEC_MAX];
unsigned int bytes, nr, loop, offset; unsigned int bytes, nr, loop, offset;
pgoff_t first = call->first, last = call->last; pgoff_t first = op->store.first, last = op->store.last;
int ret; int ret;
offset = call->first_offset; offset = op->store.first_offset;
call->first_offset = 0; op->store.first_offset = 0;
do { do {
afs_load_bvec(call, msg, bv, first, last, offset); afs_load_bvec(call, msg, bv, first, last, offset);
...@@ -340,7 +342,7 @@ static int afs_send_pages(struct afs_call *call, struct msghdr *msg) ...@@ -340,7 +342,7 @@ static int afs_send_pages(struct afs_call *call, struct msghdr *msg)
bytes = msg->msg_iter.count; bytes = msg->msg_iter.count;
nr = msg->msg_iter.nr_segs; nr = msg->msg_iter.nr_segs;
ret = rxrpc_kernel_send_data(call->net->socket, call->rxcall, msg, ret = rxrpc_kernel_send_data(op->net->socket, call->rxcall, msg,
bytes, afs_notify_end_request_tx); bytes, afs_notify_end_request_tx);
for (loop = 0; loop < nr; loop++) for (loop = 0; loop < nr; loop++)
put_page(bv[loop].bv_page); put_page(bv[loop].bv_page);
...@@ -350,7 +352,7 @@ static int afs_send_pages(struct afs_call *call, struct msghdr *msg) ...@@ -350,7 +352,7 @@ static int afs_send_pages(struct afs_call *call, struct msghdr *msg)
first += nr; first += nr;
} while (first <= last); } while (first <= last);
trace_afs_sent_pages(call, call->first, last, first, ret); trace_afs_sent_pages(call, op->store.first, last, first, ret);
return ret; return ret;
} }
...@@ -385,16 +387,18 @@ void afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call, gfp_t gfp) ...@@ -385,16 +387,18 @@ void afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call, gfp_t gfp)
*/ */
tx_total_len = call->request_size; tx_total_len = call->request_size;
if (call->send_pages) { if (call->send_pages) {
if (call->last == call->first) { struct afs_operation *op = call->op;
tx_total_len += call->last_to - call->first_offset;
if (op->store.last == op->store.first) {
tx_total_len += op->store.last_to - op->store.first_offset;
} else { } else {
/* It looks mathematically like you should be able to /* It looks mathematically like you should be able to
* combine the following lines with the ones above, but * combine the following lines with the ones above, but
* unsigned arithmetic is fun when it wraps... * unsigned arithmetic is fun when it wraps...
*/ */
tx_total_len += PAGE_SIZE - call->first_offset; tx_total_len += PAGE_SIZE - op->store.first_offset;
tx_total_len += call->last_to; tx_total_len += op->store.last_to;
tx_total_len += (call->last - call->first - 1) * PAGE_SIZE; tx_total_len += (op->store.last - op->store.first - 1) * PAGE_SIZE;
} }
} }
......
...@@ -424,10 +424,7 @@ static void __afs_put_server(struct afs_net *net, struct afs_server *server) ...@@ -424,10 +424,7 @@ static void __afs_put_server(struct afs_net *net, struct afs_server *server)
afs_dec_servers_outstanding(net); afs_dec_servers_outstanding(net);
} }
/* static void afs_give_up_callbacks(struct afs_net *net, struct afs_server *server)
* destroy a dead server
*/
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 = {
...@@ -436,8 +433,16 @@ static void afs_destroy_server(struct afs_net *net, struct afs_server *server) ...@@ -436,8 +433,16 @@ static void afs_destroy_server(struct afs_net *net, struct afs_server *server)
.error = 0, .error = 0,
}; };
afs_fs_give_up_all_callbacks(net, server, &ac, NULL);
}
/*
* destroy a dead server
*/
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_give_up_callbacks(net, server);
afs_put_server(net, server, afs_server_trace_destroy); afs_put_server(net, server, afs_server_trace_destroy);
} }
...@@ -571,7 +576,8 @@ void afs_purge_servers(struct afs_net *net) ...@@ -571,7 +576,8 @@ void afs_purge_servers(struct afs_net *net)
/* /*
* Get an update for a server's address list. * Get an update for a server's address list.
*/ */
static noinline bool afs_update_server_record(struct afs_operation *fc, struct afs_server *server) static noinline bool afs_update_server_record(struct afs_operation *op,
struct afs_server *server)
{ {
struct afs_addr_list *alist, *discard; struct afs_addr_list *alist, *discard;
...@@ -580,18 +586,17 @@ static noinline bool afs_update_server_record(struct afs_operation *fc, struct a ...@@ -580,18 +586,17 @@ static noinline bool afs_update_server_record(struct afs_operation *fc, struct a
trace_afs_server(server, atomic_read(&server->ref), atomic_read(&server->active), trace_afs_server(server, atomic_read(&server->ref), atomic_read(&server->active),
afs_server_trace_update); afs_server_trace_update);
alist = afs_vl_lookup_addrs(fc->vnode->volume->cell, fc->key, alist = afs_vl_lookup_addrs(op->volume->cell, op->key, &server->uuid);
&server->uuid);
if (IS_ERR(alist)) { if (IS_ERR(alist)) {
if ((PTR_ERR(alist) == -ERESTARTSYS || if ((PTR_ERR(alist) == -ERESTARTSYS ||
PTR_ERR(alist) == -EINTR) && PTR_ERR(alist) == -EINTR) &&
!(fc->flags & AFS_OPERATION_INTR) && (op->flags & AFS_OPERATION_UNINTR) &&
server->addresses) { server->addresses) {
_leave(" = t [intr]"); _leave(" = t [intr]");
return true; return true;
} }
fc->error = PTR_ERR(alist); op->error = PTR_ERR(alist);
_leave(" = f [%d]", fc->error); _leave(" = f [%d]", op->error);
return false; return false;
} }
...@@ -613,7 +618,7 @@ static noinline bool afs_update_server_record(struct afs_operation *fc, struct a ...@@ -613,7 +618,7 @@ static noinline bool afs_update_server_record(struct afs_operation *fc, struct a
/* /*
* See if a server's address list needs updating. * See if a server's address list needs updating.
*/ */
bool afs_check_server_record(struct afs_operation *fc, struct afs_server *server) bool afs_check_server_record(struct afs_operation *op, struct afs_server *server)
{ {
bool success; bool success;
int ret, retries = 0; int ret, retries = 0;
...@@ -633,7 +638,7 @@ bool afs_check_server_record(struct afs_operation *fc, struct afs_server *server ...@@ -633,7 +638,7 @@ bool afs_check_server_record(struct afs_operation *fc, struct afs_server *server
update: update:
if (!test_and_set_bit_lock(AFS_SERVER_FL_UPDATING, &server->flags)) { if (!test_and_set_bit_lock(AFS_SERVER_FL_UPDATING, &server->flags)) {
clear_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags); clear_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags);
success = afs_update_server_record(fc, server); success = afs_update_server_record(op, server);
clear_bit_unlock(AFS_SERVER_FL_UPDATING, &server->flags); clear_bit_unlock(AFS_SERVER_FL_UPDATING, &server->flags);
wake_up_bit(&server->flags, AFS_SERVER_FL_UPDATING); wake_up_bit(&server->flags, AFS_SERVER_FL_UPDATING);
_leave(" = %d", success); _leave(" = %d", success);
...@@ -642,10 +647,10 @@ bool afs_check_server_record(struct afs_operation *fc, struct afs_server *server ...@@ -642,10 +647,10 @@ bool afs_check_server_record(struct afs_operation *fc, struct afs_server *server
wait: wait:
ret = wait_on_bit(&server->flags, AFS_SERVER_FL_UPDATING, ret = wait_on_bit(&server->flags, AFS_SERVER_FL_UPDATING,
(fc->flags & AFS_OPERATION_INTR) ? (op->flags & AFS_OPERATION_UNINTR) ?
TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE); TASK_UNINTERRUPTIBLE : TASK_INTERRUPTIBLE);
if (ret == -ERESTARTSYS) { if (ret == -ERESTARTSYS) {
fc->error = ret; op->error = ret;
_leave(" = f [intr]"); _leave(" = f [intr]");
return false; return false;
} }
......
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
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