9p: Add fscache support to 9p

This patch adds a persistent, read-only caching facility for
9p clients using the FS-Cache caching backend.

When the fscache facility is enabled, each inode is associated
with a corresponding vcookie which is an index into the FS-Cache
indexing tree. The FS-Cache indexing tree is indexed at 3 levels:
- session object associated with each mount.
- inode/vcookie
- actual data (pages)

A cache tag is chosen randomly for each session. These tags can
be read off /sys/fs/9p/caches and can be passed as a mount-time
parameter to re-attach to the specified caching session.

Signed-off-by: Abhishek Kulkarni <adkulkar@umail.iu.edu>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>

1 files changed, 87 insertions, 1 deletions

diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
index 92828281a30b..90e38449f4b3 100644
--- a/fs/9p/vfs_addr.c
+++ b/fs/9p/vfs_addr.c
@@ -38,6 +38,7 @@
 
 #include "v9fs.h"
 #include "v9fs_vfs.h"
+#include "cache.h"
 
 /**
  * v9fs_vfs_readpage - read an entire page in from 9P
@@ -52,18 +53,31 @@ static int v9fs_vfs_readpage(struct file *filp, struct page *page)
         int retval;
         loff_t offset;
         char *buffer;
+        struct inode *inode;
 
+        inode = page->mapping->host;
         P9_DPRINTK(P9_DEBUG_VFS, "\n");
+
+        BUG_ON(!PageLocked(page));
+
+        retval = v9fs_readpage_from_fscache(inode, page);
+        if (retval == 0)
+                return retval;
+
         buffer = kmap(page);
         offset = page_offset(page);
 
         retval = v9fs_file_readn(filp, buffer, NULL, PAGE_CACHE_SIZE, offset);
-        if (retval < 0)
+        if (retval < 0) {
+                v9fs_uncache_page(inode, page);
                 goto done;
+        }
 
         memset(buffer + retval, 0, PAGE_CACHE_SIZE - retval);
         flush_dcache_page(page);
         SetPageUptodate(page);
+
+        v9fs_readpage_to_fscache(inode, page);
         retval = 0;
 
 done:
@@ -72,6 +86,78 @@ done:
         return retval;
 }
 
+/**
+ * v9fs_vfs_readpages - read a set of pages from 9P
+ *
+ * @filp: file being read
+ * @mapping: the address space
+ * @pages: list of pages to read
+ * @nr_pages: count of pages to read
+ *
+ */
+
+static int v9fs_vfs_readpages(struct file *filp, struct address_space *mapping,
+                             struct list_head *pages, unsigned nr_pages)
+{
+        int ret = 0;
+        struct inode *inode;
+
+        inode = mapping->host;
+        P9_DPRINTK(P9_DEBUG_VFS, "inode: %p file: %p\n", inode, filp);
+
+        ret = v9fs_readpages_from_fscache(inode, mapping, pages, &nr_pages);
+        if (ret == 0)
+                return ret;
+
+        ret = read_cache_pages(mapping, pages, (void *)v9fs_vfs_readpage, filp);
+        P9_DPRINTK(P9_DEBUG_VFS, "  = %d\n", ret);
+        return ret;
+}
+
+/**
+ * v9fs_release_page - release the private state associated with a page
+ *
+ * Returns 1 if the page can be released, false otherwise.
+ */
+
+static int v9fs_release_page(struct page *page, gfp_t gfp)
+{
+        if (PagePrivate(page))
+                return 0;
+
+        return v9fs_fscache_release_page(page, gfp);
+}
+
+/**
+ * v9fs_invalidate_page - Invalidate a page completely or partially
+ *
+ * @page: structure to page
+ * @offset: offset in the page
+ */
+
+static void v9fs_invalidate_page(struct page *page, unsigned long offset)
+{
+        if (offset == 0)
+                v9fs_fscache_invalidate_page(page);
+}
+
+/**
+ * v9fs_launder_page - Writeback a dirty page
+ * Since the writes go directly to the server, we simply return a 0
+ * here to indicate success.
+ *
+ * Returns 0 on success.
+ */
+
+static int v9fs_launder_page(struct page *page)
+{
+        return 0;
+}
+
 const struct address_space_operations v9fs_addr_operations = {
       .readpage = v9fs_vfs_readpage,
+      .readpages = v9fs_vfs_readpages,
+      .releasepage = v9fs_release_page,
+      .invalidatepage = v9fs_invalidate_page,
+      .launder_page = v9fs_launder_page,
 };