cifs: define inode-level cache object and register them

Define inode-level data storage objects (managed by cifsInodeInfo structs).
Each inode-level object is created in a super-block level object and is itself
a data storage object in to which pages from the inode are stored.

The inode object is keyed by UniqueId. The coherency data being used is
LastWriteTime, LastChangeTime and end of file reported by the server.

Signed-off-by: Suresh Jayaraman <[email protected]>
Signed-off-by: Steve French <[email protected]>

diff --git a/fs/cifs/cache.c b/fs/cifs/cache.c
index 15532abdac14ffcbef46dc51ac4d238827c91b24..b2649cfd3a04cc552457609c523c2148b563ffca 100644 (file)
--- a/fs/cifs/cache.c
+++ b/fs/cifs/cache.c
@@ -215,3 +215,86 @@ const struct fscache_cookie_def cifs_fscache_super_index_def = {
        .check_aux = cifs_fscache_super_check_aux,
 };
 
+/*
+ * Auxiliary data attached to CIFS inode within the cache
+ */
+struct cifs_fscache_inode_auxdata {
+       struct timespec last_write_time;
+       struct timespec last_change_time;
+       u64             eof;
+};
+
+static uint16_t cifs_fscache_inode_get_key(const void *cookie_netfs_data,
+                                          void *buffer, uint16_t maxbuf)
+{
+       const struct cifsInodeInfo *cifsi = cookie_netfs_data;
+       uint16_t keylen;
+
+       /* use the UniqueId as the key */
+       keylen = sizeof(cifsi->uniqueid);
+       if (keylen > maxbuf)
+               keylen = 0;
+       else
+               memcpy(buffer, &cifsi->uniqueid, keylen);
+
+       return keylen;
+}
+
+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 uint16_t
+cifs_fscache_inode_get_aux(const void *cookie_netfs_data, void *buffer,
+                          uint16_t maxbuf)
+{
+       struct cifs_fscache_inode_auxdata auxdata;
+       const struct cifsInodeInfo *cifsi = cookie_netfs_data;
+
+       memset(&auxdata, 0, sizeof(auxdata));
+       auxdata.eof = cifsi->server_eof;
+       auxdata.last_write_time = cifsi->vfs_inode.i_mtime;
+       auxdata.last_change_time = cifsi->vfs_inode.i_ctime;
+
+       if (maxbuf > sizeof(auxdata))
+               maxbuf = sizeof(auxdata);
+
+       memcpy(buffer, &auxdata, maxbuf);
+
+       return maxbuf;
+}
+
+static enum
+fscache_checkaux cifs_fscache_inode_check_aux(void *cookie_netfs_data,
+                                             const void *data,
+                                             uint16_t datalen)
+{
+       struct cifs_fscache_inode_auxdata auxdata;
+       struct cifsInodeInfo *cifsi = cookie_netfs_data;
+
+       if (datalen != sizeof(auxdata))
+               return FSCACHE_CHECKAUX_OBSOLETE;
+
+       memset(&auxdata, 0, sizeof(auxdata));
+       auxdata.eof = cifsi->server_eof;
+       auxdata.last_write_time = cifsi->vfs_inode.i_mtime;
+       auxdata.last_change_time = cifsi->vfs_inode.i_ctime;
+
+       if (memcmp(data, &auxdata, datalen) != 0)
+               return FSCACHE_CHECKAUX_OBSOLETE;
+
+       return FSCACHE_CHECKAUX_OKAY;
+}
+
+const struct fscache_cookie_def cifs_fscache_inode_object_def = {
+       .name           = "CIFS.uniqueid",
+       .type           = FSCACHE_COOKIE_TYPE_DATAFILE,
+       .get_key        = cifs_fscache_inode_get_key,
+       .get_attr       = cifs_fscache_inode_get_attr,
+       .get_aux        = cifs_fscache_inode_get_aux,
+       .check_aux      = cifs_fscache_inode_check_aux,
+};

diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 24d7f4ab3b65925051bf60386886865633335583..8a2cf129e535a21a8cd8bf7bc9116e2bbbd025da 100644 (file)
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -329,6 +329,12 @@ cifs_destroy_inode(struct inode *inode)
        kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 }
 
+static void
+cifs_clear_inode(struct inode *inode)
+{
+       cifs_fscache_release_inode_cookie(inode);
+}
+
 static void
 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
 {
@@ -490,6 +496,7 @@ static const struct super_operations cifs_super_ops = {
        .alloc_inode = cifs_alloc_inode,
        .destroy_inode = cifs_destroy_inode,
        .drop_inode     = cifs_drop_inode,
+       .clear_inode    = cifs_clear_inode,
 /*     .delete_inode   = cifs_delete_inode,  */  /* Do not need above
        function unless later we add lazy close of inodes or unless the
        kernel forgets to call us with the same number of releases (closes)

diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index a3e403e7e163444f9da7b7e3d78d2c5543a5212e..9b7cf9aa3a000655d4dd781025c67a34691dc1b2 100644 (file)
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -390,6 +390,9 @@ struct cifsInodeInfo {
        bool invalid_mapping:1;         /* pagecache is invalid */
        u64  server_eof;                /* current file size on server */
        u64  uniqueid;                  /* server inode number */
+#ifdef CONFIG_CIFS_FSCACHE
+       struct fscache_cookie *fscache;
+#endif
        struct inode vfs_inode;
 };
 

diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index b5fb2a0607b01cc9af354e55ac9dd23a8025817d..d302d941f9acd0e035a0c0b7e947b8b7fe9e224f 100644 (file)
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -40,6 +40,7 @@
 #include "cifs_unicode.h"
 #include "cifs_debug.h"
 #include "cifs_fs_sb.h"
+#include "fscache.h"
 
 static inline int cifs_convert_flags(unsigned int flags)
 {
@@ -282,6 +283,9 @@ int cifs_open(struct inode *inode, struct file *file)
                                CIFSSMBClose(xid, tcon, netfid);
                                rc = -ENOMEM;
                        }
+
+                       cifs_fscache_set_inode_cookie(inode, file);
+
                        goto out;
                } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
                        if (tcon->ses->serverNOS)
@@ -373,6 +377,8 @@ int cifs_open(struct inode *inode, struct file *file)
                goto out;
        }
 
+       cifs_fscache_set_inode_cookie(inode, file);
+
        if (oplock & CIFS_CREATE_ACTION) {
                /* time to set mode which we can not set earlier due to
                   problems creating new read-only files */

diff --git a/fs/cifs/fscache.c b/fs/cifs/fscache.c
index eba9beb94a4c1fba3c23af95f185ce02a22bfdfa..6c8d96758ddb2e65d818dcdb6adc714ffeab63c9 100644 (file)
--- a/fs/cifs/fscache.c
+++ b/fs/cifs/fscache.c
@@ -21,6 +21,7 @@
 #include "fscache.h"
 #include "cifsglob.h"
 #include "cifs_debug.h"
+#include "cifs_fs_sb.h"
 
 void cifs_fscache_get_client_cookie(struct TCP_Server_Info *server)
 {
@@ -56,3 +57,70 @@ void cifs_fscache_release_super_cookie(struct cifsTconInfo *tcon)
        fscache_relinquish_cookie(tcon->fscache, 0);
        tcon->fscache = NULL;
 }
+
+static void cifs_fscache_enable_inode_cookie(struct inode *inode)
+{
+       struct cifsInodeInfo *cifsi = CIFS_I(inode);
+       struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
+
+       if (cifsi->fscache)
+               return;
+
+       cifsi->fscache = fscache_acquire_cookie(cifs_sb->tcon->fscache,
+                               &cifs_fscache_inode_object_def,
+                               cifsi);
+       cFYI(1, "CIFS: got FH cookie (0x%p/0x%p)",
+                       cifs_sb->tcon->fscache, cifsi->fscache);
+}
+
+void cifs_fscache_release_inode_cookie(struct inode *inode)
+{
+       struct cifsInodeInfo *cifsi = CIFS_I(inode);
+
+       if (cifsi->fscache) {
+               cFYI(1, "CIFS releasing inode cookie (0x%p)",
+                               cifsi->fscache);
+               fscache_relinquish_cookie(cifsi->fscache, 0);
+               cifsi->fscache = NULL;
+       }
+}
+
+static void cifs_fscache_disable_inode_cookie(struct inode *inode)
+{
+       struct cifsInodeInfo *cifsi = CIFS_I(inode);
+
+       if (cifsi->fscache) {
+               cFYI(1, "CIFS disabling inode cookie (0x%p)",
+                               cifsi->fscache);
+               fscache_relinquish_cookie(cifsi->fscache, 1);
+               cifsi->fscache = NULL;
+       }
+}
+
+void cifs_fscache_set_inode_cookie(struct inode *inode, struct file *filp)
+{
+       if ((filp->f_flags & O_ACCMODE) != O_RDONLY)
+               cifs_fscache_disable_inode_cookie(inode);
+       else {
+               cifs_fscache_enable_inode_cookie(inode);
+               cFYI(1, "CIFS: fscache inode cookie set");
+       }
+}
+
+void cifs_fscache_reset_inode_cookie(struct inode *inode)
+{
+       struct cifsInodeInfo *cifsi = CIFS_I(inode);
+       struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
+       struct fscache_cookie *old = cifsi->fscache;
+
+       if (cifsi->fscache) {
+               /* retire the current fscache cache and get a new one */
+               fscache_relinquish_cookie(cifsi->fscache, 1);
+
+               cifsi->fscache = fscache_acquire_cookie(cifs_sb->tcon->fscache,
+                                       &cifs_fscache_inode_object_def,
+                                       cifsi);
+               cFYI(1, "CIFS: new cookie 0x%p oldcookie 0x%p",
+                               cifsi->fscache, old);
+       }
+}

diff --git a/fs/cifs/fscache.h b/fs/cifs/fscache.h
index d2ba628b72cd3df7f06e77d0bd417336f48c3643..1008f405083530adb9471f64d0c56fd547ff63d1 100644 (file)
--- a/fs/cifs/fscache.h
+++ b/fs/cifs/fscache.h
@@ -30,6 +30,8 @@
 extern struct fscache_netfs cifs_fscache_netfs;
 extern const struct fscache_cookie_def cifs_fscache_server_index_def;
 extern const struct fscache_cookie_def cifs_fscache_super_index_def;
+extern const struct fscache_cookie_def cifs_fscache_inode_object_def;
+
 
 extern int cifs_fscache_register(void);
 extern void cifs_fscache_unregister(void);
@@ -42,6 +44,10 @@ extern void cifs_fscache_release_client_cookie(struct TCP_Server_Info *);
 extern void cifs_fscache_get_super_cookie(struct cifsTconInfo *);
 extern void cifs_fscache_release_super_cookie(struct cifsTconInfo *);
 
+extern void cifs_fscache_release_inode_cookie(struct inode *);
+extern void cifs_fscache_set_inode_cookie(struct inode *, struct file *);
+extern void cifs_fscache_reset_inode_cookie(struct inode *);
+
 #else /* CONFIG_CIFS_FSCACHE */
 static inline int cifs_fscache_register(void) { return 0; }
 static inline void cifs_fscache_unregister(void) {}
@@ -54,6 +60,12 @@ static inline void cifs_fscache_get_super_cookie(struct cifsTconInfo *tcon) {}
 static inline void
 cifs_fscache_release_super_cookie(struct cifsTconInfo *tcon) {}
 
+static inline void cifs_fscache_release_inode_cookie(struct inode *inode) {}
+static inline void cifs_fscache_set_inode_cookie(struct inode *inode,
+                                                struct file *filp) {}
+static inline void cifs_fscache_reset_inode_cookie(struct inode *inode) {}
+
+
 #endif /* CONFIG_CIFS_FSCACHE */
 
 #endif /* _CIFS_FSCACHE_H */

diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index f884cb51622ad76e0dbe8dc4e100116676545d05..5a68b92a0f9aebfff069109b3846801764298d54 100644 (file)
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -29,6 +29,7 @@
 #include "cifsproto.h"
 #include "cifs_debug.h"
 #include "cifs_fs_sb.h"
+#include "fscache.h"
 
 
 static void cifs_set_ops(struct inode *inode, const bool is_dfs_referral)
@@ -776,6 +777,8 @@ retry_iget5_locked:
                        inode->i_flags |= S_NOATIME | S_NOCMTIME;
                if (inode->i_state & I_NEW) {
                        inode->i_ino = hash;
+                       /* initialize per-inode cache cookie pointer */
+                       CIFS_I(inode)->fscache = NULL;
                        unlock_new_inode(inode);
                }
        }
@@ -1571,6 +1574,7 @@ cifs_invalidate_mapping(struct inode *inode)
                        cifs_i->write_behind_rc = rc;
        }
        invalidate_remote_inode(inode);
+       cifs_fscache_reset_inode_cookie(inode);
 }
 
 int cifs_revalidate_file(struct file *filp)