fs/9p: Add support for marking inode attribute invalid
Aneesh Kumar K.V [Mon, 28 Feb 2011 11:34:06 +0000 (16:34 +0530)]
With cached mode some of the file system operation result
in updating inode attributes (ctime). Add support for
marking inode attribute invalid in such cases so that
we fetch the updated inode attribute on dentry revalidation.

Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>

fs/9p/v9fs.h
fs/9p/v9fs_vfs.h
fs/9p/vfs_dentry.c
fs/9p/vfs_inode.c
fs/9p/vfs_inode_dotl.c

index 71cab8e..cfdc055 100644 (file)
@@ -116,12 +116,16 @@ struct v9fs_session_info {
        struct p9_fid *root_fid; /* Used for file system sync */
 };
 
+/* cache_validity flags */
+#define V9FS_INO_INVALID_ATTR 0x01
+
 struct v9fs_inode {
 #ifdef CONFIG_9P_FSCACHE
        spinlock_t fscache_lock;
        struct fscache_cookie *fscache;
        struct p9_qid *fscache_key;
 #endif
+       unsigned int cache_validity;
        struct p9_fid *writeback_fid;
        struct inode vfs_inode;
 };
index ed9fd00..591807f 100644 (file)
@@ -70,4 +70,14 @@ int v9fs_vfs_setattr_dotl(struct dentry *, struct iattr *);
 int v9fs_file_fsync_dotl(struct file *filp, int datasync);
 ssize_t v9fs_file_write_internal(struct inode *, struct p9_fid *,
                                 const char __user *, size_t, loff_t *, int);
+int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode);
+int v9fs_refresh_inode_dotl(struct p9_fid *fid, struct inode *inode);
+static inline void v9fs_invalidate_inode_attr(struct inode *inode)
+{
+       struct v9fs_inode *v9inode;
+       v9inode = V9FS_I(inode);
+       v9inode->cache_validity |= V9FS_INO_INVALID_ATTR;
+       return;
+}
+
 #define P9_LOCK_TIMEOUT (30*HZ)
index a4ae4be..b6a3b9f 100644 (file)
@@ -100,7 +100,41 @@ static void v9fs_dentry_release(struct dentry *dentry)
        }
 }
 
+static int v9fs_lookup_revalidate(struct dentry *dentry, struct nameidata *nd)
+{
+       struct p9_fid *fid;
+       struct inode *inode;
+       struct v9fs_inode *v9inode;
+
+       if (nd->flags & LOOKUP_RCU)
+               return -ECHILD;
+
+       inode = dentry->d_inode;
+       if (!inode)
+               goto out_valid;
+
+       v9inode = V9FS_I(inode);
+       if (v9inode->cache_validity & V9FS_INO_INVALID_ATTR) {
+               int retval;
+               struct v9fs_session_info *v9ses;
+               fid = v9fs_fid_lookup(dentry);
+               if (IS_ERR(fid))
+                       return PTR_ERR(fid);
+
+               v9ses = v9fs_inode2v9ses(inode);
+               if (v9fs_proto_dotl(v9ses))
+                       retval = v9fs_refresh_inode_dotl(fid, inode);
+               else
+                       retval = v9fs_refresh_inode(fid, inode);
+               if (retval <= 0)
+                       return retval;
+       }
+out_valid:
+       return 1;
+}
+
 const struct dentry_operations v9fs_cached_dentry_operations = {
+       .d_revalidate = v9fs_lookup_revalidate,
        .d_delete = v9fs_cached_dentry_delete,
        .d_release = v9fs_dentry_release,
 };
index 334ad12..a28fe9f 100644 (file)
@@ -220,6 +220,7 @@ struct inode *v9fs_alloc_inode(struct super_block *sb)
        spin_lock_init(&v9inode->fscache_lock);
 #endif
        v9inode->writeback_fid = NULL;
+       v9inode->cache_validity = 0;
        return &v9inode->vfs_inode;
 }
 
@@ -1010,6 +1011,7 @@ v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
        char tag_name[14];
        unsigned int i_nlink;
        struct v9fs_session_info *v9ses = sb->s_fs_info;
+       struct v9fs_inode *v9inode = V9FS_I(inode);
 
        inode->i_nlink = 1;
 
@@ -1069,6 +1071,7 @@ v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
 
        /* not real number of blocks, but 512 byte ones ... */
        inode->i_blocks = (i_size_read(inode) + 512 - 1) >> 9;
+       v9inode->cache_validity &= ~V9FS_INO_INVALID_ATTR;
 }
 
 /**
@@ -1323,6 +1326,32 @@ v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
        return retval;
 }
 
+int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode)
+{
+       loff_t i_size;
+       struct p9_wstat *st;
+       struct v9fs_session_info *v9ses;
+
+       v9ses = v9fs_inode2v9ses(inode);
+       st = p9_client_stat(fid);
+       if (IS_ERR(st))
+               return PTR_ERR(st);
+
+       spin_lock(&inode->i_lock);
+       /*
+        * We don't want to refresh inode->i_size,
+        * because we may have cached data
+        */
+       i_size = inode->i_size;
+       v9fs_stat2inode(st, inode, inode->i_sb);
+       if (v9ses->cache)
+               inode->i_size = i_size;
+       spin_unlock(&inode->i_lock);
+       p9stat_free(st);
+       kfree(st);
+       return 0;
+}
+
 static const struct inode_operations v9fs_dir_inode_operations_dotu = {
        .create = v9fs_vfs_create,
        .lookup = v9fs_vfs_lookup,
index c6d9677..5c04d66 100644 (file)
@@ -484,6 +484,7 @@ int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
 void
 v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode)
 {
+       struct v9fs_inode *v9inode = V9FS_I(inode);
 
        if ((stat->st_result_mask & P9_STATS_BASIC) == P9_STATS_BASIC) {
                inode->i_atime.tv_sec = stat->st_atime_sec;
@@ -542,6 +543,7 @@ v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode)
        /* Currently we don't support P9_STATS_BTIME and P9_STATS_DATA_VERSION
         * because the inode structure does not have fields for them.
         */
+       v9inode->cache_validity &= ~V9FS_INO_INVALID_ATTR;
 }
 
 static int
@@ -822,6 +824,31 @@ ndset:
        return NULL;
 }
 
+int v9fs_refresh_inode_dotl(struct p9_fid *fid, struct inode *inode)
+{
+       loff_t i_size;
+       struct p9_stat_dotl *st;
+       struct v9fs_session_info *v9ses;
+
+       v9ses = v9fs_inode2v9ses(inode);
+       st = p9_client_getattr_dotl(fid, P9_STATS_ALL);
+       if (IS_ERR(st))
+               return PTR_ERR(st);
+
+       spin_lock(&inode->i_lock);
+       /*
+        * We don't want to refresh inode->i_size,
+        * because we may have cached data
+        */
+       i_size = inode->i_size;
+       v9fs_stat2inode_dotl(st, inode);
+       if (v9ses->cache)
+               inode->i_size = i_size;
+       spin_unlock(&inode->i_lock);
+       kfree(st);
+       return 0;
+}
+
 const struct inode_operations v9fs_dir_inode_operations_dotl = {
        .create = v9fs_vfs_create_dotl,
        .lookup = v9fs_vfs_lookup,