fscache: Pass object size in rather than calling back for it

Pass the object size in to fscache_acquire_cookie() and
fscache_write_page() rather than the netfs providing a callback by which it
can be received.  This makes it easier to update the size of the object
when a new page is written that extends the object.

The current object size is also passed by fscache to the check_aux
function, obviating the need to store it in the aux data.

Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Anna Schumaker <anna.schumaker@netapp.com>
Tested-by: Steve Dickson <steved@redhat.com>

18 files changed, 78 insertions, 119 deletions

diff --git a/fs/9p/cache.c b/fs/9p/cache.c
index 9d0030af5672..9eb34701a566 100644
--- a/fs/9p/cache.c
+++ b/fs/9p/cache.c
@@ -75,7 +75,7 @@ void v9fs_cache_session_get_cookie(struct v9fs_session_info *v9ses)
                                                 v9ses->cachetag,
                                                 strlen(v9ses->cachetag),
                                                 NULL, 0,
-                                                v9ses, true);
+                                                v9ses, 0, true);
         p9_debug(P9_DEBUG_FSC, "session %p get cookie %p\n",
                  v9ses, v9ses->fscache);
 }
@@ -88,20 +88,11 @@ void v9fs_cache_session_put_cookie(struct v9fs_session_info *v9ses)
         v9ses->fscache = NULL;
 }
 
-static void v9fs_cache_inode_get_attr(const void *cookie_netfs_data,
-                                      uint64_t *size)
-{
-        const struct v9fs_inode *v9inode = cookie_netfs_data;
-        *size = i_size_read(&v9inode->vfs_inode);
-
-        p9_debug(P9_DEBUG_FSC, "inode %p get attr %llu\n",
-                 &v9inode->vfs_inode, *size);
-}
-
 static enum
 fscache_checkaux v9fs_cache_inode_check_aux(void *cookie_netfs_data,
                                             const void *buffer,
-                                            uint16_t buflen)
+                                            uint16_t buflen,
+                                            loff_t object_size)
 {
         const struct v9fs_inode *v9inode = cookie_netfs_data;
 
@@ -118,7 +109,6 @@ fscache_checkaux v9fs_cache_inode_check_aux(void *cookie_netfs_data,
 const struct fscache_cookie_def v9fs_cache_inode_index_def = {
         .name           = "9p.inode",
         .type           = FSCACHE_COOKIE_TYPE_DATAFILE,
-        .get_attr       = v9fs_cache_inode_get_attr,
         .check_aux      = v9fs_cache_inode_check_aux,
 };
 
@@ -141,7 +131,9 @@ void v9fs_cache_inode_get_cookie(struct inode *inode)
                                                   sizeof(v9inode->qid.path),
                                                   &v9inode->qid.version,
                                                   sizeof(v9inode->qid.version),
-                                                  v9inode, true);
+                                                  v9inode,
+                                                  i_size_read(&v9inode->vfs_inode),
+                                                  true);
 
         p9_debug(P9_DEBUG_FSC, "inode %p get cookie %p\n",
                  inode, v9inode->fscache);
@@ -212,7 +204,9 @@ void v9fs_cache_inode_reset_cookie(struct inode *inode)
                                                   sizeof(v9inode->qid.path),
                                                   &v9inode->qid.version,
                                                   sizeof(v9inode->qid.version),
-                                                  v9inode, true);
+                                                  v9inode,
+                                                  i_size_read(&v9inode->vfs_inode),
+                                                  true);
         p9_debug(P9_DEBUG_FSC, "inode %p revalidating cookie old %p new %p\n",
                  inode, old, v9inode->fscache);
 
@@ -338,7 +332,8 @@ void __v9fs_readpage_to_fscache(struct inode *inode, struct page *page)
         const struct v9fs_inode *v9inode = V9FS_I(inode);
 
         p9_debug(P9_DEBUG_FSC, "inode %p page %p\n", inode, page);
-        ret = fscache_write_page(v9inode->fscache, page, GFP_KERNEL);
+        ret = fscache_write_page(v9inode->fscache, page,
+                                 i_size_read(&v9inode->vfs_inode), GFP_KERNEL);
         p9_debug(P9_DEBUG_FSC, "ret =  %d\n", ret);
         if (ret != 0)
                 v9fs_uncache_page(inode, page);
diff --git a/fs/afs/cache.c b/fs/afs/cache.c
index a16f1e024cf3..b1c31ec4523a 100644
--- a/fs/afs/cache.c
+++ b/fs/afs/cache.c
@@ -12,11 +12,10 @@
 #include <linux/sched.h>
 #include "internal.h"
 
-static void afs_vnode_cache_get_attr(const void *cookie_netfs_data,
-                                     uint64_t *size);
 static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data,
                                                        const void *buffer,
-                                                       uint16_t buflen);
+                                                       uint16_t buflen,
+                                                       loff_t object_size);
 
 struct fscache_netfs afs_cache_netfs = {
         .name                   = "afs",
@@ -36,31 +35,16 @@ struct fscache_cookie_def afs_volume_cache_index_def = {
 struct fscache_cookie_def afs_vnode_cache_index_def = {
         .name           = "AFS.vnode",
         .type           = FSCACHE_COOKIE_TYPE_DATAFILE,
-        .get_attr       = afs_vnode_cache_get_attr,
         .check_aux      = afs_vnode_cache_check_aux,
 };
 
 /*
- * provide updated file attributes
- */
-static void afs_vnode_cache_get_attr(const void *cookie_netfs_data,
-                                     uint64_t *size)
-{
-        const struct afs_vnode *vnode = cookie_netfs_data;
-
-        _enter("{%x,%x,%llx},",
-               vnode->fid.vnode, vnode->fid.unique,
-               vnode->status.data_version);
-
-        *size = vnode->status.size;
-}
-
-/*
  * check that the auxiliary data indicates that the entry is still valid
  */
 static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data,
                                                        const void *buffer,
-                                                       uint16_t buflen)
+                                                       uint16_t buflen,
+                                                       loff_t object_size)
 {
         struct afs_vnode *vnode = cookie_netfs_data;
         struct afs_vnode_cache_aux aux;
diff --git a/fs/afs/cell.c b/fs/afs/cell.c
index 0747460221cb..4235a05afc76 100644
--- a/fs/afs/cell.c
+++ b/fs/afs/cell.c
@@ -524,7 +524,7 @@ static int afs_activate_cell(struct afs_net *net, struct afs_cell *cell)
                                              &afs_cell_cache_index_def,
                                              cell->name, strlen(cell->name),
                                              NULL, 0,
-                                             cell, true);
+                                             cell, 0, true);
 #endif
         ret = afs_proc_cell_setup(net, cell);
         if (ret < 0)
diff --git a/fs/afs/file.c b/fs/afs/file.c
index a39192ced99e..79e665a35fea 100644
--- a/fs/afs/file.c
+++ b/fs/afs/file.c
@@ -339,7 +339,8 @@ int afs_page_filler(void *data, struct 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_write_page(vnode->cache, page, vnode->status.size,
+                                       GFP_KERNEL) != 0) {
                         fscache_uncache_page(vnode->cache, page);
                         BUG_ON(PageFsCache(page));
                 }
@@ -403,7 +404,8 @@ static void afs_readpages_page_done(struct afs_call *call, struct afs_read *req)
         /* send the page to the cache */
 #ifdef CONFIG_AFS_FSCACHE
         if (PageFsCache(page) &&
-            fscache_write_page(vnode->cache, page, GFP_KERNEL) != 0) {
+            fscache_write_page(vnode->cache, page, vnode->status.size,
+                               GFP_KERNEL) != 0) {
                 fscache_uncache_page(vnode->cache, page);
                 BUG_ON(PageFsCache(page));
         }
diff --git a/fs/afs/inode.c b/fs/afs/inode.c
index e499713efd2e..65c5b1edd338 100644
--- a/fs/afs/inode.c
+++ b/fs/afs/inode.c
@@ -265,7 +265,7 @@ static void afs_get_inode_cache(struct afs_vnode *vnode)
                                               &afs_vnode_cache_index_def,
                                               &key, sizeof(key),
                                               &aux, sizeof(aux),
-                                              vnode, true);
+                                              vnode, vnode->status.size, true);
 #endif
 }
 
diff --git a/fs/afs/volume.c b/fs/afs/volume.c
index 345cb2d675d2..3037bd01f617 100644
--- a/fs/afs/volume.c
+++ b/fs/afs/volume.c
@@ -227,7 +227,7 @@ void afs_activate_volume(struct afs_volume *volume)
                                                &afs_volume_cache_index_def,
                                                &volume->vid, sizeof(volume->vid),
                                                NULL, 0,
-                                               volume, true);
+                                               volume, 0, true);
 #endif
 
         write_lock(&volume->cell->proc_lock);
diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c
index 3264dcfdc92a..222bc5d8b62c 100644
--- a/fs/cachefiles/interface.c
+++ b/fs/cachefiles/interface.c
@@ -441,7 +441,7 @@ static int cachefiles_attr_changed(struct fscache_object *_object)
         loff_t oi_size;
         int ret;
 
-        _object->cookie->def->get_attr(_object->cookie->netfs_data, &ni_size);
+        ni_size = _object->store_limit_l;
 
         _enter("{OBJ%x},[%llu]",
                _object->debug_id, (unsigned long long) ni_size);
@@ -513,8 +513,7 @@ static void cachefiles_invalidate_object(struct fscache_operation *op)
         cache = container_of(object->fscache.cache,
                              struct cachefiles_cache, cache);
 
-        op->object->cookie->def->get_attr(op->object->cookie->netfs_data,
-                                          &ni_size);
+        ni_size = op->object->store_limit_l;
 
         _enter("{OBJ%x},[%llu]",
                op->object->debug_id, (unsigned long long)ni_size);
diff --git a/fs/cachefiles/xattr.c b/fs/cachefiles/xattr.c
index d84423c264af..0a29a00aed2e 100644
--- a/fs/cachefiles/xattr.c
+++ b/fs/cachefiles/xattr.c
@@ -182,7 +182,8 @@ int cachefiles_check_auxdata(struct cachefiles_object *object)
                 goto error;
 
         xlen--;
-        validity = fscache_check_aux(&object->fscache, &auxbuf->data, xlen);
+        validity = fscache_check_aux(&object->fscache, &auxbuf->data, xlen,
+                                     i_size_read(d_backing_inode(dentry)));
         if (validity != FSCACHE_CHECKAUX_OKAY)
                 goto error;
 
@@ -251,7 +252,8 @@ int cachefiles_check_object_xattr(struct cachefiles_object *object,
                        object->fscache.cookie->def->name, dlen);
 
                 result = fscache_check_aux(&object->fscache,
-                                           &auxbuf->data, dlen);
+                                           &auxbuf->data, dlen,
+                                           i_size_read(d_backing_inode(dentry)));
 
                 switch (result) {
                         /* entry okay as is */
diff --git a/fs/ceph/cache.c b/fs/ceph/cache.c
index fee869061f05..33a211b364ed 100644
--- a/fs/ceph/cache.c
+++ b/fs/ceph/cache.c
@@ -27,7 +27,6 @@
 struct ceph_aux_inode {
         u64             version;
         struct timespec mtime;
-        loff_t          size;
 };
 
 struct fscache_netfs ceph_cache_netfs = {
@@ -101,7 +100,7 @@ int ceph_fscache_register_fs(struct ceph_fs_client* fsc)
                                               &ceph_fscache_fsid_object_def,
                                               &ent->fsid, sizeof(ent->fsid) + uniq_len,
                                               NULL, 0,
-                                              fsc, true);
+                                              fsc, 0, true);
 
         if (fsc->fscache) {
                 ent->fscache = fsc->fscache;
@@ -117,27 +116,21 @@ out_unlock:
         return err;
 }
 
-static void ceph_fscache_inode_get_attr(const void *cookie_netfs_data,
-                                        uint64_t *size)
-{
-        const struct ceph_inode_info* ci = cookie_netfs_data;
-        *size = i_size_read(&ci->vfs_inode);
-}
-
 static enum fscache_checkaux ceph_fscache_inode_check_aux(
-        void *cookie_netfs_data, const void *data, uint16_t dlen)
+        void *cookie_netfs_data, const void *data, uint16_t dlen,
+        loff_t object_size)
 {
         struct ceph_aux_inode aux;
         struct ceph_inode_info* ci = cookie_netfs_data;
         struct inode* inode = &ci->vfs_inode;
 
-        if (dlen != sizeof(aux))
+        if (dlen != sizeof(aux) ||
+            i_size_read(inode) != object_size)
                 return FSCACHE_CHECKAUX_OBSOLETE;
 
         memset(&aux, 0, sizeof(aux));
         aux.version = ci->i_version;
         aux.mtime = inode->i_mtime;
-        aux.size = i_size_read(inode);
 
         if (memcmp(data, &aux, sizeof(aux)) != 0)
                 return FSCACHE_CHECKAUX_OBSOLETE;
@@ -149,7 +142,6 @@ static enum fscache_checkaux ceph_fscache_inode_check_aux(
 static const struct fscache_cookie_def ceph_fscache_inode_object_def = {
         .name           = "CEPH.inode",
         .type           = FSCACHE_COOKIE_TYPE_DATAFILE,
-        .get_attr       = ceph_fscache_inode_get_attr,
         .check_aux      = ceph_fscache_inode_check_aux,
 };
 
@@ -172,12 +164,11 @@ void ceph_fscache_register_inode_cookie(struct inode *inode)
                 memset(&aux, 0, sizeof(aux));
                 aux.version = ci->i_version;
                 aux.mtime = inode->i_mtime;
-                aux.size = i_size_read(inode);
                 ci->fscache = fscache_acquire_cookie(fsc->fscache,
                                                      &ceph_fscache_inode_object_def,
                                                      &ci->i_vino, sizeof(ci->i_vino),
                                                      &aux, sizeof(aux),
-                                                     ci, false);
+                                                     ci, i_size_read(inode), false);
         }
         inode_unlock(inode);
 }
@@ -214,7 +205,7 @@ void ceph_fscache_file_set_cookie(struct inode *inode, struct file *filp)
                 fscache_disable_cookie(ci->fscache, &ci->i_vino, false);
                 fscache_uncache_all_inode_pages(ci->fscache, inode);
         } else {
-                fscache_enable_cookie(ci->fscache, &ci->i_vino,
+                fscache_enable_cookie(ci->fscache, &ci->i_vino, i_size_read(inode),
                                       ceph_fscache_can_enable, inode);
                 if (fscache_cookie_enabled(ci->fscache)) {
                         dout("fscache_file_set_cookie %p %p enabling cache\n",
@@ -308,7 +299,8 @@ void ceph_readpage_to_fscache(struct inode *inode, struct page *page)
         if (!cache_valid(ci))
                 return;
 
-        ret = fscache_write_page(ci->fscache, page, GFP_KERNEL);
+        ret = fscache_write_page(ci->fscache, page, i_size_read(inode),
+                                 GFP_KERNEL);
         if (ret)
                  fscache_uncache_page(ci->fscache, page);
 }
diff --git a/fs/cifs/cache.c b/fs/cifs/cache.c
index b4fa270ef532..edf5f40898bf 100644
--- a/fs/cifs/cache.c
+++ b/fs/cifs/cache.c
@@ -87,7 +87,8 @@ char *extract_sharename(const char *treename)
 static enum
 fscache_checkaux cifs_fscache_super_check_aux(void *cookie_netfs_data,
                                               const void *data,
-                                              uint16_t datalen)
+                                              uint16_t datalen,
+                                              loff_t object_size)
 {
         struct cifs_fscache_super_auxdata auxdata;
         const struct cifs_tcon *tcon = cookie_netfs_data;
@@ -113,18 +114,11 @@ const struct fscache_cookie_def cifs_fscache_super_index_def = {
         .check_aux = cifs_fscache_super_check_aux,
 };
 
-static void
-cifs_fscache_inode_get_attr(const void *cookie_netfs_data, uint64_t *size)
-{
-        const struct cifsInodeInfo *cifsi = cookie_netfs_data;
-
-        *size = cifsi->vfs_inode.i_size;
-}
-
 static enum
 fscache_checkaux cifs_fscache_inode_check_aux(void *cookie_netfs_data,
                                               const void *data,
-                                              uint16_t datalen)
+                                              uint16_t datalen,
+                                              loff_t object_size)
 {
         struct cifs_fscache_inode_auxdata auxdata;
         struct cifsInodeInfo *cifsi = cookie_netfs_data;
@@ -146,6 +140,5 @@ fscache_checkaux cifs_fscache_inode_check_aux(void *cookie_netfs_data,
 const struct fscache_cookie_def cifs_fscache_inode_object_def = {
         .name           = "CIFS.uniqueid",
         .type           = FSCACHE_COOKIE_TYPE_DATAFILE,
-        .get_attr       = cifs_fscache_inode_get_attr,
         .check_aux      = cifs_fscache_inode_check_aux,
 };
diff --git a/fs/cifs/fscache.c b/fs/cifs/fscache.c
index b89b59b01759..25d3f66b2d50 100644
--- a/fs/cifs/fscache.c
+++ b/fs/cifs/fscache.c
@@ -79,7 +79,7 @@ void cifs_fscache_get_client_cookie(struct TCP_Server_Info *server)
                                        &cifs_fscache_server_index_def,
                                        &key, key_len,
                                        NULL, 0,
-                                       server, true);
+                                       server, 0, true);
         cifs_dbg(FYI, "%s: (0x%p/0x%p)\n",
                  __func__, server, server->fscache);
 }
@@ -109,7 +109,7 @@ void cifs_fscache_get_super_cookie(struct cifs_tcon *tcon)
                                        &cifs_fscache_super_index_def,
                                        sharename, strlen(sharename),
                                        &tcon->resource_id, sizeof(tcon->resource_id),
-                                       tcon, true);
+                                       tcon, 0, true);
         kfree(sharename);
         cifs_dbg(FYI, "%s: (0x%p/0x%p)\n",
                  __func__, server->fscache, tcon->fscache);
@@ -137,7 +137,7 @@ static void cifs_fscache_acquire_inode_cookie(struct cifsInodeInfo *cifsi,
                                        &cifs_fscache_inode_object_def,
                                        &cifsi->uniqueid, sizeof(cifsi->uniqueid),
                                        &auxdata, sizeof(auxdata),
-                                       cifsi, true);
+                                       cifsi, cifsi->vfs_inode.i_size, true);
 }
 
 static void cifs_fscache_enable_inode_cookie(struct inode *inode)
@@ -301,13 +301,15 @@ int __cifs_readpages_from_fscache(struct inode *inode,
 
 void __cifs_readpage_to_fscache(struct inode *inode, struct page *page)
 {
+        struct cifsInodeInfo *cifsi = CIFS_I(inode);
         int ret;
 
         cifs_dbg(FYI, "%s: (fsc: %p, p: %p, i: %p)\n",
-                 __func__, CIFS_I(inode)->fscache, page, inode);
-        ret = fscache_write_page(CIFS_I(inode)->fscache, page, GFP_KERNEL);
+                 __func__, cifsi->fscache, page, inode);
+        ret = fscache_write_page(cifsi->fscache, page,
+                                 cifsi->vfs_inode.i_size, GFP_KERNEL);
         if (ret != 0)
-                fscache_uncache_page(CIFS_I(inode)->fscache, page);
+                fscache_uncache_page(cifsi->fscache, page);
 }
 
 void __cifs_fscache_readpages_cancel(struct inode *inode, struct list_head *pages)
diff --git a/fs/fscache/cookie.c b/fs/fscache/cookie.c
index 4d6210082a60..8ca9a932d225 100644
--- a/fs/fscache/cookie.c
+++ b/fs/fscache/cookie.c
@@ -21,7 +21,8 @@ struct kmem_cache *fscache_cookie_jar;
 
 static atomic_t fscache_object_debug_id = ATOMIC_INIT(0);
 
-static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie);
+static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie,
+                                            loff_t object_size);
 static int fscache_alloc_object(struct fscache_cache *cache,
                                 struct fscache_cookie *cookie);
 static int fscache_attach_object(struct fscache_cookie *cookie,
@@ -61,6 +62,7 @@ struct fscache_cookie *__fscache_acquire_cookie(
         const void *index_key, size_t index_key_len,
         const void *aux_data, size_t aux_data_len,
         void *netfs_data,
+        loff_t object_size,
         bool enable)
 {
         struct fscache_cookie *cookie;
@@ -160,7 +162,7 @@ struct fscache_cookie *__fscache_acquire_cookie(
                  * - we create indices on disk when we need them as an index
                  * may exist in multiple caches */
                 if (cookie->type != FSCACHE_COOKIE_TYPE_INDEX) {
-                        if (fscache_acquire_non_index_cookie(cookie) == 0) {
+                        if (fscache_acquire_non_index_cookie(cookie, object_size) == 0) {
                                 set_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags);
                         } else {
                                 atomic_dec(&parent->n_children);
@@ -194,6 +196,7 @@ EXPORT_SYMBOL(__fscache_acquire_cookie);
  */
 void __fscache_enable_cookie(struct fscache_cookie *cookie,
                              const void *aux_data,
+                             loff_t object_size,
                              bool (*can_enable)(void *data),
                              void *data)
 {
@@ -215,7 +218,7 @@ void __fscache_enable_cookie(struct fscache_cookie *cookie,
                 /* Wait for outstanding disablement to complete */
                 __fscache_wait_on_invalidate(cookie);
 
-                if (fscache_acquire_non_index_cookie(cookie) == 0)
+                if (fscache_acquire_non_index_cookie(cookie, object_size) == 0)
                         set_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags);
         } else {
                 set_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags);
@@ -232,11 +235,11 @@ EXPORT_SYMBOL(__fscache_enable_cookie);
  * - this must make sure the index chain is instantiated and instantiate the
  *   object representation too
  */
-static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie)
+static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie,
+                                            loff_t object_size)
 {
         struct fscache_object *object;
         struct fscache_cache *cache;
-        uint64_t i_size;
         int ret;
 
         _enter("");
@@ -275,9 +278,6 @@ static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie)
                 return ret;
         }
 
-        /* pass on how big the object we're caching is supposed to be */
-        cookie->def->get_attr(cookie->netfs_data, &i_size);
-
         spin_lock(&cookie->lock);
         if (hlist_empty(&cookie->backing_objects)) {
                 spin_unlock(&cookie->lock);
@@ -287,7 +287,7 @@ static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie)
         object = hlist_entry(cookie->backing_objects.first,
                              struct fscache_object, cookie_link);
 
-        fscache_set_store_limit(object, i_size);
+        fscache_set_store_limit(object, object_size);
 
         /* initiate the process of looking up all the objects in the chain
          * (done by fscache_initialise_object()) */
diff --git a/fs/fscache/fsdef.c b/fs/fscache/fsdef.c
index 1122e97d56e8..aa46e48d8c75 100644
--- a/fs/fscache/fsdef.c
+++ b/fs/fscache/fsdef.c
@@ -16,7 +16,8 @@
 static
 enum fscache_checkaux fscache_fsdef_netfs_check_aux(void *cookie_netfs_data,
                                                     const void *data,
-                                                    uint16_t datalen);
+                                                    uint16_t datalen,
+                                                    loff_t object_size);
 
 /*
  * The root index is owned by FS-Cache itself.
@@ -76,7 +77,8 @@ struct fscache_cookie_def fscache_fsdef_netfs_def = {
 static enum fscache_checkaux fscache_fsdef_netfs_check_aux(
         void *cookie_netfs_data,
         const void *data,
-        uint16_t datalen)
+        uint16_t datalen,
+        loff_t object_size)
 {
         struct fscache_netfs *netfs = cookie_netfs_data;
         uint32_t version;
diff --git a/fs/fscache/object.c b/fs/fscache/object.c
index a7b28f876fde..1085ca12e25c 100644
--- a/fs/fscache/object.c
+++ b/fs/fscache/object.c
@@ -922,7 +922,8 @@ static void fscache_dequeue_object(struct fscache_object *object)
  * and creation).
  */
 enum fscache_checkaux fscache_check_aux(struct fscache_object *object,
-                                        const void *data, uint16_t datalen)
+                                        const void *data, uint16_t datalen,
+                                        loff_t object_size)
 {
         enum fscache_checkaux result;
 
@@ -932,7 +933,7 @@ enum fscache_checkaux fscache_check_aux(struct fscache_object *object,
         }
 
         result = object->cookie->def->check_aux(object->cookie->netfs_data,
-                                                data, datalen);
+                                                data, datalen, object_size);
         switch (result) {
                 /* entry okay as is */
         case FSCACHE_CHECKAUX_OKAY:
diff --git a/fs/fscache/page.c b/fs/fscache/page.c
index 810b33aced1c..111349f67d98 100644
--- a/fs/fscache/page.c
+++ b/fs/fscache/page.c
@@ -963,6 +963,7 @@ void fscache_invalidate_writes(struct fscache_cookie *cookie)
  */
 int __fscache_write_page(struct fscache_cookie *cookie,
                          struct page *page,
+                         loff_t object_size,
                          gfp_t gfp)
 {
         struct fscache_storage *op;
@@ -1014,6 +1015,10 @@ int __fscache_write_page(struct fscache_cookie *cookie,
         /* add the page to the pending-storage radix tree on the backing
          * object */
         spin_lock(&object->lock);
+
+        if (object->store_limit_l != object_size)
+                fscache_set_store_limit(object, object_size);
+
         spin_lock(&cookie->stores_lock);
 
         _debug("store limit %llx", (unsigned long long) object->store_limit);
diff --git a/fs/nfs/fscache-index.c b/fs/nfs/fscache-index.c
index 6fd3679b7137..1c5d8d31fc0a 100644
--- a/fs/nfs/fscache-index.c
+++ b/fs/nfs/fscache-index.c
@@ -70,20 +70,6 @@ const struct fscache_cookie_def nfs_fscache_super_index_def = {
 };
 
 /*
- * Get certain file attributes from the netfs data
- * - This function can be absent for an index
- * - Not permitted to return an error
- * - The netfs data from the cookie being used as the source is presented
- */
-static void nfs_fscache_inode_get_attr(const void *cookie_netfs_data,
-                                       uint64_t *size)
-{
-        const struct nfs_inode *nfsi = cookie_netfs_data;
-
-        *size = nfsi->vfs_inode.i_size;
-}
-
-/*
  * Consult the netfs about the state of an object
  * - This function can be absent if the index carries no state data
  * - The netfs data from the cookie being used as the target is
@@ -92,7 +78,8 @@ static void nfs_fscache_inode_get_attr(const void *cookie_netfs_data,
 static
 enum fscache_checkaux nfs_fscache_inode_check_aux(void *cookie_netfs_data,
                                                   const void *data,
-                                                  uint16_t datalen)
+                                                  uint16_t datalen,
+                                                  loff_t object_size)
 {
         struct nfs_fscache_inode_auxdata auxdata;
         struct nfs_inode *nfsi = cookie_netfs_data;
@@ -101,7 +88,6 @@ enum fscache_checkaux nfs_fscache_inode_check_aux(void *cookie_netfs_data,
                 return FSCACHE_CHECKAUX_OBSOLETE;
 
         memset(&auxdata, 0, sizeof(auxdata));
-        auxdata.size = nfsi->vfs_inode.i_size;
         auxdata.mtime = nfsi->vfs_inode.i_mtime;
         auxdata.ctime = nfsi->vfs_inode.i_ctime;
 
@@ -150,7 +136,6 @@ static void nfs_fh_put_context(void *cookie_netfs_data, void *context)
 const struct fscache_cookie_def nfs_fscache_inode_object_def = {
         .name           = "NFS.fh",
         .type           = FSCACHE_COOKIE_TYPE_DATAFILE,
-        .get_attr       = nfs_fscache_inode_get_attr,
         .check_aux      = nfs_fscache_inode_check_aux,
         .get_context    = nfs_fh_get_context,
         .put_context    = nfs_fh_put_context,
diff --git a/fs/nfs/fscache.c b/fs/nfs/fscache.c
index c45ba2691cee..b55fc7920c3b 100644
--- a/fs/nfs/fscache.c
+++ b/fs/nfs/fscache.c
@@ -86,7 +86,7 @@ void nfs_fscache_get_client_cookie(struct nfs_client *clp)
                                               &nfs_fscache_server_index_def,
                                               &key, len,
                                               NULL, 0,
-                                              clp, true);
+                                              clp, 0, true);
         dfprintk(FSCACHE, "NFS: get client cookie (0x%p/0x%p)\n",
                  clp, clp->fscache);
 }
@@ -188,7 +188,7 @@ void nfs_fscache_get_super_cookie(struct super_block *sb, const char *uniq, int
                                                &nfs_fscache_super_index_def,
                                                key, sizeof(*key) + ulen,
                                                NULL, 0,
-                                               nfss, true);
+                                               nfss, 0, true);
         dfprintk(FSCACHE, "NFS: get superblock cookie (0x%p/0x%p)\n",
                  nfss, nfss->fscache);
         return;
@@ -237,7 +237,6 @@ void nfs_fscache_init_inode(struct inode *inode)
                 return;
 
         memset(&auxdata, 0, sizeof(auxdata));
-        auxdata.size = nfsi->vfs_inode.i_size;
         auxdata.mtime = nfsi->vfs_inode.i_mtime;
         auxdata.ctime = nfsi->vfs_inode.i_ctime;
 
@@ -248,7 +247,7 @@ void nfs_fscache_init_inode(struct inode *inode)
                                                &nfs_fscache_inode_object_def,
                                                nfsi->fh.data, nfsi->fh.size,
                                                &auxdata, sizeof(auxdata),
-                                               nfsi, false);
+                                               nfsi, nfsi->vfs_inode.i_size, false);
 }
 
 /*
@@ -263,7 +262,6 @@ void nfs_fscache_clear_inode(struct inode *inode)
         dfprintk(FSCACHE, "NFS: clear cookie (0x%p/0x%p)\n", nfsi, cookie);
 
         memset(&auxdata, 0, sizeof(auxdata));
-        auxdata.size = nfsi->vfs_inode.i_size;
         auxdata.mtime = nfsi->vfs_inode.i_mtime;
         auxdata.ctime = nfsi->vfs_inode.i_ctime;
         fscache_relinquish_cookie(cookie, &auxdata, false);
@@ -306,7 +304,6 @@ void nfs_fscache_open_file(struct inode *inode, struct file *filp)
                 return;
 
         memset(&auxdata, 0, sizeof(auxdata));
-        auxdata.size = nfsi->vfs_inode.i_size;
         auxdata.mtime = nfsi->vfs_inode.i_mtime;
         auxdata.ctime = nfsi->vfs_inode.i_ctime;
 
@@ -317,7 +314,7 @@ void nfs_fscache_open_file(struct inode *inode, struct file *filp)
                 fscache_uncache_all_inode_pages(cookie, inode);
         } else {
                 dfprintk(FSCACHE, "NFS: nfsi 0x%p enabling cache\n", nfsi);
-                fscache_enable_cookie(cookie, &auxdata,
+                fscache_enable_cookie(cookie, &auxdata, nfsi->vfs_inode.i_size,
                                       nfs_fscache_can_enable, inode);
                 if (fscache_cookie_enabled(cookie))
                         set_bit(NFS_INO_FSCACHE, &NFS_I(inode)->flags);
@@ -495,7 +492,8 @@ void __nfs_readpage_to_fscache(struct inode *inode, struct page *page, int sync)
                  "NFS: readpage_to_fscache(fsc:%p/p:%p(i:%lx f:%lx)/%d)\n",
                  nfs_i_fscache(inode), page, page->index, page->flags, sync);
 
-        ret = fscache_write_page(nfs_i_fscache(inode), page, GFP_KERNEL);
+        ret = fscache_write_page(nfs_i_fscache(inode), page,
+                                 inode->i_size, GFP_KERNEL);
         dfprintk(FSCACHE,
                  "NFS:     readpage_to_fscache: p:%p(i:%lu f:%lx) ret %d\n",
                  page, page->index, page->flags, ret);
diff --git a/fs/nfs/fscache.h b/fs/nfs/fscache.h
index 96e989f579d1..161ba2edb9d0 100644
--- a/fs/nfs/fscache.h
+++ b/fs/nfs/fscache.h
@@ -68,7 +68,6 @@ struct nfs_fscache_key {
 struct nfs_fscache_inode_auxdata {
         struct timespec mtime;
         struct timespec ctime;
-        loff_t          size;
         u64             change_attr;
 };