Merge git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-2.6-fscache

* git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-2.6-fscache: (41 commits)
  NFS: Add mount options to enable local caching on NFS
  NFS: Display local caching state
  NFS: Store pages from an NFS inode into a local cache
  NFS: Read pages from FS-Cache into an NFS inode
  NFS: nfs_readpage_async() needs to be accessible as a fallback for local caching
  NFS: Add read context retention for FS-Cache to call back with
  NFS: FS-Cache page management
  NFS: Add some new I/O counters for FS-Cache doing things for NFS
  NFS: Invalidate FsCache page flags when cache removed
  NFS: Use local disk inode cache
  NFS: Define and create inode-level cache objects
  NFS: Define and create superblock-level objects
  NFS: Define and create server-level objects
  NFS: Register NFS for caching and retrieve the top-level index
  NFS: Permit local filesystem caching to be enabled for NFS
  NFS: Add FS-Cache option bit and debug bit
  NFS: Add comment banners to some NFS functions
  FS-Cache: Make kAFS use FS-Cache
  CacheFiles: A cache that backs onto a mounted filesystem
  CacheFiles: Export things for CacheFiles
  ...

1 files changed, 143 insertions, 77 deletions

diff --git a/fs/afs/file.c b/fs/afs/file.c
index a3901769a96c..7a1d942ef68d 100644
--- a/fs/afs/file.c
+++ b/fs/afs/file.c
@@ -23,6 +23,9 @@ static void afs_invalidatepage(struct page *page, unsigned long offset);
 static int afs_releasepage(struct page *page, gfp_t gfp_flags);
 static int afs_launder_page(struct page *page);
 
+static int afs_readpages(struct file *filp, struct address_space *mapping,
+                         struct list_head *pages, unsigned nr_pages);
+
 const struct file_operations afs_file_operations = {
         .open           = afs_open,
         .release        = afs_release,
@@ -46,6 +49,7 @@ const struct inode_operations afs_file_inode_operations = {
 
 const struct address_space_operations afs_fs_aops = {
         .readpage       = afs_readpage,
+        .readpages      = afs_readpages,
         .set_page_dirty = afs_set_page_dirty,
         .launder_page   = afs_launder_page,
         .releasepage    = afs_releasepage,
@@ -101,37 +105,18 @@ int afs_release(struct inode *inode, struct file *file)
 /*
  * deal with notification that a page was read from the cache
  */
-#ifdef AFS_CACHING_SUPPORT
-static void afs_readpage_read_complete(void *cookie_data,
-                                       struct page *page,
-                                       void *data,
-                                       int error)
+static void afs_file_readpage_read_complete(struct page *page,
+                                            void *data,
+                                            int error)
 {
-        _enter("%p,%p,%p,%d", cookie_data, page, data, error);
+        _enter("%p,%p,%d", page, data, error);
 
-        if (error)
-                SetPageError(page);
-        else
+        /* if the read completes with an error, we just unlock the page and let
+         * the VM reissue the readpage */
+        if (!error)
                 SetPageUptodate(page);
         unlock_page(page);
-
 }
-#endif
-
-/*
- * deal with notification that a page was written to the cache
- */
-#ifdef AFS_CACHING_SUPPORT
-static void afs_readpage_write_complete(void *cookie_data,
-                                        struct page *page,
-                                        void *data,
-                                        int error)
-{
-        _enter("%p,%p,%p,%d", cookie_data, page, data, error);
-
-        unlock_page(page);
-}
-#endif
 
 /*
  * AFS read page from file, directory or symlink
@@ -161,9 +146,9 @@ static int afs_readpage(struct file *file, struct page *page)
         if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
                 goto error;
 
-#ifdef AFS_CACHING_SUPPORT
         /* is it cached? */
-        ret = cachefs_read_or_alloc_page(vnode->cache,
+#ifdef CONFIG_AFS_FSCACHE
+        ret = fscache_read_or_alloc_page(vnode->cache,
                                          page,
                                          afs_file_readpage_read_complete,
                                          NULL,
@@ -171,20 +156,21 @@ static int afs_readpage(struct file *file, struct page *page)
 #else
         ret = -ENOBUFS;
 #endif
-
         switch (ret) {
-                /* read BIO submitted and wb-journal entry found */
-        case 1:
-                BUG(); // TODO - handle wb-journal match
-
                 /* read BIO submitted (page in cache) */
         case 0:
                 break;
 
-                /* no page available in cache */
-        case -ENOBUFS:
+                /* page not yet cached */
         case -ENODATA:
+                _debug("cache said ENODATA");
+                goto go_on;
+
+                /* page will not be cached */
+        case -ENOBUFS:
+                _debug("cache said ENOBUFS");
         default:
+        go_on:
                 offset = page->index << PAGE_CACHE_SHIFT;
                 len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE);
 
@@ -198,27 +184,25 @@ static int afs_readpage(struct file *file, struct page *page)
                                 set_bit(AFS_VNODE_DELETED, &vnode->flags);
                                 ret = -ESTALE;
                         }
-#ifdef AFS_CACHING_SUPPORT
-                        cachefs_uncache_page(vnode->cache, page);
+
+#ifdef CONFIG_AFS_FSCACHE
+                        fscache_uncache_page(vnode->cache, page);
 #endif
+                        BUG_ON(PageFsCache(page));
                         goto error;
                 }
 
                 SetPageUptodate(page);
 
-#ifdef AFS_CACHING_SUPPORT
-                if (cachefs_write_page(vnode->cache,
-                                       page,
-                                       afs_file_readpage_write_complete,
-                                       NULL,
-                                       GFP_KERNEL) != 0
-                    ) {
-                        cachefs_uncache_page(vnode->cache, page);
-                        unlock_page(page);
+                /* send the page to the cache */
+#ifdef CONFIG_AFS_FSCACHE
+                if (PageFsCache(page) &&
+                    fscache_write_page(vnode->cache, page, GFP_KERNEL) != 0) {
+                        fscache_uncache_page(vnode->cache, page);
+                        BUG_ON(PageFsCache(page));
                 }
-#else
-                unlock_page(page);
 #endif
+                unlock_page(page);
         }
 
         _leave(" = 0");
@@ -232,34 +216,59 @@ error:
 }
 
 /*
- * invalidate part or all of a page
+ * read a set of pages
  */
-static void afs_invalidatepage(struct page *page, unsigned long offset)
+static int afs_readpages(struct file *file, struct address_space *mapping,
+                         struct list_head *pages, unsigned nr_pages)
 {
-        int ret = 1;
+        struct afs_vnode *vnode;
+        int ret = 0;
 
-        _enter("{%lu},%lu", page->index, offset);
+        _enter(",{%lu},,%d", mapping->host->i_ino, nr_pages);
 
-        BUG_ON(!PageLocked(page));
+        vnode = AFS_FS_I(mapping->host);
+        if (vnode->flags & AFS_VNODE_DELETED) {
+                _leave(" = -ESTALE");
+                return -ESTALE;
+        }
 
-        if (PagePrivate(page)) {
-                /* We release buffers only if the entire page is being
-                 * invalidated.
-                 * The get_block cached value has been unconditionally
-                 * invalidated, so real IO is not possible anymore.
-                 */
-                if (offset == 0) {
-                        BUG_ON(!PageLocked(page));
-
-                        ret = 0;
-                        if (!PageWriteback(page))
-                                ret = page->mapping->a_ops->releasepage(page,
-                                                                        0);
-                        /* possibly should BUG_ON(!ret); - neilb */
-                }
+        /* attempt to read as many of the pages as possible */
+#ifdef CONFIG_AFS_FSCACHE
+        ret = fscache_read_or_alloc_pages(vnode->cache,
+                                          mapping,
+                                          pages,
+                                          &nr_pages,
+                                          afs_file_readpage_read_complete,
+                                          NULL,
+                                          mapping_gfp_mask(mapping));
+#else
+        ret = -ENOBUFS;
+#endif
+
+        switch (ret) {
+                /* all pages are being read from the cache */
+        case 0:
+                BUG_ON(!list_empty(pages));
+                BUG_ON(nr_pages != 0);
+                _leave(" = 0 [reading all]");
+                return 0;
+
+                /* there were pages that couldn't be read from the cache */
+        case -ENODATA:
+        case -ENOBUFS:
+                break;
+
+                /* other error */
+        default:
+                _leave(" = %d", ret);
+                return ret;
         }
 
-        _leave(" = %d", ret);
+        /* load the missing pages from the network */
+        ret = read_cache_pages(mapping, pages, (void *) afs_readpage, file);
+
+        _leave(" = %d [netting]", ret);
+        return ret;
 }
 
 /*
@@ -273,25 +282,82 @@ static int afs_launder_page(struct page *page)
 }
 
 /*
- * release a page and cleanup its private data
+ * invalidate part or all of a page
+ * - release a page and clean up its private data if offset is 0 (indicating
+ *   the entire page)
+ */
+static void afs_invalidatepage(struct page *page, unsigned long offset)
+{
+        struct afs_writeback *wb = (struct afs_writeback *) page_private(page);
+
+        _enter("{%lu},%lu", page->index, offset);
+
+        BUG_ON(!PageLocked(page));
+
+        /* we clean up only if the entire page is being invalidated */
+        if (offset == 0) {
+#ifdef CONFIG_AFS_FSCACHE
+                if (PageFsCache(page)) {
+                        struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
+                        fscache_wait_on_page_write(vnode->cache, page);
+                        fscache_uncache_page(vnode->cache, page);
+                        ClearPageFsCache(page);
+                }
+#endif
+
+                if (PagePrivate(page)) {
+                        if (wb && !PageWriteback(page)) {
+                                set_page_private(page, 0);
+                                afs_put_writeback(wb);
+                        }
+
+                        if (!page_private(page))
+                                ClearPagePrivate(page);
+                }
+        }
+
+        _leave("");
+}
+
+/*
+ * release a page and clean up its private state if it's not busy
+ * - return true if the page can now be released, false if not
  */
 static int afs_releasepage(struct page *page, gfp_t gfp_flags)
 {
+        struct afs_writeback *wb = (struct afs_writeback *) page_private(page);
         struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
-        struct afs_writeback *wb;
 
         _enter("{{%x:%u}[%lu],%lx},%x",
                vnode->fid.vid, vnode->fid.vnode, page->index, page->flags,
                gfp_flags);
 
+        /* deny if page is being written to the cache and the caller hasn't
+         * elected to wait */
+#ifdef CONFIG_AFS_FSCACHE
+        if (PageFsCache(page)) {
+                if (fscache_check_page_write(vnode->cache, page)) {
+                        if (!(gfp_flags & __GFP_WAIT)) {
+                                _leave(" = F [cache busy]");
+                                return 0;
+                        }
+                        fscache_wait_on_page_write(vnode->cache, page);
+                }
+
+                fscache_uncache_page(vnode->cache, page);
+                ClearPageFsCache(page);
+        }
+#endif
+
         if (PagePrivate(page)) {
-                wb = (struct afs_writeback *) page_private(page);
-                ASSERT(wb != NULL);
-                set_page_private(page, 0);
+                if (wb) {
+                        set_page_private(page, 0);
+                        afs_put_writeback(wb);
+                }
                 ClearPagePrivate(page);
-                afs_put_writeback(wb);
         }
 
-        _leave(" = 0");
-        return 0;
+        /* indicate that the page can be released */
+        _leave(" = T");
+        return 1;
 }