shinys000114/linux
1
0
Fork 0
mirror of https://github.com/hardkernel/linux.git synced 2026-06-06 10:58:48 +09:00
Code Issues Packages Projects Releases Wiki Activity

FROMLIST: fuse: Handle asynchronous read and write in passthrough

Browse Source 
Extend the passthrough feature by handling asynchronous IO both for read
and write operations.

When an AIO request is received, if the request targets a FUSE file with
the passthrough functionality enabled, a new identical AIO request is
created. The new request targets the lower file system file and gets
assigned a special FUSE passthrough AIO completion callback.
When the lower file system AIO request is completed, the FUSE passthrough
AIO completion callback is executed and propagates the completion signal to
the FUSE AIO request by triggering its completion callback as well.

Bug: 168023149
Link: https://lore.kernel.org/lkml/20201026125016.1905945-5-balsini@android.com/
Signed-off-by: Alessio Balsini <balsini@android.com>
Signed-off-by: Alessio Balsini <balsini@google.com>
Change-Id: I1e6b4602e0813c425a41f370c856d2e99e771277
This commit is contained in:
Alessio Balsini
2020-09-10 18:38:37 +01:00
committed by Alessio Balsini
parent f32d3e5eb8
commit aa525f2e91
1 changed files with 75 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
fs/fuse/passthrough.c
View File

@@ -6,6 +6,11 @@
#include <linux/idr.h>
#include <linux/uio.h>
struct fuse_aio_req {
struct kiocb iocb;
struct kiocb *iocb_fuse;
};
static void fuse_copyattr(struct file *dst_file, struct file *src_file)
{
struct inode *dst = file_inode(dst_file);
@@ -32,6 +37,32 @@ static inline rwf_t iocb_to_rw_flags(int ifl)
return flags;
}
static void fuse_aio_cleanup_handler(struct fuse_aio_req *aio_req)
{
struct kiocb *iocb = &aio_req->iocb;
struct kiocb *iocb_fuse = aio_req->iocb_fuse;
if (iocb->ki_flags & IOCB_WRITE) {
__sb_writers_acquired(file_inode(iocb->ki_filp)->i_sb,
SB_FREEZE_WRITE);
file_end_write(iocb->ki_filp);
fuse_copyattr(iocb_fuse->ki_filp, iocb->ki_filp);
}
iocb_fuse->ki_pos = iocb->ki_pos;
kfree(aio_req);
}
static void fuse_aio_rw_complete(struct kiocb *iocb, long res, long res2)
{
struct fuse_aio_req *aio_req =
container_of(iocb, struct fuse_aio_req, iocb);
struct kiocb *iocb_fuse = aio_req->iocb_fuse;
fuse_aio_cleanup_handler(aio_req);
iocb_fuse->ki_complete(iocb_fuse, res, res2);
}
ssize_t fuse_passthrough_read_iter(struct kiocb *iocb_fuse,
struct iov_iter *iter)
{
@@ -43,8 +74,23 @@ ssize_t fuse_passthrough_read_iter(struct kiocb *iocb_fuse,
if (!iov_iter_count(iter))
return 0;
ret = vfs_iter_read(passthrough_filp, iter, &iocb_fuse->ki_pos,
iocb_to_rw_flags(iocb_fuse->ki_flags));
if (is_sync_kiocb(iocb_fuse)) {
ret = vfs_iter_read(passthrough_filp, iter, &iocb_fuse->ki_pos,
iocb_to_rw_flags(iocb_fuse->ki_flags));
} else {
struct fuse_aio_req *aio_req;
aio_req = kmalloc(sizeof(struct fuse_aio_req), GFP_KERNEL);
if (!aio_req)
return -ENOMEM;
aio_req->iocb_fuse = iocb_fuse;
kiocb_clone(&aio_req->iocb, iocb_fuse, passthrough_filp);
aio_req->iocb.ki_complete = fuse_aio_rw_complete;
ret = call_read_iter(passthrough_filp, &aio_req->iocb, iter);
if (ret != -EIOCBQUEUED)
fuse_aio_cleanup_handler(aio_req);
}
return ret;
}
@@ -57,19 +103,40 @@ ssize_t fuse_passthrough_write_iter(struct kiocb *iocb_fuse,
struct fuse_file *ff = fuse_filp->private_data;
struct inode *fuse_inode = file_inode(fuse_filp);
struct file *passthrough_filp = ff->passthrough.filp;
struct inode *passthrough_inode = file_inode(passthrough_filp);
if (!iov_iter_count(iter))
return 0;
inode_lock(fuse_inode);
file_start_write(passthrough_filp);
ret = vfs_iter_write(passthrough_filp, iter, &iocb_fuse->ki_pos,
iocb_to_rw_flags(iocb_fuse->ki_flags));
file_end_write(passthrough_filp);
if (ret > 0)
fuse_copyattr(fuse_filp, passthrough_filp);
if (is_sync_kiocb(iocb_fuse)) {
file_start_write(passthrough_filp);
ret = vfs_iter_write(passthrough_filp, iter, &iocb_fuse->ki_pos,
iocb_to_rw_flags(iocb_fuse->ki_flags));
file_end_write(passthrough_filp);
if (ret > 0)
fuse_copyattr(fuse_filp, passthrough_filp);
} else {
struct fuse_aio_req *aio_req;
aio_req = kmalloc(sizeof(struct fuse_aio_req), GFP_KERNEL);
if (!aio_req) {
ret = -ENOMEM;
goto out;
}
file_start_write(passthrough_filp);
__sb_writers_release(passthrough_inode->i_sb, SB_FREEZE_WRITE);
aio_req->iocb_fuse = iocb_fuse;
kiocb_clone(&aio_req->iocb, iocb_fuse, passthrough_filp);
aio_req->iocb.ki_complete = fuse_aio_rw_complete;
ret = call_write_iter(passthrough_filp, &aio_req->iocb, iter);
if (ret != -EIOCBQUEUED)
fuse_aio_cleanup_handler(aio_req);
}
out:
inode_unlock(fuse_inode);
return ret;