Add synchronous O_DIRECT support to AFS (no AIO yet). It can theoretically
handle reads and writes up to the maximum size describable by an s64 - and
given an iterator with sufficiently capacity to handle that and given
support on the server.
Signed-off-by: David Howells <dhowells@xxxxxxxxxx>
cc: Marc Dionne <marc.dionne@xxxxxxxxxxxx>
cc: linux-afs@xxxxxxxxxxxxxxxxxxx
cc: linux-cachefs@xxxxxxxxxx
---
fs/afs/file.c | 59 +++++++++++++++++++++++++++++++++++++++++++
fs/afs/fsclient.c | 2 +
fs/afs/internal.h | 1 +
fs/afs/write.c | 72 +++++++++++++++++++++++++++++++++++++++++++++++++++++
4 files changed, 133 insertions(+), 1 deletion(-)
diff --git a/fs/afs/file.c b/fs/afs/file.c
index c0cf8bfa00e8..7fe57f210259 100644
--- a/fs/afs/file.c
+++ b/fs/afs/file.c
@@ -28,6 +28,7 @@ static ssize_t afs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter);
static void afs_vm_open(struct vm_area_struct *area);
static void afs_vm_close(struct vm_area_struct *area);
static vm_fault_t afs_vm_map_pages(struct vm_fault *vmf, pgoff_t start_pgoff, pgoff_t end_pgoff);
+static ssize_t afs_direct_IO(struct kiocb *iocb, struct iov_iter *iter);
const struct file_operations afs_file_operations = {
.open = afs_open,
@@ -56,6 +57,7 @@ const struct address_space_operations afs_fs_aops = {
.launder_page = afs_launder_page,
.releasepage = afs_releasepage,
.invalidatepage = afs_invalidatepage,
+ .direct_IO = afs_direct_IO,
.write_begin = afs_write_begin,
.write_end = afs_write_end,
.writepage = afs_writepage,
@@ -602,3 +604,60 @@ static ssize_t afs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
return generic_file_read_iter(iocb, iter);
}
+
+/*
+ * Direct file read operation for an AFS file.
+ *
+ * TODO: To support AIO, the pages in the iterator have to be copied and
+ * refs taken on them. Then -EIOCBQUEUED needs to be returned.
+ * iocb->ki_complete must then be called upon completion of the operation.
+ */
+static ssize_t afs_file_direct_read(struct kiocb *iocb, struct iov_iter *iter)
+{
+ struct file *file = iocb->ki_filp;
+ struct afs_vnode *vnode = AFS_FS_I(file_inode(file));
+ struct afs_read *req;
+ ssize_t ret, transferred;
+
+ _enter("%llx,%zx", iocb->ki_pos, iov_iter_count(iter));
+
+ req = afs_alloc_read(GFP_KERNEL);
+ if (!req)
+ return -ENOMEM;
+
+ req->vnode = vnode;
+ req->key = key_get(afs_file_key(file));
+ req->pos = iocb->ki_pos;
+ req->len = iov_iter_count(iter);
+ req->iter = iter;
+
+ task_io_account_read(req->len);
+
+ // TODO nfs_start_io_direct(inode);
+ ret = afs_fetch_data(vnode, req);
+ if (ret == 0)
+ transferred = req->actual_len;
+ afs_put_read(req);
+
+ // TODO nfs_end_io_direct(inode);
+
+ if (ret == 0)
+ ret = transferred;
+
+ BUG_ON(ret == -EIOCBQUEUED); // TODO
+ //if (iocb->ki_complete)
+ // iocb->ki_complete(iocb, ret, 0); // only if ret == -EIOCBQUEUED
+
+ _leave(" = %zu", ret);
+ return ret;
+}
+
+/*
+ * Do direct I/O.
+ */
+static ssize_t afs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
+{
+ if (iov_iter_rw(iter) == READ)
+ return afs_file_direct_read(iocb, iter);
+ return afs_file_direct_write(iocb, iter);
+}
diff --git a/fs/afs/fsclient.c b/fs/afs/fsclient.c
index 4943413d9c5f..a7273106803c 100644
--- a/fs/afs/fsclient.c
+++ b/fs/afs/fsclient.c
@@ -439,7 +439,7 @@ static void afs_fs_fetch_data64(struct afs_operation *op)
bp[3] = htonl(vp->fid.unique);
bp[4] = htonl(upper_32_bits(req->pos));
bp[5] = htonl(lower_32_bits(req->pos));
- bp[6] = 0;
+ bp[6] = htonl(upper_32_bits(req->len));
bp[7] = htonl(lower_32_bits(req->len));
trace_afs_make_fs_call(call, &vp->fid);
diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index 07d34291bf4f..3d640e84588e 100644
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -1538,6 +1538,7 @@ extern int afs_fsync(struct file *, loff_t, loff_t, int);
extern vm_fault_t afs_page_mkwrite(struct vm_fault *vmf);
extern void afs_prune_wb_keys(struct afs_vnode *);
extern int afs_launder_page(struct page *);
+extern ssize_t afs_file_direct_write(struct kiocb *, struct iov_iter *);
/*
* xattr.c
diff --git a/fs/afs/write.c b/fs/afs/write.c
index fa96a65d28be..94a21ee974c0 100644
--- a/fs/afs/write.c
+++ b/fs/afs/write.c
@@ -1040,3 +1040,75 @@ static void afs_write_to_cache(struct afs_vnode *vnode,
vnode->vfs_inode.i_mapping, start, len, i_size,
afs_write_to_cache_done, vnode);
}
+
+static void afs_dio_store_data_success(struct afs_operation *op)
+{
+ struct afs_vnode *vnode = op->file[0].vnode;
+
+ op->ctime = op->file[0].scb.status.mtime_client;
+ afs_vnode_commit_status(op, &op->file[0]);
+ if (op->error == 0) {
+ afs_stat_v(vnode, n_stores);
+ atomic_long_add(op->store.size, &afs_v2net(vnode)->n_store_bytes);
+ }
+}
+
+static const struct afs_operation_ops afs_dio_store_data_operation = {
+ .issue_afs_rpc = afs_fs_store_data,
+ .issue_yfs_rpc = yfs_fs_store_data,
+ .success = afs_dio_store_data_success,
+};
+
+/*
+ * Direct file write operation for an AFS file.
+ *
+ * TODO: To support AIO, the pages in the iterator have to be copied and
+ * refs taken on them. Then -EIOCBQUEUED needs to be returned.
+ * iocb->ki_complete must then be called upon completion of the operation.
+ */
+ssize_t afs_file_direct_write(struct kiocb *iocb, struct iov_iter *iter)
+{
+ struct file *file = iocb->ki_filp;
+ struct afs_vnode *vnode = AFS_FS_I(file_inode(file));
+ struct afs_operation *op;
+ loff_t size = iov_iter_count(iter), i_size;
+ ssize_t ret;
+
+ _enter("%s{%llx:%llu.%u},%llx,%llx",
+ vnode->volume->name,
+ vnode->fid.vid,
+ vnode->fid.vnode,
+ vnode->fid.unique,
+ size, iocb->ki_pos);
+
+ op = afs_alloc_operation(afs_file_key(file), vnode->volume);
+ if (IS_ERR(op))
+ return -ENOMEM;
+
+ i_size = i_size_read(&vnode->vfs_inode);
+
+ afs_op_set_vnode(op, 0, vnode);
+ op->file[0].dv_delta = 1;
+ op->file[0].set_size = true;
+ op->file[0].modification = true;
+ op->store.write_iter = iter;
+ op->store.pos = iocb->ki_pos;
+ op->store.size = size;
+ op->store.i_size = max(iocb->ki_pos + size, i_size);
+ op->mtime = current_time(&vnode->vfs_inode);
+ op->ops = &afs_dio_store_data_operation;
+
+ //if (!is_sync_kiocb(iocb)) {
+
+ ret = afs_do_sync_operation(op);
+ if (ret == 0)
+ ret = size;
+
+ afs_invalidate_cache(vnode, FSCACHE_INVAL_DIO_WRITE);
+
+ //if (iocb->ki_complete)
+ // iocb->ki_complete(iocb, ret, 0); // only if ret == -EIOCBQUEUED
+
+ _leave(" = %zd", ret);
+ return ret;
+}
