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, 22 insertions, 51 deletions

diff --git a/fs/9p/cache.c b/fs/9p/cache.c
index 64c58eb26159..9d0030af5672 100644
--- a/fs/9p/cache.c
+++ b/fs/9p/cache.c
@@ -55,41 +55,26 @@ int v9fs_random_cachetag(struct v9fs_session_info *v9ses)
         return scnprintf(v9ses->cachetag, CACHETAG_LEN, "%lu", jiffies);
 }
 
-static uint16_t v9fs_cache_session_get_key(const void *cookie_netfs_data,
-                                           void *buffer, uint16_t bufmax)
-{
-        struct v9fs_session_info *v9ses;
-        uint16_t klen = 0;
-
-        v9ses = (struct v9fs_session_info *)cookie_netfs_data;
-        p9_debug(P9_DEBUG_FSC, "session %p buf %p size %u\n",
-                 v9ses, buffer, bufmax);
-
-        if (v9ses->cachetag)
-                klen = strlen(v9ses->cachetag);
-
-        if (klen > bufmax)
-                return 0;
-
-        memcpy(buffer, v9ses->cachetag, klen);
-        p9_debug(P9_DEBUG_FSC, "cache session tag %s\n", v9ses->cachetag);
-        return klen;
-}
-
 const struct fscache_cookie_def v9fs_cache_session_index_def = {
         .name           = "9P.session",
         .type           = FSCACHE_COOKIE_TYPE_INDEX,
-        .get_key        = v9fs_cache_session_get_key,
 };
 
 void v9fs_cache_session_get_cookie(struct v9fs_session_info *v9ses)
 {
         /* If no cache session tag was specified, we generate a random one. */
-        if (!v9ses->cachetag)
-                v9fs_random_cachetag(v9ses);
+        if (!v9ses->cachetag) {
+                if (v9fs_random_cachetag(v9ses) < 0) {
+                        v9ses->fscache = NULL;
+                        return;
+                }
+        }
 
         v9ses->fscache = fscache_acquire_cookie(v9fs_cache_netfs.primary_index,
                                                 &v9fs_cache_session_index_def,
+                                                v9ses->cachetag,
+                                                strlen(v9ses->cachetag),
+                                                NULL, 0,
                                                 v9ses, true);
         p9_debug(P9_DEBUG_FSC, "session %p get cookie %p\n",
                  v9ses, v9ses->fscache);
@@ -99,21 +84,10 @@ void v9fs_cache_session_put_cookie(struct v9fs_session_info *v9ses)
 {
         p9_debug(P9_DEBUG_FSC, "session %p put cookie %p\n",
                  v9ses, v9ses->fscache);
-        fscache_relinquish_cookie(v9ses->fscache, 0);
+        fscache_relinquish_cookie(v9ses->fscache, NULL, false);
         v9ses->fscache = NULL;
 }
 
-
-static uint16_t v9fs_cache_inode_get_key(const void *cookie_netfs_data,
-                                         void *buffer, uint16_t bufmax)
-{
-        const struct v9fs_inode *v9inode = cookie_netfs_data;
-        memcpy(buffer, &v9inode->qid.path, sizeof(v9inode->qid.path));
-        p9_debug(P9_DEBUG_FSC, "inode %p get key %llu\n",
-                 &v9inode->vfs_inode, v9inode->qid.path);
-        return sizeof(v9inode->qid.path);
-}
-
 static void v9fs_cache_inode_get_attr(const void *cookie_netfs_data,
                                       uint64_t *size)
 {
@@ -124,16 +98,6 @@ static void v9fs_cache_inode_get_attr(const void *cookie_netfs_data,
                  &v9inode->vfs_inode, *size);
 }
 
-static uint16_t v9fs_cache_inode_get_aux(const void *cookie_netfs_data,
-                                         void *buffer, uint16_t buflen)
-{
-        const struct v9fs_inode *v9inode = cookie_netfs_data;
-        memcpy(buffer, &v9inode->qid.version, sizeof(v9inode->qid.version));
-        p9_debug(P9_DEBUG_FSC, "inode %p get aux %u\n",
-                 &v9inode->vfs_inode, v9inode->qid.version);
-        return sizeof(v9inode->qid.version);
-}
-
 static enum
 fscache_checkaux v9fs_cache_inode_check_aux(void *cookie_netfs_data,
                                             const void *buffer,
@@ -154,9 +118,7 @@ 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_key        = v9fs_cache_inode_get_key,
         .get_attr       = v9fs_cache_inode_get_attr,
-        .get_aux        = v9fs_cache_inode_get_aux,
         .check_aux      = v9fs_cache_inode_check_aux,
 };
 
@@ -175,6 +137,10 @@ void v9fs_cache_inode_get_cookie(struct inode *inode)
         v9ses = v9fs_inode2v9ses(inode);
         v9inode->fscache = fscache_acquire_cookie(v9ses->fscache,
                                                   &v9fs_cache_inode_index_def,
+                                                  &v9inode->qid.path,
+                                                  sizeof(v9inode->qid.path),
+                                                  &v9inode->qid.version,
+                                                  sizeof(v9inode->qid.version),
                                                   v9inode, true);
 
         p9_debug(P9_DEBUG_FSC, "inode %p get cookie %p\n",
@@ -190,7 +156,8 @@ void v9fs_cache_inode_put_cookie(struct inode *inode)
         p9_debug(P9_DEBUG_FSC, "inode %p put cookie %p\n",
                  inode, v9inode->fscache);
 
-        fscache_relinquish_cookie(v9inode->fscache, 0);
+        fscache_relinquish_cookie(v9inode->fscache, &v9inode->qid.version,
+                                  false);
         v9inode->fscache = NULL;
 }
 
@@ -203,7 +170,7 @@ void v9fs_cache_inode_flush_cookie(struct inode *inode)
         p9_debug(P9_DEBUG_FSC, "inode %p flush cookie %p\n",
                  inode, v9inode->fscache);
 
-        fscache_relinquish_cookie(v9inode->fscache, 1);
+        fscache_relinquish_cookie(v9inode->fscache, NULL, true);
         v9inode->fscache = NULL;
 }
 
@@ -236,11 +203,15 @@ void v9fs_cache_inode_reset_cookie(struct inode *inode)
         old = v9inode->fscache;
 
         mutex_lock(&v9inode->fscache_lock);
-        fscache_relinquish_cookie(v9inode->fscache, 1);
+        fscache_relinquish_cookie(v9inode->fscache, NULL, true);
 
         v9ses = v9fs_inode2v9ses(inode);
         v9inode->fscache = fscache_acquire_cookie(v9ses->fscache,
                                                   &v9fs_cache_inode_index_def,
+                                                  &v9inode->qid.path,
+                                                  sizeof(v9inode->qid.path),
+                                                  &v9inode->qid.version,
+                                                  sizeof(v9inode->qid.version),
                                                   v9inode, true);
         p9_debug(P9_DEBUG_FSC, "inode %p revalidating cookie old %p new %p\n",
                  inode, old, v9inode->fscache);