[PATCH] fuse: fix async read for legacy filesystems

While asynchronous reads mean a performance improvement in most cases, if
the filesystem assumed that reads are synchronous, then async reads may
degrade performance (filesystem may receive reads out of order, which can
confuse it's own readahead logic).

With sshfs a 1.5 to 4 times slowdown can be measured.

There's also a need for userspace filesystems to know whether asynchronous
reads are supported by the kernel or not.

To achive these, negotiate in the INIT request whether async reads will be
used and the maximum readahead value.  Update interface version to 7.6

If userspace uses a version earlier than 7.6, then disable async reads, and
set maximum readahead value to the maximum read size, as done in previous
versions.

Signed-off-by: Miklos Szeredi <miklos@szeredi.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index a7ef5e716f3c3dd9a36ae9fd72fc8cf987c2e610..296351615b0014a2f564dfa3d2fb1ce725e00f6f 100644 (file)
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -335,9 +335,14 @@ static void fuse_send_readpages(struct fuse_req *req, struct file *file,
        loff_t pos = page_offset(req->pages[0]);
        size_t count = req->num_pages << PAGE_CACHE_SHIFT;
        req->out.page_zeroing = 1;
-       req->end = fuse_readpages_end;
        fuse_read_fill(req, file, inode, pos, count, FUSE_READ);
-       request_send_background(fc, req);
+       if (fc->async_read) {
+               req->end = fuse_readpages_end;
+               request_send_background(fc, req);
+       } else {
+               request_send(fc, req);
+               fuse_readpages_end(fc, req);
+       }
 }
 
 struct fuse_readpages_data {

diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h
index 46cf933aa3bf2dc22129c74a866628d9313984c6..4a83adfec968ebae108b9ae71802e14db6ef6dbb 100644 (file)
--- a/fs/fuse/fuse_i.h
+++ b/fs/fuse/fuse_i.h
@@ -272,6 +272,9 @@ struct fuse_conn {
            reply, before any other request, and never cleared */
        unsigned conn_error : 1;
 
+       /** Do readpages asynchronously?  Only set in INIT */
+       unsigned async_read : 1;
+
        /*
         * The following bitfields are only for optimization purposes
         * and hence races in setting them will not cause malfunction

diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index c755a0440a6640848fff524c522e940da50b294a..879e6fba94803eca6a1844d9d14d500116086ae7 100644 (file)
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -473,6 +473,16 @@ static void process_init_reply(struct fuse_conn *fc, struct fuse_req *req)
        if (req->out.h.error || arg->major != FUSE_KERNEL_VERSION)
                fc->conn_error = 1;
        else {
+               unsigned long ra_pages;
+
+               if (arg->minor >= 6) {
+                       ra_pages = arg->max_readahead / PAGE_CACHE_SIZE;
+                       if (arg->flags & FUSE_ASYNC_READ)
+                               fc->async_read = 1;
+               } else
+                       ra_pages = fc->max_read / PAGE_CACHE_SIZE;
+
+               fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
                fc->minor = arg->minor;
                fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
        }
@@ -496,6 +506,8 @@ static void fuse_send_init(struct fuse_conn *fc)
 
        arg->major = FUSE_KERNEL_VERSION;
        arg->minor = FUSE_KERNEL_MINOR_VERSION;
+       arg->max_readahead = fc->bdi.ra_pages * PAGE_CACHE_SIZE;
+       arg->flags |= FUSE_ASYNC_READ;
        req->in.h.opcode = FUSE_INIT;
        req->in.numargs = 1;
        req->in.args[0].size = sizeof(*arg);
@@ -552,8 +564,6 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent)
        fc->user_id = d.user_id;
        fc->group_id = d.group_id;
        fc->max_read = d.max_read;
-       if (fc->max_read / PAGE_CACHE_SIZE < fc->bdi.ra_pages)
-               fc->bdi.ra_pages = fc->max_read / PAGE_CACHE_SIZE;
 
        /* Used by get_root_inode() */
        sb->s_fs_info = fc;

diff --git a/include/linux/fuse.h b/include/linux/fuse.h
index 528959c52f1b6fd5f9f3f9722f22cfe6616876e1..5425b60021e36193877aac02e6911db800808c4b 100644 (file)
--- a/include/linux/fuse.h
+++ b/include/linux/fuse.h
@@ -14,7 +14,7 @@
 #define FUSE_KERNEL_VERSION 7
 
 /** Minor version number of this interface */
-#define FUSE_KERNEL_MINOR_VERSION 5
+#define FUSE_KERNEL_MINOR_VERSION 6
 
 /** The node ID of the root inode */
 #define FUSE_ROOT_ID 1
@@ -58,6 +58,9 @@ struct fuse_kstatfs {
        __u32   spare[6];
 };
 
+/**
+ * Bitmasks for fuse_setattr_in.valid
+ */
 #define FATTR_MODE     (1 << 0)
 #define FATTR_UID      (1 << 1)
 #define FATTR_GID      (1 << 2)
@@ -75,6 +78,11 @@ struct fuse_kstatfs {
 #define FOPEN_DIRECT_IO                (1 << 0)
 #define FOPEN_KEEP_CACHE       (1 << 1)
 
+/**
+ * INIT request/reply flags
+ */
+#define FUSE_ASYNC_READ                (1 << 0)
+
 enum fuse_opcode {
        FUSE_LOOKUP        = 1,
        FUSE_FORGET        = 2,  /* no reply */
@@ -247,12 +255,16 @@ struct fuse_access_in {
 struct fuse_init_in {
        __u32   major;
        __u32   minor;
+       __u32   max_readahead;
+       __u32   flags;
 };
 
 struct fuse_init_out {
        __u32   major;
        __u32   minor;
-       __u32   unused[3];
+       __u32   max_readahead;
+       __u32   flags;
+       __u32   unused;
        __u32   max_write;
 };