fscache: Attach the index key and aux data to the cookie

Attach copies of the index key and auxiliary data to the fscache cookie so
that:

 (1) The callbacks to the netfs for this stuff can be eliminated.  This
     can simplify things in the cache as the information is still
     available, even after the cache has relinquished the cookie.

 (2) Simplifies the locking requirements of accessing the information as we
     don't have to worry about the netfs object going away on us.

 (3) The cache can do lazy updating of the coherency information on disk.
     As long as the cache is flushed before reboot/poweroff, there's no
     need to update the coherency info on disk every time it changes.

 (4) Cookies can be hashed or put in a tree as the index key is easily
     available.  This allows:

     (a) Checks for duplicate cookies can be made at the top fscache layer
     	 rather than down in the bowels of the cache backend.

     (b) Caching can be added to a netfs object that has a cookie if the
     	 cache is brought online after the netfs object is allocated.

A certain amount of space is made in the cookie for inline copies of the
data, but if it won't fit there, extra memory will be allocated for it.

The downside of this is that live cache operation requires more memory.

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

1 files changed, 78 insertions, 5 deletions

diff --git a/fs/nfs/fscache.c b/fs/nfs/fscache.c
index d63bea8bbfbb..c45ba2691cee 100644
--- a/fs/nfs/fscache.c
+++ b/fs/nfs/fscache.c
@@ -18,6 +18,7 @@
 #include <linux/in6.h>
 #include <linux/seq_file.h>
 #include <linux/slab.h>
+#include <linux/iversion.h>
 
 #include "internal.h"
 #include "iostat.h"
@@ -29,6 +30,21 @@ static struct rb_root nfs_fscache_keys = RB_ROOT;
 static DEFINE_SPINLOCK(nfs_fscache_keys_lock);
 
 /*
+ * Layout of the key for an NFS server cache object.
+ */
+struct nfs_server_key {
+        struct {
+                uint16_t        nfsversion;             /* NFS protocol version */
+                uint16_t        family;                 /* address family */
+                __be16          port;                   /* IP port */
+        } hdr;
+        union {
+                struct in_addr  ipv4_addr;      /* IPv4 address */
+                struct in6_addr ipv6_addr;      /* IPv6 address */
+        };
+} __packed;
+
+/*
  * Get the per-client index cookie for an NFS client if the appropriate mount
  * flag was set
  * - We always try and get an index cookie for the client, but get filehandle
@@ -36,9 +52,40 @@ static DEFINE_SPINLOCK(nfs_fscache_keys_lock);
  */
 void nfs_fscache_get_client_cookie(struct nfs_client *clp)
 {
+        const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &clp->cl_addr;
+        const struct sockaddr_in *sin = (struct sockaddr_in *) &clp->cl_addr;
+        struct nfs_server_key key;
+        uint16_t len = sizeof(key.hdr);
+
+        memset(&key, 0, sizeof(key));
+        key.hdr.nfsversion = clp->rpc_ops->version;
+        key.hdr.family = clp->cl_addr.ss_family;
+
+        switch (clp->cl_addr.ss_family) {
+        case AF_INET:
+                key.hdr.port = sin->sin_port;
+                key.ipv4_addr = sin->sin_addr;
+                len += sizeof(key.ipv4_addr);
+                break;
+
+        case AF_INET6:
+                key.hdr.port = sin6->sin6_port;
+                key.ipv6_addr = sin6->sin6_addr;
+                len += sizeof(key.ipv6_addr);
+                break;
+
+        default:
+                printk(KERN_WARNING "NFS: Unknown network family '%d'\n",
+                       clp->cl_addr.ss_family);
+                clp->fscache = NULL;
+                return;
+        }
+
         /* create a cache index for looking up filehandles */
         clp->fscache = fscache_acquire_cookie(nfs_fscache_netfs.primary_index,
                                               &nfs_fscache_server_index_def,
+                                              &key, len,
+                                              NULL, 0,
                                               clp, true);
         dfprintk(FSCACHE, "NFS: get client cookie (0x%p/0x%p)\n",
                  clp, clp->fscache);
@@ -52,7 +99,7 @@ void nfs_fscache_release_client_cookie(struct nfs_client *clp)
         dfprintk(FSCACHE, "NFS: releasing client cookie (0x%p/0x%p)\n",
                  clp, clp->fscache);
 
-        fscache_relinquish_cookie(clp->fscache, 0);
+        fscache_relinquish_cookie(clp->fscache, NULL, false);
         clp->fscache = NULL;
 }
 
@@ -139,6 +186,8 @@ 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,
+                                               key, sizeof(*key) + ulen,
+                                               NULL, 0,
                                                nfss, true);
         dfprintk(FSCACHE, "NFS: get superblock cookie (0x%p/0x%p)\n",
                  nfss, nfss->fscache);
@@ -163,7 +212,7 @@ void nfs_fscache_release_super_cookie(struct super_block *sb)
         dfprintk(FSCACHE, "NFS: releasing superblock cookie (0x%p/0x%p)\n",
                  nfss, nfss->fscache);
 
-        fscache_relinquish_cookie(nfss->fscache, 0);
+        fscache_relinquish_cookie(nfss->fscache, NULL, false);
         nfss->fscache = NULL;
 
         if (nfss->fscache_key) {
@@ -180,13 +229,25 @@ void nfs_fscache_release_super_cookie(struct super_block *sb)
  */
 void nfs_fscache_init_inode(struct inode *inode)
 {
+        struct nfs_fscache_inode_auxdata auxdata;
         struct nfs_inode *nfsi = NFS_I(inode);
 
         nfsi->fscache = NULL;
         if (!S_ISREG(inode->i_mode))
                 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;
+
+        if (NFS_SERVER(&nfsi->vfs_inode)->nfs_client->rpc_ops->version == 4)
+                auxdata.change_attr = inode_peek_iversion_raw(&nfsi->vfs_inode);
+
         nfsi->fscache = fscache_acquire_cookie(NFS_SB(inode->i_sb)->fscache,
                                                &nfs_fscache_inode_object_def,
+                                               nfsi->fh.data, nfsi->fh.size,
+                                               &auxdata, sizeof(auxdata),
                                                nfsi, false);
 }
 
@@ -195,12 +256,17 @@ void nfs_fscache_init_inode(struct inode *inode)
  */
 void nfs_fscache_clear_inode(struct inode *inode)
 {
+        struct nfs_fscache_inode_auxdata auxdata;
         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, cookie);
 
-        fscache_relinquish_cookie(cookie, false);
+        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);
         nfsi->fscache = NULL;
 }
 
@@ -232,20 +298,27 @@ static bool nfs_fscache_can_enable(void *data)
  */
 void nfs_fscache_open_file(struct inode *inode, struct file *filp)
 {
+        struct nfs_fscache_inode_auxdata auxdata;
         struct nfs_inode *nfsi = NFS_I(inode);
         struct fscache_cookie *cookie = nfs_i_fscache(inode);
 
         if (!fscache_cookie_valid(cookie))
                 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;
+
         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_disable_cookie(cookie, &auxdata, 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);
+                fscache_enable_cookie(cookie, &auxdata,
+                                      nfs_fscache_can_enable, inode);
                 if (fscache_cookie_enabled(cookie))
                         set_bit(NFS_INO_FSCACHE, &NFS_I(inode)->flags);
         }