8 files changed, 97 insertions, 83 deletions

diff --git a/fs/9p/acl.c b/fs/9p/acl.c
index 15b679166201..7af425f53bee 100644
--- a/fs/9p/acl.c
+++ b/fs/9p/acl.c
@@ -23,6 +23,7 @@
 #include "acl.h"
 #include "v9fs.h"
 #include "v9fs_vfs.h"
+#include "fid.h"
 
 static struct posix_acl *__v9fs_get_acl(struct p9_fid *fid, char *name)
 {
@@ -113,16 +114,12 @@ struct posix_acl *v9fs_iop_get_acl(struct inode *inode, int type)
 
 }
 
-static int v9fs_set_acl(struct dentry *dentry, int type, struct posix_acl *acl)
+static int v9fs_set_acl(struct p9_fid *fid, int type, struct posix_acl *acl)
 {
         int retval;
         char *name;
         size_t size;
         void *buffer;
-        struct inode *inode = dentry->d_inode;
-
-        set_cached_acl(inode, type, acl);
-
         if (!acl)
                 return 0;
 
@@ -144,17 +141,16 @@ static int v9fs_set_acl(struct dentry *dentry, int type, struct posix_acl *acl)
         default:
                 BUG();
         }
-        retval = v9fs_xattr_set(dentry, name, buffer, size, 0);
+        retval = v9fs_fid_xattr_set(fid, name, buffer, size, 0);
 err_free_out:
         kfree(buffer);
         return retval;
 }
 
-int v9fs_acl_chmod(struct dentry *dentry)
+int v9fs_acl_chmod(struct inode *inode, struct p9_fid *fid)
 {
         int retval = 0;
         struct posix_acl *acl;
-        struct inode *inode = dentry->d_inode;
 
         if (S_ISLNK(inode->i_mode))
                 return -EOPNOTSUPP;
@@ -163,25 +159,30 @@ int v9fs_acl_chmod(struct dentry *dentry)
                 retval = posix_acl_chmod(&acl, GFP_KERNEL, inode->i_mode);
                 if (retval)
                         return retval;
-                retval = v9fs_set_acl(dentry, ACL_TYPE_ACCESS, acl);
+                set_cached_acl(inode, ACL_TYPE_ACCESS, acl);
+                retval = v9fs_set_acl(fid, ACL_TYPE_ACCESS, acl);
                 posix_acl_release(acl);
         }
         return retval;
 }
 
-int v9fs_set_create_acl(struct dentry *dentry,
-                        struct posix_acl **dpacl, struct posix_acl **pacl)
+int v9fs_set_create_acl(struct inode *inode, struct p9_fid *fid,
+                        struct posix_acl *dacl, struct posix_acl *acl)
 {
-        if (dentry) {
-                v9fs_set_acl(dentry, ACL_TYPE_DEFAULT, *dpacl);
-                v9fs_set_acl(dentry, ACL_TYPE_ACCESS, *pacl);
-        }
-        posix_acl_release(*dpacl);
-        posix_acl_release(*pacl);
-        *dpacl = *pacl = NULL;
+        set_cached_acl(inode, ACL_TYPE_DEFAULT, dacl);
+        set_cached_acl(inode, ACL_TYPE_ACCESS, acl);
+        v9fs_set_acl(fid, ACL_TYPE_DEFAULT, dacl);
+        v9fs_set_acl(fid, ACL_TYPE_ACCESS, acl);
         return 0;
 }
 
+void v9fs_put_acl(struct posix_acl *dacl,
+                  struct posix_acl *acl)
+{
+        posix_acl_release(dacl);
+        posix_acl_release(acl);
+}
+
 int v9fs_acl_mode(struct inode *dir, umode_t *modep,
                   struct posix_acl **dpacl, struct posix_acl **pacl)
 {
diff --git a/fs/9p/acl.h b/fs/9p/acl.h
index 559556411965..e4f7e882272b 100644
--- a/fs/9p/acl.h
+++ b/fs/9p/acl.h
@@ -17,27 +17,33 @@
 #ifdef CONFIG_9P_FS_POSIX_ACL
 extern int v9fs_get_acl(struct inode *, struct p9_fid *);
 extern struct posix_acl *v9fs_iop_get_acl(struct inode *inode, int type);
-extern int v9fs_acl_chmod(struct dentry *);
-extern int v9fs_set_create_acl(struct dentry *,
-                               struct posix_acl **, struct posix_acl **);
+extern int v9fs_acl_chmod(struct inode *, struct p9_fid *);
+extern int v9fs_set_create_acl(struct inode *, struct p9_fid *,
+                               struct posix_acl *, struct posix_acl *);
 extern int v9fs_acl_mode(struct inode *dir, umode_t *modep,
                          struct posix_acl **dpacl, struct posix_acl **pacl);
+extern void v9fs_put_acl(struct posix_acl *dacl, struct posix_acl *acl);
 #else
 #define v9fs_iop_get_acl NULL
 static inline int v9fs_get_acl(struct inode *inode, struct p9_fid *fid)
 {
         return 0;
 }
-static inline int v9fs_acl_chmod(struct dentry *dentry)
+static inline int v9fs_acl_chmod(struct inode *inode, struct p9_fid *fid)
 {
         return 0;
 }
-static inline int v9fs_set_create_acl(struct dentry *dentry,
-                                      struct posix_acl **dpacl,
-                                      struct posix_acl **pacl)
+static inline int v9fs_set_create_acl(struct inode *inode,
+                                      struct p9_fid *fid,
+                                      struct posix_acl *dacl,
+                                      struct posix_acl *acl)
 {
         return 0;
 }
+static inline void v9fs_put_acl(struct posix_acl *dacl,
+                                struct posix_acl *acl)
+{
+}
 static inline int v9fs_acl_mode(struct inode *dir, umode_t *modep,
                                 struct posix_acl **dpacl,
                                 struct posix_acl **pacl)
diff --git a/fs/9p/vfs_dentry.c b/fs/9p/vfs_dentry.c
index 64600b5d0522..9ad68628522c 100644
--- a/fs/9p/vfs_dentry.c
+++ b/fs/9p/vfs_dentry.c
@@ -137,6 +137,7 @@ out_valid:
 
 const struct dentry_operations v9fs_cached_dentry_operations = {
         .d_revalidate = v9fs_lookup_revalidate,
+        .d_weak_revalidate = v9fs_lookup_revalidate,
         .d_delete = v9fs_cached_dentry_delete,
         .d_release = v9fs_dentry_release,
 };
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index c921ac92ea4c..d384a8b77ee8 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -129,7 +129,7 @@ out_error:
 static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl)
 {
         int res = 0;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
 
         p9_debug(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl);
 
@@ -298,7 +298,7 @@ static int v9fs_file_getlock(struct file *filp, struct file_lock *fl)
 
 static int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         int ret = -ENOLCK;
 
         p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n",
@@ -334,7 +334,7 @@ out_err:
 static int v9fs_file_flock_dotl(struct file *filp, int cmd,
         struct file_lock *fl)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         int ret = -ENOLCK;
 
         p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n",
@@ -525,7 +525,7 @@ v9fs_file_write(struct file *filp, const char __user * data,
         if (!count)
                 goto out;
 
-        retval = v9fs_file_write_internal(filp->f_path.dentry->d_inode,
+        retval = v9fs_file_write_internal(file_inode(filp),
                                         filp->private_data,
                                         data, count, &origin, 1);
         /* update offset on successful write */
@@ -600,7 +600,7 @@ v9fs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
         struct v9fs_inode *v9inode;
         struct page *page = vmf->page;
         struct file *filp = vma->vm_file;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
 
 
         p9_debug(P9_DEBUG_VFS, "page %p fid %lx\n",
diff --git a/fs/9p/vfs_inode_dotl.c b/fs/9p/vfs_inode_dotl.c
index 07f409288d1b..61e4fa70a6fa 100644
--- a/fs/9p/vfs_inode_dotl.c
+++ b/fs/9p/vfs_inode_dotl.c
@@ -330,14 +330,14 @@ v9fs_vfs_atomic_open_dotl(struct inode *dir, struct dentry *dentry,
                 p9_debug(P9_DEBUG_VFS, "inode creation failed %d\n", err);
                 goto error;
         }
+        /* Now set the ACL based on the default value */
+        v9fs_set_create_acl(inode, fid, dacl, pacl);
+
         err = v9fs_fid_add(dentry, fid);
         if (err < 0)
                 goto error;
         d_instantiate(dentry, inode);
 
-        /* Now set the ACL based on the default value */
-        v9fs_set_create_acl(dentry, &dacl, &pacl);
-
         v9inode = V9FS_I(inode);
         mutex_lock(&v9inode->v_mutex);
         if (v9ses->cache && !v9inode->writeback_fid &&
@@ -369,6 +369,7 @@ v9fs_vfs_atomic_open_dotl(struct inode *dir, struct dentry *dentry,
 #endif
         *opened |= FILE_CREATED;
 out:
+        v9fs_put_acl(dacl, pacl);
         dput(res);
         return err;
 
@@ -378,7 +379,6 @@ error:
 err_clunk_old_fid:
         if (ofid)
                 p9_client_clunk(ofid);
-        v9fs_set_create_acl(NULL, &dacl, &pacl);
         goto out;
 }
 
@@ -435,17 +435,17 @@ static int v9fs_vfs_mkdir_dotl(struct inode *dir,
         if (err < 0)
                 goto error;
 
+        fid = p9_client_walk(dfid, 1, &name, 1);
+        if (IS_ERR(fid)) {
+                err = PTR_ERR(fid);
+                p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
+                         err);
+                fid = NULL;
+                goto error;
+        }
+
         /* instantiate inode and assign the unopened fid to the dentry */
         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
-                fid = p9_client_walk(dfid, 1, &name, 1);
-                if (IS_ERR(fid)) {
-                        err = PTR_ERR(fid);
-                        p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
-                                 err);
-                        fid = NULL;
-                        goto error;
-                }
-
                 inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
                 if (IS_ERR(inode)) {
                         err = PTR_ERR(inode);
@@ -456,6 +456,7 @@ static int v9fs_vfs_mkdir_dotl(struct inode *dir,
                 err = v9fs_fid_add(dentry, fid);
                 if (err < 0)
                         goto error;
+                v9fs_set_create_acl(inode, fid, dacl, pacl);
                 d_instantiate(dentry, inode);
                 fid = NULL;
         } else {
@@ -469,16 +470,15 @@ static int v9fs_vfs_mkdir_dotl(struct inode *dir,
                         err = PTR_ERR(inode);
                         goto error;
                 }
+                v9fs_set_create_acl(inode, fid, dacl, pacl);
                 d_instantiate(dentry, inode);
         }
-        /* Now set the ACL based on the default value */
-        v9fs_set_create_acl(dentry, &dacl, &pacl);
         inc_nlink(dir);
         v9fs_invalidate_inode_attr(dir);
 error:
         if (fid)
                 p9_client_clunk(fid);
-        v9fs_set_create_acl(NULL, &dacl, &pacl);
+        v9fs_put_acl(dacl, pacl);
         return err;
 }
 
@@ -572,10 +572,11 @@ int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
         struct v9fs_session_info *v9ses;
         struct p9_fid *fid;
         struct p9_iattr_dotl p9attr;
+        struct inode *inode = dentry->d_inode;
 
         p9_debug(P9_DEBUG_VFS, "\n");
 
-        retval = inode_change_ok(dentry->d_inode, iattr);
+        retval = inode_change_ok(inode, iattr);
         if (retval)
                 return retval;
 
@@ -596,23 +597,23 @@ int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
                 return PTR_ERR(fid);
 
         /* Write all dirty data */
-        if (S_ISREG(dentry->d_inode->i_mode))
-                filemap_write_and_wait(dentry->d_inode->i_mapping);
+        if (S_ISREG(inode->i_mode))
+                filemap_write_and_wait(inode->i_mapping);
 
         retval = p9_client_setattr(fid, &p9attr);
         if (retval < 0)
                 return retval;
 
         if ((iattr->ia_valid & ATTR_SIZE) &&
-            iattr->ia_size != i_size_read(dentry->d_inode))
-                truncate_setsize(dentry->d_inode, iattr->ia_size);
+            iattr->ia_size != i_size_read(inode))
+                truncate_setsize(inode, iattr->ia_size);
 
-        v9fs_invalidate_inode_attr(dentry->d_inode);
-        setattr_copy(dentry->d_inode, iattr);
-        mark_inode_dirty(dentry->d_inode);
+        v9fs_invalidate_inode_attr(inode);
+        setattr_copy(inode, iattr);
+        mark_inode_dirty(inode);
         if (iattr->ia_valid & ATTR_MODE) {
                 /* We also want to update ACL when we update mode bits */
-                retval = v9fs_acl_chmod(dentry);
+                retval = v9fs_acl_chmod(inode, fid);
                 if (retval < 0)
                         return retval;
         }
@@ -880,17 +881,17 @@ v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
                 goto error;
 
         v9fs_invalidate_inode_attr(dir);
+        fid = p9_client_walk(dfid, 1, &name, 1);
+        if (IS_ERR(fid)) {
+                err = PTR_ERR(fid);
+                p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
+                         err);
+                fid = NULL;
+                goto error;
+        }
+
         /* instantiate inode and assign the unopened fid to the dentry */
         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
-                fid = p9_client_walk(dfid, 1, &name, 1);
-                if (IS_ERR(fid)) {
-                        err = PTR_ERR(fid);
-                        p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
-                                 err);
-                        fid = NULL;
-                        goto error;
-                }
-
                 inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
                 if (IS_ERR(inode)) {
                         err = PTR_ERR(inode);
@@ -898,6 +899,7 @@ v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
                                  err);
                         goto error;
                 }
+                v9fs_set_create_acl(inode, fid, dacl, pacl);
                 err = v9fs_fid_add(dentry, fid);
                 if (err < 0)
                         goto error;
@@ -913,14 +915,13 @@ v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
                         err = PTR_ERR(inode);
                         goto error;
                 }
+                v9fs_set_create_acl(inode, fid, dacl, pacl);
                 d_instantiate(dentry, inode);
         }
-        /* Now set the ACL based on the default value */
-        v9fs_set_create_acl(dentry, &dacl, &pacl);
 error:
         if (fid)
                 p9_client_clunk(fid);
-        v9fs_set_create_acl(NULL, &dacl, &pacl);
+        v9fs_put_acl(dacl, pacl);
         return err;
 }
 
diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
index 137d50396898..91dad63e5a2d 100644
--- a/fs/9p/vfs_super.c
+++ b/fs/9p/vfs_super.c
@@ -363,5 +363,5 @@ struct file_system_type v9fs_fs_type = {
         .mount = v9fs_mount,
         .kill_sb = v9fs_kill_super,
         .owner = THIS_MODULE,
-        .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT,
+        .fs_flags = FS_RENAME_DOES_D_MOVE,
 };
diff --git a/fs/9p/xattr.c b/fs/9p/xattr.c
index 29653b70a9c3..c45e016b190f 100644
--- a/fs/9p/xattr.c
+++ b/fs/9p/xattr.c
@@ -111,19 +111,26 @@ ssize_t v9fs_xattr_get(struct dentry *dentry, const char *name,
 int v9fs_xattr_set(struct dentry *dentry, const char *name,
                    const void *value, size_t value_len, int flags)
 {
+        struct p9_fid *fid = v9fs_fid_lookup(dentry);
+        if (IS_ERR(fid))
+                return PTR_ERR(fid);
+        return v9fs_fid_xattr_set(fid, name, value, value_len, flags);
+}
+
+int v9fs_fid_xattr_set(struct p9_fid *fid, const char *name,
+                   const void *value, size_t value_len, int flags)
+{
         u64 offset = 0;
         int retval, msize, write_count;
-        struct p9_fid *fid = NULL;
 
         p9_debug(P9_DEBUG_VFS, "name = %s value_len = %zu flags = %d\n",
                  name, value_len, flags);
 
-        fid = v9fs_fid_clone(dentry);
-        if (IS_ERR(fid)) {
-                retval = PTR_ERR(fid);
-                fid = NULL;
-                goto error;
-        }
+        /* Clone it */
+        fid = p9_client_walk(fid, 0, NULL, 1);
+        if (IS_ERR(fid))
+                return PTR_ERR(fid);
+
         /*
          * On success fid points to xattr
          */
@@ -131,7 +138,8 @@ int v9fs_xattr_set(struct dentry *dentry, const char *name,
         if (retval < 0) {
                 p9_debug(P9_DEBUG_VFS, "p9_client_xattrcreate failed %d\n",
                          retval);
-                goto error;
+                p9_client_clunk(fid);
+                return retval;
         }
         msize = fid->clnt->msize;
         while (value_len) {
@@ -144,17 +152,12 @@ int v9fs_xattr_set(struct dentry *dentry, const char *name,
                 if (write_count < 0) {
                         /* error in xattr write */
                         retval = write_count;
-                        goto error;
+                        break;
                 }
                 offset += write_count;
                 value_len -= write_count;
         }
-        /* Total read xattr bytes */
-        retval = offset;
-error:
-        if (fid)
-                retval = p9_client_clunk(fid);
-        return retval;
+        return p9_client_clunk(fid);
 }
 
 ssize_t v9fs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
diff --git a/fs/9p/xattr.h b/fs/9p/xattr.h
index eaa837c53bd5..eec348a3df71 100644
--- a/fs/9p/xattr.h
+++ b/fs/9p/xattr.h
@@ -27,6 +27,8 @@ extern ssize_t v9fs_fid_xattr_get(struct p9_fid *, const char *,
                                   void *, size_t);
 extern ssize_t v9fs_xattr_get(struct dentry *, const char *,
                               void *, size_t);
+extern int v9fs_fid_xattr_set(struct p9_fid *, const char *,
+                          const void *, size_t, int);
 extern int v9fs_xattr_set(struct dentry *, const char *,
                           const void *, size_t, int);
 extern ssize_t v9fs_listxattr(struct dentry *, char *, size_t);