fuse: allow caching readdir

This patch just adds the cache filling functions, which are invoked if
FOPEN_CACHE_DIR flag is set in the OPENDIR reply.

Cache reading and cache invalidation are added by subsequent patches.

The directory cache uses the page cache.  Directory entries are packed into
a page in the same format as in the READDIR reply.  A page only contains
whole entries, the space at the end of the page is cleared.  The page is
locked while being modified.

Multiple parallel readdirs on the same directory can fill the cache; the
only constraint is that continuity must be maintained (d_off of last entry
points to position of current entry).

Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>

diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h
index dfe10c2df6a9d4bb9c636fc1d7f5eea852264f58..d2fa7588533eafe2d5259975d4f07c82df893fbe 100644 (file)
--- a/fs/fuse/fuse_i.h
+++ b/fs/fuse/fuse_i.h
@@ -103,6 +103,21 @@ struct fuse_inode {
        /** List of writepage requestst (pending or sent) */
        struct list_head writepages;
 
+       /* readdir cache */
+       struct {
+               /* true if fully cached */
+               bool cached;
+
+               /* size of cache */
+               loff_t size;
+
+               /* position at end of cache (position of next entry) */
+               loff_t pos;
+
+               /* protects above fields */
+               spinlock_t lock;
+       } rdc;
+
        /** Miscellaneous bits describing inode state */
        unsigned long state;
 

diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index 9383b47b3d9b33f46e8963483462c2582d5c7f71..892efe6351eb0651094acde025b4e99e4bc69b46 100644 (file)
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -100,6 +100,10 @@ static struct inode *fuse_alloc_inode(struct super_block *sb)
        INIT_LIST_HEAD(&fi->queued_writes);
        INIT_LIST_HEAD(&fi->writepages);
        init_waitqueue_head(&fi->page_waitq);
+       spin_lock_init(&fi->rdc.lock);
+       fi->rdc.cached = false;
+       fi->rdc.size = 0;
+       fi->rdc.pos = 0;
        mutex_init(&fi->mutex);
        fi->forget = fuse_alloc_forget();
        if (!fi->forget) {

diff --git a/fs/fuse/readdir.c b/fs/fuse/readdir.c
index 65336c93c1f402b79269bbe5b54e872fb303fb9b..6c5ada164f7e5f7e9883a33271e1a303a4fcf21d 100644 (file)
--- a/fs/fuse/readdir.c
+++ b/fs/fuse/readdir.c
@@ -9,6 +9,8 @@
 
 #include "fuse_i.h"
 #include <linux/posix_acl.h>
+#include <linux/pagemap.h>
+#include <linux/highmem.h>
 
 static bool fuse_use_readdirplus(struct inode *dir, struct dir_context *ctx)
 {
@@ -26,9 +28,91 @@ static bool fuse_use_readdirplus(struct inode *dir, struct dir_context *ctx)
        return false;
 }
 
+static void fuse_add_dirent_to_cache(struct file *file,
+                                    struct fuse_dirent *dirent, loff_t pos)
+{
+       struct fuse_inode *fi = get_fuse_inode(file_inode(file));
+       size_t reclen = FUSE_DIRENT_SIZE(dirent);
+       pgoff_t index;
+       struct page *page;
+       loff_t size;
+       unsigned int offset;
+       void *addr;
+
+       spin_lock(&fi->rdc.lock);
+       /*
+        * Is cache already completed?  Or this entry does not go at the end of
+        * cache?
+        */
+       if (fi->rdc.cached || pos != fi->rdc.pos) {
+               spin_unlock(&fi->rdc.lock);
+               return;
+       }
+       size = fi->rdc.size;
+       offset = size & ~PAGE_MASK;
+       index = size >> PAGE_SHIFT;
+       /* Dirent doesn't fit in current page?  Jump to next page. */
+       if (offset + reclen > PAGE_SIZE) {
+               index++;
+               offset = 0;
+       }
+       spin_unlock(&fi->rdc.lock);
+
+       if (offset) {
+               page = find_lock_page(file->f_mapping, index);
+       } else {
+               page = find_or_create_page(file->f_mapping, index,
+                                          mapping_gfp_mask(file->f_mapping));
+       }
+       if (!page)
+               return;
+
+       spin_lock(&fi->rdc.lock);
+       /* Raced with another readdir */
+       if (fi->rdc.size != size || WARN_ON(fi->rdc.pos != pos))
+               goto unlock;
+
+       addr = kmap_atomic(page);
+       if (!offset)
+               clear_page(addr);
+       memcpy(addr + offset, dirent, reclen);
+       kunmap_atomic(addr);
+       fi->rdc.size = (index << PAGE_SHIFT) + offset + reclen;
+       fi->rdc.pos = dirent->off;
+unlock:
+       spin_unlock(&fi->rdc.lock);
+       unlock_page(page);
+       put_page(page);
+}
+
+static void fuse_readdir_cache_end(struct file *file, loff_t pos)
+{
+       struct fuse_inode *fi = get_fuse_inode(file_inode(file));
+       loff_t end;
+
+       spin_lock(&fi->rdc.lock);
+       /* does cache end position match current position? */
+       if (fi->rdc.pos != pos) {
+               spin_unlock(&fi->rdc.lock);
+               return;
+       }
+
+       fi->rdc.cached = true;
+       end = ALIGN(fi->rdc.size, PAGE_SIZE);
+       spin_unlock(&fi->rdc.lock);
+
+       /* truncate unused tail of cache */
+       truncate_inode_pages(file->f_mapping, end);
+}
+
 static bool fuse_emit(struct file *file, struct dir_context *ctx,
                      struct fuse_dirent *dirent)
 {
+       struct fuse_file *ff = file->private_data;
+
+       if (ff->open_flags & FOPEN_CACHE_DIR)
+               fuse_add_dirent_to_cache(file, dirent, ctx->pos);
+
        return dir_emit(ctx, dirent->name, dirent->namelen, dirent->ino,
                        dirent->type);
 }
@@ -249,7 +333,12 @@ int fuse_readdir(struct file *file, struct dir_context *ctx)
        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (!err) {
-               if (plus) {
+               if (!nbytes) {
+                       struct fuse_file *ff = file->private_data;
+
+                       if (ff->open_flags & FOPEN_CACHE_DIR)
+                               fuse_readdir_cache_end(file, ctx->pos);
+               } else if (plus) {
                        err = parse_dirplusfile(page_address(page), nbytes,
                                                file, ctx, attr_version);
                } else {