Merge branch 'fscache' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs into linux-next

Pull fs-cache fixes from David Howells:

Can you pull these commits to fix an issue with NFS whereby caching can be
enabled on a file that is open for writing by subsequently opening it for
reading.  This can be made to crash by opening it for writing again if you're
quick enough.

The gist of the patchset is that the cookie should be acquired at inode
creation only and subsequently enabled and disabled as appropriate (which
dispenses with the backing objects when they're not needed).

The extra synchronisation that NFS does can then be dispensed with as it is
thenceforth managed by FS-Cache.

Could you send these on to Linus?

This likely will need fixing also in CIFS and 9P also once the FS-Cache
changes are upstream.  AFS and Ceph are probably safe.

* 'fscache' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs:
  NFS: Use i_writecount to control whether to get an fscache cookie in nfs_open()
  FS-Cache: Provide the ability to enable/disable cookies
  FS-Cache: Add use/unuse/wake cookie wrappers

5 files changed, 70 insertions, 160 deletions

diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 6cc51ae0638d..9a8676f33350 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -1387,7 +1387,7 @@ static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, i
 
 static int do_open(struct inode *inode, struct file *filp)
 {
-        nfs_fscache_set_inode_cookie(inode, filp);
+        nfs_fscache_open_file(inode, filp);
         return 0;
 }
 
diff --git a/fs/nfs/fscache.c b/fs/nfs/fscache.c
index 24d1d1c5fcaf..3ef01f0ba0bc 100644
--- a/fs/nfs/fscache.c
+++ b/fs/nfs/fscache.c
@@ -39,7 +39,7 @@ void nfs_fscache_get_client_cookie(struct nfs_client *clp)
         /* create a cache index for looking up filehandles */
         clp->fscache = fscache_acquire_cookie(nfs_fscache_netfs.primary_index,
                                               &nfs_fscache_server_index_def,
-                                              clp);
+                                              clp, true);
         dfprintk(FSCACHE, "NFS: get client cookie (0x%p/0x%p)\n",
                  clp, clp->fscache);
 }
@@ -139,7 +139,7 @@ void nfs_fscache_get_super_cookie(struct super_block *sb, const char *uniq, int
         /* create a cache index for looking up filehandles */
         nfss->fscache = fscache_acquire_cookie(nfss->nfs_client->fscache,
                                                &nfs_fscache_super_index_def,
-                                               nfss);
+                                               nfss, true);
         dfprintk(FSCACHE, "NFS: get superblock cookie (0x%p/0x%p)\n",
                  nfss, nfss->fscache);
         return;
@@ -178,163 +178,79 @@ void nfs_fscache_release_super_cookie(struct super_block *sb)
 /*
  * Initialise the per-inode cache cookie pointer for an NFS inode.
  */
-void nfs_fscache_init_inode_cookie(struct inode *inode)
+void nfs_fscache_init_inode(struct inode *inode)
 {
-        NFS_I(inode)->fscache = NULL;
-        if (S_ISREG(inode->i_mode))
-                set_bit(NFS_INO_FSCACHE, &NFS_I(inode)->flags);
-}
-
-/*
- * Get the per-inode cache cookie for an NFS inode.
- */
-static void nfs_fscache_enable_inode_cookie(struct inode *inode)
-{
-        struct super_block *sb = inode->i_sb;
         struct nfs_inode *nfsi = NFS_I(inode);
 
-        if (nfsi->fscache || !NFS_FSCACHE(inode))
+        nfsi->fscache = NULL;
+        if (!S_ISREG(inode->i_mode))
                 return;
-
-        if ((NFS_SB(sb)->options & NFS_OPTION_FSCACHE)) {
-                nfsi->fscache = fscache_acquire_cookie(
-                        NFS_SB(sb)->fscache,
-                        &nfs_fscache_inode_object_def,
-                        nfsi);
-
-                dfprintk(FSCACHE, "NFS: get FH cookie (0x%p/0x%p/0x%p)\n",
-                         sb, nfsi, nfsi->fscache);
-        }
+        nfsi->fscache = fscache_acquire_cookie(NFS_SB(inode->i_sb)->fscache,
+                                               &nfs_fscache_inode_object_def,
+                                               nfsi, false);
 }
 
 /*
  * Release a per-inode cookie.
  */
-void nfs_fscache_release_inode_cookie(struct inode *inode)
+void nfs_fscache_clear_inode(struct inode *inode)
 {
         struct nfs_inode *nfsi = NFS_I(inode);
+        struct fscache_cookie *cookie = nfs_i_fscache(inode);
 
-        dfprintk(FSCACHE, "NFS: clear cookie (0x%p/0x%p)\n",
-                 nfsi, nfsi->fscache);
+        dfprintk(FSCACHE, "NFS: clear cookie (0x%p/0x%p)\n", nfsi, cookie);
 
-        fscache_relinquish_cookie(nfsi->fscache, 0);
+        fscache_relinquish_cookie(cookie, false);
         nfsi->fscache = NULL;
 }
 
-/*
- * Retire a per-inode cookie, destroying the data attached to it.
- */
-void nfs_fscache_zap_inode_cookie(struct inode *inode)
+static bool nfs_fscache_can_enable(void *data)
 {
-        struct nfs_inode *nfsi = NFS_I(inode);
+        struct inode *inode = data;
 
-        dfprintk(FSCACHE, "NFS: zapping cookie (0x%p/0x%p)\n",
-                 nfsi, nfsi->fscache);
-
-        fscache_relinquish_cookie(nfsi->fscache, 1);
-        nfsi->fscache = NULL;
+        return !inode_is_open_for_write(inode);
 }
 
 /*
- * Turn off the cache with regard to a per-inode cookie if opened for writing,
- * invalidating all the pages in the page cache relating to the associated
- * inode to clear the per-page caching.
- */
-static void nfs_fscache_disable_inode_cookie(struct inode *inode)
-{
-        clear_bit(NFS_INO_FSCACHE, &NFS_I(inode)->flags);
-
-        if (NFS_I(inode)->fscache) {
-                dfprintk(FSCACHE,
-                         "NFS: nfsi 0x%p turning cache off\n", NFS_I(inode));
-
-                /* Need to uncache any pages attached to this inode that
-                 * fscache knows about before turning off the cache.
-                 */
-                fscache_uncache_all_inode_pages(NFS_I(inode)->fscache, inode);
-                nfs_fscache_zap_inode_cookie(inode);
-        }
-}
-
-/*
- * wait_on_bit() sleep function for uninterruptible waiting
- */
-static int nfs_fscache_wait_bit(void *flags)
-{
-        schedule();
-        return 0;
-}
-
-/*
- * Lock against someone else trying to also acquire or relinquish a cookie
- */
-static inline void nfs_fscache_inode_lock(struct inode *inode)
-{
-        struct nfs_inode *nfsi = NFS_I(inode);
-
-        while (test_and_set_bit(NFS_INO_FSCACHE_LOCK, &nfsi->flags))
-                wait_on_bit(&nfsi->flags, NFS_INO_FSCACHE_LOCK,
-                            nfs_fscache_wait_bit, TASK_UNINTERRUPTIBLE);
-}
-
-/*
- * Unlock cookie management lock
- */
-static inline void nfs_fscache_inode_unlock(struct inode *inode)
-{
-        struct nfs_inode *nfsi = NFS_I(inode);
-
-        smp_mb__before_clear_bit();
-        clear_bit(NFS_INO_FSCACHE_LOCK, &nfsi->flags);
-        smp_mb__after_clear_bit();
-        wake_up_bit(&nfsi->flags, NFS_INO_FSCACHE_LOCK);
-}
-
-/*
- * Decide if we should enable or disable local caching for this inode.
- * - For now, with NFS, only regular files that are open read-only will be able
- *   to use the cache.
- * - May be invoked multiple times in parallel by parallel nfs_open() functions.
- */
-void nfs_fscache_set_inode_cookie(struct inode *inode, struct file *filp)
-{
-        if (NFS_FSCACHE(inode)) {
-                nfs_fscache_inode_lock(inode);
-                if ((filp->f_flags & O_ACCMODE) != O_RDONLY)
-                        nfs_fscache_disable_inode_cookie(inode);
-                else
-                        nfs_fscache_enable_inode_cookie(inode);
-                nfs_fscache_inode_unlock(inode);
-        }
-}
-EXPORT_SYMBOL_GPL(nfs_fscache_set_inode_cookie);
-
-/*
- * Replace a per-inode cookie due to revalidation detecting a file having
- * changed on the server.
+ * Enable or disable caching for a file that is being opened as appropriate.
+ * The cookie is allocated when the inode is initialised, but is not enabled at
+ * that time.  Enablement is deferred to file-open time to avoid stat() and
+ * access() thrashing the cache.
+ *
+ * For now, with NFS, only regular files that are open read-only will be able
+ * to use the cache.
+ *
+ * We enable the cache for an inode if we open it read-only and it isn't
+ * currently open for writing.  We disable the cache if the inode is open
+ * write-only.
+ *
+ * The caller uses the file struct to pin i_writecount on the inode before
+ * calling us when a file is opened for writing, so we can make use of that.
+ *
+ * Note that this may be invoked multiple times in parallel by parallel
+ * nfs_open() functions.
  */
-void nfs_fscache_reset_inode_cookie(struct inode *inode)
+void nfs_fscache_open_file(struct inode *inode, struct file *filp)
 {
         struct nfs_inode *nfsi = NFS_I(inode);
-        struct nfs_server *nfss = NFS_SERVER(inode);
-        NFS_IFDEBUG(struct fscache_cookie *old = nfsi->fscache);
+        struct fscache_cookie *cookie = nfs_i_fscache(inode);
 
-        nfs_fscache_inode_lock(inode);
-        if (nfsi->fscache) {
-                /* retire the current fscache cache and get a new one */
-                fscache_relinquish_cookie(nfsi->fscache, 1);
-
-                nfsi->fscache = fscache_acquire_cookie(
-                        nfss->nfs_client->fscache,
-                        &nfs_fscache_inode_object_def,
-                        nfsi);
+        if (!fscache_cookie_valid(cookie))
+                return;
 
-                dfprintk(FSCACHE,
-                         "NFS: revalidation new cookie (0x%p/0x%p/0x%p/0x%p)\n",
-                         nfss, nfsi, old, nfsi->fscache);
+        if (inode_is_open_for_write(inode)) {
+                dfprintk(FSCACHE, "NFS: nfsi 0x%p disabling cache\n", nfsi);
+                clear_bit(NFS_INO_FSCACHE, &nfsi->flags);
+                fscache_disable_cookie(cookie, true);
+                fscache_uncache_all_inode_pages(cookie, inode);
+        } else {
+                dfprintk(FSCACHE, "NFS: nfsi 0x%p enabling cache\n", nfsi);
+                fscache_enable_cookie(cookie, nfs_fscache_can_enable, inode);
+                if (fscache_cookie_enabled(cookie))
+                        set_bit(NFS_INO_FSCACHE, &NFS_I(inode)->flags);
         }
-        nfs_fscache_inode_unlock(inode);
 }
+EXPORT_SYMBOL_GPL(nfs_fscache_open_file);
 
 /*
  * Release the caching state associated with a page, if the page isn't busy
@@ -344,12 +260,11 @@ void nfs_fscache_reset_inode_cookie(struct inode *inode)
 int nfs_fscache_release_page(struct page *page, gfp_t gfp)
 {
         if (PageFsCache(page)) {
-                struct nfs_inode *nfsi = NFS_I(page->mapping->host);
-                struct fscache_cookie *cookie = nfsi->fscache;
+                struct fscache_cookie *cookie = nfs_i_fscache(page->mapping->host);
 
                 BUG_ON(!cookie);
                 dfprintk(FSCACHE, "NFS: fscache releasepage (0x%p/0x%p/0x%p)\n",
-                         cookie, page, nfsi);
+                         cookie, page, NFS_I(page->mapping->host));
 
                 if (!fscache_maybe_release_page(cookie, page, gfp))
                         return 0;
@@ -367,13 +282,12 @@ int nfs_fscache_release_page(struct page *page, gfp_t gfp)
  */
 void __nfs_fscache_invalidate_page(struct page *page, struct inode *inode)
 {
-        struct nfs_inode *nfsi = NFS_I(inode);
-        struct fscache_cookie *cookie = nfsi->fscache;
+        struct fscache_cookie *cookie = nfs_i_fscache(inode);
 
         BUG_ON(!cookie);
 
         dfprintk(FSCACHE, "NFS: fscache invalidatepage (0x%p/0x%p/0x%p)\n",
-                 cookie, page, nfsi);
+                 cookie, page, NFS_I(inode));
 
         fscache_wait_on_page_write(cookie, page);
 
@@ -417,9 +331,9 @@ int __nfs_readpage_from_fscache(struct nfs_open_context *ctx,
 
         dfprintk(FSCACHE,
                  "NFS: readpage_from_fscache(fsc:%p/p:%p(i:%lx f:%lx)/0x%p)\n",
-                 NFS_I(inode)->fscache, page, page->index, page->flags, inode);
+                 nfs_i_fscache(inode), page, page->index, page->flags, inode);
 
-        ret = fscache_read_or_alloc_page(NFS_I(inode)->fscache,
+        ret = fscache_read_or_alloc_page(nfs_i_fscache(inode),
                                          page,
                                          nfs_readpage_from_fscache_complete,
                                          ctx,
@@ -459,9 +373,9 @@ int __nfs_readpages_from_fscache(struct nfs_open_context *ctx,
         int ret;
 
         dfprintk(FSCACHE, "NFS: nfs_getpages_from_fscache (0x%p/%u/0x%p)\n",
-                 NFS_I(inode)->fscache, npages, inode);
+                 nfs_i_fscache(inode), npages, inode);
 
-        ret = fscache_read_or_alloc_pages(NFS_I(inode)->fscache,
+        ret = fscache_read_or_alloc_pages(nfs_i_fscache(inode),
                                           mapping, pages, nr_pages,
                                           nfs_readpage_from_fscache_complete,
                                           ctx,
@@ -506,15 +420,15 @@ void __nfs_readpage_to_fscache(struct inode *inode, struct page *page, int sync)
 
         dfprintk(FSCACHE,
                  "NFS: readpage_to_fscache(fsc:%p/p:%p(i:%lx f:%lx)/%d)\n",
-                 NFS_I(inode)->fscache, page, page->index, page->flags, sync);
+                 nfs_i_fscache(inode), page, page->index, page->flags, sync);
 
-        ret = fscache_write_page(NFS_I(inode)->fscache, page, GFP_KERNEL);
+        ret = fscache_write_page(nfs_i_fscache(inode), page, GFP_KERNEL);
         dfprintk(FSCACHE,
                  "NFS:     readpage_to_fscache: p:%p(i:%lu f:%lx) ret %d\n",
                  page, page->index, page->flags, ret);
 
         if (ret != 0) {
-                fscache_uncache_page(NFS_I(inode)->fscache, page);
+                fscache_uncache_page(nfs_i_fscache(inode), page);
                 nfs_add_fscache_stats(inode,
                                       NFSIOS_FSCACHE_PAGES_WRITTEN_FAIL, 1);
                 nfs_add_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_UNCACHED, 1);
diff --git a/fs/nfs/fscache.h b/fs/nfs/fscache.h
index 4ecb76652eba..d7fe3e799f2f 100644
--- a/fs/nfs/fscache.h
+++ b/fs/nfs/fscache.h
@@ -76,11 +76,9 @@ extern void nfs_fscache_release_client_cookie(struct nfs_client *);
 extern void nfs_fscache_get_super_cookie(struct super_block *, const char *, int);
 extern void nfs_fscache_release_super_cookie(struct super_block *);
 
-extern void nfs_fscache_init_inode_cookie(struct inode *);
-extern void nfs_fscache_release_inode_cookie(struct inode *);
-extern void nfs_fscache_zap_inode_cookie(struct inode *);
-extern void nfs_fscache_set_inode_cookie(struct inode *, struct file *);
-extern void nfs_fscache_reset_inode_cookie(struct inode *);
+extern void nfs_fscache_init_inode(struct inode *);
+extern void nfs_fscache_clear_inode(struct inode *);
+extern void nfs_fscache_open_file(struct inode *, struct file *);
 
 extern void __nfs_fscache_invalidate_page(struct page *, struct inode *);
 extern int nfs_fscache_release_page(struct page *, gfp_t);
@@ -187,12 +185,10 @@ static inline void nfs_fscache_release_client_cookie(struct nfs_client *clp) {}
 
 static inline void nfs_fscache_release_super_cookie(struct super_block *sb) {}
 
-static inline void nfs_fscache_init_inode_cookie(struct inode *inode) {}
-static inline void nfs_fscache_release_inode_cookie(struct inode *inode) {}
-static inline void nfs_fscache_zap_inode_cookie(struct inode *inode) {}
-static inline void nfs_fscache_set_inode_cookie(struct inode *inode,
-                                                struct file *filp) {}
-static inline void nfs_fscache_reset_inode_cookie(struct inode *inode) {}
+static inline void nfs_fscache_init_inode(struct inode *inode) {}
+static inline void nfs_fscache_clear_inode(struct inode *inode) {}
+static inline void nfs_fscache_open_file(struct inode *inode,
+                                         struct file *filp) {}
 
 static inline int nfs_fscache_release_page(struct page *page, gfp_t gfp)
 {
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 4bc7538f951e..471ba59c42f9 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -122,7 +122,7 @@ void nfs_clear_inode(struct inode *inode)
         WARN_ON_ONCE(!list_empty(&NFS_I(inode)->open_files));
         nfs_zap_acl_cache(inode);
         nfs_access_zap_cache(inode);
-        nfs_fscache_release_inode_cookie(inode);
+        nfs_fscache_clear_inode(inode);
 }
 EXPORT_SYMBOL_GPL(nfs_clear_inode);
 
@@ -459,7 +459,7 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, st
                 nfsi->attrtimeo_timestamp = now;
                 nfsi->access_cache = RB_ROOT;
 
-                nfs_fscache_init_inode_cookie(inode);
+                nfs_fscache_init_inode(inode);
 
                 unlock_new_inode(inode);
         } else
@@ -854,7 +854,7 @@ int nfs_open(struct inode *inode, struct file *filp)
                 return PTR_ERR(ctx);
         nfs_file_set_open_context(filp, ctx);
         put_nfs_open_context(ctx);
-        nfs_fscache_set_inode_cookie(inode, filp);
+        nfs_fscache_open_file(inode, filp);
         return 0;
 }
 
diff --git a/fs/nfs/nfs4file.c b/fs/nfs/nfs4file.c
index 77efaf15ec90..1f01b55692ee 100644
--- a/fs/nfs/nfs4file.c
+++ b/fs/nfs/nfs4file.c
@@ -75,7 +75,7 @@ nfs4_file_open(struct inode *inode, struct file *filp)
 
         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
         nfs_file_set_open_context(filp, ctx);
-        nfs_fscache_set_inode_cookie(inode, filp);
+        nfs_fscache_open_file(inode, filp);
         err = 0;
 
 out_put_ctx: